iker-python-common 1.0.29__tar.gz → 1.0.31__tar.gz

{iker_python_common-1.0.29 → iker_python_common-1.0.31}/.github/workflows/pr.yml

@@ -21,6 +21,7 @@ jobs:
 
       - name: Build and Test
         run: |
+          sudo apt-get update
           sudo apt-get install libxml2-dev libxslt1-dev llvm-14-dev
           python -m pip install --upgrade pip
           python -m pip install .[test]
@@ -39,6 +40,7 @@ jobs:
 
       - name: Build and Test
         run: |
+          sudo apt-get update
           sudo apt-get install libxml2-dev libxslt1-dev llvm-14-dev
           python -m pip install --upgrade pip
           python -m pip install .[test]
@@ -57,6 +59,7 @@ jobs:
 
       - name: Build and Test
         run: |
+          sudo apt-get update
           sudo apt-get install libxml2-dev libxslt1-dev llvm-14-dev
           python -m pip install --upgrade pip
           python -m pip install .[test]

{iker_python_common-1.0.29 → iker_python_common-1.0.31}/.github/workflows/push.yml

@@ -21,6 +21,7 @@ jobs:
 
       - name: Build and Upload
         run: |
+          sudo apt-get update
           sudo apt-get install libxml2-dev libxslt1-dev llvm-14-dev
           python -m pip install --upgrade pip build twine
           python -m pip install .[test]

{iker_python_common-1.0.29 → iker_python_common-1.0.31}/PKG-INFO

@@ -1,6 +1,6 @@
-Metadata-Version: 2.2
+Metadata-Version: 2.4
 Name: iker-python-common
-Version: 1.0.29
+Version: 1.0.31
 Classifier: Programming Language :: Python :: 3
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12

{iker_python_common-1.0.29 → iker_python_common-1.0.31}/src/iker/common/utils/funcutils.py

@@ -9,10 +9,10 @@ __all__ = [
     "unique_returns",
 ]
 
-R = TypeVar("R")
+RT = TypeVar("RT")
 
 
-def singleton(tar: Callable[..., R] = None):
+def singleton(tar: Callable[..., RT] = None):
     def decorator(target):
         if not callable(target):
             raise TypeError("expected a callable")
@@ -30,7 +30,7 @@ def singleton(tar: Callable[..., R] = None):
     return decorator if tar is None else decorator(tar)
 
 
-def memorized(tar: Callable[..., R] = None, *, ordered: bool = False, typed: bool = False):
+def memorized(tar: Callable[..., RT] = None, *, ordered: bool = False, typed: bool = False):
     def decorator(target):
         if not callable(target):
             raise TypeError("expected a callable")
@@ -64,7 +64,7 @@ def memorized(tar: Callable[..., R] = None, *, ordered: bool = False, typed: boo
     return decorator if tar is None else decorator(tar)
 
 
-def lazy(tar: Callable[..., R] = None):
+def lazy(tar: Callable[..., RT] = None):
     def decorator(target):
         if not callable(target):
             raise TypeError("expected a callable")
@@ -78,7 +78,7 @@ def lazy(tar: Callable[..., R] = None):
     return decorator if tar is None else decorator(tar)
 
 
-def unique_returns(tar: Callable[..., R] = None, *, max_trials: int | None = None):
+def unique_returns(tar: Callable[..., RT] = None, *, max_trials: int | None = None):
     def decorator(target):
         if not callable(target):
             raise TypeError("expected a callable")

{iker_python_common-1.0.29 → iker_python_common-1.0.31}/src/iker/common/utils/sequtils.py

@@ -1,7 +1,7 @@
 import functools
 import itertools
 from collections.abc import Callable, Generator, Iterable, Iterator, Sequence, Sized
-from typing import Generic, Self, TypeVar
+from typing import Generic, TypeVar
 
 __all__ = [
     "head",
@@ -22,9 +22,9 @@ __all__ = [
 ]
 
 T = TypeVar("T")
-K = TypeVar("K")
-U = TypeVar("U")
-V = TypeVar("V")
+KT = TypeVar("KT")
+VT = TypeVar("VT")
+TT = TypeVar("TT")
 Tco = TypeVar("Tco", covariant=True)
 
 
@@ -61,10 +61,10 @@ def init(ms: Sequence[T]) -> Sequence[T]:
 
 def grouped(
     ms: Sequence[T],
-    key_func: Callable[[T], K],
+    key_func: Callable[[T], KT],
     keys_ordered: bool = False,
     values_only: bool = False,
-) -> list[tuple[K, list[T]]] | list[list[T]]:
+) -> list[tuple[KT, list[T]]] | list[list[T]]:
     """
     Groups the given list of elements according to key generator function
 
@@ -76,7 +76,7 @@ def grouped(
     """
     if ms is None or len(ms) == 0:
         return []
-    grouped_ms: dict[K, list[T]] = {}
+    grouped_ms: dict[KT, list[T]] = {}
     for m in ms:
         k = key_func(m)
         grouped_ms.setdefault(k, []).append(m)
@@ -148,7 +148,7 @@ def chunk_between(ms: Sequence[T], chunk_func: Callable[[T, T], bool], exclusive
     return chunk(ms, lambda x, y: chunk_func(last(x), y), exclusive_end)
 
 
-def chunk_with_key(ms: Sequence[T], key_func: Callable[[T], K], exclusive_end: bool = False) -> list[list[T]]:
+def chunk_with_key(ms: Sequence[T], key_func: Callable[[T], KT], exclusive_end: bool = False) -> list[list[T]]:
     return chunk_between(ms, lambda x, y: key_func(x) != key_func(y), exclusive_end)
 
 
@@ -185,8 +185,11 @@ def merge_chunks(
     return merged_chunks
 
 
+SeqT = TypeVar("SeqT", bound="Seq")
+
+
 class Seq(Generic[Tco], Sequence[Tco], Sized):
-    def __init__(self, data: Iterable[Tco] | Self):
+    def __init__(self, data: Iterable[Tco] | SeqT):
         if isinstance(data, Seq):
             self.data = data.data
         elif isinstance(data, Iterable):
@@ -202,14 +205,14 @@ class Seq(Generic[Tco], Sequence[Tco], Sized):
     def empty(self) -> bool:
         return self.size == 0
 
-    def __add__(self, other: Self) -> Self:
+    def __add__(self: SeqT, other: SeqT) -> SeqT:
         return self.concat(other)
 
-    def __getitem__(self, item):
+    def __getitem__(self: SeqT, item) -> SeqT:
         if isinstance(item, slice):
-            return Seq(self.data[item])
+            return type(self)(self.data[item])
         elif isinstance(item, int):
-            return Seq([self.data[item]])
+            return type(self)([self.data[item]])
         raise ValueError("unsupported index type")
 
     def __len__(self) -> int:
@@ -230,28 +233,28 @@ class Seq(Generic[Tco], Sequence[Tco], Sized):
     def count_if(self, func: Callable[[Tco], bool]):
         return sum(1 for item in self.data if func(item))
 
-    def concat(self, other: Self) -> Self:
-        return Seq(self.data + other.data)
+    def concat(self: SeqT, other: SeqT) -> SeqT:
+        return type(self)(self.data + other.data)
 
-    def take_left(self, n: int) -> Self:
+    def take_left(self: SeqT, n: int) -> SeqT:
         if n <= 0:
-            return Seq([])
+            return type(self)([])
         return self[:n]
 
-    def take_right(self, n: int) -> Self:
+    def take_right(self: SeqT, n: int) -> SeqT:
         if n <= 0:
-            return Seq([])
+            return type(self)([])
         return self[-n:]
 
     take = take_left
 
-    def reverse(self) -> Self:
-        return Seq(reversed(self.data))
+    def reverse(self: SeqT) -> SeqT:
+        return type(self)(reversed(self.data))
 
-    def distinct(self) -> Self:
-        return Seq(list(set(self.data)))
+    def distinct(self: SeqT) -> SeqT:
+        return type(self)(sorted(set(self.data)))
 
-    def scan_left(self, zero: U | None, func: Callable[[U, Tco], U]) -> "Seq[U]":
+    def scan_left(self, zero: TT | None, func: Callable[[TT, Tco], TT]) -> "Seq[TT]":
         def scan():
             accum = zero
             for elem in self.data:
@@ -260,7 +263,7 @@ class Seq(Generic[Tco], Sequence[Tco], Sized):
 
         return Seq(scan())
 
-    def scan_right(self, zero: U | None, func: Callable[[U, Tco], U]) -> "Seq[U]":
+    def scan_right(self, zero: TT | None, func: Callable[[TT, Tco], TT]) -> "Seq[TT]":
         def scan():
             accum = zero
             for elem in reversed(self.data):
@@ -271,10 +274,10 @@ class Seq(Generic[Tco], Sequence[Tco], Sized):
 
     scan = scan_left
 
-    def map(self, func: Callable[[Tco], U]) -> "Seq[U]":
+    def map(self, func: Callable[[Tco], TT]) -> "Seq[TT]":
         return self.scan(None, lambda x, y: func(y))
 
-    def fold_left(self, zero: U | None, func: Callable[[U, Tco], U]) -> "Seq[U]":
+    def fold_left(self, zero: TT | None, func: Callable[[TT, Tco], TT]) -> "Seq[TT]":
         if self.empty:
             return Seq([]) if zero is None else Seq([zero])
         data = self.data if zero is None else [zero] + self.data
@@ -283,7 +286,7 @@ class Seq(Generic[Tco], Sequence[Tco], Sized):
             accum = func(accum, elem)
         return Seq([accum])
 
-    def fold_right(self, zero: U | None, func: Callable[[U, Tco], U]) -> "Seq[U]":
+    def fold_right(self, zero: TT | None, func: Callable[[TT, Tco], TT]) -> "Seq[TT]":
         if self.empty:
             return Seq([]) if zero is None else Seq([zero])
         data = self.data if zero is None else self.data + [zero]
@@ -294,18 +297,18 @@ class Seq(Generic[Tco], Sequence[Tco], Sized):
 
     fold = fold_left
 
-    def reduce(self, func: Callable[[Tco, Tco], Tco]) -> Self:
-        return self.fold(None, lambda x, y: func(x, y))
+    def reduce(self: SeqT, func: Callable[[Tco, Tco], Tco]) -> SeqT:
+        return type(self)(self.fold(None, lambda x, y: func(x, y)))
 
-    def max(self, func: Callable[[Tco, Tco], bool] = None) -> Self:
+    def max(self: SeqT, func: Callable[[Tco, Tco], bool] = None) -> SeqT:
         func = func or (lambda x, y: x > y)
         return self.reduce(lambda x, y: x if func(x, y) else y)
 
-    def min(self, func: Callable[[Tco, Tco], bool] = None) -> Self:
+    def min(self: SeqT, func: Callable[[Tco, Tco], bool] = None) -> SeqT:
         func = func or (lambda x, y: x < y)
         return self.reduce(lambda x, y: x if func(x, y) else y)
 
-    def group(self, func: Callable[[Tco], K]) -> "Seq[tuple[K, list[Tco]]]":
+    def group(self, func: Callable[[Tco], KT]) -> "Seq[tuple[KT, list[Tco]]]":
         return Seq(grouped(self.data, key_func=func, keys_ordered=True))
 
     def keys(self):
@@ -317,13 +320,13 @@ class Seq(Generic[Tco], Sequence[Tco], Sized):
     def swap(self):
         return Seq((value, key) for key, value in self.data)
 
-    def map_keys(self, func: Callable[[Tco], U]) -> Self:
+    def map_keys(self, func: Callable[[Tco], TT]):
         return Seq((func(key), value) for key, value in self.data)
 
-    def map_values(self, func: Callable[[Tco], U]) -> Self:
+    def map_values(self, func: Callable[[Tco], TT]):
         return Seq((key, func(value)) for key, value in self.data)
 
-    def flat_map(self, func: Callable[[Tco], Iterable[U]]) -> "Seq[U]":
+    def flat_map(self, func: Callable[[Tco], Iterable[TT]]) -> "Seq[TT]":
         data = []
         for d in self.data:
             data.extend(func(d))
@@ -332,31 +335,31 @@ class Seq(Generic[Tco], Sequence[Tco], Sized):
     def flatten(self):
         return self.flat_map(lambda x: list(x))
 
-    def group_map(self, group_func: Callable[[Tco], K], map_func: Callable[[Tco], U]) -> "Seq[tuple[K, list[U]]]":
+    def group_map(self, group_func: Callable[[Tco], KT], map_func: Callable[[Tco], TT]) -> "Seq[tuple[KT, list[TT]]]":
         return self.group(group_func).map_values(lambda x: list(map(map_func, x)))
 
-    def filter(self, func: Callable[[Tco], bool]) -> Self:
-        return Seq(filter(func, self.data))
+    def filter(self: SeqT, func: Callable[[Tco], bool]) -> SeqT:
+        return type(self)(filter(func, self.data))
 
-    def filter_not(self, func: Callable[[Tco], bool]) -> Self:
+    def filter_not(self: SeqT, func: Callable[[Tco], bool]) -> SeqT:
         return self.filter(lambda x: not func(x))
 
-    def sort(self, func: Callable[[Tco], K]) -> Self:
-        return Seq(sorted(self.data, key=func))
+    def sort(self: SeqT, func: Callable[[Tco], KT]) -> SeqT:
+        return type(self)(sorted(self.data, key=func))
 
-    def head(self) -> Self:
-        return Seq([head(self.data)])
+    def head(self: SeqT) -> SeqT:
+        return type(self)([head(self.data)])
 
-    def last(self) -> Self:
-        return Seq([last(self.data)])
+    def last(self: SeqT) -> SeqT:
+        return type(self)([last(self.data)])
 
-    def init(self) -> Self:
-        return Seq(init(self.data))
+    def init(self: SeqT) -> SeqT:
+        return type(self)(init(self.data))
 
-    def tail(self) -> Self:
-        return Seq(tail(self.data))
+    def tail(self: SeqT) -> SeqT:
+        return type(self)(tail(self.data))
 
-    def foreach(self, func: Callable[[Tco], None]) -> Self:
+    def foreach(self: SeqT, func: Callable[[Tco], None]) -> SeqT:
         for elem in self.data:
             func(elem)
         return self
@@ -367,16 +370,16 @@ class Seq(Generic[Tco], Sequence[Tco], Sized):
     def forall(self, func: Callable[[Tco], bool]) -> "Seq[bool]":
         return Seq([all(map(func, self.data))])
 
-    def union(self, other: Self) -> Self:
-        return Seq(list(set(self.data).union(set(other.data))))
+    def union(self: SeqT, other: SeqT) -> SeqT:
+        return type(self)(sorted(set(self.data).union(set(other.data))))
 
-    def intersect(self, other: Self) -> Self:
-        return Seq(list(set(self.data).intersection(set(other.data))))
+    def intersect(self: SeqT, other: SeqT) -> SeqT:
+        return type(self)(sorted(set(self.data).intersection(set(other.data))))
 
-    def zip(self, other: "Seq[U]") -> "Seq[tuple[Tco, U]]":
+    def zip(self, other: "Seq[TT]") -> "Seq[tuple[Tco, TT]]":
         return Seq(zip(self.data, other.data))
 
-    def zip_fill(self, other: "Seq[U]", fill: Tco | U | None = None) -> "Seq[tuple[Tco, U]]":
+    def zip_fill(self, other: "Seq[TT]", fill: Tco | TT | None = None) -> "Seq[tuple[Tco, TT]]":
         return Seq(itertools.zip_longest(self.data, other.data, fillvalue=fill))
 
 

{iker_python_common-1.0.29 → iker_python_common-1.0.31}/src/iker_python_common.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
-Metadata-Version: 2.2
+Metadata-Version: 2.4
 Name: iker-python-common
-Version: 1.0.29
+Version: 1.0.31
 Classifier: Programming Language :: Python :: 3
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12

{iker_python_common-1.0.29 → iker_python_common-1.0.31}/test/iker_tests/common/utils/sequtils_test.py

@@ -1,7 +1,11 @@
 import unittest
+from collections.abc import Iterable
+from dataclasses import dataclass
+from typing import Self
 
 import ddt
 
+from iker.common.utils.sequtils import Seq
 from iker.common.utils.sequtils import batch_yield
 from iker.common.utils.sequtils import chunk, chunk_between, chunk_with_key, merge_chunks
 from iker.common.utils.sequtils import deduped, grouped
@@ -790,6 +794,26 @@ class SeqUtilsTest(unittest.TestCase):
         self.assertEqual(expect, merge_chunks(data, merge_func=merge_func, drop_exclusive_end=True))
 
 
+@dataclass(frozen=True, eq=True, order=True)
+class Naming(object):
+    serial: int
+    name: str
+    gender: str
+
+
+class NamingSeq(Seq[Naming]):
+
+    def __init__(self, data: Iterable[Naming]):
+        super(NamingSeq, self).__init__(data)
+        self.serials = list(map(lambda x: x.serial, self.data))
+
+    def identity(self) -> Self:
+        return self
+
+    def axis(self) -> list[int]:
+        return self.serials
+
+
 @ddt.ddt
 class SeqTest(unittest.TestCase):
 
@@ -1315,3 +1339,100 @@ class SeqTest(unittest.TestCase):
     def test_zip_fill(self, a, b, fill, expect):
         actual = seq(a).zip_fill(seq(b), fill)
         self.assertEqual(actual.data, expect)
+
+    def test_naming_seq(self):
+        names = [
+            ("Andrew", "M"),
+            ("Alice", "W"),
+            ("Benjamin", "M"),
+            ("Bella", "W"),
+            ("Charles", "M"),
+            ("Charlotte", "W"),
+            ("Daniel", "M"),
+            ("Diana", "W"),
+            ("Ethan", "M"),
+            ("Emily", "W"),
+            ("Felix", "M"),
+            ("Fiona", "W"),
+            ("George", "M"),
+            ("Grace", "W"),
+            ("Henry", "M"),
+            ("Hannah", "W"),
+            ("Isaac", "M"),
+            ("Isabella", "W"),
+            ("Jacob", "M"),
+            ("Julia", "W"),
+            ("Kevin", "M"),
+            ("Katherine", "W"),
+            ("Liam", "M"),
+            ("Lily", "W"),
+            ("Michael", "M"),
+            ("Madison", "W"),
+            ("Nathan", "M"),
+            ("Natalie", "W"),
+            ("Oliver", "M"),
+            ("Olivia", "W"),
+            ("Patrick", "M"),
+            ("Penelope", "W"),
+            ("Quentin", "M"),
+            ("Quinn", "W"),
+            ("Ryan", "M"),
+            ("Rebecca", "W"),
+            ("Samuel", "M"),
+            ("Sophia", "W"),
+            ("Thomas", "M"),
+            ("Tiffany", "W"),
+            ("Ulysses", "M"),
+            ("Ursula", "W"),
+            ("Victor", "M"),
+            ("Victoria", "W"),
+            ("William", "M"),
+            ("Wendy", "W"),
+            ("Xavier", "M"),
+            ("Xenia", "W"),
+            ("Yosef", "M"),
+            ("Yvonne", "W"),
+            ("Zachary", "M"),
+            ("Zoe", "W"),
+        ]
+        naming_seq = NamingSeq(Naming(serial, name, gender) for serial, (name, gender) in enumerate(names))
+
+        self.assertEqual(naming_seq, naming_seq)
+        self.assertEqual(naming_seq.concat(naming_seq).axis(), list(range(0, 52)) + list(range(0, 52)))
+        self.assertEqual(naming_seq.take_left(26).axis(), list(range(0, 26)))
+        self.assertEqual(naming_seq.take_right(26).axis(), list(range(26, 52)))
+        self.assertEqual(naming_seq.reverse().axis(), list(reversed(range(0, 52))))
+        self.assertEqual(naming_seq.distinct().axis(), list(range(0, 52)))
+        self.assertEqual(naming_seq.reduce(lambda x, y: x).axis(), [0])
+        self.assertEqual(naming_seq.reduce(lambda x, y: y).axis(), [51])
+        self.assertEqual(naming_seq.min(lambda x, y: x.serial < y.serial).axis(), [0])
+        self.assertEqual(naming_seq.max(lambda x, y: x.serial > y.serial).axis(), [51])
+        self.assertEqual(naming_seq.filter(lambda x: x.gender == "M").axis(), list(range(0, 52, 2)))
+        self.assertEqual(naming_seq.filter(lambda x: x.gender == "W").axis(), list(range(1, 52, 2)))
+        self.assertEqual(naming_seq.filter_not(lambda x: x.gender == "M").axis(),
+                         naming_seq.filter(lambda x: x.gender == "W").axis())
+        self.assertEqual(naming_seq.filter_not(lambda x: x.gender == "W").axis(),
+                         naming_seq.filter(lambda x: x.gender == "M").axis())
+        self.assertEqual(naming_seq.sort(lambda x: -x.serial).axis(), naming_seq.reverse().axis())
+        self.assertEqual(naming_seq.head().axis(), [0])
+        self.assertEqual(naming_seq.last().axis(), [51])
+        self.assertEqual(naming_seq.init().axis(), list(range(0, 51)))
+        self.assertEqual(naming_seq.tail().axis(), list(range(1, 52)))
+        self.assertEqual(naming_seq.foreach(lambda x: x).data, naming_seq.data)
+        self.assertEqual(naming_seq.union(naming_seq).data, naming_seq.data)
+        self.assertEqual(naming_seq.intersect(naming_seq).data, naming_seq.data)
+
+        self.assertEqual(naming_seq.scan_left(0, lambda x, y: x + y.serial).data,
+                         seq(range(0, 52)).scan_left(0, lambda x, y: x + y).data)
+        self.assertEqual(naming_seq.scan_right(0, lambda x, y: x + y.serial).data,
+                         seq(range(0, 52)).scan_right(0, lambda x, y: x + y).data)
+        self.assertEqual(naming_seq.map(lambda x: x.serial).data, list(range(0, 52)))
+
+        self.assertEqual(naming_seq.fold_left(0, lambda x, y: x + y.serial).data,
+                         seq(range(0, 52)).fold_left(0, lambda x, y: x + y).data)
+        self.assertEqual(naming_seq.fold_right(0, lambda x, y: x + y.serial).data,
+                         seq(range(0, 52)).fold_right(0, lambda x, y: x + y).data)
+
+        self.assertEqual(naming_seq.group(lambda x: x.serial % 2).size, 2)
+        self.assertEqual(naming_seq.group(lambda x: x.gender).size, 2)
+        self.assertEqual(naming_seq.group(lambda x: x.name[0]).size, 26)