import sys

import platform

VERSION = (0, 3, 99)

BACKENDS = {

    'hg': 'Mercurial repository',

refer to the routes manual at http://routes.groovie.org/docs/

"""

from routes import Mapper

# prefix for non repository related links needs to be prefixed with `/`

import logging

from sqlalchemy.orm import joinedload

from whoosh.qparser.default import QueryParser

from whoosh.qparser.dateparse import DateParserPlugin

import formencode.htmlfill

import traceback

from webob.exc import HTTPFound

from kallithea.config.routing import url

import formencode

from formencode import htmlfill

from webob.exc import HTTPFound

from kallithea.config.routing import url

import traceback

import formencode.htmlfill

from webob.exc import HTTPFound, HTTPNotFound, HTTPForbidden

from kallithea.config.routing import url

from sqlalchemy import func

from formencode import htmlfill

from webob.exc import HTTPFound

from kallithea.config.routing import url

import logging

import traceback

from webob.exc import HTTPBadRequest, HTTPForbidden

from kallithea.model.db import Notification

import formencode

from formencode import htmlfill

from webob.exc import HTTPFound

from kallithea.config.routing import url

from formencode import htmlfill

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

import kallithea

import traceback

import formencode

from formencode import htmlfill

from sqlalchemy.sql.expression import func

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

import formencode

from formencode import htmlfill

from webob.exc import HTTPFound

from kallithea.config.routing import url

import formencode

from formencode import htmlfill

from webob.exc import HTTPFound

from sqlalchemy.orm import joinedload

import formencode

from formencode import htmlfill

from sqlalchemy.sql.expression import func

from webob.exc import HTTPFound, HTTPNotFound

from paste.response import replace_header

from pylons.controllers import WSGIController

from pylons.controllers.util import Response

from webob.exc import HTTPError

import logging

from sqlalchemy import or_

from kallithea.controllers.api import JSONRPCController, JSONRPCError

from kallithea.lib.auth import (

import logging

import traceback

from webob.exc import HTTPFound, HTTPNotFound, HTTPBadRequest

import kallithea.lib.helpers as h

import traceback

from collections import defaultdict

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

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

import logging

import re

from webob.exc import HTTPFound, HTTPBadRequest, HTTPNotFound

from kallithea.config.routing import url

import cgi

import logging

from pylons.middleware import media_path

from kallithea.lib.base import BaseController, render

import logging

from beaker.cache import cache_region, region_invalidate

from webhelpers.feedgenerator import Atom1Feed, Rss201rev2Feed

import tempfile

import shutil

from webob.exc import HTTPFound

from kallithea.config.routing import url

import logging

from kallithea.lib.auth import LoginRequired, HasRepoPermissionLevelDecorator

from kallithea.lib.base import BaseRepoController, render

import traceback

from formencode import htmlfill

from webob.exc import HTTPFound

import kallithea.lib.helpers as h

import logging

from webob.exc import HTTPBadRequest

from sqlalchemy.sql.expression import func

from webhelpers.feedgenerator import Atom1Feed, Rss201rev2Feed

from webob.exc import HTTPBadRequest

from kallithea.config.routing import url

from kallithea.controllers.admin.admin import _journal_filter

import formencode

from formencode import htmlfill

from webob.exc import HTTPFound, HTTPBadRequest

import kallithea.lib.helpers as h

import traceback

import formencode

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

from kallithea.config.routing import url

import logging

import traceback

import urllib

from whoosh.index import open_dir, EmptyIndexError

from whoosh.qparser import QueryParser, QueryParserError

from time import mktime

from datetime import timedelta, date

from webob.exc import HTTPBadRequest

from beaker.cache import cache_region, region_invalidate

from decorator import decorator

from webhelpers.pylonslib import secure_form

from sqlalchemy.orm.exc import ObjectDeletedError

from sqlalchemy.orm import joinedload

import paste.httpheaders

from webhelpers.pylonslib import secure_form

from pylons.controllers import WSGIController

from pylons.templating import render_mako as render  # don't remove this import

from kallithea import __version__, BACKENDS

import os

import logging

from hashlib import md5

from decorator import decorator

from operator import itemgetter

from string import lower

from kallithea import CELERY_ON

from kallithea.lib import celerylib

import warnings

# Verify Pylons configuration has been loaded

assert config['celery.imports'] == 'kallithea.lib.celerylib.tasks', 'Kallithea Celery configuration has not been loaded'

# Prepare environment to point at Kallithea Pylons loader

# -*- coding: utf-8 -*-

from celery.loaders.base import BaseLoader

# TODO: drop this mangling and just use a separate celery config section

to_pylons = lambda x: x.replace('_', '.').lower()

from itertools import tee, imap

from kallithea.lib.vcs.exceptions import VCSError

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

from beaker.cache import cache_region

from pygments.formatters.html import HtmlFormatter

from pygments import highlight as code_highlight

from webhelpers.html import literal, HTML, escape

from webhelpers.html.tags import checkbox, end_form, hidden, link_to, \

        The return value is a list of ``Message`` objects.

        """

        messages = session.pop(self.session_key, [])

        session.save()

        return [_Message(*m) for m in messages]

    and '_' changed to '-' and be used as attributes on the div. The default

    class is 'gravatar'.

    """

    if not c.visual.use_gravatar:

        return ''

    if 'div_class' not in div_attributes:

    empty then we fallback to using an icon.

    """

    if not c.visual.use_gravatar:

        return ''

    # doh, we need to re-import those to mock it later

    from kallithea.config.routing import url

    from kallithea.model.db import User

    if not c.visual.use_gravatar:

        return ""

    def command(self):

        from kallithea.lib import celerypylons

        try:

            CELERY_ON = str2bool(config['app_conf'].get('use_celery'))

        except KeyError:

        """

        Loads the app configuration.

        """

        self.path_to_ini_file = os.path.realpath(conf)

        conf = paste.deploy.appconfig('config:' + self.path_to_ini_file)

        """

        logging.config.fileConfig(self.path_to_ini_file)

        from kallithea.model.base import init_model

        from kallithea.lib.utils2 import engine_from_config

        setup_cache_regions(config)

    def command(self):

        #get SqlAlchemy session

        self._init_session()

        index_location = config['index_dir']

        load_rcextensions(config['here'])

        '''

    def command(self):

        here = config['here']

        content = pkg_resources.resource_string(

import webob

import urlobject

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

from kallithea.lib.compat import json

    Gets kallithea user from threadlocal tmpl_context variable if it's

    defined, else returns None.

    """

    if hasattr(tmpl_context, 'authuser'):

        return tmpl_context.authuser

import logging

from collections import defaultdict

from kallithea.lib.utils2 import extract_mentioned_users, safe_unicode

from beaker.cache import cache_region, region_invalidate

from webob.exc import HTTPNotFound

from kallithea.lib.exceptions import DefaultUserException

from kallithea.lib.vcs import get_backend

        if not uri_tmpl:

            uri_tmpl = self.DEFAULT_CLONE_URI

            try:

                uri_tmpl = c.clone_uri_tmpl

            except AttributeError:

                # in any case if we call this outside of request context,

import formencode

from formencode import All

from kallithea import BACKENDS

from kallithea.model import validators as v

import logging

import traceback

from sqlalchemy.orm import joinedload, subqueryload

import kallithea

import datetime

import re

from sqlalchemy.orm import joinedload

    @classmethod

    def _render_datatable(cls, tmpl, *args, **kwargs):

        import kallithea

        _tmpl_lookup = kallithea.CONFIG['pylons.app_globals'].mako_lookup

        template = _tmpl_lookup.get_template('data_table/_dt_elements.html')

    def get_repos_as_dict(self, repos_list=None, admin=False, perm_check=True,

                          super_user_actions=False, short_name=False):

        _render = self._render_datatable

        def repo_lnk(name, rtype, rstate, private, fork_of):

            return _render('repo_name', name, rtype, rstate, private, fork_of,

import pkg_resources

from sqlalchemy import func

import kallithea

from kallithea.lib.vcs import get_backend

        from kallithea import CONFIG

        from kallithea.lib.base import _get_ip_addr

        try:

            environ = request.environ

        except TypeError:

            # we might use this outside of request context, let's fake the

import time

import traceback

from sqlalchemy.exc import DatabaseError

import formencode

import logging

from collections import defaultdict

from webhelpers.pylonslib.secure_form import authentication_token

import sqlalchemy

import tempfile

import time

import pylons

from pylons.i18n.translation import _get_translator

from pylons.util import ContextObj

from routes.util import URLGenerator