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

"""

import argparse

import sys

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

        sys.exit()

    if args.format == FORMAT_PRETTY:

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

    error_prefix = ''

    else:

        json_data = json_resp['result']

    if args.format == FORMAT_JSON:

    elif args.format == FORMAT_PRETTY:

            error_prefix, json.dumps(json_data, indent=4, sort_keys=True)

    return 0

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

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

"""

import sys

import kallithea.bin.kallithea_cli_base as cli_base

    try:

        from IPython import embed

    except ImportError:

        sys.exit(-1)

    from traitlets.config.loader import Config

    cfg = Config()

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

"""

import argparse

import fileinput

import os

        json_data = api_call(apikey, host, 'create_gist', **margs)['result']

        if args.format == FORMAT_JSON:

        elif args.format == FORMAT_PRETTY:

    return 0

    try:

        return _run(argv)

    except Exception as e:

        return 1

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

"""

import urllib2

import uuid

from ConfigParser import ConfigParser

if __name__ == '__main__':

    sync = LdapSync()

    for gr in sync.ldap_client.get_groups():

        # TODO: exception when user does not exist during add membership...

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

"""

import logging

import os

import sys

        else:

            destroy = self._ask_ok('Are you sure to destroy old database ? [y/n]')

        if not destroy:

            sys.exit(0)

        if destroy:

            # drop and re-create old schemas

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

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

import errno

import os

from multiprocessing.util import Finalize

    def _on_finalize(lock, debug):

        if lock.held:

            if debug:

            lock.release()

    def lock(self):

        """

        lockname = str(os.getpid())

        if self.debug:

        self.trylock()

        self.makelock(lockname, self.pidfile)

        return True

    def trylock(self):

        running_pid = False

        if self.debug:

        try:

            with open(self.pidfile, 'r') as f:

                try:

                    running_pid = -1

            if self.debug:

            # Now we check the PID from lock file matches to the current

            # process PID

            if running_pid:

                    if exc.errno in (errno.ESRCH, errno.EPERM):

                        print ("Lock File is there but"

                               " the program is not running")

                        self.release()

                    else:

                        raise

                else:

                    raise LockHeld()

        except IOError as e:

        """releases the pid by removing the pidfile

        """

        if self.debug:

        if self.callbackfn:

            #execute callback function on release

            if self.debug:

            self.callbackfn()

        try:

            if self.debug:

            os.remove(self.pidfile)

            self.held = False

        except OSError as e:

            if self.debug:

            pass

    def makelock(self, lockname, pidfile):

        :param pidfile: the file to write the pid in

        """

        if self.debug:

        dir_, file_ = os.path.split(pidfile)

        if not os.path.isdir(dir_):

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

"""

import binascii

import datetime

        retries = retries - 1

        if retries < 0:

            raise IOError

# encoding: UTF-8

import datetime

import string

import sys

def main():

    import time

    bar = ProgressBar(30)

    for x in xrange(1, 31):

        bar.render(x)

        time.sleep(0.02)

    bar.stream.write('\n')

    bar = ProgressBar(50)

    bar.render(0)

    bar = ColoredProgressBar(20)

    for x in bar:

        time.sleep(0.01)

    bar = AnimatedProgressBar(20)

    for x in bar:

        time.sleep(0.01)

    bar = AnimatedColoredProgressBar(20)

    for x in bar:

        time.sleep(0.01)

    bar = BarOnlyProgressBar(20)

    for x in bar:

        time.sleep(0.01)

    bar = BarOnlyColoredProgressBar(40)

    bar.width = 60

    bar.elements += ['time', 'eta']

    for x in bar:

        time.sleep(0.01)

    total_bytes = 1024 * 1024 * 2

    bar = ProgressBar(total_bytes)

    bar.width = 50

        now = datetime.datetime.now()

        if now - bar.started >= datetime.timedelta(seconds=2):

            break

if __name__ == '__main__':

"""

import json

import os

import re

        command = ' '.join(args)

        ignoreReturnCode = environ.pop('ignoreReturnCode', False)

        if DEBUG:

        testenv = dict(os.environ)

        testenv['LANG'] = 'en_US.UTF-8'

        testenv['LANGUAGE'] = 'en_US:en'

        stdout, stderr = p.communicate()

        if DEBUG:

            if stdout:

            if stderr:

        if not ignoreReturnCode:

            assert p.returncode == 0

        return stdout, stderr

"""

import logging

import os

import shutil

        command = cmd + ' ' + ' '.join(args)

        log.debug('Executing %s', command)

        if DEBUG:

        p = Popen(command, shell=True, stdout=PIPE, stderr=PIPE, cwd=self.cwd)

        stdout, stderr = p.communicate()

        if DEBUG:

        return stdout, stderr

def create_test_user(force=True):

    sa = get_session()

    user = sa.query(User).filter(User.username == USER).scalar()

    if force and user is not None:

        for repo in sa.query(Repository).filter(Repository.user == user).all():

            sa.delete(repo)

        sa.delete(user)

        sa.commit()

    if user is None or force:

        new_usr = User()

        new_usr.username = USER

        new_usr.password = get_crypt_password(PASS)

        sa.add(new_usr)

        sa.commit()

def create_test_repo(force=True):

    from kallithea.model.repo import RepoModel

    sa = get_session()

    repo = sa.query(Repository).filter(Repository.repo_name == HG_REPO).scalar()

    if repo is None:

        form_data = {'repo_name': HG_REPO,

                     'repo_type': 'hg',

        rm.base_path = '/home/hg'

        rm.create(form_data, user)

def set_anonymous_access(enable=True):

                                        backend=backend)

        s = time.time()

        for i in range(1, int(sys.argv[2]) + 1):

            test_clone_with_credentials(repo=sys.argv[1], method=METHOD,

                                        backend=backend)

    except Exception as e:

        sys.exit('stop on %s' % e)

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

"""

import cookielib

import os

if not BASE_URI.endswith('/'):

    BASE_URI += '/'

BASE_URI += '%s'

PROJECT_PATH = os.path.join('/', 'home', 'username', 'repos')

PROJECTS = [

        size = len(f.read())

        e = time.time() - s

        total_time += e

def test_changeset_walk(proj, limit=None):

    repo, proj = _get_repo(proj)

    total_time = 0

    cnt = 0

            break

        full_uri = (BASE_URI % raw_cs)

        s = time.time()

        f = o.open(full_uri)

        size = len(f.read())

        e = time.time() - s

        total_time += e

def test_files_walk(proj, limit=100):

    repo, proj = _get_repo(proj)

    total_time = 0

    paths_ = OrderedSet([''])

        file_path = '/'.join((proj, 'files', 'tip', f))

        full_uri = (BASE_URI % file_path)

        s = time.time()

        f = o.open(full_uri)

        size = len(f.read())

        e = time.time() - s

        total_time += e

if __name__ == '__main__':

    for path in PROJECTS:

        repo = vcs.get_repo(os.path.join(PROJECT_PATH, path))

        for i in range(PASES):

            test_changelog_walk(repo, pages=80)

            test_changeset_walk(repo, limit=100)

            test_files_walk(repo, limit=100)

Consistent formatting of rst section titles

"""

import re

import subprocess

def main():

    filenames = subprocess.check_output(['hg', 'loc', 'set:**.rst+kallithea/i18n/how_to']).splitlines()

    for fn in filenames:

        s = open(fn).read()

        # find levels and their styles

            if style in styles:

                stylepos = styles.index(style)

                if stylepos > lastpos + 1:

            else:

                stylepos = len(styles)

                if stylepos > lastpos + 1:

                else:

                    styles.append(style)

            lastpos = stylepos

        open(fn, 'w').write(s)

if __name__ == '__main__':

    main()

Based on kallithea/lib/paster_commands/template.ini.mako, generate development.ini

"""

import re

from kallithea.lib import inifile

def main():

    # make sure all mako lines starting with '#' (the '##' comments) are marked up as <text>

    makofile = inifile.template_file

    mako_org = open(makofile).read()

    mako_no_text_markup = re.sub(r'</?%text>', '', mako_org)

    mako_marked_up = re.sub(r'\n(##.*)', r'\n<%text>\1</%text>', mako_no_text_markup, flags=re.MULTILINE)

    if mako_marked_up != mako_org:

        open(makofile, 'w').write(mako_marked_up)

    # create ini files

    for fn, settings in ini_files:

        inifile.create(fn, None, settings)

#!/usr/bin/env python2

import re

import sys

if __name__ == '__main__':

    if len(sys.argv) < 2:

        raise SystemExit(1)

    for f in sys.argv[1:]: