A toolkit for variants, whose default_variant is the schema
of its classes. Make one with make.
Attributes#
| Attribute | Type | Description |
|---|---|---|
variants | tuple[str, ...] | |
default_variant | str | |
Class | type[VariantClass] = field(init=False) |
Functions#
__init__#
__init__(variants, default_variant) -> None| Parameter | Type | Description |
|---|---|---|
variants | tuple[str, ...] | |
default_variant | str |
Struct#
Struct(fields) -> VariantStructField definitions (Effect's Struct); None leaves a key out.
| Parameter | Type | Description |
|---|---|---|
fields | Mapping[str, Definition | None] |
Returns VariantStruct
def Struct(self, fields: Mapping[str, Definition | None], /) -> VariantStruct:
"""Field definitions (Effect's ``Struct``); ``None`` leaves a key out."""
for value in fields.values():
if isinstance(value, VariantField):
self._known(list(value.schemas))
return VariantStruct(fields)Field#
Field(**schemas) -> VariantField[Any]A field's schema per variant; None or a missing variant
leaves it out of that variant.
| Parameter | Type | Description |
|---|---|---|
schemas | AnyCodec | None = {} |
Returns VariantField[Any]
def Field(self, **schemas: AnyCodec | None) -> VariantField[Any]:
"""A field's schema per variant; ``None`` or a missing variant
leaves it out of that variant."""
self._known(list(schemas))
return VariantField({k: v for k, v in schemas.items() if v is not None})field_only#
field_only(keys) -> FieldOnlyA field in the keys variants only (Effect's FieldOnly).
| Parameter | Type | Description |
|---|---|---|
keys | Sequence[str] |
Returns FieldOnly
def field_only(self, keys: Sequence[str], /) -> FieldOnly:
"""A field in the ``keys`` variants only (Effect's ``FieldOnly``)."""
return FieldOnly(self._known(keys))field_except#
field_except(keys) -> FieldOnlyA field in every variant but keys (Effect's FieldExcept).
| Parameter | Type | Description |
|---|---|---|
keys | Sequence[str] |
Returns FieldOnly
def field_except(self, keys: Sequence[str], /) -> FieldOnly:
"""A field in every variant but ``keys`` (Effect's ``FieldExcept``)."""
excluded = self._known(keys)
return FieldOnly(tuple(v for v in self.variants if v not in excluded))field_evolve#
field_evolve(mapping: Mapping[str, Callable[[AnyCodec], AnyCodec]], /) -> FieldEvolve
field_evolve(field: VariantField[Any] | AnyCodec, mapping: Mapping[str, Callable[[AnyCodec], AnyCodec]], /) -> VariantField[Any]Each named variant's schema of a field (or of a schema in every
variant) mapped (Effect's fieldEvolve); a variant the field
lacks stays out.
| Parameter | Type | Description |
|---|---|---|
args | = () |
@overload
def field_evolve(
self, mapping: Mapping[str, Callable[[AnyCodec], AnyCodec]], /
) -> FieldEvolve: ...
@overload
def field_evolve(
self,
field: VariantField[Any] | AnyCodec,
mapping: Mapping[str, Callable[[AnyCodec], AnyCodec]],
/,
) -> VariantField[Any]: ...
def field_evolve(self, *args: Any) -> FieldEvolve | VariantField[Any]:
"""Each named variant's schema of a field (or of a schema in every
variant) mapped (Effect's ``fieldEvolve``); a variant the field
lacks stays out."""
if len(args) == 1:
return FieldEvolve(self.variants, self._mapping(args[0]))
return FieldEvolve(self.variants, self._mapping(args[1]))(args[0])Union#
Union(members) -> VariantUnionSchemaThe union of the members' default variants (a class is its own),
with variants holding the union of each variant.
| Parameter | Type | Description |
|---|---|---|
members | Sequence[HasVariants] |
Returns VariantUnionSchema
def Union(self, members: Sequence[HasVariants], /) -> VariantUnionSchema:
"""The union of the members' default variants (a class is its own),
with ``variants`` holding the union of each variant."""
defaults = [
m if is_schema(m) else extract(m, self.default_variant, is_default=True)
for m in members
]
union = SchemaUnion(*defaults)
variants = {v: SchemaUnion(*(extract(m, v) for m in members)) for v in self.variants}
return VariantUnionSchema(union.ast, union.members, variants)extract#
extract(struct, variant) -> Anyvariant's struct schema; the default variant of a class is
the class itself.
| Parameter | Type | Description |
|---|---|---|
struct | HasVariants | |
variant | str |
Returns Any
def extract(self, struct: HasVariants, variant: str, /) -> Any:
"""``variant``'s struct schema; the default variant of a class is
the class itself."""
self._known([variant])
return extract(struct, variant, is_default=variant == self.default_variant)