GitHub

VariantSchema

API reference for VariantSchema.

A toolkit for variants, whose default_variant is the schema of its classes. Make one with make.

Attributes

AttributeTypeDescription
variantstuple[str, ...]
default_variantstr
Classtype[VariantClass] = field(init=False)

Functions

__init__

__init__(variants, default_variant) -> None
ParameterTypeDescription
variantstuple[str, ...]
default_variantstr

Struct

Struct(fields) -> VariantStruct

Field definitions (Effect's Struct); None leaves a key out.

ParameterTypeDescription
fieldsMapping[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.

ParameterTypeDescription
schemasAnyCodec | 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) -> FieldOnly

A field in the keys variants only (Effect's FieldOnly).

ParameterTypeDescription
keysSequence[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) -> FieldOnly

A field in every variant but keys (Effect's FieldExcept).

ParameterTypeDescription
keysSequence[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.

ParameterTypeDescription
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) -> VariantUnionSchema

The union of the members' default variants (a class is its own), with variants holding the union of each variant.

ParameterTypeDescription
membersSequence[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) -> Any

variant's struct schema; the default variant of a class is the class itself.

ParameterTypeDescription
structHasVariants
variantstr

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)