CONFIG = {}

# Linked module for extensions

EXTENSIONS = {}

from kallithea.lib.vcs.exceptions import (ChangesetDoesNotExistError, ChangesetError, EmptyRepositoryError, ImproperArchiveTypeError, NodeAlreadyExistsError,

                                          NodeDoesNotExistError, NodeError, RepositoryError, VCSError)

from kallithea.lib.vcs.nodes import FileNode

from kallithea.model.repo import RepoModel

from kallithea.model.scm import ScmModel

        file_node = self.__get_filenode(cs, f_path)

        response.content_disposition = \

        response.content_type = file_node.mimetype

        return file_node.content

#==============================================================================

from kallithea.lib.vcs.utils import author_email, author_name

from kallithea.model.changeset_status import ChangesetStatusModel

# mute pyflakes "imported but unused"

                    log.error('invalid issue_url setting %r -> %r %r. Error: %s', issue_pat, issue_server_link, issue_sub, str(e))

                    issue_url = issue_server_link

                issue_url = issue_url.replace('{repo}', repo_name)

                # if issue_sub is empty use the matched issue reference verbatim

                if not issue_sub:

                    issue_text = match_obj.group()

from kallithea.lib.vcs.exceptions import RepositoryError, VCSError

from kallithea.lib.vcs.utils.fakemod import create_module

from kallithea.lib.vcs.utils.helpers import get_scm

from kallithea.model.db import RepoGroup, Repository, Setting, Ui, User, UserGroup, UserLog

    """

    from kallithea.model.repo_group import RepoGroupModel

    sa = meta.Session()

    parent = None

    group = None

from kallithea.model.meta import Base, Session

log = logging.getLogger(__name__)

#==============================================================================

        :param cls:

        :param repo_name:

        """

    @classmethod

    def guess_instance(cls, value):

        assert repo_full_path.startswith(base_full_path + os.path.sep)

        repo_name = repo_full_path[len(base_full_path) + 1:]

        repo_name = cls.normalize_repo_name(repo_name)

    @classmethod

    def get_repo_forks(cls, repo_id):

    @property

    def just_name(self):

    @property

    def groups_with_parents(self):

        # we need to split the name by / since this is how we store the

        # names in the database, but that eventually needs to be converted

        # into a valid system path

        return os.path.join(*p)

    def get_new_name(self, repo_name):

        :param group_name:

        """

        path_prefix = self.group.full_path_splitted if self.group else []

    @property

    def _ui(self):

    @property

    def name(self):

    @property

    def full_path(self):

    @property

    def full_path_splitted(self):

    @property

    def repositories(self):

        """

        path_prefix = (self.parent_group.full_path_splitted if

                       self.parent_group else [])

    def get_api_data(self):

        """

from kallithea.lib.utils import is_valid_repo_uri, make_ui

from kallithea.lib.utils2 import LazyProperty, get_current_authuser, obfuscate_url_pw, remove_prefix

from kallithea.lib.vcs.backends import get_backend

                                UserGroupRepoToPerm, UserRepoGroupToPerm, UserRepoToPerm)

class RepoModel(object):

    def _create_default_perms(self, repository, private):

        # create default permission

        default = 'repository.read'

            # while repo_name_full is a full qualified name that is combined

            # with name and path of group

            repo_name_full = repo_name

            if kallithea.lib.utils2.repo_name_slug(repo_name) != repo_name:

                raise Exception('invalid repo name %s' % repo_name)

import kallithea.lib.utils2

from kallithea.lib.utils2 import LazyProperty

from kallithea.model.db import Permission, RepoGroup, Repository, Session, Ui, User, UserGroup, UserGroupRepoGroupToPerm, UserRepoGroupToPerm

        :param group: instance of group from database

        :param force_delete: use shutil rmtree to remove all objects

        """

        paths = os.sep.join(paths)

        rm_path = os.path.join(self.repos_path, paths)

from sqlalchemy import func

from tg.i18n import ugettext as _

from kallithea.config.routing import ADMIN_PREFIX

from kallithea.lib.auth import HasPermissionAny, HasRepoGroupPermissionLevel

from kallithea.lib.compat import OrderedSet

from kallithea.lib.exceptions import InvalidCloneUriException, LdapImportError

from kallithea.lib.utils import is_valid_repo_uri

from kallithea.lib.utils2 import asbool, aslist, repo_name_slug

from kallithea.model.db import RepoGroup, Repository, User, UserGroup

                # value needs to be aware of group name in order to check

                # db key This is an actual just the name to store in the

                # database

            else:

                group_name = group_path = ''

                repo_name_full = repo_name

import mock

import pytest

from kallithea.lib import vcs

from kallithea.model.db import Permission, Repository, Ui, User, UserRepoToPerm

from kallithea.model.meta import Session

from kallithea.model.repo import RepoModel

        Session().commit()

        repo_name = 'ingroup'

        description = 'description for newly created repo'

        response = self.app.post(base.url('repos'),

                        fixture._get_repo_create_params(repo_private=False,

        Session().commit()

        repo_name = 'ingroup'

        description = 'description for newly created repo'

        response = self.app.post(base.url('repos'),

                        fixture._get_repo_create_params(repo_private=False,

        # user is allowed to create in this group

        repo_name = 'ingroup'

        description = 'description for newly created repo'

        response = self.app.post(base.url('repos'),

                        fixture._get_repo_create_params(repo_private=False,

        Session().commit()

        repo_name = 'ingroup_inherited_%s' % self.REPO_TYPE

        description = 'description for newly created repo'

        response = self.app.post(base.url('repos'),

                        fixture._get_repo_create_params(repo_private=False,

from kallithea.lib.auth import AuthUser

from kallithea.model.db import Permission, User, UserGroupRepoGroupToPerm, UserToPerm

from kallithea.model.meta import Session

from kallithea.model.permission import PermissionModel

        assert a1_auth.repository_group_permissions.get('group2') == 'group.none'

        # add repo to group

        self.test_repo = fixture.create_repo(name=name,

                                             repo_type='hg',

                                             repo_group=self.g1,

import pytest

from sqlalchemy.exc import IntegrityError

from kallithea.model.db import RepoGroup

from kallithea.model.meta import Session

from kallithea.model.repo import RepoModel

        assert self.__check_path('g2', 'g1')

        # test repo

    def test_move_to_root(self):

        g1 = fixture.create_repo_group('t11')