当结构嵌套时，棉花糖应判决失败

Question

我试图用棉花糖进行深层结构。例如：

hour = {
    'day': {
        'name': 'monday'
    }
}
loaded_hour, error = HoursSerializationSchema().load(hour) # this works
new_practitioner_at_location = {
    'hours': [
        hour
    ]
}
loaded, error = PractitionerToServiceLocationSerializationSchema().load(new_practitioner_at_location) # this fails

当我尝试对new_practitioner_at_location进行估算时，我会得到以下（发生在序列化器上的" day"键时发生）：

AttributeError: 'dict' object has no attribute '_sa_instance_state'

请注意，当该结构未嵌套在new_practitioner_at_location中时，相同的架构可以对相同的数据结构（小时）进行估算。

独立脚本显示问题：

from sqlalchemy import Column, Integer, ForeignKey, String
from sqlalchemy.orm import relationship, backref
from sqlalchemy.ext.declarative import declarative_base
import os
from flask import Flask
from flask_sqlalchemy import SQLAlchemy
from flask_marshmallow import Marshmallow
from flask_migrate import Migrate
base = declarative_base()

class HoursDay(base):
    __tablename__ = 'HoursDay'
    uid = Column(Integer, primary_key=True)
    name = Column(String)
    hour_id = Column(Integer, ForeignKey('Hours.uid'))
    hour = relationship("Hours", back_populates="day")
    def __init__(self, **kwargs):
        super().__init__(**kwargs)

class Hours(base):
    __tablename__ = 'Hours'
    uid = Column(Integer, primary_key=True)
    practitioner_at_location_id = Column(Integer, ForeignKey('PractitionerToServiceLocation.uid'))
    practitioner_at_location = relationship('PractitionerToServiceLocation', back_populates="hours")
    day = relationship(HoursDay, uselist=False, back_populates="hour")
    def __repr__(self):
        return f'<Hours {self.uid}>'

class PractitionerToServiceLocation(base):
    """
    A practitioner practices at a number of service locations.
    """
    __tablename__ = 'PractitionerToServiceLocation'
    uid = Column(Integer, primary_key=True)
    hours = relationship("Hours", back_populates="practitioner_at_location")
    def __init__(self, **kwargs):
        super().__init__(**kwargs)
    def __repr__(self):
        return f'<PractitionerToServiceLocation {self.uid}>'

app = Flask(__name__)
app.config.from_object(os.environ['APP_SETTINGS'])
db = SQLAlchemy(app, model_class=base)
ma = Marshmallow(app)
migrate = Migrate(app, db)
from marshmallow import fields

class HoursDaySerializationSchema(ma.ModelSchema):
    class Meta:
        model = HoursDay

class HoursSerializationSchema(ma.ModelSchema):
    class Meta:
        model = Hours
    day = fields.Nested(HoursDaySerializationSchema)

class PractitionerToServiceLocationSerializationSchema(ma.ModelSchema):
    class Meta:
        model = PractitionerToServiceLocation
        hours = fields.Nested('HoursSerializationSchema', many=True)

if __name__ == "__main__":
    hour = {
        'day': {
            'name': 'monday'
        }
    }
    loaded_hour, error = HoursSerializationSchema().load(hour) # this works
    new_practitioner_at_location = {
        'hours': [
            hour
        ]
    }
    loaded, error = PractitionerToServiceLocationSerializationSchema().load(new_practitioner_at_location) # this fails
    print('hi')

更新：

我认为正在发生的事情是，棉花糖在试图对new_practitioner_at_location dict进行估算时并不试图对HoursDay对象进行估算。如果我从HoursDay.hour字段中删除backpopulates行为，那么您可以看到它只需将未进行的数据结构分配到该字段即可。这对我来说毫无意义，尤其是因为当您直接将hour命令而不是将其嵌入new_practitioner_at_location中时，它起作用了。任何帮助，将不胜感激。

Answer 1

这是一个简单的错别字式错误：

class PractitionerToServiceLocationSerializationSchema(ma.ModelSchema):
    class Meta:
        model = PractitionerToServiceLocation
        hours = fields.Nested('HoursSerializationSchema', many=True)

您在class Meta内定义hours，但需要在您的模式中：

class PractitionerToServiceLocationSerializationSchema(ma.ModelSchema):
    class Meta:
        model = PractitionerToServiceLocation
    hours = fields.Nested('HoursSerializationSchema', many=True)