# if we don't have method here it's an error

    if not method:

        parser.error('Please specify method name')

    try:

        margs = dict(map(lambda s: s.split(':', 1), other))

        sys.stderr.write('Error parsing arguments \n')

        sys.exit()

    if args.format == FORMAT_PRETTY:

        print 'Calling method %s => %s' % (method, apihost)

    json_resp = api_call(apikey, apihost, method, **margs)

    :param argv:

    """

    if argv is None:

        argv = sys.argv

        return _run(argv)

if __name__ == '__main__':

    sys.exit(main(sys.argv))

        users_log = UserLog.query()\

                .options(joinedload(UserLog.user))\

                .options(joinedload(UserLog.repository))

        #FILTERING

        c.search_term = request.GET.get('filter')

            users_log = _journal_filter(users_log, c.search_term)

        users_log = users_log.order_by(UserLog.action_date.desc())

        p = safe_int(request.GET.get('page', 1), 1)

        def url_generator(**kw):

def get_ignore_ws(fid, GET):

    ig_ws_global = GET.get('ignorews')

    ig_ws = filter(lambda k: k.startswith('WS'), GET.getall(fid))

    if ig_ws:

            return int(ig_ws[0].split(':')[-1])

    return ig_ws_global

def _ignorews_url(GET, fileid=None):

    fileid = str(fileid) if fileid else None

    params = defaultdict(list)

    def get_error_explanation(self, code):

        """ get the error explanations of int codes

            [400, 401, 403, 404, 500]"""

        try:

            code = int(code)

            code = 500

        if code == 400:

            return _('The request could not be understood by the server'

                     ' due to malformed syntax.')

        if code == 401:

:copyright: (c) 2013 RhodeCode GmbH, and others.

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

"""

import logging

from itertools import groupby

from sqlalchemy import or_

from sqlalchemy.orm import joinedload

from sqlalchemy.sql.expression import func

            filtering_criterion = UserLog.user_id.in_(user_ids)

        if filtering_criterion is not None:

            journal = self.sa.query(UserLog)\

                .options(joinedload(UserLog.user))\

                .options(joinedload(UserLog.repository))

            #filter

                journal = _journal_filter(journal, c.search_term)

            journal = journal.filter(filtering_criterion)\

                        .order_by(UserLog.action_date.desc())

        else:

            journal = []

        return journal

                try:

                    self.scm_model.toggle_following_user(user_id,

                                                self.authuser.user_id)

                    Session.commit()

                    return 'ok'

                except Exception:

                    raise HTTPBadRequest()

            repo_id = request.POST.get('follows_repo_id')

            if repo_id:

                try:

                    self.scm_model.toggle_following_repo(repo_id,

                                                self.authuser.user_id)

                    Session.commit()

                    return 'ok'

                except Exception:

                    raise HTTPBadRequest()

        log.debug('token mismatch %s vs %s' % (cur_token, token))

        raise HTTPBadRequest()

    @LoginRequired()

                        continue

            except ChangesetError:

                log.error(traceback.format_exc())

                pass

            except EmptyRepositoryError:

                pass

            return readme_data, readme_file

        kind = 'README'

        valid = CacheInvalidation.test_and_set_valid(repo_name, kind)

        if not valid:

    """

    log.info('getting information about all available permissions')

    try:

        sa = meta.Session

        all_perms = sa.query(Permission).all()

        config['available_permissions'] = [x.permission_name for x in all_perms]

    finally:

        meta.Session.remove()

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

# CHECK DECORATORS

    def __call__(self, user, repo_name):

        # repo_name MUST be unicode, since we handle keys in permission

        # dict by unicode

        repo_name = safe_unicode(repo_name)

        usr = AuthUser(user.user_id)

            self.user_perms = set([usr.permissions['repositories'][repo_name]])

        self.username = user.username

        self.repo_name = repo_name

        return self.check_permissions()

    def check_permissions(self):

        log.debug('checking VCS protocol '

    :param allowed_ips: list of allowed ips together with mask

    """

    from kallithea.lib import ipaddr

    log.debug('checking if ip:%s is subnet of %s' % (source_ip, allowed_ips))

    if isinstance(allowed_ips, (tuple, list, set)):

        for ip in allowed_ips:

                if ipaddr.IPAddress(source_ip) in ipaddr.IPNetwork(ip):

                    log.debug('IP %s is network %s' %

                              (ipaddr.IPAddress(source_ip), ipaddr.IPNetwork(ip)))

                    return True

    return False

                extern_name=auth["extern_name"],

                extern_type=self.name

            )

            Session().flush()

            # enforce user is just in given groups, all of them has to be ones

            # created from plugins. We store this info in _group_data JSON field

                groups = auth['groups'] or []

                UserGroupModel().enforce_groups(user, groups, self.name)

            Session().commit()

        return auth

def importplugin(plugin):

    """

            regex = settings["gecos"]

            match = re.search(regex, user_data.pw_gecos)

            if match:

                user_attrs["firstname"] = match.group('first_name')

                user_attrs["lastname"] = match.group('last_name')

        except Exception:

            pass

        log.debug("pamuser: \n%s" % formatted_json(user_attrs))

        log.info('user %s authenticated correctly' % user_attrs['username'])

        return user_attrs

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

def get_logger(cls):

    if CELERY_ON:

        try:

@task(ignore_result=True)

@locked_task

@dbsession

def whoosh_index(repo_location, full_index):

        paths = self.sa.query(Ui)\

                .filter(Ui.ui_key == '/')\

                .scalar()

        paths.ui_value = paths.ui_value.replace('*', '')

            self.sa.add(paths)

            self.sa.commit()

    def fix_default_user(self):

        """

        Fixes a old default user with some 'nicer' default values,

        used mostly for anonymous access

        """

                .one()

        def_user.name = 'Anonymous'

        def_user.lastname = 'User'

        def_user.email = 'anonymous@kallithea-scm.org'

            self.sa.add(def_user)

            self.sa.commit()

    def fix_settings(self):

        """

        Fixes kallithea settings adds ga_code key for google analytics

        """

        hgsettings3 = Setting('ga_code', '')

            self.sa.add(hgsettings3)

            self.sa.commit()

    def admin_prompt(self, second=False):

        if not self.tests:

            import getpass

            # defaults

    newtext = urlify_issues(newtext, repository, link_)

    return literal(newtext)

def urlify_issues(newtext, repository, link_=None):

        # allow multiple issue servers to be used

        valid_indices = [

            x.group(1)

            for x in map(lambda x: re.match(r'issue_pat(.*)', x), conf.keys())

            if x and 'issue_server_link%s' % x.group(1) in conf

            log.debug('processed prefix:`%s` => %s' % (pattern_index, newtext))

        # if we actually did something above

        if link_:

            # wrap not links into final link => link_

            newtext = linkify_others(newtext, link_)

    return newtext

def rst(source):

    return literal('<div class="rst-block">%s</div>' %

                   MarkupRenderer.rst(source))

        _group = _group.rstrip('/')

    return _group

def get_user_group_slug(request):

    _group = request.environ['pylons.routes_dict'].get('id')

        _group = UserGroup.get(_group)

        if _group:

def _extract_id_from_repo_name(repo_name):

    if repo_name.startswith('/'):

        repo_name = repo_name.lstrip('/')

    by_id_match = re.match(r'^_(\d{1,})', repo_name)

    """

    Extracts repo_name by id from special urls. Example url is _11/repo_name

    :param repo_name:

    :return: repo_name if matched else None

    """

        _repo_id = _extract_id_from_repo_name(repo_name)

        if _repo_id:

            from kallithea.model.db import Repository

def action_logger(user, action, repo, ipaddr='', sa=None, commit=False):

    """

    Action logger for various actions made by users

        sa = meta.Session()

    # if we don't get explicit IP address try to get one from registered user

    # in tmpl context var

    if not ipaddr:

        ipaddr = getattr(get_current_authuser(), 'ip_addr', '')

        if getattr(user, 'user_id', None):

            user_obj = User.get(user.user_id)

        elif isinstance(user, basestring):

            user_obj = User.get_by_username(user)

        else:

            raise Exception('You have to provide a user object or a username')

        sa.add(user_log)

        log.info('Logging action:%s on %s by user:%s ip:%s' %

                 (action, safe_unicode(repo), user_obj, ipaddr))

        if commit:

            sa.commit()

def get_filesystem_repos(path, recursive=False, skip_removed_repos=True):

    """

    Scans given path for repos and return (name,(type,path)) tuple

    ver = (stdout.split(' ')[-1] or '').strip() or '0.0.0'

    if len(ver.split('.')) > 3:

        #StrictVersion needs to be only 3 element type

        ver = '.'.join(ver.split('.')[:3])

    try:

        _ver = StrictVersion(ver)

        _ver = StrictVersion('0.0.0')

        stderr = traceback.format_exc()

    req_ver = '1.7.4'

    to_old_git = False

    if  _ver < StrictVersion(req_ver):

import os

import re

import sys

import time

import uuid

import datetime

import webob

import urllib

import urlobject

from pylons.i18n.translation import _, ungettext

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

    cur_path = os.path.split(sys.executable)[0]

    if not os.environ['PATH'].startswith(cur_path):

        os.environ['PATH'] = '%s:%s' % (cur_path, os.environ['PATH'])

def obfuscate_url_pw(engine):

    from sqlalchemy.engine import url as sa_url

    try:

        if _url.password:

            _url.password = 'XXXXX'

    return str(_url)

def get_server_url(environ):

    req = webob.Request(environ)

    return req.host_url + req.script_name

    """

    if not env:

        env = os.environ

    try:

        rc_extras = json.loads(env['KALLITHEA_EXTRAS'])

        rc_extras = {}

    try:

        for k in ['username', 'repository', 'locked_by', 'scm', 'make_lock',

                  'action', 'ip']:

            rc_extras[k]

        is_bstr = isinstance(revision, (str, unicode))

        if ((is_bstr and revision.isdigit() and len(revision) < 12)

            or isinstance(revision, int) or is_null(revision)):

            try:

                revision = self.revisions[int(revision)]

                msg = ("Revision %s does not exist for %s" % (revision, self))

                raise ChangesetDoesNotExistError(msg)

        elif is_bstr:

            # get by branch/tag name

            _ref_revision = self._parsed_refs.get(revision)

        try:

            if src_url:

                url = str(self._get_url(src_url))

                opts = {}

                if not update_after_clone:

                    opts.update({'noupdate': True})

                    MercurialRepository._check_url(url, self.baseui)

                    clone(self.baseui, url, self.path, **opts)

                # Don't try to create if we've already cloned repo

                create = False

            return localrepository(self.baseui, self.path, create=create)

        except (Abort, RepoError), err:

            if create:

            else:

                mtype = 'text/plain'

                encoding = None

                #try with pygments

                try:

                    mt = None

                if mt:

                    mtype = mt[0]

        return mtype, encoding

        self.bytes = _bytes()

        if type(source) in (type(''), _bytes, _bytearray):  # string-like

            self.bytes = _bytes(source)

        else:  # can be either file pointer or file-like

            if type(source) in (int, long):  # file pointer it is

                ## converting file descriptor (int) stdin into file-like

                    source = os.fdopen(source, 'rb', 16384)

            # let's see if source is file-like by now

        if not filelike and not self.bytes:

            raise TypeError("StreamFeeder's source object must be a readable "

                            "file-like, a file descriptor, or a string-like.")

        self.source = source

        self.readiface, self.writeiface = os.pipe()

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

"""

from __future__ import with_statement

import time

import logging

from sqlalchemy import or_

from kallithea.lib.utils2 import generate_api_key

from kallithea.model import BaseModel

from kallithea.model.db import UserApiKeys

from kallithea.model.meta import Session

        if user:

            user = self._get_user(user)

            api_key = api_key.filter(UserApiKeys.user_id == user.user_id)

        api_key = api_key.scalar()

            Session().delete(api_key)

    def get_api_keys(self, user, show_expired=True):

        user = self._get_user(user)

        user_api_keys = UserApiKeys.query()\

            .filter(UserApiKeys.user_id == user.user_id)

        if not show_expired:

        # we didn't override our tmpl from **overrides

        if not uri_tmpl:

            uri_tmpl = self.DEFAULT_CLONE_URI

            try:

                from pylons import tmpl_context as c

                uri_tmpl = c.clone_uri_tmpl

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

                # ie, not having tmpl_context set up

                pass

        return get_clone_url(uri_tmpl=uri_tmpl,

                             qualifed_home_url=qualified_home_url,

        """

        Mark all caches of a repo as invalid in the database.

        """

        inv_objs = Session().query(cls).filter(cls.cache_args == repo_name).all()

        log.debug('for repo %s got %s invalidation objects'

                  % (safe_str(repo_name), inv_objs))

            for inv_obj in inv_objs:

                log.debug('marking %s key for invalidation based on repo_name=%s'

                          % (inv_obj, safe_str(repo_name)))

                if delete:

                    Session().delete(inv_obj)

                else:

                    inv_obj.cache_active = False

                    Session().add(inv_obj)

            Session().commit()

    @classmethod

    def test_and_set_valid(cls, repo_name, kind, valid_cache_keys=None):

        """

        Mark this cache key as active and currently cached.

        Return True if the existing cache registration still was valid.

        key = (repo_name + '_' + kind) if kind else repo_name

        cache_key = cls._get_cache_key(key)

        if valid_cache_keys and cache_key in valid_cache_keys:

            return True

            inv_obj = cls.query().filter(cls.cache_key == cache_key).scalar()

            if not inv_obj:

                inv_obj = CacheInvalidation(cache_key, repo_name)

            if inv_obj.cache_active:

                return True

            inv_obj.cache_active = True

            Session().add(inv_obj)

            Session().commit()

            return False

    @classmethod

    def get_valid_cache_keys(cls):

        """

        Return opaque object with information of which caches still are valid

        and can be used without checking for invalidation.

            'email': _fd['email'], 'firstname': _fd['firstname'], 'lastname': _fd['lastname'],

            'active': _fd['active'], 'admin': False

        }

        # raises UserCreationError if it's not allowed

        check_allowed_create_user(user_data, cur_user)

        from kallithea.lib.auth import get_crypt_password

            new_user = User()

            for k, v in form_data.items():

                if k == 'password':

                    v = get_crypt_password(v)

                if k == 'firstname':

                    k = 'name'

            new_user.api_key = generate_api_key(form_data['username'])

            self.sa.add(new_user)

            log_create_user(new_user.get_dict(), cur_user)

            return new_user

    def create_or_update(self, username, password, email, firstname='',

                         lastname='', active=True, admin=False,

                         extern_type=None, extern_name=None, cur_user=None):

        """

        Creates a new instance if not found, or updates current one

            raise

    def create_registration(self, form_data):

        from kallithea.model.notification import NotificationModel

        import kallithea.lib.helpers as h

            form_data['admin'] = False

            form_data['extern_name'] = EXTERN_TYPE_INTERNAL

            form_data['extern_type'] = EXTERN_TYPE_INTERNAL

            new_user = self.create(form_data)

            self.sa.add(new_user)

            edit_url = h.canonical_url('edit_user', id=new_user.user_id)

            email_kwargs = {'registered_user_url': edit_url, 'new_username': new_user.username}

            NotificationModel().create(created_by=new_user, subject=subject,

                                       body=body, recipients=None,

                                       type_=Notification.TYPE_REGISTRATION,

                                       email_kwargs=email_kwargs)

    def update(self, user_id, form_data, skip_attrs=[]):

        from kallithea.lib.auth import get_crypt_password

            user = self.get(user_id, cache=False)

            if user.username == User.DEFAULT_USER:

                raise DefaultUserException(

                                _("You can't Edit this user since it's "

                                  "crucial for entire application"))

                    # old legacy thing orm models store firstname as name,

                    # need proper refactor to username

                    if k == 'firstname':

                        k = 'name'

                    setattr(user, k, v)

            self.sa.add(user)

    def update_user(self, user, **kwargs):

        from kallithea.lib.auth import get_crypt_password

            user = self._get_user(user)

            if user.username == User.DEFAULT_USER:

                raise DefaultUserException(

                    _("You can't Edit this user since it's"

                      " crucial for entire application")

                )

                if k == 'password' and v:

                    v = get_crypt_password(v)

                setattr(user, k, v)

            self.sa.add(user)

            return user

    def delete(self, user, cur_user=None):

        if not cur_user:

            cur_user = getattr(get_current_authuser(), 'username', None)

        user = self._get_user(user)

            if user.username == User.DEFAULT_USER:

                raise DefaultUserException(

                    _(u"You can't remove this user since it's"

                      " crucial for entire application")

                )

            if user.repositories:

                    % (user.username, len(repos), ', '.join(repos))

                )

            self.sa.delete(user)

            from kallithea.lib.hooks import log_delete_user

            log_delete_user(user.get_dict(), cur_user)

    def reset_password_link(self, data):

        from kallithea.lib.celerylib import tasks, run_task

        from kallithea.model.notification import EmailNotificationModel

        import kallithea.lib.helpers as h