False positive ``__init__ method from base class is not called`` when the constructor raises ``NotImplementedError`` without using ``abc``

[cpitclaudel]

Is your feature request related to a problem? Please describe

In the following example, Pylint flags the Derived's __init__ method because it doesn't call Bases's __init__.

class Base:
    def __init__(self, a: int, b: str):
        raise NotImplementedError()

class Derived(Base):
    def __init__(self, a: int, b: str):
        self.a = a + 1
        self.b = b[::-1]

This is discussed here: https://stackoverflow.com/questions/25072363/error-init-method-from-base-class-is-not-called-for-an-abstract-class

Describe the solution you'd like

Pylint could (should?) detect this case and not report an error.

Additional context

An easy fix is to remove the init in the base class, but it can be useful to have it there to define what signature __init__ should have.

[hippo91]

@cpitclaudel thanks for your report. Why not using abc module and defining the base class as an abstract one?

[cpitclaudel]

Are you thinking of this?

from abc import ABCMeta, abstractmethod

class Base:
    __metaclass__ = ABCMeta

    @abstractmethod
    def __init__(self, a: int, b: str):
        pass

class Derived(Base):
    def __init__(self, a: int, b: str):
        super().__init__(a, b)
        self.a = a + 1
        self.b = b[::-1]

That's what one of the answers on stackoverflow suggests, but it's a lot of cruft, and it doesn't prevent Base from being instantiated.

[cpitclaudel]

Why not using abc module and defining the base class as an abstract one?

A different perspective: maybe there should be a pylint rule that suggests moving to an ABS instead of using NotImplementedError(); but this issue is about a different problem, namely pylint suggesting to call an __init__ that raises NotImplementedError/

[hippo91]

@cpitclaudel indeed if you use metaclass this way:

from abc import ABCMeta, abstractmethod

class Base(metaclass=ABCMeta):
    @abstractmethod
    def __init__(self, a: int, b: str):
        pass

class Derived(Base):
    def __init__(self, a: int, b: str):
        super().__init__(a, b)
        self.a = a + 1
        self.b = b[::-1]


if __name__ == "__main__":
    x = Base(3, "toto")

and execute this program, you will get:

TypeError: Can't instantiate abstract class Base with abstract methods __init__

Thus it is impossible to instantiate Base class.

However i agree that pylint should be able to detect that the __init__ method of the base class raises NotImplementError and thus should invite the user to switch toward use of ABCMeta.

[cpitclaudel]

However i agree that pylint should be able to detect that the init method of the base class raises NotImplementError and thus should invite the user to switch toward use of ABCMeta.

👍 , though does the added ABCMeta stuff buy anything compared to the version that just throws an exception? Pylint currently recognizes methods that throw NotImplementedErrors just fine, without recommending to move these too.

And having to call __init__ in the derived class is definitely a downside, no?

[Py-GNU-Unix]

I agree with the need to ignore super-init-not-called if the super init raises NotImplementedError. That's a important feature, but no one fixed this in a long time. I tried to fix this by myself, but that's the first time that i look into pylint code and i failed. I hope that someone will fix this...

[Py-GNU-Unix]

may someone add an high priority tag to this issue? This is nearly a bug.

[Pierre-Sassoulas]

Hi @Py-GNU-Unix The high priority tag is for issue that have more than 10 thumbsup/heart reactions, but we're reviewing every contribution. If you want to contribute to this issue, it's going to get merged before high priority issues that do not get any attention.

[vivi90]

I think it's NOT an False Positive.
The reason, i think so is:

• If you are NOT USING the abc package: Might be hard to detect abstract methods in a reliable way. So pylint prevents you here from possible logical issues.
• If you are USING the abc package: Even if you are not able to instantiate the base class without implementing all abstract methods (including __init__) in an concrete way, you ARE INDEED ABLE to implement some stuff in abstract methods of the base class and call this methods with super() in it's subclass(es). For the __init__ method this means, that pylint prevents you here from violating OOP concepts.

An good practice example from me:

#!/usr/bin/env python3
# -*- coding: utf-8 -*-

"""Abstract class example."""

from abc import ABCMeta, abstractmethod


class Abstract(metaclass=ABCMeta):
    """Abstract class."""

    @property
    @abstractmethod
    def message(self) -> str:
        """str: Return message."""

    @abstractmethod
    def __init__(self, message: str) -> None:
        """Abstract constructor.

        Args:
            message (str):
                Message.

        """


class Concrete(Abstract):
    """Concrete class."""

    @property
    def message(self) -> str:
        """str: Return message."""
        return self._message

    def __init__(self, message: str) -> None:
        """Concrete constructor.

        Args:
            message (str):
                Message.

        """
        super().__init__(message)
        self._message = message


print(Concrete("test").message)

(using class Abstract(metaclass=ABCMeta) instead of class Abstract(ABC) here, because it's more explicit and works also well in combination with Protocol [if really needed])

[cpitclaudel]

@vivi90 Your example is great, but this issue is about an __init__ that throws a NotImplementedError. pylint suggests adding a call to that __init__, which would throws a runtime exception. That's not good ^^