The abc-delegation from monomonedula

Update documentation and readme with new validation features

Document the delegation metaclasses & update examples in readme

Integrate with CodeShip CI/CD, add coverage badge

Validate delegate attributes on object creation

Raise an error if the object's delegate is missing a delegated attribute. Implement the same behavior for both single and multi delegate classes

Multiple Inheritance partial delegation

First up super cool project. Takes most of the headache out of delegation.

I was wondering if in the case of multiple inheritance you could specify which class to delegate.
Say your class C inherits from A and B but only require that the delegate implements A.
Right now the only way that seems to work is to add all the methods of B to your Class C as abstract methods, or turn of validation completely.

More concretely I would like to do this:

from abc import ABCMeta, abstractmethod
from abc_delegation import delegation_metaclass

class abc_foo(metaclass=ABCMeta):
    @abstractmethod
    def foo(self):
        pass

class abc_bar(metaclass=ABCMeta):
    @abstractmethod
    def bar(self):
        pass
    ...
   #Potentially many more

class delegate_foo(abc_foo, abc_bar, 
                   metaclass=delegation_metaclass("_foo")):
    def __init__(self, foo):
        self._foo = foo

class implement_bar(delegate_foo):
    def __init__(self, foo):
        super().__init__(foo)

    def bar(self):
        super().bar()
        return "bar"

class foo:
    def foo(self):
        return "foo"

bar = implement_bar(foo())

Without having to write:

class delegate_foo(abc_foo, abc_bar, 
                    metaclass=delegation_metaclass("_foo")):
    def __init__(self, foo):
        self._foo = foo

    @abstractmethod
    def bar(self):
        pass
   ...
   #Potentially many more

Or turn of validation.

Alternatively making this work would be equally nice

from abc import ABCMeta, abstractmethod
from abc_delegation import delegation_metaclass

class abc_foo(metaclass=ABCMeta):
    @abstractmethod
    def foo(self):
        pass

class abc_bar(metaclass=ABCMeta):
    @abstractmethod
    def bar(self):
        pass
    ...
   #Potentially many more

class delegate_foo(abc_foo, metaclass=delegation_metaclass("_foo")):
    def __init__(self, foo):
        self._foo = foo

class implement_bar_delegate_foo(abc_bar, delegate_foo):
    def __init__(self, foo):
        super().__init__(foo)

    def bar(self):
        return "bar"

class foo:
    def foo(self):
        return "foo"

bar = implement_bar_delegate_foo(foo())
bar.bar()
bar.foo()

I don't know how difficult either thing is because metaclasses and inheritance gives me headaches, but it feels like it should be possible.

monomonedula / abc-delegation Goto Github PK

abc-delegation's People

Contributors

Stargazers

Watchers

Forkers

abc-delegation's Issues

Recommend Projects

Recommend Topics

Recommend Org

Jobs