sh-edraft.de/sh_cpl
2
1
Fork 0
Code Issues 4 Pull Requests 1 Actions Packages Projects 1 Releases 12 Wiki Activity

Moved query functions to static query class

Browse Source
This commit is contained in:
Sven Heidemann
2022-09-12 22:53:52 +02:00
parent b16d555e33
commit d8a4210c9b
22 changed files with 438 additions and 542 deletions
Download Patch File Download Diff File Expand all files Collapse all files

77
src/cpl_query/extension/iterable.py
View File

@@ -1,27 +1,8 @@
from typing import Callable, Optional, Union
from cpl_query._query.all import all_query
from cpl_query._query.any import any_query
from cpl_query._query.avg import avg_query
from cpl_query._query.contains import contains_query
from cpl_query._query.count import count_query
from cpl_query._query.distinct import distinct_query
from cpl_query._query.element_at import (element_at_or_default_query,
element_at_query)
from cpl_query._query.first_last import (first_or_default_query, first_query,
last_or_default_query, last_query)
from cpl_query._query.for_each import for_each_query
from cpl_query._query.max_min import max_query, min_query
from cpl_query._query.order_by import order_by_descending_query, order_by_query
from cpl_query._query.reverse import reverse_query
from cpl_query._query.select import select_query, select_many_query
from cpl_query._query.single import single_or_default_query, single_query
from cpl_query._query.skip_take import (skip_last_query, skip_query,
take_last_query, take_query)
from cpl_query._query.sum import sum_query
from cpl_query._query.where import where_query
from cpl_query.extension.iterable_abc import IterableABC
from cpl_query.extension.ordered_iterable_abc import OrderedIterableABC
from cpl_query.query import Query
class Iterable(IterableABC):
@@ -30,94 +11,94 @@ class Iterable(IterableABC):
IterableABC.__init__(self, t, values)
def any(self, func: Callable) -> bool:
return any_query(self, func)
return Query.any(self, func)
def all(self, func: Callable) -> bool:
return all_query(self, func)
return Query.all(self, func)
def average(self, func: Callable = None) -> Union[int, float, complex]:
return avg_query(self, func)
return Query.avg(self, func)
def contains(self, value: object) -> bool:
return contains_query(self, value)
return Query.contains(self, value)
def count(self, func: Callable = None) -> int:
return count_query(self, func)
return Query.count(self, func)
def distinct(self, func: Callable = None) -> IterableABC:
return self.__to_self(distinct_query(self, func))
return self.__to_self(Query.distinct(self, func))
def element_at(self, index: int) -> any:
return element_at_query(self, index)
return Query.element_at(self, index)
def element_at_or_default(self, index: int) -> Optional[any]:
return element_at_or_default_query(self, index)
return Query.element_at_or_default(self, index)
def last(self) -> any:
return last_query(self)
return Query.last(self)
def last_or_default(self) -> Optional[any]:
return last_or_default_query(self)
return Query.last_or_default(self)
def first(self) -> any:
return first_query(self)
return Query.first(self)
def first_or_default(self) -> Optional[any]:
return first_or_default_query(self)
return Query.first_or_default(self)
def for_each(self, func: Callable):
for_each_query(self, func)
Query.for_each(self, func)
def max(self, func: Callable = None) -> Union[int, float, complex]:
return max_query(self, func)
return Query.max(self, func)
def min(self, func: Callable = None) -> Union[int, float, complex]:
return min_query(self, func)
return Query.min(self, func)
def order_by(self, func: Callable) -> OrderedIterableABC:
res = order_by_query(self, func)
res = Query.order_by(self, func)
from cpl_query.extension.ordered_iterable import OrderedIterable
res.__class__ = OrderedIterable
return res
def order_by_descending(self, func: Callable) -> OrderedIterableABC:
res = order_by_descending_query(self, func)
res = Query.order_by_descending(self, func)
from cpl_query.extension.ordered_iterable import OrderedIterable
res.__class__ = OrderedIterable
return res
def reverse(self) -> IterableABC:
return reverse_query(self)
return Query.reverse(self)
def single(self) -> any:
return single_query(self)
return Query.single(self)
def single_or_default(self) -> Optional[any]:
return single_or_default_query(self)
return Query.single_or_default(self)
def select(self, _f: Callable) -> IterableABC:
return self.__to_self(select_query(self, _f))
return self.__to_self(Query.select(self, _f))
def select_many(self, _f: Callable) -> IterableABC:
return self.__to_self(select_many_query(self, _f))
return self.__to_self(Query.select_many(self, _f))
def skip(self, index: int) -> IterableABC:
return self.__to_self(skip_query(self, index))
return self.__to_self(Query.skip(self, index))
def skip_last(self, index: int) -> IterableABC:
return self.__to_self(skip_last_query(self, index))
return self.__to_self(Query.skip_last(self, index))
def sum(self, func: Callable = None) -> Union[int, float, complex]:
return sum_query(self, func)
return Query.sum(self, func)
def take(self, index: int) -> IterableABC:
return self.__to_self(take_query(self, index))
return self.__to_self(Query.take(self, index))
def take_last(self, index: int) -> IterableABC:
return self.__to_self(take_last_query(self, index))
return self.__to_self(Query.take_last(self, index))
def where(self, func: Callable) -> IterableABC:
return self.__to_self(where_query(self, func))
return self.__to_self(Query.where(self, func))
@staticmethod
def __to_self(obj: IterableABC) -> IterableABC:

6
src/cpl_query/extension/ordered_iterable.py
View File

@@ -1,8 +1,8 @@
from collections.abc import Callable
from cpl_query._query.order_by import then_by_descending_query, then_by_query
from cpl_query.extension.iterable import Iterable
from cpl_query.extension.ordered_iterable_abc import OrderedIterableABC
from cpl_query.query import Query
class OrderedIterable(Iterable, OrderedIterableABC):
@@ -15,8 +15,8 @@ class OrderedIterable(Iterable, OrderedIterableABC):
def then_by(self, _func: Callable) -> OrderedIterableABC:
self._funcs.append(_func)
return then_by_query(self, lambda *args: [f(*args) for f in self._funcs])
return Query.then_by(self, lambda *args: [f(*args) for f in self._funcs])
def then_by_descending(self, _func: Callable) -> OrderedIterableABC:
self._funcs.append(_func)
return then_by_descending_query(self, lambda *args: [f(*args) for f in self._funcs])
return Query.then_by_descending(self, lambda *args: [f(*args) for f in self._funcs])