Python SQLAlchemy association\u代理如何双向使用？

我正在使用Flask SQLAlchemy创建一个多对多关系，使用和

关联\u代理

，但我遇到了一个问题：当我使用

关联\u代理

时，我可以设置它，这样当我将一个新实例附加到关系的一侧时，就会创建关联对象，但是，如果我试图从关系的另一端添加实例，关联对象构造函数将不会被传递给正确的实例

下面是一个简化的示例，其中

俱乐部

有许多

人

，而

人

有许多

俱乐部

，并且协会对象是

会员

：

class Club(db.Model):
    __tablename__ = 'clubs'

    id = db.Column(db.Integer, db.Sequence('clubs_id_seq'), autoincrement=True, primary_key=True)
    name = db.Column(db.String(255))
    memberships = db.relationship('Membership', backref='club')
    members = association_proxy('memberships', 'club') # Can I pass a Person instance to Membership here? 
    created_at = db.Column('created_at', db.DateTime, default=datetime.datetime.now())

    def __init__(self, name):
        self.name = name

class Person(db.Model):
    __tablename__ = 'people'

    id = db.Column(db.Integer, db.Sequence('people_id_seq'), autoincrement=True, primary_key=True)
    name = db.Column(db.String(255))
    memberships = db.relationship('Membership', backref='person')
    clubs = association_proxy('memberships', 'club')
    created_at = db.Column('created_at', db.DateTime, default=datetime.datetime.now())

    def __init__(self, name):
        self.name = name

class Membership(db.Model):
    __tablename__ =  'memberships'

    person_id = db.Column('person_id', db.Integer, db.ForeignKey('people.id'), primary_key=True)
    club_id = db.Column('club_id', db.Integer, db.ForeignKey('clubs.id'), primary_key=True)
    club = db.relationship('Club', backref='membership')
    joined_at = db.Column('joined_at', db.DateTime, default=datetime.datetime.now())

    def __init__(self, club):
        self.club = club

我使用的是

协会\代理

，因为不仅仅是

俱乐部

和

个人

之间的联系很重要；如果需要，我还希望能够检索

成员资格

的

joined_at

属性。不过，在大多数情况下，我只会查询并附加到

俱乐部的
.members
或
个人的
.clubs
。在本例中，我可以通过调用
person\u instance.clubs.append（club\u instance）
创建一个新的
成员身份
，但是由于
成员身份
的构造函数只能接受一个参数，如果我要反向工作，我如何调用
club\u instance.members.append（person\u instance）
？我可以潜在地迭代
club\u实例。成员
，但必须记住不要
append（）
。我遗漏了什么吗？
在中找到了我的答案。以下是相关部分：

class DossierTarife(Base):
    __tablename__ = 'tarifer_dossier'
    IdDossier = Column(Integer, ForeignKey('dossier.IdDossier'), primary_key=True)
    IdAt = Column(Integer, ForeignKey('article_tarife.IdAt'), primary_key=True)

    dossier = relationship(Dossier, backref=backref("tarifer_dossier", cascade="all, delete-orphan"))
    article_tarife = relationship(ArticleTarife, backref=backref("tarifer_dossier"))

class Dossier(Base):
    __tablename__ = 'dossier'
    IdDossier = Column('IdDossier', Integer, primary_key=True)
   ...

class ArticleTarife(Base):
    __tablename__ = 'article_tarife'
    IdAt = Column('IdAt', Integer, primary_key=True)
   ...

Dossier.LesTar = association_proxy("tarifer_dossier", "article_tarife", creator=lambda art:DossierTarife(article_tarife=art))
ArticleTarife.LesTar = association_proxy("tarifer_dossier", "dossier", creator=lambda dos:DossierTarife(dossier=dos))

我直接在类定义中分配了我的
关联\u代理
，而不是像上面那样在事实发生后进行分配，这也很有效

描述如何正确删除关联对象行也很有帮助：

user = relationship(User, backref=backref('user_to_groups', cascade='all, delete-orphan'))
group = relationship(Group, backref=backref('group_to_user', cascade='all, delete-orphan'))