db-models: use consistent __str__ for all models, removed safe_unicode calls

rhodecode/model/db.py

@@ -53,12 +53,13 b' from zope.cachedescriptors.property impo'
 from pyramid.threadlocal import get_current_request
 from webhelpers2.text import remove_formatting
 
+from rhodecode.lib.str_utils import safe_bytes
 from rhodecode.translation import _
 from rhodecode.lib.vcs import get_vcs_instance, VCSError
 from rhodecode.lib.vcs.backends.base import (
     EmptyCommit, Reference, unicode_to_reference, reference_to_unicode)
 from rhodecode.lib.utils2 import (
-    str2bool, safe_str, get_commit_safe, safe_unicode, sha1_safe,
+    str2bool, safe_str, get_commit_safe, sha1_safe,
     time_to_datetime, aslist, Optional, safe_int, get_clone_url, AttributeDict,
     glob2re, StrictAttributeDict, cleaned_uri, datetime_to_time)
 from rhodecode.lib.jsonalchemy import MutationObj, MutationList, JsonType, \
@@ -316,7 +317,7 b' class RhodeCodeSetting(Base, BaseModel):'
     SETTINGS_TYPES = {
         'str': safe_str,
         'int': safe_int,
-        'unicode': safe_unicode,
+        'unicode': safe_str,
         'bool': str2bool,
         'list': functools.partial(aslist, sep=',')
     }
@@ -360,7 +361,7 b' class RhodeCodeSetting(Base, BaseModel):'
 
         :param val:
         """
-        val = safe_unicode(val)
+        val = safe_str(val)
         # encode the encrypted value
         if 'encrypted' in self.app_settings_type:
             cipher = EncryptedTextValue()
@@ -436,7 +437,7 b' class RhodeCodeUi(Base, BaseModel):'
     ui_active = Column(
         "ui_active", Boolean(), nullable=True, unique=None, default=True)
 
-    def __repr__(self):
+    def __str__(self):
         return '<%s[%s]%s=>%s]>' % (self.__class__.__name__, self.ui_section,
                                     self.ui_key, self.ui_value)
 
@@ -494,7 +495,7 b' class RepoRhodeCodeSetting(Base, BaseMod'
 
         :param val:
         """
-        self._app_settings_value = safe_unicode(val)
+        self._app_settings_value = safe_str(val)
 
     @hybrid_property
     def app_settings_type(self):
@@ -508,8 +509,8 b' class RepoRhodeCodeSetting(Base, BaseMod'
                             % (SETTINGS_TYPES.keys(), val))
         self._app_settings_type = val
 
-    def __unicode__(self):
-        return u"<%s('%s:%s:%s[%s]')>" % (
+    def __str__(self):
+        return "<%s('%s:%s:%s[%s]')>" % (
             self.__class__.__name__, self.repository.repo_name,
             self.app_settings_name, self.app_settings_value,
             self.app_settings_type
@@ -542,7 +543,7 b' class RepoRhodeCodeUi(Base, BaseModel):'
 
     repository = relationship('Repository')
 
-    def __repr__(self):
+    def __str__(self):
         return '<%s[%s:%s]%s=>%s]>' % (
             self.__class__.__name__, self.repository.repo_name,
             self.ui_section, self.ui_key, self.ui_value)
@@ -626,9 +627,9 b' class User(Base, BaseModel):'
     # no cascade, set NULL
     scope_artifacts = relationship('FileStore', primaryjoin='FileStore.scope_user_id==User.user_id')
 
-    def __unicode__(self):
-        return u"<%s('id:%s:%s')>" % (self.__class__.__name__,
-                                      self.user_id, self.username)
+
+    def __str__(self):
+        return f"<{self.__class__.__name__}('id:{self.user_id}:{self.username}')>"
 
     @hybrid_property
     def email(self):
@@ -1177,8 +1178,8 b' class UserApiKeys(Base, BaseModel):'
 
     user = relationship('User', lazy='joined')
 
-    def __unicode__(self):
-        return u"<%s('%s')>" % (self.__class__.__name__, self.role)
+    def __str__(self):
+        return f"<{self.__class__.__name__}('{self.role}')>"
 
     def __json__(self):
         data = {
@@ -1318,9 +1319,8 b' class UserIpMap(Base, BaseModel):'
           'ip_range': self._get_ip_range(self.ip_addr),
         }
 
-    def __unicode__(self):
-        return u"<%s('user_id:%s=>%s')>" % (self.__class__.__name__,
-                                            self.user_id, self.ip_addr)
+    def __str__(self):
+        return "<%s('user_id:%s=>%s')>" % (self.__class__.__name__, self.user_id, self.ip_addr)
 
 
 class UserSshKeys(Base, BaseModel):
@@ -1382,9 +1382,9 b' class UserLog(Base, BaseModel):'
     user_data = Column('user_data_json', MutationObj.as_mutable(JsonType(dialect_map=dict(mysql=LONGTEXT()))))
     action_data = Column('action_data_json', MutationObj.as_mutable(JsonType(dialect_map=dict(mysql=LONGTEXT()))))
 
-    def __unicode__(self):
-        return u"<%s('id:%s:%s')>" % (
-            self.__class__.__name__, self.repository_name, self.action)
+
+    def __str__(self):
+        return f"<{self.__class__.__name__}('id:{self.repository_name}:{self.action}')>"
 
     def __json__(self):
         return {
@@ -1473,10 +1473,8 b' class UserGroup(Base, BaseModel):'
     def sync(self):
         return self._load_sync(self.group_data)
 
-    def __unicode__(self):
-        return u"<%s('id:%s:%s')>" % (self.__class__.__name__,
-                                      self.users_group_id,
-                                      self.users_group_name)
+    def __str__(self):
+        return f"<{self.__class__.__name__}('id:{self.users_group_id}:{self.users_group_name}')>"
 
     @classmethod
     def get_by_group_name(cls, group_name, cache=False,
@@ -1783,9 +1781,9 b' class Repository(Base, BaseModel):'
     # no cascade, set NULL
     artifacts = relationship('FileStore', primaryjoin='FileStore.scope_repo_id==Repository.repo_id')
 
-    def __unicode__(self):
-        return u"<%s('%s:%s')>" % (self.__class__.__name__, self.repo_id,
-                                   safe_unicode(self.repo_name))
+
+    def __str__(self):
+        return "<%s('%s:%s')>" % (self.__class__.__name__, self.repo_id, self.repo_name)
 
     @hybrid_property
     def description_safe(self):
@@ -2012,7 +2010,7 b' class Repository(Base, BaseModel):'
         # names in the database, but that eventually needs to be converted
         # into a valid system path
         p += self.repo_name.split(self.NAME_SEP)
-        return os.path.join(*map(safe_unicode, p))
+        return os.path.join(*map(safe_str, p))
 
     @property
     def cache_keys(self):
@@ -2699,8 +2697,8 b' class RepoGroup(Base, BaseModel):'
         self.group_name = group_name
         self.parent_group = parent_group
 
-    def __unicode__(self):
-        return u"<%s('id:%s:%s')>" % (
+    def __str__(self):
+        return "<%s('id:%s:%s')>" % (
             self.__class__.__name__, self.group_id, self.group_name)
 
     @hybrid_property
@@ -3233,8 +3231,8 b' class Permission(Base, BaseModel):'
     permission_name = Column("permission_name", String(255), nullable=True, unique=None, default=None)
     permission_longname = Column("permission_longname", String(255), nullable=True, unique=None, default=None)
 
-    def __unicode__(self):
-        return u"<%s('%s:%s')>" % (
+    def __str__(self):
+        return "<%s('%s:%s')>" % (
             self.__class__.__name__, self.permission_id, self.permission_name
         )
 
@@ -3422,8 +3420,8 b' class UserRepoToPerm(Base, BaseModel):'
         Session().add(n)
         return n
 
-    def __unicode__(self):
-        return u'<%s => %s >' % (self.user, self.repository)
+    def __str__(self):
+        return f'<{self.user} => {self.repository} >'
 
 
 class UserUserGroupToPerm(Base, BaseModel):
@@ -3451,8 +3449,8 b' class UserUserGroupToPerm(Base, BaseMode'
         Session().add(n)
         return n
 
-    def __unicode__(self):
-        return u'<%s => %s >' % (self.user, self.user_group)
+    def __str__(self):
+        return f'<{self.user} => {self.user_group} >'
 
 
 class UserToPerm(Base, BaseModel):
@@ -3469,8 +3467,8 b' class UserToPerm(Base, BaseModel):'
     user = relationship('User')
     permission = relationship('Permission', lazy='joined')
 
-    def __unicode__(self):
-        return u'<%s => %s >' % (self.user, self.permission)
+    def __str__(self):
+        return f'<{self.user} => {self.permission} >'
 
 
 class UserGroupRepoToPerm(Base, BaseModel):
@@ -3499,8 +3497,8 b' class UserGroupRepoToPerm(Base, BaseMode'
         Session().add(n)
         return n
 
-    def __unicode__(self):
-        return u'<UserGroupRepoToPerm:%s => %s >' % (self.users_group, self.repository)
+    def __str__(self):
+        return '<UserGroupRepoToPerm:%s => %s >' % (self.users_group, self.repository)
 
 
 class UserGroupUserGroupToPerm(Base, BaseModel):
@@ -3529,8 +3527,8 b' class UserGroupUserGroupToPerm(Base, Bas'
         Session().add(n)
         return n
 
-    def __unicode__(self):
-        return u'<UserGroupUserGroup:%s => %s >' % (self.target_user_group, self.user_group)
+    def __str__(self):
+        return '<UserGroupUserGroup:%s => %s >' % (self.target_user_group, self.user_group)
 
 
 class UserGroupToPerm(Base, BaseModel):
@@ -3599,8 +3597,8 b' class UserGroupRepoGroupToPerm(Base, Bas'
         Session().add(n)
         return n
 
-    def __unicode__(self):
-        return u'<UserGroupRepoGroupToPerm:%s => %s >' % (self.users_group, self.group)
+    def __str__(self):
+        return '<UserGroupRepoGroupToPerm:%s => %s >' % (self.users_group, self.group)
 
 
 class Statistics(Base, BaseModel):
@@ -3670,8 +3668,8 b' class CacheKey(Base, BaseModel):'
         # first key should be same for all entries, since all workers should share it
         self.cache_state_uid = cache_state_uid or self.generate_new_state_uid()
 
-    def __unicode__(self):
-        return u"<%s('%s:%s[%s]')>" % (
+    def __str__(self):
+        return "<%s('%s:%s[%s]')>" % (
             self.__class__.__name__,
             self.cache_id, self.cache_key, self.cache_active)
 
@@ -3912,11 +3910,11 b' class ChangesetComment(Base, BaseModel):'
         if self.status_change:
             return self.status_change[0].status_lbl
 
-    def __repr__(self):
+    def __str__(self):
         if self.comment_id:
-            return '<DB:Comment #%s>' % self.comment_id
+            return f'<DB:Comment #{self.comment_id}>'
         else:
-            return '<DB:Comment at %#x>' % id(self)
+            return f'<DB:Comment at {id(self)!r}>'
 
     def get_api_data(self):
         comment = self
@@ -4009,11 +4007,9 b' class ChangesetStatus(Base, BaseModel):'
     comment = relationship('ChangesetComment', lazy='select')
     pull_request = relationship('PullRequest', lazy='select')
 
-    def __unicode__(self):
-        return u"<%s('%s[v%s]:%s')>" % (
-            self.__class__.__name__,
-            self.status, self.version, self.author
-        )
+
+    def __str__(self):
+        return f"<{self.__class__.__name__}('{self.status}[v{self.version}]:{self.author}')>"
 
     @classmethod
     def get_status_lbl(cls, value):
@@ -4143,7 +4139,7 b' class _PullRequestBase(BaseModel):'
         if len(parts) != 3:
             raise ValueError(
                 'Invalid reference format given: {}, expected X:Y:Z'.format(val))
-        self._source_ref = safe_unicode(val)
+        self._source_ref = safe_str(val)
 
     _target_ref = Column('other_ref', Unicode(255), nullable=False)
 
@@ -4157,7 +4153,7 b' class _PullRequestBase(BaseModel):'
         if len(parts) != 3:
             raise ValueError(
                 'Invalid reference format given: {}, expected X:Y:Z'.format(val))
-        self._target_ref = safe_unicode(val)
+        self._target_ref = safe_str(val)
 
     @declared_attr
     def target_repo_id(cls):
@@ -4290,7 +4286,7 b' class _PullRequestBase(BaseModel):'
                 PullRequestModel().merge_status(pull_request)
             merge_state = {
                 'status': merge_status,
-                'message': safe_unicode(msg),
+                'message': safe_str(msg),
             }
         else:
             merge_state = {'status': 'not_available',
@@ -4375,12 +4371,10 b' class PullRequest(Base, _PullRequestBase'
     pull_request_id = Column(
         'pull_request_id', Integer(), nullable=False, primary_key=True)
 
-    def __repr__(self):
+    def __str__(self):
         if self.pull_request_id:
-            return '<DB:PullRequest #%s>' % self.pull_request_id
+            return f'<DB:PullRequest #{self.pull_request_id}>'
         else:
-            return '<DB:PullRequest at %#x>' % id(self)
-
     reviewers = relationship('PullRequestReviewers', cascade="all, delete-orphan")
     statuses = relationship('ChangesetStatus', cascade="all, delete-orphan")
     comments = relationship('ChangesetComment', cascade="all, delete-orphan")
@@ -4412,8 +4406,9 b' class PullRequest(Base, _PullRequestBase'
                     raise AttributeError(
                         '%s object has no attribute %s' % (self, item))
 
-            def __repr__(self):
-                return '<DB:PullRequestDisplay #%s>' % self.attrs.get('pull_request_id')
+            def __str__(self):
+                pr_id = self.attrs.get('pull_request_id')
+                return f'<DB:PullRequestDisplay #{pr_id}>'
 
             def versions(self):
                 return pull_request_obj.versions.order_by(
@@ -4546,15 +4541,16 b' class PullRequestVersion(Base, _PullRequ'
         ForeignKey('pull_requests.pull_request_id'), nullable=False)
     pull_request = relationship('PullRequest')
 
-    def __repr__(self):
+    def __str__(self):
         if self.pull_request_version_id:
-            return '<DB:PullRequestVersion #%s>' % self.pull_request_version_id
+            return f'<DB:PullRequestVersion #{self.pull_request_version_id}>'
         else:
-            return '<DB:PullRequestVersion at %#x>' % id(self)
+            return f'<DB:PullRequestVersion at {id(self)!r}>'
 
     @property
     def reviewers(self):
         return self.pull_request.reviewers
+
     @property
     def reviewers(self):
         return self.pull_request.reviewers
@@ -4648,9 +4644,8 b' class PullRequestReviewers(Base, BaseMod'
 
         return qry.all()
 
-    def __unicode__(self):
-        return u"<%s('id:%s')>" % (self.__class__.__name__,
-                                   self.pull_requests_reviewers_id)
+    def __str__(self):
+        return f"<{self.__class__.__name__}('id:{self.pull_requests_reviewers_id}')>"
 
 
 class Notification(Base, BaseModel):
@@ -4821,8 +4816,8 b' class Gist(Base, BaseModel):'
 
     owner = relationship('User')
 
-    def __repr__(self):
-        return '<Gist:[%s]%s>' % (self.gist_type, self.gist_access_id)
+    def __str__(self):
+        return f'<Gist:[{self.gist_type}]{self.gist_access_id}>'
 
     @hybrid_property
     def description_safe(self):
@@ -5005,7 +5000,7 b' class Integration(Base, BaseModel):'
             return 'root_repos'
         return 'global'
 
-    def __repr__(self):
+    def __str__(self):
         return '<Integration(%r, %r)>' % (self.integration_type, self.scope)
 
 
@@ -5248,7 +5243,7 b' class RepoReviewRule(Base, BaseModel):'
                 rules.append(user_group)
         return rules
 
-    def __repr__(self):
+    def __str__(self):
         return '<RepoReviewerRule(id=%r, repo=%r)>' % (
             self.repo_review_rule_id, self.repo)
 
@@ -5366,7 +5361,7 b' class ScheduleEntry(Base, BaseModel):'
     def kwargs_raw(self, indent=None):
         return self._as_raw(self.task_kwargs, indent)
 
-    def __repr__(self):
+    def __str__(self):
         return '<DB:ScheduleEntry({}:{})>'.format(
             self.schedule_entry_id, self.schedule_name)
 
@@ -5442,9 +5437,8 b' class UserToRepoBranchPermission(Base, _'
     _branch_pattern = Column('branch_pattern', UnicodeText().with_variant(UnicodeText(2048), 'mysql'), default=u'*')  # glob
     _branch_hash = Column('branch_hash', UnicodeText().with_variant(UnicodeText(2048), 'mysql'))
 
-    def __unicode__(self):
-        return u'<UserBranchPermission(%s => %r)>' % (
-            self.user_repo_to_perm, self.branch_pattern)
+    def __str__(self):
+        return f'<UserBranchPermission({self.user_repo_to_perm} => {self.branch_pattern!r})>'
 
 
 class UserGroupToRepoBranchPermission(Base, _BaseBranchPerms):
@@ -5468,9 +5462,8 b' class UserGroupToRepoBranchPermission(Ba'
     _branch_pattern = Column('branch_pattern', UnicodeText().with_variant(UnicodeText(2048), 'mysql'), default=u'*')  # glob
     _branch_hash = Column('branch_hash', UnicodeText().with_variant(UnicodeText(2048), 'mysql'))
 
-    def __unicode__(self):
-        return u'<UserBranchPermission(%s => %r)>' % (
-            self.user_group_repo_to_perm, self.branch_pattern)
+    def __str__(self):
+        return f'<UserBranchPermission({self.user_group_repo_to_perm} => {self.branch_pattern!r})>'
 
 
 class UserBookmark(Base, BaseModel):
@@ -5518,8 +5511,8 b' class UserBookmark(Base, BaseModel):'
 
         return bookmarks.all()
 
-    def __unicode__(self):
-        return u'<UserBookmark(%s @ %r)>' % (self.position, self.redirect_url)
+    def __str__(self):
+        return f'<UserBookmark({self.position} @ {self.redirect_url!r})>'
 
 
 class FileStore(Base, BaseModel):
@@ -5672,8 +5665,8 b' class FileStore(Base, BaseModel):'
 
         return data
 
-    def __repr__(self):
-        return '<FileStore({})>'.format(self.file_store_id)
+    def __str__(self):
+        return f'<FileStore({self.file_store_id})>'
 
 
 class FileStoreMetadata(Base, BaseModel):
@@ -5687,7 +5680,7 b' class FileStoreMetadata(Base, BaseModel)'
     SETTINGS_TYPES = {
         'str': safe_str,
         'int': safe_int,
-        'unicode': safe_unicode,
+        'unicode': safe_str,
         'bool': str2bool,
         'list': functools.partial(aslist, sep=',')
     }
@@ -5753,7 +5746,7 b' class FileStoreMetadata(Base, BaseModel)'
             # decode the encrypted value if it's encrypted field type
             if '.encrypted' in self._file_store_meta_value_type:
                 cipher = EncryptedTextValue()
-                val = safe_unicode(cipher.process_result_value(val, None))
+                val = safe_str(cipher.process_result_value(val, None))
             # do final type conversion
             converter = self.SETTINGS_TYPES.get(_type) or self.SETTINGS_TYPES['unicode']
             val = converter(val)
@@ -5762,11 +5755,11 b' class FileStoreMetadata(Base, BaseModel)'
 
     @file_store_meta_value.setter
     def file_store_meta_value(self, val):
-        val = safe_unicode(val)
+        val = safe_str(val)
         # encode the encrypted value
         if '.encrypted' in self.file_store_meta_value_type:
             cipher = EncryptedTextValue()
-            val = safe_unicode(cipher.process_bind_param(val, None))
+            val = safe_str(cipher.process_bind_param(val, None))
         self._file_store_meta_value = val
 
     @hybrid_property
@@ -5789,7 +5782,7 b' class FileStoreMetadata(Base, BaseModel)'
 
         return data
 
-    def __repr__(self):
+    def __str__(self):
         return '<%s[%s]%s=>%s]>' % (self.__class__.__name__, self.file_store_meta_section,
                                     self.file_store_meta_key, self.file_store_meta_value)
 
@@ -5820,8 +5813,8 b' class DbSession(Base, BaseModel):'
         base_table_args,
     )
 
-    def __repr__(self):
-        return '<DB:DbSession({})>'.format(self.id)
+    def __str__(self):
+        return f'<DB:DbSession({self.id})>'
 
     id = Column('id', Integer())
     namespace = Column('namespace', String(255), primary_key=True)