Summary  
This chapter explains how to use the `__subclasshook__` method in abstract base classes to perform structural (protocol-style) subtype checks by detecting required methods on a class, enabling `isinstance()`/`issubclass()` to succeed without explicit inheritance or registration.

General domain of usage  
Serialization

`register()` requires explicit opt-in for each class. `__subclasshook__` goes further – it lets an ABC automatically accept any class that satisfies a structural condition, without requiring registration at all. This is how Python's built-in ABCs like `Iterable` work.

In this video, you will explore how `__subclasshook__` enables structural, protocol-style checks in Python Abstract Base Classes. Learn how `__subclasshook__` differs from `register()`, and see step-by-step demonstrations using the `Serializable` and `Iterable` examples. Watch as the video explains how any class with a `serialize()` method can automatically be recognized as a `Serializable`, and how `collections.abc.Iterable` uses the same approach with `__iter__`. The video also shows how `__subclasshook__` works independently of abstract method enforcement, combining protocol checks with traditional ABC features. Finally, you will see a clear comparison of `register()` and `__subclasshook__`, helping you decide when to use each mechanism for custom membership in your own ABCs.

- video metadata (use this info when making a video) --
Cut all examples of code to a minimum. Show only the essential code. Show code no longer than 10 lines. Remove all possible pieces to demonstrate some code feature. You may show not full code that will not start, but still demonstrates some feature theoritacally.
If code is longer than 8 lines, move code output  blocks to second column.

## How `__subclasshook__` Works

`__subclasshook__` is a class method called by `isinstance()` and `issubclass()` before consulting the MRO or the registered subclasses. It returns:

- `True` – the class is considered a subclass;
- `False` – the class is explicitly not a subclass;
- `NotImplemented` – fall through to normal lookup.

from abc import ABC, abstractmethod

# ABC that automatically accepts any class with a serialize() method
class Serializable(ABC):
    @abstractmethod
    def serialize(self):
        pass

    @classmethod
    def __subclasshook__(cls, subclass):
        if cls is Serializable:
            if any("serialize" in klass.__dict__ for klass in subclass.__mro__):
                return True
        return NotImplemented

# A class that never heard of Serializable
class TransactionRecord:
    def serialize(self):
        return {"id": "TX-001", "amount": 4500.0}

# Passes isinstance() without register() or inheritance
print(isinstance(TransactionRecord(), Serializable))   # True
print(issubclass(TransactionRecord, Serializable))     # True

## How the Standard Library Uses `__subclasshook__`

`collections.abc.Iterable` uses exactly this mechanism – any class that defines `__iter__` is automatically considered an `Iterable`:

from collections.abc import Iterable

# Custom class with __iter__ – no inheritance from Iterable
class DataStream:
    def __init__(self, records):
        self._records = records

    def __iter__(self):
        return iter(self._records)

stream = DataStream([{"id": 1}, {"id": 2}, {"id": 3}])

print(isinstance(stream, Iterable))  # True – __subclasshook__ recognized __iter__

for record in stream:
    print(record)

## Combining `__subclasshook__` with Abstract Methods

`__subclasshook__` controls `isinstance()`/`issubclass()` checks, but does not enforce abstract methods on real subclasses. The two mechanisms are independent:

from abc import ABC, abstractmethod

class Runnable(ABC):
    @abstractmethod
    def run(self):
        pass

    @classmethod
    def __subclasshook__(cls, subclass):
        if cls is Runnable:
            if any("run" in klass.__dict__ for klass in subclass.__mro__):
                return True
        return NotImplemented

# Structural check passes – run() is present
class BackgroundJob:
    def run(self):
        print("Running background job")

print(isinstance(BackgroundJob(), Runnable))   # True

# Real subclass still gets enforcement
class BrokenJob(Runnable):
    pass  # Missing run()

job = BrokenJob()  # TypeError – abstract method not implemented

What should `__subclasshook__` return to signal that normal ABC membership lookup should proceed?

Explore the power and flexibility of Python's Abstract Base Classes (ABCs). Learn how to design robust APIs, enforce contracts, and distinguish between ABCs and protocols for advanced object-oriented programming.

Discover why Abstract Base Classes matter, how to define them, and the rules for enforcing abstract methods in Python.

Delve into advanced features of ABCs, including abstract properties, virtual subclassing, and custom membership logic.

Compare typing.Protocol with ABCs, explore runtime checkable protocols, and learn when to use each approach.

subclasshook and Custom Membership

How `subclasshook` Works

How the Standard Library Uses `subclasshook`

Combining `subclasshook` with Abstract Methods

`register()` vs `subclasshook`

__subclasshook__ and Custom Membership

How __subclasshook__ Works

How the Standard Library Uses __subclasshook__

Combining __subclasshook__ with Abstract Methods

register() vs __subclasshook__

subclasshook and Custom Membership

How `subclasshook` Works

How the Standard Library Uses `subclasshook`

Combining `subclasshook` with Abstract Methods

`register()` vs `subclasshook`