if sys.version_info < (3, 6):

    raise Exception('Kallithea requires python 3.6 or later')

VERSION = (0, 6, 99)

BACKENDS = {

    'hg': 'Mercurial repository',

    'git': 'Git repository',

}

CELERY_APP = celery.Celery()  # needed at import time but is lazy and can be configured later

CONFIG = {}  # set to tg.config when TG app is initialized and calls app_cfg

# URL prefix for non repository related links - must start with `/`

ADMIN_PREFIX = '/_admin'

URL_SEP = '/'

# Linked module for extensions

EXTENSIONS = {}

__version__ = '.'.join(str(each) for each in VERSION)

__platform__ = platform.system()

__license__ = 'GPLv3'

"""

    vcs.backends.base

    ~~~~~~~~~~~~~~~~~

    Base for all available scm backends

    :created_on: Apr 8, 2010

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

"""

import datetime

import itertools

from kallithea.lib.vcs.backends import get_backend

from kallithea.lib.vcs.conf import settings

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

                                          NodeAlreadyRemovedError, NodeDoesNotExistError, NodeNotChangedError, RepositoryError)

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

from kallithea.lib.vcs.utils.helpers import get_dict_for_attrs

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

class BaseRepository(object):

    """

        ``changesets``

            storage dict caching returned changesets

        ``path``

            absolute path to the repository

        ``branches``

            branches as list of changesets

        ``tags``

            tags as list of changesets

    """

    EMPTY_CHANGESET = '0' * 40

    def __init__(self, repo_path, create=False, **kwargs):

        """

        Initializes repository. Raises RepositoryError if repository could

        not be find at the given ``repo_path`` or directory at ``repo_path``

        exists and ``create`` is set to True.

        :param repo_path: local path of the repository

        :param create=False: if set to True, would try to create repository.

        :param src_url=None: if set, should be proper url from which repository

          would be cloned; requires ``create`` parameter to be set to True -

        ``message``

            message of the changeset, as str

        ``parents``

            list of parent changesets

        ``last``

            ``True`` if this is last changeset in repository, ``False``

            otherwise; trying to access this attribute while there is no

            changesets would raise ``EmptyRepositoryError``

    """

    def __str__(self):

        return '<%s at %s:%s>' % (self.__class__.__name__, self.revision,

            self.short_id)

    def __repr__(self):

        return self.__str__()

    def __eq__(self, other):

        if type(self) is not type(other):

            return False

        return self.raw_id == other.raw_id

#

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

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

"""

Tests for the JSON-RPC web api.

"""

import os

import random

import re

import string

import mock

import pytest

from kallithea.lib import ext_json

from kallithea.lib.auth import AuthUser

from kallithea.lib.utils2 import ascii_bytes

from kallithea.model import db, meta

from kallithea.model.changeset_status import ChangesetStatusModel

from kallithea.model.gist import GistModel

from kallithea.model.pull_request import PullRequestModel

from kallithea.model.repo import RepoModel

from kallithea.model.repo_group import RepoGroupModel

from kallithea.model.scm import ScmModel

from kallithea.model.user import UserModel

                                       user=base.TEST_USER_ADMIN_LOGIN)

    meta.Session().commit()

    return gr

def make_repo_group(name=TEST_REPO_GROUP):

    gr = fixture.create_repo_group(name, cur_user=base.TEST_USER_ADMIN_LOGIN)

    meta.Session().commit()

    return gr

class _BaseTestApi(object):

    @classmethod

    def setup_class(cls):

        cls.usr = db.User.get_by_username(base.TEST_USER_ADMIN_LOGIN)

        cls.apikey = cls.usr.api_key

        cls.test_user = UserModel().create_or_update(

            username='test-api',

            password='test',

            email='test@example.com',

            firstname='first',

            lastname='last'

        )

    replaced with a more specific cache invalidation in code or test."""

    for cache in cache_managers.values():

        cache.clear()

class NullHandler(logging.Handler):

    def emit(self, record):

        pass

class TestController(object):

    """Pytest-style test controller"""

    # Note: pytest base classes cannot have an __init__ method

    @pytest.fixture(autouse=True)

    def app_fixture(self):

        h = NullHandler()

        logging.getLogger("kallithea").addHandler(h)

        self.app = TestApp(testapp)

        return self.app

    def log_user(self, username=TEST_USER_ADMIN_LOGIN,

                 password=TEST_USER_ADMIN_PASS):

struct

subprocess

sys

tarfile

tempfile

textwrap

tgext

threading

time

traceback

traitlets

types

urllib

urlobject

uuid

warnings

webhelpers2

webob

webtest

whoosh

win32traceutil

zipfile

'''.split())