AsyncEnumerable

pydantic_linq.AsyncEnumerable

AsyncEnumerable(source: AnyIterable[T] = ())

Bases: Generation[T], Filtering[T], Projection[T], Partitioning[T], Concatenation[T], Sets[T], Sorting[T], GroupingOps[T], Joining[T], Element[T], Quantifiers[T], Equality[T], Aggregation[T], Conversion[T]

IAsyncEnumerable with the System.Linq.Async operators.

Wraps any sync or async iterable. Sequence operators are deferred; terminal operators are awaitable. Selectors may be plain functions or async def.

aggregate async

aggregate(func: Fn[[T, T], T]) -> T

aggregate(seed: A, func: Fn[[A, T], A]) -> A

aggregate(seed: A, func: Fn[[A, T], A], result_selector: Fn[[A], R]) -> R

aggregate(*args: Any) -> Any

aggregate_by

aggregate_by(key_selector: Fn[[T], K], seed: A, func: Fn[[A, T], A]) -> AsyncEnumerable[tuple[K, A]]

all async

all(predicate: Fn[[T], bool]) -> bool

any async

any(predicate: Fn[[T], bool] | None = None) -> bool

append async

append(element: T) -> AsyncIterator[T]

as_async_enumerable

as_async_enumerable() -> Self

average async

average(selector: Fn[[T], Any] | None = None) -> float

cast async

cast(type_: type[U], *, strict: bool = False) -> AsyncIterator[U]

Cast, pydantic-style: validates each element with a TypeAdapter (dicts become models).

chunk

chunk(size: int) -> AsyncEnumerable[list[T]]

concat async

concat(second: AnyIterable[T]) -> AsyncIterator[T]

contains async

contains(value: T) -> bool

count async

count(predicate: Fn[[T], bool] | None = None) -> int

count_by

count_by(key_selector: Fn[[T], K]) -> AsyncEnumerable[tuple[K, int]]

default_if_empty async

default_if_empty(default: T | None = None) -> AsyncIterator[T | None]

distinct

distinct() -> AsyncEnumerable[T]

distinct_by async

distinct_by(key_selector: Fn[[T], Any]) -> AsyncIterator[T]

element_at async

element_at(index: int) -> T

A negative index counts from the end (^n).

element_at_or_default async

element_at_or_default(index: int, default: T | None = None) -> T | None

empty staticmethod

empty() -> AsyncEnumerable[Any]

except_

except_(second: AnyIterable[T]) -> AsyncEnumerable[T]

Except (trailing underscore: except is a keyword).

except_by async

except_by(second: AnyIterable[K], key_selector: Fn[[T], K]) -> AsyncIterator[T]

first async

first(predicate: Fn[[T], bool] | None = None) -> T

first_or_default async

first_or_default(predicate: Fn[[T], bool] | None = None, default: T | None = None) -> T | None

group_by

group_by(key_selector: Fn[[T], K]) -> AsyncEnumerable[AsyncGrouping[K, T]]

group_by(key_selector: Fn[[T], K], element_selector: Fn[[T], E]) -> AsyncEnumerable[AsyncGrouping[K, E]]

group_by(key_selector: Fn[[T], K], element_selector: Fn[[T], E] | None = None, *, result_selector: Fn[[K, AsyncEnumerable[E]], R]) -> AsyncEnumerable[R]

group_by(key_selector: Fn[[T], Any], element_selector: Fn[[T], Any] | None = None, *, result_selector: Fn[[Any, AsyncEnumerable[Any]], Any] | None = None) -> AsyncEnumerable[Any]

group_join async

group_join(inner: AnyIterable[I], outer_key_selector: Fn[[T], K], inner_key_selector: Fn[[I], K], result_selector: Fn[[T, AsyncEnumerable[I]], R]) -> AsyncIterator[R]

index async

index() -> AsyncIterator[tuple[int, T]]

intersect

intersect(second: AnyIterable[T]) -> AsyncEnumerable[T]

intersect_by async

intersect_by(second: AnyIterable[K], key_selector: Fn[[T], K]) -> AsyncIterator[T]

join async

join(inner: AnyIterable[I], outer_key_selector: Fn[[T], K], inner_key_selector: Fn[[I], K], result_selector: Fn[[T, I], R]) -> AsyncIterator[R]

last async

last(predicate: Fn[[T], bool] | None = None) -> T

last_or_default async

last_or_default(predicate: Fn[[T], bool] | None = None, default: T | None = None) -> T | None

left_join async

left_join(inner: AnyIterable[I], outer_key_selector: Fn[[T], K], inner_key_selector: Fn[[I], K], result_selector: Fn[[T, I | None], R]) -> AsyncIterator[R]

Unmatched outer elements pair with None.

long_count async

long_count(predicate: Fn[[T], bool] | None = None) -> int

max async

max(selector: Fn[[T], Any] | None = None) -> Any

max_by async

max_by(key_selector: Fn[[T], Any]) -> T

min async

min(selector: Fn[[T], Any] | None = None) -> Any

min_by async

min_by(key_selector: Fn[[T], Any]) -> T

of_type async

of_type(type_: type[U]) -> AsyncIterator[U]

order

order(comparer: Comparer | None = None) -> OrderedAsyncEnumerable[T]

order_by

order_by(key_selector: Fn[[T], Any], comparer: Comparer | None = None) -> OrderedAsyncEnumerable[T]

order_by_descending

order_by_descending(key_selector: Fn[[T], Any], comparer: Comparer | None = None) -> OrderedAsyncEnumerable[T]

order_descending

order_descending(comparer: Comparer | None = None) -> OrderedAsyncEnumerable[T]

prepend async

prepend(element: T) -> AsyncIterator[T]

range staticmethod

range(start: int, count: int) -> AsyncEnumerable[int]

repeat staticmethod

repeat(element: U, count: int) -> AsyncEnumerable[U]

reverse async

reverse() -> AsyncIterator[T]

right_join async

right_join(inner: AnyIterable[I], outer_key_selector: Fn[[T], K], inner_key_selector: Fn[[I], K], result_selector: Fn[[T | None, I], R]) -> AsyncIterator[R]

Unmatched inner elements pair with None.

select async

select(selector: Fn[[T], U]) -> AsyncIterator[U]

select_many

select_many(selector: Fn[[T], AnyIterable[U]]) -> AsyncEnumerable[U]

select_many(selector: Fn[[T], AnyIterable[C]], result_selector: Fn[[T, C], U]) -> AsyncEnumerable[U]

select_many(selector: Fn[[T], AnyIterable[Any]], result_selector: Fn[[T, Any], Any] | None = None) -> AsyncEnumerable[Any]

sequence_equal async

sequence_equal(second: AnyIterable[T]) -> bool

shuffle async

shuffle() -> AsyncIterator[T]

single async

single(predicate: Fn[[T], bool] | None = None) -> T

single_or_default async

single_or_default(predicate: Fn[[T], bool] | None = None, default: T | None = None) -> T | None

skip async

skip(count: int) -> AsyncIterator[T]

skip_last async

skip_last(count: int) -> AsyncIterator[T]

skip_while async

skip_while(predicate: Fn[[T], bool]) -> AsyncIterator[T]

sum async

sum(selector: Fn[[T], Any] | None = None) -> Any

take

take(count: int | slice) -> AsyncEnumerable[T]

Take(int) or Take(Range): pass a slice for ranges; negative bounds count from the end (^n).

take_last async

take_last(count: int) -> AsyncIterator[T]

take_while async

take_while(predicate: Fn[[T], bool]) -> AsyncIterator[T]

to_array async

to_array() -> list[T]

to_dictionary async

to_dictionary(key_selector: Fn[[T], K]) -> dict[K, T]

to_dictionary(key_selector: Fn[[T], K], element_selector: Fn[[T], E]) -> dict[K, E]

to_dictionary(key_selector: Fn[[T], Any], element_selector: Fn[[T], Any] | None = None) -> dict[Any, Any]

to_hash_set async

to_hash_set() -> set[T]

to_list async

to_list() -> list[T]

to_lookup async

to_lookup(key_selector: Fn[[T], K]) -> Lookup[K, T]

to_lookup(key_selector: Fn[[T], K], element_selector: Fn[[T], E]) -> Lookup[K, E]

to_lookup(key_selector: Fn[[T], Any], element_selector: Fn[[T], Any] | None = None) -> Lookup[Any, Any]

union

union(second: AnyIterable[T]) -> AsyncEnumerable[T]

union_by async

union_by(second: AnyIterable[T], key_selector: Fn[[T], Any]) -> AsyncIterator[T]

where async

where(predicate: Fn[[T], bool]) -> AsyncIterator[T]

zip

zip(second: AnyIterable[S]) -> AsyncEnumerable[tuple[T, S]]

zip(second: AnyIterable[S], third: AnyIterable[U]) -> AsyncEnumerable[tuple[T, S, U]]

zip(*others: AnyIterable[Any]) -> AsyncEnumerable[tuple[Any, ...]]

zip_with async

zip_with(second: AnyIterable[S], result_selector: Fn[[T, S], R]) -> AsyncIterator[R]

pydantic_linq.OrderedAsyncEnumerable

OrderedAsyncEnumerable(source: AnyIterable[T], keys: tuple[AsyncSortKey[T], ...])

Bases: AsyncEnumerable[T]

IOrderedAsyncEnumerable: stable multi-key sort; supports then_by / then_by_descending.

then_by

then_by(key_selector: Fn[[T], Any], comparer: Comparer | None = None) -> OrderedAsyncEnumerable[T]

then_by_descending

then_by_descending(key_selector: Fn[[T], Any], comparer: Comparer | None = None) -> OrderedAsyncEnumerable[T]