diff --git a/kallithea/model/base.py b/kallithea/model/base.py
--- a/kallithea/model/base.py
+++ b/kallithea/model/base.py
@@ -67,8 +67,7 @@ class BaseModel(object):
         :param user: UserID, username, or User instance
         """
         from kallithea.model.db import User
-        return User.guess_instance(user,
-                                  callback=User.get_by_username)
+        return User.guess_instance(user)
 
     def _get_repo(self, repository):
         """
@@ -77,8 +76,7 @@ class BaseModel(object):
         :param repository: RepoID, repository name or Repository Instance
         """
         from kallithea.model.db import Repository
-        return Repository.guess_instance(repository,
-                                  callback=Repository.get_by_repo_name)
+        return Repository.guess_instance(repository)
 
     def _get_perm(self, permission):
         """
@@ -87,5 +85,4 @@ class BaseModel(object):
         :param permission: PermissionID, permission_name or Permission instance
         """
         from kallithea.model.db import Permission
-        return Permission.guess_instance(permission,
-                                  callback=Permission.get_by_key)
+        return Permission.guess_instance(permission)
diff --git a/kallithea/model/db.py b/kallithea/model/db.py
--- a/kallithea/model/db.py
+++ b/kallithea/model/db.py
@@ -560,6 +560,10 @@ class User(Base, BaseDbModel):
                                       self.user_id, self.username)
 
     @classmethod
+    def guess_instance(cls, value):
+        return super(User, cls).guess_instance(value, User.get_by_username)
+
+    @classmethod
     def get_or_404(cls, id_, allow_default=True):
         '''
         Overridden version of BaseDbModel.get_or_404, with an extra check on
@@ -880,6 +884,10 @@ class UserGroup(Base, BaseDbModel):
                                       self.users_group_name)
 
     @classmethod
+    def guess_instance(cls, value):
+        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:
@@ -1118,6 +1126,10 @@ class Repository(Base, BaseDbModel):
         return cls.url_sep().join(repo_name.split(os.sep))
 
     @classmethod
+    def guess_instance(cls, value):
+        return super(Repository, cls).guess_instance(value, Repository.get_by_repo_name)
+
+    @classmethod
     def get_by_repo_name(cls, repo_name):
         q = Session().query(cls).filter(cls.repo_name == repo_name)
         q = q.options(joinedload(Repository.fork)) \
@@ -1562,6 +1574,10 @@ class RepoGroup(Base, BaseDbModel):
         return URL_SEP
 
     @classmethod
+    def guess_instance(cls, value):
+        return super(RepoGroup, cls).guess_instance(value, RepoGroup.get_by_group_name)
+
+    @classmethod
     def get_by_group_name(cls, group_name, cache=False, case_insensitive=False):
         group_name = group_name.rstrip('/')
         if case_insensitive:
@@ -1778,6 +1794,10 @@ class Permission(Base, BaseDbModel):
         )
 
     @classmethod
+    def guess_instance(cls, value):
+        return super(Permission, cls).guess_instance(value, Permission.get_by_key)
+
+    @classmethod
     def get_by_key(cls, key):
         return cls.query().filter(cls.permission_name == key).scalar()
 
@@ -2538,6 +2558,10 @@ class Gist(Base, BaseDbModel):
         return '<Gist:[%s]%s>' % (self.gist_type, self.gist_access_id)
 
     @classmethod
+    def guess_instance(cls, value):
+        return super(Gist, cls).guess_instance(value, Gist.get_by_access_id)
+
+    @classmethod
     def get_or_404(cls, id_):
         res = cls.query().filter(cls.gist_access_id == id_).scalar()
         if res is None:
diff --git a/kallithea/model/gist.py b/kallithea/model/gist.py
--- a/kallithea/model/gist.py
+++ b/kallithea/model/gist.py
@@ -53,7 +53,7 @@ class GistModel(BaseModel):
 
         :param gist: GistID, gist_access_id, or Gist instance
         """
-        return Gist.guess_instance(gist, callback=Gist.get_by_access_id)
+        return Gist.guess_instance(gist)
 
     def __delete_gist(self, gist):
         """
diff --git a/kallithea/model/repo.py b/kallithea/model/repo.py
--- a/kallithea/model/repo.py
+++ b/kallithea/model/repo.py
@@ -59,12 +59,10 @@ class RepoModel(BaseModel):
     URL_SEPARATOR = Repository.url_sep()
 
     def _get_user_group(self, users_group):
-        return UserGroup.guess_instance(users_group,
-                                  callback=UserGroup.get_by_group_name)
+        return UserGroup.guess_instance(users_group)
 
     def _get_repo_group(self, repo_group):
-        return RepoGroup.guess_instance(repo_group,
-                                  callback=RepoGroup.get_by_group_name)
+        return RepoGroup.guess_instance(repo_group)
 
     def _create_default_perms(self, repository, private):
         # create default permission
diff --git a/kallithea/model/repo_group.py b/kallithea/model/repo_group.py
--- a/kallithea/model/repo_group.py
+++ b/kallithea/model/repo_group.py
@@ -44,12 +44,10 @@ log = logging.getLogger(__name__)
 class RepoGroupModel(BaseModel):
 
     def _get_user_group(self, users_group):
-        return UserGroup.guess_instance(users_group,
-                                  callback=UserGroup.get_by_group_name)
+        return UserGroup.guess_instance(users_group)
 
     def _get_repo_group(self, repo_group):
-        return RepoGroup.guess_instance(repo_group,
-                                  callback=RepoGroup.get_by_group_name)
+        return RepoGroup.guess_instance(repo_group)
 
     @LazyProperty
     def repos_path(self):
diff --git a/kallithea/model/user_group.py b/kallithea/model/user_group.py
--- a/kallithea/model/user_group.py
+++ b/kallithea/model/user_group.py
@@ -40,8 +40,7 @@ log = logging.getLogger(__name__)
 class UserGroupModel(BaseModel):
 
     def _get_user_group(self, user_group):
-        return UserGroup.guess_instance(user_group,
-                                  callback=UserGroup.get_by_group_name)
+        return UserGroup.guess_instance(user_group)
 
     def _create_default_perms(self, user_group):
         # create default permission