Metaclasses, ABCs and Class Machinery

### The decorator does almost nothing `abc.abstractmethod` is three lines of Python. It sets `__isabstractmethod__ = True` on the function object handed to it and returns that same function unchanged. It does not wrap the function, does not replace its body, and does not block anything by itself. An abstract method is an ordinary method carrying a flag; its body still runs if a subclass calls it through `super()`, which is why abstract methods in real code are often a useful default rather than `...`. ### The metaclass reads the flag The enforcement lives in `abc.ABCMeta`. Writing `class CatalogueImporter(ABC)` is simply the readable way to get that metaclass — `class CatalogueImporter(metaclass=ABCMeta)` builds exactly the same thing. When `ABCMeta` creates a class it does two passes. First it scans the new class namespace for names whose value has a truthy `__isabstractmethod__`. Then, for every base class that already has an `__abstractmethods__` set, it re-resolves each of those names with `getattr` on the new class and keeps the ones that are *still* abstract. The union is frozen and stored as a class attribute, `__abstractmethods__`. So `PartialImporter.__abstractmethods__` is `frozenset({'rollback'})`: `load` was resolved to a concrete function defined in the subclass and dropped out of the set, `rollback` resolved back to the flagged function on the base and stayed. ### Where the TypeError is raised `object.__new__` refuses to build an instance of a class whose `__abstractmethods__` is non-empty, and that is the whole enforcement: ``` TypeError: Can't instantiate abstract class PartialImporter without an implementation for abstract method 'rollback' ``` With several missing names the message pluralises and lists them all: `... without an implementation for abstract methods 'load', 'rollback'`. The timing is the part interviews probe. **Class creation succeeds.** The module imports cleanly, the incomplete class is a perfectly good object, you can subclass it further, and static analysis or an editor may flag nothing. Only the call `PartialImporter()` fails. A missing implementation is therefore a runtime error on the first construction — which in a service means the first request that reaches that code path, not startup, unless something constructs the object eagerly at import. ### The check is name presence, not a contract `ABCMeta` asks only whether the name resolves to something non-abstract. It never inspects a signature, a return type or a docstring. Consequences worth saying out loud: * `def load(self): ...` in the subclass satisfies the base's `load(self, record)` even though calling it will fail with a `TypeError` about arguments. * Binding the name to a non-function clears it too: `load = None` in the class body makes the class instantiable, and so does a class-level attribute or an assignment to a `lambda`. * An ABC with no abstract methods at all is instantiable. `class Marker(ABC): pass` builds instances happily; `ABC` itself is only "abstract" in the sense that it supplies the metaclass. * If a class decorator adds or removes methods *after* the class object exists, the frozenset is already computed and stale; `abc.update_abstractmethods` recomputes it. Structural checkers do enforce signatures, but that is a separate, static story — the ABC machinery at runtime is presence-only. ### The failure mode when ABCMeta is absent Decorating methods with `@abstractmethod` on a class that is **not** built by `ABCMeta` does nothing enforceable. There is no `__abstractmethods__` attribute, `object.__new__` has nothing to check, and instances are created without complaint. This is the most common way an intended interface silently stops being one: someone refactors the base class, drops the `ABC` base (or introduces a competing metaclass) and every `@abstractmethod` decoration downgrades to documentation. ### What to say in an interview State the three moving parts in order: the decorator sets a flag on the function; `ABCMeta` collects the still-flagged names into `__abstractmethods__` at class-creation time; `object.__new__` raises `TypeError` while that set is non-empty. Then add the two facts that show you have debugged it — the error is at instantiation, not definition, and the check is name-based, so an ABC guarantees that a name exists and nothing about what it accepts or returns. If you want a compile-time contract on argument types, an ABC is not the tool; if you want "this object cannot be built until someone supplies a rollback", it is exactly the tool.