context

Explicit registry context binding every extension point of one conversion.

A conversion resolves parsers, operator classes, transforms and option classes through a RegistryContext rather than module-level globals, so callers can extend or replace built-ins per conversion without cross-test leakage.

Machine-readable model

RegistryBundleclassThe five registries a conversion dispatches through.
RegistryContextclassMutable view over a RegistryBundle with a freeze latch.
build_default_registry_contextfunctionBuild an isolated set of built-ins, apply customizers, then optionally freeze.

RegistryBundle(
    litert_model_hooks: Registry[str, LiteRtModelHook],
    litert_parsers: Registry[AirOpType | str, OpParserFn],
    aot_operator_classes: Registry[AirOpType | str, type[AotOperator]],
    transforms: Registry[str, type[AirTransform]],
    air_options: Registry[AirOpType | str, type[AirOperatorOptions]],
) -> None

dataclass

The five registries a conversion dispatches through.

litert_model_hooks: Registry[str, LiteRtModelHook]

Model-level hooks run while loading a LiteRT model.

litert_parsers: Registry[AirOpType | str, OpParserFn]

LiteRT operator parsers, keyed by canonical op key.

aot_operator_classes: Registry[AirOpType | str, type[AotOperator]]

AOT operator classes, keyed by canonical op key.

transforms: Registry[str, type[AirTransform]]

AIR transform classes, keyed by transform name.

air_options: Registry[AirOpType | str, type[AirOperatorOptions]]

AIR operator option classes, keyed by canonical op key.

RegistryContext(bundle: RegistryBundle)

Mutable view over a RegistryBundle with a freeze latch.

Exposes each registry as an attribute and freezes or unfreezes them together, so a context handed to a conversion cannot be mutated once the built-ins and any customizers have been registered.

bundle = bundle

litert_model_hooks = bundle.litert_model_hooks

litert_parsers = bundle.litert_parsers

aot_operator_classes = bundle.aot_operator_classes

transforms = bundle.transforms

air_options = bundle.air_options

freeze() -> None

unfreeze() -> None

build_default_registry_context(
    *,
    customizers: list[Callable[[RegistryContext], None]] | None = None,
    allow_override: bool = False,
    freeze: bool = True,
) -> RegistryContext

Build an isolated set of built-ins, apply customizers, then optionally freeze.

Parameters

Parameters of build_default_registry_context
Name	Type	Default	Description
`customizers`	`list[Callable[[RegistryContext], None]] \| None`	None	Functions receiving the mutable context after built-ins are registered. Use the same canonical key for a custom parser, AIR operation and AOT operator class.
`allow_override`	`bool`	False	Permit customizers to replace or remove built-in entries. The default rejects either change while allowing new keys.
`freeze`	`bool`	True	Freeze all registries after customization so conversion cannot accidentally mutate registration. Defaults to true.

Returns

Returns of build_default_registry_context
Type	Description
`RegistryContext`	A fresh context; registrations are not shared with other conversions.

Raises

Errors raised by build_default_registry_context
Type	Description
`RuntimeError`	A customizer replaces or removes a built-in while ``allow_override`` is false. Exceptions from customizers propagate.