from kallithea.lib.auth import LoginRequired

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

from kallithea.lib.page import Page

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

from kallithea.model.db import Gist

from kallithea.model.forms import GistForm

            raise HTTPNotFound()

        if format == 'raw':

            content = '\n\n'.join(

                for f in c.files if (f_path is None or f.path == f_path)

            )

            response.content_type = 'text/plain'

from kallithea.lib.celerylib import tasks

from kallithea.lib.exceptions import HgsubversionImportError

from kallithea.lib.utils import repo2db_mapper, set_app_settings

from kallithea.lib.vcs import VCSError

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

from kallithea.model.forms import ApplicationSettingsForm, ApplicationUiSettingsForm, ApplicationVisualisationForm

                                            user=request.authuser.username,

                                            overwrite_git_hooks=overwrite_git_hooks)

            added_msg = h.HTML(', ').join(

            ) or '-'

            removed_msg = h.HTML(', ').join(

            ) or '-'

            h.flash(h.HTML(_('Repositories successfully rescanned. Added: %s. Removed: %s.')) %

                    (added_msg, removed_msg), category='success')

from kallithea.lib.base import BaseController, render

from kallithea.lib.exceptions import RepoGroupAssignmentError, UserGroupsAssignedException

from kallithea.lib.utils import action_logger

from kallithea.model.db import User, UserGroup, UserGroupRepoGroupToPerm, UserGroupRepoToPerm, UserGroupToPerm

from kallithea.model.forms import CustomDefaultPermissionsForm, UserGroupForm, UserGroupPermsForm

from kallithea.model.meta import Session

        c.active = 'settings'

        self.__load_data(id)

        users_group_form = UserGroupForm(edit=True,

                                         old_data=c.user_group.get_dict(),

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

from kallithea.lib.graphmod import graph_data

from kallithea.lib.utils import action_logger

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

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

from kallithea.model.changeset_status import ChangesetStatusModel

            return raw_diff

        elif method == 'patch':

            response.content_type = 'text/plain'

            return render('changeset/patch_changeset.html')

        elif method == 'raw':

            response.content_type = 'text/plain'

from kallithea.lib.auth import HasRepoPermissionLevelDecorator, LoginRequired

from kallithea.lib.base import BaseRepoController

from kallithea.lib.diffs import DiffProcessor

log = logging.getLogger(__name__)

        desc_msg.extend(changes)

        if str2bool(CONFIG.get('rss_include_diff', False)):

            desc_msg.append('\n\n')

        desc_msg.append('</pre>')

        return desc_msg

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 (

        c.f_path = f_path

        if r_post:

            sl = old_content.splitlines(1)

            first_line = sl[0] if sl else ''

            # modes:  0 - Unix, 1 - Mac, 2 - DOS

from kallithea.lib.celerylib.tasks import get_commits_stats

from kallithea.lib.markup_renderer import MarkupRenderer

from kallithea.lib.page import Page

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

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

from kallithea.lib.vcs.nodes import FileNode

                        readme_file = f

                        log.debug('Found README file `%s` rendering...',

                                  readme_file)

                                                      filename=f)

                        break

                    except NodeDoesNotExistError:

from kallithea.lib.vcs.exceptions import VCSError

from kallithea.lib.vcs.nodes import FileNode

def annotate_highlight(filenode, annotate_from_changeset_func,

        annotate_from_changeset_func=annotate_from_changeset_func, order=order,

        headers=headers, **options)

    lexer = get_custom_lexer(filenode.extension) or filenode.lexer

    return highlighted

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

    org_req = environ.get('tg.original_request')

    if org_req is not None:

        environ = org_req.environ

def log_in_user(user, remember, is_external_auth, ip_addr):

from tg.i18n import ugettext as _

from kallithea.lib import helpers as h

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

from kallithea.lib.vcs.exceptions import VCSError

from kallithea.lib.vcs.nodes import FileNode, SubModuleNode

            return ' <i></i>'

        assert False

_git_header_re = re.compile(br"""

from kallithea.lib.pygmentsutils import get_custom_lexer

from kallithea.lib.utils2 import MENTIONS_REGEX, AttributeDict

from kallithea.lib.utils2 import age as _age

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

from kallithea.lib.vcs.exceptions import ChangesetDoesNotExistError

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

    """

    lexer = get_custom_lexer(filenode.extension) or filenode.lexer

    return literal(markup_whitespace(

def hsv_to_rgb(h, s, v):

    Render plain text with revision hashes and issue references urlified

    and with @mention highlighting.

    """

    s = urlify_text(s, repo_name=repo_name)

    return literal('<div class="formatted-fixed">%s</div>' % s)

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

                u_content = u''

            else:

                log.debug('    >> %s', path)

                indexed_w_content += 1

        else:

import bleach

import markdown as markdown_mod

log = logging.getLogger(__name__)

    @classmethod

    def plain(cls, source, universal_newline=True):

        if universal_newline:

            newline = '\n'

            source = newline.join(source.splitlines())

        </pre></div>

        </td></tr></table>

        """

        try:

            if flavored:

                source = cls._flavored_markdown(source)

    @classmethod

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

        try:

            from docutils.core import publish_parts

            from docutils.parsers.rst import directives

from kallithea.lib.utils import fix_repo_id_name

class PermanentRepoUrl(object):

    def __call__(self, environ, start_response):

        # Extract path_info as get_path_info does, but do it explicitly because

        # we also have to do the reverse operation when patching it back in

        if path_info.startswith('/'): # it must

            path_info = '/' + fix_repo_id_name(path_info[1:])

            environ['PATH_INFO'] = safe_bytes(path_info)

from tg.i18n import ungettext

from webhelpers2.text import collapse, remove_formatting, strip_tags

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

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

    @LazyProperty

    def message(self):

    @LazyProperty

    def committer(self):

    @LazyProperty

    def author(self):

    @LazyProperty

    def date(self):

        heads = self.repository._heads(reverse=False)

        ref = heads.get(self._commit.id)

        if ref:

    @LazyProperty

    def branches(self):

        repo = self.repository._repo

        object_store = repo.object_store

        # Create tree and populates it with blobs

        commit_tree = self.parents[0] and repo[self.parents[0]._commit.tree] or \

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

        if os.path.isdir(self.path):

            cwd = self.path

        stdout, _stderr = self._run_git_command(cmd, cwd=cwd)

    @classmethod

    def _check_url(cls, url):

    @LazyProperty

    def description(self):

    @LazyProperty

    def contact(self):

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

    @LazyProperty

    def tags(self):

    @LazyProperty

    def branch(self):

    @LazyProperty

    def branches(self):

    @LazyProperty

    def closesbranch(self):

    @LazyProperty

    def bookmarks(self):

    @LazyProperty

    def message(self):

    @LazyProperty

    def committer(self):

    @LazyProperty

    def author(self):

    @LazyProperty

    def date(self):

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

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

            if isclosed:

                if closed:

            else:

                if normal:

        return bt

    @LazyProperty

            return {}

        return OrderedDict(sorted(

            reverse=True,

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

        ))

            return {}

        return OrderedDict(sorted(

            reverse=True,

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

        ))

    @LazyProperty

    def description(self):

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

    @LazyProperty

    def contact(self):

                            or b'Unknown')

    @LazyProperty

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

            return ascii_str(mercurial.scmutil.revsymbol(self._repo, revision).hex())

        except (IndexError, ValueError, mercurial.error.RepoLookupError, TypeError):

            raise ChangesetDoesNotExistError(msg)

        except (LookupError, ):

            raise ChangesetDoesNotExistError(msg)

    def get_ref_revision(self, ref_type, ref_name):

if os.path.isdir(VCSRC_PATH):

    VCSRC_PATH = os.path.join(VCSRC_PATH, '__init__.py')

DEFAULT_ENCODINGS = aslist('utf-8')

# path to git executable run by run_git_command function

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

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

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

        """

        from pygments import lexers

        try:

        except lexers.ClassNotFound:

            lexer = lexers.TextLexer(stripnl=False)

        # returns first alias

    return val

    """

    Safe unicode str function. Use a few tricks to turn s into str:

    In case of UnicodeDecodeError with configured default encodings, try to

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

def ascii_bytes(s):

    """

    Simple conversion from str to bytes, *assuming* all codepoints are

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

    SETTINGS_TYPES = {

        'str': safe_bytes,

        'int': safe_int,

        'bool': str2bool,

        'list': functools.partial(aslist, sep=',')

    }

        :param val:

        """

    @hybrid_property

    def app_settings_type(self):

                    </div>

                    <div class="panel-body no-padding">

                        <div id="editor_container">

                        </div>

                    </div>

                </div>

                    </span>

              </div>

              <div class="panel-body no-padding">

              </div>

            </div>

            <div>