# api_key, which is translated to instance of user at that name

        USER_SESSION_ATTR = 'apiuser'

        # get our arglist and check if we provided them as args

        for arg, default in func_kwargs.iteritems():

            if arg == USER_SESSION_ATTR:

                    )

                )

        self._rpc_args.update(self._request_params)

    """

    API Controller

            pass

    Each function should also **raise** JSONRPCError for any

    errors that happens.

    """

    @HasPermissionAnyDecorator('hg.admin')

        return args

    @HasPermissionAnyDecorator('hg.admin')

        """

        Triggers a pull from remote location on given repo. Can be used to

        automatically keep remote repos up to date. This command can be executed

        only using api_key belonging to user with admin rights

        :param repoid: repository name or repository id

        :type repoid: str or int

            )

    @HasPermissionAnyDecorator('hg.admin')

        """

        Triggers rescan repositories action. If remove_obsolete is set

        than also delete repos that are in database but not in the filesystem.

        aka "clean zombies". This command can be executed only using api_key

        belonging to user with admin rights.

        :param remove_obsolete: deletes repositories from

            database that are not found on the filesystem

        :type remove_obsolete: Optional(bool)

                'Error occurred during rescan repositories action'

            )

        """

        Invalidate cache for repository.

        This command can be executed only using api_key belonging to user with admin

        rights or regular user that have write or admin or write access to repository.

        :param repoid: repository name or repository id

        :type repoid: str or int

            )

    # permission check inside

             userid=Optional(OAttr('apiuser'))):

        """

        Set locking state on given repository by given user. If userid param

        to user with admin rights or regular user that have admin or write

        access to repository.

        :param repoid: repository name or repository id

        :type repoid: str or int

        :param locked: lock state to be set

                                     'repository.write')(repo_name=repo.repo_name):

            # make sure normal user does not pass someone else userid,

            # he is not allowed to do that

                raise JSONRPCError(

                    'userid is not the same as your user'

                )

            raise JSONRPCError('repository `%s` does not exist' % (repoid,))

        if isinstance(userid, Optional):

        user = get_user_or_error(userid)

                    'Error occurred locking repository `%s`' % repo.repo_name

                )

        """

        Get all repositories with locks for given userid, if

        this command is run by non-admin account userid is set to user

        who is calling this method, thus returning locks for himself.

        :param userid: User to get locks for

        :type userid: Optional(str or int)

        if not HasPermissionAnyApi('hg.admin')():

            # make sure normal user does not pass someone else userid,

            # he is not allowed to do that

                raise JSONRPCError(

                    'userid is not the same as your user'

                )

        return ret

    @HasPermissionAnyDecorator('hg.admin')

        """

        Shows IP address as seen from Kallithea server, together with all

        defined IP addresses for given user. If userid is not passed data is

        This command can be executed only using api_key belonging to user with

        admin rights.

        :param userid: username to show ips for

        :type userid: Optional(str or int)

        """

        if isinstance(userid, Optional):

        user = get_user_or_error(userid)

        ips = UserIpMap.query().filter(UserIpMap.user == user).all()

        return dict(

    show_ip = get_ip

    @HasPermissionAnyDecorator('hg.admin')

        """

        return server info, including Kallithea version and installed packages

        OUTPUT::

        """

        return Setting.get_server_info()

        """

        Gets a user by username or user_id, Returns empty result if user is

        not found. If userid param is skipped it is set to id of user who is

        belonging to user with admin rights, or regular users that cannot

        specify different userid than theirs

        :param userid: user to get data for

        :type userid: Optional(str or int)

        if not HasPermissionAnyApi('hg.admin')():

            # make sure normal user does not pass someone else userid,

            # he is not allowed to do that

                raise JSONRPCError(

                    'userid is not the same as your user'

                )

        if isinstance(userid, Optional):

        user = get_user_or_error(userid)

        data = user.get_api_data()

        return data

    @HasPermissionAnyDecorator('hg.admin')

        """

        Lists all existing users. This command can be executed only using api_key

        belonging to user with admin rights.

        OUTPUT::

        return result

    @HasPermissionAnyDecorator('hg.admin')

                    firstname=Optional(''), lastname=Optional(''),

                    active=Optional(True), admin=Optional(False),

                    extern_type=Optional(User.DEFAULT_AUTH_TYPE),

        Creates new user. Returns new user object. This command can

        be executed only using api_key belonging to user with admin rights.

        :param username: new username

        :type username: str or int

        :param email: email

            raise JSONRPCError('failed to create user `%s`' % (username,))

    @HasPermissionAnyDecorator('hg.admin')

                    email=Optional(None), password=Optional(None),

                    firstname=Optional(None), lastname=Optional(None),

                    active=Optional(None), admin=Optional(None),

        updates given user if such user exists. This command can

        be executed only using api_key belonging to user with admin rights.

        :param userid: userid to update

        :type userid: str or int

        :param username: new username

            raise JSONRPCError('failed to update user `%s`' % (userid,))

    @HasPermissionAnyDecorator('hg.admin')

        """

        deletes given user if such user exists. This command can

        be executed only using api_key belonging to user with admin rights.

        :param userid: user to delete

        :type userid: str or int

                               % (user.user_id, user.username))

    # permission check inside

        """

        Gets an existing user group. This command can be executed only using api_key

        belonging to user with admin rights or user who has at least

        read access to user group.

        :param usergroupid: id of user_group to edit

        :type usergroupid: str or int

        return data

    # permission check inside

        """

        Lists all existing user groups. This command can be executed only using

        api_key belonging to user with admin rights or user who has at least

        read access to user group.

        OUTPUT::

        return result

    @HasPermissionAnyDecorator('hg.admin', 'hg.usergroup.create.true')

                          owner=Optional(OAttr('apiuser')), active=Optional(True)):

        """

        Creates new user group. This command can be executed only using api_key

        belonging to user with admin rights or an user who has create user group

        permission

        :param group_name: name of new user group

        :type group_name: str

        :param description: group description

        try:

            if isinstance(owner, Optional):

            owner = get_user_or_error(owner)

            active = Optional.extract(active)

            raise JSONRPCError('failed to create group `%s`' % (group_name,))

    # permission check inside

                          description=Optional(''), owner=Optional(None),

                          active=Optional(True)):

        """

        Updates given usergroup.  This command can be executed only using api_key

        belonging to user with admin rights or an admin of given user group

        :param usergroupid: id of user group to update

        :type usergroupid: str or int

        :param group_name: name of new user group

            raise JSONRPCError('failed to update user group `%s`' % (usergroupid,))

    # permission check inside

        """

        Delete given user group by user group id or name.

        This command can be executed only using api_key

        belonging to user with admin rights or an admin of given user group

        :param usergroupid:

        :type usergroupid: int

                               )

    # permission check inside

        """

        Adds a user to a user group. If user exists in that group success will be

        `false`. This command can be executed only using api_key

        belonging to user with admin rights  or an admin of given user group

        :param usergroupid:

        :type usergroupid: int

        :param userid:

            )

    # permission check inside

        """

        Removes a user from a user group. If user is not in given group success will

        be `false`. This command can be executed only

        using api_key belonging to user with admin rights or an admin of given user group

        :param usergroupid:

        :param userid:

            )

    # permission check inside

        """

        Gets an existing repository by it's name or repository_id. Members will return

        either users_group or user associated to that repository. This command can be

        executed only using api_key belonging to user with admin

        rights or regular user that have at least read access to repository.

        :param repoid: repository name or repository id

        :type repoid: str or int

        return data

    # permission check inside

        """

        Lists all existing repositories. This command can be executed only using

        api_key belonging to user with admin rights or regular user that have

        admin, write or read access to repository.

        OUTPUT::

        """

        result = []

        if not HasPermissionAnyApi('hg.admin')():

        else:

            repos = Repository.get_all()

        return result

    # permission check inside

                       ret_type=Optional('all')):

        """

        returns a list of nodes and it's children in a flat list for a given path

        `dirs`.  This command can be executed only using api_key belonging to

        user with admin rights or regular user that have at least read access to repository.

        :param repoid: repository name or repository id

        :type repoid: str or int

        :param revision: revision for which listing should be done

            )

    @HasPermissionAnyDecorator('hg.admin', 'hg.create.repository')

                    repo_type=Optional('hg'), description=Optional(''),

                    private=Optional(False), clone_uri=Optional(None),

                    landing_rev=Optional('rev:tip'),

        belonging to user with admin rights or regular user that have create

        repository permission. Regular users cannot specify owner parameter

        :param repo_name: repository name

        :type repo_name: str

        :param owner: user_id or username

                    'Only Kallithea admin can specify `owner` param'

                )

        if isinstance(owner, Optional):

        owner = get_user_or_error(owner)

                'failed to create repository `%s`' % (repo_name,))

    # permission check inside

                    owner=Optional(OAttr('apiuser')),

                    group=Optional(None),

                    description=Optional(''), private=Optional(False),

        """

        Updates repo

        :param repoid: repository name or repository id

        :type repoid: str or int

        :param name:

            raise JSONRPCError('failed to update repo `%s`' % repoid)

    @HasPermissionAnyDecorator('hg.admin', 'hg.fork.repository')

                  owner=Optional(OAttr('apiuser')),

                  description=Optional(''), copy_permissions=Optional(False),

                  private=Optional(False), landing_rev=Optional('rev:tip')):

        user with admin rights or regular user that have fork permission, and at least

        read access to forking repository. Regular users cannot specify owner parameter.

        :param repoid: repository name or repository id

        :type repoid: str or int

        :param fork_name:

            raise JSONRPCError('repository `%s` does not exist' % (repoid,))

        if isinstance(owner, Optional):

        owner = get_user_or_error(owner)

            )

    # permission check inside

        """

        Deletes a repository. This command can be executed only using api_key belonging

        to user with admin rights or regular user that have admin access to repository.

        When `forks` param is set it's possible to detach or delete forks of deleting

        repository

        :param repoid: repository name or repository id

        :type repoid: str or int

        :param forks: `detach` or `delete`, what do do with attached forks for repo

            )

    @HasPermissionAnyDecorator('hg.admin')

        """

        Grant permission for user on given repository, or update existing one

        if found. This command can be executed only using api_key belonging to user

        with admin rights.

        :param repoid: repository name or repository id

        :type repoid: str or int

        :param userid:

            )

    @HasPermissionAnyDecorator('hg.admin')

        """

        Revoke permission for user on given repository. This command can be executed

        only using api_key belonging to user with admin rights.

        :param repoid: repository name or repository id

        :type repoid: str or int

        :param userid:

            )

    # permission check inside

        """

        Grant permission for user group on given repository, or update

        existing one if found. This command can be executed only using

        api_key belonging to user with admin rights.

        :param repoid: repository name or repository id

        :type repoid: str or int

        :param usergroupid: id of usergroup

            )

    # permission check inside

        """

        Revoke permission for user group on given repository. This command can be

        executed only using api_key belonging to user with admin rights.

        :param repoid: repository name or repository id

        :type repoid: str or int

        :param usergroupid:

            )

    @HasPermissionAnyDecorator('hg.admin')

        """

        Returns given repo group together with permissions, and repositories

        inside the group

        :param repogroupid: id/name of repository group

        :type repogroupid: str or int

        """

        return data

    @HasPermissionAnyDecorator('hg.admin')

        """

        Returns all repository groups

        """

        result = []

        for repo_group in RepoGroup.get_all():

        return result

    @HasPermissionAnyDecorator('hg.admin')

                          owner=Optional(OAttr('apiuser')),

                          parent=Optional(None),

                          copy_permissions=Optional(False)):

        Creates a repository group. This command can be executed only using

        api_key belonging to user with admin rights.

        :param group_name:

        :type group_name:

        :param description:

            raise JSONRPCError("repo group `%s` already exist" % (group_name,))

        if isinstance(owner, Optional):

        group_description = Optional.extract(description)

        parent_group = Optional.extract(parent)

        if not isinstance(parent, Optional):

            raise JSONRPCError('failed to create repo group `%s`' % (group_name,))

    @HasPermissionAnyDecorator('hg.admin')

                          description=Optional(''),

                          owner=Optional(OAttr('apiuser')),

                          parent=Optional(None), enable_locking=Optional(False)):

                               % (repogroupid,))

    @HasPermissionAnyDecorator('hg.admin')

        """

        :param repogroupid: name or id of repository group

        :type repogroupid: str or int

                               )

    # permission check inside

                                            perm, apply_to_children=Optional('none')):

        """

        Grant permission for user on given repository group, or update existing

        to user with admin rights, or user who has admin right to given repository

        group.

        :param repogroupid: name or id of repository group

        :type repogroupid: str or int

        :param userid:

                    userid, repo_group.name))

    # permission check inside

                                               apply_to_children=Optional('none')):

        """

        Revoke permission for user on given repository group. This command can

        be executed only using api_key belonging to user with admin rights, or

        user who has admin right to given repository group.

        :param repogroupid: name or id of repository group

        :type repogroupid: str or int

        :param userid:

    # permission check inside

    def grant_user_group_permission_to_repo_group(

            apply_to_children=Optional('none')):

        """

        Grant permission for user group on given repository group, or update

        api_key belonging to user with admin rights, or user who has admin

        right to given repository group.

        :param repogroupid: name or id of repository group

        :type repogroupid: str or int

        :param usergroupid: id of usergroup

    # permission check inside

    def revoke_user_group_permission_from_repo_group(

            apply_to_children=Optional('none')):

        """

        Revoke permission for user group on given repository. This command can be

        executed only using api_key belonging to user with admin rights, or

        user who has admin right to given repository group.

        :param repogroupid: name or id of repository group

        :type repogroupid: str or int

        :param usergroupid:

                )

            )

        """

        Get given gist by id

        :param gistid: id of private or public gist

        :type gistid: str

        """

        gist = get_gist_or_error(gistid)

        if not HasPermissionAnyApi('hg.admin')():

                raise JSONRPCError('gist `%s` does not exist' % (gistid,))

        return gist.get_api_data()

        """

        Get all gists for given user. If userid is empty returned gists

        are for user who called the api

        :param userid: user to get gists for

        :type userid: Optional(str or int)

        """

        if not HasPermissionAnyApi('hg.admin')():

            # make sure normal user does not pass someone else userid,

            # he is not allowed to do that

                raise JSONRPCError(

                    'userid is not the same as your user'

                )

        if isinstance(userid, Optional):

        else:

            user_id = get_user_or_error(userid).user_id

            gists.append(gist.get_api_data())

        return gists

                    gist_type=Optional(Gist.GIST_PUBLIC), lifetime=Optional(-1),

                    description=Optional('')):

        """

        Creates new Gist

        :param files: files to be added to gist

            {'filename': {'content':'...', 'lexer': null},

             'filename2': {'content':'...', 'lexer': null}}

        """

        try:

            if isinstance(owner, Optional):

            owner = get_user_or_error(owner)

            description = Optional.extract(description)

            log.error(traceback.format_exc())

            raise JSONRPCError('failed to create gist')

    #                 gist_type=Optional(Gist.GIST_PUBLIC),

    #                 gist_lifetime=Optional(-1), gist_description=Optional('')):

    #     gist = get_gist_or_error(gistid)

    #     updates = {}

    # permission check inside

        """

        Deletes existing gist

        :param gistid: id of gist to delete

        :type gistid: str

        """

        gist = get_gist_or_error(gistid)

        if not HasPermissionAnyApi('hg.admin')():

                raise JSONRPCError('gist `%s` does not exist' % (gistid,))

        try: