fumus.queries.query

Classes

Query

Abstraction over a sequence of elements supporting sequential aggregate operations

Module Contents

class fumus.queries.query.Query(iterable)

Bases: fumus.queries.itertools_mixin.ItertoolsMixin

Abstraction over a sequence of elements supporting sequential aggregate operations

_iterable

_is_consumed = False

_on_close_handler = None

__iter__()

classmethod of(*iterable)

Creates Query from args

classmethod of_nullable(iterable)

Creates Query from args if iterable is not None; otherwise returns empty Query

classmethod empty()

Creates empty Query

classmethod iterate(seed, operation, condition=None)

Creates infinite ordered Query

classmethod generate(supplier)

Creates infinite unordered Query with values generated by given supplier function

classmethod constant(element)

Creates infinite Query with given value

classmethod from_range(*range_list: int)

Creates Query from start (inclusive) to stop (exclusive) by an incremental step

classmethod _(range_obj: range)

Creates Query range object

property iterable

concat(*queries)

Concatenates several queries together or adds new queries/collections to the current one

prepend(iterable)

Prepends iterable to current query

filter(predicate)

Filters values in query based on given predicate function

map(mapper)

Returns a query consisting of the results of applying the given function to the elements of this query

filter_map(mapper, *, discard_falsy=False)

Filters out all None or falsy values and applies mapper function to the elements of the query

flat_map(mapper)

Maps each element of the query and yields the elements of the produced iterators

flatten()

Converts a Query of multidimensional collection into a one-dimensional

peek(operation)

Performs the provided operation on each element of the query without consuming it

distinct()

Returns a query with the distinct elements of the current one

count()

Returns the count of elements in the query

sum()

Sums the elements of the query

average()

Returns the average value of elements in the query

skip(count)

Discards the first n elements of the query and returns a new query with the remaining ones

limit(count)

Returns a query with the first n elements, or fewer if the underlying iterator ends sooner

head(count)

Alias for ‘limit’

tail(count)

Returns a query with the last n elements, or fewer if the underlying iterator ends sooner

take_while(predicate)

Returns a query that yields elements based on a predicate

drop_while(predicate)

Returns a query that skips elements based on a predicate and yields the remaining ones

take_first(default=None)

Returns Optional with the first element of the query or a default value

take_last(default=None)

Returns Optional with the last element of the query or a default value

sort(comparator=None, *, reverse=False)

Sorts the elements of the current query according to natural order or based on the given comparator. If ‘reverse’ flag is True, the elements are sorted in descending order

reverse(comparator=None)

Sorts the elements of the current query in descending order. Alias for ‘sort(comparator, reverse=True)’

find_first(predicate=None)

Searches for an element of the query that satisfies a predicate. Returns an Optional with the first found value, if any, or None

find_any(predicate=None)

Searches for an element of the query that satisfies a predicate. Returns an Optional with some of the found values, if any, or None

any_match(predicate)

Returns whether any elements of the query match the given predicate

all_match(predicate)

Returns whether all elements of the query match the given predicate

none_match(predicate)

Returns whether no elements of the query match the given predicate

min(comparator=None, default=None)

Returns the minimum element of the query according to the given comparator

max(comparator=None, default=None)

Returns the maximum element of the query according to the given comparator

for_each(operation)

Performs an action for each element of this query

enumerate(start=0)

Returns each element of the Query preceded by his corresponding index (by default starting from 0 if not specified otherwise)

reduce(accumulator, identity=None)

Reduces the elements to a single one, by repeatedly applying a reducing operation. Returns Optional with the result, if any, or None

compare_with(other, comparator=None)

Compares current query with another one based on a given comparator

collect(collection_type, dict_collector=None, dict_merger=None, str_delimiter=', ')

Returns a collection from the query.

In case of dict: The ‘dict_collector’ function receives an element from the query and returns a (key, value) pair or a DictItem specifying how the dict should be constructed.

The ‘dict_merger’ functions indicates in the case of a collision (duplicate keys), which entry should be kept. E.g. lambda old, new: new

In case of str: Concatenates the elements of the Query, separated by the specified ‘str_delimiter’

to_list()

Returns a list of the elements of the current query

to_tuple()

Returns a tuple of the elements of the current query

to_set()

Returns a set of the elements of the current query

to_dict(collector=None, merger=None)

Returns a dict of the elements of the current query.

The ‘collector’ function receives an element from the query and returns a (key, value) pair or a DictItem specifying how the dict should be constructed.

The ‘merger’ functions indicates in the case of a collision (duplicate keys), which entry should be kept. E.g. lambda old, new: new

_unpack_dict_item(item)

to_string(delimiter=', ')

Concatenates the elements of the Query, separated by the specified delimiter

group_by(classifier=None, collector=None)

Performs a “group by” operation on the elements of the query according to a classification function. Returns the results in a dict built using collector function (optionally provided by the user or via a default one)

_group_by(classifier=None)

quantify(predicate=bool)

Count how many of the elements are Truthy or evaluate to True based on a given predicate

close()

Closes the query, causing the provided close handler to be called

on_close(handler)

Returns an equivalent query with an additional close handler

__repr__()

_join(delimiter=', ')

take_nth(idx, default=None)

Returns Optional with the nth element of the query or a default value

all_equal(key=None)

Returns True if all elements of the query are equal to each other