"""

import logging

import re

from tg import request

from tg import tmpl_context as c

from tg.i18n import ugettext as _

from webob.exc import HTTPBadRequest, HTTPFound, HTTPNotFound

from kallithea.config.routing import url

from kallithea.lib import diffs

from kallithea.lib import helpers as h

from kallithea.lib.auth import HasRepoPermissionLevelDecorator, LoginRequired

from kallithea.lib.base import BaseRepoController, render

from kallithea.lib.graphmod import graph_data

from kallithea.lib.utils2 import ascii_bytes, ascii_str, safe_int, safe_str

from kallithea.model.db import Repository

log = logging.getLogger(__name__)

            org_changesets = []

            other_changesets = []

        elif alias == 'hg':

            # case two independent repos

            if org_repo != other_repo:

                                                       other_repo.path,

                                                       org_repo.path)

                # all ancestors of other_rev will be in other_repo and

                # rev numbers from hgrepo can be used in other_repo - org_rev ancestors cannot

            # no remote compare do it on the same repository

"""

import logging

import traceback

import formencode

from tg import request

from tg import tmpl_context as c

from tg.i18n import ugettext as _

from webob.exc import HTTPBadRequest, HTTPForbidden, HTTPFound, HTTPNotFound

from kallithea.config.routing import url

from kallithea.lib.auth import HasRepoPermissionLevelDecorator, LoginRequired

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

from kallithea.lib.graphmod import graph_data

from kallithea.lib.page import Page

from kallithea.lib.utils2 import ascii_bytes, safe_bytes, safe_int, safe_str

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

from kallithea.model.changeset_status import ChangesetStatusModel

from kallithea.model.comment import ChangesetCommentsModel

from kallithea.model.db import ChangesetStatus, PullRequest, PullRequestReviewer, Repository, User

from kallithea.model.forms import PullRequestForm, PullRequestPostForm

from kallithea.model.meta import Session

from kallithea.model.pull_request import CreatePullRequestAction, CreatePullRequestIterationAction, PullRequestModel

                        # also show changesets that not are descendants but would be merged in

                        targethead = other_scm_instance.get_changeset(c.a_branch_name).raw_id

                        if org_scm_instance.path != other_scm_instance.path:

                            # Note: org_scm_instance.path must come first so all

                            # valid revision numbers are 100% org_scm compatible

                            # - both for avail_revs and for revset results

                                                                   org_scm_instance.path,

                                                                   other_scm_instance.path)

                        else:

                            hgrepo = org_scm_instance._repo

                        show = set(hgrepo.revs('::%ld & !::parents(%s) & !::%s',

                                               avail_revs, revs[0], targethead))

:license: GPLv3, see LICENSE.md for more details.

"""

import os

import time

from kallithea.lib import helpers as h

from kallithea.lib.exceptions import UserCreationError

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

from kallithea.lib.utils2 import ascii_str, get_hook_environment, safe_str, safe_unicode

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

from kallithea.model.db import Repository, User

def _get_scm_size(alias, root_path):

    if not alias.startswith('.'):

        alias += '.'

    The pushed changesets is given by the revset 'node:node_last'.

    Note: This hook is not only logging, but also the side effect invalidating

    cahes! The function should perhaps be renamed.

    """

    process_pushed_raw_ids(revs)

    return 0

def process_pushed_raw_ids(revs):

    """

import logging

import os

import urllib

from kallithea.lib.base import BaseVCSController, get_path_info

from kallithea.lib.utils import make_ui

from kallithea.lib.utils2 import safe_str, safe_unicode

log = logging.getLogger(__name__)

def get_header_hgarg(environ):

        """

        Make an hgweb wsgi application.

        """

        str_repo_name = safe_str(parsed_request.repo_name)

        repo_path = os.path.join(safe_str(self.basepath), str_repo_name)

        baseui = make_ui(repo_path=repo_path)

        def wrapper_app(environ, start_response):

            return hgweb_app(environ, start_response)

        return wrapper_app

import re

import sys

import traceback

from distutils.version import StrictVersion

import beaker

from beaker.cache import _cache_decorate

from tg.i18n import ugettext as _

import kallithea.config.conf

from kallithea.lib.exceptions import HgsubversionImportError

from kallithea.lib.utils2 import ascii_bytes, aslist, get_current_authuser, safe_bytes, safe_str, safe_unicode

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

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 import meta

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

log = logging.getLogger(__name__)

def make_ui(repo_path=None):

    """

    Create an Mercurial 'ui' object based on database Ui settings, possibly

    augmenting with content from a hgrc file.

    """

    # clean the baseui object

    sa = meta.Session()

    for ui_ in sa.query(Ui).all():

        if ui_.ui_active:

            log.debug('config from db: [%s] %s=%r', ui_.ui_section,

                      ui_.ui_key, ui_.ui_value)

    baseui.setconfig(b'hooks', b'outgoing.kallithea_log_pull_action', b'python:kallithea.lib.hooks.log_pull_action')

    if repo_path is not None:

        hgrc_path = os.path.join(repo_path, '.hg', 'hgrc')

        if os.path.isfile(hgrc_path):

            log.debug('reading hgrc from %s', hgrc_path)

            cfg.read(hgrc_path)

            for section in ui_sections:

                for k, v in cfg.items(section):

                    log.debug('config from file: [%s] %s=%s', section, k, v)

                    baseui.setconfig(ascii_bytes(section), ascii_bytes(k), safe_bytes(v))

        else:

import re

import time

import urllib

import urllib2

from collections import OrderedDict

from dulwich.config import ConfigFile

from dulwich.objects import Tag

from dulwich.repo import NotGitRepository, Repo

from kallithea.lib.vcs import subprocessio

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

from kallithea.lib.vcs.conf import settings

from kallithea.lib.vcs.exceptions import (

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

from kallithea.lib.vcs.utils import ascii_str, date_fromtimestamp, makedate, safe_str, safe_unicode

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

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

from .changeset import GitChangeset

from .inmemory import GitInMemoryChangeset

from .workdir import GitWorkdir

            return True

        if '+' in url[:url.find('://')]:

            url = url[url.find('+') + 1:]

        handlers = []

        test_uri, authinfo = url_obj.authinfo()

        if not test_uri.endswith('info/refs'):

            test_uri = test_uri.rstrip('/') + '/info/refs'

        url_obj.passwd = b'*****'

        cleaned_uri = str(url_obj)

        if authinfo:

            # create a password manager

            passmgr = urllib2.HTTPPasswordMgrWithDefaultRealm()

            passmgr.add_password(*authinfo)

        o = urllib2.build_opener(*handlers)

        o.addheaders = [('User-Agent', 'git/1.7.8.0')]  # fake some git

        q = {"service": 'git-upload-pack'}

        qs = '?%s' % urllib.urlencode(q)

    Mercurial backend implementation.

    :created_on: Apr 8, 2010

    :copyright: (c) 2010-2011 by Marcin Kuzminski, Lukasz Balcerzak.

"""

from .changeset import MercurialChangeset

from .inmemory import MercurialInMemoryChangeset

from .repository import MercurialRepository

from .workdir import MercurialWorkdir

__all__ = [

    'MercurialRepository', 'MercurialChangeset',

    'MercurialInMemoryChangeset', 'MercurialWorkdir',

]

import os

import posixpath

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

from kallithea.lib.vcs.conf import settings

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 import ascii_bytes, ascii_str, date_fromtimestamp, safe_str, safe_unicode

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

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

class MercurialChangeset(BaseChangeset):

    """

            return 'Secret'

        else:

            return ''

    @LazyProperty

    def successors(self):

        if successors:

            # flatten the list here handles both divergent (len > 1)

            # and the usual case (len = 1)

        return successors

    @LazyProperty

    def predecessors(self):

    @LazyProperty

    def bookmarks(self):

        return [safe_unicode(bookmark) for bookmark in self._ctx.bookmarks()]

    @LazyProperty

        """

        fctx = self._get_filectx(path)

        hist = []

        cnt = 0

        for cs in reversed([x for x in fctx.filelog()]):

            cnt += 1

            if limit is not None and cnt == limit:

                break

        return [self.repository.get_changeset(node) for node in hist]

    def get_file_annotate(self, path):

            prefix = '%s-%s' % (self.repository.name, self.short_id)

        elif prefix.startswith('/'):

            raise VCSError("Prefix cannot start with leading slash")

        elif prefix.strip() == '':

            raise VCSError("Prefix cannot be empty")

                         kind, prefix=prefix, subrepos=subrepos)

    def get_nodes(self, path):

        """

        Returns combined ``DirNode`` and ``FileNode`` objects list representing

        state of changeset at the given ``path``. If node at the given ``path``

import datetime

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

from kallithea.lib.vcs.exceptions import RepositoryError

from kallithea.lib.vcs.utils import ascii_str, safe_bytes

class MercurialInMemoryChangeset(BaseInMemoryChangeset):

    def commit(self, message, author, parents=None, branch=None, date=None,

            **kwargs):

            if path in (node.path for node in self.removed):

                return None

            # check if this path is added

            for node in self.added:

                if node.path == path:

                        data=node.content,

                        islink=False,

                        isexec=node.is_executable,

                        copysource=False)

            # or changed

            for node in self.changed:

                if node.path == path:

                        data=node.content,

                        islink=False,

                        isexec=node.is_executable,

                        copysource=False)

            raise RepositoryError("Given path haven't been marked as added,"

            if parent is not None:

                parents[i] = parent._ctx.node()

        if date and isinstance(date, datetime.datetime):

            date = date.strftime('%a, %d %b %Y %H:%M:%S')

            parents=parents,

            text=b'',

            files=self.get_paths(),

            filectxfn=filectxfn,

            user=author,

            date=date,

        n = self.repository._repo.commitctx(commit_ctx)

        # Returns mercurial node

        self._commit_ctx = commit_ctx  # For reference

        # Update vcs repository object & recreate mercurial _repo

        # new_ctx = self.repository._repo[node]

        # new_tip = ascii_str(self.repository.get_changeset(new_ctx.hex()))

        self._repo = self.repository._get_repo(create=False)

        self.repository.branches = self.repository._get_branches()

        tip = self.repository.get_changeset()

        self.reset()

        return tip

import os

import time

import urllib

import urllib2

from collections import OrderedDict

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 import ascii_str, author_email, author_name, date_fromtimestamp, makedate, safe_bytes, safe_str, safe_unicode

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

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

from .changeset import MercurialChangeset

from .inmemory import MercurialInMemoryChangeset

from .workdir import MercurialWorkdir

        if not isinstance(repo_path, str):

            raise VCSError('Mercurial backend requires repository path to '

                           'be instance of <str> got %s instead' %

                           type(repo_path))

        self.path = abspath(repo_path)

        # We've set path and ui, now we can set _repo itself

        self._repo = self._get_repo(create, src_url, update_after_clone)

    @property

    def _empty(self):

        """

            return {}

        bt = OrderedDict()

        for bn, _heads, node, isclosed in sorted(self._repo.branchmap().iterbranches()):

            if isclosed:

                if closed:

            else:

                if normal:

        return bt

    @LazyProperty

    def tags(self):

        """

        Gets tags for this repository

    def _get_tags(self):

        if self._empty:

            return {}

        return OrderedDict(sorted(

            reverse=True,

            key=lambda x: x[0],  # sort by name

        ))

    def tag(self, name, user, revision=None, message=None, date=None,

            **kwargs):

                changeset.short_id)

        if date is None:

            date = datetime.datetime.now().strftime('%a, %d %b %Y %H:%M:%S')

        try:

            raise RepositoryError(e.message)

        # Reinitialize tags

        self.tags = self._get_tags()

        tag_id = self.tags[name]

            message = "Removed tag %s" % name

        if date is None:

            date = datetime.datetime.now().strftime('%a, %d %b %Y %H:%M:%S')

        local = False

        try:

            self.tags = self._get_tags()

            raise RepositoryError(e.message)

    @LazyProperty

    def bookmarks(self):

        """

        Gets bookmarks for this repository

        # Check if given revisions are present at repository (may raise

        # ChangesetDoesNotExistError)

        if rev1 != self.EMPTY_CHANGESET:

            self.get_changeset(rev1)

        self.get_changeset(rev2)

        if path:

        else:

            file_filter = None

                                        showfunc=True,

                                        ignorews=ignore_whitespace,

                                        context=context)))

    @classmethod

    def _check_url(cls, url, repoui=None):

        if os.path.isdir(url) or url.startswith(b'file:'):

            return True

        if url.startswith(b'ssh:'):

            # in case of invalid uri or authentication issues, sshpeer will

            # throw an exception.

            return True

        url_prefix = None

        if b'+' in url[:url.find(b'://')]:

            url_prefix, url = url.split(b'+', 1)

        handlers = []

        test_uri, authinfo = url_obj.authinfo()

        url_obj.passwd = b'*****'

        cleaned_uri = str(url_obj)

        if authinfo:

            # create a password manager

            passmgr = urllib2.HTTPPasswordMgrWithDefaultRealm()

            passmgr.add_password(*authinfo)

        o = urllib2.build_opener(*handlers)

        o.addheaders = [('Content-Type', 'application/mercurial-0.1'),

                        ('Accept', 'application/mercurial-0.1')]

        q = {"cmd": 'between'}

            # means it cannot be cloned

            raise urllib2.URLError("[%s] org_exc: %s" % (cleaned_uri, e))

        if not url_prefix: # skip svn+http://... (and git+... too)

            # now check if it's a proper hg repo

            try:

            except Exception as e:

                raise urllib2.URLError(

                    "url [%s] does not look like an hg repo org_exc: %s"

                    % (cleaned_uri, e))

        return True

            if src_url:

                url = safe_bytes(self._get_url(src_url))

                opts = {}

                if not update_after_clone:

                    opts.update({'noupdate': True})

                MercurialRepository._check_url(url, self.baseui)

                # Don't try to create if we've already cloned repo

                create = False

            if create:

                msg = "Cannot create repository at %s. Original error was %s" \

                    % (self.path, err)

            else:

                msg = "Not valid repository at %s. Original error was %s" \

                    % (self.path, err)

    def description(self):

        _desc = self._repo.ui.config(b'web', b'description', None, untrusted=True)

        return safe_unicode(_desc or b'unknown')

    @LazyProperty

    def contact(self):

                            or b'Unknown')

    @LazyProperty

    def last_change(self):

        """

        Returns last change made on this repository as datetime object

        elif isinstance(revision, unicode):

            revision = safe_bytes(revision)

        try:

            if isinstance(revision, int):

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

            msg = ("Revision %s does not exist for %s" % (revision, self))

            raise ChangesetDoesNotExistError(msg)

        except (LookupError, ):

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

            raise ChangesetDoesNotExistError(msg)

        rev_spec = "%%s & %s(%%s)" % _revset_predicates[ref_type]

        try:

            revs = self._repo.revs(rev_spec, ref_name, ref_name)

        except LookupError:

            msg = ("Ambiguous identifier %s:%s for %s" % (ref_type, ref_name, self.name))

            raise ChangesetDoesNotExistError(msg)

            msg = ("Revision %s:%s does not exist for %s" % (ref_type, ref_name, self.name))

            raise ChangesetDoesNotExistError(msg)

        if revs:

            revision = revs.last()

        else:

            # TODO: just report 'not found'?

            if filter_:

                revspec = b' and '.join(filter_)

            else:

                revspec = b'all()'

            if max_revisions:

                revspec = b'limit(%s, %d)' % (revspec, max_revisions)

        else:

            revisions = self.revisions

        # this is very much a hack to turn this into a list; a better solution

        # would be to get rid of this function entirely and use revsets

        revs = list(revisions)[start_pos:end_pos]

    def pull(self, url):

        """

        Tries to pull changes from external location.

        """

        url = self._get_url(url)

        try:

            # Propagate error but with vcs's type

            raise RepositoryError(str(err))

    @LazyProperty

    def workdir(self):

        """

            config_file = []

        elif isinstance(config_file, basestring):

            config_file = [config_file]

        config = self._repo.ui

        if config_file:

            for path in config_file:

                config.readconfig(path)

        return config.config(section, name)

    def get_user_name(self, config_file=None):

        """

#

# You should have received a copy of the GNU General Public License

# along with this program.  If not, see <http://www.gnu.org/licenses/>.

import logging

from kallithea.lib.utils import make_ui

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

from kallithea.lib.vcs.utils import safe_bytes, safe_unicode

        # Note: we want a repo with config based on .hg/hgrc and can thus not use self.db_repo.scm_instance._repo.ui

        baseui = make_ui(repo_path=self.db_repo.repo_full_path)

        if not self.allow_push:

            baseui.setconfig(b'hooks', b'pretxnopen._ssh_reject', b'python:kallithea.lib.hooks.rejectpush')

            baseui.setconfig(b'hooks', b'prepushkey._ssh_reject', b'python:kallithea.lib.hooks.rejectpush')

        log.debug("Starting Mercurial sshserver for %s", self.db_repo.repo_full_path)

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

from kallithea.lib.vcs.exceptions import BranchDoesNotExistError

from kallithea.lib.vcs.utils import ascii_bytes, ascii_str

class MercurialWorkdir(BaseWorkdir):

    def get_branch(self):

        return self.repository._repo.dirstate.branch()

        if branch is None:

            branch = self.repository.DEFAULT_BRANCH_NAME

        if branch not in self.repository.branches:

            raise BranchDoesNotExistError

        raw_id = self.repository.branches[branch]

"""

Mercurial libs compatibility

"""