import kallithea.bin.kallithea_cli_base as cli_base

from kallithea.lib.utils import REMOVED_REPO_PAT, repo2db_mapper

from kallithea.model.db import Repository, Ui

from kallithea.model.meta import Session

from kallithea.model.scm import ScmModel

    repos_location = Ui.get_repos_location()

    to_remove = []

        alldirs = list(dirs)

        del dirs[:]

        if ('.hg' in alldirs or

        remove = True

    else:

        remove = ask_ok('The following repositories will be removed completely:\n%s\n'

    if remove:

        for path, date_ in to_remove:

from kallithea.lib.auth import AuthUser

from kallithea.lib.base import _get_ip_addr as _get_ip

from kallithea.lib.base import get_path_info

from kallithea.model.db import User

        super(JSONRPCError, self).__init__()

    def __str__(self):

class JSONRPCErrorResponse(Response, HTTPException):

from kallithea.lib.auth import HasRepoPermissionLevelDecorator, LoginRequired

from kallithea.lib.base import BaseRepoController, render

from kallithea.lib.graphmod import graph_data

from kallithea.model.db import Repository

                from dulwich.client import SubprocessGitClient

                gitrepo = Repo(org_repo.path)

                gitrepo_remote = Repo(other_repo.path)

                revs = [

                    ascii_str(x.commit.id)

from kallithea.lib.base import BaseRepoController, jsonify, render

from kallithea.lib.exceptions import NonRelativePathError

from kallithea.lib.utils import action_logger

from kallithea.lib.vcs.backends.base import EmptyChangeset

from kallithea.lib.vcs.conf import settings

from kallithea.lib.vcs.exceptions import (

        cs = self.__get_cs(revision)

        file_node = self.__get_filenode(cs, f_path)

        response.content_type = file_node.mimetype

        return file_node.content

                mimetype, dispo = 'text/plain', 'inline'

        if dispo == 'attachment':

        response.content_disposition = dispo

        response.content_type = mimetype

        from kallithea import CONFIG

        rev_name = cs.raw_id[:12]

        archive_path = None

        cached_archive_path = None

from kallithea.lib.auth import AuthUser, HasPermissionAnyDecorator

from kallithea.lib.base import BaseController, log_in_user, render

from kallithea.lib.exceptions import UserCreationError

from kallithea.model.db import Setting, User

from kallithea.model.forms import LoginForm, PasswordResetConfirmationForm, PasswordResetRequestForm, RegisterForm

from kallithea.model.meta import Session

        return _re.match(came_from) is not None

    def index(self):

        if c.came_from:

            if not self._validate_came_from(c.came_from):

                log.error('Invalid came_from (not server-relative): %r', c.came_from)

from kallithea.lib.base import BaseRepoController, jsonify, render

from kallithea.lib.graphmod import graph_data

from kallithea.lib.page import Page

from kallithea.lib.vcs.exceptions import ChangesetDoesNotExistError, EmptyRepositoryError

from kallithea.model.changeset_status import ChangesetStatusModel

from kallithea.model.comment import ChangesetCommentsModel

        # list named branches that has been merged to this named branch - it should probably merge back

        peers = []

        if branch_rev:

            # a revset not restricting to merge() would be better

            # (especially because it would get the branch point)

        log.debug('running diff between %s and %s in %s',

                  c.a_rev, c.cs_rev, org_scm_instance.path)

        try:

                                      ignore_whitespace=ignore_whitespace, context=line_context)

        except ChangesetDoesNotExistError:

            raw_diff = safe_bytes(_("The diff can't be shown - the PR revisions could not be found."))

from kallithea.lib.base import BaseRepoController, render

from kallithea.lib.indexers import CHGSET_IDX_NAME, CHGSETS_SCHEMA, IDX_NAME, SCHEMA, WhooshResultWrapper

from kallithea.lib.page import Page

from kallithea.model.repo import RepoModel

                        page=p,

                        item_count=res_ln,

                        items_per_page=10,

                    )

                except QueryParserError:

from kallithea.lib import auth_modules

from kallithea.lib.compat import hybrid_property

from kallithea.model.db import Setting

        # only way to log in is using environ

        username = None

        if userobj:

        if not username:

            # we don't have any objects in DB, user doesn't exist, extract

from kallithea.lib import auth_modules

from kallithea.lib.compat import hybrid_property

from kallithea.lib.exceptions import LdapConnectionError, LdapImportError, LdapPasswordError, LdapUsernameError

log = logging.getLogger(__name__)

                            port)

            for host in server.split(',')))

        self.SEARCH_SCOPE = getattr(ldap, 'SCOPE_%s' % search_scope)

        self.attr_login = attr_login

                try:

                    log.debug('Trying simple bind with %s', dn)

                    results = server.search_ext_s(dn, ldap.SCOPE_BASE,

                                                  '(objectClass=*)')

                    if len(results) == 1:

from kallithea.lib.auth import AuthUser, HasPermissionAnyMiddleware

from kallithea.lib.exceptions import UserCreationError

from kallithea.lib.utils import get_repo_slug, is_valid_repo

from kallithea.lib.vcs.exceptions import ChangesetDoesNotExistError, EmptyRepositoryError, RepositoryError

from kallithea.model import meta

from kallithea.model.db import PullRequest, Repository, Setting, User

        # If not authenticated by the container, running basic auth

        if not username:

            result = self.authenticate(environ)

            if isinstance(result, str):

                paste.httpheaders.AUTH_TYPE.update(environ, 'basic')

            try:

                log.info('%s action on %s repo "%s" by "%s" from %s',

                app = self._make_app(parsed_request)

                return app(environ, start_response)

            except Exception:

from sqlalchemy.orm.query import Query

from sqlalchemy.sql import visitors

class CachingQuery(Query):

    """A Query subclass which optionally loads full results from a Beaker

                        "for region %r namespace %r" %

                        (region, namespace)

                    )

class FromCache(MapperOption):

from kallithea.lib import helpers as h

from kallithea.lib.exceptions import UserCreationError

from kallithea.lib.utils import action_logger, make_ui

from kallithea.lib.vcs.backends.base import EmptyChangeset

from kallithea.model.db import Repository, User

        alias += '.'

    size_scm, size_root = 0, 0

        if path.find(alias) != -1:

            for f in files:

                try:

    repo = Repository.get_by_full_path(repo_path)

    if not repo:

    baseui = make_ui()

    return baseui, repo

def rejectpush(ui, **kwargs):

    """Mercurial hook to be installed as pretxnopen and prepushkey for read-only repos"""

    ex = get_hook_environment()

    return 1

from kallithea.config.conf import INDEX_EXTENSIONS, INDEX_FILENAMES

from kallithea.lib.indexers import CHGSET_IDX_NAME, CHGSETS_SCHEMA, IDX_NAME, SCHEMA

from kallithea.lib.vcs.exceptions import ChangesetError, NodeDoesNotExistError, RepositoryError

from kallithea.model.db import Repository

from kallithea.model.scm import ScmModel

            cs = self._get_index_changeset(repo)

            for _topnode, _dirs, files in cs.walk('/'):

                for f in files:

        except RepositoryError:

            log.debug(traceback.format_exc())

    def get_node(self, repo, path, index_rev=None):

        """

        :param repo: scm repo instance

        :param path: full path including root location

        :return: FileNode

        """

        # FIXME: paths should be normalized ... or even better: don't include repo.path

        cs = self._get_index_changeset(repo, index_rev=index_rev)

        node = cs.get_node(node_path)

        return node

from kallithea.lib.base import BaseVCSController, get_path_info

from kallithea.lib.utils import make_ui

log = logging.getLogger(__name__)

        """

        Make an hgweb wsgi application.

        """

        baseui = make_ui(repo_path=repo_path)

        def wrapper_app(environ, start_response):

            return hgweb_app(environ, start_response)

        return wrapper_app

import kallithea.config.conf

from kallithea.lib.exceptions import HgsubversionImportError

from kallithea.lib.vcs.backends.git.repository import GitRepository

from kallithea.lib.vcs.backends.hg.repository import MercurialRepository

from kallithea.lib.vcs.conf import settings

    """

    # remove ending slash for better results

    log.debug('now scanning in %s', path)

    def isdir(*n):

    :return True: if given path is a valid repository

    """

    # TODO: paranoid security checks?

    try:

        scm_ = get_scm(full_path)

    :param repo_name:

    :param base_path:

    """

    # check if it's not a repo

    if is_valid_repo(repo_group_name, base_path):

        system_user = 'kallithea' # hardcoded default value ...

    args = {

        'scheme': parsed_url.scheme,

        'netloc': parsed_url.netloc + prefix,  # like "hostname:port/prefix" (with optional ":port" and "/prefix")

        'prefix': prefix, # undocumented, empty or starting with /

        'repo': repo_name,

def urlreadable(s, _cleanstringsub=re.compile('[^-a-zA-Z0-9./]+').sub):

def recursive_replace(str_, replace=' '):

from kallithea.lib.vcs.exceptions import ChangesetDoesNotExistError, ChangesetError, ImproperArchiveTypeError, NodeDoesNotExistError, RepositoryError, VCSError

from kallithea.lib.vcs.nodes import (

    AddedFileNodesGenerator, ChangedFileNodesGenerator, DirNode, FileNode, NodeKind, RemovedFileNodesGenerator, RootNode, SubModuleNode)

from kallithea.lib.vcs.utils.lazy import LazyProperty

    def __init__(self, repository, revision):

        self._stat_modes = {}

        self.repository = repository

        try:

            commit = self.repository._repo[ascii_bytes(revision)]

            if isinstance(commit, objects.Tag):

        return path

    def _get_id_for_path(self, path):

        # FIXME: Please, spare a couple of minutes and make those codes cleaner;

        if path not in self._paths:

            path = path.strip('/')

            if path not in self._paths:

                raise NodeDoesNotExistError("There is no file nor directory "

                    "at the given path '%s' at revision %s"

        return self._paths[path]

    def _get_kind(self, path):

        Returns stat mode of the file at the given ``path``.

        """

        # ensure path is traversed

        self._get_id_for_path(path)

        return self._stat_modes[path]

        iterating commits.

        """

        self._get_filectx(path)

        if limit is not None:

            cmd = ['log', '-n', str(safe_int(limit, 0)),

        else:

            cmd = ['log',

        so = self.repository.run_git_command(cmd)

        ids = re.findall(r'[0-9a-fA-F]{40}', so)

        return [self.repository.get_changeset(sha) for sha in ids]

from kallithea.lib.vcs.conf import settings

from kallithea.lib.vcs.exceptions import (

    BranchDoesNotExistError, ChangesetDoesNotExistError, EmptyRepositoryError, RepositoryError, TagAlreadyExistError, TagDoesNotExistError)

from kallithea.lib.vcs.utils.lazy import LazyProperty

from kallithea.lib.vcs.utils.paths import abspath, get_user_home

        Returns normalized url. If schema is not given, would fall to

        filesystem (``file:///``) schema.

        """

        if url != 'default' and '://' not in url:

            url = ':///'.join(('file', url))

        return url

from kallithea.lib.hooks import log_pull_action

from kallithea.lib.utils import make_ui

from kallithea.lib.vcs.backends.ssh import BaseSshHandler

log = logging.getLogger(__name__)

            log_pull_action(ui=make_ui(), repo=self.db_repo.scm_instance._repo)

        else: # probably verb 'git-receive-pack', action 'push'

            if not self.allow_push:

            # Note: push logging is handled by Git post-receive hook

        # git shell is not a real shell but use shell inspired quoting *inside* the argument.

from kallithea.lib.vcs.exceptions import ChangesetDoesNotExistError, ChangesetError, ImproperArchiveTypeError, NodeDoesNotExistError, VCSError

from kallithea.lib.vcs.nodes import (

    AddedFileNodesGenerator, ChangedFileNodesGenerator, DirNode, FileNode, NodeKind, RemovedFileNodesGenerator, RootNode, SubModuleNode)

from kallithea.lib.vcs.utils.lazy import LazyProperty

from kallithea.lib.vcs.utils.paths import get_dirs_for_path

        if path.endswith('/'):

            path = path.rstrip('/')

    def _get_kind(self, path):

        path = self._fix_path(path)

from kallithea.lib.vcs.backends.base import BaseRepository, CollectionGenerator

from kallithea.lib.vcs.exceptions import (

    BranchDoesNotExistError, ChangesetDoesNotExistError, EmptyRepositoryError, RepositoryError, TagAlreadyExistError, TagDoesNotExistError, VCSError)

from kallithea.lib.vcs.utils.lazy import LazyProperty

from kallithea.lib.vcs.utils.paths import abspath

        """

        Returns revision number for the given reference.

        """

        if ref_type == 'rev' and not ref_name.strip('0'):

            return self.EMPTY_CHANGESET

        # lookup up the exact node id

    def _get_url(self, url):

        """

        """

        if url != 'default' and '://' not in url:

            url = "file:" + urllib.request.pathname2url(url)

        return url

from kallithea.lib.auth import AuthUser, HasPermissionAnyMiddleware

from kallithea.lib.utils2 import set_hook_environment

from kallithea.model.db import Repository, User, UserSshKeys

from kallithea.model.meta import Session

        elif HasPermissionAnyMiddleware('repository.read')(self.authuser, self.repo_name):

            self.allow_push = False

        else:

        self.db_repo = Repository.get_by_repo_name(self.repo_name)

        if self.db_repo is None:

from kallithea.lib.vcs.backends.base import EmptyChangeset

from kallithea.lib.vcs.exceptions import NodeError, RemovedFileNodeError

from kallithea.lib.vcs.utils.lazy import LazyProperty

        if path.startswith('/'):

            raise NodeError("Cannot initialize Node objects with slash at "

                            "the beginning as only relative paths are supported")

        if path == '' and kind != NodeKind.DIR:

            raise NodeError("Only DirNode and its subclasses may be "

                            "initialized with empty path")

        self.alias = alias

        # we have to use emptyChangeset here since this can point to svn/git/hg

        # submodules we cannot get from repository

        self.url = url

    def __repr__(self):

    m = email_re.search(author)

    if m is None:

        return ''

def author_name(author):

from kallithea.lib.caching_query import FromCache

from kallithea.lib.exceptions import DefaultUserException

from kallithea.lib.utils2 import (

from kallithea.lib.vcs import get_backend

from kallithea.lib.vcs.backends.base import EmptyChangeset

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

        return _c(rn)

    def scm_instance_no_cache(self):

        alias = get_scm(repo_full_path)[0]

        log.debug('Creating instance of %s repository from %s',

                  alias, self.repo_full_path)

        """

        inv_objs = Session().query(cls).filter(cls.cache_args == repo_name).all()

        log.debug('for repo %s got %s invalidation objects',

        for inv_obj in inv_objs:

            log.debug('marking %s key for invalidation based on repo_name=%s',

            Session().delete(inv_obj)

        Session().commit()

    def scm_instance(self):

        from kallithea.lib.vcs import get_repo

        base_path = self.base_path()

class UserSshKeys(Base, BaseDbModel):

from kallithea.lib.exceptions import AttachedForksError

from kallithea.lib.hooks import log_delete_repository

from kallithea.lib.utils import is_valid_repo_uri, make_ui

from kallithea.lib.vcs.backends import get_backend

from kallithea.model.db import (

    Permission, RepoGroup, Repository, RepositoryField, Session, Statistics, Ui, User, UserGroup, UserGroupRepoGroupToPerm, UserGroupRepoToPerm, UserRepoGroupToPerm, UserRepoToPerm)

            _paths = [repo_store_location]

        else:

            _paths = [self.repos_path, new_parent_path, repo_name]

        # check if this path is not a repository

        if is_valid_repo(repo_path, self.repos_path):

        """

        log.info('renaming repo from %s to %s', old, new)

        if os.path.isdir(new_path):

            raise Exception(

                'Was trying to rename to already existing dir %s' % new_path

        :param repo: repo object

        """

        log.info("Removing %s", rm_path)

        _now = datetime.now()

            args = repo.group.full_path_splitted + [_d]

            _d = os.path.join(*args)

        if os.path.exists(rm_path):

        else:

            log.error("Can't find repo to delete in %r", rm_path)

from kallithea.lib.exceptions import IMCCommitError, NonRelativePathError

from kallithea.lib.hooks import process_pushed_raw_ids

from kallithea.lib.utils import action_logger, get_filesystem_repos, make_ui

from kallithea.lib.vcs import get_backend

from kallithea.lib.vcs.backends.base import EmptyChangeset

from kallithea.lib.vcs.exceptions import RepositoryError

                    klass = get_backend(path[0])

                    if path[0] == 'hg' and path[0] in BACKENDS:

                    if path[0] == 'git' and path[0] in BACKENDS:

                        repos[name] = klass(path[1])

        """

        user = User.guess_instance(user)

        IMC = self._get_IMC_module(repo.alias)

        imc = IMC(repo)

        try:

            tip = imc.commit(message=message, author=author,

                             parents=[cs], branch=cs.branch)

        for f_path in nodes:

            content = nodes[f_path]['content']

            f_path = self._sanitize_path(f_path)

                content = content.read()

            processed_nodes.append((f_path, content))

import pytest

from webtest import TestApp

from kallithea.model.db import User

    def checkSessionFlash(self, response, msg=None, skip=0, _matcher=lambda msg, m: msg in m):

        if 'flash' not in response.session:

        try:

            level, m = response.session['flash'][-1 - skip]