Enumerable¶

pydantic_linq.Enumerable ¶

Enumerable(source: Iterable[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]

IEnumerable with the System.Linq operators. Operators returning sequences are deferred and re-enumerable.

aggregate ¶

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

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

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

aggregate(*args: Any) -> Any

aggregate_by ¶

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

.NET 9 AggregateBy; yields (key, accumulate) tuples in place of KeyValuePair.

all ¶

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

any ¶

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

append ¶

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

as_enumerable ¶

as_enumerable() -> Self

average ¶

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

cast ¶

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

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

chunk ¶

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

concat ¶

concat(second: Iterable[T]) -> Iterator[T]

contains ¶

contains(value: T) -> bool

count ¶

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

count_by ¶

count_by(key_selector: Callable[[T], K]) -> Enumerable[tuple[K, int]]

.NET 9 CountBy.

default_if_empty ¶

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

distinct ¶

distinct() -> Enumerable[T]

distinct_by ¶

distinct_by(key_selector: Callable[[T], Any]) -> Iterator[T]

element_at ¶

element_at(index: int) -> T

ElementAt(int) or ElementAt(Index): a negative index counts from the end (^n).

element_at_or_default ¶

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

empty `staticmethod` ¶

empty() -> Enumerable[Any]

except_ ¶

except_(second: Iterable[T]) -> Enumerable[T]

Except (trailing underscore: except is a keyword).

except_by ¶

except_by(second: Iterable[K], key_selector: Callable[[T], K]) -> Iterator[T]

first ¶

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

first_or_default ¶

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

group_by ¶

group_by(key_selector: Callable[[T], K]) -> Enumerable[Grouping[K, T]]

group_by(key_selector: Callable[[T], K], element_selector: Callable[[T], E]) -> Enumerable[Grouping[K, E]]

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

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

group_join ¶

group_join(inner: Iterable[I], outer_key_selector: Callable[[T], K], inner_key_selector: Callable[[I], K], result_selector: Callable[[T, Enumerable[I]], R]) -> Iterator[R]

index ¶

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

.NET 9 Index(): (index, element) pairs.

infinite_sequence `staticmethod` ¶

infinite_sequence(start: int, step: int) -> Enumerable[int]

.NET 10 Enumerable.InfiniteSequence.

intersect ¶

intersect(second: Iterable[T]) -> Enumerable[T]

intersect_by ¶

intersect_by(second: Iterable[K], key_selector: Callable[[T], K]) -> Iterator[T]

join ¶

join(inner: Iterable[I], outer_key_selector: Callable[[T], K], inner_key_selector: Callable[[I], K], result_selector: Callable[[T, I], R]) -> Iterator[R]

last ¶

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

last_or_default ¶

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

left_join ¶

left_join(inner: Iterable[I], outer_key_selector: Callable[[T], K], inner_key_selector: Callable[[I], K], result_selector: Callable[[T, I | None], R]) -> Iterator[R]

Unmatched outer elements pair with None.

long_count ¶

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

max ¶

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

max_by ¶

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

min ¶

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

min_by ¶

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

of_type ¶

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

order ¶

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

order_by ¶

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

order_by_descending ¶

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

order_descending ¶

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

prepend ¶

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

range `staticmethod` ¶

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

repeat `staticmethod` ¶

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

reverse ¶

reverse() -> Iterator[T]

right_join ¶

right_join(inner: Iterable[I], outer_key_selector: Callable[[T], K], inner_key_selector: Callable[[I], K], result_selector: Callable[[T | None, I], R]) -> Iterator[R]

Unmatched inner elements pair with None.

select ¶

select(selector: Callable[[T], U]) -> Iterator[U]

select_many ¶

select_many(selector: Callable[[T], Iterable[U]]) -> Enumerable[U]

select_many(selector: Callable[[T], Iterable[C]], result_selector: Callable[[T, C], U]) -> Enumerable[U]

select_many(selector: Callable[[T], Iterable[Any]], result_selector: Callable[[T, Any], Any] | None = None) -> Enumerable[Any]

sequence `staticmethod` ¶

sequence(start: int, end_inclusive: int, step: int) -> Enumerable[int]

.NET 10 Enumerable.Sequence.

sequence_equal ¶

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

shuffle ¶

shuffle() -> Iterator[T]

.NET 10 Shuffle.

single ¶

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

single_or_default ¶

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

skip ¶

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

skip_last ¶

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

skip_while ¶

skip_while(predicate: Callable[[T], bool]) -> Iterator[T]

sum ¶

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

take ¶

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

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

take_last ¶

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

take_while ¶

take_while(predicate: Callable[[T], bool]) -> Iterator[T]

to_array ¶

to_array() -> list[T]

to_async_enumerable ¶

to_async_enumerable() -> AsyncEnumerable[T]

ToAsyncEnumerable: enter the async operators.

to_dictionary ¶

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

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

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

to_hash_set ¶

to_hash_set() -> set[T]

to_list ¶

to_list() -> list[T]

to_lookup ¶

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

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

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

try_get_non_enumerated_count ¶

try_get_non_enumerated_count() -> int | None

union ¶

union(second: Iterable[T]) -> Enumerable[T]

union_by ¶

union_by(second: Iterable[T], key_selector: Callable[[T], Any]) -> Iterator[T]

where ¶

where(predicate: Callable[[T], bool]) -> Iterator[T]

zip ¶

zip(second: Iterable[S]) -> Enumerable[tuple[T, S]]

zip(second: Iterable[S], third: Iterable[U]) -> Enumerable[tuple[T, S, U]]

zip(*others: Iterable[Any]) -> Enumerable[tuple[Any, ...]]

zip_with ¶

zip_with(second: Iterable[S], result_selector: Callable[[T, S], R]) -> Iterator[R]

Zip(second, resultSelector).

pydantic_linq.OrderedEnumerable ¶

OrderedEnumerable(source: Iterable[T], keys: tuple[SortKey[T], ...])

Bases: Enumerable[T]

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

then_by ¶

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

then_by_descending ¶

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