Changeset - 8c99d5d8eb0e
Parent rev.
Child rev.
[Not reviewed]
default
0 1 0
Mads Kiilerich - 6 years ago 2020-01-02 00:57:38
mads@kiilerich.com
Grafted from: 7c11d8ff3bf7
cleanup: fix db.py "import *"

pyflakes rightfully complains about wildcard imports. But we like to keep the
short names, so let's just be explicit about which names we import.
1 file changed with 10 insertions and 10 deletions:
kallithea/model/db.py
10
10
0 comments (0 inline, 0 general)
kallithea/model/db.py
➞
Show inline comments
 
@@ -35,13 +35,13 @@ import os
 
import time
 
import traceback
 

			




	
	
	
		
 
import ipaddr

			




	
	
	
		
 
import sqlalchemy

			




	
	
	
		
 
from beaker.cache import cache_region, region_invalidate

			




	
	
	
		
 
from sqlalchemy import *

			




	
	
	
		
 
from sqlalchemy import Boolean, Column, DateTime, Float, ForeignKey, Index, Integer, LargeBinary, String, Unicode, UnicodeText, UniqueConstraint

			




	
	
	
		
 
from sqlalchemy.ext.hybrid import hybrid_property

			




	
	
	
		
 
from sqlalchemy.orm import class_mapper, joinedload, relationship, validates

			




	
	
	
		
 
from tg.i18n import lazy_ugettext as _

			




	
	
	
		
 
from webob.exc import HTTPNotFound

			




	
	
	
		
 

			




	
	
	
		
 
import kallithea

			




	
	
		
 
@@ -564,13 +564,13 @@ class User(Base, BaseDbModel):

			




	
	
	
		
 
        else:

			




	
	
	
		
 
            return User.get_by_username(username_or_email, case_insensitive=case_insensitive, cache=cache)

			




	
	
	
		
 

			




	
	
	
		
 
    @classmethod

			




	
	
	
		
 
    def get_by_username(cls, username, case_insensitive=False, cache=False):

			




	
	
	
		
 
        if case_insensitive:

			




	
	
	
		
 
            q = cls.query().filter(func.lower(cls.username) == func.lower(username))

			




	
	
	
		
 
            q = cls.query().filter(sqlalchemy.func.lower(cls.username) == sqlalchemy.func.lower(username))

			




	
	
	
		
 
        else:

			




	
	
	
		
 
            q = cls.query().filter(cls.username == username)

			




	
	
	
		
 

			




	
	
	
		
 
        if cache:

			




	
	
	
		
 
            q = q.options(FromCache(

			




	
	
	
		
 
                            "sql_cache_short",

			




	
	
		
 
@@ -599,23 +599,23 @@ class User(Base, BaseDbModel):

			




	
	
	
		
 
        if res is None or not res.active or res.is_default_user:

			




	
	
	
		
 
            return None

			




	
	
	
		
 
        return res

			




	
	
	
		
 

			




	
	
	
		
 
    @classmethod

			




	
	
	
		
 
    def get_by_email(cls, email, cache=False):

			




	
	
	
		
 
        q = cls.query().filter(func.lower(cls.email) == func.lower(email))

			




	
	
	
		
 
        q = cls.query().filter(sqlalchemy.func.lower(cls.email) == sqlalchemy.func.lower(email))

			




	
	
	
		
 

			




	
	
	
		
 
        if cache:

			




	
	
	
		
 
            q = q.options(FromCache("sql_cache_short",

			




	
	
	
		
 
                                    "get_email_key_%s" % email))

			




	
	
	
		
 

			




	
	
	
		
 
        ret = q.scalar()

			




	
	
	
		
 
        if ret is None:

			




	
	
	
		
 
            q = UserEmailMap.query()

			




	
	
	
		
 
            # try fetching in alternate email map

			




	
	
	
		
 
            q = q.filter(func.lower(UserEmailMap.email) == func.lower(email))

			




	
	
	
		
 
            q = q.filter(sqlalchemy.func.lower(UserEmailMap.email) == sqlalchemy.func.lower(email))

			




	
	
	
		
 
            q = q.options(joinedload(UserEmailMap.user))

			




	
	
	
		
 
            if cache:

			




	
	
	
		
 
                q = q.options(FromCache("sql_cache_short",

			




	
	
	
		
 
                                        "get_email_map_key_%s" % email))

			




	
	
	
		
 
            ret = getattr(q.scalar(), 'user', None)

			




	
	
	
		
 

			




	
	
		
 
@@ -854,13 +854,13 @@ class UserGroup(Base, BaseDbModel):

			




	
	
	
		
 
        return super(UserGroup, cls).guess_instance(value, UserGroup.get_by_group_name)

			




	
	
	
		
 

			




	
	
	
		
 
    @classmethod

			




	
	
	
		
 
    def get_by_group_name(cls, group_name, cache=False,

			




	
	
	
		
 
                          case_insensitive=False):

			




	
	
	
		
 
        if case_insensitive:

			




	
	
	
		
 
            q = cls.query().filter(func.lower(cls.users_group_name) == func.lower(group_name))

			




	
	
	
		
 
            q = cls.query().filter(sqlalchemy.func.lower(cls.users_group_name) == sqlalchemy.func.lower(group_name))

			




	
	
	
		
 
        else:

			




	
	
	
		
 
            q = cls.query().filter(cls.users_group_name == group_name)

			




	
	
	
		
 
        if cache:

			




	
	
	
		
 
            q = q.options(FromCache(

			




	
	
	
		
 
                            "sql_cache_short",

			




	
	
	
		
 
                            "get_group_%s" % _hash_key(group_name)

			




	
	
		
 
@@ -1051,13 +1051,13 @@ class Repository(Base, BaseDbModel):

			




	
	
	
		
 

			




	
	
	
		
 
        sorted: if True, apply the default ordering (name, case insensitive).

			




	
	
	
		
 
        """

			




	
	
	
		
 
        q = super(Repository, cls).query()

			




	
	
	
		
 

			




	
	
	
		
 
        if sorted:

			




	
	
	
		
 
            q = q.order_by(func.lower(Repository.repo_name))

			




	
	
	
		
 
            q = q.order_by(sqlalchemy.func.lower(Repository.repo_name))

			




	
	
	
		
 

			




	
	
	
		
 
        return q

			




	
	
	
		
 

			




	
	
	
		
 
    @classmethod

			




	
	
	
		
 
    def url_sep(cls):

			




	
	
	
		
 
        return URL_SEP

			




	
	
		
 
@@ -1079,13 +1079,13 @@ class Repository(Base, BaseDbModel):

			




	
	
	
		
 

			




	
	
	
		
 
    @classmethod

			




	
	
	
		
 
    def get_by_repo_name(cls, repo_name, case_insensitive=False):

			




	
	
	
		
 
        """Get the repo, defaulting to database case sensitivity.

			




	
	
	
		
 
        case_insensitive will be slower and should only be specified if necessary."""

			




	
	
	
		
 
        if case_insensitive:

			




	
	
	
		
 
            q = Session().query(cls).filter(func.lower(cls.repo_name) == func.lower(repo_name))

			




	
	
	
		
 
            q = Session().query(cls).filter(sqlalchemy.func.lower(cls.repo_name) == sqlalchemy.func.lower(repo_name))

			




	
	
	
		
 
        else:

			




	
	
	
		
 
            q = Session().query(cls).filter(cls.repo_name == repo_name)

			




	
	
	
		
 
        q = q.options(joinedload(Repository.fork)) \

			




	
	
	
		
 
                .options(joinedload(Repository.owner)) \

			




	
	
	
		
 
                .options(joinedload(Repository.group))

			




	
	
	
		
 
        return q.scalar()

			




	
	
		
 
@@ -1472,13 +1472,13 @@ class RepoGroup(Base, BaseDbModel):

			




	
	
	
		
 

			




	
	
	
		
 
        sorted: if True, apply the default ordering (name, case insensitive).

			




	
	
	
		
 
        """

			




	
	
	
		
 
        q = super(RepoGroup, cls).query()

			




	
	
	
		
 

			




	
	
	
		
 
        if sorted:

			




	
	
	
		
 
            q = q.order_by(func.lower(RepoGroup.group_name))

			




	
	
	
		
 
            q = q.order_by(sqlalchemy.func.lower(RepoGroup.group_name))

			




	
	
	
		
 

			




	
	
	
		
 
        return q

			




	
	
	
		
 

			




	
	
	
		
 
    def __init__(self, group_name='', parent_group=None):

			




	
	
	
		
 
        self.group_name = group_name

			




	
	
	
		
 
        self.parent_group = parent_group

			




	
	
		
 
@@ -1511,13 +1511,13 @@ class RepoGroup(Base, BaseDbModel):

			




	
	
	
		
 

			




	
	
	
		
 
    @classmethod

			




	
	
	
		
 
    def get_by_group_name(cls, group_name, cache=False, case_insensitive=False):

			




	
	
	
		
 
        group_name = group_name.rstrip('/')

			




	
	
	
		
 
        if case_insensitive:

			




	
	
	
		
 
            gr = cls.query() \

			




	
	
	
		
 
                .filter(func.lower(cls.group_name) == func.lower(group_name))

			




	
	
	
		
 
                .filter(sqlalchemy.func.lower(cls.group_name) == sqlalchemy.func.lower(group_name))

			




	
	
	
		
 
        else:

			




	
	
	
		
 
            gr = cls.query() \

			




	
	
	
		
 
                .filter(cls.group_name == group_name)

			




	
	
	
		
 
        if cache:

			




	
	
	
		
 
            gr = gr.options(FromCache(

			




	
	
	
		
 
                            "sql_cache_short",

			




	
	
		
 
@@ -2007,13 +2007,13 @@ class UserFollowing(Base, BaseDbModel):

			




	
	
	
		
 
    follows_user_id = Column(Integer(), ForeignKey('users.user_id'), nullable=True)

			




	
	
	
		
 
    follows_from = Column(DateTime(timezone=False), nullable=False, default=datetime.datetime.now)

			




	
	
	
		
 

			




	
	
	
		
 
    user = relationship('User', primaryjoin='User.user_id==UserFollowing.user_id')

			




	
	
	
		
 

			




	
	
	
		
 
    follows_user = relationship('User', primaryjoin='User.user_id==UserFollowing.follows_user_id')

			




	
	
	
		
 
    follows_repository = relationship('Repository', order_by=lambda: func.lower(Repository.repo_name))

			




	
	
	
		
 
    follows_repository = relationship('Repository', order_by=lambda: sqlalchemy.func.lower(Repository.repo_name))

			




	
	
	
		
 

			




	
	
	
		
 
    @classmethod

			




	
	
	
		
 
    def get_repo_followers(cls, repo_id):

			




	
	
	
		
 
        return cls.query().filter(cls.follows_repository_id == repo_id)

			




	
	
	
		
 

			




	
	
	
		
 

			




        

    



    


    



    



      

      





    
    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.