kallithea.lib.annotate

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

This file was forked by the Kallithea project in July 2014.

Original author and date, and relevant copyright and licensing information is below:

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

    uid = user_id

    default_global_perms = UserToPerm.query()\

        .filter(UserToPerm.user_id == default_user_id)\

        .options(joinedload(UserToPerm.permission))

        :param user: instance of User object from database

        :param explicit: In case there are permissions both for user and a group

            explicitly override permissions from group, if it's False it will

            make decision based on the algo

        :param algo: algorithm to decide what permission should be choose if

        Exposes Kallithea validators modules

        """

        # this is a hack to overcome issues with pylons threadlocals and

        class LazyCaller(object):

            def __init__(self, name):

                self.validator_name = name

    def get_user(self, username=None, **kwargs):

        """

        Helper method for user fetching in plugins, by default it's using

        eg. container auth plugin to fetch user by environ params

        :param username: username if given to fetch from database

            # maybe plugin will clean the username ?

            # we should use the return value

            username = auth['username']

            # this can prevent from creating users in Kallithea when using

            # external authentication, but if it's inactive user we shouldn't

            # create that user anyway

    except (ImportError, TypeError):

        log.error(traceback.format_exc())

        # TODO: make this more error prone, if by some accident we screw up

        raise

    log.debug("Loaded auth plugin from %s (module:%s, file:%s)"

    plugin = importplugin(plugin)()

    if plugin.plugin_settings.im_func != KallitheaAuthPluginBase.plugin_settings.im_func:

        raise TypeError("Authentication class %s.KallitheaAuthPluginBase "

                        "forbidden." % plugin)

    return plugin

        log.info('Authenticating user using %s plugin' % plugin.__module__)

        # _authenticate is a wrapper for .auth() method of plugin.

        # it also maps users to Database and maps the attributes returned

        # from .auth() to Kallithea database. If this function returns data

        # then auth is correct.

    def get_user(self, username=None, **kwargs):

        """

        Helper method for user fetching in plugins, by default it's using

        eg. container auth plugin to fetch user by environ params

        :param username: username if given to fetch

        :param kwargs: extra arguments needed for user fetching.

    def auth(self, userobj, username, password, settings, **kwargs):

        """

        from REMOTE_USER if this plugin is enabled, if that fails

        it tries to get username from HTTP_X_FORWARDED_USER if fallback header

        is set. clean_username extracts the username from this data if it's

            username = getattr(userobj, 'username')

        if not username:

            username = self._get_username(environ, settings)

        # if cannot fetch username, it's a no-go for this plugin to proceed

    def accepts(self, user, accepts_empty=True):

        """

        Custom accepts for this auth that doesn't accept empty users. We

        """

        return super(KallitheaAuthPlugin, self).accepts(user,

                                                        accepts_empty=False)

    def _get_by_id(self, repo_name):

        """

        Gets a special pattern _<ID> from clone url and tries to replace it

        :param repo_name:

        """

    def _invalidate_cache(self, repo_name):

        """

        :param repo_name: full repo name, also a cache key

        """

def _get_cache_parameters(query):

    """For a query with cache_region and cache_namespace configured,

    on this query's current criterion and parameter values.

    """

        stats.commit_activity = json.dumps(co_day_auth_aggr)

        stats.commit_activity_combined = json.dumps(overview_data)

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

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

if __py_version__ >= (2, 6):

    _bytes = bytes

else:

    _bytes = str

if __py_version__ >= (2, 6):

    def reset_permissions(self, username):

        """

        bad permissions, we must clean them up

        :param username:

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

                                            firstname='Anonymous',

                                            lastname='User')

        if self.cli_args.get('public_access') is False:

            log.info('Public access disabled')

            user.active = False

        :param engine: the database engine to use. If this is \

        :keyword:`None` the instance's engine will be used

        :type engine: :class:`sqlalchemy.engine.base.Engine`

        :type connection: :class:`sqlalchemy.engine.base.Connection` instance

        """

        # TODO: set the parent here instead of in __init__

        :param cascade: Issue CASCADE drop if database supports it

        :type engine: :class:`sqlalchemy.engine.base.Engine`

        :type cascade: bool

        :type connection: :class:`sqlalchemy.engine.base.Connection` instance

        :returns: Instance with cleared columns

        """

        """Changing NULL is not supported"""

        # TODO: http://www.firebirdfaq.org/faq103/

        raise exceptions.NotSupportedError(

class FBConstraintGenerator(ansisql.ANSIConstraintGenerator):

class FBConstraintDropper(ansisql.ANSIConstraintDropper):

    def cascade_constraint(self, constraint):

        """Cascading constraints is not supported"""

class PGConstraintDropper(ansisql.ANSIConstraintDropper):

    pass

        API to :meth:`ChangesetColumn.drop`

        :type column: Column instance or string

        """

        if not isinstance(column, sqlalchemy.Column):

        :param name: New name of the table.

        :type name: string

        :type connection: :class:`sqlalchemy.engine.base.Connection` instance

        """

        engine = self.bind

`~migrate.changeset.constraint.PrimaryKeyConstraint` on this column.

        :param populate_default: If True, created column will be \

populated with defaults

        :type table: Table instance

        :type index_name: string

        :type unique_name: string

        ``ALTER TABLE DROP COLUMN``, for most databases.

        :type connection: :class:`sqlalchemy.engine.base.Connection` instance

        """

        if table is not None:

        :param name: New name of the Index.

        :type name: string

        :type connection: :class:`sqlalchemy.engine.base.Connection` instance

        """

        engine = self.table.bind

    def run(self, engine, step):

        """Core method of Script file.

        :param engine: SQLAlchemy Engine

        :param step: Operation to run

def main(argv=None, **kwargs):

    """Shell interface to :mod:`migrate.versioning.api`.

    --some_option as command line option

    :param disable_logging: Let migrate configure logging

        return d

    def get_appstruct(self):

        to this model data """

        l = []

            return json.JSONEncoder.default(self, obj)

class BaseModel(object):

    """

        return d

    def get_appstruct(self):

        to this model data """

        l = []

            if gr is None:

                break

            if cnt == parents_recursion_limit:

                log.error('group nested more than %s' %

                          parents_recursion_limit)

                break

        return d

    def get_appstruct(self):

        to this model data """

        l = []

            if gr is None:

                break

            if cnt == parents_recursion_limit:

                log.error('group nested more than %s' %

                          parents_recursion_limit)

                break

        return d

    def get_appstruct(self):

        to this model data """

        l = []

            if gr is None:

                break

            if cnt == parents_recursion_limit:

                log.error('group nested more than %s' %

                          parents_recursion_limit)

                break

        return d

    def get_appstruct(self):

        to this model data """

        l = []

            if gr is None:

                break

            if cnt == parents_recursion_limit:

                log.error('group nested more than %s' %

                          parents_recursion_limit)

                break

        return d

    def get_appstruct(self):

        to this model data """

        l = []

            if gr is None:

                break

            if cnt == parents_recursion_limit:

                log.error('group nested more than %s' %

                          parents_recursion_limit)

                break

        return d

    def get_appstruct(self):

        to this model data """

        l = []

            if gr is None:

                break

            if cnt == parents_recursion_limit:

                log.error('group nested more than %s' %

                          parents_recursion_limit)

                break

        return d

    def get_appstruct(self):

        to this model data """

        l = []

            if gr is None:

                break

            if cnt == parents_recursion_limit:

                log.error('group nested more than %s' %

                          parents_recursion_limit)

                break

        return d

    def get_appstruct(self):

        to this model data """

        l = []

            if gr is None:

                break

            if cnt == parents_recursion_limit:

                log.error('group nested more than %s' %

                          parents_recursion_limit)

                break

        return d

    def get_appstruct(self):

        to this model data """

        l = []

            if gr is None:

                break

            if cnt == parents_recursion_limit:

                log.error('group nested more than %s' %

                          parents_recursion_limit)

                break

        return d

    def get_appstruct(self):

        to this model data """

        l = []

            if gr is None:

                break

            if cnt == parents_recursion_limit:

                log.error('group nested more than %s' %

                          parents_recursion_limit)

                break

        return d

    def get_appstruct(self):

        to this model data """

        l = []

            if gr is None:

                break

            if cnt == parents_recursion_limit:

                log.error('group nested more than %s' %

                          parents_recursion_limit)

                break

        return d

    def get_appstruct(self):

        to this model data """

        l = []

            if gr is None:

                break

            if cnt == parents_recursion_limit:

                log.error('group nested more than %s' %

                          parents_recursion_limit)

                break

        return d

    def get_appstruct(self):

        to this model data """

        l = []

            if gr is None:

                break

            if cnt == parents_recursion_limit:

                log.error('group nested more than %s' %

                          parents_recursion_limit)

                break

        return d

    def get_appstruct(self):

        to this model data """

        l = []

            if gr is None:

                break

            if cnt == parents_recursion_limit:

                log.error('group nested more than %s' %

                          parents_recursion_limit)

                break

    def __init__(self, diff, vcs='hg', format='gitdiff', diff_limit=None):

        """

        :param diff:   a text in diff format

        :param format: format of diff passed, `udiff` or `gitdiff`

        :param diff_limit: define the size of diff that is considered "big"

            based on that parameter cut off will be triggered, set to None

        # Add unknown parents to nextrow

        tmprow = row[:]

        # Stop looking for non-existing ancestors

        nextrow = []

        for r in tmprow:

def FID(raw_id, path):

    """

    it's safe to use in urls

    :param raw_id:

            nav_items.append(text)

        for thispage in xrange(leftmost_page, rightmost_page + 1):

            if thispage == self.page:

                text = '%s' % (thispage,)

                # Wrap in a SPAN tag if nolink_attr is set

def urlify_text(text_, safe=True):

    """

    :param text_:

    """

kallithea.lib.hooks

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

This file was forked by the Kallithea project in July 2014.

Original author and date, and relevant copyright and licensing information is below:

def handle_git_receive(repo_path, revs, env, hook_type='post'):

    """

    an push action together with pushed revisions. It's executed by subprocess

    connect to database and run the logging code. Hacky as sh*t but works.

    :param repo_path:

            minus other.

        Raises:

              versions, or if other is not a network object.

            ValueError: If other is not completely contained by self.

        except Exception:

            log.error(traceback.format_exc())

            if safe:

                return cls.plain(source)

            else:

                raise

        except Exception:

            log.error(traceback.format_exc())

            if safe:

                return cls.plain(source)

            else:

                raise

kallithea.lib.middleware.wrapper

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

This file was forked by the Kallithea project in July 2014.

Original author and date, and relevant copyright and licensing information is below:

    def _on_finalize(lock, debug):

        if lock.held:

            if debug:

            lock.release()

    def lock(self):

        """

        this function will make an actual lock

        :param pidfile: the file to write the pid in

        """

        if self.debug:

            profiler.snapshot_stats()

            stats = pstats.Stats(profiler)

            # Redirect output

            out = StringIO()

def convert_line_endings(line, mode):

    """

    Available modes are::

        0 - Unix

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

        :param repo_path: local path of the 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 -

          raises RepositoryError if src_url is set and create evaluates to