mock >= 3.0.0, < 4.1

Sphinx >= 1.8.0, < 3.1

WebTest >= 2.0.6, < 2.1

pyflakes == 2.2.0

# 'debug = true' (not in production!)

# See the Kallithea documentation for more information.

try:

    from tgext.debugbar import enable_debugbar

    assert kajiki

except ImportError:

    pass

        elif alias == 'git':

            if org_repo != other_repo:

                from dulwich.repo import Repo

                gitrepo = Repo(org_repo.path)

                SubprocessGitClient(thin_packs=False).fetch(other_repo.path, gitrepo)

@celerylib.task

@celerylib.dbsession

def create_repo(form_data, cur_user):

    from kallithea.model.repo import RepoModel

    DBS = celerylib.get_session()

            self.create_user(username, password, email, True)

        else:

            log.info('creating admin and regular test users')

            self.create_user(TEST_USER_ADMIN_LOGIN, TEST_USER_ADMIN_PASS,

                             TEST_USER_ADMIN_EMAIL, True)

    """Find the user identified by 'author', return one of the users attributes,

    default to the username attribute, None if there is no user"""

    from kallithea.model.db import User

    # if author is already an instance use it for extraction

    if isinstance(author, User):

        return getattr(author, show_attr)

def person_by_id(id_, show_attr="username"):

    from kallithea.model.db import User

    # maybe it's an ID ?

    if str(id_).isdigit() or isinstance(id_, int):

        id_ = int(id_)

def gravatar_url(email_address, size=30, default=''):

    from tg import tmpl_context as c

    if not c.visual.use_gravatar:

        return ""

    if email_address == _def:

        return default

    parsed_url = urllib.parse.urlparse(url.current(qualified=True))

    url = (c.visual.gravatar_url or User.DEFAULT_GRAVATAR_URL) \

               .replace('{email}', email_address) \

    :param stats: two element list of added/deleted lines of code

    """

    a, d = stats['added'], stats['deleted']

    width = 100

    connect to the database.

    """

    import paste.deploy

    import kallithea.config.application

    extras = get_hook_environment()

        if git_command in ['git-receive-pack']:

            # updating refs manually after each push.

            # Needed for pre-1.7.0.4 git clients using regular HTTP mode.

            from kallithea.lib.vcs import get_repo

            repo = get_repo(self.content_path)

            if repo:

                update_server_info(repo._repo)

def make_wsgi_app(repo_name, repo_root):

    app = GitDirectory(repo_root, repo_name)

    return GunzipFilter(LimitedInputFilter(app))

    :param repo:

    :param rev:

    """

    from kallithea.lib.vcs.exceptions import RepositoryError

    if not isinstance(repo, BaseRepository):

        raise Exception('You must pass an Repository '

                        'object as first argument got %s' % type(repo))

    except ImportError:

        return code

    from pygments import highlight

    from pygments.formatters import TerminalFormatter

    try:

        lexer = guess_lexer_for_filename(name, code)

    @classmethod

    def get_server_info(cls):

        import pkg_resources

        from kallithea.lib.utils import check_git_version

        mods = [(p.project_name, p.version) for p in pkg_resources.working_set]

        info = {

        :param author:

        """

        # Valid email in the attribute passed, see if they're in the system

        _email = email(author)

        if _email:

    @classmethod

    def _render_datatable(cls, tmpl, *args, **kwargs):

        from tg.i18n import ugettext as _

        _tmpl_lookup = app_globals.mako_lookup

        admin: return data for action column.

        """

        _render = self._render_datatable

        from kallithea.model.scm import ScmModel

        def repo_lnk(name, rtype, rstate, private, fork_of):

    def _update_permissions(self, repo_group, perms_new=None,

                            perms_updates=None, recursive=None,

                            check_perms=True):

        from kallithea.model.repo import RepoModel

        if not perms_new:

            perms_new = []

        if not cur_user:

            cur_user = getattr(get_current_authuser(), 'username', None)

        _fd = form_data

        user_data = {

            'username': _fd['username'],

        if not cur_user:

            cur_user = getattr(get_current_authuser(), 'username', None)

        user_data = {

            'username': username, 'password': password,

            'email': email, 'firstname': firstname, 'lastname': lastname,

            raise

    def create_registration(self, form_data):

        from kallithea.model.notification import NotificationModel

        form_data['admin'] = False

        form_data['extern_type'] = User.DEFAULT_AUTH_TYPE

        allowing users to copy-paste or manually enter the token from the

        email.

        """

        from kallithea.lib.celerylib import tasks

        from kallithea.model.notification import EmailNotificationModel

        user_email = data['email']

        user = User.get_by_email(user_email)

        return expected_token == token

    def reset_password(self, user_email, new_passwd):

        from kallithea.lib.celerylib import tasks

        user = User.get_by_email(user_email)

        if user is not None:

            if not self.can_change_password(user):

        assert 'trololo' == Optional.extract('trololo')

    def test_Optional_OAttr(self):

        option1 = Optional(OAttr('apiuser'))

        assert 'apiuser' == Optional.extract(option1)

        (dict(years= -3, months= -2), '3 years and 2 months ago'),

    ])

    def test_age(self, age_args, expected):

        from kallithea.lib.utils2 import age

        with test_context(self.app):

            n = datetime.datetime(year=2012, month=5, day=17)

            delt = lambda *args, **kwargs: relativedelta.relativedelta(*args, **kwargs)

        (dict(years= -4, months= -8), '5 years ago'),

    ])

    def test_age_short(self, age_args, expected):

        from kallithea.lib.utils2 import age

        with test_context(self.app):

            n = datetime.datetime(year=2012, month=5, day=17)

            delt = lambda *args, **kwargs: relativedelta.relativedelta(*args, **kwargs)

        (dict(years=1, months=1), 'in 1 year and 1 month')

    ])

    def test_age_in_future(self, age_args, expected):

        from kallithea.lib.utils2 import age

        with test_context(self.app):

            n = datetime.datetime(year=2012, month=5, day=17)

            delt = lambda *args, **kwargs: relativedelta.relativedelta(*args, **kwargs)

        :param text:

        """

        import re

        # quickly change expected url[] into a link

        url_pattern = re.compile(r'(?:url\[)(.+?)(?:\])')

        ('http://www.example.org/kallithea/repos/', 'abc/xyz/', 'http://www.example.org/kallithea/repos/abc/xyz/'),

    ])

    def test_canonical_url(self, canonical, test, expected):

        from tg import request

        m = routes.Mapper()

        m.connect('about', '/about-page')

        url = routes.URLGenerator(m, {'HTTP_HOST': 'http_host.example.org'})

        ('http://www.example.org/kallithea/repos/', 'www.example.org'),

    ])

    def test_canonical_hostname(self, canonical, expected):

        from tg import request

        # setup url(), used by canonical_hostname

        m = routes.Mapper()

        url = routes.URLGenerator(m, {'HTTP_HOST': 'http_host.example.org'})

    def test_checkout_branch(self):

        from kallithea.lib.vcs.exceptions import BranchDoesNotExistError

        # first, 'foobranch' does not exist.

        with pytest.raises(BranchDoesNotExistError):

            self.repo.workdir.checkout_branch(branch='foobranch')

import sys

import click

import i18n_utils

    and then invoke merge/rebase/graft with the additional argument '--tool i18n'.

    """

    print('i18n normalized-merge: normalizing and merging %s' % output)