LLD in Python 3.14: dataclasses and protocols

Python 3.14 gives a low-level design four building blocks, and each one is checked at a different moment. A dataclass writes the constructor, equality and repr of a class from its annotated fields, and with frozen=True it becomes a value object whose fields cannot be reassigned. An enum is a closed set, and the members of a StrEnum are also strings, so they print, compare and serialise as their text. A protocol describes an abstraction by its methods: any class with matching methods satisfies it without inheriting from it. An abstract base class works the other way round: implementations inherit from it, and Python refuses to create an instance of one that leaves a method out. Python itself checks little of this while a program runs, so a good design knows which checks come from the language, which from a type checker and which from tests.

This lesson builds a parking model from these parts and runs it. Every example ran on Python 3.14.8, and the ones with a Run button also run in your browser on Pyodide, which carries CPython 3.14.2. How to find the classes of a design is the subject of from a script to an object model; this lesson writes them in Python.

Which Python construct for which part of a design

A design’s types fall into four groups, and Python has a construct for each:

• A value is nothing but its data (an amount of money, a spot number, a time range), and it becomes a @dataclass(frozen=True, slots=True). Equality and hashing come from the fields, so equal values are interchangeable and work as dictionary keys.
• An entity, an identity whose data changes, such as a ticket, an account or a parking lot, is a @dataclass(eq=False) or a plain class. Two tickets with the same data are still two tickets.
• A closed set of names without data, such as vehicle sizes or order statuses, is an Enum, or a StrEnum when the members travel as text.
• An abstraction with several implementations, such as a fee policy or a payment gateway, is a Protocol or an abstract base class.

The last choice is the one interviewers probe, because the two express the same idea with different checks:

The parking model below uses all four kinds. Money and SpotId are values, Ticket is an entity, Size is a StrEnum, and two fee policies satisfy a FeePolicy protocol without inheriting from it.

A parking model in about a hundred lines

"""A small parking design in Python 3.14.

Values are frozen dataclasses, vehicle sizes are a StrEnum, a ticket is an entity with an identity, and the two fee
policies satisfy the FeePolicy protocol without inheriting from it.
"""

from dataclasses import FrozenInstanceError, dataclass
from enum import StrEnum
from typing import Protocol


class Size(StrEnum):
    BIKE = "bike"
    CAR = "car"
    VAN = "van"


@dataclass(frozen=True, slots=True)
class Money:
    paise: int

    def __post_init__(self) -> None:
        if self.paise < 0:
            raise ValueError(f"an amount cannot be negative: {self.paise} paise")

    def __add__(self, other: Money) -> Money:
        return Money(self.paise + other.paise)

    def __str__(self) -> str:
        return f"{self.paise // 100}.{self.paise % 100:02d}"


@dataclass(frozen=True, slots=True)
class SpotId:
    level: int
    number: int


class FeePolicy(Protocol):
    def fee(self, size: Size, minutes: int) -> Money: ...


@dataclass(frozen=True, slots=True)
class HourlyFee:
    """Every started hour is charged; vans pay double."""

    per_hour: Money

    def fee(self, size: Size, minutes: int) -> Money:
        hours = -(-minutes // 60)
        factor = 2 if size is Size.VAN else 1
        return Money(self.per_hour.paise * hours * factor)


@dataclass(frozen=True, slots=True)
class FlatFee:
    """One price per visit, whatever the size."""

    amount: Money

    def fee(self, size: Size, minutes: int) -> Money:
        return self.amount


@dataclass(eq=False)
class Ticket:
    """An entity: two tickets with the same data are still two tickets."""

    number: str
    spot: SpotId
    size: Size
    entered_minute: int


class Lot:
    def __init__(self, policy: FeePolicy) -> None:
        self.policy = policy
        self.open: dict[str, Ticket] = {}

    def park(self, number: str, spot: SpotId, size: Size, minute: int) -> Ticket:
        ticket = Ticket(number, spot, size, minute)
        self.open[number] = ticket
        return ticket

    def leave(self, number: str, minute: int) -> Money:
        ticket = self.open.pop(number)
        return self.policy.fee(ticket.size, minute - ticket.entered_minute)


a, b = SpotId(1, 7), SpotId(1, 7)
print("equal values:", a == b, "| one object:", a is b, "| spots in a set:", len({a, b, SpotId(2, 1)}))
try:
    a.number = 8
except FrozenInstanceError as error:
    print("frozen:", error)
try:
    Money(-500)
except ValueError as error:
    print("refused:", error)

print("size from text:", Size("van") is Size.VAN, "| printed as:", f"{Size.VAN}")

t1 = Ticket("T1", SpotId(1, 7), Size.CAR, 0)
t2 = Ticket("T1", SpotId(1, 7), Size.CAR, 0)
print("same data, two tickets:", t1 == t2)

for policy in (HourlyFee(Money(4000)), FlatFee(Money(10000))):
    lot = Lot(policy)
    lot.park("T1", SpotId(1, 7), Size.CAR, minute=0)
    lot.park("T2", SpotId(1, 8), Size.VAN, minute=30)
    total = lot.leave("T1", minute=130) + lot.leave("T2", minute=95)
    print(f"{type(policy).__name__}: car 130 min + van 65 min = {total}")

equal values: True | one object: False | spots in a set: 2
frozen: cannot assign to field 'number'
refused: an amount cannot be negative: -500 paise
size from text: True | printed as: van
same data, two tickets: False
HourlyFee: car 130 min + van 65 min = 280.00
FlatFee: car 130 min + van 65 min = 200.00

Each line of the output is one property of the design. Two SpotId objects with the same fields are equal although they are separate objects, so a set holds two spots, not three. Assigning to a field of a frozen value raises FrozenInstanceError, and Money refuses a negative amount in __post_init__, the method that a dataclass calls right after its generated constructor. Size("van") returns the existing member, and the member prints as van. Two tickets with the same data are not equal, because eq=False keeps the identity equality that every object inherits.

The lot never asks what kind of policy it holds: it calls fee(). With hourly charging, the car’s 130 minutes start 3 hours at 40.00 each, and the van’s 65 minutes start 2 hours at the doubled rate, 280.00 in all; the flat policy charges 100.00 per visit. Swapping the policy changed one argument and no class.

One line of the file is new in Python 3.14. Money.__add__ names Money in its annotations while the class is still being defined, and without quotes. Earlier versions evaluated those annotations at once and stopped there with a NameError; Python 3.14 evaluates annotations only when something reads them.

What Python checks, and when

Each construct protects a design at one moment, and each stops at a known edge:

• __post_init__ runs every time an instance is created, so a check written there sees every value.
• frozen=True refuses assignment to a field, but not changes inside a list that a field holds.
• A plain @dataclass sets __hash__ to None, so an entity written that way cannot go into a set.
• An abstract base class refuses an incomplete subclass when you create an instance, not when you define it.
• isinstance() with a runtime-checkable protocol only checks that the names exist.
• @override marks a method as an override; Python never checks the mark, but type checkers do.
• match takes dataclasses apart field by field, and assert_never reports a state that has no case.

Knowing these edges is what separates a Python design that looks right from one that stays right when the next requirement arrives.

Value objects that stay valid: checks, copies and hashing Pro: opens with a Pro, Premium or Ultimate pass

ABCs, protocols and @override: what each one checks Pro: opens with a Pro, Premium or Ultimate pass

Python 3.14 in a design: annotations, enums and match Pro: opens with a Pro, Premium or Ultimate pass

Interview questions

Key takeaways

• Write values as frozen, slotted dataclasses and entities as eq=False dataclasses or plain classes.
• Use an Enum for a closed set, and a StrEnum when its members travel as text.
• Describe a plug-in abstraction with a Protocol, and a family that shares code with an abstract base class.
• Check values in __post_init__, where every instance passes through.
• Know which checks Python makes while the program runs and which only a type checker or a test makes.
• Python 3.14 evaluates annotations only when they are read, so classes can name each other without quotes.