Implemented enumerable

src/cpl_query/iterable/__init__.py

@@ -0,0 +1,30 @@
+# -*- coding: utf-8 -*-
+
+"""
+cpl-query sh-edraft Common Python library Query
+~~~~~~~~~~~~~~~~~~~
+
+sh-edraft Common Python library Python integrated Queries
+
+:copyright: (c) 2021 - 2022 sh-edraft.de
+:license: MIT, see LICENSE for more details.
+
+"""
+
+__title__ = 'cpl_query.iterable'
+__author__ = 'Sven Heidemann'
+__license__ = 'MIT'
+__copyright__ = 'Copyright (c) 2021 - 2022 sh-edraft.de'
+__version__ = '2022.10.2'
+
+from collections import namedtuple
+
+
+# imports:
+from .iterable_abc import IterableABC
+from .iterable import Iterable
+from .ordered_iterable_abc import OrderedIterableABC
+from .ordered_iterable import OrderedIterable
+
+VersionInfo = namedtuple('VersionInfo', 'major minor micro')
+version_info = VersionInfo(major='2022', minor='10', micro='2')

src/cpl_query/iterable/iterable.py

@@ -0,0 +1,106 @@
+from typing import Callable, Optional, Union
+
+from cpl_query.iterable.iterable_abc import IterableABC
+from cpl_query.iterable.ordered_iterable_abc import OrderedIterableABC
+from cpl_query.query import Query
+
+
+class Iterable(IterableABC):
+
+    def __init__(self, t: type = None, values: list = None):
+        IterableABC.__init__(self, t, values)
+
+    def any(self, func: Callable) -> bool:
+        return Query.any(self, func)
+
+    def all(self, func: Callable) -> bool:
+        return Query.all(self, func)
+
+    def average(self, func: Callable = None) -> Union[int, float, complex]:
+        return Query.avg(self, func)
+
+    def contains(self, value: object) -> bool:
+        return Query.contains(self, value)
+
+    def count(self, func: Callable = None) -> int:
+        return Query.count(self, func)
+
+    def distinct(self, func: Callable = None) -> IterableABC:
+        return self.__to_self(Query.distinct(self, func))
+
+    def element_at(self, index: int) -> any:
+        return Query.element_at(self, index)
+
+    def element_at_or_default(self, index: int) -> Optional[any]:
+        return Query.element_at_or_default(self, index)
+
+    def last(self) -> any:
+        return Query.last(self)
+
+    def last_or_default(self) -> Optional[any]:
+        return Query.last_or_default(self)
+
+    def first(self) -> any:
+        return Query.first(self)
+
+    def first_or_default(self) -> Optional[any]:
+        return Query.first_or_default(self)
+
+    def for_each(self, func: Callable):
+        Query.for_each(self, func)
+
+    def max(self, func: Callable = None) -> Union[int, float, complex]:
+        return Query.max(self, func)
+
+    def min(self, func: Callable = None) -> Union[int, float, complex]:
+        return Query.min(self, func)
+
+    def order_by(self, func: Callable) -> OrderedIterableABC:
+        res = Query.order_by(self, func)
+        from cpl_query.iterable.ordered_iterable import OrderedIterable
+        res.__class__ = OrderedIterable
+        return res
+
+    def order_by_descending(self, func: Callable) -> OrderedIterableABC:
+        res = Query.order_by_descending(self, func)
+        from cpl_query.iterable.ordered_iterable import OrderedIterable
+        res.__class__ = OrderedIterable
+        return res
+
+    def reverse(self) -> IterableABC:
+        return Query.reverse(self)
+
+    def single(self) -> any:
+        return Query.single(self)
+
+    def single_or_default(self) -> Optional[any]:
+        return Query.single_or_default(self)
+
+    def select(self, _f: Callable) -> IterableABC:
+        return self.__to_self(Query.select(self, _f))
+
+    def select_many(self, _f: Callable) -> IterableABC:
+        return self.__to_self(Query.select_many(self, _f))
+
+    def skip(self, index: int) -> IterableABC:
+        return self.__to_self(Query.skip(self, index))
+
+    def skip_last(self, index: int) -> IterableABC:
+        return self.__to_self(Query.skip_last(self, index))
+
+    def sum(self, func: Callable = None) -> Union[int, float, complex]:
+        return Query.sum(self, func)
+
+    def take(self, index: int) -> IterableABC:
+        return self.__to_self(Query.take(self, index))
+
+    def take_last(self, index: int) -> IterableABC:
+        return self.__to_self(Query.take_last(self, index))
+
+    def where(self, func: Callable) -> IterableABC:
+        return self.__to_self(Query.where(self, func))
+
+    @staticmethod
+    def __to_self(obj: IterableABC) -> IterableABC:
+        obj.__class__ = Iterable
+        return obj

src/cpl_query/iterable/iterable_abc.py

@@ -0,0 +1,64 @@
+from abc import ABC, abstractmethod
+from typing import Optional, Callable, Union, Iterable
+
+from cpl_query.base.queryable_abc import QueryableABC
+from cpl_query.enumerable.enumerable_abc import EnumerableABC
+
+
+class IterableABC(QueryableABC, list):
+    r"""ABC to define functions on list
+    """
+
+    @abstractmethod
+    def __init__(self, t: type = None, values: list = None):
+        list.__init__(self)
+
+        if t == any:
+            t = None
+        self._type = t
+
+        if values is not None:
+            for value in values:
+                self.append(value)
+
+    @property
+    def type(self) -> type:
+        return self._type
+
+    def append(self, __object: object) -> None:
+        r"""Adds element to list
+
+        Parameter
+        ---------
+            __object: :class:`object`
+                value
+        """
+        if self._type is not None and type(__object) != self._type and not isinstance(type(__object), self._type) and not issubclass(type(__object), self._type):
+            raise Exception(f'Unexpected type: {type(__object)}\nExpected type: {self._type}')
+
+        if len(self) == 0 and self._type is None:
+            self._type = type(__object)
+
+        super().append(__object)
+
+    def extend(self, __iterable: Iterable) -> 'IterableABC':
+        r"""Adds elements of given list to list
+
+        Parameter
+        ---------
+            __iterable: :class: `cpl_query.extension.iterable.Iterable`
+                index
+        """
+        for value in __iterable:
+            self.append(value)
+
+        return self
+
+    def to_list(self) -> list:
+        r"""Converts :class: `cpl_query.enumerable.enumerable_abc.EnumerableABC` to :class: `list`
+
+        Returns
+        -------
+            :class: `list`
+        """
+        return list(self)

src/cpl_query/iterable/ordered_iterable.py

@@ -0,0 +1,22 @@
+from collections.abc import Callable
+
+from cpl_query.iterable.iterable import Iterable
+from cpl_query.iterable.ordered_iterable_abc import OrderedIterableABC
+from cpl_query.query import Query
+
+
+class OrderedIterable(Iterable, OrderedIterableABC):
+    r"""Implementation of :class: `cpl_query.extension.Iterable` `cpl_query.extension.OrderedIterableABC`
+    """
+
+    def __init__(self, _t: type = None):
+        Iterable.__init__(self, _t)
+        OrderedIterableABC.__init__(self, _t)
+
+    def then_by(self, _func: Callable) -> OrderedIterableABC:
+        self._funcs.append(_func)
+        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 Query.then_by_descending(self, lambda *args: [f(*args) for f in self._funcs])

src/cpl_query/iterable/ordered_iterable_abc.py

@@ -0,0 +1,42 @@
+from abc import abstractmethod
+from collections.abc import Callable
+
+from cpl_query.iterable.iterable_abc import IterableABC
+
+
+class OrderedIterableABC(IterableABC):
+
+    @abstractmethod
+    def __init__(self, _t: type, _func: Callable = None):
+        IterableABC.__init__(self, _t)
+        self._funcs: list[Callable] = []
+        if _func is not None:
+            self._funcs.append(_func)
+
+    @abstractmethod
+    def then_by(self, func: Callable) -> 'OrderedIterableABC':
+        r"""Sorts OrderedList in ascending order by function
+
+        Parameter
+        ---------
+            func: :class:`Callable`
+            
+        Returns
+        -------
+            list of :class:`cpl_query.extension.OrderedIterableABC`
+        """
+        pass
+
+    @abstractmethod
+    def then_by_descending(self, func: Callable) -> 'OrderedIterableABC':
+        r"""Sorts OrderedList in descending order by function
+
+        Parameter
+        ---------
+            func: :class:`Callable`
+            
+        Returns
+        -------
+            list of :class:`cpl_query.extension.OrderedIterableABC`
+        """
+        pass