try:

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

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

        sys.exit()

    if args.format == FORMAT_PRETTY:

    if argv is None:

        argv = sys.argv

        return _run(argv)

if __name__ == '__main__':

        #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())

    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

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

        try:

            code = int(code)

            code = 500

        if code == 400:

"""

import logging

from itertools import groupby

from sqlalchemy import or_

                .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:

                    Session.commit()

                    return 'ok'

                except Exception:

                    raise HTTPBadRequest()

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

                    Session.commit()

                    return 'ok'

                except Exception:

                    raise HTTPBadRequest()

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

                pass

            except EmptyRepositoryError:

                pass

            return readme_data, readme_file

        sa = meta.Session

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

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

    finally:

        meta.Session.remove()

        # 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()

    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

            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

                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))

def get_logger(cls):

    if CELERY_ON:

        try:

@task(ignore_result=True)

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

            self.sa.add(paths)

            self.sa.commit()

    def fix_default_user(self):

        """

        def_user.lastname = 'User'

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

            self.sa.add(def_user)

            self.sa.commit()

    def fix_settings(self):

        """

        hgsettings3 = Setting('ga_code', '')

            self.sa.add(hgsettings3)

            self.sa.commit()

    def admin_prompt(self, second=False):

        if not self.tests:

    return literal(newtext)

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

        # allow multiple issue servers to be used

        valid_indices = [

        if link_:

            # wrap not links into final link => link_

            newtext = linkify_others(newtext, link_)

    return newtext

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):

    :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):

    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):

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

        if commit:

            sa.commit()

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

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

    try:

        _ver = StrictVersion(ver)

        _ver = StrictVersion('0.0.0')

        stderr = traceback.format_exc()

import time

import uuid

import datetime

import webob

import urllib

import urlobject

def obfuscate_url_pw(engine):

    from sqlalchemy.engine import url as sa_url

    try:

        if _url.password:

            _url.password = 'XXXXX'

    return str(_url)

    try:

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

        rc_extras = {}

    try:

            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)

                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

                #try with pygments

                try:

                    mt = None

                if mt:

        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.")

from __future__ import with_statement

import time

import logging

from sqlalchemy import or_

from kallithea.lib.utils2 import generate_api_key

            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)

            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

        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)))

                    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):

        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)

            Session().add(inv_obj)

            Session().commit()

            return False

    @classmethod

    def get_valid_cache_keys(cls):

        # 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':

            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,

        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

                                       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(

                        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(

                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"

            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

        import kallithea.lib.helpers as h

        user_email = data['email']

            user = User.get_by_email(user_email)

            if user:

                log.debug('password reset user found %s' % user)

                log.info('send new password mail to %s' % user_email)

            else:

                log.debug("password reset email %s not found" % user_email)

        return True

        from kallithea.lib.celerylib import tasks, run_task

        from kallithea.lib import auth

        user_email = data['email']

            user = User.get_by_email(user_email)

            new_passwd = auth.PasswordGenerator().gen_password(8,

                            auth.PasswordGenerator.ALPHABETS_BIG_SMALL)

            if new_passwd is None:

                raise Exception('unable to generate new password')

            run_task(tasks.send_email, [user_email],

                     _('Your new password'),

                     _('Your new Kallithea password:%s') % (new_passwd,))

            log.info('send new password mail to %s' % user_email)

        return True

    def fill_data(self, auth_user, user_id=None, api_key=None, username=None):

        if user_id is None and api_key is None and username is None:

            raise Exception('You need to pass user_id, api_key or username')

            dbuser = None

            if user_id:

                dbuser = self.get(user_id)

                for k, v in dbuser.get_dict().iteritems():

                    if k not in ['api_keys', 'permissions']:

                        setattr(auth_user, k, v)

                return False

    def has_perm(self, user, perm):

        perm = self._get_perm(perm)

        user = self._get_user(user)

from collections import defaultdict

from pylons.i18n.translation import _

from webhelpers.pylonslib.secure_form import authentication_token

from formencode.validators import (

    UnicodeString, OneOf, Int, Number, Regex, Email, Bool, StringBoolean, Set,

            try:

                User.query().filter(User.active == True)\

                    .filter(User.username == value).one()

                msg = M(self, 'invalid_username', state, username=value)

                raise formencode.Invalid(msg, value, state,

                    error_dict=dict(username=msg)

        # test if the repository was created on filesystem

        try:

            vcs.get_repo(os.path.join(TESTS_TMP_PATH, repo_name))

            self.fail('no repo %s in filesystem' % repo_name)

        RepoModel().delete(repo_name)

        # test if the repository was created on filesystem

        try:

            vcs.get_repo(os.path.join(TESTS_TMP_PATH, repo_name))

            self.fail('no repo %s in filesystem' % repo_name)

    def test_create_in_group(self):

        # test if the repository was created on filesystem

        try:

            vcs.get_repo(os.path.join(TESTS_TMP_PATH, repo_name_full))

            RepoGroupModel().delete(group_name)

            Session().commit()

            self.fail('no repo %s in filesystem' % repo_name)

        # test if the repository was created on filesystem

        try:

            vcs.get_repo(os.path.join(TESTS_TMP_PATH, repo_name_full))

            RepoGroupModel().delete(group_name)

            Session().commit()

            self.fail('no repo %s in filesystem' % repo_name)

        # test if the repository was created on filesystem

        try:

            vcs.get_repo(os.path.join(TESTS_TMP_PATH, repo_name_full))

            RepoGroupModel().delete(group_name)

            Session().commit()

            self.fail('no repo %s in filesystem' % repo_name)

        # test if the repository was created on filesystem

        try:

            vcs.get_repo(os.path.join(TESTS_TMP_PATH, repo_name))

            self.fail('no repo %s in filesystem' % repo_name)

        response = self.app.delete(url('repo', repo_name=repo_name))

        # test if the repository was created on filesystem

        try:

            vcs.get_repo(os.path.join(TESTS_TMP_PATH, repo_name))

            self.fail('no repo %s in filesystem' % repo_name)

        response = self.app.delete(url('repo', repo_name=repo_name))

        try:

            METHOD = sys.argv[3]

            pass

        try:

            backend = sys.argv[4]

            backend = 'hg'

        if METHOD == 'pull':