raw_response = ''

        try:

            raw_response = getattr(self, action)(**rpc_args)

            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

        response = dict(id=self._req_id, result=raw_response, error=self._error)

        try:

    params = list(fargs)

    params.extend(['%s-%s' % ar for ar in fkwargs.items()])

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

    lockkey = 'task_%s.lock' % \

    return lockkey

def locked_task(func):

    def __wrapper(func, *fargs, **fkwargs):

        lockkey = __get_lockkey(func, *fargs, **fkwargs)

    logf defaults to log.info, unless category equals 'success', in which

    case logf defaults to log.debug.

    """

    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':

            logf = log.debug

    logf('Flash %s: %s', category, safe_message)

    """

    if not (g_recaptcha_response and len(g_recaptcha_response)):

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

    def encode_if_necessary(s):

            return s.encode('utf-8')

        return s

    params = urllib.parse.urlencode({

        'secret': encode_if_necessary(private_key),

        'remoteip': encode_if_necessary(remoteip),

    turns a datetime into an age string.

    If show_short_version is True, then it will generate a not so accurate but shorter string,

    example: 2days ago, instead of 2 days and 23 hours ago.

    :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']

    deltas = {}

    future = False

def uri_filter(uri):

    """

    Removes user:password from given url string

    :param uri:

    :returns: filtered list of strings

    """

    if not uri:

        return []

    proto = ''

            list of ``DirNode`` (``Node`` with NodeKind.DIR) objects

        ``nodes``

            combined list of ``Node`` objects

        ``author``

        ``message``

        ``parents``

            list of parent changesets

        ``last``

            ``True`` if this is last changeset in repository, ``False``

        """

        if self._empty:

            raise EmptyRepositoryError("There are no changesets yet")

        if revision in [-1, None]:

            revision = b'tip'

            revision = safe_bytes(revision)

        try:

            if isinstance(revision, int):

                return ascii_str(self._repo[revision].hex())

            return ascii_str(mercurial.scmutil.revsymbol(self._repo, revision).hex())

    Processor class wrapping handling of subprocess IO.

    In a way, this is a "communicate()" replacement with a twist.

    - 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

       does not block the parent calling code. On the flip side, reading from

       slow-yielding subprocess may block the iteration until data shows up. This

       does not block the parallel inpipe reading occurring parallel thread.)

        self.app_settings_name = key

        self.app_settings_value = val

        self.app_settings_type = type

    @validates('_app_settings_value')

    def validate_settings_value(self, key, val):

        return val

    @hybrid_property

    def app_settings_value(self):

        v = self._app_settings_value

        _type = self.app_settings_type

        gist.gist_expires = gist_expires

        gist.gist_type = gist_type

        Session().add(gist)

        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(

            repo_name=gist.gist_access_id, repo_type='hg', repo_group=GIST_STORE_LOC)

        processed_mapping = {}

            raise

        # gmail doesn't do proper threading but will ignore leading square

        # bracket content ... so that is where we put status info

        bracket_tags = []

        status_change = kwargs.get('status_change')

        if status_change:

        if kwargs.get('closing_pr'):

            bracket_tags.append(_('Closing'))

        if bracket_tags:

            if subj.startswith('['):

                subj = '[' + ', '.join(bracket_tags) + ': ' + subj[1:]

            else:

        chset = self.repo.get_changeset(

            '54386793436c938cff89326944d4c2702340037d')

        changed = ['setup.py', 'tests/test_nodes.py', 'vcs/backends/hg.py',

            '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()

        for node in changeset.get_node('/'):

            if node.is_file():

                assert isinstance(node.content, bytes)

        path = 'vcs/backends/BaseRepository.py'

        with pytest.raises(NodeDoesNotExistError):

            chset.get_node(path)

        # 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 test_changeset.get_node('/'):

            if node.is_file():

                assert isinstance(node.content, bytes)

        rev_count = len(self.repo.revisions)

        to_add = [FileNode(node.path, content=node.content)

            for node in self.nodes]

        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()

        assert changeset == newtip

        assert rev_count + 1 == len(self.repo.revisions)

        assert newtip.message == message

    def test_add_in_bulk(self):

        rev_count = len(self.repo.revisions)

        to_add = [FileNode(node.path, content=node.content)

            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()

        assert changeset == newtip

        assert rev_count + 1 == len(self.repo.revisions)

        assert newtip.message == message

            FileNode('żółwik/zwierzątko', content='ćććć'),

            FileNode(u'żółwik/zwierzątko_uni', content=u'ćććć'),

        ]

        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()

        assert changeset == newtip

        assert rev_count + 1 == len(self.repo.revisions)

        assert newtip.message == message

        with pytest.raises(NodeAlreadyAddedError):

            self.imc.add(node)

    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',

                            author=str(self))

    def test_change(self):

        with pytest.raises(EmptyRepositoryError):

            self.imc.change(node)

    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):

            self.imc.commit(message='Changed not existing node', author=str(self))

    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):

            self.imc.change(node)

    def test_check_integrity_change_raise_node_not_changed(self):

        node = FileNode(self.nodes[0].path, content=self.nodes[0].content)

        self.imc.change(node)

        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)

    def test_remove(self):

        self.test_add()  # Performs first commit

        tip = self.repo.get_changeset()

        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

        assert tip.raw_id != newtip.raw_id

        with pytest.raises(NodeDoesNotExistError):

            newtip.get_node(node.path)

    def test_remove_raise_node_does_not_exist(self):

        self.imc.remove(self.nodes[0])

        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):

        self.test_add()  # Performs first commit

        node = FileNode('no-such-file')

        self.imc.remove(node)

        with pytest.raises(NodeDoesNotExistError):

            self.imc.commit(

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

            )

    def test_remove_raise_node_already_removed(self):

        self.test_add() # Performs first commit

        node = FileNode(self.nodes[0].path)