seampact-codegen 1.0.0__py3-none-any.whl

seampact/codegen/runtime/wire_codec.py

@@ -0,0 +1,229 @@
+"""Turns a decoded wire body into the tree a generated model validates, and a generated value back into the wire
+tree: object members renamed between their wire names and their Python attributes by the api's member table, unknown
+keys taken out and reported by pointer (the input use's `unknownKeys` policy decides on them), and on the way out
+`date-time` with its offset and the fraction it holds, `date`, `uuid`, decimals and enum members as wire text. Values
+are read by attribute, so a Pydantic model and a frozen dataclass both encode."""
+
+from collections.abc import Mapping, Sequence
+from dataclasses import dataclass, field
+from datetime import UTC, date, datetime, timedelta
+from decimal import Decimal
+from enum import Enum
+from typing import Final
+from uuid import UUID
+
+from seampact.codegen.runtime.contract import ApiContract
+from seampact.codegen.runtime.failures import BoundaryFailureError
+from seampact.codegen.runtime.ir_view import IrMap, ir_map, ir_maps, ir_string, ir_true
+from seampact.hooks import Absent
+
+_LIST_SHAPES: Final = frozenset({"list", "page"})
+_TABLE_SHAPE: Final = "table"
+_OBJECT_SCHEMA: Final = "object"
+_WHOLE_MINUTE: Final = timedelta(minutes=1)
+_FRACTION_DIGITS: Final = 6
+
+
+@dataclass(frozen=True, slots=True)
+class PythonTree:
+    """The tree a model validates; `unknown_keys` holds the wire pointer of each unknown member taken out."""
+
+    value: object
+    unknown_keys: tuple[str, ...] = field(default=())
+
+
+class WireCodec:
+    def __init__(self, contract: ApiContract) -> None:
+        self._contract = contract
+
+    def to_python(self, type_use: IrMap, tree: object) -> PythonTree:
+        """Raises `LookupError` for a schema the api has no member table or object declaration for."""
+        unknown: list[str] = []
+        value = self._to_python(type_use, tree, "", unknown)
+
+        return PythonTree(value, tuple(unknown))
+
+    def to_wire(self, type_use: IrMap, value: object) -> object:
+        """Raises `BoundaryFailureError` for a value the contract cannot write: null for a non-nullable opaque
+        value, a date-time without an offset, or an object without a declared attribute."""
+        if value is None or value is Absent.ABSENT:
+            if ir_string(type_use, "kind") == "opaque" and not ir_true(type_use, "nullable"):
+                raise BoundaryFailureError(
+                    "seampact: the handler wrote null for an opaque value the contract does not make nullable; "
+                    "return a JSON value, or declare it 'nullable: true'."
+                )
+
+            return None
+
+        kind = ir_string(type_use, "kind")
+
+        if kind == "ref":
+            return self._object_to_wire(ir_string(type_use, "schema") or "", value)
+
+        if kind == "array":
+            return [self.to_wire(ir_map(type_use, "items"), item) for item in _items(value, "an array value")]
+
+        if kind in ("scalar", "enum", "opaque"):
+            return scalar_to_wire(value)
+
+        raise LookupError(f"seampact: the type kind {kind!r} is not one the boundary encodes.")
+
+    def body_to_wire(self, response: IrMap, body: object) -> object:
+        """A response body as the wire writes it: a list's items, or a table's values keyed as the handler keyed
+        them.
+
+        Raises `BoundaryFailureError` for a list or page body that is not a list, or a table body that is not a
+        mapping."""
+        body_type = ir_map(response, "body")
+        shape = ir_string(response, "shape")
+
+        if shape in _LIST_SHAPES:
+            return [self.to_wire(body_type, item) for item in _items(body, f"a {shape} body")]
+
+        if shape == _TABLE_SHAPE:
+            return {str(key): self.to_wire(body_type, item) for key, item in _entries(body).items()}
+
+        return self.to_wire(body_type, body)
+
+    def _to_python(self, type_use: IrMap, tree: object, pointer: str, unknown: list[str]) -> object:
+        kind = ir_string(type_use, "kind")
+
+        if kind == "ref" and isinstance(tree, dict):
+            return self._object_to_python(ir_string(type_use, "schema") or "", tree, pointer, unknown)
+
+        if kind == "array" and isinstance(tree, list):
+            items = ir_map(type_use, "items")
+            return [self._to_python(items, item, f"{pointer}/{index}", unknown) for index, item in enumerate(tree)]
+
+        # A scalar, an enum or an opaque value, or a tree of the wrong type, which the model's type rule reports.
+        return tree
+
+    def _object_to_python(
+        self, schema_id: str, tree: dict[str, object], pointer: str, unknown: list[str]
+    ) -> dict[str, object]:
+        attributes, properties = self._object_schema(schema_id)
+        renamed: dict[str, object] = {}
+
+        for wire_name, value in tree.items():
+            attribute = attributes.get(wire_name)
+            member_pointer = f"{pointer}/{_escaped(wire_name)}"
+
+            if attribute is None:
+                unknown.append(member_pointer)
+                continue
+
+            renamed[attribute] = self._to_python(ir_map(properties[wire_name], "type"), value, member_pointer, unknown)
+
+        return renamed
+
+    def _object_to_wire(self, schema_id: str, value: object) -> dict[str, object]:
+        attributes, properties = self._object_schema(schema_id)
+        encoded: dict[str, object] = {}
+
+        for wire_name, attribute in attributes.items():
+            if not hasattr(value, attribute):
+                raise BoundaryFailureError(
+                    f"seampact: a {type(value).__qualname__} was written for the schema '{schema_id}', which has the "
+                    f"member '{attribute}'; return the generated type of the schema."
+                )
+
+            held = getattr(value, attribute)
+            member = properties[wire_name]
+
+            # An optional member that is not nullable holds None when absent; a nullable one holds `Field`.
+            absent_none = held is None and ir_true(member, "optional") and not ir_true(member, "nullable")
+
+            if held is Absent.ABSENT or absent_none:
+                continue
+
+            encoded[wire_name] = None if held is None else self.to_wire(ir_map(member, "type"), held)
+
+        return encoded
+
+    def _object_schema(self, schema_id: str) -> tuple[Mapping[str, str], dict[str, IrMap]]:
+        schema = self._contract.declaration("schemas", schema_id)
+        attributes = self._contract.members.get(schema_id)
+
+        if ir_string(schema, "kind") != _OBJECT_SCHEMA or attributes is None:
+            raise LookupError(f"seampact: no generated object type for the schema '{schema_id}'; regenerate the api.")
+
+        properties = {ir_string(member, "name") or "": member for member in ir_maps(schema, "properties")}
+
+        return attributes, properties
+
+
+def scalar_to_wire(value: object) -> object:
+    """A scalar, enum or opaque value as the wire writes it.
+
+    Raises `BoundaryFailureError` for a date-time without an offset and a decimal that is not finite, which the
+    contract cannot write."""
+    if isinstance(value, Enum):
+        return value.value
+
+    if isinstance(value, datetime):
+        if value.utcoffset() is None:
+            raise BoundaryFailureError(
+                "seampact: the handler wrote a date-time without an offset; give it a time zone, such as UTC."
+            )
+
+        return _date_time_text(value)
+
+    if isinstance(value, date):
+        return value.isoformat()
+
+    if isinstance(value, Decimal):
+        return _decimal_text(value)
+
+    if isinstance(value, UUID):
+        return str(value)
+
+    return value
+
+
+def _date_time_text(value: datetime) -> str:
+    """RFC 3339 with the fraction the value holds, without trailing zeros (ADR 0003 section 8); an offset with
+    seconds, which RFC 3339 cannot write, is written in UTC."""
+    offset = value.utcoffset()
+
+    if offset is not None and offset % _WHOLE_MINUTE:
+        value = value.astimezone(UTC)
+
+    if value.microsecond == 0:
+        return value.isoformat(timespec="seconds")
+
+    seconds, fraction_and_offset = value.isoformat(timespec="microseconds").split(".", 1)
+    fraction = fraction_and_offset[:_FRACTION_DIGITS].rstrip("0")
+
+    return f"{seconds}.{fraction}{fraction_and_offset[_FRACTION_DIGITS:]}"
+
+
+def _decimal_text(value: Decimal) -> str:
+    """ADR 0003's decimal wire form, never an exponent."""
+    if not value.is_finite():
+        raise BoundaryFailureError(f"seampact: the handler wrote the decimal {value}; write a finite decimal.")
+
+    return format(value, "f")
+
+
+def _items(value: object, held_as: str) -> Sequence[object]:
+    if not isinstance(value, list | tuple):
+        raise BoundaryFailureError(
+            f"seampact: the handler wrote {held_as} as a {type(value).__qualname__}, not a list; return a list."
+        )
+
+    return value
+
+
+def _entries(value: object) -> Mapping[object, object]:
+    if not isinstance(value, Mapping):
+        raise BoundaryFailureError(
+            f"seampact: the handler wrote a table body as a {type(value).__qualname__}, not a mapping; return a "
+            "mapping keyed as the contract keys it."
+        )
+
+    return value
+
+
+def _escaped(key: str) -> str:
+    """A JSON Pointer token (RFC 6901)."""
+    return key.replace("~", "~0").replace("/", "~1")

seampact/codegen/runtime/wire_values.py

@@ -0,0 +1,260 @@
+"""The IR's wire form of path, query and header values (ADR 0003): each is text on the wire, read as the integer,
+number or boolean its type names when the text spells one, and kept as text otherwise, so the type rule reports it.
+The query is read from the raw query string with form decoding, never through a framework's parsed query."""
+
+import math
+import re
+from collections.abc import Mapping, Sequence
+from decimal import Decimal
+from typing import Final
+from urllib.parse import quote, unquote_plus, unquote_to_bytes
+
+from seampact.codegen.runtime.ir_view import IrMap, ir_int, ir_map, ir_string
+from seampact.codegen.runtime.uuid_text import UUID_TEXT
+from seampact.codegen.runtime.wire_codec import scalar_to_wire
+
+_INTEGER: Final = re.compile(r"-?(0|[1-9][0-9]*)")
+_NUMBER: Final = re.compile(r"-?(0|[1-9][0-9]*)(\.[0-9]+)?([eE][+-]?[0-9]+)?")
+_TRUE: Final = "true"
+_FALSE: Final = "false"
+_PLACEHOLDER: Final = re.compile(r"\{([^{}]+)\}")
+# `encodeURIComponent` keeps the unreserved set and `!*'()`.
+_COMPONENT_SAFE: Final = "-_.!~*'()"
+# RFC 3986's query characters beside the alphanumerics: what a kept query pair may hold unescaped in a `Link` target.
+_QUERY_SAFE: Final = frozenset(b"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-._~!$&'()*+,;=:@/?")
+_PATH_SAFE: Final = frozenset(b"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-._~/")
+_HEX_DIGITS: Final = frozenset(b"0123456789abcdefABCDEF")
+_PERCENT: Final = ord("%")
+# The raw query is text read from its bytes one to one (`RawTarget`), so a pair goes back to its bytes the same way.
+_BYTES_AS_TEXT: Final = "latin-1"
+# `Number#toString` writes plain digits while the decimal point sits at most 21 digits right and 6 zeros left.
+_DECIMAL_DIGITS_MAX: Final = 21
+_DECIMAL_ZEROS_MIN: Final = -6
+_BOOLEAN: Final = (bool,)
+_SCALAR_TYPES: Final = {"integer": (int,), "number": (int, float), "boolean": _BOOLEAN, "string": (str,)}
+
+
+def scalar_issue(type_use: IrMap, value: object) -> str | None:
+    """The rule a scalar breaks among its type, its `uuid` format and its length bounds, the check a scope id, a
+    subject id and a rule's proof get before any hook reads them; None for a use of any other kind, which step 6 checks
+    in full."""
+    expected = _SCALAR_TYPES.get(ir_string(type_use, "type") or "")
+
+    if expected is None:
+        return None
+
+    if isinstance(value, bool) and expected is not _BOOLEAN:
+        return "type"
+
+    if not isinstance(value, expected):
+        return "type"
+
+    if not isinstance(value, str):
+        return None
+
+    if ir_string(type_use, "format") == "uuid" and not UUID_TEXT.fullmatch(value):
+        return "format"
+
+    refinements = ir_map(type_use, "refinements")
+    min_length = ir_int(refinements, "minLength")
+    max_length = ir_int(refinements, "maxLength")
+
+    if min_length is not None and len(value) < min_length:
+        return "minLength"
+
+    if max_length is not None and len(value) > max_length:
+        return "maxLength"
+
+    return None
+
+
+def decoded_segment(raw: str) -> str | None:
+    """A raw path segment percent-decoded, or None when its bytes are not UTF-8."""
+    try:
+        return unquote_to_bytes(raw).decode("utf-8")
+    except UnicodeDecodeError:
+        return None
+
+
+def path_value(raw: str, type_use: object) -> object:
+    decoded = decoded_segment(raw)
+
+    return raw if decoded is None else scalar(decoded, type_use)
+
+
+def scalar(text: str, type_use: object) -> object:
+    """The text of a parameter read as its scalar type names it, else the text itself."""
+    scalar_type = ir_string(type_use, "type") if ir_string(type_use, "kind") == "scalar" else None
+
+    if scalar_type == "integer" and _INTEGER.fullmatch(text):
+        return int(text)
+
+    if scalar_type == "number" and _NUMBER.fullmatch(text):
+        return int(text) if _INTEGER.fullmatch(text) else float(text)
+
+    if scalar_type == "boolean" and text in (_TRUE, _FALSE):
+        return text == _TRUE
+
+    return text
+
+
+def raw_query(raw: str) -> dict[str, list[str]]:
+    """Each query member by its form-decoded name, with all its raw values in order as received."""
+    members: dict[str, list[str]] = {}
+
+    for pair in raw.split("&"):
+        if pair == "":
+            continue
+
+        name, _, value = pair.partition("=")
+        members.setdefault(_form_decoded(name), []).append(value)
+
+    return members
+
+
+def list_items(values: Sequence[str], wire: object) -> list[str]:
+    """A parameter's values form-decoded; a list written with `explode: false` is one comma-separated value, split
+    on raw commas only, so an encoded `%2C` stays data within one item."""
+    unexploded = ir_string(wire, "kind") == "list" and isinstance(wire, Mapping) and wire.get("explode") is False
+    items: list[str] = []
+
+    for value in values:
+        items.extend(_form_decoded(item) for item in (value.split(",") if unexploded else [value]))
+
+    return items
+
+
+def query_value(values: Sequence[str], type_use: object) -> object:
+    """An array parameter takes every value, a scalar one its only value; several values for a scalar stay a list,
+    which the type rule refuses."""
+    if ir_string(type_use, "kind") == "array":
+        items = ir_map(type_use, "items")
+        return [scalar(value, items) for value in values]
+
+    return scalar(values[0], type_use) if len(values) == 1 else list(values)
+
+
+def _form_decoded(text: str) -> str:
+    """`+` is a space; bytes that are not UTF-8 keep the text as received, so the type rule reports it."""
+    try:
+        return unquote_plus(text, encoding="utf-8", errors="strict")
+    except UnicodeDecodeError:
+        return text
+
+
+def contract_path(template: str, values: Mapping[str, object]) -> str:
+    """The contract path `template` with each `{wire name}` replaced by its value encoded as one segment, as the
+    generated route helpers build a path.
+
+    Raises `ValueError` for a value that cannot be one segment."""
+    return _PLACEHOLDER.sub(
+        lambda placeholder: path_segment(placeholder.group(1), values[placeholder.group(1)]), template
+    )
+
+
+def path_segment(name: str, value: object) -> str:
+    """A path value as one segment, as the generated clients send it: its wire text, encoded as JavaScript's
+    `encodeURIComponent` writes it.
+
+    Raises `ValueError` for an empty, `.` or `..` text, which a URL parser reads as another route, or a value with no
+    wire text."""
+    text = _wire_text(name, value)
+
+    if text in ("", ".", ".."):
+        raise ValueError(
+            f"The path parameter '{name}' must be one non-empty segment, not '{text}': it would reach another route."
+        )
+
+    return component_encoded(text)
+
+
+def component_encoded(text: str) -> str:
+    """`text` as JavaScript's `encodeURIComponent` writes it: every UTF-8 byte outside the unreserved set and `!*'()`
+    percent-encoded."""
+    return quote(text, safe=_COMPONENT_SAFE)
+
+
+def kept_query_pairs(raw: str, names: Sequence[str]) -> list[str]:
+    """The raw query's pairs whose form-decoded name is not one of `names`, in order, each made link safe."""
+    return [
+        link_safe(pair) for pair in raw.split("&") if pair != "" and _form_decoded(pair.partition("=")[0]) not in names
+    ]
+
+
+def link_safe(pair: str) -> str:
+    """Bytes outside the RFC 3986 query set, and a `%` that starts no escape, percent-encoded, so a raw `>` or `"` the
+    server accepted cannot break a `Link` target built from the pair."""
+    return _escaped_outside(pair, _QUERY_SAFE)
+
+
+def path_link_safe(request_path: str) -> str:
+    """The request path with every byte but the unreserved ones and `/` percent-encoded, valid escapes kept, so a
+    segment the server accepted adds no relation to a `Link` header or an absolute link built from it."""
+    return _escaped_outside(request_path, _PATH_SAFE)
+
+
+def _escaped_outside(text: str, safe_bytes: frozenset[int]) -> str:
+    data = text.encode(_BYTES_AS_TEXT, errors="strict")
+    safe: list[str] = []
+
+    for index, byte in enumerate(data):
+        starts_escape = byte == _PERCENT and _is_escape(data, index)
+        kept = starts_escape or (byte != _PERCENT and byte in safe_bytes)
+        safe.append(chr(byte) if kept else f"%{byte:02X}")
+
+    return "".join(safe)
+
+
+def _is_escape(data: bytes, index: int) -> bool:
+    return index + 2 < len(data) and data[index + 1] in _HEX_DIGITS and data[index + 2] in _HEX_DIGITS
+
+
+def scalar_text(value: object) -> str | None:
+    """A scalar's wire text as JavaScript's `String(value)` writes it, so every target writes the same text; None for
+    an object, an array or a number that is not finite."""
+    if isinstance(value, bool):
+        return _TRUE if value else _FALSE
+
+    if isinstance(value, float):
+        return _javascript_number(value) if math.isfinite(value) else None
+
+    wire = scalar_to_wire(value)
+
+    return str(wire) if isinstance(wire, str | int) else None
+
+
+def _wire_text(name: str, value: object) -> str:
+    if isinstance(value, float) and not math.isfinite(value):
+        raise ValueError(f"The path parameter '{name}' must be a finite number, not {value}.")
+
+    text = scalar_text(value)
+
+    if text is None:
+        raise ValueError(f"The path parameter '{name}' has no wire text: {type(value).__qualname__}.")
+
+    return text
+
+
+def _javascript_number(value: float) -> str:
+    """The text JavaScript's `String(value)` writes of a finite number: plain digits from 1e-7 up to 1e21, an exponent
+    outside."""
+    if value == 0:
+        return "0"
+
+    _sign, digit_tuple, exponent = Decimal(repr(abs(value))).normalize().as_tuple()
+    digits = "".join(str(digit) for digit in digit_tuple)
+    point = len(digits) + int(exponent)
+    prefix = "-" if value < 0 else ""
+
+    if len(digits) <= point <= _DECIMAL_DIGITS_MAX:
+        return prefix + digits + "0" * (point - len(digits))
+
+    if 0 < point <= _DECIMAL_DIGITS_MAX:
+        return prefix + digits[:point] + "." + digits[point:]
+
+    if _DECIMAL_ZEROS_MIN < point <= 0:
+        return prefix + "0." + "0" * -point + digits
+
+    mantissa = digits[0] + ("." + digits[1:] if len(digits) > 1 else "")
+
+    return f"{prefix}{mantissa}e{'+' if point > 0 else '-'}{abs(point - 1)}"

seampact/codegen/source_lines.py

@@ -0,0 +1,35 @@
+"""Lines of generated Python that ruff formats as written: the package-relative imports, which ruff sorts after the
+seampact ones, one blank line before the first statement and two before a class or function."""
+
+from collections.abc import Sequence
+from typing import Final
+
+from seampact.codegen.printer import INDENT, fits
+
+_DEFINITIONS: Final = ("class ", "def ", "async def ", "@")
+OPERATIONS_MODULE: Final = "operations"
+
+
+def with_local_imports(modules: Sequence[str], names: Sequence[str], first_block: Sequence[str]) -> list[str]:
+    """The first block of a module, preceded by `from . import <module> as _<module>` for each sibling module and
+    `from .operations import <names>` for names of the package's operations module, sorted as ruff sorts them."""
+    imports = [f"from . import {module} as _{module}" for module in sorted(modules)]
+    ordered = sorted(set(names), key=_member_order)
+    single = f"from .{OPERATIONS_MODULE} import {', '.join(ordered)}"
+
+    if ordered and fits(single):
+        imports.append(single)
+    elif ordered:
+        imports += [f"from .{OPERATIONS_MODULE} import (", *(f"{INDENT}{name}," for name in ordered), ")"]
+
+    separator = ["", ""] if first_block and first_block[0].startswith(_DEFINITIONS) else [""]
+
+    return [*imports, *separator, *first_block]
+
+
+def _member_order(name: str) -> tuple[int, str]:
+    """ruff's `order-by-type`: constants, then classes, then the rest; modules are lower case."""
+    if name.isupper():
+        return (0, name)
+
+    return (1, name) if name[:1].isupper() else (2, name)

seampact_codegen-1.0.0.dist-info/METADATA

@@ -0,0 +1,18 @@
+Metadata-Version: 2.5
+Name: seampact-codegen
+Version: 1.0.0
+Summary: The neutral code generation of the seampact Python targets and the framework-free runtime of generated code.
+License-Expression: MIT
+License-File: LICENSE
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Typing :: Typed
+Requires-Python: >=3.12
+Requires-Dist: seampact-hooks==1.0.0
+Provides-Extra: generate
+Requires-Dist: seampact-ir==1.0.0; extra == 'generate'
+Provides-Extra: pydantic
+Requires-Dist: pydantic<3,>=2.9; extra == 'pydantic'
+Description-Content-Type: text/markdown
+
+The neutral code generation plan and Pydantic emitter of the Python targets, and the framework-free runtime their generated code imports.

seampact_codegen-1.0.0.dist-info/RECORD

@@ -0,0 +1,76 @@
+seampact/codegen/__init__.py,sha256=2mu3bKeEzNhyx8_K77J87SITftXRq7E1rq5GUgODwaY,228
+seampact/codegen/boot_check_hooks.py,sha256=AAu6AGEHhAzj5f-7May3hILcjahU95ygpLbXc8mICac,1262
+seampact/codegen/contract_module.py,sha256=L795efHj-JfH3f2YR2m7IBZwLC1-En77B_VaVyd8wLo,6077
+seampact/codegen/credentials_classes.py,sha256=eF_yJ7Pw5Wz3JS9cFXu2UgAncB4SLjKhNAmVmrtv6VI,4213
+seampact/codegen/handler_forms.py,sha256=w3NsBSepz8-qw2S23d5oMPGSC6kJ9xELF8AH1WSaPTQ,4723
+seampact/codegen/input_schemas.py,sha256=JlOrYFp-7pQKZ2FFuVGoM4TVi3RNSJLEuGRd7xNKz2s,4621
+seampact/codegen/kept_forms.py,sha256=ssg8qy0QqGCBTvdhU15fE0w9-oOtNxgk4L9JkC75w5E,22186
+seampact/codegen/matrix_row.py,sha256=T0S8f3JyeCaJvyoUoHTDdkHw6AMBkZbmnaAnQ9-rg9g,991
+seampact/codegen/names.py,sha256=Oc7FWQLK9W5YQRGAX-Ddl38RP-n3EwZ13DY1SOOXqXo,6084
+seampact/codegen/native_docs_file.py,sha256=llDo1G5qs9lHkykaC2RPbAn7rMPnAErjKfrlMsUW_b8,6900
+seampact/codegen/operation_types.py,sha256=uE2mtYpwNwd8qwuld2Wk0qM9flu-vyZ2Gn4nrUTiLOc,17149
+seampact/codegen/placement_lines.py,sha256=ZHDrcOdqX5HVTKl5TC5Xe32xQHBW0jakMykppSvDwmA,3130
+seampact/codegen/printer.py,sha256=Q-agn08z_dHz1vFHYqp27WWJQRBJ4KfUc4k4H8itNx4,7116
+seampact/codegen/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+seampact/codegen/pydantic_forms.py,sha256=nbDQEDfTFTfI2sk9R2WHHwGxDr8kBxzaTiuzbEa-eTE,2377
+seampact/codegen/pydantic_layout.py,sha256=iV_JBHD4RfU0CDBhQ8KqzwhMZfkSMc35NgzwljZpGuI,6904
+seampact/codegen/pydantic_models.py,sha256=AnPgzoNm2ZuxFD7tmtGA94P7Kf2Hs6_aNPWzly8iWvU,16331
+seampact/codegen/redacted_members.py,sha256=LlnJ-B1vRmhWf6t-tmMsdNX_evDFXokjfIgmtvtUYWg,1873
+seampact/codegen/refusals.py,sha256=Wc9n3u4YAxETZfrOIfPt8N2DV2hBp1KZBOwVMB2M_9w,3450
+seampact/codegen/request_deadline.py,sha256=pGQtpKoeIyaJfa7nCZ84dFVAOnE6rZbbn02LztWJCbM,2677
+seampact/codegen/response_header_forms.py,sha256=ZFtgaK1M3df_SZyxyilwvY2ZI3MzmDkZ7LIhU-WbTNs,3213
+seampact/codegen/restricted_sort_keys.py,sha256=MJUV055aE442MxiQ6nsTzNIz4qrmEWZe29nUQYgAJMM,746
+seampact/codegen/route_helpers.py,sha256=aExfo5Ig3JlXZ6r3mKNzuYXlJ5j1_P8OIrV5LjTQ3vo,4675
+seampact/codegen/routes.py,sha256=8LQomkDOp_enNvFivzX2w62Unk4-4BU3r2EkO-2-VJ4,5006
+seampact/codegen/source_lines.py,sha256=xLrhARNjoVaPoLyIbX0MTSfLtfmEjxA3qvkp0KsxXTY,1565
+seampact/codegen/runtime/__init__.py,sha256=A6lh9ZgdhKXBi-K4cwURJ6bIcciOJNcHFRtE2llcUr8,437
+seampact/codegen/runtime/access_kinds.py,sha256=RV4LKI_Bfj3nQL-FrzVcSDQtzIKJWH1sm_OczP4PPbI,1101
+seampact/codegen/runtime/access_steps.py,sha256=YkXtdSPNJDBIEvnDx6YSCxJF37sUYKklncqX8u5qr_4,20754
+seampact/codegen/runtime/body_reader.py,sha256=hKdFyUZQ9HQREORHvQeJIkPtSfkrvcS84Hv1gi-qjus,2442
+seampact/codegen/runtime/cache_headers.py,sha256=L26z4tpBIHVNxFoWYdhGEugbRkcgcYji7HAXOg3EDcA,3257
+seampact/codegen/runtime/contract.py,sha256=MR4dYzOWsVfc2IpDoqFC7OKMNkHi5ux8B52QhBmkCOk,11104
+seampact/codegen/runtime/cors_preflight.py,sha256=tUQIGr0yKJIx5_uRp6SNB0fKiVvW9TTzJPeH11AgxrM,809
+seampact/codegen/runtime/deadline.py,sha256=sB6zzouRGFCiS3BQKKO4aWhfnNCv7DeZHxeDgSXH4D4,3002
+seampact/codegen/runtime/digests.py,sha256=lw6wcesv5Oj595ZAbCN0wO9kl08zG8X_hdD3sDxntj0,3694
+seampact/codegen/runtime/failures.py,sha256=_00KuIjxhXg-yanuMYG4hcRmuUfhDRv99G9Vev4yovk,1479
+seampact/codegen/runtime/field_rights.py,sha256=pmFG19ZvJq8jH0E5DrKv5SXywG_FKaU-4gdk7KDIrTI,7570
+seampact/codegen/runtime/framework_routes.py,sha256=1_ZFqoKvZWXRr5TPXwGBp6P1dngUj4uJ-GoXoxlgHHg,1393
+seampact/codegen/runtime/framework_versions.py,sha256=5Szre-JtK-rI5IcL5CF5ACQFnj0QtrtLoN74HSazTpo,3504
+seampact/codegen/runtime/handler_call.py,sha256=Sv1STll1lGUJXq6D3pXw4Efpj1id6gWtskw_IyjW0H4,1408
+seampact/codegen/runtime/handler_reply.py,sha256=RL0J9kTYpb_0kvP4TJQmcgW4oAAZdjG9THhj3uk7jHM,6842
+seampact/codegen/runtime/hinted_values.py,sha256=UqkVIudACNMp9ehG0vY40Z13WAAIGIP6GI7a1J950Hs,1875
+seampact/codegen/runtime/hook_check.py,sha256=OdLycQIMNeAop_bYUuIXX3MIw7EazRS6EoHvLygVplc,2754
+seampact/codegen/runtime/idempotency.py,sha256=f0prdZC4RyCL4dHWS5nk-cTlCuqh4cwf1fz4eZwD73Q,11651
+seampact/codegen/runtime/input_decoding.py,sha256=COXqqLvV9xyAGQRICB-Q5PWjB79h613U544fbg-TyMw,8236
+seampact/codegen/runtime/ir_view.py,sha256=uf1NXSkBssUiVyXvIotp-yEU67CfVxXgisMHzpitm5Q,1666
+seampact/codegen/runtime/native_docs.py,sha256=tce0NSXrpXpjTgeMWhe7Xu2SIqkRnlwY-VLmVSrl96I,4889
+seampact/codegen/runtime/page_facts.py,sha256=EUdFL7SwY7F1pDP_e2ZXcG5VxR2ybyjJ9NMMIBEBZPQ,1444
+seampact/codegen/runtime/page_reply.py,sha256=96sCe8PGUhHsSlQk5ax28dfcGDVclWHsesXc2fVCVH0,15250
+seampact/codegen/runtime/pattern.py,sha256=k8SAv6fgzK9vpfcgxEr3HGJmY5gWCkviYQkH6BalLDo,2279
+seampact/codegen/runtime/principal_members.py,sha256=rp1YOJOm87xyMRLMs9vQfOrEYStt8YN8S1I-rUKtU5M,1947
+seampact/codegen/runtime/public_origin.py,sha256=tyPV6uEHN9xnhaXG7pUEFzKFBegQsCXFcXt0i60Kmyo,3925
+seampact/codegen/runtime/raw_target.py,sha256=Ph6-ksb14qA9EgBTqCv260CLjhoBm4AtEbpbaZW3310,3699
+seampact/codegen/runtime/replies.py,sha256=czlcIvR9l3hep6KeUm6E81EDomXpo4v74oiTxM1GTU4,5743
+seampact/codegen/runtime/reply_verdict.py,sha256=H6vMAeydO1f4W75_9Ore1LZUHcpCHJfruaeqk6IrYgw,7428
+seampact/codegen/runtime/requirement_params.py,sha256=VthIFeHGgSYmfBkBfcbmAQdiDG_BUHU62qdkF1NHwF8,7514
+seampact/codegen/runtime/response_header_entries.py,sha256=9LZu5RhnTrHnioq9dzpdXK-ZuumueNfbYbihsXwQ9N0,7803
+seampact/codegen/runtime/response_headers.py,sha256=C3cE3QAgO6_vnppaegp1kOQyyJHfz_w6qpvIiTo2DbA,5465
+seampact/codegen/runtime/route_match.py,sha256=-T8ul7EW0H_YZuSnyp5A5AKwugfd-MWxJvJ_ipr8UCM,3128
+seampact/codegen/runtime/run_settings.py,sha256=EMQgl0Ru9idKO0zCYlAufhrTRHukMC-XSqRgof95EAQ,1263
+seampact/codegen/runtime/signature_header.py,sha256=38Zh-vZJbiefA7FrGq23l_HmudcyhEhXSTfJgDK0lsg,2980
+seampact/codegen/runtime/sync_driver.py,sha256=oPVMo7vUAuPTGmr50hMrhWRxFdRs3MP65ExfiuB2YWk,1366
+seampact/codegen/runtime/templates.py,sha256=5PbFqSZhGK2LzoiJeZUSEBbJjuZSc1AX8hjnqQOIj5o,4062
+seampact/codegen/runtime/uuid_text.py,sha256=uC7kmx6B_LRA35xQ241vvjKvfvY7x8GYFAEXJfqkPEE,327
+seampact/codegen/runtime/value_rules.py,sha256=MDY3umSM9ZYfgRvIbYoO3KEwVr1bzp04N8HwSkU1f1E,8292
+seampact/codegen/runtime/version.py,sha256=E4sGeqn4loulZ_8BpjcCCXTmC9TQU_HoE4pXjxFPjOU,2491
+seampact/codegen/runtime/version_token.py,sha256=R1_Apddd4EB6IO8fwbYktMTyWY2Lgna53WIrnxIL9n4,5050
+seampact/codegen/runtime/wire_codec.py,sha256=ImIpQ60MFL5LUcLdYYr-qn27orO2aFE-Mp4iqHqP2pM,9215
+seampact/codegen/runtime/wire_values.py,sha256=OSSei111cbLTVCdz5a1zV0RNaeQ1YBrROuBbsQ8PeaQ,10177
+seampact/codegen/runtime/pydantic/__init__.py,sha256=JPg2u9lS-GibWiKyfO78PKszSLZxPq8CzbN23mV5aHM,6039
+seampact/codegen/runtime/pydantic/checked_input.py,sha256=qHlkV7VD6EcZH2IrDT6RWCev6kx4TraPhvJMZYpJecQ,2377
+seampact/codegen/runtime/pydantic/contract_input.py,sha256=GPOkU5sQCUw_-vFUZFoX7w-83Fz1Bihi0H2MZH5jkjc,8431
+seampact/codegen/runtime/pydantic/issues.py,sha256=rWCnYrwtAHQAwVnItDm_FNXrayhQTquifsOpvJ2MKu0,5295
+seampact_codegen-1.0.0.dist-info/METADATA,sha256=P0MWFggtZ72Jebo7xlDG6M6n6PvE3-riesdsZ49ycgo,754
+seampact_codegen-1.0.0.dist-info/WHEEL,sha256=2iZrJkDIkeDh0k9SikKMqFuRP-ua6mb4Ir1AsER4BEw,87
+seampact_codegen-1.0.0.dist-info/licenses/LICENSE,sha256=5ZUBhQlzdoQ7CzKtydHCW5CGsxG5ucoOu1lKo7k3RrY,1070
+seampact_codegen-1.0.0.dist-info/RECORD,,

seampact_codegen-1.0.0.dist-info/WHEEL

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

seampact_codegen-1.0.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Julien Metral
+
+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.