iker-python-common 1.0.8__tar.gz → 1.0.9__tar.gz

{iker_python_common-1.0.8 → iker_python_common-1.0.9}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: iker-python-common
-Version: 1.0.8
+Version: 1.0.9
 Classifier: Programming Language :: Python :: 3
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12

{iker_python_common-1.0.8 → iker_python_common-1.0.9}/src/iker/common/utils/dbutils.py

@@ -1,7 +1,7 @@
 import contextlib
 import dataclasses
 import urllib.parse
-from typing import Any, ContextManager, Type
+from typing import Any
 
 import psycopg
 import pymysql
@@ -87,13 +87,13 @@ class ConnectionMaker(object):
     def make_connection(self):
         return self.engine.connect()
 
-    def make_session(self, **kwargs) -> ContextManager[sqlalchemy.orm.Session]:
+    def make_session(self, **kwargs) -> contextlib.AbstractContextManager[sqlalchemy.orm.Session]:
         return contextlib.closing(sqlalchemy.orm.sessionmaker(self.engine, **{**self.session_opts, **kwargs})())
 
-    def create_model(self, orm_base: Type[sqlalchemy.orm.DeclarativeBase]):
+    def create_model(self, orm_base: type[sqlalchemy.orm.DeclarativeBase]):
         orm_base.metadata.create_all(self.engine)
 
-    def drop_model(self, orm_base: Type[sqlalchemy.orm.DeclarativeBase]):
+    def drop_model(self, orm_base: type[sqlalchemy.orm.DeclarativeBase]):
         orm_base.metadata.drop_all(self.engine)
 
     def execute(self, sql: str, **params):

{iker_python_common-1.0.8 → iker_python_common-1.0.9}/src/iker/common/utils/dockerutils.py

@@ -1,7 +1,8 @@
 import contextlib
 import re
+from collections.abc import Iterable
 from dataclasses import dataclass
-from typing import Any, ContextManager, Iterable
+from typing import Any
 
 import docker
 import docker.errors
@@ -67,7 +68,11 @@ class ImageName(object):
         return None
 
 
-def docker_create_client(registry: str, username: str, password: str) -> ContextManager[docker.DockerClient]:
+def docker_create_client(
+    registry: str,
+    username: str,
+    password: str,
+) -> contextlib.AbstractContextManager[docker.DockerClient]:
     try:
         client = docker.DockerClient()
         client.login(registry=registry, username=username, password=password, reauth=True)

{iker_python_common-1.0.8 → iker_python_common-1.0.9}/src/iker/common/utils/funcutils.py

@@ -1,5 +1,6 @@
 import functools
-from typing import Callable, TypeVar
+from collections.abc import Callable
+from typing import TypeVar
 
 __all__ = [
     "singleton",

{iker_python_common-1.0.8 → iker_python_common-1.0.9}/src/iker/common/utils/numutils.py

@@ -1,9 +1,10 @@
 from __future__ import annotations
 
 import math
+from collections.abc import Callable, Sequence
 from decimal import Decimal
 from numbers import Real
-from typing import Any, Callable, Sequence, TypeVar
+from typing import Any, TypeVar
 
 import numpy as np
 

{iker_python_common-1.0.8 → iker_python_common-1.0.9}/src/iker/common/utils/s3utils.py

@@ -5,7 +5,6 @@ import mimetypes
 import os
 import tempfile
 from dataclasses import dataclass
-from typing import ContextManager
 
 import boto3
 from botocore.client import BaseClient
@@ -39,7 +38,7 @@ def s3_make_client(
     secret_access_key: str = None,
     region_name: str = None,
     endpoint_url: str = None,
-) -> ContextManager[BaseClient]:
+) -> contextlib.AbstractContextManager[BaseClient]:
     """
     Makes an AWS S3 client
 

{iker_python_common-1.0.8 → iker_python_common-1.0.9}/src/iker/common/utils/sequtils.py

@@ -2,7 +2,8 @@ from __future__ import annotations
 
 import functools
 import itertools
-from typing import Callable, Generator, Generic, Iterable, Self, Sequence, TypeVar
+from collections.abc import Callable, Generator, Iterable, Iterator, Sequence, Sized
+from typing import Generic, Self, TypeVar
 
 __all__ = [
     "head",
@@ -26,6 +27,7 @@ T = TypeVar("T")
 K = TypeVar("K")
 U = TypeVar("U")
 V = TypeVar("V")
+Tco = TypeVar("Tco", covariant=True)
 
 
 # See Haskell's list operations head, tail, init, and last
@@ -185,8 +187,8 @@ def merge_chunks(
     return merged_chunks
 
 
-class Seq(Generic[T]):
-    def __init__(self, data: Iterable[T] | Self):
+class Seq(Generic[Tco], Sequence[Tco], Sized):
+    def __init__(self, data: Iterable[Tco] | Self):
         if isinstance(data, Seq):
             self.data = data.data
         elif isinstance(data, Iterable):
@@ -195,12 +197,12 @@ class Seq(Generic[T]):
             raise ValueError("unsupported data type")
 
     @property
-    def count(self) -> int:
+    def size(self) -> int:
         return len(self.data)
 
     @property
     def empty(self) -> bool:
-        return self.count == 0
+        return self.size == 0
 
     def __add__(self, other: Self) -> Self:
         return self.concat(other)
@@ -212,6 +214,24 @@ class Seq(Generic[T]):
             return Seq([self.data[item]])
         raise ValueError("unsupported index type")
 
+    def __len__(self) -> int:
+        return len(self.data)
+
+    def __contains__(self, item) -> bool:
+        return item in self.data
+
+    def __iter__(self) -> Iterator[Tco]:
+        return iter(self.data)
+
+    def __reversed__(self) -> Iterator[Tco]:
+        return reversed(self.data)
+
+    def count(self, elem: Tco):
+        return self.count_if(lambda x: x == elem)
+
+    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)
 
@@ -229,7 +249,7 @@ class Seq(Generic[T]):
     def distinct(self) -> Self:
         return Seq(list(set(self.data)))
 
-    def scan_left(self, zero: U | None, func: Callable[[U, T], U]) -> "Seq[U]":
+    def scan_left(self, zero: U | None, func: Callable[[U, Tco], U]) -> "Seq[U]":
         def scan():
             accum = zero
             for elem in self.data:
@@ -238,7 +258,7 @@ class Seq(Generic[T]):
 
         return Seq(scan())
 
-    def scan_right(self, zero: U | None, func: Callable[[U, T], U]) -> "Seq[U]":
+    def scan_right(self, zero: U | None, func: Callable[[U, Tco], U]) -> "Seq[U]":
         def scan():
             accum = zero
             for elem in reversed(self.data):
@@ -249,10 +269,10 @@ class Seq(Generic[T]):
 
     scan = scan_left
 
-    def map(self, func: Callable[[T], U]) -> "Seq[U]":
+    def map(self, func: Callable[[Tco], U]) -> "Seq[U]":
         return self.scan(None, lambda x, y: func(y))
 
-    def fold_left(self, zero: U | None, func: Callable[[U, T], U]) -> "Seq[U]":
+    def fold_left(self, zero: U | None, func: Callable[[U, Tco], U]) -> "Seq[U]":
         if self.empty:
             return Seq([]) if zero is None else Seq([zero])
         data = self.data if zero is None else [zero] + self.data
@@ -261,7 +281,7 @@ class Seq(Generic[T]):
             accum = func(accum, elem)
         return Seq([accum])
 
-    def fold_right(self, zero: U | None, func: Callable[[U, T], U]) -> "Seq[U]":
+    def fold_right(self, zero: U | None, func: Callable[[U, Tco], U]) -> "Seq[U]":
         if self.empty:
             return Seq([]) if zero is None else Seq([zero])
         data = self.data if zero is None else self.data + [zero]
@@ -272,18 +292,18 @@ class Seq(Generic[T]):
 
     fold = fold_left
 
-    def reduce(self, func: Callable[[T, T], T]) -> Self:
+    def reduce(self, func: Callable[[Tco, Tco], Tco]) -> Self:
         return self.fold(None, lambda x, y: func(x, y))
 
-    def max(self, func: Callable[[T, T], bool] = None) -> Self:
+    def max(self, func: Callable[[Tco, Tco], bool] = None) -> Self:
         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[[T, T], bool] = None) -> Self:
+    def min(self, func: Callable[[Tco, Tco], bool] = None) -> Self:
         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[[T], K]) -> "Seq[tuple[K, list[T]]]":
+    def group(self, func: Callable[[Tco], K]) -> "Seq[tuple[K, list[Tco]]]":
         return Seq(grouped(self.data, key_func=func, keys_ordered=True))
 
     def keys(self):
@@ -295,10 +315,10 @@ class Seq(Generic[T]):
     def swap(self):
         return Seq((value, key) for key, value in self.data)
 
-    def map_keys(self, func: Callable[[T], U]) -> Self:
+    def map_keys(self, func: Callable[[Tco], U]) -> Self:
         return Seq((func(key), value) for key, value in self.data)
 
-    def map_values(self, func: Callable[[T], U]) -> Self:
+    def map_values(self, func: Callable[[Tco], U]) -> Self:
         return Seq((key, func(value)) for key, value in self.data)
 
     def flatten(self):
@@ -307,19 +327,19 @@ class Seq(Generic[T]):
             data.extend(d)
         return Seq(data)
 
-    def flat_map(self, func: Callable[[T], U]) -> "Seq[U]":
+    def flat_map(self, func: Callable[[Tco], U]) -> "Seq[U]":
         return self.flatten().map(func)
 
-    def group_map(self, group_func: Callable[[T], K], map_func: Callable[[T], U]) -> "Seq[tuple[K, list[U]]]":
+    def group_map(self, group_func: Callable[[Tco], K], map_func: Callable[[Tco], U]) -> "Seq[tuple[K, list[U]]]":
         return self.group(group_func).map_values(lambda x: list(map(map_func, x)))
 
-    def filter(self, func: Callable[[T], bool]) -> Self:
+    def filter(self, func: Callable[[Tco], bool]) -> Self:
         return Seq(filter(func, self.data))
 
-    def filter_not(self, func: Callable[[T], bool]) -> Self:
+    def filter_not(self, func: Callable[[Tco], bool]) -> Self:
         return self.filter(lambda x: not func(x))
 
-    def sort(self, func: Callable[[T], K]) -> Self:
+    def sort(self, func: Callable[[Tco], K]) -> Self:
         return Seq(sorted(self.data, key=func))
 
     def head(self) -> Self:
@@ -334,15 +354,15 @@ class Seq(Generic[T]):
     def tail(self) -> Self:
         return Seq(tail(self.data))
 
-    def foreach(self, func: Callable[[T], None]) -> Self:
+    def foreach(self, func: Callable[[Tco], None]) -> Self:
         for elem in self.data:
             func(elem)
         return self
 
-    def exists(self, func: Callable[[T], bool]) -> "Seq[bool]":
+    def exists(self, func: Callable[[Tco], bool]) -> "Seq[bool]":
         return Seq([any(map(func, self.data))])
 
-    def forall(self, func: Callable[[T], bool]) -> "Seq[bool]":
+    def forall(self, func: Callable[[Tco], bool]) -> "Seq[bool]":
         return Seq([all(map(func, self.data))])
 
     def union(self, other: Self) -> Self:
@@ -351,5 +371,11 @@ class Seq(Generic[T]):
     def intersect(self, other: Self) -> Self:
         return Seq(list(set(self.data).intersection(set(other.data))))
 
+    def zip(self, other: Seq[U]) -> Seq[tuple[Tco, U]]:
+        return Seq(zip(self.data, other.data))
+
+    def zip_fill(self, other: Seq[U], fill: Tco | U | None = None) -> Seq[tuple[Tco, U]]:
+        return Seq(itertools.zip_longest(self.data, other.data, fillvalue=fill))
+
 
 seq = Seq

{iker_python_common-1.0.8 → iker_python_common-1.0.9}/src/iker/common/utils/span.py

@@ -2,7 +2,8 @@ from __future__ import annotations
 
 import enum
 import itertools
-from typing import Sequence, TypeVar
+from collections.abc import Sequence
+from typing import TypeVar
 
 __all__ = [
     "SpanRelation",

{iker_python_common-1.0.8 → iker_python_common-1.0.9}/src/iker_python_common.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: iker-python-common
-Version: 1.0.8
+Version: 1.0.9
 Classifier: Programming Language :: Python :: 3
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12

{iker_python_common-1.0.8 → iker_python_common-1.0.9}/test/iker_tests/common/utils/sequtils_test.py

@@ -805,6 +805,84 @@ class SeqUtilsTest(unittest.TestCase):
         actual = seq(data)[item]
         self.assertEqual(actual.data, expect)
 
+    @ddt.data(
+        ([], 0),
+        ([0], 1),
+        ([1, 2, 3, 4, 5], 5),
+    )
+    @ddt.unpack
+    def test_seq_builtin_len(self, data, expect):
+        actual = len(seq(data))
+        self.assertEqual(actual, expect)
+
+    @ddt.data(
+        ([], 0, False),
+        ([0], 0, True),
+        ([0], -1, False),
+        ([1, 2, 3, 4, 5], 0, False),
+        ([1, 2, 3, 4, 5], 1, True),
+        ([1, 2, 3, 4, 5], -1, False),
+    )
+    @ddt.unpack
+    def test_seq_builtin_contains(self, data, item, expect):
+        actual = item in seq(data)
+        self.assertEqual(actual, expect)
+
+    @ddt.data(
+        ([], []),
+        ([0], [0]),
+        ([1, 2, 3, 4, 5], [1, 2, 3, 4, 5]),
+    )
+    @ddt.unpack
+    def test_seq_builtin_iter(self, data, expect):
+        actual = list(x for x in seq(data))
+        self.assertEqual(actual, expect)
+
+    @ddt.data(
+        ([], []),
+        ([0], [0]),
+        ([1, 2, 3, 4, 5], [5, 4, 3, 2, 1]),
+    )
+    @ddt.unpack
+    def test_seq_builtin_reversed(self, data, expect):
+        actual = list(x for x in reversed(seq(data)))
+        self.assertEqual(actual, expect)
+
+    @ddt.data(
+        ([], 0, 0),
+        ([0], 0, 1),
+        ([0], -1, 0),
+        ([0, 0, 0], 0, 3),
+        ([0, 0, 0], -1, 0),
+        ([1, 2, 3, 4, 5], 0, 0),
+        ([1, 2, 3, 4, 5], 1, 1),
+        ([1, 2, 3, 4, 5], -1, 0),
+    )
+    @ddt.unpack
+    def test_seq_count(self, data, item, expect):
+        actual = seq(data).count(item)
+        self.assertEqual(actual, expect)
+
+    @ddt.data(
+        ([], lambda x: True, 0),
+        ([0], lambda x: True, 1),
+        ([0], lambda x: False, 0),
+        ([0], lambda x: x % 2 == 0, 1),
+        ([0], lambda x: x % 2 == 1, 0),
+        ([0, 0, 0], lambda x: True, 3),
+        ([0, 0, 0], lambda x: False, 0),
+        ([0, 0, 0], lambda x: x % 2 == 0, 3),
+        ([0, 0, 0], lambda x: x % 2 == 1, 0),
+        ([1, 2, 3, 4, 5], lambda x: x % 2 == 0, 2),
+        ([1, 2, 3, 4, 5], lambda x: x % 2 == 1, 3),
+        ([1, 2, 2, 3, 3, 3, 4, 4, 4, 4, 5, 5, 5, 5, 5], lambda x: x % 2 == 0, 6),
+        ([1, 2, 2, 3, 3, 3, 4, 4, 4, 4, 5, 5, 5, 5, 5], lambda x: x % 2 == 1, 9),
+    )
+    @ddt.unpack
+    def test_seq_count_if(self, data, func, expect):
+        actual = seq(data).count_if(func)
+        self.assertEqual(actual, expect)
+
     @ddt.data(
         ([], 0, lambda x, y: x, []),
         ([], None, lambda x, y: x, []),
@@ -955,3 +1033,69 @@ class SeqUtilsTest(unittest.TestCase):
     def test_seq_flatten(self, data, expect):
         actual = seq(data).flatten()
         self.assertEqual(actual.data, expect)
+
+    @ddt.data(
+        ([], [], []),
+        ([0], [], []),
+        ([], [0], []),
+        ([0], [0], [(0, 0)]),
+        ([0, 0], [0], [(0, 0)]),
+        ([0], [0, 0], [(0, 0)]),
+        ([1, 2, 3, 4, 5], [1, 2, 3, 4, 5], [(1, 1), (2, 2), (3, 3), (4, 4), (5, 5)]),
+        ([1, 2, 3, 4, 5], [5, 4, 3, 2, 1], [(1, 5), (2, 4), (3, 3), (4, 2), (5, 1)]),
+        ([1, 2, 3, 4, 5], ["a", "b", "c", "d", "e"], [(1, "a"), (2, "b"), (3, "c"), (4, "d"), (5, "e")]),
+        (["a", "b", "c", "d", "e"], [1, 2, 3, 4, 5], [("a", 1), ("b", 2), ("c", 3), ("d", 4), ("e", 5)]),
+    )
+    @ddt.unpack
+    def test_seq_zip(self, a, b, expect):
+        actual = seq(a).zip(seq(b))
+        self.assertEqual(actual.data, expect)
+
+    @ddt.data(
+        ([], [], 0, []),
+        ([0], [], None, [(0, None)]),
+        ([0], [], 1, [(0, 1)]),
+        ([], [0], None, [(None, 0)]),
+        ([], [0], 1, [(1, 0)]),
+        ([0], [0], 0, [(0, 0)]),
+        ([0, 0], [0], None, [(0, 0), (0, None)]),
+        ([0, 0], [0], 1, [(0, 0), (0, 1)]),
+        ([0], [0, 0], None, [(0, 0), (None, 0)]),
+        ([0], [0, 0], 1, [(0, 0), (1, 0)]),
+        ([1, 2, 3, 4, 5], [1, 2, 3, 4, 5], None, [(1, 1), (2, 2), (3, 3), (4, 4), (5, 5)]),
+        ([1, 2, 3, 4, 5], [5, 4, 3, 2, 1], None, [(1, 5), (2, 4), (3, 3), (4, 2), (5, 1)]),
+        ([1, 2, 3, 4, 5, 6, 7], [1, 2, 3, 4, 5], 0, [(1, 1), (2, 2), (3, 3), (4, 4), (5, 5), (6, 0), (7, 0)]),
+        ([1, 2, 3, 4, 5, 6, 7], [5, 4, 3, 2, 1], 0, [(1, 5), (2, 4), (3, 3), (4, 2), (5, 1), (6, 0), (7, 0)]),
+        ([1, 2, 3, 4, 5], [1, 2, 3, 4, 5, 6, 7], 0, [(1, 1), (2, 2), (3, 3), (4, 4), (5, 5), (0, 6), (0, 7)]),
+        ([1, 2, 3, 4, 5], [7, 6, 5, 4, 3, 2, 1], 0, [(1, 7), (2, 6), (3, 5), (4, 4), (5, 3), (0, 2), (0, 1)]),
+        ([1, 2, 3, 4, 5], ["a", "b", "c", "d", "e"], None, [(1, "a"), (2, "b"), (3, "c"), (4, "d"), (5, "e")]),
+        (["a", "b", "c", "d", "e"], [1, 2, 3, 4, 5], None, [("a", 1), ("b", 2), ("c", 3), ("d", 4), ("e", 5)]),
+        (
+            [1, 2, 3, 4, 5],
+            ["a", "b", "c", "d", "e", "f", "g"],
+            0,
+            [(1, "a"), (2, "b"), (3, "c"), (4, "d"), (5, "e"), (0, "f"), (0, "g")],
+        ),
+        (
+            [1, 2, 3, 4, 5],
+            ["a", "b", "c", "d", "e", "f", "g"],
+            "-",
+            [(1, "a"), (2, "b"), (3, "c"), (4, "d"), (5, "e"), ("-", "f"), ("-", "g")],
+        ),
+        (
+            [1, 2, 3, 4, 5, 6, 7],
+            ["a", "b", "c", "d", "e"],
+            "-",
+            [(1, "a"), (2, "b"), (3, "c"), (4, "d"), (5, "e"), (6, "-"), (7, "-")],
+        ),
+        (
+            [1, 2, 3, 4, 5, 6, 7],
+            ["a", "b", "c", "d", "e"],
+            0,
+            [(1, "a"), (2, "b"), (3, "c"), (4, "d"), (5, "e"), (6, 0), (7, 0)],
+        ),
+    )
+    @ddt.unpack
+    def test_seq_zip_fill(self, a, b, fill, expect):
+        actual = seq(a).zip_fill(seq(b), fill)
+        self.assertEqual(actual.data, expect)