Implement an immutable USD money value object in Python

• Use Decimal, not binary floating point.
• Keep the dataclass frozen and normalize accepted values to two decimal places.
• Reject negative values and values that would need rounding.
• Return a new value from addition.
• Keep equality and hashing consistent with normalized state.

1. Parse external text directly into Decimal.
2. Quantize to cents, then reject when the quantized numeric value differs.
3. Use object.__setattr__ inside __post_init__ to store normalized state in the frozen instance.
4. Construct arithmetic results through the same invariant.
5. Test equivalent exponents, invalid precision, immutability, and ordering.

from dataclasses import dataclass
from decimal import Decimal
from functools import total_ordering

CENT = Decimal("0.01")

@total_ordering
@dataclass(frozen=True, slots=True)
class UsdMoney:
    amount: Decimal

    def __post_init__(self) -> None:
        if not isinstance(self.amount, Decimal):
            raise TypeError("amount must be Decimal")
        normalized = self.amount.quantize(CENT)
        if normalized != self.amount:
            raise ValueError("amount must have at most two decimal places")
        if normalized < 0:
            raise ValueError("amount must be non-negative")
        object.__setattr__(self, "amount", normalized)

    @classmethod
    def from_text(cls, value: str) -> "UsdMoney":
        return cls(Decimal(value))

    def __add__(self, other: "UsdMoney") -> "UsdMoney":
        if not isinstance(other, UsdMoney):
            return NotImplemented
        return UsdMoney(self.amount + other.amount)

    def __lt__(self, other: "UsdMoney") -> bool:
        if not isinstance(other, UsdMoney):
            return NotImplemented
        return self.amount < other.amount

Construction, comparison, and addition are proportional to the number of decimal digits. Each value stores one normalized immutable Decimal.

• 2, 2.0, and 2.00 normalize to equal values.
• 1.005 is rejected instead of rounded.
• NaN and infinity need an explicit product policy if external input can contain them.
• A product maximum is separate from the value object's scale invariant.

• Verify equivalent inputs have equal hashes.
• Attempt construction from float, negative text, and excessive precision.
• Verify addition leaves both operands unchanged.
• Verify comparison with an unrelated type follows Python's protocol.

• Calling Decimal with a float preserves binary floating-point noise.
• Using ordinary mutable dataclass fields breaks value-object assumptions.
• Quantizing without comparing silently rounds unauthorized input.
• Validating only in a factory leaves direct construction unsafe.