PnP does not run plugins that inherit a plugin without set implements again

[hugosenari]

Hi,

PnP does not run plugins that inherit a plugin without set 'implements' again

ie:

class Parent(Plugin)
    implement=[SomeInterface]

    def helloIm(self):
        print(self)

class Child(Parent)
    pass

The Child will be called only if I set implement

ie:

class Parent(Plugin)
    implement=[SomeInterface]

    def helloIm(self):
        print(self)

class Child(Parent)
    implement=[SomeInterface]

[daltonmatos]

This is interesting. If the child class implements a set of different interfaces from the parent, PnP should join the lists and the child would then implement all interfaces that the parent implements.

I will take a look at this.

[daltonmatos]

Hello, consider the following scenario:

class OnePlugin(Plugin):
    implements = [MyInterface]

class OtherPlugin(OnePlugin):
    implements = [OtherInterface]

when calling OtherInterface.method() only OtherPlugin must be called. But the problem is with the MyInterface. If we join the implements list of the child class with its parent, OtherPlugin would have (at runtime) implements = [OtherInterface, MyInterface].

And the problem is: When calling MyInterface.method, which plugins should be called?? Only OnePlugin? Only OtherPlugin? Or both?

If we call only OnePlugin we have the current behavior, where only the class that defines the implements attribue is called.

If we call Only OtherPlugin we must take care of removing this implementation of the parent class. This could be dangerous because we would be changing this at runtime.

If we call both, this could cause an unndesired behavior where we get duplicate calls when executing a spcific interface.

I think the best is to call only the class that defines the implements attribute, that's the class that should be called when executing an interface method.

Do you have a real use case where you need this inheritance scenario?

Thanks.

[hugosenari]

Hi,

My Scenario:

I have one BasePlugin abstract class with:

class BasePlugin(Plugin):
    implements = [IBasePlugin]
    def on_load(self): # to call when app 'run'
        self.running = config[self.id].running 
    def on_start(self): # to call when user enable
        pass
    def on_stop(self): # to call when user disable (or app stop)
        pass

class XPlugin(BasePlugin):
    def on_start(self):
        start_resources()
    def on_stop(self):
        free_resources()

class YPlugin(BasePlugin):
    def on_start(self):
        start_other_resources() # don't require stop

My BasePlugin do 'nothing', but is valid as plugin
My XPlugin require start and stop
My YPlugin only require start, and is valid
All does the 'same' when load is called
I can filter for plugins where running == 'auto', and start without user interaction

class ZPlugin(BasePlugin):
    implements = [NewInterface]
    def on_load(self):
        do_something_new()

In this case I'm overwriting that means: ignore my parent

• Case 1: with 'implements', use this
• Case 2: without 'implements' but is child of something that does, use parent