if isinstance(raw_response, HTTPError):

                self._error = str(raw_response)

        except JSONRPCError as e:

        except Exception as e:

            log.error('Encountered unhandled exception: %s',

                      traceback.format_exc(),)

            json_exc = JSONRPCError('Internal server error')

        if self._error is not None:

            raw_response = None

    func_name = str(func.__name__) if hasattr(func, '__name__') else str(func)

    lockkey = 'task_%s.lock' % \

    return lockkey

    assert category in ('error', 'success', 'warning'), category

    if hasattr(message, '__html__'):

        # render to HTML for storing in cookie

    else:

        # Apply str - the message might be an exception with __str__

        # Escape, so we can trust the result without further escaping, without any risk of injection

    if logf is None:

        logf = log.info

        if category == 'success':

        return RecaptchaResponse(is_valid=False, error_code='incorrect-captcha-sol')

    def encode_if_necessary(s):

            return s.encode('utf-8')

        return s

    :param prevdate: datetime object

    :param show_short_version: if it should approximate the date and return a shorter string

    """

    now = now or datetime.datetime.now()

    order = ['year', 'month', 'day', 'hour', 'minute', 'second']

    Removes user:password from given url string

    :param uri:

    :returns: filtered list of strings

    """

    if not uri:

            combined list of ``Node`` objects

        ``author``

        ``message``

        ``parents``

            list of parent changesets

        if revision in [-1, None]:

            revision = b'tip'

            revision = safe_bytes(revision)

        try:

    - We are multithreaded. Writing in and reading out, err are all sep threads.

    - We support concurrent (in and out) stream processing.

      chunks. The object behaves as an iterable. You can "for chunk in obj:" us.

    - We are non-blocking in more respects than communicate()

      (reading from subprocess out pauses when internal buffer is full, but

    @validates('_app_settings_value')

    def validate_settings_value(self, key, val):

        return val

    @hybrid_property

        Session().flush() # make database assign gist.gist_id

        if gist_type == Gist.GIST_PUBLIC:

            # use DB ID for easy to use GIST ID

        log.debug('Creating new %s GIST repo %s', gist_type, gist.gist_access_id)

        repo = RepoModel()._create_filesystem_repo(

        bracket_tags = []

        status_change = kwargs.get('status_change')

        if status_change:

        if kwargs.get('closing_pr'):

            bracket_tags.append(_('Closing'))

        if bracket_tags:

            'vcs/nodes.py']

        assert set(changed) == set([f.path for f in chset.changed])

        for cs in self.repo:

        for cs in self.repo:

    def test_repo_files_content_is_bytes(self):

        changeset = self.repo.get_changeset()

        # but it would be one of ``removed`` (changeset's attribute)

        assert path in [rf.path for rf in chset.removed]

        for cm in self.repo:

        for cm in self.repo:

    def test_repo_files_content_is_bytes(self):

        test_changeset = self.repo.get_changeset(100)

        for node in to_add:

            self.imc.add(node)

        message = u'Added: %s' % ', '.join((node.path for node in self.nodes))

        changeset = self.imc.commit(message=message, author=author)

        newtip = self.repo.get_changeset()

            for node in self.nodes]

        self.imc.add(*to_add)

        message = u'Added: %s' % ', '.join((node.path for node in self.nodes))

        changeset = self.imc.commit(message=message, author=author)

        newtip = self.repo.get_changeset()

        for node in to_add:

            self.imc.add(node)

        message = u'Added: %s' % ', '.join((node.path for node in self.nodes))

        changeset = self.imc.commit(message=message, author=author)

        newtip = self.repo.get_changeset()

    def test_check_integrity_raise_already_exist(self):

        node = FileNode('foobar', content='baz')

        self.imc.add(node)

        self.imc.add(node)

        with pytest.raises(NodeAlreadyExistsError):

            self.imc.commit(message='new message',

    def test_check_integrity_change_raise_node_does_not_exist(self):

        node = FileNode('foobar', content='baz')

        self.imc.add(node)

        node = FileNode('not-foobar', content='')

        self.imc.change(node)

        with pytest.raises(NodeDoesNotExistError):

    def test_change_raise_node_already_changed(self):

        node = FileNode('foobar', content='baz')

        self.imc.add(node)

        node = FileNode('foobar', content='more baz')

        self.imc.change(node)

        with pytest.raises(NodeAlreadyChangedError):

        with pytest.raises(NodeNotChangedError):

            self.imc.commit(

                message=u'Trying to mark node as changed without touching it',

            )

    def test_change_raise_node_already_removed(self):

        node = FileNode('foobar', content='baz')

        self.imc.add(node)

        self.imc.remove(FileNode('foobar'))

        with pytest.raises(NodeAlreadyRemovedError):

            self.imc.change(node)

        node = self.nodes[0]

        assert node.content == tip.get_node(node.path).content

        self.imc.remove(node)

        newtip = self.repo.get_changeset()

        assert tip != newtip

        with pytest.raises(NodeDoesNotExistError):

            self.imc.commit(

                message='Trying to remove node at empty repository',

            )

    def test_check_integrity_remove_raise_node_does_not_exist(self):

        with pytest.raises(NodeDoesNotExistError):

            self.imc.commit(

                message=u'Trying to remove not existing node',

            )

    def test_remove_raise_node_already_removed(self):