Python composite pattern exception handling & pylint

Question

I'm implementig a Composite pattern in this way:

1) the "abstract" component is:

class Component(object):
"""Basic Component Abstraction"""
def __init__(self, *args, **kw):
    raise NotImplementedError("must be subclassed")

def status(self):
    """Base Abstract method"""
    raise NotImplementedError("must be implemented")

2) a leaf:

class Leaf(Component):
"""Basic atomic component
"""
def __init__(self, *args, **kw):
    self.dict = {}

def status(self):
    """Retrieves properties
    """
    return self.dict

The Problem is that pylint generates, of course, this warning:

Leaf.__init__: __init__ method from base class 'Component' is not called

but into my Leaf i cannot call for:

def __init__(self, *args, **kw):
    Component.__init__(self, *args, **kw)
    self.dict = {}

without raise of the exception.

Must I ignore pylint warning or there is some bad coding?

Answer 1

Abstract initializers are a bad idea. Your code might evolve so that you want to do some initialization in the root component. And even if you don't why require the implementation of the initializer. For some subclasses an empty initializer would be an acceptable choice.

If you don't want any instances of the Component class around, check for that in the initializer:

class Component(object):
    def __init__(self, **kwargs):
        assert type(self) != Component, "Component must not be instantiated directly"

class Leaf(Component):
    def __init__(self, some, args, **kwargs):
        # regular initialization
        Component.__init__(self, **kwargs)

Answer 2

You want to guarantee, that the base class Component is not instanciated. This is a noble guesture common in other programming languages like C++ (where you can make the constructors private or so to prevent direct usage).

But it is not supported in Python. Python does not support all programming notions and also is more "dynamic". So initialization is done in a "Pythonic" way and your notion is not supported thus.

Python is much more based on trust than other languages -- so, for example static variables are not supported and private ones also only in a limited way.

What you could do (when you distrust the users of your module) -- you could hide the base class by naming it "_Component" -- make it an internal secret. But of course this can create other troubles.

Answer 3

Not bad coding as such, but the __init__ of the component is simply not needed. If you want it, you can ignore pylint, but it's a better idea to simply remove the __init__ from Component.

Embrace the dynamicism!

Answer 4

Another suggestion to complement the idea of Markus:

If you really must, I suggest that you use __new __ and check for the given object type. When it is "Component" you could fire your exception:

class Component(object):
"""Basic Component Abstraction"""

def __new__(objType, *args, **kwargs):
    if objType == Component:
       raise NotImplementedError("must be subclassed")
    return object.__new__(type, *args, **kwargs)

When a subclass is created, objType will be != Component and all will be fine!

Answer 5

Renaming your class Component to AbstractComponent should help. And don't provide an __init__ method in your base class if it's not supposed to be called by subclasses.