Python - Metaclasses

Metaclasses in Python

Metaclasses are a powerful and advanced feature in Python that allow developers to control the creation and behavior of classes. While regular classes define the behavior of objects, metaclasses define the behavior of classes themselves. In other words, metaclasses are classes of classes. They are often considered one of the more complex and esoteric parts of the Python language, but with proper understanding, they become a tool that can enable advanced behaviors such as class validation, automatic code generation, and API enforcement.

Introduction to Metaclasses

Everything in Python is an object, including classes themselves. When you create a class, Python uses a metaclass to create it. By default, the metaclass for all classes is `type`, which is itself a class.

Basic Class Creation

class MyClass:
    pass

print(type(MyClass))

Output:

<class 'type'>

This means that the class `MyClass` is an instance of the metaclass `type`. So just as objects are instances of classes, classes are instances of metaclasses.

Defining a Metaclass

You can define your own metaclass by subclassing `type` and overriding its methods. The most commonly overridden methods are:

• `__new__` — Controls the creation of the class object itself
• `__init__` — Initializes the class object after it has been created

Custom Metaclass Example

class MyMeta(type):
    def __new__(cls, name, bases, dct):
        print(f"Creating class {name}")
        return super().__new__(cls, name, bases, dct)

class MyClass(metaclass=MyMeta):
    pass

Output:

Creating class MyClass

Here, the metaclass `MyMeta` controls the creation of `MyClass`. The message is printed when the class is created, not when an instance is created.

Why Use Metaclasses?

Metaclasses can be useful in a variety of advanced use cases:

• Validating class definitions
• Injecting class-level attributes or methods
• Registering classes
• Enforcing coding standards or interfaces

Enforcing Method Presence

Suppose you want to ensure that every subclass implements a method called `execute`:

class InterfaceMeta(type):
    def __new__(cls, name, bases, dct):
        if 'execute' not in dct:
            raise TypeError("Missing required method 'execute'")
        return super().__new__(cls, name, bases, dct)

class Base(metaclass=InterfaceMeta):
    def execute(self):
        print("Base execute")

# The following will raise an error
class Derived(Base):
    pass

Metaclasses vs Class Decorators

Both metaclasses and class decorators allow modifying classes, but with key differences:

• Class decorators modify the class after it is created
• Metaclasses can modify the class during creation

Class Decorator Example

def add_method(cls):
    cls.new_method = lambda self: "Hello from new_method"
    return cls

@add_method
class MyClass:
    pass

obj = MyClass()
print(obj.new_method())

Overriding __init__ vs __new__ in Metaclasses

Just like in normal classes, `__new__` is responsible for creating the object, while `__init__` initializes it. In metaclasses:

• `__new__` creates the class
• `__init__` is called after the class has been created

class MetaLogger(type):
    def __new__(cls, name, bases, dct):
        print(f"MetaLogger __new__ for class {name}")
        return super().__new__(cls, name, bases, dct)
    
    def __init__(cls, name, bases, dct):
        print(f"MetaLogger __init__ for class {name}")
        super().__init__(name, bases, dct)

class MyClass(metaclass=MetaLogger):
    pass

Output:

MetaLogger __new__ for class MyClass
MetaLogger __init__ for class MyClass

Using Metaclasses for Validation

Here is an example that enforces all class attribute names to be uppercase:

class UpperAttrMetaclass(type):
    def __new__(cls, name, bases, dct):
        uppercase_attrs = {
            key.upper(): value
            for key, value in dct.items()
            if not key.startswith('__')
        }
        return super().__new__(cls, name, bases, uppercase_attrs)

class MyClass(metaclass=UpperAttrMetaclass):
    foo = 'bar'
    hello = 'world'

print(hasattr(MyClass, 'foo'))      # False
print(hasattr(MyClass, 'FOO'))      # True

Metaclasses for Singleton Pattern

The Singleton design pattern ensures that only one instance of a class can exist. A metaclass can enforce this easily.

class SingletonMeta(type):
    _instances = {}

    def __call__(cls, *args, **kwargs):
        if cls not in cls._instances:
            cls._instances[cls] = super().__call__(*args, **kwargs)
        return cls._instances[cls]

class Singleton(metaclass=SingletonMeta):
    def __init__(self):
        print("Creating instance")

a = Singleton()
b = Singleton()
print(a is b)  # True

Metaclasses in Real-World Libraries

Metaclasses are widely used in popular frameworks:

• Django ORM uses metaclasses to map models to databases
• Python's ABC module uses metaclasses to enforce abstract base classes

Example: ABCMeta

from abc import ABCMeta, abstractmethod

class MyBase(metaclass=ABCMeta):
    @abstractmethod
    def do_something(self):
        pass

class MyConcrete(MyBase):
    def do_something(self):
        print("Doing something")

Combining Multiple Metaclasses

Python does not support multiple metaclasses directly, but you can create a composite metaclass that inherits from both:

class MetaOne(type):
    pass

class MetaTwo(type):
    pass

# Combined metaclass
class CombinedMeta(MetaOne, MetaTwo):
    pass

class MyClass(metaclass=CombinedMeta):
    pass

Metaclasses with Class Registration

You can use a metaclass to keep track of all subclasses of a given class.

class RegistryMeta(type):
    registry = []

    def __new__(cls, name, bases, dct):
        new_class = super().__new__(cls, name, bases, dct)
        cls.registry.append(new_class)
        return new_class

class Base(metaclass=RegistryMeta):
    pass

class A(Base): pass
class B(Base): pass

print(RegistryMeta.registry)

Metaclass Conflicts

If you mix multiple classes with different metaclasses, Python may raise a metaclass conflict error. Always ensure that the metaclasses are compatible or use a unified metaclass.

class MetaA(type): pass
class MetaB(type): pass

class A(metaclass=MetaA): pass
class B(metaclass=MetaB): pass

# Will raise TypeError due to metaclass conflict
class C(A, B): pass

Dynamic Class Creation with type()

You can create classes dynamically using the `type` metaclass directly.

MyDynamicClass = type('MyDynamicClass', (object,), {'greet': lambda self: 'Hello'})
obj = MyDynamicClass()
print(obj.greet())

Metaclasses are a unique and powerful feature in Python that allows you to customize and control class creation. While they should not be overused, they are invaluable in scenarios such as enforcing coding standards, creating singletons, dynamically registering classes, and implementing frameworks. Mastery of metaclasses opens up a deeper understanding of Python's internals and unlocks new levels of design flexibility.

For most use cases, class decorators or regular inheritance might suffice. However, for advanced API design, enforcing interfaces, or abstract class mechanics, metaclasses are the appropriate tool. It is always recommended to keep metaclass logic simple and well-documented to avoid unnecessary complexity.