不能動的sqlalchemy

errormsg

AttributeError: Neither 'InstrumentedAttribute' object nor 'Comparator' object associated with BedHistory.user has an attribute 'tag_histories'

main.py

# 下面這一大段是時間問題，如果都沒填寫會有當下有效的東西出來。
    search_obj = BedHistory.query.filter(BedHistory.create_time <= datetime.datetime.fromtimestamp(
            int(re_json.get('since', datetime.datetime.now().timestamp()))
        ),BedHistory.delete_time >= datetime.datetime.fromtimestamp(
            int(re_json.get('before', datetime.datetime.now().timestamp()))))
    
    input_tags = re_json.get('tags')  # 這個Tag是一個List，我要過濾同時有這些Tag的Record
    if input_tags is not None:
        for tag_regs in input_tags:
            search_obj = search_obj.filter(BedHistory.user.tag_histories.tag.name == tag_regs)
    
    # 輸出結果
    result: BedHistory = search_obj.paginate(page=re_json.get('page', 1),
                                                        per_page=re_json.get('limit', 20),
                                                        error_out=False
                                                        ).items

models.py

from flask_sqlalchemy import SQLAlchemy
from sqlalchemy.ext.hybrid import hybrid_property
import datetime

db = SQLAlchemy()


class UserRecord(db.Model):
    __tablename__ = "userrecord"
    uid = db.Column(db.String(128), primary_key=True)
    email = db.Column(db.String(64), unique=True)
    phone = db.Column(db.String(16), unique=True)
    card_id = db.Column(db.String(32), unique=True)
    unit = db.Column(db.String(12))  # 班級之類的
    stuff_id = db.Column(db.String(32))  # 學號之類的
    credentials = db.Column(db.String(64), unique=True)
    tag_histories = db.relationship('TagHistory', backref='userrecord', lazy='subquery')
    bed_histories = db.relationship('BedHistory', back_populates='user')
    remark = db.Column(db.Text())
    english_name = db.Column(db.String(64))
    name = db.Column(db.String(8), index=True)
    relation_logs = db.relationship("LogPerson", back_populates="user")  # 不要動它，他沒有要用

    @hybrid_property
    def now_bed(self):
        for i in self.bed_historices:  # type: BedHistory
            if i.enable:
                return i.bed
        return None

    @property
    def now_tags(self):
        lst = []
        for i in self.tag_histories:
            if i.enable:
                lst.append(i.tag)
        return lst

    @property
    def now_tags_name(self):
        return [x.name for x in self.now_tags]


class TagHistory(db.Model):
    __tablename__ = 'taghistory'
    id = db.Column(db.Integer, autoincrement=True, primary_key=True)
    create_time = db.Column(db.DateTime, index=True)
    delete_time = db.Column(db.DateTime)
    tag_id = db.Column(db.String(32), db.ForeignKey('usertag.name'))
    tag = db.relationship('UserTag', back_populates="histories")
    user = db.Column(db.String(128), db.ForeignKey('userrecord.uid'), nullable=False)

    @hybrid_property
    def tag_name(self):
        return self.tag.name

    @hybrid_property
    def enable(self):
        return self.create_time <= datetime.datetime.now() <= self.delete_time


class UserTag(db.Model):
    __tablename__ = "usertag"
    name = db.Column(db.String(32), primary_key=True)
    remarks = db.Column(db.Text)
    histories = db.relationship("TagHistory", back_populates="tag")
    system_tag = db.Column(db.Boolean)


room2tags = db.Table('room2tags',
                     db.Column('roomtag_id', db.ForeignKey('roomtag.id')),
                     db.Column('room_id', db.Integer, db.ForeignKey('room.id'))
                     )


class Room(db.Model):
    __tablename__ = "room"
    id = db.Column(db.Integer, autoincrement=True, primary_key=True)
    dorm = db.Column(db.String(12), nullable=False)
    floor = db.Column(db.Integer)
    builder = db.Column(db.String(4))
    name = db.Column(db.String(8), nullable=False)
    sex = db.Column(db.String(12), index=True)
    tags = db.relationship('RoomTag', secondary=room2tags, lazy='subquery', backref=db.backref('rooms', lazy=True))
    beds = db.relationship('Bed', back_populates='room', lazy='dynamic')
    usable = db.Column(db.Integer)
    who_use_it = db.Column(db.String(128), db.ForeignKey('userrecord.uid'))  # 上述狀態若為1：占用時此欄可用
    remark = db.Column(db.Text)


class RoomTag(db.Model):
    __tablename__ = "roomtag"
    id = db.Column(db.Integer, autoincrement=True, primary_key=True)
    name = db.Column(db.String(32), unique=True)


class Bed(db.Model):
    __tablename__ = "bed"
    id = db.Column(db.Integer, primary_key=True, autoincrement=True)
    room_id = db.Column(db.Integer, db.ForeignKey('room.id'), nullable=False)
    room = db.relationship("Room", back_populates='beds')
    histories = db.relationship("BedHistory", back_populates='bed')
    name = db.Column(db.String(8))


class BedHistory(db.Model):
    __tablename__ = "bedhistory"
    id = db.Column(db.Integer, primary_key=True, autoincrement=True)
    create_time = db.Column(db.DateTime, index=True)
    delete_time = db.Column(db.DateTime, index=True)
    bed_id = db.Column(db.Integer, db.ForeignKey('bed.id'))
    bed = db.relationship('Bed', back_populates='histories')
    user_id = db.Column(db.String(128), db.ForeignKey('userrecord.uid'))
    user = db.relationship('UserRecord', back_populates='bed_histories')
    emergency_contact = db.Column(db.Text)
    emergency_contact_phone = db.Column(db.String(16))

    @hybrid_property
    def enable(self):
        return self.create_time <= datetime.datetime.now() <= self.delete_time

    @property
    def room_name4human(self):
        return self.bed.room.dorm + self.bed.room.builder + self.bed.room.name + "-" + self.bed.name


class Log(db.Model):
    __tablename__ = "log"
    id = db.Column(db.BigInteger, primary_key=True, autoincrement=True)
    persons = db.relationship('LogPerson', back_populates='log')
    event_type = db.Column(db.String(16))
    text = db.Column(db.Text)
    create_time = db.Column(db.DateTime)


class LogPerson(db.Model):
    __tablename__ = 'logperson'
    id = db.Column(db.BigInteger, primary_key=True, autoincrement=True)
    log_id = db.Column(db.BigInteger, db.ForeignKey('log.id'))
    log = db.relationship("Log", back_populates="persons")
    admin = db.Column(db.Boolean)
    uid = db.Column(db.String(128), db.ForeignKey('userrecord.uid'))
    user = db.relationship('UserRecord', back_populates="relation_logs")

    @hybrid_property
    def person(self):
        return db.session.query(UserRecord).filter_by(uid=self.uid).first()


admin_policy = db.Table('admin_policies',
                        db.Column("admin_id", db.String(128), db.ForeignKey('administrator.uid')),
                        db.Column("policy_id", db.Integer, db.ForeignKey('policy.id'))
                        )


class Administrator(db.Model):
    __tablename__ = "administrator"
    uid = db.Column(db.String(128), primary_key=True)
    enable = db.Column(db.Boolean)
    two_fa = db.Column(db.String(16))
    two_fa_enable = db.Column(db.Boolean)
    policies = db.relationship("Policy", secondary=admin_policy, back_populates="admins")


class Policy(db.Model):
    __tablename__ = "policy"
    id = db.Column(db.Integer, primary_key=True, autoincrement=True)
    name = db.Column(db.String(32))
    _policy: str = db.Column(db.Text)
    admins = db.relationship("Administrator", secondary=admin_policy, back_populates="policies")

    @property
    def policies(self):
        return self._policy.split('|')