return state

    def _rpc_call(self, action, environ, **rpc_args):

        """

        Call the specified RPC Method

        """

        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:

            return ascii_bytes(ext_json.dumps(response))

        except TypeError as e:

            log.error('API FAILED. Error encoding response for %s %s: %s\n%s', action, rpc_args, e, traceback.format_exc())

            return ascii_bytes(ext_json.dumps(

                dict(

                    id=self._req_id,

            return FakeTask(result)

    return f_wrapped

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

    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)

        lockkey_path = config.get('cache_dir') or config['app_conf']['cache_dir']  # Backward compatibility for TurboGears < 2.4

        log.info('running task with lockkey %s', lockkey)

        try:

            l = DaemonLock(os.path.join(lockkey_path, lockkey))

            ret = func(*fargs, **fkwargs)

    """

    Show a message to the user _and_ log it through the specified function

    category: notice (default), warning, error, success

    logf: a custom log function - such as log.debug

    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)

    _session_flash_messages(append=(category, safe_message))

def pop_flash_messages():

    """Return all accumulated messages and delete them from the session.

    """

    Submits a reCAPTCHA request for verification. Returns RecaptchaResponse for the request

    g_recaptcha_response -- The value of g_recaptcha_response from the form

    private_key -- your reCAPTCHA private key

    remoteip -- the user's IP address

    """

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

        'response': encode_if_necessary(g_recaptcha_response),

    }).encode('ascii')

    req = urllib.request.Request(

        url="https://www.google.com/recaptcha/api/siteverify",

        data=params,

        s = s[len(prefix):]

    return s

def age(prevdate, show_short_version=False, now=None):

    """

    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

    if prevdate > now:

        now, prevdate = prevdate, now

        future = True

    if future:

        prevdate = prevdate.replace(microsecond=0)

    # Get date parts deltas

        else:

            return _('%s and %s ago') % (fmt_funcs[part](value),

                fmt_funcs[sub_part](sub_value))

    return _('just now')

def uri_filter(uri):

    """

    Removes user:password from given url string

    :param uri:

    :returns: filtered list of strings

    """

    if not uri:

        return []

    proto = ''

    for pat in ('https://', 'http://', 'git://'):

        if uri.startswith(pat):

            uri = uri[len(pat):]

            proto = pat

            break

            revision number as integer

        ``files``

            list of ``FileNode`` (``Node`` with NodeKind.FILE) objects

        ``dirs``

            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``

            otherwise; trying to access this attribute while there is no

            changesets would raise ``EmptyRepositoryError``

    """

    def __str__(self):

        return '<%s at %s:%s>' % (self.__class__.__name__, self.revision,

            self.short_id)

    def _get_revision(self, revision):

        """

        Given any revision identifier, returns a 40 char string with revision hash.

        :param revision: str or int or None

        """

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

        except (IndexError, ValueError, mercurial.error.RepoLookupError, TypeError):

            msg = "Revision %r does not exist for %s" % (safe_str(revision), self.name)

            raise ChangesetDoesNotExistError(msg)

        except (LookupError, ):

            msg = "Ambiguous identifier `%s` for %s" % (safe_str(revision), self.name)

            raise ChangesetDoesNotExistError(msg)

    def __getitem__(self, i):

        return self.data[i]

class SubprocessIOChunker(object):

    """

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

    The purpose of the object is to allow us to wrap subprocess interactions into

    an iterable that can be passed to a WSGI server as the application's return

    value. Because of stream-processing-ability, WSGI does not have to read ALL

    of the subprocess's output and buffer it, before handing it to WSGI server for

    HTTP response. Instead, the class initializer reads just a bit of the stream

    app_settings_id = Column(Integer(), primary_key=True)

    app_settings_name = Column(String(255), nullable=False, unique=True)

    _app_settings_value = Column("app_settings_value", Unicode(4096), nullable=False)

    _app_settings_type = Column("app_settings_type", String(255), nullable=True) # FIXME: not nullable?

    def __init__(self, key='', val='', type='unicode'):

        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

        converter = self.SETTINGS_TYPES.get(_type) or self.SETTINGS_TYPES['unicode']

        return converter(v)

    @app_settings_value.setter

    def app_settings_value(self, val):

        """

                   if gist_expires != -1 else 'forever')

        # create the Database version

        gist = Gist()

        gist.gist_description = description

        gist.gist_access_id = gist_access_id

        gist.owner_id = owner.user_id

        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 = {}

        for filename in gist_mapping:

            if filename != os.path.basename(filename):

                raise Exception('Filename cannot be inside a directory')

            content = gist_mapping[filename]['content']

            # TODO: expand support for setting explicit lexers

        """

        tmpl = self._subj_map[type_]

        try:

            subj = tmpl % kwargs

        except KeyError as e:

            log.error('error generating email subject for %r from %s: %s', type_, ', '.join(self._subj_map), e)

            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:

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

        return subj

    def get_email_tmpl(self, type_, content_type, **kwargs):

        """

        return generated template for email based on given type

        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]

        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)

    def test_wrong_path(self):

        # There is 'setup.py' in the root dir but not there:

        path = 'foo/bar/setup.py'

        tip = self.repo.get_changeset()

        with pytest.raises(VCSError):

        assert node.not_changed

        assert not node.removed

        # If node has REMOVED state then trying to fetch it would raise

        # ChangesetError exception

        chset = self.repo.get_changeset(2)

        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)

    def test_wrong_path(self):

        # There is 'setup.py' in the root dir but not there:

        path = 'foo/bar/setup.py'

        with pytest.raises(VCSError):

            self.repo.get_changeset().get_node(path)

            FileNode('foo/bar/file.bin', content='\xd0\xcf\x11\xe0\xa1\xb1\x1a\xe1\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00;\x00\x03\x00\xfe\xff\t\x00\x06\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x1a\x00\x00\x00\x00\x00\x00\x00\x00\x10\x00\x00\x18\x00\x00\x00\x01\x00\x00\x00\xfe\xff\xff\xff\x00\x00\x00\x00\x00\x00\x00\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff'),

        ]

        commits = []

        return commits

    def test_add(self):

        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

        assert newtip.author == author

        assert not any((

            self.imc.added,

            self.imc.changed,

            self.imc.removed

        ))

        for node in to_add:

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

    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

        assert newtip.author == author

        assert not any((

            self.imc.added,

            self.imc.changed,

            self.imc.removed

        ))

        changeset.get_node('foobar/foobaz/file').content == b'foo'

        changeset.get_node('foobar/barbaz').content == b'foo'

    def test_add_non_ascii_files(self):

        rev_count = len(self.repo.revisions)

        to_add = [

            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

        assert newtip.author == author

        assert not any((

            self.imc.added,

            self.imc.changed,

            self.imc.removed

        ))

        for node in to_add:

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

    def test_add_raise_already_added(self):

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

        self.imc.add(node)

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

        self.imc.add(FileNode('foo/bar/baz', content='foo'))

        self.imc.add(FileNode('foo/fbar', content='foobar'))

        tip = self.imc.commit(u'Initial', u'joe.doe@example.com')

        # Change node's content

        node = FileNode('foo/bar/baz', content='My **changed** content')

        assert newtip.get_node('żółwik/zwierzątko').content == b'My **changed** content'

        assert newtip.get_node('żółwik/zwierzątko_uni').content == b'My **changed** content'

    def test_change_raise_empty_repository(self):

        node = FileNode('foobar')

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

        self.test_add()  # Performs first commit

        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_last_file_from_directory(self):

        node = FileNode('omg/qwe/foo/bar', content='foobar')

        self.imc.add(node)

        self.imc.commit(u'added', u'joe doe')

        self.imc.remove(node)

        tip = self.imc.commit(u'removed', u'joe doe')

        with pytest.raises(NodeDoesNotExistError):

            tip.get_node('omg/qwe/foo/bar')

    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)

        self.imc.remove(node)

        with pytest.raises(NodeAlreadyRemovedError):

            self.imc.remove(node)

    def test_remove_raise_node_already_changed(self):

        self.test_add()  # Performs first commit