Add remove_hook to undo the effect of set_hook

Despite the documentation says that we should not need to call set_hook directly, I do have a use case where using set_hook would result in a nicer design. If there is a way to put up something (set_hook), there should also be a way to put it down (the proposed remove_hook here).

Story: I have an Adapter design pattern where marshmallow schemas are used. We may have one adapter that does one thing, another adapter does something different, but both want to use the same schema. One adapter can use set_hook to add hooks without affecting another adapter. Something like this:

class MyAdapter:
    def load(self, schema):
        schema.set_hook(my_post_load_function, (POST_LOAD, pass_many))
        try:
                return schema.load(...)
        finally:
            # remove_hook is proposed here
            schema.remove_hook(my_post_load_function, (POST_LOAD, pass_many))

[kitchoi]

Thank you @sloria! Yes it does.

We are in agreement here 😃 I’m sorry that I should have presented code like you did, for it is much clearer. We also try to unset the context to avoid side-effect on the schema being passed from elsewhere (i.e. the “remove_hook”).

This is what we are doing (more or less):

class MySchema(Schema):

    @post_load
    def postprocess(self, data):
        for func in self.context.get("post_loads", []):
            data = func(data)
    return data

class MyAdapter:
    def load(self, schema):
        old_context = self.schema.context
        self.schema.context = old_context.copy()
        self.schema.context["post_loads"] = [func1, func2, ...]
        try:
            self.schema.load(...)
        finally:
            self.schema.context = old_context

For some reason I thought we were just working around a missing feature with this solution. Assuming this is how such use case is expected to be solved, I will close this issue. Please feel free to reopen it for other reasons though. Thank you!

[sloria]

Sorry, to clarify: rather than dynamically adding and removing the post_load method, you can read the schema context in the method and branch there. Along the lines of:

class MySchema(Schema):
    @post_load
    def postprocess(self, data, **kwargs):
        if self.context["foo"] == ...:
            do_something(data)
        else:
            do_something_else(data)

# -----

class MyAdapter:
    def load(self, schema):
        schema.context['foo'] = ....
        return schema.load(...)

Does that meet your use case?