Mailman 3 Abstract metaclasses? - Python-ideas

10 Sep 2014

      Hi all,

I recently ran across an interesting (mis?)-feature at least in
CPython that I couldn't find any specific justification for or
against.  The issue is that abstract *types*, while technically
possible, don't behave as abstract classes.

To exemplify, say I wanted to create a metaclass which itself has
ABCMeta as a metaclass, and which has some abstract classmethod
defined:
...
...
...
import abc
class Meta(type, metaclass=abc.ABCMeta):
...     @abc.abstractmethod
...     def foo(cls): pass
...
Now for all intents and purposes Meta *is* an abstract type:
...
...
...
import inspect
inspect.isabstract(Meta)
True
Meta.__abstractmethods__
frozenset({'foo'})
However, nothing prevents Meta from being used as a metaclass for
another class, despite it being "abstract":
...
...
...
class A(metaclass=Meta): pass
...
A

...
...
...
class AbstractableType(type):
...     def __new__(mcls, name, bases, members):
...         if inspect.isabstract(mcls):
...             raise TypeError(
...                 "Can't instantiate abstract type {0} with "
...                 "abstract methods {1}".format(
...                     mcls.__name__, ',
'.join(sorted(mcls.__abstractmethods__))))
...         return super(AbstractableType, mcls).__new__(mcls, name,
This is simply because the check for the Py_TYPFLAGS_IS_ABSTRACT flag
is implemented in object_new, which is overridden by type_new for type
subclasses.  type_new does not perform this check.

I'm perfectly fine if this is dismissed as too abstract or too
academic to be useful, but I will mention that this came up in a real
use case.  The use case is in a hierarchy of metaclasses involved in a
syntactic-sugary class factory framework involving creation of new
classes via operators.

So I just wonder if this is a bug that should be fixed, or at the very
least a feature request.  The IS_ABSTRACT flag check is cheap and easy
to add to type_new, in principle.

In the meantime a workaround, which doesn't seem too terrible, is
simply to define something I called AbstractableType:

bases, members)
...

Now create an abstract metaclass with (meta-)metaclass abc.ABCMeta:
...
...
...
class AbstractMeta(AbstractableType, metaclass=abc.ABCMeta):
...     @abc.abstractmethod
...     def foo(cls): pass
...
Creating a class with metaclass AbstractMeta fails as it should:
...
...
...
class A(metaclass=AbstractMeta): pass
...
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
  File "<stdin>", line 7, in __new__
TypeError: Can't instantiate abstract type AbstractMeta with abstract
methods foo
However, AbstractMeta can be subclassed with a concrete implementation:
...
...
...
class ConcreteMeta(AbstractMeta):
...     def foo(cls): print("Concrete method")
...
class A(metaclass=ConcreteMeta): pass
...
A.foo()
Concrete method
Thanks,

Erik

Abstract metaclasses?

Erik Bray

Ethan Furman

Erik Bray

Ethan Furman

Erik Bray

Ethan Furman

tags

participants (2)