Callable Injection: Mechanisms

[Scienfitz]

Lets discuss some possible mechanism for implementing a general mechanism to inject callables. This is eg realted to #215 where a specific hardcoded implementation was done for one method

[Scienfitz]

One way could be to have a class CallableMixin akin to SerialMixin. If a class inhertis from that, it gets access to the method register_callable(method_name:str, callable:Callable).

A registering like this would for instance cause that the callable my_callable is called whenever the .recommend function of a used Campaign object is called:

my_campaign = Campaign(...)
my_campaign.register_callable('recommend', my_callable)
...
my_campaign.recommend(...) # calls my_callable
...
my_campaign.recommend(...) # calls my_callable again

The arguments that are passed to my_callable comprise of two parts:

• all attributes the class instance where the method_name belongs to has access to via .self
• all args and kwargs of the method method_name
  This means my_callable has access to all info the referenced method has access to as well.

Implementation could be done via wrapping (this is just pseudocode not ironed out potential issues):

class CallableMixin:
    def register_callable(self, method_name:str, callable:Callable):
        method = self.getattr(method_name)

        @functools.wraps(method)
        def wraps(self, *args, **kwards):
            attribs = get_fields(self) #pseudocode
            my_callable(*args, **kwargs, **attribs)
            return method(self, *args, *kwargs)

        self.setattr(method_name, wraps)

This would

• Enable easy control over which classes should have callable injection enabled
• Not interfere with serialization
• Could be stacked arbitrarily
• Provide a general recipe for what users can expect the callable to be called with (class instance attributes + method args)

[Scienfitz]

tried around with this, its quite lightweight and works for some classes. But the big problem are classes that are frozen, setattr cannot be used for them