Class Hooks and ABC Contracts

Introduction

Welcome back to Class Machinery: Dataclasses, Descriptors, Metaclasses! You've made excellent progress, having mastered advanced dataclasses for robust data containers and descriptors for sophisticated attribute validation. In our previous lesson, you built reusable Range descriptors that provide centralized validation logic across multiple classes and attributes. Today, we're exploring the powerful combination of Abstract Base Classes (ABCs) and class hooks to build extensible plugin architectures. While descriptors give us control over attribute access, ABCs and class hooks let us control class creation and enforce contracts across inheritance hierarchies. This combination is perfect for building systems where new functionality can be added simply by defining new classes that follow established protocols. We'll construct a self-registering plugin system that automatically discovers concrete implementations while enforcing abstract contracts. Using abc.ABC for interface definitions and__init_subclass__for automatic registration, we'll build a transformation pipeline where plugins are discovered, validated, and executed in priority order. By the end, you'll understand how to create extensible architectures that grow naturally as new requirements emerge.

Understanding Abstract Base Classes and Class Hooks

In programming, a contract is a formal specification that defines the interface and behavioral expectations that implementing code must satisfy. It establishes what methods must exist, what parameters they accept, and what they should return, without dictating how the implementation achieves these requirements. Abstract Base Classes serve as contracts in Python, defining interfaces that subclasses must implement while preventing the instantiation of incomplete classes. Combined with class hooks, they create powerful patterns for automatic registration and validation during class creation. The abc module provides the infrastructure for creating abstract classes that cannot be instantiated until all abstract methods are implemented. This ensures that concrete subclasses adhere to the expected interface, catching implementation errors early and making code more reliable. Meanwhile,__init_subclass__is a special method called automatically whenever a class is subclassed, allowing parent classes to inspect, validate, or register their children during class creation. Together, these features enable plugin architectures where new functionality is added by simply defining classes that inherit from a base class. The parent can automatically discover and register these plugins while ensuring they implement the required interface, creating systems that are both extensible and safe.

Join the 1M+ learners on CodeSignal

Be a part of our community of 1M+ users who develop and demonstrate their skills on CodeSignal

Python

from __future__ import annotations

import inspect
from abc import ABC, abstractmethod
from typing import Any, ClassVar


class PluginBase(ABC):
    registry: ClassVar[list[type["PluginBase"]]] = []

Python

    def __init_subclass__(cls, *, register: bool = True, **kwargs: Any) -> None:
        super().__init_subclass__(**kwargs)
        if register and not inspect.isabstract(cls):
            PluginBase.registry.append(cls)
            PluginBase.registry.sort(key=lambda c: getattr(c, "priority", 100))

Python

    @abstractmethod
    def execute(self, payload: dict[str, Any]) -> dict[str, Any]:
        raise NotImplementedError

Python

class BaseTransform(PluginBase):
    @abstractmethod
    def transform(self, payload: dict[str, Any]) -> dict[str, Any]:
        raise NotImplementedError

    def execute(self, payload: dict[str, Any]) -> dict[str, Any]:
        return self.transform(payload)

Python

from decimal import Decimal, ROUND_HALF_EVEN

class UpperCaseNames(BaseTransform):
    priority = 10

    def transform(self, payload: dict[str, Any]) -> dict[str, Any]:
        out = dict(payload)
        if "name" in out and out["name"] is not None:
            out["name"] = str(out["name"]).upper()
        return out

Python

class AddTax(PluginBase):
    priority = 20

    def execute(self, payload: dict[str, Any]) -> dict[str, Any]:
        out = dict(payload)
        if "amount" in out:
            amt = Decimal(str(out["amount"]))
            total = (amt * Decimal("1.10")).quantize(
                Decimal("0.01"), rounding=ROUND_HALF_EVEN
            )
            out["amount"] = str(total)
        return out

Python

class NotRegistered(PluginBase, register=False):
    priority = 5

    def execute(self, payload: dict[str, Any]) -> dict[str, Any]:
        return dict(payload)

Python

def run_all(payload: dict[str, Any]) -> dict[str, Any]:
    result = dict(payload)
    for cls in PluginBase.registry:
        result = cls().execute(result)
    return result

Python

if __name__ == "__main__":
    print(len(PluginBase.registry))
    print(",".join(c.__name__ for c in PluginBase.registry))

    data = {"name": "alpha beta", "amount": "10.00"}
    out = run_all(data)
    print(out["name"])
    print(out["amount"])

    print(any(c is BaseTransform for c in PluginBase.registry))
    print(any(c.__name__ == "NotRegistered" for c in PluginBase.registry))

    try:
        BaseTransform()
    except Exception as e:
        print(type(e).__name__)

text

2
UpperCaseNames,AddTax
ALPHA BETA
11.00
False
False
TypeError

Introduction

Understanding Abstract Base Classes and Class Hooks

Join the 1M+ learners on CodeSignal

Building a Plugin Registry System

Implementing Class Registration Hooks

Creating Abstract Contracts with ABC

Building Transform Plugins

Implementing Concrete Plugin Logic

Implementing Direct Plugin Execution

Managing Plugin Registration Control

Executing the Plugin Pipeline

Testing the Complete System

Conclusion and Next Steps