return q

    def get_reviewer_users(self):

        """Like .reviewers, but actually returning the users"""

        return User.query() \

            .join(PullRequestReviewer) \

            .filter(PullRequestReviewer.pull_request == self) \

            .order_by(PullRequestReviewer.pull_request_reviewers_id) \

            .all()

    def is_closed(self):

        return self.status == self.STATUS_CLOSED

    def user_review_status(self, user_id):

        """Return the user's latest status votes on PR"""

        # note: no filtering on repo - that would be redundant

        status = ChangesetStatus.query() \

            .filter(ChangesetStatus.pull_request == self) \

            .filter(ChangesetStatus.user_id == user_id) \

            .order_by(ChangesetStatus.version) \

            .first()

        return str(status.status) if status else ''

    @classmethod

    def make_nice_id(cls, pull_request_id):

        '''Return pull request id nicely formatted for displaying'''

        return '#%s' % pull_request_id

    def nice_id(self):

        '''Return the id of this pull request, nicely formatted for displaying'''

        return self.make_nice_id(self.pull_request_id)

    def get_api_data(self):

        return self.__json__()

    def __json__(self):

        clone_uri_tmpl = kallithea.CONFIG.get('clone_uri_tmpl') or Repository.DEFAULT_CLONE_URI

        return dict(

            pull_request_id=self.pull_request_id,

            url=self.url(),

            reviewers=self.reviewers,

            revisions=self.revisions,

            owner=self.owner.username,

            title=self.title,

            description=self.description,

            org_repo_url=self.org_repo.clone_url(clone_uri_tmpl=clone_uri_tmpl),

            org_ref_parts=self.org_ref_parts,

            other_ref_parts=self.other_ref_parts,

            status=self.status,

            comments=self.comments,

            statuses=self.statuses,

        )

    def url(self, **kwargs):

        canonical = kwargs.pop('canonical', None)

        import kallithea.lib.helpers as h

        b = self.org_ref_parts[1]

        if b != self.other_ref_parts[1]:

            s = '/_/' + b

        else:

            s = '/_/' + self.title

        kwargs['extra'] = urlreadable(s)

        if canonical:

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

                                   pull_request_id=self.pull_request_id, **kwargs)

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

                     pull_request_id=self.pull_request_id, **kwargs)

class PullRequestReviewer(Base, BaseDbModel):

    __tablename__ = 'pull_request_reviewers'

    __table_args__ = (

        Index('pull_request_reviewers_user_id_idx', 'user_id'),

        _table_args_default_dict,

    )

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

        self.user = user

        self.pull_request = pull_request

    pull_request_reviewers_id = Column('pull_requests_reviewers_id', Integer(), primary_key=True)

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

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

    user = relationship('User')

    pull_request = relationship('PullRequest')

    def __json__(self):

        return dict(

            username=self.user.username if self.user else None,

        )

class Notification(object):

    __tablename__ = 'notifications'

class UserNotification(object):

    __tablename__ = 'user_to_notification'

class Gist(Base, BaseDbModel):

    __tablename__ = 'gists'

    __table_args__ = (

        Index('g_gist_access_id_idx', 'gist_access_id'),

        Index('g_created_on_idx', 'created_on'),

        _table_args_default_dict,

    )

    GIST_PUBLIC = 'public'

    GIST_PRIVATE = 'private'

    DEFAULT_FILENAME = 'gistfile1.txt'

    gist_id = Column(Integer(), primary_key=True)

    gist_access_id = Column(Unicode(250), nullable=False)

    gist_description = Column(UnicodeText(), nullable=False)

    owner_id = Column('user_id', Integer(), ForeignKey('users.user_id'), nullable=False)

    gist_expires = Column(Float(53), nullable=False)

    gist_type = Column(Unicode(128), nullable=False)

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

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

    owner = relationship('User')

    @hybrid_property

    def is_expired(self):

        return (self.gist_expires != -1) & (time.time() > self.gist_expires)

    def __repr__(self):

        return "<%s %s %s>" % (

            self.__class__.__name__,

            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:

            raise HTTPNotFound

        return res

    @classmethod

    def get_by_access_id(cls, gist_access_id):

        return cls.query().filter(cls.gist_access_id == gist_access_id).scalar()

    def gist_url(self):

        alias_url = kallithea.CONFIG.get('gist_alias_url')

        if alias_url:

            return alias_url.replace('{gistid}', self.gist_access_id)

        import kallithea.lib.helpers as h

        return h.canonical_url('gist', gist_id=self.gist_access_id)

    def get_api_data(self):

        """

        Common function for generating gist related data for API

        """

        gist = self

        data = dict(

            gist_id=gist.gist_id,

            type=gist.gist_type,

            access_id=gist.gist_access_id,

            description=gist.gist_description,

            url=gist.gist_url(),

            expires=gist.gist_expires,

            created_on=gist.created_on,

        )

        return data

    def __json__(self):

        data = dict(

        )

        data.update(self.get_api_data())

        return data

    ## SCM functions

    @property

    def scm_instance(self):

        from kallithea.lib.vcs import get_repo

        from kallithea.model.gist import GIST_STORE_LOC

        gist_base_path = os.path.join(kallithea.CONFIG['base_path'], GIST_STORE_LOC)

        return get_repo(os.path.join(gist_base_path, self.gist_access_id))

class UserSshKeys(Base, BaseDbModel):

    __tablename__ = 'user_ssh_keys'

    __table_args__ = (

        Index('usk_fingerprint_idx', 'fingerprint'),

        _table_args_default_dict

    )

    __mapper_args__ = {}

    user_ssh_key_id = Column(Integer(), primary_key=True)

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

    _public_key = Column('public_key', UnicodeText(), nullable=False)

    description = Column(UnicodeText(), nullable=False)

    fingerprint = Column(String(255), nullable=False, unique=True)

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

    last_seen = Column(DateTime(timezone=False), nullable=True)

    user = relationship('User')

    @property

    def public_key(self):

        return self._public_key

    @public_key.setter

    def public_key(self, full_key):

        # the full public key is too long to be suitable as database key - instead,

        # use fingerprints similar to 'ssh-keygen -E sha256 -lf ~/.ssh/id_rsa.pub'

        self._public_key = full_key

        enc_key = safe_bytes(full_key.split(" ")[1])

        self.fingerprint = base64.b64encode(hashlib.sha256(base64.b64decode(enc_key)).digest()).replace(b'\n', b'').rstrip(b'=').decode()