return safe_str(self.__unicode__())

            except UnicodeDecodeError:

                pass

        return '<DB:%s>' % (self.__class__.__name__)

class Setting(Base, BaseModel):

    __tablename__ = DB_PREFIX + 'settings'

    __table_args__ = (

        UniqueConstraint('app_settings_name'),

    )

    SETTINGS_TYPES = {

        'str': safe_str,

        'int': safe_int,

        'unicode': safe_unicode,

class Ui(Base, BaseModel):

    __tablename__ = DB_PREFIX + 'ui'

    __table_args__ = (

        UniqueConstraint('ui_key'),

    )

    HOOK_UPDATE = 'changegroup.update'

    HOOK_REPO_SIZE = 'changegroup.repo_size'

    HOOK_PUSH = 'changegroup.push_logger'

    HOOK_PRE_PUSH = 'prechangegroup.pre_push'

class User(Base, BaseModel):

    __tablename__ = 'users'

    __table_args__ = (

        UniqueConstraint('username'), UniqueConstraint('email'),

        Index('u_username_idx', 'username'),

        Index('u_email_idx', 'email'),

    )

    DEFAULT_USER = 'default'

    DEFAULT_GRAVATAR_URL = 'https://secure.gravatar.com/avatar/{md5email}?d=identicon&s={size}'

    user_id = Column(Integer(), nullable=False, unique=True, primary_key=True)

    username = Column(String(255, convert_unicode=False), nullable=True, unique=None, default=None)

    password = Column(String(255, convert_unicode=False), nullable=True, unique=None, default=None)

class UserApiKeys(Base, BaseModel):

    __tablename__ = 'user_api_keys'

    __table_args__ = (

        Index('uak_api_key_idx', 'api_key'),

        Index('uak_api_key_expires_idx', 'api_key', 'expires'),

        UniqueConstraint('api_key'),

    )

    __mapper_args__ = {}

    user_api_key_id = Column(Integer(), nullable=False, unique=True, primary_key=True)

    user_id = Column(Integer(), ForeignKey('users.user_id'), nullable=True, unique=None, default=None)

    api_key = Column(String(255, convert_unicode=False), nullable=False, unique=True)

class UserEmailMap(Base, BaseModel):

    __tablename__ = 'user_email_map'

    __table_args__ = (

        Index('uem_email_idx', 'email'),

        UniqueConstraint('email'),

    )

    __mapper_args__ = {}

    email_id = Column(Integer(), nullable=False, unique=True, primary_key=True)

    user_id = Column(Integer(), ForeignKey('users.user_id'), nullable=True, unique=None, default=None)

    _email = Column("email", String(255, convert_unicode=False), nullable=True, unique=False, default=None)

class UserIpMap(Base, BaseModel):

    __tablename__ = 'user_ip_map'

    __table_args__ = (

        UniqueConstraint('user_id', 'ip_addr'),

    )

    __mapper_args__ = {}

    ip_id = Column(Integer(), nullable=False, unique=True, primary_key=True)

    user_id = Column(Integer(), ForeignKey('users.user_id'), nullable=True, unique=None, default=None)

    ip_addr = Column(String(255, convert_unicode=False), nullable=True, unique=False, default=None)

        return u"<%s('user_id:%s=>%s')>" % (self.__class__.__name__,

                                            self.user_id, self.ip_addr)

class UserLog(Base, BaseModel):

    __tablename__ = 'user_logs'

    __table_args__ = (

    )

    user_log_id = Column(Integer(), nullable=False, unique=True, primary_key=True)

    user_id = Column(Integer(), ForeignKey('users.user_id'), nullable=True, unique=None, default=None)

    username = Column(String(255, convert_unicode=False), nullable=True, unique=None, default=None)

    repository_id = Column(Integer(), ForeignKey('repositories.repo_id'), nullable=True)

    repository_name = Column(String(255, convert_unicode=False), nullable=True, unique=None, default=None)

    user_ip = Column(String(255, convert_unicode=False), nullable=True, unique=None, default=None)

    repository = relationship('Repository', cascade='')

class UserGroup(Base, BaseModel):

    __tablename__ = 'users_groups'

    __table_args__ = (

    )

    users_group_id = Column(Integer(), nullable=False, unique=True, primary_key=True)

    users_group_name = Column(String(255, convert_unicode=False), nullable=False, unique=True, default=None)

    user_group_description = Column(String(10000, convert_unicode=False), nullable=True, unique=None, default=None)

    users_group_active = Column(Boolean(), nullable=True, unique=None, default=None)

        return data

class UserGroupMember(Base, BaseModel):

    __tablename__ = 'users_groups_members'

    __table_args__ = (

    )

    users_group_member_id = Column(Integer(), nullable=False, unique=True, primary_key=True)

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

    user_id = Column(Integer(), ForeignKey('users.user_id'), nullable=False, unique=None, default=None)

class RepositoryField(Base, BaseModel):

    __tablename__ = 'repositories_fields'

    __table_args__ = (

        UniqueConstraint('repository_id', 'field_key'),  # no-multi field

    )

    PREFIX = 'ex_'  # prefix used in form to not conflict with already existing fields

    repo_field_id = Column(Integer(), nullable=False, unique=True, primary_key=True)

    repository_id = Column(Integer(), ForeignKey('repositories.repo_id'), nullable=False, unique=None, default=None)

    field_key = Column(String(250, convert_unicode=False))

    field_label = Column(String(1024, convert_unicode=False), nullable=False)

class Repository(Base, BaseModel):

    __tablename__ = 'repositories'

    __table_args__ = (

        UniqueConstraint('repo_name'),

        Index('r_repo_name_idx', 'repo_name'),

    )

    DEFAULT_CLONE_URI = '{scheme}://{user}@{netloc}/{repo}'

    DEFAULT_CLONE_URI_ID = '{scheme}://{user}@{netloc}/_{repoid}'

    STATE_CREATED = 'repo_state_created'

    STATE_PENDING = 'repo_state_pending'

    STATE_ERROR = 'repo_state_error'

class RepoGroup(Base, BaseModel):

    __tablename__ = 'groups'

    __table_args__ = (

        UniqueConstraint('group_name', 'group_parent_id'),

        CheckConstraint('group_id != group_parent_id'),

    )

    __mapper_args__ = {'order_by': 'group_name'}

    SEP = ' » '

    group_id = Column(Integer(), nullable=False, unique=True, primary_key=True)

class Permission(Base, BaseModel):

    __tablename__ = 'permissions'

    __table_args__ = (

        Index('p_perm_name_idx', 'permission_name'),

    )

    PERMS = [

        ('hg.admin', _('Kallithea Administrator')),

        ('repository.none', _('Default user has no access to new repositories')),

        ('repository.read', _('Default user has read access to new repositories')),

        ('repository.write', _('Default user has write access to new repositories')),

class UserRepoToPerm(Base, BaseModel):

    __tablename__ = 'repo_to_perm'

    __table_args__ = (

        UniqueConstraint('user_id', 'repository_id', 'permission_id'),

    )

    repo_to_perm_id = Column(Integer(), nullable=False, unique=True, primary_key=True)

    user_id = Column(Integer(), ForeignKey('users.user_id'), nullable=False, unique=None, default=None)

    permission_id = Column(Integer(), ForeignKey('permissions.permission_id'), nullable=False, unique=None, default=None)

    repository_id = Column(Integer(), ForeignKey('repositories.repo_id'), nullable=False, unique=None, default=None)

    user = relationship('User')

class UserUserGroupToPerm(Base, BaseModel):

    __tablename__ = 'user_user_group_to_perm'

    __table_args__ = (

        UniqueConstraint('user_id', 'user_group_id', 'permission_id'),

    )

    user_user_group_to_perm_id = Column(Integer(), nullable=False, unique=True, primary_key=True)

    user_id = Column(Integer(), ForeignKey('users.user_id'), nullable=False, unique=None, default=None)

    permission_id = Column(Integer(), ForeignKey('permissions.permission_id'), nullable=False, unique=None, default=None)

    user_group_id = Column(Integer(), ForeignKey('users_groups.users_group_id'), nullable=False, unique=None, default=None)

    user = relationship('User')

class UserToPerm(Base, BaseModel):

    __tablename__ = 'user_to_perm'

    __table_args__ = (

        UniqueConstraint('user_id', 'permission_id'),

    )

    user_to_perm_id = Column(Integer(), nullable=False, unique=True, primary_key=True)

    user_id = Column(Integer(), ForeignKey('users.user_id'), nullable=False, unique=None, default=None)

    permission_id = Column(Integer(), ForeignKey('permissions.permission_id'), nullable=False, unique=None, default=None)

    user = relationship('User')

    permission = relationship('Permission')

class UserGroupRepoToPerm(Base, BaseModel):

    __tablename__ = 'users_group_repo_to_perm'

    __table_args__ = (

        UniqueConstraint('repository_id', 'users_group_id', 'permission_id'),

    )

    users_group_to_perm_id = Column(Integer(), nullable=False, unique=True, primary_key=True)

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

    permission_id = Column(Integer(), ForeignKey('permissions.permission_id'), nullable=False, unique=None, default=None)

    repository_id = Column(Integer(), ForeignKey('repositories.repo_id'), nullable=False, unique=None, default=None)

    users_group = relationship('UserGroup')

class UserGroupUserGroupToPerm(Base, BaseModel):

    __tablename__ = 'user_group_user_group_to_perm'

    __table_args__ = (

        UniqueConstraint('target_user_group_id', 'user_group_id', 'permission_id'),

        CheckConstraint('target_user_group_id != user_group_id'),

    )

    user_group_user_group_to_perm_id = Column(Integer(), nullable=False, unique=True, primary_key=True)

    target_user_group_id = Column(Integer(), ForeignKey('users_groups.users_group_id'), nullable=False, unique=None, default=None)

    permission_id = Column(Integer(), ForeignKey('permissions.permission_id'), nullable=False, unique=None, default=None)

    user_group_id = Column(Integer(), ForeignKey('users_groups.users_group_id'), nullable=False, unique=None, default=None)

    target_user_group = relationship('UserGroup', primaryjoin='UserGroupUserGroupToPerm.target_user_group_id==UserGroup.users_group_id')

class UserGroupToPerm(Base, BaseModel):

    __tablename__ = 'users_group_to_perm'

    __table_args__ = (

        UniqueConstraint('users_group_id', 'permission_id',),

    )

    users_group_to_perm_id = Column(Integer(), nullable=False, unique=True, primary_key=True)

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

    permission_id = Column(Integer(), ForeignKey('permissions.permission_id'), nullable=False, unique=None, default=None)

    users_group = relationship('UserGroup')

    permission = relationship('Permission')

class UserRepoGroupToPerm(Base, BaseModel):

    __tablename__ = 'user_repo_group_to_perm'

    __table_args__ = (

        UniqueConstraint('user_id', 'group_id', 'permission_id'),

    )

    group_to_perm_id = Column(Integer(), nullable=False, unique=True, primary_key=True)

    user_id = Column(Integer(), ForeignKey('users.user_id'), nullable=False, unique=None, default=None)

    group_id = Column(Integer(), ForeignKey('groups.group_id'), nullable=False, unique=None, default=None)

    permission_id = Column(Integer(), ForeignKey('permissions.permission_id'), nullable=False, unique=None, default=None)

class UserGroupRepoGroupToPerm(Base, BaseModel):

    __tablename__ = 'users_group_repo_group_to_perm'

    __table_args__ = (

        UniqueConstraint('users_group_id', 'group_id'),

    )

    users_group_repo_group_to_perm_id = Column(Integer(), nullable=False, unique=True, primary_key=True)

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

    group_id = Column(Integer(), ForeignKey('groups.group_id'), nullable=False, unique=None, default=None)

    permission_id = Column(Integer(), ForeignKey('permissions.permission_id'), nullable=False, unique=None, default=None)

class Statistics(Base, BaseModel):

    __tablename__ = 'statistics'

    __table_args__ = (

         UniqueConstraint('repository_id'),

    )

    stat_id = Column(Integer(), nullable=False, unique=True, primary_key=True)

    repository_id = Column(Integer(), ForeignKey('repositories.repo_id'), nullable=False, unique=True, default=None)

    stat_on_revision = Column(Integer(), nullable=False)

    commit_activity = Column(LargeBinary(1000000), nullable=False)#JSON data

    commit_activity_combined = Column(LargeBinary(), nullable=False)#JSON data

    languages = Column(LargeBinary(1000000), nullable=False)#JSON data

class UserFollowing(Base, BaseModel):

    __tablename__ = 'user_followings'

    __table_args__ = (

        UniqueConstraint('user_id', 'follows_repository_id'),

        UniqueConstraint('user_id', 'follows_user_id'),

    )

    user_following_id = Column(Integer(), nullable=False, unique=True, primary_key=True)

    user_id = Column(Integer(), ForeignKey('users.user_id'), nullable=False, unique=None, default=None)

    follows_repo_id = Column("follows_repository_id", Integer(), ForeignKey('repositories.repo_id'), nullable=True, unique=None, default=None)

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

class CacheInvalidation(Base, BaseModel):

    __tablename__ = 'cache_invalidation'

    __table_args__ = (

        UniqueConstraint('cache_key'),

        Index('key_idx', 'cache_key'),

    )

    # cache_id, not used

    cache_id = Column(Integer(), nullable=False, unique=True, primary_key=True)

    # cache_key as created by _get_cache_key

    cache_key = Column(String(255, convert_unicode=False))

    # cache_args is a repo_name

    cache_args = Column(String(255, convert_unicode=False))

class ChangesetComment(Base, BaseModel):

    __tablename__ = 'changeset_comments'

    __table_args__ = (

        Index('cc_revision_idx', 'revision'),

        Index('cc_pull_request_id_idx', 'pull_request_id'),

    )

    comment_id = Column(Integer(), nullable=False, unique=True, primary_key=True)

    repo_id = Column(Integer(), ForeignKey('repositories.repo_id'), nullable=False)

    revision = Column(String(40))

    pull_request_id = Column(Integer(), ForeignKey('pull_requests.pull_request_id'))

    line_no = Column(Unicode(10))

    f_path = Column(Unicode(1000))

        Index('cs_revision_idx', 'revision'),

        Index('cs_version_idx', 'version'),

        Index('cs_pull_request_id_idx', 'pull_request_id'),

        Index('cs_changeset_comment_id_idx', 'changeset_comment_id'),

        Index('cs_pull_request_id_user_id_version_idx', 'pull_request_id', 'user_id', 'version'),

        UniqueConstraint('repo_id', 'revision', 'version'),

    )

    STATUS_NOT_REVIEWED = DEFAULT = 'not_reviewed'

    STATUS_APPROVED = 'approved'

    STATUS_REJECTED = 'rejected'

    STATUS_UNDER_REVIEW = 'under_review'

    STATUSES = [

class PullRequest(Base, BaseModel):

    __tablename__ = 'pull_requests'

    __table_args__ = (

        Index('pr_org_repo_id_idx', 'org_repo_id'),

        Index('pr_other_repo_id_idx', 'other_repo_id'),

    )

    # values for .status

    STATUS_NEW = u'new'

    STATUS_CLOSED = u'closed'

        return h.url('pullrequest_show', repo_name=self.other_repo.repo_name,

                     pull_request_id=self.pull_request_id, **kwargs)

class PullRequestReviewers(Base, BaseModel):

    __tablename__ = 'pull_request_reviewers'

    __table_args__ = (

    )

    def __init__(self, user=None, pull_request=None):

        self.user = user

        self.pull_request = pull_request

class Notification(Base, BaseModel):

    __tablename__ = 'notifications'

    __table_args__ = (

        Index('notification_type_idx', 'type'),

    )

    TYPE_CHANGESET_COMMENT = u'cs_comment'

    TYPE_MESSAGE = u'message'

    TYPE_MENTION = u'mention'

    TYPE_REGISTRATION = u'registration'

class UserNotification(Base, BaseModel):

    __tablename__ = 'user_to_notification'

    __table_args__ = (

        UniqueConstraint('user_id', 'notification_id'),

    )

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

    notification_id = Column(Integer(), ForeignKey('notifications.notification_id'), primary_key=True)

    read = Column(Boolean, default=False)

    sent_on = Column(DateTime(timezone=False), nullable=True, unique=None)

    user = relationship('User')

class Gist(Base, BaseModel):

    __tablename__ = 'gists'

    __table_args__ = (

        Index('g_gist_access_id_idx', 'gist_access_id'),

        Index('g_created_on_idx', 'created_on'),

    )

    GIST_PUBLIC = u'public'

    GIST_PRIVATE = u'private'

    DEFAULT_FILENAME = u'gistfile1.txt'

    gist_id = Column(Integer(), nullable=False, unique=True, primary_key=True)

    gist_access_id = Column(Unicode(250))

                                          [base_path, self.gist_access_id])))

class DbMigrateVersion(Base, BaseModel):

    __tablename__ = 'db_migrate_version'

    __table_args__ = (

    )

    repository_id = Column(String(250), nullable=False, unique=True, primary_key=True)

    repository_path = Column(Text)

    version = Column(Integer)