Python Dataclasses — Mutable Default Traps That Break Prod

from dataclasses import dataclass, field
from typing import List

# @dataclass reads the annotated class variables below and generates
# __init__, __repr__, and __eq__ automatically at class definition time.
@dataclass
class Product:
    name: str                          # Required field — no default, must be supplied
    price: float                       # Required field
    category: str = "Uncategorized"    # Optional field with a simple default value
    tags: List[str] = field(default_factory=list)  # Mutable default — MUST use field()

# Python calls the generated __init__ under the hood here
laptop = Product(name="ThinkPad X1", price=1299.99, category="Electronics", tags=["work", "portable"])
coffee = Product(name="Arabica Blend", price=14.50)  # category and tags get their defaults

# The generated __repr__ makes this print something actually useful
print(laptop)
print(coffee)

# The generated __eq__ compares field-by-field
identical_laptop = Product(name="ThinkPad X1", price=1299.99, category="Electronics", tags=["work", "portable"])
print(f"Same product? {laptop == identical_laptop}")   # True — field values match
print(f"Different products? {laptop == coffee}")        # False — fields differ

# You can still add your own methods — dataclass doesn't restrict this
def discounted_price(self, percent: float) -> float:
    return self.price * (1 - percent / 100)

Product.discounted_price = discounted_price  # Attaching for demo; normally define inside class
print(f"Laptop at 10% off: ${laptop.discounted_price(10):.2f}")

from dataclasses import dataclass, field
from typing import List

@dataclass
class LineItem:
    product_name: str
    unit_price: float
    quantity: int

    # init=False means this field is NOT part of the constructor signature —
    # callers never pass it. repr=True means it shows up in print() output.
    subtotal: float = field(init=False, repr=True)

    def __post_init__(self):
        # __post_init__ runs right after __init__ completes.
        # All fields (name, unit_price, quantity) are already set when this runs.
        if self.unit_price < 0:
            raise ValueError(f"unit_price cannot be negative, got {self.unit_price}")
        if self.quantity < 1:
            raise ValueError(f"quantity must be at least 1, got {self.quantity}")
        # Compute and store the subtotal — callers never need to calculate this themselves
        self.subtotal = round(self.unit_price * self.quantity, 2)


# frozen=True makes the whole object immutable after construction.
# It also enables __hash__, so Order instances can be used as dict keys or in sets.
@dataclass(frozen=True)
class Order:
    order_id: str
    customer_email: str
    items: tuple  # Use tuple, not list — lists are mutable and incompatible with frozen

    # This computed field summarises the order total
    total: float = field(init=False, repr=True)

    def __post_init__(self):
        if not self.customer_email or "@" not in self.customer_email:
            raise ValueError(f"Invalid customer email: '{self.customer_email}'")
        # With frozen=True, self.field = value raises FrozenInstanceError.
        # object.__setattr__ is the approved workaround inside __post_init__.
        object.__setattr__(self, "total", round(sum(item.subtotal for item in self.items), 2))


# --- Build a realistic order ---
item1 = LineItem(product_name="Mechanical Keyboard", unit_price=89.99, quantity=1)
item2 = LineItem(product_name="USB-C Hub", unit_price=34.50, quantity=2)
print(item1)
print(item2)

order = Order(order_id="ORD-001", customer_email="alex@example.com", items=(item1, item2))
print(order)
print(f"Order total: ${order.total}")

# Confirm immutability
try:
    order.order_id = "ORD-999"   # This should blow up
except Exception as err:
    print(f"Caught expected error: {err}")

# Confirm frozen dataclasses are hashable
processed_orders = {order}  # Can be added to a set
print(f"Order in set: {order in processed_orders}")

# Confirm validation fires
try:
    bad_item = LineItem(product_name="Ghost Product", unit_price=-5.00, quantity=1)
except ValueError as err:
    print(f"Validation caught: {err}")

from dataclasses import dataclass
from typing import NamedTuple, TypedDict

# Plain class
class PointClass:
    def __init__(self, x: float, y: float):
        self.x = x
        self.y = y

# NamedTuple
class PointNT(NamedTuple):
    x: float
    y: float

# Dataclass
@dataclass
class PointDC:
    x: float
    y: float

# TypedDict — just type hints, still a plain dict
class PointTD(TypedDict):
    x: float
    y: float

# Usage
p_class = PointClass(1.0, 2.0)
p_nt = PointNT(1.0, 2.0)
p_dc = PointDC(1.0, 2.0)
p_td: PointTD = {'x': 1.0, 'y': 2.0}

print(f"Class repr: {p_class}")
print(f"NamedTuple repr: {p_nt}")
print(f"Dataclass repr: {p_dc}")
print(f"TypedDict repr: {p_td}  (plain dict)")

from dataclasses import dataclass, asdict, astuple
from datetime import datetime
from typing import List

@dataclass
class Address:
    street: str
    city: str
    zip_code: str

@dataclass
class Customer:
    name: str
    email: str
    address: Address
    tags: List[str]

# Build a nested dataclass
addr = Address(street="123 Main St", city="Springfield", zip_code="12345")
customer = Customer(name="Alice", email="alice@example.com", address=addr, tags=["premium", "vip"])

# Convert to dict — recursive
data_dict = asdict(customer)
print("asdict:")
print(data_dict)

# Convert to tuple — field order
data_tuple = astuple(customer)
print("\nastuple:")
print(data_tuple)

# JSON serialization with asdict
import json
print("\nJSON:")
print(json.dumps(data_dict, indent=2))

# Verify deep copy: modifying the dict does not affect the original
data_dict["name"] = "Bob"
print(f"\nOriginal name unchanged: {customer.name}")

from dataclasses import dataclass, field, KW_ONLY

@dataclass
class User:
    username: str          # Required, can be positional or keyword
    email: str             # Required, can be positional or keyword
    _ = KW_ONLY            # All fields after this are keyword-only
    phone: str | None = None
    role: str = "viewer"
    department: str | None = None

# Valid calls:
user1 = User("alice", "alice@example.com", role="admin")
user2 = User("bob", "bob@example.com", phone="555-0100", department="eng")
print(user1)
print(user2)

# This would raise TypeError: User.__init__() takes 3 positional arguments but 4 were given
try:
    user3 = User("charlie", "charlie@example.com", "555-0200")  # phone as positional
except TypeError as e:
    print(f"Caught: {e}")

from dataclasses import dataclass, asdict, astuple
from typing import NamedTuple

# --- Option 1: Plain Class ---
# You write everything yourself. Maximum control, maximum boilerplate.
class PlainPoint:
    def __init__(self, x: float, y: float):
        self.x = x
        self.y = y

    def __repr__(self):
        return f"PlainPoint(x={self.x}, y={self.y})"

    def __eq__(self, other):
        if not isinstance(other, PlainPoint):
            return NotImplemented
        return self.x == other.x and self.y == other.y


# --- Option 2: NamedTuple ---
# Immutable, tuple-compatible, fast, but no post-init or mutable defaults.
class NamedPoint(NamedTuple):
    x: float
    y: float


# --- Option 3: Dataclass ---
# Generated boilerplate + full class features + serialization helpers.
@dataclass
class DataPoint:
    x: float
    y: float

    def distance_from_origin(self) -> float:
        return (self.x ** 2 + self.y ** 2) ** 0.5


# -- Demonstrate the differences --

plain = PlainPoint(3.0, 4.0)
named = NamedPoint(3.0, 4.0)
data  = DataPoint(3.0, 4.0)

print("--- Repr ---")
print(plain)  # Our hand-rolled repr
print(named)  # NamedTuple gives this for free
print(data)   # Dataclass gives this for free

print("\n--- Equality ---")
print(PlainPoint(1, 2) == PlainPoint(1, 2))  # True — we wrote __eq__
print(NamedPoint(1, 2) == NamedPoint(1, 2))  # True — tuple equality
print(DataPoint(1, 2) == DataPoint(1, 2))    # True — generated __eq__

print("\n--- Tuple unpacking (NamedTuple only) ---")
x_coord, y_coord = named          # Works because NamedTuple IS a tuple
print(f"Unpacked: x={x_coord}, y={y_coord}")
# x_coord, y_coord = data         # Would raise: cannot unpack dataclass directly

print("\n--- Dataclass serialization helpers ---")
print(asdict(data))    # {'x': 3.0, 'y': 4.0} — perfect for JSON serialization
print(astuple(data))   # (3.0, 4.0)

print("\n--- Custom method on dataclass ---")
print(f"Distance from origin: {data.distance_from_origin():.2f}")

print("\n--- Mutability ---")
data.x = 10.0          # Works fine — dataclasses are mutable by default
print(f"Mutated DataPoint: {data}")
try:
    named = named._replace(x=10.0)  # NamedTuple 'mutation' returns a new instance
    print(f"New NamedPoint: {named}")
except Exception as err:
    print(err)

from dataclasses import dataclass, field
from datetime import datetime
from typing import Optional

# Base dataclass with defaults — risky for inheritance
@dataclass
class BaseEntity:
    id: Optional[int] = None
    created_at: datetime = field(default_factory=datetime.now)

# This will raise: TypeError: non-default argument 'name' follows default argument
# class User(BaseEntity):
#     name: str
#     email: str

# Fix: give all child fields defaults, or separate into two hierarchies
@dataclass
class BaseEntityNoDefaults:
    id: int
    created_at: datetime

@dataclass
class User(BaseEntityNoDefaults):
    name: str
    email: str

# Alternatively, if you want defaults in child:
@dataclass
class Config:
    debug: bool = False
    timeout: int = 30

# child class with all fields having defaults
@dataclass
class ExtendedConfig(Config):
    feature_flag: bool = False
    retry_count: int = 3

print(Config(debug=True))
print(ExtendedConfig(debug=True, feature_flag=True))

from dataclasses import dataclass
from sys import getsizeof

# Standard dataclass
@dataclass
class Point:
    x: float
    y: float

# Slots dataclass — Python 3.10+
@dataclass(slots=True)
class SlottedPoint:
    x: float
    y: float

# Memory comparison
p = Point(1.0, 2.0)
sp = SlottedPoint(1.0, 2.0)

print(f"Point instance size: {getsizeof(p)} bytes (__dict__ size: {getsizeof(p.__dict__)})")
print(f"SlottedPoint instance size: {getsizeof(sp)} bytes (no __dict__)")

# Speed test (simplified)
import timeit
print(f"Point access: {timeit.timeit(lambda: p.x, number=10_000_000):.3f}s")
print(f"SlottedPoint access: {timeit.timeit(lambda: sp.x, number=10_000_000):.3f}s")

# Slots prevent arbitrary attribute assignment
try:
    sp.z = 3.0
except AttributeError as e:
    print(f"SlottedPoint rejects new attr: {e}")

# p.z = 3.0  # Works fine on regular dataclass