Core

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

Types

AvroRegistrySerde

check_compatibility

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

delete_version

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

deserialize

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

Deserialize Confluent wire-format bytes, fetching schema from registry by ID.

deserialize_many

deserialize_many(self, bytes_list: BytesList) -> IList

Deserialize BytesList to IList[Either[DeserializationError, obj]].

deserialize_many_objects

deserialize_many_objects(self, bytes_list: BytesList) -> IList

Deserialize BytesList directly to IList[obj], raising DeserializationError on first failure.

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

Convenience constructor - derives subject as “{topic}-value” or “{topic}-key”.

get_schema_by_version

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

list_versions

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

register

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

Eagerly register this serde’s schema with the registry. Returns Either[SerializationError, int] where int is the assigned schema ID. Not required - serialize() registers lazily on first call.

serialize

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

serialize_many

serialize_many(self, items: IList) -> IList

serialize_many_bytes

serialize_many_bytes(self, items: IList) -> BytesList

Serialize IList directly to BytesList, raising SerializationError on first failure.

subject

subject(self) -> str

---

AvroSerde

deserialize

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

deserialize_many

deserialize_many(self, bytes_list: BytesList) -> IList

serialize

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

serialize_many

serialize_many(self, items: IList) -> IList

serialize_many_bytes

serialize_many_bytes(self, items: IList) -> BytesList

Serialize IList directly to BytesList, raising SerializationError on first failure.

---

BytesList

Immutable list of byte sequences (Vec<Vec<u8>>).

Each element is a bytes object in Python. Supports conversion to IList[bytes] via to_ilist().

append

append(self, item: bytes) -> BytesList

empty

empty() -> BytesList

from_packed

from_packed(buf, count)

Build from one length-framed buffer: count records, each a little-endian u32 length followed by that many bytes. Lets the Kafka consumer hand the whole batch across the extension boundary as a single bytes object - one copy + one parse - instead of allocating a bytes per record and re-extracting each. count lets us pre-size inner.

get

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

is_empty

is_empty(self) -> bool

length

length(self) -> int

to_ilist

to_ilist(self) -> IList[bytes]

to_list

to_list(self) -> list[bytes]

to_packed

to_packed(self) -> bytes

Export as one length-framed bytes object: count * (u32 little-endian length + payload).

---

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.

Examples

from pyrula import Duration

d = Duration.seconds(1) + Duration.millis(500)
assert d.to_millis() == 1500

import datetime
assert Duration.seconds(1).to_timedelta() == datetime.timedelta(seconds=1)

days

days(n: float) -> Duration

Create a Duration from a number of days (fractional days allowed).

from_timedelta

from_timedelta(td: Any) -> Duration

Create a Duration from a Python datetime.timedelta.

hours

hours(n: float) -> Duration

Create a Duration from a number of hours (fractional hours allowed).

micros

micros(n: int) -> Duration

Create a Duration from a microsecond count.

millis

millis(n: int) -> Duration

Create a Duration from a millisecond count.

minutes

minutes(n: float) -> Duration

Create a Duration from a number of minutes (fractional minutes allowed).

nanos

nanos(n: int) -> Duration

Create a Duration from a nanosecond count.

seconds

seconds(n: float) -> Duration

Create a Duration from a number of seconds (fractional seconds allowed).

to_millis

to_millis(self) -> int

Milliseconds, truncating sub-millisecond precision.

to_nanos

to_nanos(self) -> int

The raw nanosecond count.

to_seconds

to_seconds(self) -> float

Seconds as a float.

to_timedelta

to_timedelta(self) -> Any

Convert to a Python datetime.timedelta.

Resolution is microseconds (Python’s timedelta does not support nanosecond precision). Sub-microsecond nanos are truncated.

---

Either

The base of the Either result type: an Ok value or an Err error.

Ok and Err subclass Either, the same way Scala’s Either is subclassed by Right and Left. So isinstance(x, Either) holds for both cases and Either[A, E] is a real generic alias. Either is abstract: construct values through Either.ok / Either.err (or Ok / Err directly), not Either(...).

cond

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

Ok(ok) if condition else Err(err).

err

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

Err(error).

ok

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

Ok(value).

sequence

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

Ok of every value, or the first Err encountered.

try_of

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

Ok(f()), or Err(exc) if f raises an Exception. A BaseException (KeyboardInterrupt, SystemExit) propagates rather than being captured.

---

Err

Fields:

• error: E

flat_map

flat_map(self, _f) -> Err[E]

fold

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

get_or_else

get_or_else(self, default: Any) -> Any

is_err

is_err(self) -> bool

is_ok

is_ok(self) -> bool

map

map(self, _f) -> Err[E]

map_err

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

or_else

or_else(self, default: Any) -> Any

recover

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

to_option

to_option(self) -> _Nothing

unwrap_or_raise

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

With exc: raise it. Without: raise the contained error if it is an exception, else RuntimeError - so result.unwrap_or_raise() replaces the if result.is_err(): raise result.error boilerplate.

---

Failure

Fields:

• error: BaseException

flat_map

flat_map(self, _f) -> Failure

fold

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

get_or_else

get_or_else(self, default: Any) -> Any

is_failure

is_failure(self) -> bool

is_success

is_success(self) -> bool

map

map(self, _f) -> Failure

or_else

or_else(self, default: Any) -> Any

recover

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

to_either

to_either(self) -> Err[Any]

---

FloatList

Immutable list of f64 values with typed scalar operations.

Scalar methods (add_scalar, mul_scalar, min, max, sum) run on rayon’s thread pool without touching the GIL. Callback-based methods (map_float, filter, fold_left) require the GIL for the Python closure.

abs_vals

abs_vals(self) -> FloatList

add_scalar

add_scalar(self, n: float) -> FloatList

clamp_vals

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

div_scalar

div_scalar(self, n: float) -> FloatList

empty

empty() -> FloatList

filter

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

fold_left

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

is_empty

is_empty(self) -> bool

length

length(self) -> int

map_float

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

max

max(self) -> float

mean

mean(self) -> float

min

min(self) -> float

mul_scalar

mul_scalar(self, n: float) -> FloatList

std_dev

std_dev(self) -> float

sub_scalar

sub_scalar(self, n: float) -> FloatList

sum

sum(self) -> float

to_ilist

to_ilist(self) -> IList[float]

to_list

to_list(self) -> list[float]

zip_add

zip_add(self, other: FloatList) -> FloatList

zip_mul

zip_mul(self, other: FloatList) -> FloatList

---

IList

Immutable persistent list - structural sharing via im-rs. Arc<Py> elements allow im::Vector to clone nodes without the GIL.

append

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

collect_err

collect_err(self) -> IList[Any]

Extract all Err values from an IList of Either[Ok, Err].

collect_ok

collect_ok(self) -> IList[Any]

concat

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

distinct

distinct(self) -> IList[T]

drop

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

empty

empty() -> IList[Any]

filter

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

find

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

flat_map

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

fold_left

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

head

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

is_empty

is_empty(self) -> bool

last

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

length

length(self) -> int

map

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

partition_either

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

Partition an IList of Either[Ok, Err] into (oks, errs).

prepend

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

tail

tail(self) -> IList[T]

take

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

to_list

to_list(self) -> list[T]

zip

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

Pair each element with the element at the same index in other, stopping at the shorter of the two lists. Yields (self, other) tuples.

---

IMap

contains

contains(self, key: K) -> bool

empty

empty() -> IMap[Any, Any]

filter_values

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

get

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

Return the value for key, or nothing() if not present.

is_empty

is_empty(self) -> bool

items

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

keys

keys(self) -> IList[K]

length

length(self) -> int

map_values

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

merge

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

remove

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

set

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

to_dict

to_dict(self) -> dict

Convert to a standard Python dict.

values

values(self) -> IList[V]

---

ISet

Immutable persistent set - structural sharing via im-rs HashSet.

add

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

Return a new ISet with item added. No-op if already present.

contains

contains(self, item: T) -> bool

Return true if item is in this set.

difference

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

Return a new ISet with elements of this set that are not in other.

empty

empty() -> ISet[Any]

filter

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

Return a new ISet containing only elements for which pred returns true.

intersection

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

Return a new ISet containing only elements present in both sets.

is_empty

is_empty(self) -> bool

is_subset_of

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

Return true if every element of this set is also in other.

map

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

Apply f to each element and return a new ISet of the results.

remove

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

Return a new ISet with item removed. No-op if absent.

size

size(self) -> int

Number of elements in this set.

to_ilist

to_ilist(self) -> IList[T]

Convert to an IList. Order is unspecified (hash set iteration order).

to_set

to_set(self) -> set[T]

Convert to a standard Python set.

union

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

Return a new ISet that is the union of this set and other.

---

IntList

Immutable list of i64 values with typed scalar operations.

Scalar methods (add_scalar, mul_scalar, min, max, sum) run on rayon’s thread pool without touching the GIL. Callback-based methods (map_int, filter, fold_left) require the GIL for the Python closure.

abs_vals

abs_vals(self) -> IntList

add_scalar

add_scalar(self, n: int) -> IntList

clamp_vals

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

div_scalar

div_scalar(self, n: int) -> IntList

empty

empty() -> IntList

filter

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

fold_left

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

is_empty

is_empty(self) -> bool

length

length(self) -> int

map_int

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

max

max(self) -> int

mean

mean(self) -> float

min

min(self) -> int

mul_scalar

mul_scalar(self, n: int) -> IntList

std_dev

std_dev(self) -> float

sub_scalar

sub_scalar(self, n: int) -> IntList

sum

sum(self) -> int

to_ilist

to_ilist(self) -> IList[int]

to_list

to_list(self) -> list[int]

zip_add

zip_add(self, other: IntList) -> IntList

zip_mul

zip_mul(self, other: IntList) -> IntList

---

IntSet

Immutable set of non-negative integers backed by a Roaring bitmap.

Set algebra (union, intersection, difference, cardinality, …) runs entirely in Rust over compressed bitmaps - no per-element Python callbacks and no GIL contention. Construction and to_list cross the boundary once per element, the same as building a Python set; the payoff is the operations.

add

add(self, value: int) -> IntSet

cardinality

cardinality(self) -> int

contains

contains(self, value: int) -> bool

difference

difference(self, other: IntSet) -> IntSet

empty

empty() -> IntSet

from_bytes

from_bytes(data: bytes) -> IntSet

Reconstruct an IntSet from to_bytes output (Roaring portable format).

intersection

intersection(self, other: IntSet) -> IntSet

is_disjoint

is_disjoint(self, other: IntSet) -> bool

is_empty

is_empty(self) -> bool

is_subset

is_subset(self, other: IntSet) -> bool

remove

remove(self, value: int) -> IntSet

symmetric_difference

symmetric_difference(self, other: IntSet) -> IntSet

to_bytes

to_bytes(self) -> bytes

Serialize to the Roaring portable byte format, suitable for durable checkpoints or interop with other Roaring implementations.

to_list

to_list(self) -> list[int]

union

union(self, other: IntSet) -> IntSet

---

Invalid

Fields:

• errors: list[E] Always a Python list of error values.

fold

fold(self, invalid_fn, _valid_fn)

fold(invalid_fn, valid_fn) - calls invalid_fn(errors).

get_or_else

get_or_else(self, default)

Return default.

is_invalid

is_invalid(self)

is_valid

is_valid(self)

map

map(self, _f)

Pass-through: map on Invalid is a no-op (returns a fresh copy).

map_err

map_err(self, f)

Invalid(f(errors)). f receives the errors list and must return a new value (usually a list) to use as the new error collection.

to_either

to_either(self)

Err(errors_list).

zip

zip(self, other)

Combine with other. Concatenates error lists from both sides. Valid on other contributes no errors.

---

JsonSchemaRegistrySerde

check_compatibility

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

delete_version

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

deserialize

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

deserialize_many

deserialize_many(self, bytes_list: BytesList) -> IList

deserialize_many_objects

deserialize_many_objects(self, bytes_list: BytesList) -> IList

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

get_schema_by_version

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

list_versions

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

register

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

serialize

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

serialize_many

serialize_many(self, items: IList) -> IList

serialize_many_bytes

serialize_many_bytes(self, items: IList) -> BytesList

subject

subject(self) -> str

---

JsonSerde

deserialize

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

deserialize_many

deserialize_many(self, bytes_list: BytesList) -> IList

deserialize_many_raw

deserialize_many_raw(self, bytes_list: BytesList) -> IList

Fail-fast deserialization from BytesList returning IList directly.

serialize

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

serialize_many

serialize_many(self, items: IList) -> IList

serialize_many_raw

serialize_many_raw(self, items: IList) -> BytesList

Fail-fast serialization returning BytesList directly.

---

NonEmptyList

NonEmptyList - a list provably containing at least one element.

head, last, and reduce are total (return A, never Option) because the non-empty invariant is upheld by the constructor. from_list converts a plain list or IList into Option[NonEmptyList], making the emptiness check explicit at the boundary.

append

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

Append an element to the end, returning a new NonEmptyList.

flat_map

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

flat_map - each element maps to a NonEmptyList; results are concatenated. The overall result is still non-empty (at least the first mapped NEL contributes one element).

fold_left

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

Left fold with an explicit initial accumulator.

from_list

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

Convert an IList[T] or list[T] into Option[NonEmptyList[T]].

Returns Some(nel) when the input is non-empty, Nothing otherwise.

head

head(self) -> T

The first element - total (never Option) because the list is non-empty.

last

last(self) -> T

The last element - total for the same reason.

length

length(self) -> int

Number of elements (always >= 1).

map

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

Element-wise map - result is still a NonEmptyList.

of

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

Alias for NonEmptyList(head, *tail).

prepend

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

Prepend an element to the front, returning a new NonEmptyList.

reduce

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

Fold the list with f, seeded by head. Total - non-empty list always has at least the head to return.

tail

tail(self) -> IList[T]

All elements except the first, as an IList (may be empty).

to_ilist

to_ilist(self) -> IList[T]

Convert to an IList.

to_list

to_list(self) -> list[T]

Convert to a plain Python list.

---

Ok

Fields:

• value: T

flat_map

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

fold

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

get_or_else

get_or_else(self, _default) -> T

is_err

is_err(self) -> bool

is_ok

is_ok(self) -> bool

map

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

map_err

map_err(self, _f) -> Ok[T]

or_else

or_else(self, _default) -> Ok[T]

recover

recover(self, _f) -> Ok[T]

to_option

to_option(self) -> Some[T]

unwrap_or_raise

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

---

Option

The base of the Option type: a Some value or Nothing.

Some and Nothing subclass Option, mirroring Scala’s Option subclassed by Some and None. So isinstance(x, Option) holds for both cases and Option[T] is a real generic alias. Option is abstract: construct values through Option.of / Option.when (or Some / Nothing directly), not Option(...).

from_callable

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

Some(f()) if f returns a non-None value; Nothing if f returns None or raises an Exception. A BaseException (KeyboardInterrupt, SystemExit) propagates rather than being captured.

of

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

Some(value) if value is not None, else Nothing.

sequence

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

Some of every value in the iterable, or Nothing if any element is Nothing.

when

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

Some(value) if condition is True, else Nothing.

---

ProtobufRegistrySerde

check_compatibility

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

delete_version

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

deserialize

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

deserialize_many

deserialize_many(self, bytes_list: BytesList) -> IList

deserialize_many_objects

deserialize_many_objects(self, bytes_list: BytesList) -> IList

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

get_schema_by_version

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

list_versions

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

register

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

serialize

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

serialize_many

serialize_many(self, items: IList) -> IList

serialize_many_bytes

serialize_many_bytes(self, items: IList) -> BytesList

serialize_with_id

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

subject

subject(self) -> str

---

SerdeError

---

SerializationError

---

Some

Fields:

• value: T

filter

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

flat_map

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

fold

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

get_or_else

get_or_else(self, _default) -> T

is_empty

is_empty(self) -> bool

is_nothing

is_nothing(self) -> bool

is_some

is_some(self) -> bool

map

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

or_else

or_else(self, _default) -> Some[T]

to_either

to_either(self, _left) -> Ok[T]

to_list

to_list(self) -> IList[T]

---

Success

Fields:

• value: T

flat_map

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

fold

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

get_or_else

get_or_else(self, _default) -> T

is_failure

is_failure(self) -> bool

is_success

is_success(self) -> bool

map

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

or_else

or_else(self, _default) -> Success[T]

recover

recover(self, _f) -> Success[T]

to_either

to_either(self) -> Ok[T]

---

Try

The base of the Try result type: a Success value or a Failure exception.

Success and Failure subclass Try, the same way Scala’s Try is subclassed by Success and Failure. So isinstance(x, Try) holds for both cases and Try[A] is a real generic alias. Try is abstract: construct values through Try.apply / Try.of (or Success / Failure directly), not Try(...).

apply

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

Success(f()), or Failure(exc) if f raises an Exception. A BaseException (KeyboardInterrupt, SystemExit) propagates rather than being captured.

of

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

Alias for Try.apply.

sequence

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

Success of every value, or the first Failure encountered.

---

Valid

Fields:

• value: T

fold

fold(self, _invalid_fn, valid_fn)

fold(invalid_fn, valid_fn) - calls valid_fn(value).

get_or_else

get_or_else(self, _default)

Return value directly.

is_invalid

is_invalid(self)

is_valid

is_valid(self)

map

map(self, f)

Valid(f(value)).

map_err

map_err(self, _f)

Pass-through: map_err on Valid is a no-op.

to_either

to_either(self)

Ok(value).

zip

zip(self, other)

Combine with other. Both Valid → Valid((self.value, other.value)). Any Invalid → Invalid with that side’s error list.

---

Validated

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

Valid and Invalid subclass Validated just as Scala’s Valid/Invalid subclass Validated. Build values through the factory methods; Validated itself is abstract - constructing it directly is an error.

cond

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

Valid(value) if condition, else Invalid([error]).

from_either

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

Convert an Either into a Validated.

Ok(v) → Valid(v); Err(e) → Invalid([e]).

invalid

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

Invalid([error]). If error is already a list it is stored as-is (shallow copy); otherwise it is wrapped: [error].

valid

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

Valid(value).

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

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

sealed

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