Changeset - 884d2c246570
Parent rev.
Child rev.
[Not reviewed]
default
0 4 0
Søren Løvborg - 9 years ago 2017-02-20 19:21:34
sorenl@unity3d.com
cleanup: use list comprehensions

It's often the same number of lines, but avoids introducing a needless
"result" variable, and makes the item expression stand out more clearly.

It's also a tiny bit faster, but the readability gains is what matters.
4 files changed with 50 insertions and 54 deletions:
kallithea/controllers/api/api.py
29
30
kallithea/controllers/compare.py
5
5
kallithea/model/db.py
8
9
kallithea/tests/api/api_base.py
8
10
0 comments (0 inline, 0 general)
kallithea/controllers/api/api.py
➞
Show inline comments
 
@@ -575,31 +575,30 @@ class ApiController(JSONRPCController):
 
        """
 
        Lists all existing users. This command can be executed only using api_key
 
        belonging to user with admin rights.
 

			




	
	
	
		
 

			




	
	
	
		
 
        OUTPUT::

			




	
	
	
		
 

			




	
	
	
		
 
            id : <id_given_in_input>

			




	
	
	
		
 
            result: [<user_object>, ...]

			




	
	
	
		
 
            error:  null

			




	
	
	
		
 
        """

			




	
	
	
		
 

			




	
	
	
		
 
        result = []

			




	
	
	
		
 
        users_list = User.query().order_by(User.username) \

			




	
	
	
		
 
            .filter(User.username != User.DEFAULT_USER) \

			




	
	
	
		
 
            .all()

			




	
	
	
		
 
        for user in users_list:

			




	
	
	
		
 
            result.append(user.get_api_data())

			




	
	
	
		
 
        return result

			




	
	
	
		
 
        return [

			




	
	
	
		
 
            user.get_api_data()

			




	
	
	
		
 
            for user in User.query()

			




	
	
	
		
 
                .order_by(User.username)

			




	
	
	
		
 
                .filter(User.username != User.DEFAULT_USER)

			




	
	
	
		
 
        ]

			




	
	
	
		
 

			




	
	
	
		
 
    @HasPermissionAnyDecorator('hg.admin')

			




	
	
	
		
 
    def create_user(self, username, email, password=Optional(''),

			




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

			




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

			




	
	
	
		
 
                    extern_type=Optional(User.DEFAULT_AUTH_TYPE),

			




	
	
	
		
 
                    extern_name=Optional('')):

			




	
	
	
		
 
        """

			




	
	
	
		
 
        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

			




	
	
		
 
@@ -832,28 +831,28 @@ class ApiController(JSONRPCController):

			




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

			




	
	
	
		
 

			




	
	
	
		
 
            id : <id_given_in_input>

			




	
	
	
		
 
            result : [<user_group_obj>,...]

			




	
	
	
		
 
            error : null

			




	
	
	
		
 
        """

			




	
	
	
		
 

			




	
	
	
		
 
        result = []

			




	
	
	
		
 
        for user_group in UserGroupList(UserGroup.query().all(), perm_level='read'):

			




	
	
	
		
 
            result.append(user_group.get_api_data())

			




	
	
	
		
 
        return result

			




	
	
	
		
 
        return [

			




	
	
	
		
 
            user_group.get_api_data()

			




	
	
	
		
 
            for user_group in UserGroupList(UserGroup.query().all(), perm_level='read')

			




	
	
	
		
 
        ]

			




	
	
	
		
 

			




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

			




	
	
	
		
 
    def create_user_group(self, group_name, description=Optional(''),

			




	
	
	
		
 
                          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

			




	
	
		
 
@@ -1178,47 +1177,48 @@ class ApiController(JSONRPCController):

			




	
	
	
		
 
            }

			




	
	
	
		
 
          }

			




	
	
	
		
 
          error :  null

			




	
	
	
		
 

			




	
	
	
		
 
        """

			




	
	
	
		
 
        repo = get_repo_or_error(repoid)

			




	
	
	
		
 

			




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

			




	
	
	
		
 
            if not HasRepoPermissionLevel('read')(repo.repo_name):

			




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

			




	
	
	
		
 

			




	
	
	
		
 
        members = []

			




	
	
	
		
 
        followers = []

			




	
	
	
		
 
        for user in repo.repo_to_perm:

			




	
	
	
		
 
            perm = user.permission.permission_name

			




	
	
	
		
 
            user = user.user

			




	
	
	
		
 
            user_data = {

			




	
	
	
		
 
                'name': user.username,

			




	
	
	
		
 
                'type': "user",

			




	
	
	
		
 
                'permission': perm

			




	
	
	
		
 
            }

			




	
	
	
		
 
            members.append(user_data)

			




	
	
	
		
 

			




	
	
	
		
 
        for user_group in repo.users_group_to_perm:

			




	
	
	
		
 
            perm = user_group.permission.permission_name

			




	
	
	
		
 
            user_group = user_group.users_group

			




	
	
	
		
 
            user_group_data = {

			




	
	
	
		
 
                'name': user_group.users_group_name,

			




	
	
	
		
 
                'type': "user_group",

			




	
	
	
		
 
                'permission': perm

			




	
	
	
		
 
            }

			




	
	
	
		
 
            members.append(user_group_data)

			




	
	
	
		
 

			




	
	
	
		
 
        for user in repo.followers:

			




	
	
	
		
 
            followers.append(user.user.get_api_data())

			




	
	
	
		
 
        followers = [

			




	
	
	
		
 
            uf.user.get_api_data()

			




	
	
	
		
 
            for uf in repo.followers

			




	
	
	
		
 
        ]

			




	
	
	
		
 

			




	
	
	
		
 
        data = repo.get_api_data()

			




	
	
	
		
 
        data['members'] = members

			




	
	
	
		
 
        data['followers'] = followers

			




	
	
	
		
 
        return data

			




	
	
	
		
 

			




	
	
	
		
 
    # permission check inside

			




	
	
	
		
 
    def get_repos(self):

			




	
	
	
		
 
        """

			




	
	
	
		
 
        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.

			




	
	
		
 
@@ -1238,33 +1238,33 @@ class ApiController(JSONRPCController):

			




	
	
	
		
 
                        "description" :      "<description>",

			




	
	
	
		
 
                        "landing_rev":       "<landing_rev>",

			




	
	
	
		
 
                        "owner":             "<repo_owner>",

			




	
	
	
		
 
                        "fork_of":           "<name_of_fork_parent>",

			




	
	
	
		
 
                        "enable_downloads":  "<bool>",

			




	
	
	
		
 
                        "enable_locking":    "<bool>",

			




	
	
	
		
 
                        "enable_statistics": "<bool>",

			




	
	
	
		
 
                      },

			




	
	
	
		
 
                      …

			




	
	
	
		
 
                    ]

			




	
	
	
		
 
            error:  null

			




	
	
	
		
 
        """

			




	
	
	
		
 
        result = []

			




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

			




	
	
	
		
 
            repos = RepoModel().get_all_user_repos(user=request.authuser.user_id)

			




	
	
	
		
 
        else:

			




	
	
	
		
 
            repos = Repository.query()

			




	
	
	
		
 

			




	
	
	
		
 
        for repo in repos:

			




	
	
	
		
 
            result.append(repo.get_api_data())

			




	
	
	
		
 
        return result

			




	
	
	
		
 
        return [

			




	
	
	
		
 
            repo.get_api_data()

			




	
	
	
		
 
            for repo in repos

			




	
	
	
		
 
        ]

			




	
	
	
		
 

			




	
	
	
		
 
    # permission check inside

			




	
	
	
		
 
    def get_repo_nodes(self, repoid, revision, root_path,

			




	
	
	
		
 
                       ret_type=Optional('all')):

			




	
	
	
		
 
        """

			




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

			




	
	
	
		
 
        at given revision. It's possible to specify ret_type to show only `files` or

			




	
	
	
		
 
        `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

			




	
	
		
 
@@ -1901,28 +1901,28 @@ class ApiController(JSONRPCController):

			




	
	
	
		
 
            members.append(user_group_data)

			




	
	
	
		
 

			




	
	
	
		
 
        data = repo_group.get_api_data()

			




	
	
	
		
 
        data["members"] = members

			




	
	
	
		
 
        return data

			




	
	
	
		
 

			




	
	
	
		
 
    @HasPermissionAnyDecorator('hg.admin')

			




	
	
	
		
 
    def get_repo_groups(self):

			




	
	
	
		
 
        """

			




	
	
	
		
 
        Returns all repository groups

			




	
	
	
		
 

			




	
	
	
		
 
        """

			




	
	
	
		
 
        result = []

			




	
	
	
		
 
        for repo_group in RepoGroup.query():

			




	
	
	
		
 
            result.append(repo_group.get_api_data())

			




	
	
	
		
 
        return result

			




	
	
	
		
 
        return [

			




	
	
	
		
 
            repo_group.get_api_data()

			




	
	
	
		
 
            for repo_group in RepoGroup.query()

			




	
	
	
		
 
        ]

			




	
	
	
		
 

			




	
	
	
		
 
    @HasPermissionAnyDecorator('hg.admin')

			




	
	
	
		
 
    def create_repo_group(self, group_name, description=Optional(''),

			




	
	
	
		
 
                          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:

			




	
	
		
 
@@ -2343,32 +2343,31 @@ class ApiController(JSONRPCController):

			




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

			




	
	
	
		
 
            # he is not allowed to do that

			




	
	
	
		
 
            if not isinstance(userid, Optional) and userid != request.authuser.user_id:

			




	
	
	
		
 
                raise JSONRPCError(

			




	
	
	
		
 
                    'userid is not the same as your user'

			




	
	
	
		
 
                )

			




	
	
	
		
 

			




	
	
	
		
 
        if isinstance(userid, Optional):

			




	
	
	
		
 
            user_id = request.authuser.user_id

			




	
	
	
		
 
        else:

			




	
	
	
		
 
            user_id = get_user_or_error(userid).user_id

			




	
	
	
		
 

			




	
	
	
		
 
        gists = []

			




	
	
	
		
 
        _gists = Gist().query() \

			




	
	
	
		
 
            .filter(or_(Gist.gist_expires == -1, Gist.gist_expires >= time.time())) \

			




	
	
	
		
 
            .filter(Gist.owner_id == user_id) \

			




	
	
	
		
 
            .order_by(Gist.created_on.desc())

			




	
	
	
		
 
        for gist in _gists:

			




	
	
	
		
 
            gists.append(gist.get_api_data())

			




	
	
	
		
 
        return gists

			




	
	
	
		
 
        return [

			




	
	
	
		
 
            gist.get_api_data()

			




	
	
	
		
 
            for gist in Gist().query()

			




	
	
	
		
 
                .filter(or_(Gist.gist_expires == -1, Gist.gist_expires >= time.time()))

			




	
	
	
		
 
                .filter(Gist.owner_id == user_id)

			




	
	
	
		
 
                .order_by(Gist.created_on.desc())

			




	
	
	
		
 
        ]

			




	
	
	
		
 

			




	
	
	
		
 
    def create_gist(self, files, owner=Optional(OAttr('apiuser')),

			




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

			




	
	
	
		
 
        :type files: dict

			




        

    


    
    

    

        

                

                    kallithea/controllers/compare.py
                

                

                  
                      
                        

                      ➞

                      
                        
                  

                  
                      
                  
                      
                  
                      
                  
                      
                  
                  
                

                

                    Show inline comments
                    
                

        

        

            



	
	
		
 
@@ -125,29 +125,29 @@ class CompareController(BaseRepoControll

			




	
	
	
		
 

			




	
	
	
		
 
        elif alias == 'git':

			




	
	
	
		
 
            if org_repo != other_repo:

			




	
	
	
		
 
                from dulwich.repo import Repo

			




	
	
	
		
 
                from dulwich.client import SubprocessGitClient

			




	
	
	
		
 

			




	
	
	
		
 
                gitrepo = Repo(org_repo.path)

			




	
	
	
		
 
                SubprocessGitClient(thin_packs=False).fetch(safe_str(other_repo.path), gitrepo)

			




	
	
	
		
 

			




	
	
	
		
 
                gitrepo_remote = Repo(other_repo.path)

			




	
	
	
		
 
                SubprocessGitClient(thin_packs=False).fetch(safe_str(org_repo.path), gitrepo_remote)

			




	
	
	
		
 

			




	
	
	
		
 
                revs = []

			




	
	
	
		
 
                for x in gitrepo_remote.get_walker(include=[other_rev],

			




	
	
	
		
 
                                                   exclude=[org_rev]):

			




	
	
	
		
 
                    revs.append(x.commit.id)

			




	
	
	
		
 

			




	
	
	
		
 
                revs = [

			




	
	
	
		
 
                    x.commit.id

			




	
	
	
		
 
                    for x in gitrepo_remote.get_walker(include=[other_rev],

			




	
	
	
		
 
                                                       exclude=[org_rev])

			




	
	
	
		
 
                ]

			




	
	
	
		
 
                other_changesets = [other_repo.get_changeset(rev) for rev in reversed(revs)]

			




	
	
	
		
 
                if other_changesets:

			




	
	
	
		
 
                    ancestors = [other_changesets[0].parents[0].raw_id]

			




	
	
	
		
 
                else:

			




	
	
	
		
 
                    # no changesets from other repo, ancestor is the other_rev

			




	
	
	
		
 
                    ancestors = [other_rev]

			




	
	
	
		
 

			




	
	
	
		
 
                gitrepo.close()

			




	
	
	
		
 
                gitrepo_remote.close()

			




	
	
	
		
 

			




	
	
	
		
 
            else:

			




	
	
	
		
 
                so, se = org_repo.run_git_command(

			




        

    


    
    

    

        

                

                    kallithea/model/db.py
                

                

                  
                      
                        

                      ➞

                      
                        
                  

                  
                      
                  
                      
                  
                      
                  
                      
                  
                  
                

                

                    Show inline comments
                    
                

        

        

            



	
	
		
 
@@ -91,28 +91,28 @@ class BaseDbModel(object):

			




	
	
	
		
 
        if _json_attr:

			




	
	
	
		
 
            # update with attributes from __json__

			




	
	
	
		
 
            if callable(_json_attr):

			




	
	
	
		
 
                _json_attr = _json_attr()

			




	
	
	
		
 
            for k, val in _json_attr.iteritems():

			




	
	
	
		
 
                d[k] = val

			




	
	
	
		
 
        return d

			




	
	
	
		
 

			




	
	
	
		
 
    def get_appstruct(self):

			




	
	
	
		
 
        """return list with keys and values tuples corresponding

			




	
	
	
		
 
        to this model data """

			




	
	
	
		
 

			




	
	
	
		
 
        l = []

			




	
	
	
		
 
        for k in self._get_keys():

			




	
	
	
		
 
            l.append((k, getattr(self, k),))

			




	
	
	
		
 
        return l

			




	
	
	
		
 
        return [

			




	
	
	
		
 
            (k, getattr(self, k))

			




	
	
	
		
 
            for k in self._get_keys()

			




	
	
	
		
 
        ]

			




	
	
	
		
 

			




	
	
	
		
 
    def populate_obj(self, populate_dict):

			




	
	
	
		
 
        """populate model with data from given populate_dict"""

			




	
	
	
		
 

			




	
	
	
		
 
        for k in self._get_keys():

			




	
	
	
		
 
            if k in populate_dict:

			




	
	
	
		
 
                setattr(self, k, populate_dict[k])

			




	
	
	
		
 

			




	
	
	
		
 
    @classmethod

			




	
	
	
		
 
    def query(cls):

			




	
	
	
		
 
        return Session().query(cls)

			




	
	
	
		
 

			




	
	
		
 
@@ -906,29 +906,28 @@ class UserGroup(Base, BaseDbModel):

			




	
	
	
		
 

			




	
	
	
		
 
    def get_api_data(self, with_members=True):

			




	
	
	
		
 
        user_group = self

			




	
	
	
		
 

			




	
	
	
		
 
        data = dict(

			




	
	
	
		
 
            users_group_id=user_group.users_group_id,

			




	
	
	
		
 
            group_name=user_group.users_group_name,

			




	
	
	
		
 
            group_description=user_group.user_group_description,

			




	
	
	
		
 
            active=user_group.users_group_active,

			




	
	
	
		
 
            owner=user_group.owner.username,

			




	
	
	
		
 
        )

			




	
	
	
		
 
        if with_members:

			




	
	
	
		
 
            members = []

			




	
	
	
		
 
            for user in user_group.members:

			




	
	
	
		
 
                user = user.user

			




	
	
	
		
 
                members.append(user.get_api_data())

			




	
	
	
		
 
            data['members'] = members

			




	
	
	
		
 
            data['members'] = [

			




	
	
	
		
 
                ugm.user.get_api_data()

			




	
	
	
		
 
                for ugm in user_group.members

			




	
	
	
		
 
            ]

			




	
	
	
		
 

			




	
	
	
		
 
        return data

			




	
	
	
		
 

			




	
	
	
		
 

			




	
	
	
		
 
class UserGroupMember(Base, BaseDbModel):

			




	
	
	
		
 
    __tablename__ = 'users_groups_members'

			




	
	
	
		
 
    __table_args__ = (

			




	
	
	
		
 
        _table_args_default_dict,

			




	
	
	
		
 
    )

			




	
	
	
		
 

			




	
	
	
		
 
    users_group_member_id = Column(Integer(), primary_key=True)

			




	
	
	
		
 
    users_group_id = Column(Integer(), ForeignKey('users_groups.users_group_id'), nullable=False)

			




        

    


    
    

    

        

                

                    kallithea/tests/api/api_base.py
                

                

                  
                      
                        

                      ➞

                      
                        
                  

                  
                      
                  
                      
                  
                      
                  
                      
                  
                  
                

                

                    Show inline comments
                    
                

        

        

            



	
	
		
 
@@ -868,42 +868,40 @@ class _BaseTestApi(object):

			




	
	
	
		
 
        id_, params = _build_data(self.apikey, 'get_repo',

			




	
	
	
		
 
                                  repoid='no-such-repo')

			




	
	
	
		
 
        response = api_call(self, params)

			




	
	
	
		
 

			




	
	
	
		
 
        ret = 'repository `%s` does not exist' % 'no-such-repo'

			




	
	
	
		
 
        expected = ret

			




	
	
	
		
 
        self._compare_error(id_, expected, given=response.body)

			




	
	
	
		
 

			




	
	
	
		
 
    def test_api_get_repos(self):

			




	
	
	
		
 
        id_, params = _build_data(self.apikey, 'get_repos')

			




	
	
	
		
 
        response = api_call(self, params)

			




	
	
	
		
 

			




	
	
	
		
 
        result = []

			




	
	
	
		
 
        for repo in Repository.query():

			




	
	
	
		
 
            result.append(repo.get_api_data())

			




	
	
	
		
 
        ret = jsonify(result)

			




	
	
	
		
 
        expected = jsonify([

			




	
	
	
		
 
            repo.get_api_data()

			




	
	
	
		
 
            for repo in Repository.query()

			




	
	
	
		
 
        ])

			




	
	
	
		
 

			




	
	
	
		
 
        expected = ret

			




	
	
	
		
 
        self._compare_ok(id_, expected, given=response.body)

			




	
	
	
		
 

			




	
	
	
		
 
    def test_api_get_repos_non_admin(self):

			




	
	
	
		
 
        id_, params = _build_data(self.apikey_regular, 'get_repos')

			




	
	
	
		
 
        response = api_call(self, params)

			




	
	
	
		
 

			




	
	
	
		
 
        result = []

			




	
	
	
		
 
        for repo in RepoModel().get_all_user_repos(self.TEST_USER_LOGIN):

			




	
	
	
		
 
            result.append(repo.get_api_data())

			




	
	
	
		
 
        ret = jsonify(result)

			




	
	
	
		
 
        expected = jsonify([

			




	
	
	
		
 
            repo.get_api_data()

			




	
	
	
		
 
            for repo in RepoModel().get_all_user_repos(self.TEST_USER_LOGIN)

			




	
	
	
		
 
        ])

			




	
	
	
		
 

			




	
	
	
		
 
        expected = ret

			




	
	
	
		
 
        self._compare_ok(id_, expected, given=response.body)

			




	
	
	
		
 

			




	
	
	
		
 
    @parametrize('name,ret_type', [

			




	
	
	
		
 
        ('all', 'all'),

			




	
	
	
		
 
        ('dirs', 'dirs'),

			




	
	
	
		
 
        ('files', 'files'),

			




	
	
	
		
 
    ])

			




	
	
	
		
 
    def test_api_get_repo_nodes(self, name, ret_type):

			




	
	
	
		
 
        rev = 'tip'

			




	
	
	
		
 
        path = '/'

			




	
	
	
		
 
        id_, params = _build_data(self.apikey, 'get_repo_nodes',

			




	
	
	
		
 
                                  repoid=self.REPO, revision=rev,

			




        

    



    


    



    



      

      





    
    0 comments (0 inline, 0 general)
    





    


  

  







  


    




    








    
        
    
    
        This site is powered by
            Kallithea 0.7.0,
        which is
        © 2010–2025 by various authors & licensed under GPLv3.