fixfield 0.1.0__py3-none-any.whl

fixfield/__init__.py

@@ -0,0 +1,17 @@
+from fixfield.rounding import RoundingStrategy
+from fixfield.types import FixedDecimal, FieldOverflowError
+from fixfield.field import Field, FieldValue
+from fixfield.record import Record, RecordField
+
+__version__ = "0.1.0"
+
+__all__ = [
+    "__version__",
+    "RoundingStrategy",
+    "FixedDecimal",
+    "FieldOverflowError",
+    "Field",
+    "FieldValue",
+    "Record",
+    "RecordField",
+]

fixfield/field.py

@@ -0,0 +1,73 @@
+from __future__ import annotations
+
+from typing import overload
+from fixfield.rounding import RoundingStrategy
+from fixfield.types import FixedDecimal, _NUMBER
+
+type FieldValue = _NUMBER | FixedDecimal
+
+
+class Field:
+    def __init__(
+        self,
+        places: int = 2,
+        rounding: RoundingStrategy = RoundingStrategy.ROUND_HALF_UP,
+        default: _NUMBER | None = None,
+        digits: int | None = None,
+    ) -> None:
+        self.places = places
+        self.rounding = rounding
+        self.digits = digits
+        self.default = (
+            FixedDecimal(default, places, rounding, digits)
+            if default is not None
+            else None
+        )
+        self._attr: str = ""  # set by __set_name__
+
+    def __set_name__(self, owner: type, name: str) -> None:
+        self._attr = f"_field_{name}"
+
+    @overload
+    def __get__(self, obj: None, objtype: type) -> Field: ...
+
+    @overload
+    def __get__(self, obj: object, objtype: type) -> FixedDecimal: ...
+
+    def __get__(self, obj: object | None, objtype: type) -> Field | FixedDecimal:
+        if obj is None:
+            return self
+        value = obj.__dict__.get(self._attr)
+        if value is None:
+            if self.default is not None:
+                return self.default
+            return FixedDecimal(0, self.places, self.rounding, self.digits)
+        return value
+
+    def __set__(self, obj: object, value: FieldValue) -> None:
+        raw = value.value if isinstance(value, FixedDecimal) else value
+        obj.__dict__[self._attr] = FixedDecimal(
+            raw, self.places, self.rounding, self.digits
+        )
+
+    @property
+    def width(self) -> int:
+        """
+        Fixed-width character length for this field.
+        Requires ``digits`` to be set.
+
+        Format: [sign(1)] + [integer digits] + [. + decimal places if places > 0]
+        Example: digits=5, places=2  →  "-99999.99"  → width 9
+        """
+        if self.digits is None:
+            raise ValueError(
+                "Field must have 'digits' set to use fixed-width serialization"
+            )
+        decimal_part = 1 + self.places if self.places > 0 else 0
+        return 1 + self.digits + decimal_part   # 1 for sign
+
+    def __repr__(self) -> str:
+        return (
+            f"Field(places={self.places}, rounding={self.rounding}, "
+            f"digits={self.digits}, default={self.default})"
+        )

fixfield/record.py

@@ -0,0 +1,175 @@
+from __future__ import annotations
+
+from typing import Generic, Self, TypeVar, overload
+from fixfield.field import Field, FieldValue
+from fixfield.types import FixedDecimal
+
+_R = TypeVar("_R", bound="Record")
+
+
+class RecordField(Generic[_R]):
+    """
+    Descriptor for embedding a nested Record as a field within another Record.
+
+    Example::
+
+        class Address(Record):
+            zip_code = Field(places=0, digits=5)
+
+        class Customer(Record):
+            customer_id = Field(places=0, digits=6)
+            address     = RecordField(Address)
+    """
+
+    def __init__(self, record_type: type[_R]) -> None:
+        self.record_type = record_type
+        self._attr: str = ""
+
+    def __set_name__(self, owner: type, name: str) -> None:
+        self._attr = f"_recordfield_{name}"
+
+    @overload
+    def __get__(self, obj: None, objtype: type) -> RecordField[_R]: ...
+    @overload
+    def __get__(self, obj: object, objtype: type) -> _R: ...
+
+    def __get__(self, obj: object | None, objtype: type) -> RecordField[_R] | _R:
+        if obj is None:
+            return self
+        value = obj.__dict__.get(self._attr)
+        if value is None:
+            return self.record_type()
+        return value  # type: ignore[return-value]
+
+    def __set__(self, obj: object, value: _R) -> None:
+        if not isinstance(value, self.record_type):
+            raise TypeError(
+                f"Expected {self.record_type.__name__}, got {type(value).__name__}"
+            )
+        obj.__dict__[self._attr] = value
+
+    @property
+    def width(self) -> int:
+        """Total fixed-width character length of the nested record."""
+        return sum(attr.width for attr in self.record_type._all_attrs.values())
+
+    def __repr__(self) -> str:
+        return f"RecordField({self.record_type.__name__})"
+
+
+class Record:
+    """
+    Base class for structured groups of Fields.
+
+    Subclass and declare Fields (and optionally RecordFields) as class
+    attributes. Record generates an __init__ that accepts values for each
+    declared attribute by keyword, coercing each through its declared
+    precision automatically.
+
+    Arithmetic convention: the LEFT operand's precision governs the result.
+
+    Example::
+
+        class Invoice(Record):
+            price    = Field(places=2)
+            tax_rate = Field(places=4)
+            total    = Field(places=2)
+
+        inv = Invoice(price="19.99", tax_rate="0.0825", total="0")
+        inv.total = inv.price * inv.tax_rate + inv.price
+    """
+
+    def __init_subclass__(cls, **kwargs: object) -> None:
+        super().__init_subclass__(**kwargs)
+        # Collect all declared fields in declaration order
+        all_attrs: dict[str, Field | RecordField] = {
+            name: obj
+            for name, obj in cls.__dict__.items()
+            if isinstance(obj, (Field, RecordField))
+        }
+        cls._all_attrs: dict[str, Field | RecordField] = all_attrs
+        cls._fields: dict[str, Field] = {
+            n: o for n, o in all_attrs.items() if isinstance(o, Field)
+        }
+        cls._record_fields: dict[str, RecordField] = {
+            n: o for n, o in all_attrs.items() if isinstance(o, RecordField)
+        }
+        cls.__init__ = _make_init(all_attrs)  # type: ignore[method-assign]
+
+    def __repr__(self) -> str:
+        parts = ", ".join(
+            f"{name}={getattr(self, name)!s}"
+            for name in self._all_attrs
+        )
+        return f"{type(self).__name__}({parts})"
+
+    def __eq__(self, other: object) -> bool:
+        if type(self) is not type(other):
+            return NotImplemented
+        return all(
+            getattr(self, name) == getattr(other, name)
+            for name in self._all_attrs
+        )
+
+    def to_dict(self) -> dict[str, FixedDecimal | Record]:
+        return {name: getattr(self, name) for name in self._all_attrs}
+
+    def to_string(self) -> str:
+        """
+        Serialise the record to a fixed-width string.
+        Every Field must have ``digits`` set. RecordFields recurse into
+        their nested record's ``to_string``.
+        """
+        parts: list[str] = []
+        for name, attr in self._all_attrs.items():
+            value = getattr(self, name)
+            if isinstance(attr, RecordField):
+                parts.append(value.to_string())
+            else:
+                parts.append(str(value).rjust(attr.width))
+        return "".join(parts)
+
+    @classmethod
+    def from_string(cls, text: str) -> Self:
+        """
+        Parse a fixed-width string produced by ``to_string``.
+        Raises ``ValueError`` if ``text`` is shorter than the expected width.
+        """
+        expected = sum(attr.width for attr in cls._all_attrs.values())
+        if len(text) < expected:
+            raise ValueError(
+                f"{cls.__name__}.from_string expects at least {expected} "
+                f"characters, got {len(text)}"
+            )
+        offset = 0
+        kwargs: dict[str, str | Record] = {}
+        for name, attr in cls._all_attrs.items():
+            w = attr.width
+            chunk = text[offset : offset + w]
+            if isinstance(attr, RecordField):
+                kwargs[name] = attr.record_type.from_string(chunk)
+            else:
+                kwargs[name] = chunk.strip()
+            offset += w
+        return cls(**kwargs)
+
+
+def _make_init(all_attrs: dict[str, Field | RecordField]):
+    """Generates a keyword-only __init__ for all declared attrs."""
+    attr_names = list(all_attrs.keys())
+
+    def __init__(self: Record, **kwargs: FieldValue | Record) -> None:
+        for name in attr_names:
+            value = kwargs.get(name)
+            attr = all_attrs[name]
+            if value is not None:
+                setattr(self, name, value)
+            elif isinstance(attr, Field) and attr.default is not None:
+                object.__setattr__(self, f"_field_{name}", attr.default)
+            # else: leave unset — descriptor returns zero/empty on access
+
+    __init__.__doc__ = (
+        "Args:\n" + "\n".join(f"    {n}: {all_attrs[n]}" for n in attr_names)
+    )
+
+    return __init__

fixfield/rounding.py

@@ -0,0 +1,48 @@
+
+
+
+import decimal
+from enum import Enum, auto
+
+class RoundingStrategy(Enum):
+    ROUND_HALF_UP   = auto()
+    ROUND_HALF_DOWN = auto()
+    ROUND_UP        = auto()
+    ROUND_DOWN      = auto()
+    ROUND_CEILING   = auto()
+    ROUND_FLOOR     = auto()
+    ROUND_HALF_EVEN = auto()
+    ROUND_HALF_ODD  = auto()
+
+
+def _round_half_odd(value: decimal.Decimal, places: int) -> decimal.Decimal:
+    quantizer = decimal.Decimal(10) ** -places
+    floor = value.quantize(quantizer, rounding=decimal.ROUND_FLOOR)
+    ceil  = value.quantize(quantizer, rounding=decimal.ROUND_CEILING)
+    half  = quantizer / 2
+    if abs(value - floor) == half:
+        # exactly halfway — pick whichever of floor/ceil is odd
+        return floor if floor % (2 * quantizer) != 0 else ceil
+    # not halfway — normal rounding applies
+    return value.quantize(quantizer, rounding=decimal.ROUND_HALF_EVEN)
+
+
+_DECIMAL_MAP = {
+    RoundingStrategy.ROUND_HALF_UP:   decimal.ROUND_HALF_UP,
+    RoundingStrategy.ROUND_HALF_DOWN: decimal.ROUND_HALF_DOWN,
+    RoundingStrategy.ROUND_UP:        decimal.ROUND_UP,
+    RoundingStrategy.ROUND_DOWN:      decimal.ROUND_DOWN,
+    RoundingStrategy.ROUND_CEILING:   decimal.ROUND_CEILING,
+    RoundingStrategy.ROUND_FLOOR:     decimal.ROUND_FLOOR,
+    RoundingStrategy.ROUND_HALF_EVEN: decimal.ROUND_HALF_EVEN,
+}
+
+
+def apply(value: decimal.Decimal, places: int, strategy: RoundingStrategy) -> decimal.Decimal:
+    if strategy is RoundingStrategy.ROUND_HALF_ODD:
+        return _round_half_odd(value, places)
+
+    with decimal.localcontext() as ctx:
+        ctx.rounding = _DECIMAL_MAP[strategy]
+        return value.quantize(decimal.Decimal(10) ** -places, context=ctx)
+    

fixfield/types.py

@@ -0,0 +1,160 @@
+
+
+from __future__ import annotations
+import decimal
+from fixfield.rounding import RoundingStrategy, apply
+
+type _NUMBER = str | float | int | decimal.Decimal
+
+
+class FieldOverflowError(ValueError):
+    """Raised when a value exceeds the declared integer-digit capacity."""
+
+
+def _to_decimal(value: _NUMBER) -> decimal.Decimal:
+    if isinstance(value, float):
+        return decimal.Decimal(str(value))
+    return decimal.Decimal(value)  # type: ignore[arg-type]
+
+
+class FixedDecimal:
+    places: int
+    digits: int | None
+    rounding: RoundingStrategy
+
+    def __init__(
+        self,
+        value: _NUMBER,
+        places: int = 2,
+        rounding: RoundingStrategy = RoundingStrategy.ROUND_HALF_UP,
+        digits: int | None = None,
+    ) -> None:
+        self.places = places
+        self.rounding = rounding
+        self.digits = digits
+        rounded = apply(_to_decimal(value), places, rounding)
+        if digits is not None:
+            limit = decimal.Decimal(10) ** digits
+            if abs(rounded) >= limit:
+                raise FieldOverflowError(
+                    f"value {rounded} exceeds {digits} integer digits"
+                )
+        self.value = rounded
+
+    def _new(self, value: decimal.Decimal) -> FixedDecimal:
+        return FixedDecimal(value, self.places, self.rounding, self.digits)
+
+    def _coerce(self, other: FixedDecimal | _NUMBER) -> FixedDecimal:
+        if not isinstance(other, FixedDecimal):
+            return FixedDecimal(other, self.places, self.rounding, self.digits)
+        return other
+
+    # Arithmetic --------------------------------------------------------------
+    # Convention: the LEFT operand's precision (places, rounding, digits)
+    # always governs the result. The right operand's rounding is ignored.
+    # This mirrors COBOL's COMPUTE statement where the receiving field
+    # defines the result's precision.
+
+    def __add__(self, other: FixedDecimal | _NUMBER) -> FixedDecimal:
+        return self._new(self.value + self._coerce(other).value)
+
+    def __sub__(self, other: FixedDecimal | _NUMBER) -> FixedDecimal:
+        return self._new(self.value - self._coerce(other).value)
+
+    def __mul__(self, other: FixedDecimal | _NUMBER) -> FixedDecimal:
+        return self._new(self.value * self._coerce(other).value)
+
+    def __truediv__(self, other: FixedDecimal | _NUMBER) -> FixedDecimal:
+        return self._new(self.value / self._coerce(other).value)
+
+    # Reverse arithmetic — scalars on the left (e.g. 2 * price) ---------------
+    # Left operand's precision is unknown so we use self's precision.
+
+    def __radd__(self, other: _NUMBER) -> FixedDecimal:
+        return self._new(_to_decimal(other) + self.value)
+
+    def __rsub__(self, other: _NUMBER) -> FixedDecimal:
+        return self._new(_to_decimal(other) - self.value)
+
+    def __rmul__(self, other: _NUMBER) -> FixedDecimal:
+        return self._new(_to_decimal(other) * self.value)
+
+    def __rtruediv__(self, other: _NUMBER) -> FixedDecimal:
+        return self._new(_to_decimal(other) / self.value)
+
+    def __neg__(self) -> FixedDecimal:
+        return self._new(-self.value)
+
+    def __abs__(self) -> FixedDecimal:
+        return self._new(abs(self.value))
+
+    # Copy / replace ----------------------------------------------------------
+
+    def copy(self) -> FixedDecimal:
+        """Return an identical copy."""
+        return self._new(self.value)
+
+    def replace(
+        self,
+        *,
+        places: int | None = None,
+        rounding: RoundingStrategy | None = None,
+        digits: int | None = ...,  # type: ignore[assignment]
+    ) -> FixedDecimal:
+        """
+        Return a new ``FixedDecimal`` with selected attributes changed.
+        The value is re-rounded to the new precision.
+
+        Pass ``digits=None`` explicitly to remove the digit cap.
+        """
+        new_places   = self.places   if places   is None else places
+        new_rounding = self.rounding if rounding is None else rounding
+        new_digits   = self.digits   if digits   is ... else digits
+        return FixedDecimal(self.value, new_places, new_rounding, new_digits)
+
+    # Comparisons -------------------------------------------------------------
+    # FixedDecimal vs FixedDecimal: precision-sensitive (value AND places must match).
+    # FixedDecimal vs raw scalar: value-only, so FixedDecimal("1.00", places=2) == 1
+    # is True regardless of places. This is intentional — raw scalars carry no
+    # precision information.
+
+    def __eq__(self, other: object) -> bool:
+        if isinstance(other, FixedDecimal):
+            return self.value == other.value and self.places == other.places
+        if isinstance(other, (str, int, float, decimal.Decimal)):
+            return self.value == _to_decimal(other)
+        return NotImplemented
+
+    def __ne__(self, other: object) -> bool:
+        result = self.__eq__(other)
+        if result is NotImplemented:
+            return result
+        return not result
+
+    def __lt__(self, other: FixedDecimal | _NUMBER) -> bool:
+        return self.value < self._coerce(other).value
+
+    def __le__(self, other: FixedDecimal | _NUMBER) -> bool:
+        return self.value <= self._coerce(other).value
+
+    def __gt__(self, other: FixedDecimal | _NUMBER) -> bool:
+        return self.value > self._coerce(other).value
+
+    def __ge__(self, other: FixedDecimal | _NUMBER) -> bool:
+        return self.value >= self._coerce(other).value
+
+    def __hash__(self) -> int:
+        # Includes places so precision-different instances with equal values
+        # hash differently — consistent with precision-sensitive __eq__.
+        return hash((self.value, self.places))
+
+    # Representation ----------------------------------------------------------
+
+    def __repr__(self) -> str:
+        return (
+            f"FixedDecimal(value={self.value}, places={self.places}, "
+            f"rounding={self.rounding})"
+        )
+
+    def __str__(self) -> str:
+        return f"{self.value:.{self.places}f}"

fixfield-0.1.0.dist-info/METADATA

@@ -0,0 +1,248 @@
+Metadata-Version: 2.4
+Name: fixfield
+Version: 0.1.0
+Summary: Fixed-decimal arithmetic with per-field precision enforcement
+Author-email: Charles Reilly <charlesreilly0@gmail.com>
+License: MIT
+License-File: LICENSE
+Keywords: cobol,decimal,finance,fixed-point,precision
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.14
+Classifier: Topic :: Office/Business :: Financial
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Classifier: Typing :: Typed
+Requires-Python: >=3.14
+Description-Content-Type: text/markdown
+
+# fixfield
+
+Fixed-decimal arithmetic for Python with per-field precision enforcement.
+
+Inspired by COBOL's `PIC` clause — declare precision once on the field, and it is enforced automatically on every assignment and arithmetic result.
+
+---
+
+## Installation
+
+```bash
+uv add fixfield
+# or
+pip install fixfield
+```
+
+---
+
+## Quick Start
+
+```python
+from fixfield import Record, Field, RoundingStrategy
+
+class Invoice(Record):
+    price    = Field(places=2)
+    tax_rate = Field(places=4)
+    tax      = Field(places=2)
+    total    = Field(places=2)
+
+inv = Invoice(price="19.99", tax_rate="0.0825")
+inv.tax   = inv.price * inv.tax_rate   # 1.649175 → rounded to 1.65
+inv.total = inv.price + inv.tax        # 21.64
+
+print(inv.total)   # "21.64"
+print(repr(inv))   # Invoice(price=19.99, tax_rate=0.0825, tax=1.65, total=21.64)
+```
+
+---
+
+## Why Not Just Use `decimal.Decimal`?
+
+| | `decimal.Decimal` | `fixfield` |
+|---|---|---|
+| Precision location | Global context or per `.quantize()` call | Declared on the field, enforced automatically |
+| Rounding enforcement | Manual on every result | Automatic on every assignment |
+| Per-field rounding strategy | Manual | Declarative |
+| Domain modelling | Plain values | Named record schema |
+
+With `decimal` you must call `.quantize()` on every result or silently lose precision. With `fixfield` the field declaration is the single source of truth.
+
+---
+
+## Core Concepts
+
+### `FixedDecimal`
+
+A scalar decimal value locked to a declared precision.
+
+```python
+from fixfield import FixedDecimal, RoundingStrategy
+
+price = FixedDecimal("19.999", places=2)
+str(price)   # "20.00" — rounded on construction
+
+# Arithmetic preserves left operand's precision
+result = price + FixedDecimal("1.005", places=4)
+result.places     # 2  (left operand wins)
+str(result)       # "21.00"
+
+# Comparisons work naturally
+price > FixedDecimal("10.00")   # True
+price == "20.00"                # True
+
+# Unary operators
+str(-price)        # "-20.00"
+str(abs(-price))   # "20.00"
+```
+
+Float inputs are automatically converted via `str` to avoid binary imprecision:
+
+```python
+FixedDecimal(0.1 + 0.2, places=2)   # "0.30" not "0.30000000000000004"
+```
+
+### `Field`
+
+A descriptor that enforces precision on a class attribute. Used inside a `Record`.
+
+```python
+from fixfield import Field, RoundingStrategy
+
+price    = Field(places=2)                                    # default ROUND_HALF_UP
+tax_rate = Field(places=4, rounding=RoundingStrategy.ROUND_FLOOR)
+total    = Field(places=2, default="0.00")
+capped   = Field(places=2, digits=5)                          # max 99999.99
+```
+
+| Parameter | Default | Description |
+|---|---|---|
+| `places` | `2` | Decimal places to keep |
+| `rounding` | `ROUND_HALF_UP` | Rounding strategy on assignment |
+| `default` | `None` | Default value (zero if not set) |
+| `digits` | `None` | Max integer digits — raises `FieldOverflowError` if exceeded |
+
+### `Record`
+
+A structured collection of `Field` descriptors. Generates `__init__`, `__repr__`, and `__eq__` automatically.
+
+> **Field ordering** relies on Python's guaranteed `dict` insertion order (Python 3.7+). Fields are serialised to and from fixed-width strings in the order they are declared in the class body.
+
+```python
+from fixfield import Record, Field
+
+class Payment(Record):
+    amount     = Field(places=2, digits=7)   # up to 9999999.99
+    fee        = Field(places=2, digits=4)
+    net        = Field(places=2, digits=7)
+
+p = Payment(amount="1000.00", fee="2.50")
+p.net = p.amount - p.fee
+
+print(p)          # Payment(amount=1000.00, fee=2.50, net=997.50)
+p.to_dict()       # {"amount": FixedDecimal(...), "fee": ..., "net": ...}
+```
+
+### `RecordField`
+
+Embed a nested `Record` as a field inside another `Record`. The nested record's fields participate in `to_string`/`from_string` as a contiguous block.
+
+```python
+from fixfield import Record, Field, RecordField
+
+class Address(Record):
+    zip_code = Field(places=0, digits=5)
+    state    = Field(places=0, digits=2)
+
+class Customer(Record):
+    customer_id = Field(places=0, digits=6)
+    address     = RecordField(Address)
+
+c = Customer(customer_id="42", address=Address(zip_code="90210", state="6"))
+line = c.to_string()                        # "    42 90210 6"
+parsed = Customer.from_string(line)
+str(parsed.address.zip_code)                # "90210"
+```
+
+`RecordField` is generic: `RecordField[Address]` so your IDE knows that `c.address` is an `Address`, not just a `Record`.
+
+### `RoundingStrategy`
+
+```python
+from fixfield import RoundingStrategy
+
+RoundingStrategy.ROUND_HALF_UP    # 2.5 → 3  (COBOL ROUNDED default)
+RoundingStrategy.ROUND_HALF_DOWN  # 2.5 → 2
+RoundingStrategy.ROUND_HALF_EVEN  # 2.5 → 2, 3.5 → 4  (banker's rounding)
+RoundingStrategy.ROUND_HALF_ODD   # 2.5 → 3, 3.5 → 3
+RoundingStrategy.ROUND_UP         # always away from zero
+RoundingStrategy.ROUND_DOWN       # always toward zero (truncate)
+RoundingStrategy.ROUND_CEILING    # toward +∞
+RoundingStrategy.ROUND_FLOOR      # toward -∞
+```
+
+---
+
+## Fixed-Width Serialization
+
+When every `Field` has `digits` set, records can be serialized to and from fixed-width strings — useful for mainframe flat files and legacy EDI formats.
+
+```python
+class CustomerRecord(Record):
+    customer_id = Field(places=0, digits=6)    # 7 chars:  " 123456"
+    balance     = Field(places=2, digits=8)    # 11 chars: "  99999.99"
+
+rec = CustomerRecord(customer_id="123456", balance="99999.99")
+line = rec.to_string()             # " 123456  99999.99"
+
+parsed = CustomerRecord.from_string(line)
+parsed.balance == rec.balance      # True
+```
+
+Field width formula: `1 (sign) + digits + (1 + places if places > 0 else 0)`
+
+---
+
+## Overflow Protection
+
+```python
+from fixfield import Field, Record, FieldOverflowError
+
+class Account(Record):
+    balance = Field(places=2, digits=5)   # max 99999.99
+
+a = Account()
+a.balance = "99999.99"   # ok
+a.balance = "100000.00"  # raises FieldOverflowError
+```
+
+---
+
+## Dataclass Integration
+
+For users who prefer `@dataclass`, use `FixedDecimal` directly and coerce values in `__post_init__`:
+
+```python
+from dataclasses import dataclass, field
+from fixfield import FixedDecimal, RoundingStrategy
+
+@dataclass
+class LineItem:
+    price:    FixedDecimal = field(default_factory=lambda: FixedDecimal(0, places=2))
+    quantity: int = 1
+
+    def __post_init__(self):
+        if not isinstance(self.price, FixedDecimal):
+            self.price = FixedDecimal(self.price, places=2)
+
+    @property
+    def total(self) -> FixedDecimal:
+        return self.price * self.quantity
+```
+
+For full precision enforcement without `__post_init__` boilerplate, use `Record` instead.
+
+---
+
+## License
+
+MIT

fixfield-0.1.0.dist-info/RECORD

@@ -0,0 +1,10 @@
+fixfield/__init__.py,sha256=rYGhkQtdSvgnwxPRKKBPpRQnfdBrhS_YO7frJZTxTA0,391
+fixfield/field.py,sha256=GW_tRcwp1s19F1riMxAXKBSoHKPAWRButrB0fRaEJqQ,2399
+fixfield/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+fixfield/record.py,sha256=yhqW0D9YBnTo4D1IYBxCOHZCxjgp2wpuHe-9uEzbOcc,6078
+fixfield/rounding.py,sha256=QeMNDXSLcOvuO_8CpQkgqQzuZa2Pc5vZGgPDITHSBu0,1683
+fixfield/types.py,sha256=xSMa8qxw0s4BKIRt4YIE4Gz05aDEGfyD5TlhqG2thGU,5993
+fixfield-0.1.0.dist-info/METADATA,sha256=lM7kosD1t68r308eyGyd4sXNKP2ETcYGYp_xtjZr1A4,7402
+fixfield-0.1.0.dist-info/WHEEL,sha256=QccIxa26bgl1E6uMy58deGWi-0aeIkkangHcxk2kWfw,87
+fixfield-0.1.0.dist-info/licenses/LICENSE,sha256=vKYEaMk4m1-gPk-kEcwDlFEzARj6t1hj4lhumZC3uTk,1071
+fixfield-0.1.0.dist-info/RECORD,,

fixfield-0.1.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.29.0
+Root-Is-Purelib: true
+Tag: py3-none-any

fixfield-0.1.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Charles Reilly
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.