UniqueConstraint('repository_id'),

         {'extend_existing': True, 'mysql_engine': 'InnoDB',

          'mysql_charset': 'utf8', 'sqlite_autoincrement': True}

    )

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

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

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

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

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

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

    repository = relationship('Repository', single_parent=True)

class UserFollowing(Base, BaseModel):

    __tablename__ = 'user_followings'

    __table_args__ = (

        UniqueConstraint('user_id', 'follows_repository_id'),

        UniqueConstraint('user_id', 'follows_user_id'),

        {'extend_existing': True, 'mysql_engine': 'InnoDB',

         'mysql_charset': 'utf8', 'sqlite_autoincrement': True}

    )

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

    user_id = Column("user_id", 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("follows_user_id", Integer(), ForeignKey('users.user_id'), nullable=True, unique=None, default=None)

    follows_from = Column('follows_from', DateTime(timezone=False), nullable=True, unique=None, 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='Repository.repo_name')

    @classmethod

    def get_repo_followers(cls, repo_id):

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

class CacheInvalidation(Base, BaseModel):

    __tablename__ = 'cache_invalidation'

    __table_args__ = (

        UniqueConstraint('cache_key'),

        Index('key_idx', 'cache_key'),

        {'extend_existing': True, 'mysql_engine': 'InnoDB',

         'mysql_charset': 'utf8', 'sqlite_autoincrement': True},

    )

    # cache_id, not used

    # cache_key as created by _get_cache_key

    # cache_args is a repo_name

    def __init__(self, cache_key, repo_name=''):

        self.cache_key = cache_key

        self.cache_args = repo_name

        self.cache_active = False

    def __unicode__(self):

    def _cache_key_partition(self):

        prefix, repo_name, suffix = self.cache_key.partition(self.cache_args)

        return prefix, repo_name, suffix

    def get_prefix(self):

        """

        get prefix that might have been used in _get_cache_key to

        generate self.cache_key. Only used for informational purposes

        in repo_edit.html.

        """

        # prefix, repo_name, suffix

        return self._cache_key_partition()[0]

    def get_suffix(self):

        """

        get suffix that might have been used in _get_cache_key to

        generate self.cache_key. Only used for informational purposes

        in repo_edit.html.

        """

        # prefix, repo_name, suffix

        return self._cache_key_partition()[2]

    @classmethod

    def clear_cache(cls):

        """

        Delete all cache keys from database.

        Should only be run when all instances are down and all entries thus stale.

        """

        cls.query().delete()

        Session().commit()

    @classmethod

    def _get_cache_key(cls, key):

        """

        Wrapper for generating a unique cache key for this instance and "key".

        key must / will start with a repo_name which will be stored in .cache_args .

        """

        import kallithea

        prefix = kallithea.CONFIG.get('instance_id', '')

        return "%s%s" % (prefix, key)

    @classmethod

    def set_invalidate(cls, repo_name, delete=False):

        """

        Mark all caches of a repo as invalid in the database.

        """

        inv_objs = Session().query(cls).filter(cls.cache_args == repo_name).all()