Schema deserialisation with defined session and nested field throws an exception

Not sure if this is intended functionality, however the code below throws ValueError: Deserialization requires a session when trying to load data into a nested object.

I would expect passing a session would propagate to nested fields, however this doesn’t seem to be the case. Is this by design?

If i remove followup (the nested field) from the only= property, the data loads fine from the non-nested field.

class FollowUp(ModelSchema):
    reasonCode =fields.String(attribute='reason_code')
    comment = fields.String()

class Occurence(ModelSchema):
    #... other fields before ...
    followup = fields.Nested(FollowUp())
    status = fields.String()

# Inside my request handler:
obj = DBOccurence.query.get_or_404(occ_id)
res = Occurence(only=['status', 'followup']).load(
            request.json,
            instance=obj,
            session=current_app.db.session
        )

[MattF-NSIDC]

I managed to implement a fix that builds upon the one linked in the comment above, making it general-purpose (you don’t need to know the names of your nested fields to use this):

class BaseModelSchema(ModelSchema):
    OPTIONS_CLASS = BaseOpts

    @mm.pre_load
    def set_nested_session(self, data):
        """Allow nested schemas to use the parent schema's session. This is a
        longstanding bug with marshmallow-sqlalchemy.

        https://github.com/marshmallow-code/marshmallow-sqlalchemy/issues/67
        https://github.com/marshmallow-code/marshmallow/issues/658#issuecomment-328369199
        """
        nested_fields = {k: v for k, v in self.fields.items() if type(v) == mm.fields.Nested}
        for field in nested_fields.values():
            field.schema.session = self.session

[YKdvd]

It looks like even if you specify “sqla_session” for the TopLevel schema definition, it doesn’t get passed along to the Nested schemas, so Nested() is broken completely except where the nested schema itself specifies a “sqla_session” in its definition?
I took a quick look at the code (schema.py), and it would seem that there is no way that the session could have been intended to propagate to nested schemas? The constructor would have to attach the “session” parm it was passed to any nested mmsqla.ModelSchema fields after the super() call constructed the parent schema. And load() would have to something similar as a one-time thing. I didn’t see anything that looked like it could do this. Also, ModelSchema keeps a “session” attribute which gets set by init() and load(). But load() looks like it doesn’t preserve the existing value? So if you had something like this, the second call would wipe out the schema specified in the constructor, and future load() calls will use the last session explicitly passed to load():

#permSession and tempSession are a couple of sqlAlchemy sessions
class MySchema(ModelSchema):
   ...
schema = MySchema(session=permSession)   # always use permSession unless overridden by load()
result = schema.load(data)   # will use permSession
result = schema.load(data, session=tempSession)  # will use tempSession
result = schema.load(data)  # should use permSession, but previous load has set schema.session to tempSession but never restored it to permSession.

I haven’t tested this, but scanning the code seems to suggest that’s what would happen.