from pygments import highlight

from pygments.formatters import HtmlFormatter

from kallithea.lib.vcs.exceptions import VCSError

from kallithea.lib.vcs.nodes import FileNode

from kallithea.lib.vcs.utils import safe_str

    :param headers: dictionary with headers (keys are whats in ``order``

      parameter)

    """

    options['linenos'] = True

    formatter = AnnotateHtmlFormatter(filenode=filenode,

        annotate_from_changeset_func=annotate_from_changeset_func, order=order,

import importlib

import logging

import traceback

from kallithea.lib.auth import AuthUser, PasswordGenerator

from kallithea.lib.compat import hybrid_property

from kallithea.lib.utils2 import asbool

from kallithea.model.db import Setting, User

from kallithea.model.meta import Session

from kallithea.model.user import UserModel

        self.kwargs = kwargs

    def __call__(self, *args, **kwargs):

        formencode_obj = self.formencode_obj

        if isfunction(formencode_obj):

            # case we wrap validators into functions

                self.validator_name = name

            def __call__(self, *args, **kwargs):

                #log.debug('Initializing lazy formencode object: %s', obj)

                return LazyFormencode(obj, *args, **kwargs)

import logging

from kallithea.lib.compat import hybrid_property

        }

        log.debug('user data: %s', user_data)

        password_match = auth.check_password(password, userobj.password)

        if userobj.is_default_user:

            log.info('user %s authenticated correctly as anonymous user',

from tg import config

import kallithea

from kallithea.lib import celerylib, ext_json

from kallithea.lib.helpers import person

from kallithea.lib.hooks import log_create_repository

from kallithea.lib.rcmail.smtp_mailer import SmtpMailer

from kallithea.lib.utils import action_logger

from kallithea.lib.utils2 import asbool, ascii_bytes

from kallithea.lib.vcs.utils import author_email

__all__ = ['whoosh_index', 'get_commits_stats', 'send_email']

@celerylib.locked_task

@celerylib.dbsession

def whoosh_index(repo_location, full_index):

    celerylib.get_session() # initialize database connection

    index_location = config['index_dir']

@celerylib.task

@celerylib.dbsession

def create_repo(form_data, cur_user):

    DBS = celerylib.get_session()

    cur_user = User.guess_instance(cur_user)

    :param form_data:

    :param cur_user:

    """

    DBS = celerylib.get_session()

    base_path = kallithea.CONFIG['base_path']

def __get_codes_stats(repo_name):

    repo = Repository.get_by_repo_name(repo_name).scm_instance

    tip = repo.get_changeset()

    for _topnode, _dirnodes, filenodes in tip.walk('/'):

        for filenode in filenodes:

            ext = filenode.extension.lower()

                if ext in code_stats:

                    code_stats[ext] += 1

                else:

import sqlalchemy

from sqlalchemy.engine import create_engine

from kallithea.model.base import init_model

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

from kallithea.model.meta import Base, Session

        force_ask = self.cli_args.get('force_ask')

        if force_ask is not None:

            return force_ask

        return ask_ok(msg)

    def init_db(self, SESSION=None):

from beaker.cache import cache_region

from pygments import highlight as code_highlight

from pygments.formatters.html import HtmlFormatter

from tg.i18n import ugettext as _

from webhelpers2.html import HTML, escape, literal

from webhelpers2.html.tags import NotGiven, Option, Options, _input, _make_safe_id_component, checkbox, end_form

# PERMS

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

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

from kallithea.lib.markup_renderer import url_re

from kallithea.lib.pygmentsutils import get_custom_lexer

from kallithea.lib.utils2 import MENTIONS_REGEX, AttributeDict

# SCM FILTERS available via h.

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

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

# mute pyflakes "imported but unused"

    """Manage a message queue in tg.session: return the current message queue

    after appending the given message, and possibly clearing the queue."""

    key = 'flash'

    if key in session:

        flash_messages = session[key]

    else:

    - or return None if user not found"""

    email = author_email(author)

    if email:

        user = User.get_by_email(email)

        if user is not None:

            return getattr(user, show_attr)

def person(author, show_attr="username"):

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

    default to the username attribute, None if there is no 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"):

    # maybe it's an ID ?

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

        id_ = int(id_)

        return group_name

    def get_pull_request():

        pull_request_id = action_params

        nice_id = PullRequest.make_nice_id(pull_request_id)

    if email_address == _def:

        return default

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

    return (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

    """Urlify issue references according to .ini configuration"""

    global _urlify_issues_f

    if _urlify_issues_f is None:

        assert kallithea.CONFIG['sqlalchemy.url'] # make sure config has been loaded

        # Build chain of urlify functions, starting with not doing any transformation

def changeset_status(repo, revision):

    return ChangesetStatusModel().get_status(repo, revision)

def changeset_status_lbl(changeset_status):

    return ChangesetStatus.get_status_lbl(changeset_status)

def get_permission_name(key):

    return dict(Permission.PERMS).get(key)

def ip_range(ip_addr):

    s, e = UserIpMap._get_ip_range(ip_addr)

    return '%s - %s' % (s, e)

def session_csrf_secret_token():

    """Return (and create) the current session's CSRF protection token."""

    if not session_csrf_secret_name in session:

        session[session_csrf_secret_name] = str(random.getrandbits(128))

        session.save()

"""

import logging

import re

import traceback

import bleach

import markdown as markdown_mod

from kallithea.lib.utils2 import MENTIONS_REGEX, safe_str

        :param text:

        """

        # Extract pre blocks.

        extractions = {}

        def pre_extraction_callback(matchobj):

            extractions[digest] = matchobj.group(0)

            return "{gfm-extraction-%s}" % digest

        pattern = re.compile(r'<pre>.*?</pre>', re.MULTILINE | re.DOTALL)

    def rst(cls, source, safe=True):

        source = safe_str(source)

        try:

            docutils_settings = dict([(alias, None) for alias in

                                cls.RESTRUCTUREDTEXT_DISALLOWED_DIRECTIVES])

                                  settings_overrides=docutils_settings)

            return parts['html_title'] + parts["fragment"]

        except Exception:

            log.error(traceback.format_exc())

            if safe:

from pygments import lexers

def get_extension_descriptions():

    """

    returns a custom lexer if it's defined in the extensions module, or None

    if there's no custom lexer defined

    """

    lexer_name = getattr(kallithea.EXTENSIONS, 'EXTRA_LEXERS', {}).get(extension)

    if lexer_name is None:

        return None

import urllib.parse

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

import kallithea

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

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

    if future:

        prevdate = prevdate.replace(microsecond=0)

    # Get date parts deltas

    for part in order:

        d = relativedelta.relativedelta(now, prevdate)

        deltas[part] = getattr(d, part + 's')

    :param repo:

    :param rev:

    """

    if not isinstance(repo, BaseRepository):

        raise Exception('You must pass an Repository '

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

def obfuscate_url_pw(engine):

    try:

        _url = sa_url.make_url(engine or '')

    except ArgumentError:

import datetime

import itertools

from kallithea.lib.vcs.conf import settings

from kallithea.lib.vcs.exceptions import (ChangesetError, EmptyRepositoryError, NodeAlreadyAddedError, NodeAlreadyChangedError, NodeAlreadyExistsError,

                                          NodeAlreadyRemovedError, NodeDoesNotExistError, NodeNotChangedError, RepositoryError)

    @LazyProperty

    def branch(self):

        return get_backend(self.alias).DEFAULT_BRANCH_NAME

    @LazyProperty

    def branches(self):

        return [get_backend(self.alias).DEFAULT_BRANCH_NAME]

    @LazyProperty

import posixpath

import stat

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

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

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

                encoding = None

                # try with pygments

                try:

                    mt = lexers.get_lexer_for_filename(self.name).mimetypes

                except lexers.ClassNotFound:

        Returns pygment's lexer class. Would try to guess lexer taking file's

        content, name and mimetype.

        """

        try:

            lexer = lexers.guess_lexer_for_filename(self.name, safe_str(self.content), stripnl=False)

        except lexers.ClassNotFound:

import re

import time

def makedate():

    lt = time.localtime()

    if not isinstance(s, bytes):  # use __str__ and don't expect UnicodeDecodeError

        return str(s)

    for enc in settings.DEFAULT_ENCODINGS:

        try:

            return str(s, enc)

            pass

    try:

        encoding = chardet.detect(s)['encoding']

        if encoding is not None:

            return s.decode(encoding)

        pass

    return str(s, settings.DEFAULT_ENCODINGS[0], 'replace')

    assert isinstance(s, str), repr(s)  # bytes cannot coerse with __str__ or handle None or int

    for enc in settings.DEFAULT_ENCODINGS:

        try:

            return s.encode(enc)

"""

import datetime

import os

import re

import time

import urllib.request

import mercurial.url

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

from kallithea.lib.vcs.utils import safe_str

    then returned output is colored. Otherwise

    unchanged content is returned.

    """

    try:

        lexer = guess_lexer_for_filename(name, code)

        formatter = TerminalFormatter()