Core

Generated from the type stubs and docstrings. Do not edit by hand.

Types

AvroRegistrySerde

Avro serde with Confluent Schema Registry integration.

Wire format: [0x00 magic][schema_id: 4 bytes BE][avro payload]

Schema registration is lazy - happens on first serialize() call. Reader schemas are fetched from the registry on first deserialize() per schema ID and cached in memory for the lifetime of this serde.

TLS/mTLS: pass ca_path to trust a custom CA, or cert_path + key_path for mutual TLS (client certificate authentication). Both cert_path and key_path must be set together. TLS args apply only when registry_url is https://.

Encrypted (password-protected) private keys are not supported - key_path must point to an unencrypted PEM. (No equivalent to confluent’s ssl.key.password.)

Usage: serde = AvroRegistrySerde.for_topic(“http://localhost:8081”, “my-topic”, SCHEMA_JSON) result = serde.serialize({“id”: 1, “name”: “alice”}) # registers + framing

serde2 = AvroRegistrySerde("http://localhost:8081", "my-topic-value", SCHEMA_JSON)

# With custom CA + client cert (mTLS):
serde3 = AvroRegistrySerde(
    "https://registry.example.com", "my-topic-value", SCHEMA_JSON,
    username="user", password="pass",
    ca_path="/path/to/ca.pem",
    cert_path="/path/to/client.pem",
    key_path="/path/to/client-key.pem",
)

for_topic

for_topic(registry_url: str, topic: str, schema: str, is_key: bool = False, username: Optional[str] = None, password: Optional[str] = None, ca_path: Optional[str] = None, cert_path: Optional[str] = None, key_path: Optional[str] = None) -> AvroRegistrySerde

register

register(self) -> Ok[int] | Err[SerdeError]

subject

subject(self) -> str

serialize

serialize(self, obj: Any) -> Ok[bytes] | Err[SerdeError]

deserialize

deserialize(self, data: bytes) -> Ok[Any] | Err[SerdeError]

serialize_many

serialize_many(self, items: Iterable[Any]) -> IList

serialize_many_bytes

serialize_many_bytes(self, items: Iterable[Any]) -> BytesList

deserialize_many

deserialize_many(self, bytes_list: Iterable[bytes] | BytesList) -> IList

deserialize_many_objects

deserialize_many_objects(self, bytes_list: Iterable[bytes] | BytesList) -> IList

deserialize_many_from_packed

deserialize_many_from_packed(self, packed: bytes, count: int) -> IList

check_compatibility

check_compatibility(self, schema: str, version: Optional[str] = None) -> Ok[bool] | Err[SerdeError]

list_versions

list_versions(self) -> Ok[list[int]] | Err[SerdeError]

get_schema_by_version

get_schema_by_version(self, version: int) -> Ok[str] | Err[SerdeError]

delete_version

delete_version(self, version: int) -> Ok[bool] | Err[SerdeError]

---

AvroSerde

serialize

serialize(self, obj: Any) -> Ok[bytes] | Err[SerdeError]

deserialize

deserialize(self, data: bytes) -> Ok[Any] | Err[SerdeError]

serialize_many

serialize_many(self, items: Iterable[Any]) -> IList

serialize_many_bytes

serialize_many_bytes(self, items: Iterable[Any]) -> BytesList

deserialize_many

deserialize_many(self, bytes_list: Iterable[bytes] | BytesList) -> IList

---

BytesList

empty

empty(cls) -> BytesList

from_packed

from_packed(buf: bytes, count: int) -> BytesList

get

get(self, index: int) -> Some[bytes] | _Nothing

append

append(self, item: bytes) -> BytesList

to_list

to_list(self) -> list[bytes]

to_packed

to_packed(self) -> bytes

to_ilist

to_ilist(self) -> IList[bytes]

length

length(self) -> int

is_empty

is_empty(self) -> bool

---

DecodeFailure

A single per-row decode failure - the dead-letter story.

index is the input index; raw is the original payload bytes, ready to route straight to a DLQ without re-serialization.

Fields:

• index: int
• message: str
• raw: bytes

---

DeserializationError

---

Duration

A typed time-span value backed by an i64 nanosecond count.

Mirrors Scala’s FiniteDuration - a precise, immutable quantity of time with unit-converting constructors and full arithmetic support.

nanos

nanos(n: int) -> Duration

micros

micros(n: int) -> Duration

millis

millis(n: int) -> Duration

seconds

seconds(n: float) -> Duration

minutes

minutes(n: float) -> Duration

hours

hours(n: float) -> Duration

days

days(n: float) -> Duration

from_timedelta

from_timedelta(td: Any) -> Duration

to_nanos

to_nanos(self) -> int

to_millis

to_millis(self) -> int

to_seconds

to_seconds(self) -> float

to_timedelta

to_timedelta(self) -> Any

---

Either

A value (Ok) or an error (Err). Subclassed by Ok and Err, the same way Scala’s Either is by Right/Left, so Either[A, E] is a real generic and isinstance(x, Either) holds for both. Abstract: build values through the factories below (or Ok/Err directly), not Either(...).

ok

ok(value: T) -> Ok[T]

err

err(error: E) -> Err[E]

try_of

try_of(f: Callable[[], T]) -> Either[T, Exception]

cond

cond(condition: bool, ok: T, err: E) -> Either[T, E]

sequence

sequence(values: Iterable[Either[T, E]]) -> Either[list[T], E]

map

map(self, f: Callable[..., Any]) -> Either[Any, E]

flat_map

flat_map(self, f: Callable[..., Any]) -> Either[Any, E]

map_err

map_err(self, f: Callable[..., Any]) -> Either[T, Any]

recover

recover(self, f: Callable[[E], Any]) -> Either[Any, Any]

recover_with

recover_with(self, f: Callable[[E], Either[Any, Any]]) -> Either[Any, Any]

or_else

or_else(self, alt: Either[Any, Any] | Callable[[], Either[Any, Any]]) -> Either[Any, Any]

fold

fold(self, err: Callable[..., Any], ok: Callable[..., Any]) -> Any

get_or_else

get_or_else(self, default: Any) -> Any

unwrap_or_raise

unwrap_or_raise(self, exc: Any = None) -> Any

to_option

to_option(self) -> Option[T]

is_ok

is_ok(self) -> bool

is_err

is_err(self) -> bool

---

Err

Fields:

• error: E

map

map(self, f: Callable[..., Any]) -> Err[E]

flat_map

flat_map(self, f: Callable[..., Any]) -> Err[E]

recover

recover(self, f: Callable[[E], Any]) -> Either[Any, Any]

recover_with

recover_with(self, f: Callable[[E], Either[Any, Any]]) -> Either[Any, Any]

map_err

map_err(self, f: Callable[..., Any]) -> Err[Any]

or_else

or_else(self, alt: Either[Any, Any] | Callable[[], Either[Any, Any]]) -> Either[Any, Any]

fold

fold(self, err: Callable[..., Any], ok: Callable[..., Any]) -> Any

get_or_else

get_or_else(self, default: Any) -> Any

unwrap_or_raise

unwrap_or_raise(self, exc: Any = None) -> Any

to_option

to_option(self) -> _Nothing

is_ok

is_ok(self) -> bool

is_err

is_err(self) -> bool

---

Failure

Fields:

• error: BaseException

map

map(self, f: Callable[..., Any]) -> Failure

flat_map

flat_map(self, f: Callable[..., Any]) -> Failure

recover

recover(self, f: Callable[[Any], Any]) -> Try[Any]

recover_with

recover_with(self, f: Callable[[Any], Try[Any]]) -> Try[Any]

or_else

or_else(self, alt: Try[Any] | Callable[[], Try[Any]]) -> Try[Any]

fold

fold(self, failure: Callable[..., Any], success: Callable[..., Any]) -> Any

get_or_else

get_or_else(self, default: Any) -> Any

to_either

to_either(self) -> Err[Any]

is_success

is_success(self) -> bool

is_failure

is_failure(self) -> bool

---

FloatList

empty

empty(cls) -> FloatList

map_float

map_float(self, f: Callable[[float], float]) -> FloatList

filter

filter(self, pred: Callable[[float], bool]) -> FloatList

fold_left

fold_left(self, initial: Any, f: Callable[..., Any]) -> Any

add_scalar

add_scalar(self, n: float) -> FloatList

sub_scalar

sub_scalar(self, n: float) -> FloatList

mul_scalar

mul_scalar(self, n: float) -> FloatList

div_scalar

div_scalar(self, n: float) -> FloatList

abs_vals

abs_vals(self) -> FloatList

clamp_vals

clamp_vals(self, lo: float, hi: float) -> FloatList

zip_add

zip_add(self, other: FloatList) -> FloatList

zip_mul

zip_mul(self, other: FloatList) -> FloatList

sum

sum(self) -> float

min

min(self) -> float

max

max(self) -> float

mean

mean(self) -> float

std_dev

std_dev(self) -> float

to_list

to_list(self) -> list[float]

to_ilist

to_ilist(self) -> IList[float]

length

length(self) -> int

is_empty

is_empty(self) -> bool

---

IList

empty

empty(cls) -> IList[Any]

map

map(self, f: Callable[..., Any]) -> IList[Any]

flat_map

flat_map(self, f: Callable[..., Any]) -> IList[Any]

filter

filter(self, pred: Callable[..., bool]) -> IList[T]

fold_left

fold_left(self, initial: Any, f: Callable[..., Any]) -> Any

head

head(self) -> Some[T] | _Nothing

last

last(self) -> Some[T] | _Nothing

tail

tail(self) -> IList[T]

find

find(self, pred: Callable[..., bool]) -> Some[T] | _Nothing

take

take(self, n: int) -> IList[T]

drop

drop(self, n: int) -> IList[T]

distinct

distinct(self) -> IList[T]

zip

zip(self, other: IList[Any]) -> IList[tuple[T, Any]]

append

append(self, item: T) -> IList[T]

prepend

prepend(self, item: T) -> IList[T]

concat

concat(self, other: IList[T]) -> IList[T]

to_list

to_list(self) -> list[T]

collect_ok

collect_ok(self) -> IList[Any]

collect_err

collect_err(self) -> IList[Any]

partition_either

partition_either(self) -> tuple[IList[Any], IList[Any]]

length

length(self) -> int

is_empty

is_empty(self) -> bool

---

IMap

empty

empty(cls) -> IMap[Any, Any]

get

get(self, key: K) -> Some[V] | _Nothing

set

set(self, key: K, value: V) -> IMap[K, V]

remove

remove(self, key: K) -> IMap[K, V]

contains

contains(self, key: K) -> bool

to_dict

to_dict(self) -> dict

keys

keys(self) -> IList[K]

values

values(self) -> IList[V]

items

items(self) -> IList[tuple[K, V]]

map_values

map_values(self, f: Callable[[V], Any]) -> IMap[K, Any]

filter_values

filter_values(self, pred: Callable[[V], bool]) -> IMap[K, V]

merge

merge(self, other: IMap[K, V]) -> IMap[K, V]

length

length(self) -> int

is_empty

is_empty(self) -> bool

---

ISet

empty

empty(cls) -> ISet[Any]

add

add(self, item: T) -> ISet[T]

remove

remove(self, item: T) -> ISet[T]

contains

contains(self, item: T) -> bool

union

union(self, other: ISet[T]) -> ISet[T]

intersection

intersection(self, other: ISet[T]) -> ISet[T]

difference

difference(self, other: ISet[T]) -> ISet[T]

is_subset_of

is_subset_of(self, other: ISet[T]) -> bool

map

map(self, f: Callable[[T], Any]) -> ISet[Any]

filter

filter(self, pred: Callable[[T], bool]) -> ISet[T]

to_set

to_set(self) -> set[T]

to_ilist

to_ilist(self) -> IList[T]

size

size(self) -> int

is_empty

is_empty(self) -> bool

---

IntList

empty

empty(cls) -> IntList

map_int

map_int(self, f: Callable[[int], int]) -> IntList

filter

filter(self, pred: Callable[[int], bool]) -> IntList

fold_left

fold_left(self, initial: Any, f: Callable[..., Any]) -> Any

add_scalar

add_scalar(self, n: int) -> IntList

sub_scalar

sub_scalar(self, n: int) -> IntList

mul_scalar

mul_scalar(self, n: int) -> IntList

div_scalar

div_scalar(self, n: int) -> IntList

abs_vals

abs_vals(self) -> IntList

clamp_vals

clamp_vals(self, lo: int, hi: int) -> IntList

zip_add

zip_add(self, other: IntList) -> IntList

zip_mul

zip_mul(self, other: IntList) -> IntList

sum

sum(self) -> int

min

min(self) -> int

max

max(self) -> int

mean

mean(self) -> float

std_dev

std_dev(self) -> float

to_list

to_list(self) -> list[int]

to_ilist

to_ilist(self) -> IList[int]

length

length(self) -> int

is_empty

is_empty(self) -> bool

---

IntSet

empty

empty(cls) -> IntSet

add

add(self, value: int) -> IntSet

remove

remove(self, value: int) -> IntSet

contains

contains(self, value: int) -> bool

union

union(self, other: IntSet) -> IntSet

intersection

intersection(self, other: IntSet) -> IntSet

difference

difference(self, other: IntSet) -> IntSet

symmetric_difference

symmetric_difference(self, other: IntSet) -> IntSet

is_subset

is_subset(self, other: IntSet) -> bool

is_disjoint

is_disjoint(self, other: IntSet) -> bool

cardinality

cardinality(self) -> int

to_list

to_list(self) -> list[int]

to_bytes

to_bytes(self) -> bytes

from_bytes

from_bytes(data: bytes) -> IntSet

is_empty

is_empty(self) -> bool

---

Invalid

Fields:

• errors: list[E]

---

JsonSchemaRegistrySerde

JSON Schema serde with Confluent Schema Registry integration.

Wire format: [0x00 magic][schema_id: 4 bytes BE][json payload]

Same magic byte as Avro; content is JSON. NOTE: payloads are NOT validated against the JSON Schema - this serde provides Confluent wire framing ([0x00][schema_id:4B BE][json]) and registry registration only. (confluent’s JSONSerializer validates; pyrula does not yet.)

for_topic

for_topic(registry_url: str, topic: str, schema: str, is_key: bool = False, username: Optional[str] = None, password: Optional[str] = None, ca_path: Optional[str] = None, cert_path: Optional[str] = None, key_path: Optional[str] = None) -> JsonSchemaRegistrySerde

register

register(self) -> Ok[int] | Err[SerdeError]

subject

subject(self) -> str

serialize

serialize(self, obj: Any) -> Ok[bytes] | Err[SerdeError]

deserialize

deserialize(self, data: bytes) -> Ok[Any] | Err[SerdeError]

serialize_many

serialize_many(self, items: Iterable[Any]) -> IList

serialize_many_bytes

serialize_many_bytes(self, items: Iterable[Any]) -> BytesList

deserialize_many

deserialize_many(self, bytes_list: Iterable[bytes] | BytesList) -> IList

deserialize_many_objects

deserialize_many_objects(self, bytes_list: Iterable[bytes] | BytesList) -> IList

deserialize_many_from_packed

deserialize_many_from_packed(self, packed: bytes, count: int) -> IList

check_compatibility

check_compatibility(self, schema: str, version: Optional[str] = None) -> Ok[bool] | Err[SerdeError]

list_versions

list_versions(self) -> Ok[list[int]] | Err[SerdeError]

get_schema_by_version

get_schema_by_version(self, version: int) -> Ok[str] | Err[SerdeError]

delete_version

delete_version(self, version: int) -> Ok[bool] | Err[SerdeError]

---

JsonSerde

serialize

serialize(self, obj: Any) -> Ok[bytes] | Err[SerdeError]

deserialize

deserialize(self, data: bytes) -> Ok[Any] | Err[SerdeError]

serialize_many

serialize_many(self, items: Iterable[Any]) -> IList

serialize_many_raw

serialize_many_raw(self, items: Iterable[Any]) -> BytesList

deserialize_many

deserialize_many(self, bytes_list: Iterable[bytes] | BytesList) -> IList

deserialize_many_raw

deserialize_many_raw(self, bytes_list: Iterable[bytes] | BytesList) -> IList

---

NonEmptyList

A list with at least one element.

head, last, and reduce are total - they return T, not Option[T], because the non-empty invariant is enforced at construction time. from_list is the safe boundary: it returns Option[NonEmptyList[T]].

of

of(head: T, *tail: T) -> NonEmptyList[T]

from_list

from_list(items: IList[T] | list[T]) -> Option[NonEmptyList[T]]

head

head(self) -> T

tail

tail(self) -> IList[T]

last

last(self) -> T

map

map(self, f: Callable[[T], Any]) -> NonEmptyList[Any]

flat_map

flat_map(self, f: Callable[[T], NonEmptyList[Any]]) -> NonEmptyList[Any]

reduce

reduce(self, f: Callable[[T, T], T]) -> T

fold_left

fold_left(self, init: Any, f: Callable[[Any, T], Any]) -> Any

append

append(self, item: T) -> NonEmptyList[T]

prepend

prepend(self, item: T) -> NonEmptyList[T]

to_ilist

to_ilist(self) -> IList[T]

to_list

to_list(self) -> list[T]

length

length(self) -> int

---

Ok

Fields:

• value: T

map

map(self, f: Callable[..., Any]) -> Ok[Any]

flat_map

flat_map(self, f: Callable[..., Any]) -> Any

map_err

map_err(self, f: Callable[..., Any]) -> Ok[T]

recover

recover(self, f: Callable[[Any], Any]) -> Ok[T]

recover_with

recover_with(self, f: Callable[[Any], Either[Any, Any]]) -> Ok[T]

or_else

or_else(self, alt: Either[Any, Any] | Callable[[], Either[Any, Any]]) -> Ok[T]

fold

fold(self, err: Callable[..., Any], ok: Callable[..., Any]) -> Any

get_or_else

get_or_else(self, default: Any) -> T

unwrap_or_raise

unwrap_or_raise(self, exc: Any = None) -> T

to_option

to_option(self) -> Some[T]

is_ok

is_ok(self) -> bool

is_err

is_err(self) -> bool

---

Option

Some(value) or Nothing; subclassed by both like Scala’s Option.

of

of(value: Optional[T]) -> Option[T]

when

when(condition: bool, value: T) -> Option[T]

from_callable

from_callable(f: Callable[[], T]) -> Option[T]

sequence

sequence(values: Iterable[Option[T]]) -> Option[list[T]]

map

map(self, f: Callable[..., Any]) -> Option[Any]

flat_map

flat_map(self, f: Callable[..., Any]) -> Option[Any]

filter

filter(self, pred: Callable[..., bool]) -> Option[T]

get_or_else

get_or_else(self, default: Any) -> Any

or_else

or_else(self, alt: Option[Any] | Callable[[], Option[Any]]) -> Option[Any]

fold

fold(self, nothing_val: Any, some_fn: Callable[..., Any]) -> Any

to_either

to_either(self, left: Any) -> Either[T, Any]

to_list

to_list(self) -> IList[T]

is_some

is_some(self) -> bool

is_nothing

is_nothing(self) -> bool

is_empty

is_empty(self) -> bool

---

ProtobufRegistrySerde

Protobuf serde with Confluent Schema Registry integration.

Wire format: [0x00 magic][schema_id: 4 bytes BE][msg-index zigzag varint array][protobuf payload]

Accepts a serialized FileDescriptorSet and a fully-qualified message name. Deserialization decodes to Python dicts using prost-reflect; no compiled message types needed. Registration requires proto_source (the .proto source text) so the Confluent SR can parse and validate the schema.

LIMITATION: the Confluent message-index is always written as [0] (first message). Only correct when message_name is the first top-level message in the descriptor; multi-message / nested .proto files will not interoperate with Confluent consumers that rely on the message index. (Tracked: K10 follow-up C3a.)

NOTE: proto3 implicit-presence scalar fields at their default (0, "", false) are omitted on deserialize - absent from the returned dict (standard protobuf semantics). Use optional fields if presence must be preserved.

NOTE: enum fields accept the enum value name (str) or number (int) on serialize; deserialize returns the number (int).

for_topic

for_topic(registry_url: str, topic: str, file_descriptor_set: bytes, message_name: str, is_key: bool = False, proto_source: Optional[str] = None, username: Optional[str] = None, password: Optional[str] = None, ca_path: Optional[str] = None, cert_path: Optional[str] = None, key_path: Optional[str] = None) -> ProtobufRegistrySerde

register

register(self) -> Ok[int] | Err[SerdeError]

subject

subject(self) -> str

serialize

serialize(self, obj: Any) -> Ok[bytes] | Err[SerdeError]

serialize_with_id

serialize_with_id(self, obj: Any, schema_id: int) -> Ok[bytes] | Err[SerdeError]

deserialize

deserialize(self, data: bytes) -> Ok[Any] | Err[SerdeError]

serialize_many

serialize_many(self, items: Iterable[Any]) -> IList

serialize_many_bytes

serialize_many_bytes(self, items: Iterable[Any]) -> BytesList

deserialize_many

deserialize_many(self, bytes_list: Iterable[bytes] | BytesList) -> IList

deserialize_many_objects

deserialize_many_objects(self, bytes_list: Iterable[bytes] | BytesList) -> IList

deserialize_many_from_packed

deserialize_many_from_packed(self, packed: bytes, count: int) -> IList

check_compatibility

check_compatibility(self, proto_source: str, version: Optional[str] = None) -> Ok[bool] | Err[SerdeError]

list_versions

list_versions(self) -> Ok[list[int]] | Err[SerdeError]

get_schema_by_version

get_schema_by_version(self, version: int) -> Ok[str] | Err[SerdeError]

delete_version

delete_version(self, version: int) -> Ok[bool] | Err[SerdeError]

---

Record

A lazy view of one row in a :class:RecordList.

Field access materializes exactly one value - attribute for ergonomics (rec.price), subscript for certainty (rec["price"] reaches fields that collide with method names or are non-identifiers). to_instance rebuilds the whole originating object.

to_instance

to_instance(self) -> Any

---

RecordList

Immutable columnar batch of typed records (struct-of-arrays).

Records live in Rust; fields become Python objects only when a callable touches one. Built by RecordSchema.deserialize_many (JSON) or RecordList.from_instances (Python objects).

Fields:

• schema: RecordSchema

from_instances

from_instances(first: Any, second: Any = ...) -> RecordList

concat

concat(lists: Any) -> RecordList

from_arrow

from_arrow(obj: Any, tp: Any = ...) -> RecordList

from_csv

from_csv(data: bytes | str, tp: Any, delimiter: str = ..., quote: str = ..., header: bool | list[str] = ...) -> RecordList

map

map(self, fn: Any) -> Any

filter

filter(self, fn: Any) -> RecordList

fold

fold(self, field_or_fn: Any, monoid: Any) -> Any

serialize_many

serialize_many(self) -> BytesList

column

column(self, name: str) -> Any

to_ilist

to_ilist(self) -> IList[Record]

to_instances

to_instances(self) -> list[Any]

to_scalars

to_scalars(self) -> list[Any]

to_arrow

to_arrow(self, json_as_string: bool = ...) -> ArrowTable

---

RecordSchema

Ordered typed fields for a columnar record batch.

Build from a Python type via schema_for (binds the type for to_instance), or hand-build recursive schemas with of.

Fields:

• fields: list[tuple[str, str, bool]]

of

of(fields: list[tuple]) -> RecordSchema

has_default

has_default(self, name: str) -> bool

deserialize_many

deserialize_many(self, data: Any) -> Ok[RecordList] | Err[DeserializationError]

deserialize_many_partial

deserialize_many_partial(self, data: Any) -> tuple[RecordList, IList[DecodeFailure]]

deserialize_csv_many

deserialize_csv_many(self, lines: Any, delimiter: str = ..., quote: str = ..., header: bool | list[str] = ...) -> Ok[RecordList] | Err[DeserializationError]

deserialize_csv_many_partial

deserialize_csv_many_partial(self, lines: Any, delimiter: str = ..., quote: str = ..., header: bool | list[str] = ...) -> tuple[RecordList, IList[DecodeFailure]]

---

SerdeError

---

SerializationError

---

Some

Fields:

• value: T

map

map(self, f: Callable[..., Any]) -> Some[Any]

flat_map

flat_map(self, f: Callable[..., Any]) -> Any

filter

filter(self, pred: Callable[..., bool]) -> Any

get_or_else

get_or_else(self, default: Any) -> T

or_else

or_else(self, alt: Option[Any] | Callable[[], Option[Any]]) -> Some[T]

fold

fold(self, nothing_val: Any, some_fn: Callable[..., Any]) -> Any

to_either

to_either(self, left: Any) -> Ok[T]

to_list

to_list(self) -> IList[T]

is_some

is_some(self) -> bool

is_nothing

is_nothing(self) -> bool

is_empty

is_empty(self) -> bool

---

Success

Fields:

• value: T

map

map(self, f: Callable[..., Any]) -> Any

flat_map

flat_map(self, f: Callable[..., Any]) -> Any

recover

recover(self, f: Callable[[Any], Any]) -> Success[T]

recover_with

recover_with(self, f: Callable[[Any], Try[Any]]) -> Success[T]

or_else

or_else(self, alt: Try[Any] | Callable[[], Try[Any]]) -> Success[T]

fold

fold(self, failure: Callable[..., Any], success: Callable[..., Any]) -> Any

get_or_else

get_or_else(self, default: Any) -> T

to_either

to_either(self) -> Ok[T]

is_success

is_success(self) -> bool

is_failure

is_failure(self) -> bool

---

Try

Success(value) or Failure(exc); subclassed by both like Scala’s Try.

apply

apply(f: Callable[[], T]) -> Try[T]

of

of(f: Callable[[], T]) -> Try[T]

sequence

sequence(values: Iterable[Try[T]]) -> Try[list[T]]

map

map(self, f: Callable[..., Any]) -> Try[Any]

flat_map

flat_map(self, f: Callable[..., Any]) -> Try[Any]

recover

recover(self, f: Callable[[Any], Any]) -> Try[Any]

recover_with

recover_with(self, f: Callable[[Any], Try[Any]]) -> Try[Any]

or_else

or_else(self, alt: Try[Any] | Callable[[], Try[Any]]) -> Try[Any]

fold

fold(self, failure: Callable[..., Any], success: Callable[..., Any]) -> Any

get_or_else

get_or_else(self, default: Any) -> Any

to_either

to_either(self) -> Either[T, Any]

is_success

is_success(self) -> bool

is_failure

is_failure(self) -> bool

---

Valid

Fields:

• value: T

---

Validated

Like Either, but zip accumulates errors instead of short-circuiting.

valid

valid(value: T) -> Validated[T, E]

invalid

invalid(error: E) -> Validated[T, E]

from_either

from_either(either: Either[T, E]) -> Validated[T, E]

cond

cond(condition: bool, value: T, error: E) -> Validated[T, E]

map

map(self, f: Callable[[T], Any]) -> Validated[Any, E]

map_err

map_err(self, f: Callable[[list[E]], Any]) -> Validated[T, Any]

zip

zip(self, other: Validated[Any, E]) -> Validated[Any, E]

fold

fold(self, invalid: Callable[[list[E]], Any], valid: Callable[[T], Any]) -> Any

get_or_else

get_or_else(self, default: T) -> T

to_either

to_either(self) -> Either[T, list[E]]

is_valid

is_valid(self) -> bool

is_invalid

is_invalid(self) -> bool

Constants

• Nothing: _Nothing = nothing()

Functions

case

case(cls: type[T]) -> type[T]

do

do(func: Callable[..., Any]) -> Callable[..., Any]

do_async

do_async(func: Callable[..., Any]) -> Callable[..., Any]

flow

flow(*funcs: Callable[..., Any]) -> Callable[..., Any]

match

match(value: Any) -> Callable[..., Any]

newtype

newtype(name: str, base_type: type[T]) -> type[T]

newtype_strict

newtype_strict(name: str, base_type: type[T], validate: Optional[Callable[..., bool]] = None, err_msg: Optional[str] = None) -> type[T]

on

on(typ: type[T], handler: Callable[..., Any]) -> Any

partial

partial(f: Callable[..., Any], *args: Any, **kwargs: Any) -> Callable[..., Any]

pipe

pipe(value: Any, *funcs: Callable[..., Any]) -> Any

schema_for

schema_for(tp: type) -> RecordSchema

Derive a :class:RecordSchema from a dataclass, pydantic v2 model, TypedDict, or NamedTuple.

The result is cached per type (schema_for(T) is schema_for(T)) and binds the originating type onto the schema so Record.to_instance can rebuild it.

See the module docstring for the full set of supported/rejected annotation forms; unsupported types raise :class:SchemaResolutionError (a TypeError).

sealed

sealed(cls: type[T]) -> type[T]