Pylint W0223: Method ... is abstract in class ... but is not overridden

Question

Pylint generates this error for subclasses of an abstract class, even when those subclasses are not themselves instantiated and the methods are overridden in the concrete subclasses. Why does Pylint think my abstract subclasses are intended to be concrete? How can I shut up this warning without getting out the hammer and disabling it altogether in the rc file?

Answer 1

For some reason pylint think the class isn't abstract (currenly detection is done by checking for method which raise NotImplementedError). Adding a comment like #pylint: disable=W0223 at the top of the module (for disabling only in this module) or class (only in this class), should do the trick.

Answer 2

In order to shut up the wrong abstract-method warning you can implement abstract classes with abc.ABC superclass instead of using abc.ABCMeta metaclass.

For example, this code will raise the warning:

from abc import ABCMeta, abstractmethod


class Parent:
    __metaclass__ = ABCMeta

    @abstractmethod
    def do_something(self):
        pass


class Child(Parent):
    __metaclass__ = ABCMeta

but this will not:

from abc import ABC, abstractmethod


class Parent(ABC):

    @abstractmethod
    def do_something(self):
        pass


class Child(Parent, ABC):
    pass

Caution! With ABC superclass and multiple inheritance you have to watch out for potential Method Resolution Order (MRO) problems.

Answer 3

I agree with Michal that you should use ABCMeta. I think the way it's used in this example is now considered the better way to use it.

from abc import ABCMeta, abstractmethod


class Bird( metaclass=ABCMeta ) :
    '''It's a bird'''

    def __init__(self, name : str ) :
        self._name = name

    @abstractmethod
    def talk(self) :
        '''Talk as as appropriate'''

    @abstractmethod
    def walk(self) :
        ...

# No warning here. The abstract method walk is inherited,
# but this class is declared abstract, so that's ok.
class Duck( Bird, metaclass=ABCMeta ) :
    '''Talks like a duck'''
    def talk(self) :
        return "quack"

# Pylint warns here. The abstract method walk is inherited.
# This class is not declared abstract, but it is abstract because
# it has inherited an abstract method.
class Mallard( Duck ) :
    '''It's really just a Duck, but concrete'''


def main() :
    d = Duck( "Donald" ) # Pylint warns here because Duck is abstract
    m = Mallard( "Moe" ) # Pylint warns here because Mallard is abstract
    # even though it was not declared as such.

This style is very much like Java in that abstract classes should be declared as such. The only difference is that in Java you don't get the final warning because in Java a class is concrete unless declared abstract.