# All configuration values have a default; values that are commented out

# serve to show the default.

import os

import sys

# If extensions (or modules to document with autodoc) are in another directory,

# add these directories to sys.path here. If the directory is relative to the

# documentation root, use os.path.abspath to make it absolute, like shown here.

sys.path.insert(0, os.path.abspath('..'))

# |version| and |release|, also used in various other places throughout the

# built documents.

#

# The short X.Y version.

root = os.path.dirname(os.path.dirname(__file__))

sys.path.append(root)

# The full version, including alpha/beta/rc tags.

# The language for content autogenerated by Sphinx. Refer to documentation

# for a list of supported languages.

#language = None

# There are two options for replacing |today|: either, you set today to some

import paste.httpheaders

import webob.exc

from tg import TGController, config, render_template, request, response, session

from tg import tmpl_context as c

from tg.i18n import ugettext as _

from kallithea.config.routing import url

from kallithea.lib import auth_modules, ext_json

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.utils2 import AttributeDict, asbool, ascii_bytes, safe_int, safe_str, set_hook_environment

            from kallithea.lib import helpers as h

            token = request.POST.get(h.session_csrf_secret_name)

            if not token or token != h.session_csrf_secret_token():

                log.error('CSRF check failed')

                raise webob.exc.HTTPForbidden()

        rc_config = Setting.get_app_settings()

        # Visual options

        c.visual = AttributeDict({})

        ## DB stored

        c.instance_id = config.get('instance_id')

        c.issues_url = config.get('bugtracker', url('issues_url'))

        # END CONFIG VARS

        c.repo_name = get_repo_slug(request)  # can be empty

        self.cut_off_limit = safe_int(config.get('cut_off_limit'))

        c.my_pr_count = PullRequest.query(reviewer_id=request.authuser.user_id, include_closed=False).count()

        self.scm_model = ScmModel()

import os

import sys

import time

import mercurial.scmutil

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.utils2 import HookEnvironmentError, ascii_str, get_hook_environment, safe_bytes, safe_str

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

from kallithea.model.db import Repository, User

    ex = get_hook_environment()

    user = User.get_by_username(ex.username)

    action = 'pull'

    action_logger(user, action, ex.repository, ex.ip, commit=True)

    # extension hook call

    if callable(callback):

        kw = {}

        kw.update(ex)

        callback(**kw)

    action_logger(ex.username, action, ex.repository, ex.ip, commit=True)

    from kallithea.model.scm import ScmModel

    ScmModel().mark_for_invalidation(ex.repository)

    # extension hook call

    if callable(callback):

        kw = {'pushed_revs': revs}

        kw.update(ex)

        callback(**kw)

     'clone_uri',

     'fork_id',

     'group_id',

     'repo_name'

    """

    if callable(callback):

        kw = {}

        kw.update(repository_dict)

        kw.update({'created_by': created_by})

        kw.update(kwargs)

        callback(**kw)

def check_allowed_create_user(user_dict, created_by, **kwargs):

    # pre create hooks

    if callable(callback):

        allowed, reason = callback(created_by=created_by, **user_dict)

        if not allowed:

            raise UserCreationError(reason)

     'full_name',

     'active',

     'password',

     'emails',

    """

    if callable(callback):

        callback(created_by=created_by, **user_dict)

def log_create_pullrequest(pullrequest_dict, created_by, **kwargs):

    """

    Post create pull request hook.

    :param pullrequest_dict: dict dump of pull request object

    """

    if callable(callback):

        return callback(created_by=created_by, **pullrequest_dict)

    return 0

def log_delete_repository(repository_dict, deleted_by, **kwargs):

     'clone_uri',

     'fork_id',

     'group_id',

     'repo_name'

    """

    if callable(callback):

        kw = {}

        kw.update(repository_dict)

        kw.update({'deleted_by': deleted_by,

                   'deleted_on': time.time()})

        kw.update(kwargs)

     'full_name',

     'active',

     'password',

     'emails',

    """

    if callable(callback):

        callback(deleted_by=deleted_by, **user_dict)

def _hook_environment(repo_path):

    """

import urlobject

from tg.i18n import ugettext as _

from tg.i18n import ungettext

from tg.support.converters import asbool, aslist

from webhelpers2.text import collapse, remove_formatting, strip_tags

from kallithea.lib.vcs.utils import ascii_bytes, ascii_str, safe_bytes, safe_str  # re-export

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

try:

    import pwd

    Most importantly, this allow Git hooks to do proper logging and updating of

    caches after pushes.

    Must always be called before anything with hooks are invoked.

    """

    extras = {

        'ip': ip_addr, # used in log_push/pull_action action_logger

        'username': username,

        'action': action or 'push_local', # used in log_push_action_raw_ids action_logger

        'repository': repo_name,

        'scm': repo_alias, # used to pick hack in log_push_action_raw_ids

    }

    os.environ['KALLITHEA_EXTRAS'] = json.dumps(extras)

def get_current_authuser():

    """

import logging

import formencode

from formencode import All

from tg.i18n import ugettext as _

from kallithea.model import validators as v

log = logging.getLogger(__name__)

        chained_validators = [v.ValidPasswordsMatch('password',

                                                    'password_confirm')]

    return _PasswordResetConfirmationForm

             repo_groups=None, landing_revs=None):

    old_data = old_data or {}

    repo_groups = repo_groups or []

    landing_revs = landing_revs or []

    repo_group_ids = [rg[0] for rg in repo_groups]

        new_field_label = v.UnicodeString(not_empty=False)

        new_field_desc = v.UnicodeString(not_empty=False)

    return _RepoFieldForm

                 repo_groups=None, landing_revs=None):

    old_data = old_data or {}

    repo_groups = repo_groups or []

    landing_revs = landing_revs or []

    repo_group_ids = [rg[0] for rg in repo_groups]

        fork_repo_perm = v.StringBoolean(if_missing=False)

    return _CustomDefaultPermissionsForm

    class _DefaultsForm(formencode.Schema):

        allow_extra_fields = True

        filter_extra_fields = True

        default_repo_type = v.OneOf(supported_backends)

        default_repo_private = v.StringBoolean(if_missing=False)

        default_repo_enable_statistics = v.StringBoolean(if_missing=False)

import traceback

import pkg_resources

from tg.i18n import ugettext as _

import kallithea

from kallithea.lib.auth import HasPermissionAny, HasRepoGroupPermissionLevel, HasRepoPermissionLevel, HasUserGroupPermissionLevel

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.utils2 import safe_bytes, set_hook_environment

from kallithea.lib.vcs import get_backend

                    raise RepositoryError('Duplicate repository name %s '

                                          'found in %s' % (name, path))

                else:

                    klass = get_backend(path[0])

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

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

            except OSError:

                continue

        log.debug('found %s paths with repositories', len(repos))

        return repos