import os

import pprint

import random

import sys

import urllib2

CONFIG_NAME = '.config/kallithea'

FORMAT_PRETTY = 'pretty'

FORMAT_JSON = 'json'

    if not method:

        raise Exception('please specify method name !')

    apihost = apihost.rstrip('/')

    id_ = random.randrange(1, 9999)

    req = urllib2.Request('%s/_admin/api' % apihost,

                      headers={'content-type': 'text/plain'})

    ret = urllib2.urlopen(req)

    raw_json = ret.read()

    id_ret = json_data['id']

    if id_ret == id_:

        return json_data

    else:

        _formatted_json = pprint.pformat(json_data)

        :param config:

        """

        update = False

        if os.path.exists(self._conf_name):

            update = True

        with open(self._conf_name, 'wb') as f:

            f.write('\n')

        if update:

            sys.stdout.write('Updated config in %s\n' % self._conf_name)

        else:

            sys.stdout.write('Created new config in %s\n' % self._conf_name)

        :param new_config:

        """

        config = {}

        try:

            with open(self._conf_name, 'rb') as conf:

        except IOError as e:

            sys.stderr.write(str(e) + '\n')

        config.update(new_config)

        self.make_config(config)

    def load_config(self):

        """

        Loads config from file and returns loaded JSON object

        """

        try:

            with open(self._conf_name, 'rb') as conf:

        except IOError as e:

            #sys.stderr.write(str(e) + '\n')

            pass

:license: GPLv3, see LICENSE.md for more details.

"""

from __future__ import print_function

import argparse

import sys

def argparser(argv):

    usage = (

      "kallithea-api [-h] [--format=FORMAT] [--apikey=APIKEY] [--apihost=APIHOST] "

      "[--config=CONFIG] [--save-config] "

"""

from __future__ import print_function

import argparse

import fileinput

import os

import stat

import sys

def argparser(argv):

    usage = (

      "kallithea-gist [-h] [--format=FORMAT] [--apikey=APIKEY] [--apihost=APIHOST] "

      "[--config=CONFIG] [--save-config] [GIST OPTIONS] "

import urllib2

import uuid

from ConfigParser import ConfigParser

import ldap

config = ConfigParser()

config.read('ldap_sync.conf')

        This will generate the UUID for validation check after the

        response is returned. Handle errors and get the result back.

        """

        uid = str(uuid.uuid1())

        data = self.get_api_data(uid, method, args)

        headers = {'content-type': 'text/plain'}

        req = urllib2.Request(self.url, data, headers)

        response = urllib2.urlopen(req)

        if uid != response["id"]:

            raise InvalidResponseIDError("UUID does not match.")

        if response["error"] is not None:

            raise ResponseError(response["error"])

import traceback

import types

from tg import Response, TGController, request, response

from webob.exc import HTTPError, HTTPException

from kallithea.lib.auth import AuthUser

from kallithea.lib.base import _get_ip_addr as _get_ip

from kallithea.lib.base import get_path_info

from kallithea.model.db import User

log = logging.getLogger('JSONRPC')

            raise JSONRPCErrorResponse(retid=self._req_id,

                                       message="Content-Length is 0")

        raw_body = environ['wsgi.input'].read(length)

        try:

        except ValueError as e:

            # catch JSON errors Here

            raise JSONRPCErrorResponse(retid=self._req_id,

                                       message="JSON parse error ERR:%s RAW:%r"

                                                % (e, raw_body))

        if self._error is not None:

            raw_response = None

        response = dict(id=self._req_id, result=raw_response, error=self._error)

        try:

        except TypeError as e:

            log.error('API FAILED. Error encoding response for %s %s: %s\n%s', action, rpc_args, e, traceback.format_exc())

                dict(

                    id=self._req_id,

                    result=None,

                )

    def _find_method(self):

        """

        Return method named by `self._req_method` in controller if able

        """

        log.debug('Trying to find JSON-RPC method: %s', self._req_method)

from tg import tmpl_context as c

from tg.i18n import ugettext as _

from webob.exc import HTTPBadRequest

import kallithea.lib.helpers as h

from kallithea.config.conf import ALL_EXTS, ALL_READMES, LANGUAGES_EXTENSIONS_MAP

from kallithea.lib.auth import HasRepoPermissionLevelDecorator, LoginRequired

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

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.utils2 import safe_int, safe_unicode

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

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

from kallithea.lib.vcs.nodes import FileNode

            .scalar()

        c.stats_percentage = 0

        if stats and stats.languages:

            c.no_data = False is c.db_repo.enable_statistics

            lang_stats = [(x, {"count": y,

                               "desc": LANGUAGES_EXTENSIONS_MAP.get(x, '?')})

                          for x, y in lang_stats_d.items()]

            lang_stats.sort(key=lambda k: (-k[1]['count'], k[0]))

        stats = Statistics.query() \

            .filter(Statistics.repository == c.db_repo) \

            .scalar()

        c.stats_percentage = 0

        if stats and stats.languages:

            c.no_data = False is c.db_repo.enable_statistics

            lang_stats = ((x, {"count": y,

                               "desc": LANGUAGES_EXTENSIONS_MAP.get(x)})

                          for x, y in lang_stats_d.items())

            c.trending_languages = (

import base64

import logging

import urllib2

log = logging.getLogger(__name__)

class CrowdServer(object):

            msg = "".join(rdoc.readlines())

            if not msg and empty_response_ok:

                rval = {}

                rval["status"] = True

                rval["error"] = "Response body was empty"

            elif not noformat:

                rval["status"] = True

            else:

                rval = "".join(rdoc.readlines())

        except Exception as e:

            if not noformat:

                rval = {"status": False,

    def user_auth(self, username, password):

        """Authenticate a user against crowd. Returns brief information about

        the user."""

        url = ("%s/rest/usermanagement/%s/authentication?username=%s"

               % (self._uri, self._version, urllib2.quote(username)))

        return self._request(url, body)

    def user_groups(self, username):

        """Retrieve a list of groups to which this user belongs."""

        url = ("%s/rest/usermanagement/%s/user/group/nested?username=%s"

               % (self._uri, self._version, urllib2.quote(username)))

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 import BACKENDS, __version__

from kallithea.config.routing import url

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

from kallithea.model.scm import ScmModel

        msg = "JSON responses with Array envelopes are susceptible to " \

              "cross-site data leak attacks, see " \

              "https://web.archive.org/web/20120519231904/http://wiki.pylonshq.com/display/pylonsfaq/Warnings"

        warnings.warn(msg, Warning, 2)

        log.warning(msg)

    log.debug("Returning JSON wrapped action output")

@decorator.decorator

def IfSshEnabled(func, *args, **kwargs):

    """Decorator for functions that can only be called if SSH access is enabled.

    If SSH access is disabled in the configuration file, HTTPNotFound is raised.

from operator import itemgetter

from time import mktime

from tg import config

from kallithea import CELERY_ON

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.vcs.utils import author_email

from kallithea.model.db import RepoGroup, Repository, Statistics, User

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

            # current state of parsing revision(from db marker) is the

            # last revision

            lock.release()

            return True

        if cur_stats:

                                        cur_stats.commit_activity_combined))

        log.debug('starting parsing %s', parse_limit)

        last_rev = last_rev + 1 if last_rev and last_rev >= 0 else 0

        log.debug('Getting revisions from %s to %s',

             last_rev, last_rev + parse_limit

                "label": akc(repo.contact),

                "data": [0, 1],

                "schema": ["commits"],

            }

        stats = cur_stats if cur_stats else Statistics()

        log.debug('last revision %s', last_rev)

        leftovers = len(repo.revisions[last_rev:])

        log.debug('revisions to parse %s', leftovers)

        if last_rev == 0 or leftovers < parse_limit:

            log.debug('getting code trending stats')

        try:

            stats.repository = dbrepo

            stats.stat_on_revision = last_cs.revision if last_cs else 0

            DBS.add(stats)

            DBS.commit()

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

from sqlalchemy.util import OrderedSet

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

# json

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

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

# kill

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

if os.name == 'nt': # Windows

"""

"""

import datetime

import decimal

import functools

def _is_tz_aware(value):

    """

    Determines if a given datetime.time is timezone aware.

class ExtendedEncoder(json.JSONEncoder):

    def default(self, obj):

        try:

            return _obj_dump(obj)

        except NotImplementedError:

        raise TypeError("%r is not JSON serializable" % (obj,))

"""

from __future__ import print_function

import binascii

import datetime

import os

import pwd

import re

import time

import urllib

import urlobject

from tg.i18n import ugettext as _

from tg.i18n import ungettext

from webhelpers2.text import collapse, remove_formatting, strip_tags

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

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

def str2bool(_str):

    """

from sqlalchemy.ext.hybrid import hybrid_property

from sqlalchemy.orm import class_mapper, joinedload, relationship, validates

from tg.i18n import lazy_ugettext as _

from webob.exc import HTTPNotFound

import kallithea

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

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

from kallithea.model.meta import Base, Session

    @hybrid_property

    def user_data(self):

        if not self._user_data:

            return {}

        try:

        except TypeError:

            return {}

    @user_data.setter

    def user_data(self, val):

        try:

        except Exception:

            log.error(traceback.format_exc())

    def __repr__(self):

        return "<%s %s: %r')>" % (self.__class__.__name__, self.user_id, self.username)

    @hybrid_property

    def group_data(self):

        if not self._group_data:

            return {}

        try:

        except TypeError:

            return {}

    @group_data.setter

    def group_data(self, val):

        try:

        except Exception:

            log.error(traceback.format_exc())

    def __repr__(self):

        return "<%s %s: %r')>" % (self.__class__.__name__,

                                  self.users_group_id,

                             'of <rev_type>:<rev>, got %s instead' % val)

        self._landing_revision = val

    @hybrid_property

    def changeset_cache(self):

        try:

            cs_cache['raw_id'] # verify data, raise exception on error

            return cs_cache

        except (TypeError, KeyError, ValueError):

            return EmptyChangeset().__json__()

    @changeset_cache.setter

    def changeset_cache(self, val):

        try:

        except Exception:

            log.error(traceback.format_exc())

    @classmethod

    def query(cls, sorted=False):

        """Add Repository-specific helpers for common query constructs.

import os

import random

import shutil

import time

import traceback

from kallithea.model.db import Gist, Session, User

from kallithea.model.repo import RepoModel

from kallithea.model.scm import ScmModel

log = logging.getLogger(__name__)

            'gist_owner_id': user_id,

            'gist_type': gist_type,

            'gist_expires': gist_expires,

            'gist_updated': time.time(),

        }

        with open(os.path.join(repo.path, '.hg', GIST_METADATA_FILE), 'wb') as f:

    def get_gist(self, gist):

        return Gist.guess_instance(gist)

    def get_gist_files(self, gist_access_id, revision=None):

        """

import random

import re

import mock

import pytest

from kallithea.lib.auth import AuthUser

from kallithea.model.changeset_status import ChangesetStatusModel

from kallithea.model.db import ChangesetStatus, PullRequest, RepoGroup, Repository, Setting, Ui, User

from kallithea.model.gist import GistModel

from kallithea.model.meta import Session

from kallithea.model.repo import RepoModel

from kallithea.model.repo_group import RepoGroupModel

fixture = Fixture()

def _build_data(apikey, method, **kw):

    """

    Builds API data with given random ID

    """

    random_id = random.randrange(1, 9999)

        "id": random_id,

        "api_key": apikey,

        "method": method,

        "args": kw

    })

def crash(*args, **kwargs):

    raise Exception('Total Crash !')

    def _compare_ok(self, id_, expected, given):

        expected = jsonify({

            'id': id_,

            'error': None,

            'result': expected

        })

        assert expected == given, (expected, given)

    def _compare_error(self, id_, expected, given):

        expected = jsonify({

            'id': id_,

            'error': expected,

            'result': None

        })

        assert expected == given, (expected, given)

    def test_Optional_object(self):

        from kallithea.controllers.api.api import Optional

        option1 = Optional(None)

        id_, params = _build_data(self.apikey_regular, 'create_gist',

                                  lifetime=10,

                                  description='foobar-gist',

                                  gist_type='public',

                                  files={'foobar': {'content': 'foo'}})

        response = api_call(self, params)

        expected = {

            'gist': {

                'description': 'foobar-gist',

                'type': 'public',

            },

            'msg': 'created new gist'

        }

        self._compare_ok(id_, expected, given=response.body)

    @mock.patch.object(GistModel, 'create', crash)

        self._compare_ok(id_, expected, given=response.body)

    def test_api_get_changesets(self):

        id_, params = _build_data(self.apikey, 'get_changesets',

                                  repoid=self.REPO, start=0, end=2)

        response = api_call(self, params)

        assert len(result) == 3

        assert 'message' in result[0]

        assert 'added' not in result[0]

    def test_api_get_changesets_with_max_revisions(self):

        id_, params = _build_data(self.apikey, 'get_changesets',

                                  repoid=self.REPO, start_date="2011-02-24T00:00:00", max_revisions=10)

        response = api_call(self, params)

        assert len(result) == 10

        assert 'message' in result[0]

        assert 'added' not in result[0]

    def test_api_get_changesets_with_branch(self):

        if self.REPO == 'vcs_test_hg':

            branch = 'stable'

        else:

            pytest.skip("skipping due to missing branches in git test repo")

        id_, params = _build_data(self.apikey, 'get_changesets',

                                  repoid=self.REPO, branch_name=branch, start_date="2011-02-24T00:00:00")

        response = api_call(self, params)

        assert len(result) == 5

        assert 'message' in result[0]

        assert 'added' not in result[0]

    def test_api_get_changesets_with_file_list(self):

        id_, params = _build_data(self.apikey, 'get_changesets',

                                  repoid=self.REPO, start_date="2010-04-07T23:30:30", end_date="2010-04-08T00:31:14", with_file_list=True)

        response = api_call(self, params)

        assert len(result) == 3

        assert 'message' in result[0]

        assert 'added' in result[0]

    def test_api_get_changeset(self):

        review = fixture.review_changeset(self.REPO, self.TEST_REVISION, "approved")

        id_, params = _build_data(self.apikey, 'get_changeset',

                                  repoid=self.REPO, raw_id=self.TEST_REVISION)

        response = api_call(self, params)

        assert result["raw_id"] == self.TEST_REVISION

        assert "reviews" not in result

    def test_api_get_changeset_with_reviews(self):

        reviewobjs = fixture.review_changeset(self.REPO, self.TEST_REVISION, "approved")

        id_, params = _build_data(self.apikey, 'get_changeset',

                                  repoid=self.REPO, raw_id=self.TEST_REVISION,

                                  with_reviews=True)

        response = api_call(self, params)

        assert result["raw_id"] == self.TEST_REVISION

        assert "reviews" in result

        assert len(result["reviews"]) == 1

        review = result["reviews"][0]

        expected = {

            'status': 'approved',

        expected = u'Access denied to repo %s' % self.REPO

        self._compare_error(id_, expected, given=response.body)

    def test_api_get_pullrequest(self):

        pull_request_id = fixture.create_pullrequest(self, self.REPO, self.TEST_PR_SRC, self.TEST_PR_DST, u'get test')

        random_id = random.randrange(1, 9999)

            "id": random_id,

            "api_key": self.apikey,

            "method": 'get_pullrequest',

            "args": {"pullrequest_id": pull_request_id},

        response = api_call(self, params)

        pullrequest = PullRequest().get(pull_request_id)

        expected = {

            "status": "new",