GitHub

AlreadyProcessingMessage

API reference for AlreadyProcessingMessage.

The entity is already processing the message with this id.

Attributes

AttributeTypeDescription
envelope_idSnowflake = S.field(SnowflakeFromString, key='envelopeId')
addressEntityAddress

Functions

fields

fields() -> Mapping[str, Bottom[object, object, Never, Never]]

Each field's schema, the tag's first in a tagged class.

Returns Mapping[str, Bottom[object, object, Never, Never]]

@classmethod
def fields(cls) -> Mapping[str, Bottom[object, object, Never, Never]]:
    """Each field's schema, the tag's first in a tagged class."""
    shape = _shape_of(cls)
    schemas = shape.schemas
    if shape.tag is None:
        return dict(schemas)
    tag: Bottom[object, object, Never, Never] = Bottom(ast.Literal(shape.tag))
    return {"_tag": tag, **schemas}

make

make(input, **options) -> Self

input checked against the class's schema (its checks included); raises SchemaError. Construct with cls(...); an instance is kept as it is.

ParameterTypeDescription
inputSelf
optionsUnpack[ParseOptions] = {}

Returns Self

@classmethod
def make(cls, input: Self, /, **options: Unpack[ParseOptions]) -> Self:
    """``input`` checked against the class's schema (its checks
    included); raises ``SchemaError``. Construct with ``cls(...)``; an
    instance is kept as it is."""
    shape = _shape_of(cls)
    return make_class_sync(
        cls.ast.to_type(),
        input,
        options,
        lambda fields: cast("Self", shape.construct(dict(fields))),
    )

make_option

make_option(input, **options) -> Option[Self]
ParameterTypeDescription
inputSelf
optionsUnpack[ParseOptions] = {}

Returns Option[Self]

@classmethod
def make_option(cls, input: Self, /, **options: Unpack[ParseOptions]) -> Option[Self]:
    return cls.__codec__().make_option(input, **options)

make_effect

make_effect(input, **options) -> Effect[Self, Issue]
ParameterTypeDescription
inputSelf
optionsUnpack[ParseOptions] = {}

Returns Effect[Self, Issue]

@classmethod
def make_effect(cls, input: Self, /, **options: Unpack[ParseOptions]) -> Effect[Self, Issue]:
    return cls.__codec__().make_effect(input, **options)

annotate

annotate(**annotations) -> Bottom[Self, Mapping[str, object]]

The class's schema with annotations (a new schema, not a class).

ParameterTypeDescription
annotationsobject = {}

Returns Bottom[Self, Mapping[str, object]]

@classmethod
def annotate(cls, /, **annotations: object) -> Bottom[Self, Mapping[str, object]]:
    """The class's schema with annotations (a new schema, not a class)."""
    return cls.__codec__().annotate(**annotations)

check

check(first, *rest) -> Bottom[Self, Mapping[str, object]]

The class's schema with checks (a new schema, not a class).

ParameterTypeDescription
firstCheck[Self]
restCheck[Self] = ()

Returns Bottom[Self, Mapping[str, object]]

@classmethod
def check(cls, first: Check[Self], /, *rest: Check[Self]) -> Bottom[Self, Mapping[str, object]]:
    """The class's schema with checks (a new schema, not a class)."""
    return cls.__codec__().check(first, *rest)

pipe

pipe[B](f) -> B
ParameterTypeDescription
fCallable[[type[Self]], B]

Returns B

@classmethod
def pipe[B](cls, f: Callable[[type[Self]], B], /) -> B:
    return f(cls)