pyrio 1.0.0__py3-none-any.whl

pyrio/__init__.py

@@ -0,0 +1,2 @@
+from .stream import Stream as Stream
+from .optional import Optional as Optional

pyrio/decorator.py

@@ -0,0 +1,55 @@
+from functools import wraps
+
+from pyrio.exception import IllegalStateError
+
+TERMINAL_FUNCTIONS = [
+    "for_each",
+    "reduce",
+    "count",
+    "sum",
+    "find_first",
+    "find_any",
+    "any_match",
+    "all_match",
+    "none_match",
+    "min",
+    "max",
+    "compare_with",
+    "to_list",
+    "to_tuple",
+    "to_set",
+    "to_dict",
+    "group_by",
+    "take_nth",
+    "all_equal",
+]
+
+
+def pre_call(function_decorator):
+    def decorator(cls):
+        for name, obj in vars(cls).items():
+            if callable(obj):
+                setattr(cls, name, function_decorator(obj))
+        return cls
+
+    return decorator
+
+
+def handle_consumed(func):
+    @wraps(func)
+    def wrapper(*args, **kw):
+        from pyrio import Stream
+
+        if not args or isinstance(args[0], Stream) is False:
+            return func(*args, **kw)
+
+        is_consumed = getattr(args[0], "_is_consumed", None)
+        if is_consumed:
+            raise IllegalStateError("Stream object already consumed")
+
+        result = func(*args, **kw)
+        if is_consumed is False and func.__name__ in TERMINAL_FUNCTIONS:
+            args[0]._is_consumed = True
+        return result
+
+    return wrapper

pyrio/exception.py

@@ -0,0 +1,10 @@
+class IllegalStateError(Exception):
+    pass
+
+
+class NullPointerError(Exception):
+    pass
+
+
+class NoSuchElementError(Exception):
+    pass

pyrio/iterator.py

@@ -0,0 +1,135 @@
+class Iterator:
+    @staticmethod
+    def concat(*streams):
+        for iterable in streams:
+            yield from iterable
+
+    @staticmethod
+    def filter(iterable, predicate):
+        for i in iterable:
+            if predicate(i):
+                yield i
+
+    @staticmethod
+    def map(iterable, mapper):
+        for i in iterable:
+            yield mapper(i)
+
+    @staticmethod
+    def filter_map(iterable, mapper, falsy=False):
+        for i in iterable:
+            if (not falsy and i is not None) or (falsy and i):
+                yield mapper(i)
+
+    @staticmethod
+    def flat_map(iterable, mapper):
+        for i in iterable:
+            for j in mapper(i):
+                yield j
+
+    @staticmethod
+    def flatten(iterable):
+        from collections.abc import Iterable
+
+        for i in iterable:
+            if isinstance(i, str) or not isinstance(i, Iterable):
+                yield i
+            else:
+                yield from Iterator.flatten(i)
+
+    @staticmethod
+    def reduce(iterable, accumulator, identity=None):
+        if len(iterable) == 0:
+            return identity
+
+        idx = 0
+        if identity is None:
+            identity = iterable[0]
+            idx = 1
+
+        for i in iterable[idx:]:
+            identity = accumulator(identity, i)
+        return identity
+
+    @staticmethod
+    def for_each(iterable, operation):
+        for i in iterable:
+            operation(i)
+
+    @staticmethod
+    def peek(iterable, operation):
+        for i in iterable:
+            operation(i)
+            yield i
+
+    @staticmethod
+    def iterate(seed, operation):
+        while True:
+            yield seed
+            seed = operation(seed)
+
+    @staticmethod
+    def generate(supplier):
+        while True:
+            yield supplier()
+
+    @staticmethod
+    def distinct(iterable):
+        elements = set()
+        for i in iterable:
+            if i not in elements:
+                elements.add(i)
+                yield i
+
+    @staticmethod
+    def skip(iterable, count):
+        for i in iterable:
+            if count > 0:
+                count -= 1
+            else:
+                yield i
+
+    @staticmethod
+    def limit(iterable, count):
+        for i in iterable:
+            if count == 0:
+                break
+            yield i
+            count -= 1
+
+    @staticmethod
+    def tail(iterable, count):
+        import collections
+
+        for i in collections.deque(iterable, maxlen=count):
+            yield i
+
+    @staticmethod
+    def take_while(iterable, predicate):
+        for i in iterable:
+            if not predicate(i):
+                break
+            yield i
+
+    @staticmethod
+    def drop_while(iterable, predicate):
+        iterator = iter(iterable)
+        for x in iterator:
+            if not predicate(x):
+                yield x
+                break
+
+        for x in iterator:
+            yield x
+
+    @staticmethod
+    def sorted(iterable, comparator=None, reverse=False):
+        for i in sorted(iterable, key=comparator, reverse=reverse):
+            yield i
+
+    @staticmethod
+    def compare_with(iterable, other_iterable, comparator=None):
+        for i, j in zip(iterable, other_iterable):
+            if (comparator and not comparator(i, j)) or i != j:
+                return False
+        return True

pyrio/itertools_mixin.py

@@ -0,0 +1,223 @@
+from collections.abc import Iterable, Sized
+import itertools as it
+import operator
+
+from pyrio.optional import Optional
+
+
+class ItertoolsMixin:
+    _iterable: Iterable | Sized
+
+    def use(self, it_function, *args, **kwargs):
+        """Provides integration with itertools methods"""
+        import inspect
+
+        if args:
+            raise ValueError("Use keyword arguments only")
+
+        if self._handle_no_signature_functions(it_function, **kwargs):
+            return self
+
+        signature = inspect.signature(it_function).parameters
+        if self._handle_no_kwargs_functions(signature, it_function, **kwargs):
+            return self
+
+        return self._handle_default_signature_functions(signature, it_function, **kwargs)
+
+    def _handle_no_signature_functions(self, it_function, **kwargs):
+        NO_SIGNATURE_FUNCTIONS = ["chain", "islice", "product", "repeat", "zip_longest"]
+
+        if it_function.__name__ not in NO_SIGNATURE_FUNCTIONS:
+            return False
+
+        if it_function.__name__ in ("product", "zip_longest"):
+            if isinstance(self._iterable, range):
+                self._iterable = it_function(self._iterable, **kwargs)
+            else:
+                self._iterable = it_function(*self._iterable, **kwargs)
+            return True
+
+        # functions like 'chain' don't expect key-word arguments
+        self._iterable = it_function(self._iterable, *kwargs.values())
+        return True
+
+    def _handle_no_kwargs_functions(self, signature, it_function, **kwargs):
+        NO_KWARGS_FUNCTIONS = ["dropwhile", "filterfalse", "starmap", "takewhile", "tee"]
+
+        # handle functions that take only iterable as arg
+        if len(signature.keys()) == 1 and "iterable" in signature:
+            self._iterable = it_function(self._iterable)
+            return True
+
+        # handle functions that take no kwargs
+        if it_function.__name__ in NO_KWARGS_FUNCTIONS:
+            if it_function.__name__ == "tee":
+                self._iterable = it_function(self._iterable, *kwargs.values())
+            else:
+                self._iterable = it_function(*kwargs.values(), self._iterable)
+            return True
+        return False
+
+    def _handle_default_signature_functions(self, signature, it_function, **kwargs):
+        if "iterable" in signature:
+            kwargs["iterable"] = self._iterable
+        elif "data" in signature:
+            kwargs["data"] = self._iterable
+        self._iterable = it_function(**kwargs)
+        return self
+
+    # ### 'recipes' ###
+    # https://docs.python.org/3/library/itertools.html#itertools-recipes
+    def tabulate(self, mapper, start=0):
+        """ "Returns function(0), function(1), ..."""
+        self._iterable = map(mapper, it.count(start))
+        return self
+
+    def repeat_func(self, operation, times=None):
+        """Repeats calls to func with specified arguments"""
+        self._iterable = it.starmap(operation, it.repeat(self._iterable, times=times))
+        return self
+
+    def ncycles(self, count=0):
+        """Returns the stream elements n times"""
+        self._iterable = it.chain.from_iterable(it.repeat(tuple(self._iterable), count))
+        return self
+
+    def consume(self, n=None):
+        """Advances the iterator n-steps ahead. If n is None, consumes stream entirely"""
+        import collections
+
+        if n is None:
+            self._iterable = collections.deque(self._iterable, maxlen=0)
+            return self
+        if n < 0:
+            raise ValueError("Consume boundary cannot be negative")
+        self._iterable = it.islice(self._iterable, n, len(self._iterable))
+        return self
+
+    def take_nth(self, idx, default=None):
+        """Returns Optional with the nth element of the stream or a default value"""
+        if idx < 0:
+            idx = len(self._iterable) + idx
+        return Optional.of_nullable(next(it.islice(self._iterable, idx, None), default))
+
+    def all_equal(self, key=None):
+        """Returns True if all elements of the stream are equal to each other"""
+        return len(list(it.islice(it.groupby(self._iterable, key), 2))) <= 1
+
+    def view(self, start=0, stop=None, step=None):
+        """Provides access to a selected part of the stream"""
+        if start < 0:
+            start = len(self._iterable) + start
+
+        if stop and stop < 0:
+            stop = len(self._iterable) + stop
+
+        if step and step < 0:
+            raise ValueError("Step must be a positive integer or None")
+
+        self._iterable = it.islice(self._iterable, start, stop, step)
+        return self
+
+    # ### unique ###
+    def unique(self, key=None, reverse=False):
+        """Yields unique elements in sorted order. Supports unhashable inputs"""
+        self._iterable = self._unique(sorted(self._iterable, key=key, reverse=reverse), key=key)
+        return self
+
+    @staticmethod
+    def _unique(iterable, key=None):
+        return map(next, map(operator.itemgetter(1), it.groupby(iterable, key)))
+
+    def unique_just_seen(self, key=None):
+        """Yields unique elements, preserving order. Remembers only the element just seen"""
+        self._iterable = map(next, map(operator.itemgetter(1), it.groupby(self._iterable, key)))
+        return self
+
+    def unique_ever_seen(self, key=None):
+        """Yields unique elements, preserving order. Remembers all elements ever seen"""
+        self._iterable = self._unique_ever_seen(self._iterable, key)
+        return self
+
+    @staticmethod
+    def _unique_ever_seen(iterable, key=None):
+        seen = set()
+        for element in iterable:
+            k = key(element) if key else element
+            if k not in seen:
+                seen.add(k)
+                yield element
+
+    # ### ###
+    def sliding_window(self, n):
+        """Collects data into overlapping fixed-length chunks or blocks"""
+        if n < 0:
+            raise ValueError("Window size cannot be negative")
+        self._iterable = self._sliding_window(self._iterable, n)
+        return self
+
+    @staticmethod
+    def _sliding_window(iterable, n):
+        import collections
+
+        window = collections.deque(it.islice(iterable, n - 1), maxlen=n)
+        for x in it.islice(iterable, n - 1, len(iterable)):
+            window.append(x)
+            yield tuple(window)
+
+    def grouper(self, n, *, incomplete="fill", fill_value=None):
+        """Collects data into non-overlapping fixed-length chunks or blocks"""
+        self._iterable = self._grouper(n, incomplete, fill_value)
+        return self
+
+    def _grouper(self, n, incomplete="fill", fill_value=None):
+        iterators = [iter(self._iterable)] * n
+        match incomplete:
+            case "fill":
+                return it.zip_longest(*iterators, fillvalue=fill_value)
+            case "strict":
+                return zip(*iterators, strict=True)
+            case "ignore":
+                return zip(*iterators)
+            case _:
+                raise ValueError(
+                    f"Invalid incomplete flag '{incomplete}', expected: 'fill', 'strict', or 'ignore'"
+                )
+
+    def round_robin(self):
+        """Visits input iterables in a cycle until each is exhausted"""
+        self._iterable = self._round_robin(self._iterable)
+        return self
+
+    @staticmethod
+    def _round_robin(iterable):
+        # Algorithm credited to George Sakkis
+        iterators = map(iter, iterable)
+        for num_active in range(len(iterable), 0, -1):
+            iterators = it.cycle(it.islice(iterators, num_active))
+            yield from map(next, iterators)
+
+    def partition(self, predicate):
+        """Partitions entries into false entries and true entries.
+        Returns a stream of two nested generators"""
+        true_iter, false_iter = it.tee(self._iterable)
+        self._iterable = filter(predicate, true_iter), it.filterfalse(predicate, false_iter)
+        return self
+
+    def subslices(self):
+        """Returns all contiguous non-empty sub-slices"""
+        slices = it.starmap(slice, it.combinations(range(len(self._iterable) + 1), 2))
+        self._iterable = map(operator.getitem, it.repeat(self._iterable), slices)  # noqa
+        return self
+
+    def find_indices(self, value, start=0, stop=None):
+        """Returns indices where a value occurs in a sequence or iterable"""
+        self._iterable = self._find_indices(self._iterable, value, start, stop)
+        return self
+
+    @staticmethod
+    def _find_indices(iterable, value, start=0, stop=None):
+        iterator = it.islice(iterable, start, stop)
+        for i, element in enumerate(iterator, start):
+            if element is value or element == value:
+                yield i

pyrio/optional.py

@@ -0,0 +1,62 @@
+from pyrio.exception import NoSuchElementError, NullPointerError
+
+
+class Optional:
+    def __init__(self, element):
+        self._element = element
+
+    def __str__(self):
+        return f"Optional[{self._element}]"
+
+    @staticmethod
+    def empty():
+        """Creates empty Optional"""
+        return Optional(None)
+
+    @staticmethod
+    def of(element):
+        """Creates Optional describing given non-null value"""
+        if element is None:
+            raise NullPointerError("Value cannot be None")
+        return Optional(element)
+
+    @staticmethod
+    def of_nullable(element):
+        """Returns an Optional describing the given value, if non-null, otherwise returns an empty Optional"""
+        return Optional(element)
+
+    def get(self):
+        """If a value is present, returns the value, otherwise raises an Exception"""
+        if self.is_empty():
+            raise NoSuchElementError("Optional is empty")
+        return self._element
+
+    def is_present(self):
+        """Returns bool whether a value is present"""
+        return not self.is_empty()
+
+    def is_empty(self):
+        """Returns bool whether the Optional is empty"""
+        return self._element is None
+
+    def if_present(self, action):
+        """Performs given action with the value if the Optional is not empty"""
+        if self.is_present():
+            action(self.get())
+
+    def if_present_or_else(self, action, empty_action):
+        """Performs given action with the value if the Optional is not empty, otherwise calls fallback 'empty_action'"""
+        if self.is_present():
+            action(self.get())
+        else:
+            empty_action()
+
+    def or_else(self, value):
+        """Returns the value if present, or a provided argument otherwise.
+        Safe alternative to get() method."""
+        return self._element if self.is_present() else value
+
+    def or_else_get(self, supplier):
+        """Returns the value if present, or calls a 'supplier' function otherwise.
+        Safe alternative to get() method."""
+        return self._element if self.is_present() else supplier()

pyrio/stream.py

@@ -0,0 +1,305 @@
+from pyrio.decorator import pre_call, handle_consumed
+from pyrio.exception import IllegalStateError
+from pyrio.iterator import Iterator
+from pyrio.itertools_mixin import ItertoolsMixin
+from pyrio.optional import Optional
+
+
+@pre_call(handle_consumed)
+class Stream(ItertoolsMixin):
+    def __init__(self, iterable):
+        """Creates Stream from a collection"""
+        self._iterable = iterable
+        self._is_consumed = False
+
+    def __iter__(self):
+        return iter(self._iterable)
+
+    @classmethod
+    def of(cls, *iterable):
+        """Creates Stream from args"""
+        return cls(iterable)
+
+    @classmethod
+    def empty(cls):
+        """Creates empty Stream"""
+        return cls([])
+
+    @classmethod
+    def iterate(cls, seed, operation):
+        """Creates infinite ordered Stream"""
+        return cls(Iterator.iterate(seed, operation))
+
+    @classmethod
+    def generate(cls, supplier):
+        """Creates infinite unordered Stream with values generated by given supplier function"""
+        return cls(Iterator.generate(supplier))
+
+    @classmethod
+    def constant(cls, element):
+        """Creates infinite Stream with given value"""
+        return cls.generate(lambda: element)
+
+    @staticmethod
+    def concat(*streams):
+        """Concatenates several streams together or add new streams to the current one"""
+        return Stream(Iterator.concat(*streams))
+
+    def prepend(self, *iterable):
+        """Prepends iterable to current stream"""
+        self._iterable = Iterator.concat(iterable, self._iterable)
+        return self
+
+    def filter(self, predicate):
+        """Filters values in stream based on given predicate function"""
+        self._iterable = Iterator.filter(self._iterable, predicate)
+        return self
+
+    def map(self, mapper):
+        """Returns a stream consisting of the results of applying the given function to the elements of this stream"""
+        self._iterable = Iterator.map(self._iterable, mapper)
+        return self
+
+    def filter_map(self, mapper, *, falsy=False):
+        """Filters out all None or falsy values and applies mapper function to the elements of the stream"""
+        self._iterable = Iterator.filter_map(self._iterable, mapper, falsy)
+        return self
+
+    def flat_map(self, mapper):
+        """Maps each element of the stream and yields the elements of the produced iterators"""
+        self._iterable = Iterator.flat_map(self._iterable, mapper)
+        return self
+
+    def flatten(self):
+        """Converts a Stream of multidimensional collection into a one-dimensional"""
+        self._iterable = Iterator.flatten(self._iterable)
+        return self
+
+    def for_each(self, operation):
+        """Performs an action for each element of this stream"""
+        return Iterator.for_each(self._iterable, operation)
+
+    def peek(self, operation):
+        """Performs the provided operation on each element of the stream without consuming it"""
+        self._iterable = Iterator.peek(self._iterable, operation)
+        return self
+
+    def reduce(self, 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"""
+        return Optional.of_nullable(Iterator.reduce(self._iterable, accumulator, identity))
+
+    def distinct(self):
+        """Returns a stream with the distinct elements of the current one"""
+        self._iterable = Iterator.distinct(self._iterable)
+        return self
+
+    def count(self):
+        """Returns the count of elements in the stream"""
+        return len(tuple(self._iterable))
+
+    def sum(self):
+        """Sums the elements of the stream"""
+        if len(self._iterable) == 0:
+            return 0
+        if any(isinstance(x, (int | float | None)) for x in self._iterable) is False:
+            raise ValueError("Cannot apply sum on non-number elements")
+        return sum(self._iterable)
+
+    def skip(self, count):
+        """Discards the first n elements of the stream and returns a new stream with the remaining ones"""
+        if count < 0:
+            raise ValueError("Skip count cannot be negative")
+        self._iterable = Iterator.skip(self._iterable, count)
+        return self
+
+    def limit(self, count):
+        """Returns a stream with the first n elements, or fewer if the underlying iterator ends sooner"""
+        if count < 0:
+            raise ValueError("Limit count cannot be negative")
+        self._iterable = Iterator.limit(self._iterable, count)
+        return self
+
+    def head(self, count):
+        """Alias for 'limit'"""
+        if count < 0:
+            raise ValueError("Head count cannot be negative")
+        self._iterable = Iterator.limit(self._iterable, count)
+        return self
+
+    def tail(self, count):
+        """Returns a stream with the last n elements, or fewer if the underlying iterator ends sooner"""
+        if count < 0:
+            raise ValueError("Tail count cannot be negative")
+        self._iterable = Iterator.tail(self._iterable, count)
+        return self
+
+    def take_while(self, predicate):
+        """Returns a stream that yields elements based on a predicate"""
+        self._iterable = Iterator.take_while(self._iterable, predicate)
+        return self
+
+    def drop_while(self, predicate):
+        """Returns a stream that skips elements based on a predicate and yields the remaining ones"""
+        self._iterable = Iterator.drop_while(self._iterable, predicate)
+        return self
+
+    def find_first(self, predicate=None):
+        """Searches for an element of the stream that satisfies a predicate.
+        Returns an Optional with the first found value, if any, or None"""
+        return Optional.of_nullable(next(filter(predicate, self._iterable), None))
+
+    def find_any(self, predicate=None):
+        """Searches for an element of the stream that satisfies a predicate.
+        Returns an Optional with some of the found values, if any, or None"""
+        import random
+
+        if predicate:
+            self.filter(predicate)
+        try:
+            return Optional.of(random.choice(list(self._iterable)))
+        except IndexError:
+            return Optional.of_nullable(None)
+
+    def any_match(self, predicate):
+        """Returns whether any elements of the stream match the given predicate"""
+        return any(predicate(i) for i in self._iterable)
+
+    def all_match(self, predicate):
+        """Returns whether all elements of the stream match the given predicate"""
+        return all(predicate(i) for i in self._iterable)
+
+    def none_match(self, predicate):
+        """Returns whether no elements of the stream match the given predicate"""
+        return not all(predicate(i) for i in self._iterable)
+
+    def min(self, comparator=None, default=None):
+        """Returns the minimum element of the stream according to the given comparator"""
+        return Optional.of_nullable(min(self._iterable, key=comparator, default=default))
+
+    def max(self, comparator=None, default=None):
+        """Returns the maximum element of the stream according to the given comparator"""
+        return Optional.of_nullable(max(self._iterable, key=comparator, default=default))
+
+    def compare_with(self, other, comparator=None):
+        """Compares current stream with another one based on a given comparator"""
+        return Iterator.compare_with(self._iterable, other, comparator)
+
+    def sorted(self, comparator=None, *, reverse=False):
+        """Sorts the elements of the current stream according to natural order or based on the given comparator.
+        If 'reverse' flag is True, the elements are sorted in descending order"""
+        self._iterable = Iterator.sorted(self._iterable, comparator, reverse)
+        return self
+
+    # ### collectors ###
+    def collect(self, collection_type, dict_collector=None, dict_merger=None):
+        """Returns a collections from the stream.
+
+        In case of dict:
+        The 'dict_collector' function receives an element from the stream and returns a (key, value) pair
+        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"""
+        import builtins
+
+        match collection_type:
+            case builtins.tuple:
+                return self.to_tuple()
+            case builtins.list:
+                return self.to_list()
+            case builtins.set:
+                return self.to_set()
+            case builtins.dict:
+                if dict_collector is None:
+                    raise ValueError("Missing dict_collector")
+                return self.to_dict(dict_collector, dict_merger)
+            case _:
+                raise ValueError("Invalid collection type")
+
+    def to_list(self):
+        """Returns a list of the elements of the current stream"""
+        return list(self._iterable)
+
+    def to_tuple(self):
+        """Returns a tuple of the elements of the current stream"""
+        return tuple(self._iterable)
+
+    def to_set(self):
+        """Returns a set of the elements of the current stream"""
+        return set(self._iterable)
+
+    def to_dict(self, collector, merger=None):
+        """Returns a dict of the elements of the current stream.
+
+        The 'collector' function receives an element from the stream and returns a (key, value) pair
+        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"""
+        result = {}
+        for k, v in (collector(i) for i in self._iterable):
+            if k in result:
+                if merger is None:
+                    raise IllegalStateError(f"Key '{k}' already exists")
+                v = merger(result[k], v)
+            result[k] = v
+        return result
+
+    def group_by(self, classifier=None, collector=None):
+        if collector is None:
+            return {key: list(group) for key, group in self._group_by(classifier)}
+
+        result = {}
+        for key, group in self._group_by(classifier):
+            key, group = collector(key, list(group))
+            if hasattr(group, "__iter__"):
+                if key not in result:
+                    result[key] = []
+                result[key] += group
+            else:
+                result[key] = group
+        return result
+
+    def _group_by(self, classifier=None):
+        # https://docs.python.org/3/library/itertools.html#itertools.groupby
+        classifier = (lambda x: x) if classifier is None else classifier
+        iterator = iter(self._iterable)
+        exhausted = False
+
+        def _grouper(target_key):
+            nonlocal curr_value, curr_key, exhausted
+            yield curr_value
+            for curr_value in iterator:
+                curr_key = classifier(curr_value)
+                if curr_key != target_key:
+                    return
+                yield curr_value
+            exhausted = True
+
+        try:
+            curr_value = next(iterator)
+        except StopIteration:
+            return
+        curr_key = classifier(curr_value)
+
+        while not exhausted:
+            target_key = curr_key
+            curr_group = _grouper(target_key)
+            yield curr_key, curr_group
+            if curr_key == target_key:
+                for _ in curr_group:
+                    pass
+
+    def quantify(self, predicate=bool):
+        """Count how many of the elements are Truthy or evaluate to True based on a given predicate"""
+        return sum(self.map(predicate))
+
+    # NB: give access to handle_consumed decorator to toggle flag
+    def take_nth(self, idx, default=None):
+        """Returns Optional with the nth element of the stream or a default value"""
+        return super().take_nth(idx, default)
+
+    def all_equal(self, key=None):
+        """Returns True if all elements of the stream are equal to each other"""
+        return super().all_equal(key)

pyrio-1.0.0.dist-info/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 Kaloyan Ivanov
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

pyrio-1.0.0.dist-info/METADATA

@@ -0,0 +1,25 @@
+Metadata-Version: 2.1
+Name: pyrio
+Version: 1.0.0
+Summary: Java-inspired Streams Api
+Author: kaliv0
+Author-email: kaloyan.ivanov88@gmail.com
+Requires-Python: >=3.12,<4.0
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.12
+Description-Content-Type: text/markdown
+
+<p align="center">
+  <img src="https://github.com/kaliv0/pyrio/blob/main/assets/Pyrio.jpg?raw=true" width="400" alt="Pyrio">
+</p>
+
+# pyrio
+
+
+![Python 3.x](https://img.shields.io/badge/python-3.12-blue?style=flat-square&logo=Python&logoColor=white)
+[![tests](https://img.shields.io/github/actions/workflow/status/kaliv0/pyrio/ci.yml)](https://github.com/kaliv0/pyrio/actions/workflows/ci.yml)
+[![codecov](https://codecov.io/gh/kaliv0/pyrio/graph/badge.svg?token=7EEG43BL33)](https://codecov.io/gh/kaliv0/pyrio)
+[![PyPI](https://img.shields.io/pypi/v/pyrio.svg)](https://pypi.org/project/pyrio/)
+
+<br>Java-inspired Streams Api
+

pyrio-1.0.0.dist-info/RECORD

@@ -0,0 +1,11 @@
+pyrio/__init__.py,sha256=HkXoOFVMiDnGl7AdnEgN2q4WReQhR2SmMDXt2w72D-I,80
+pyrio/decorator.py,sha256=tKGcY1s1zopEqHK21m-ndLUhcXSc9ahUaNN53uXj6U8,1182
+pyrio/exception.py,sha256=UXFw_3F1jrvPY0dD-UDFvcpogxzM_N2CNhsNoJq2N-U,139
+pyrio/iterator.py,sha256=aAXQUjq5z80ZFkIRxmYHpld8X4JT7Cgk2gDZexkfDkU,3284
+pyrio/itertools_mixin.py,sha256=qOPojN_hg3uGih1EaylkIHX_Epxc3Qg8sRdKBNt_Mzo,8633
+pyrio/optional.py,sha256=a277B0b7DLsKinnJMvjqmYm3oKAryGhJDHyyVOKsDCY,2091
+pyrio/stream.py,sha256=PLOyn6KSpDfq2VoazxsrWOCGv22EaBNDS3HGW73B-0c,12025
+pyrio-1.0.0.dist-info/LICENSE,sha256=frOVyHZrx5o-fh5xC-kggT3MaLdp6yxV_YGpVXFHFSQ,1071
+pyrio-1.0.0.dist-info/METADATA,sha256=PV5VNxjzVxZHj8-u2kuy7iSTshKXA9t0njy0B4cluiE,935
+pyrio-1.0.0.dist-info/WHEEL,sha256=sP946D7jFCHeNz5Iq4fL4Lu-PrWrFsgfLXbbkciIZwg,88
+pyrio-1.0.0.dist-info/RECORD,,

pyrio-1.0.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: poetry-core 1.9.0
+Root-Is-Purelib: true
+Tag: py3-none-any