iker-python-common 1.0.56__py3-none-any.whl → 1.0.58__py3-none-any.whl

iker/common/utils/funcutils.py

@@ -1,6 +1,6 @@
 import functools
 from collections.abc import Callable
-from typing import Protocol, TypeVar
+from typing import Protocol
 
 __all__ = [
     "identity",
@@ -11,12 +11,8 @@ __all__ = [
     "unique_returns",
 ]
 
-T = TypeVar("T")
-U = TypeVar("U")
-RT = TypeVar("RT")
 
-
-def identity(instance: T) -> T:
+def identity[T](instance: T) -> T:
     """
     Returns the input ``instance`` unchanged. This is a utility function often used as a default or placeholder.
 
@@ -26,22 +22,19 @@ def identity(instance: T) -> T:
     return instance
 
 
-class Composable(Protocol[T, RT]):
+class Composable[T, R](Protocol):
     """
     Protocol for composable callables, supporting composition and chaining with other callables.
-
-    :param x: The input value for the callable.
-    :return: The result of the callable.
     """
 
-    def __call__(self, x: T) -> RT: ...
+    def __call__(self, x: T) -> R: ...
 
-    def compose(self, func: "Callable[[U], T] | Composable[U, T]") -> "Composable[U, RT]": ...
+    def compose[U](self, func: "Callable[[U], T] | Composable[U, T]") -> "Composable[U, R]": ...
 
-    def and_then(self, func: "Callable[[RT], U] | Composable[RT, U]") -> "Composable[T, U]": ...
+    def and_then[U](self, func: "Callable[[R], U] | Composable[R, U]") -> "Composable[T, U]": ...
 
 
-def composable(func: Callable[[T], RT]) -> Composable[T, RT]:
+def composable[T, R](func: Callable[[T], R]) -> Composable[T, R]:
     """
     Wraps a function to make it composable, allowing chaining with compose and and_then methods.
 
@@ -49,13 +42,13 @@ def composable(func: Callable[[T], RT]) -> Composable[T, RT]:
     :return: A composable version of the function.
     """
 
-    def compose(another_func: Callable[[U], T] | Composable[U, T]) -> Composable[U, RT]:
-        def chained(x: U) -> RT:
+    def compose[U](another_func: Callable[[U], T] | Composable[U, T]) -> Composable[U, R]:
+        def chained(x: U) -> R:
             return func(another_func(x))
 
         return composable(chained)
 
-    def and_then(another_func: Callable[[RT], U] | Composable[RT, U]) -> Composable[T, U]:
+    def and_then[U](another_func: Callable[[R], U] | Composable[R, U]) -> Composable[T, U]:
         def chained(x: T) -> U:
             return another_func(func(x))
 
@@ -66,7 +59,7 @@ def composable(func: Callable[[T], RT]) -> Composable[T, RT]:
     return func
 
 
-def singleton(tar: Callable[..., RT] = None):
+def singleton[R](tar: Callable[..., R] = None):
     """
     Decorator to ensure a function or class is only instantiated once. Subsequent calls return the same instance.
 
@@ -91,7 +84,7 @@ def singleton(tar: Callable[..., RT] = None):
     return decorator if tar is None else decorator(tar)
 
 
-def memorized(tar: Callable[..., RT] = None, *, ordered: bool = False, typed: bool = False):
+def memorized[R](tar: Callable[..., R] = None, *, ordered: bool = False, typed: bool = False):
     """
     Decorator to cache the results of a function based on its arguments. Supports options for argument order and type.
 
@@ -134,7 +127,7 @@ def memorized(tar: Callable[..., RT] = None, *, ordered: bool = False, typed: bo
     return decorator if tar is None else decorator(tar)
 
 
-def lazy(tar: Callable[..., RT] = None):
+def lazy[R](tar: Callable[..., R] = None):
     """
     Decorator to defer the execution of a function until its result is explicitly requested.
 
@@ -155,7 +148,7 @@ def lazy(tar: Callable[..., RT] = None):
     return decorator if tar is None else decorator(tar)
 
 
-def unique_returns(tar: Callable[..., RT] = None, *, max_trials: int | None = None):
+def unique_returns[R](tar: Callable[..., R] = None, *, max_trials: int | None = None):
     """
     Decorator to ensure a function produces unique return values. If no unique value is found within max_trials,
     raises an error.

iker/common/utils/jsonutils.py

@@ -1,12 +1,6 @@
 import math
-import sys
 from collections.abc import Callable, Mapping, MutableMapping, MutableSequence, Sequence, Set
-from typing import Any, SupportsFloat, SupportsInt, TypeAlias
-
-if sys.version_info < (3, 12):
-    from typing_extensions import TypeAliasType
-else:
-    from typing import TypeAliasType
+from typing import Any, SupportsFloat, SupportsInt
 
 from iker.common.utils.numutils import is_normal_real
 
@@ -35,28 +29,26 @@ __all__ = [
 
 JsonKey = str
 JsonValue = str | bool | float | int | None
-JsonObject: TypeAlias = TypeAliasType("JsonObject", "dict[JsonKey, JsonType]")
-JsonArray: TypeAlias = TypeAliasType("JsonArray", "list[JsonType]")
-JsonType: TypeAlias = TypeAliasType("JsonType", "JsonValue | JsonObject | JsonArray")
+type JsonObject = dict[JsonKey, JsonType]
+type JsonArray = list[JsonType]
+type JsonType = JsonValue | JsonObject | JsonArray
+
 JsonKeyCompatible = str
 JsonValueCompatible = str | bool | SupportsFloat | SupportsInt | None
-JsonObjectCompatible: TypeAlias = TypeAliasType("JsonObjectCompatible",
-                                                "Mapping[JsonKeyCompatible, JsonTypeCompatible]")
-JsonArrayCompatible: TypeAlias = TypeAliasType("JsonArrayCompatible",
-                                               "Sequence[JsonTypeCompatible]")
-JsonTypeCompatible: TypeAlias = TypeAliasType("JsonTypeCompatible",
-                                              "JsonValueCompatible | JsonObjectCompatible | JsonArrayCompatible")
+type JsonObjectCompatible = Mapping[JsonKeyCompatible, JsonTypeCompatible]
+type JsonArrayCompatible = Sequence[JsonTypeCompatible]
+type JsonTypeCompatible = JsonValueCompatible | JsonObjectCompatible | JsonArrayCompatible
 
 
 class NodeAsterisk(object):
     pass
 
 
-Node = str | int | NodeAsterisk
-NodePath: TypeAlias = TypeAliasType("NodePath", "list[Node]")
-
 asterisk = NodeAsterisk()
 
+Node = str | int | NodeAsterisk
+type NodePath = list[Node]
+
 
 def json_get(
     obj: JsonTypeCompatible,

iker/common/utils/numutils.py

@@ -2,7 +2,7 @@ import math
 from collections.abc import Callable, Sequence
 from decimal import Decimal
 from numbers import Real
-from typing import Any, TypeVar
+from typing import Any
 
 import numpy as np
 
@@ -26,8 +26,6 @@ __all__ = [
     "real_nan_std",
 ]
 
-RealT = TypeVar("RealT", bound=Real)
-
 
 def to_decimal(x: float | str | None) -> Decimal | None:
     """
@@ -72,10 +70,7 @@ def is_normal_real(v: Any) -> bool:
     return is_real(v) and not math.isnan(v) and not math.isinf(v)
 
 
-def make_real_unary(
-    op: Callable[[RealT], RealT],
-    fb: RealT | None = None,
-) -> Callable[[RealT], RealT | None]:
+def make_real_unary[T: Real](op: Callable[[T], T], fb: T | None = None) -> Callable[[T], T | None]:
     """
     Creates a unary function that applies the given operation to a real number, returning a fallback if not real.
 
@@ -84,7 +79,7 @@ def make_real_unary(
     :return: A function that applies ``op`` to a real number or returns ``fb``.
     """
 
-    def func(x: RealT) -> RealT | None:
+    def func(x: T) -> T | None:
         if not is_real(x):
             return fb
         return op(x)
@@ -92,10 +87,7 @@ def make_real_unary(
     return func
 
 
-def make_real_binary(
-    op: Callable[[RealT, RealT], RealT],
-    fb: RealT | None = None,
-) -> Callable[[RealT, RealT], RealT | None]:
+def make_real_binary[T: Real](op: Callable[[T, T], T], fb: T | None = None) -> Callable[[T, T], T | None]:
     """
     Creates a binary function that applies the given operation to two real numbers, with fallback logic.
 
@@ -104,7 +96,7 @@ def make_real_binary(
     :return: A function that applies ``op`` to two real numbers or returns ``fb``.
     """
 
-    def func(a: RealT, b: RealT) -> RealT | None:
+    def func(a: T, b: T) -> T | None:
         if not is_real(a) and not is_real(b):
             return fb
         if not is_real(a):
@@ -116,10 +108,10 @@ def make_real_binary(
     return func
 
 
-def make_real_reducer(
-    op: Callable[[Sequence[RealT], ...], RealT],
-    fb: RealT | None = None,
-) -> Callable[[Sequence[RealT], ...], RealT | None]:
+def make_real_reducer[T: Real](
+    op: Callable[[Sequence[T], ...], T],
+    fb: T | None = None,
+) -> Callable[[Sequence[T], ...], T | None]:
     """
     Creates a reducer function that applies the given operation to a sequence of real numbers, filtering out non-reals.
 
@@ -128,7 +120,7 @@ def make_real_reducer(
     :return: A function that reduces a sequence of real numbers or returns ``fb``.
     """
 
-    def func(xs: Sequence[RealT], *args, **kwargs) -> RealT | None:
+    def func(xs: Sequence[T], *args, **kwargs) -> T | None:
         xs_new = list(filter(is_real, xs))
         return op(xs_new, *args, **kwargs) if len(xs_new) > 0 else fb
 

iker/common/utils/randutils.py

@@ -4,7 +4,6 @@ import random
 import string
 import sys
 from collections.abc import Callable, Sequence
-from typing import TypeVar
 from typing import overload
 
 from iker.common.utils.dtutils import dt_utc_max, dt_utc_min
@@ -19,8 +18,6 @@ __all__ = [
     "randomizer",
 ]
 
-T = TypeVar("T")
-
 
 @singleton
 def max_int() -> int:
@@ -268,22 +265,22 @@ class Randomizer(object):
         return generate_json_object(0)
 
     @overload
-    def sample(self, population: Sequence[T], count_func: Callable[[T], int], k: int) -> list[T]:
+    def sample[T](self, population: Sequence[T], count_func: Callable[[T], int], k: int) -> list[T]:
         ...
 
     @overload
-    def sample(self, population: Sequence[T], k: int) -> list[T]:
+    def sample[T](self, population: Sequence[T], k: int) -> list[T]:
         ...
 
     @overload
-    def sample(self, population: Sequence[T], count_func: Callable[[T], int], k: None = None) -> T:
+    def sample[T](self, population: Sequence[T], count_func: Callable[[T], int], k: None = None) -> T:
         ...
 
     @overload
-    def sample(self, population: Sequence[T], k: None = None) -> T:
+    def sample[T](self, population: Sequence[T], k: None = None) -> T:
         ...
 
-    def sample(self, population: Sequence[T], count_func: Callable[[T], int] = None, k: int = None) -> list[T] | T:
+    def sample[T](self, population: Sequence[T], count_func: Callable[[T], int] = None, k: int = None) -> list[T] | T:
         """
         Returns a random sample from the population, optionally weighted by a count function.
 
@@ -297,22 +294,27 @@ class Randomizer(object):
         return result if k is not None else head_or_none(result)
 
     @overload
-    def choose(self, population: Sequence[T], weight_func: Callable[[T], float], k: int) -> list[T]:
+    def choose[T](self, population: Sequence[T], weight_func: Callable[[T], float], k: int) -> list[T]:
         ...
 
     @overload
-    def choose(self, population: Sequence[T], k: int) -> list[T]:
+    def choose[T](self, population: Sequence[T], k: int) -> list[T]:
         ...
 
     @overload
-    def choose(self, population: Sequence[T], weight_func: Callable[[T], float], k: None = None) -> T:
+    def choose[T](self, population: Sequence[T], weight_func: Callable[[T], float], k: None = None) -> T:
         ...
 
     @overload
-    def choose(self, population: Sequence[T], k: None = None) -> T:
+    def choose[T](self, population: Sequence[T], k: None = None) -> T:
         ...
 
-    def choose(self, population: Sequence[T], weight_func: Callable[[T], float] = None, k: int = None) -> list[T] | T:
+    def choose[T](
+        self,
+        population: Sequence[T],
+        weight_func: Callable[[T], float] = None,
+        k: int = None,
+    ) -> list[T] | T:
         """
         Returns a random selection from the population, optionally weighted by a weight function.
 
@@ -325,7 +327,7 @@ class Randomizer(object):
         result = self.random.choices(population, weights=weights, k=k or 1)
         return result if k is not None else head_or_none(result)
 
-    def shuffle(self, data: Sequence[T]) -> list[T]:
+    def shuffle[T](self, data: Sequence[T]) -> list[T]:
         """
         Returns a shuffled copy of the input ``data`` sequence.
 

iker/common/utils/sequtils.py

@@ -1,7 +1,6 @@
 import itertools
 from collections import deque
 from collections.abc import Callable, Generator, Iterable, Iterator, Sequence, Sized
-from typing import Generic, TypeAlias, TypeVar
 from typing import overload
 
 __all__ = [
@@ -32,19 +31,13 @@ __all__ = [
     "seq",
 ]
 
-T = TypeVar("T")
-KT = TypeVar("KT")
-VT = TypeVar("VT")
-TT = TypeVar("TT")
-Tco = TypeVar("Tco", covariant=True)
-
-NestedIterable: TypeAlias = "T | Iterable[NestedSequence[T]]"
+type NestedIterable[T] = T | Iterable[NestedIterable[T]]
 
 
 # See Haskell's list operations head, tail, init, and last
 # which is also provided in Scala list operations
 
-def head(ms: Sequence[T]) -> T:
+def head[T](ms: Sequence[T]) -> T:
     """
     Returns the first element of the sequence ``ms``.
 
@@ -54,7 +47,7 @@ def head(ms: Sequence[T]) -> T:
     return ms[0]
 
 
-def head_or_none(ms: Sequence[T]) -> T | None:
+def head_or_none[T](ms: Sequence[T]) -> T | None:
     """
     Returns the first element of the sequence ``ms``, or ``None`` if the sequence is empty.
 
@@ -66,7 +59,7 @@ def head_or_none(ms: Sequence[T]) -> T | None:
     return None
 
 
-def last(ms: Sequence[T]) -> T:
+def last[T](ms: Sequence[T]) -> T:
     """
     Returns the last element of the sequence ``ms``.
 
@@ -76,7 +69,7 @@ def last(ms: Sequence[T]) -> T:
     return ms[-1]
 
 
-def last_or_none(ms: Sequence[T]) -> T | None:
+def last_or_none[T](ms: Sequence[T]) -> T | None:
     """
     Returns the last element of the sequence ``ms``, or ``None`` if the sequence is empty.
 
@@ -88,7 +81,7 @@ def last_or_none(ms: Sequence[T]) -> T | None:
     return None
 
 
-def tail(ms: Sequence[T]) -> Sequence[T]:
+def tail[T](ms: Sequence[T]) -> Sequence[T]:
     """
     Returns all elements of the sequence ``ms`` except the first.
 
@@ -98,7 +91,7 @@ def tail(ms: Sequence[T]) -> Sequence[T]:
     return ms[1:]
 
 
-def tail_iter(ms: Iterable[T]) -> Generator[T, None, None]:
+def tail_iter[T](ms: Iterable[T]) -> Generator[T, None, None]:
     """
     Returns an iterator over all elements of the iterable ``ms`` except the first.
 
@@ -114,7 +107,7 @@ def tail_iter(ms: Iterable[T]) -> Generator[T, None, None]:
         return
 
 
-def init(ms: Sequence[T]) -> Sequence[T]:
+def init[T](ms: Sequence[T]) -> Sequence[T]:
     """
     Returns all elements of the sequence ``ms`` except the last.
 
@@ -124,7 +117,7 @@ def init(ms: Sequence[T]) -> Sequence[T]:
     return ms[:-1]
 
 
-def init_iter(ms: Iterable[T]) -> Generator[T, None, None]:
+def init_iter[T](ms: Iterable[T]) -> Generator[T, None, None]:
     """
     Returns an iterator over all elements of the iterable ``ms`` except the last.
 
@@ -141,7 +134,7 @@ def init_iter(ms: Iterable[T]) -> Generator[T, None, None]:
         prev = this
 
 
-def some(x: T, test: Callable[[T], bool] = lambda x: x is not None) -> Generator[T, None, None]:
+def some[T](x: T, test: Callable[[T], bool] = lambda x: x is not None) -> Generator[T, None, None]:
     """
     Yields the value ``x`` if it passes the ``test`` function.
 
@@ -153,7 +146,7 @@ def some(x: T, test: Callable[[T], bool] = lambda x: x is not None) -> Generator
         yield x
 
 
-def flatten(ms: "NestedIterable[T] | None") -> Generator[T, None, None]:
+def flatten[T](ms: "NestedIterable[T] | None") -> Generator[T, None, None]:
     """
     Flattens a nested iterable ``ms`` into a generator of elements.
 
@@ -169,7 +162,7 @@ def flatten(ms: "NestedIterable[T] | None") -> Generator[T, None, None]:
             yield from flatten(m)
 
 
-def scan_left(ms: Sequence[T], zero: TT | None, func: Callable[[TT, T], TT]) -> Generator[TT, None, None]:
+def scan_left[T, R](ms: Sequence[T], zero: R | None, func: Callable[[R, T], R]) -> Generator[R, None, None]:
     """
     Applies a function cumulatively to the items of a sequence from left to right, yielding the intermediate results.
 
@@ -184,7 +177,7 @@ def scan_left(ms: Sequence[T], zero: TT | None, func: Callable[[TT, T], TT]) ->
         yield accum
 
 
-def scan_right(ms: Sequence[T], zero: TT | None, func: Callable[[TT, T], TT]) -> Generator[TT, None, None]:
+def scan_right[T, R](ms: Sequence[T], zero: R | None, func: Callable[[R, T], R]) -> Generator[R, None, None]:
     """
     Applies a function cumulatively to the items of a sequence from right to left, yielding the intermediate results.
 
@@ -199,7 +192,7 @@ def scan_right(ms: Sequence[T], zero: TT | None, func: Callable[[TT, T], TT]) ->
         yield accum
 
 
-def fold_left(ms: Sequence[T], zero: TT | None, func: Callable[[TT, T], TT]) -> TT | None:
+def fold_left[T, R](ms: Sequence[T], zero: R | None, func: Callable[[R, T], R]) -> R | None:
     """
     Applies a function cumulatively to the items of a sequence ``ms`` from left to right, reducing the sequence to a
     single value. If the initial value (``zero``) is ``None``, the first element of ``ms`` is used as the starting
@@ -219,7 +212,7 @@ def fold_left(ms: Sequence[T], zero: TT | None, func: Callable[[TT, T], TT]) ->
     return accum
 
 
-def fold_right(ms: Sequence[T], zero: TT | None, func: Callable[[TT, T], TT]) -> TT | None:
+def fold_right[T, R](ms: Sequence[T], zero: R | None, func: Callable[[R, T], R]) -> R | None:
     """
     Applies a function cumulatively to the items of a sequence ``ms`` from right to left, reducing the sequence to a
     single value. If the initial value (``zero``) is ``None``, the last element of ``ms`` is used as the starting
@@ -239,14 +232,14 @@ def fold_right(ms: Sequence[T], zero: TT | None, func: Callable[[TT, T], TT]) ->
     return accum
 
 
-def slide_left(
+def slide_left[T, R](
     ms: Sequence[T],
     window: int,
-    func: Callable[[Iterable[T]], TT] = lambda x: x,
+    func: Callable[[Iterable[T]], R] = lambda x: x,
     *,
     allow_partial: tuple[bool, bool] = (False, False),
     padding: tuple[T, T] = (None, None),
-) -> Generator[TT, None, None]:
+) -> Generator[R, None, None]:
     """
     Generates a sliding window over the input sequence from left to right.
 
@@ -295,14 +288,14 @@ def slide_left(
         yield from (func(ms[-i:]) for i in reversed(range(1, min(window, len(ms)))))
 
 
-def slide_right(
+def slide_right[T, R](
     ms: Sequence[T],
     window: int,
-    func: Callable[[Iterable[T]], TT] = lambda x: x,
+    func: Callable[[Iterable[T]], R] = lambda x: x,
     *,
     allow_partial: tuple[bool, bool] = (False, False),
     padding: tuple[T, T] = (None, None),
-) -> Generator[TT, None, None]:
+) -> Generator[R, None, None]:
     """
     Generates a sliding window over the input sequence from right to left.
 
@@ -352,28 +345,28 @@ def slide_right(
 
 
 @overload
-def grouped(
+def grouped[T, K](
     ms: Sequence[T],
-    key_func: Callable[[T], KT],
+    key_func: Callable[[T], K],
     keys_ordered: bool,
     values_only: False = False,
-) -> Generator[tuple[KT, list[T]], None, None]:
+) -> Generator[tuple[K, list[T]], None, None]:
     ...
 
 
 @overload
-def grouped(
+def grouped[T, K](
     ms: Sequence[T],
-    key_func: Callable[[T], KT],
+    key_func: Callable[[T], K],
     values_only: False = False,
-) -> Generator[tuple[KT, list[T]], None, None]:
+) -> Generator[tuple[K, list[T]], None, None]:
     ...
 
 
 @overload
-def grouped(
+def grouped[T, K](
     ms: Sequence[T],
-    key_func: Callable[[T], KT],
+    key_func: Callable[[T], K],
     keys_ordered: bool,
     values_only: True = True,
 ) -> Generator[list[T], None, None]:
@@ -381,20 +374,20 @@ def grouped(
 
 
 @overload
-def grouped(
+def grouped[T, K](
     ms: Sequence[T],
-    key_func: Callable[[T], KT],
+    key_func: Callable[[T], K],
     values_only: True = True,
 ) -> Generator[list[T], None, None]:
     ...
 
 
-def grouped(
+def grouped[T, K](
     ms: Sequence[T],
-    key_func: Callable[[T], KT],
+    key_func: Callable[[T], K],
     keys_ordered: bool = False,
     values_only: bool = False,
-) -> Generator[tuple[KT, list[T]] | list[T], None, None]:
+) -> Generator[tuple[K, list[T]] | list[T], None, None]:
     """
     Groups elements of a sequence by a key function.
 
@@ -406,7 +399,7 @@ def grouped(
     """
     if ms is None or len(ms) == 0:
         return
-    grouped_ms: dict[KT, list[T]] = {}
+    grouped_ms: dict[K, list[T]] = {}
     for m in ms:
         k = key_func(m)
         grouped_ms.setdefault(k, []).append(m)
@@ -414,7 +407,7 @@ def grouped(
     yield from (d for _, d in groups) if values_only else groups
 
 
-def deduped(ms: Sequence[T], comp_func: Callable[[T, T], bool]) -> Generator[T, None, None]:
+def deduped[T](ms: Sequence[T], comp_func: Callable[[T, T], bool]) -> Generator[T, None, None]:
     """
     Yields elements from the input sequence, removing consecutive duplicates as determined by the comparison function.
 
@@ -432,7 +425,7 @@ def deduped(ms: Sequence[T], comp_func: Callable[[T, T], bool]) -> Generator[T,
             prev = m
 
 
-def batched(ms: Iterable[T], batch_size: int) -> Generator[list[T], None, None]:
+def batched[T](ms: Iterable[T], batch_size: int) -> Generator[list[T], None, None]:
     """
     Splits an iterable into consecutive batches of a specified size.
 
@@ -456,7 +449,7 @@ def batched(ms: Iterable[T], batch_size: int) -> Generator[list[T], None, None]:
 batch_yield = batched
 
 
-def chunk(
+def chunk[T](
     ms: Sequence[T],
     chunk_func: Callable[[Sequence[T], T], bool],
     exclusive_end: bool = False,
@@ -485,7 +478,7 @@ def chunk(
     yield prev
 
 
-def chunk_between(
+def chunk_between[T](
     ms: Sequence[T],
     chunk_func: Callable[[T, T], bool],
     exclusive_end: bool = False,
@@ -504,9 +497,9 @@ def chunk_between(
     yield from chunk(ms, lambda x, y: chunk_func(last(x), y), exclusive_end)
 
 
-def chunk_with_key(
+def chunk_with_key[T, K](
     ms: Sequence[T],
-    key_func: Callable[[T], KT],
+    key_func: Callable[[T], K],
     exclusive_end: bool = False,
 ) -> Generator[list[T], None, None]:
     """
@@ -521,7 +514,7 @@ def chunk_with_key(
     yield from chunk_between(ms, lambda x, y: key_func(x) != key_func(y), exclusive_end)
 
 
-def merge_chunks(
+def merge_chunks[T](
     chunks: Sequence[Sequence[T]],
     merge_func: Callable[[Sequence[T], Sequence[T]], bool],
     drop_exclusive_end: bool = False,
@@ -546,11 +539,8 @@ def merge_chunks(
                    chunk_between(chunks, lambda a, b: not merge_func(a, b)))
 
 
-SeqT = TypeVar("SeqT", bound="Seq")
-
-
-class Seq(Generic[Tco], Sequence[Tco], Sized):
-    def __init__(self, data: Iterable[Tco] | SeqT):
+class Seq[T](Sequence[T], Sized):
+    def __init__(self, data: Iterable[T]):
         if isinstance(data, Seq):
             self.data = data.data
         elif isinstance(data, Iterable):
@@ -566,15 +556,15 @@ class Seq(Generic[Tco], Sequence[Tco], Sized):
     def empty(self) -> bool:
         return self.size == 0
 
-    def __add__(self: SeqT, other: SeqT) -> SeqT:
+    def __add__[SeqT: Seq](self: SeqT, other: SeqT) -> SeqT:
         return self.concat(other)
 
-    def __getitem__(self: SeqT, item: int | slice) -> SeqT:
+    def __getitem__[SeqT: Seq](self: SeqT, item: int | slice) -> SeqT:
         if isinstance(item, slice):
             return type(self)(self.data[item])
         elif isinstance(item, int):
             return type(self)(some(self.data[item]))
-        raise ValueError("unsupported index type")
+        raise IndexError("unsupported index type")
 
     def __len__(self) -> int:
         return len(self.data)
@@ -582,104 +572,104 @@ class Seq(Generic[Tco], Sequence[Tco], Sized):
     def __contains__(self, item) -> bool:
         return item in self.data
 
-    def __iter__(self) -> Iterator[Tco]:
+    def __iter__(self) -> Iterator[T]:
         return iter(self.data)
 
-    def __reversed__(self) -> Iterator[Tco]:
+    def __reversed__(self) -> Iterator[T]:
         return reversed(self.data)
 
-    def count(self, elem: Tco):
+    def count(self, elem: T):
         return self.count_if(lambda x: x == elem)
 
-    def count_if(self, func: Callable[[Tco], bool]):
+    def count_if(self, func: Callable[[T], bool]):
         return sum(1 for item in self.data if func(item))
 
-    def concat(self: SeqT, other: SeqT) -> SeqT:
+    def concat[SeqT: Seq](self: SeqT, other: SeqT) -> SeqT:
         return type(self)(itertools.chain(self.data, other.data))
 
-    def pad_left(self: SeqT, n: int, value: Tco) -> SeqT:
+    def pad_left[SeqT: Seq](self: SeqT, n: int, value: T) -> SeqT:
         return self if n <= 0 else type(self)(itertools.repeat(value, n)).concat(self)
 
-    def pad_right(self: SeqT, n: int, value: Tco) -> SeqT:
+    def pad_right[SeqT: Seq](self: SeqT, n: int, value: T) -> SeqT:
         return self if n <= 0 else self.concat(type(self)(itertools.repeat(value, n)))
 
-    def pad_left_head(self: SeqT, n: int) -> SeqT:
+    def pad_left_head[SeqT: Seq](self: SeqT, n: int) -> SeqT:
         return self if self.empty else self.pad_left(n, head(self.data))
 
-    def pad_right_last(self: SeqT, n: int) -> SeqT:
+    def pad_right_last[SeqT: Seq](self: SeqT, n: int) -> SeqT:
         return self if self.empty else self.pad_right(n, last(self.data))
 
-    def take_left(self: SeqT, n: int) -> SeqT:
+    def take_left[SeqT: Seq](self: SeqT, n: int) -> SeqT:
         if n <= 0:
             return type(self)([])
         return self[:n]
 
-    def take_right(self: SeqT, n: int) -> SeqT:
+    def take_right[SeqT: Seq](self: SeqT, n: int) -> SeqT:
         if n <= 0:
             return type(self)([])
         return self[-n:]
 
     take = take_left
 
-    def reverse(self: SeqT) -> SeqT:
+    def reverse[SeqT: Seq](self: SeqT) -> SeqT:
         return type(self)(reversed(self.data))
 
-    def distinct(self: SeqT) -> SeqT:
+    def distinct[SeqT: Seq](self: SeqT) -> SeqT:
         return type(self)(sorted(set(self.data)))
 
-    def scan_left(self, zero: TT | None, func: Callable[[TT, Tco], TT]) -> "Seq[TT]":
+    def scan_left[R](self, zero: R | None, func: Callable[[R, T], R]) -> "Seq[R]":
         return Seq(scan_left(self.data, zero, func))
 
-    def scan_right(self, zero: TT | None, func: Callable[[TT, Tco], TT]) -> "Seq[TT]":
+    def scan_right[R](self, zero: R | None, func: Callable[[R, T], R]) -> "Seq[R]":
         return Seq(scan_right(self.data, zero, func))
 
     scan = scan_left
 
-    def map(self, func: Callable[[Tco], TT]) -> "Seq[TT]":
+    def map[R](self, func: Callable[[T], R]) -> "Seq[R]":
         return self.scan(None, lambda x, y: func(y))
 
-    def fold_left(self, zero: TT | None, func: Callable[[TT, Tco], TT]) -> "Seq[TT]":
+    def fold_left[R](self, zero: R | None, func: Callable[[R, T], R]) -> "Seq[R]":
         return Seq(some(fold_left(self.data, zero, func)))
 
-    def fold_right(self, zero: TT | None, func: Callable[[TT, Tco], TT]) -> "Seq[TT]":
+    def fold_right[R](self, zero: R | None, func: Callable[[R, T], R]) -> "Seq[R]":
         return Seq(some(fold_right(self.data, zero, func)))
 
     fold = fold_left
 
-    def slide_left(
+    def slide_left[R](
         self,
         window: int,
-        func: Callable[[Iterable[Tco]], TT] = lambda x: x,
+        func: Callable[[Iterable[T]], R] = lambda x: x,
         *,
         allow_partial: tuple[bool, bool] = (False, False),
-        padding: tuple[Tco, Tco] = (None, None),
-    ) -> "Seq[TT]":
+        padding: tuple[T, T] = (None, None),
+    ) -> "Seq[R]":
         return Seq(slide_left(self.data, window, func, allow_partial=allow_partial, padding=padding))
 
-    def slide_right(
+    def slide_right[R](
         self,
         window: int,
-        func: Callable[[Iterable[Tco]], TT] = lambda x: x,
+        func: Callable[[Iterable[T]], R] = lambda x: x,
         *,
         allow_partial: tuple[bool, bool] = (False, False),
-        padding: tuple[Tco, Tco] = (None, None),
-    ) -> "Seq[TT]":
+        padding: tuple[T, T] = (None, None),
+    ) -> "Seq[R]":
         return Seq(slide_right(self.data, window, func, allow_partial=allow_partial, padding=padding))
 
     slide = slide_left
 
-    def reduce(self: SeqT, func: Callable[[Tco, Tco], Tco]) -> SeqT:
+    def reduce[SeqT: Seq](self: SeqT, func: Callable[[T, T], T]) -> SeqT:
         return type(self)(self.fold(None, lambda x, y: func(x, y)))
 
-    def max(self: SeqT, func: Callable[[Tco, Tco], bool] = None) -> SeqT:
+    def max[SeqT: Seq](self: SeqT, func: Callable[[T, T], 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: SeqT, func: Callable[[Tco, Tco], bool] = None) -> SeqT:
+    def min[SeqT: Seq](self: SeqT, func: Callable[[T, T], 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], KT]) -> "Seq[tuple[KT, list[Tco]]]":
+    def group[K](self, func: Callable[[T], K]) -> "Seq[tuple[K, list[T]]]":
         return Seq(grouped(self.data, key_func=func, keys_ordered=True))
 
     def keys(self):
@@ -691,63 +681,63 @@ 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], TT]):
+    def map_keys[R](self, func: Callable[[T], R]):
         return Seq((func(key), value) for key, value in self.data)
 
-    def map_values(self, func: Callable[[Tco], TT]):
+    def map_values[R](self, func: Callable[[T], R]):
         return Seq((key, func(value)) for key, value in self.data)
 
-    def flat_map(self, func: Callable[[Tco], Iterable[TT]]) -> "Seq[TT]":
+    def flat_map[R](self, func: Callable[[T], Iterable[R]]) -> "Seq[R]":
         return Seq(flatten(map(lambda x: func(x), self.data)))
 
     def flatten(self):
         return self.flat_map(lambda x: list(x))
 
-    def group_map(self, group_func: Callable[[Tco], KT], map_func: Callable[[Tco], TT]) -> "Seq[tuple[KT, list[TT]]]":
+    def group_map[K, R](self, group_func: Callable[[T], K], map_func: Callable[[T], R]) -> "Seq[tuple[K, list[R]]]":
         return self.group(group_func).map_values(lambda x: list(map(map_func, x)))
 
-    def filter(self: SeqT, func: Callable[[Tco], bool]) -> SeqT:
+    def filter[SeqT: Seq](self: SeqT, func: Callable[[T], bool]) -> SeqT:
         return type(self)(filter(func, self.data))
 
-    def filter_not(self: SeqT, func: Callable[[Tco], bool]) -> SeqT:
+    def filter_not[SeqT: Seq](self: SeqT, func: Callable[[T], bool]) -> SeqT:
         return self.filter(lambda x: not func(x))
 
-    def sort(self: SeqT, func: Callable[[Tco], KT]) -> SeqT:
+    def sort[SeqT: Seq, K](self: SeqT, func: Callable[[T], K]) -> SeqT:
         return type(self)(sorted(self.data, key=func))
 
-    def head(self: SeqT) -> SeqT:
+    def head[SeqT: Seq](self: SeqT) -> SeqT:
         return type(self)(some(head_or_none(self.data)))
 
-    def last(self: SeqT) -> SeqT:
+    def last[SeqT: Seq](self: SeqT) -> SeqT:
         return type(self)(some(last_or_none(self.data)))
 
-    def init(self: SeqT) -> SeqT:
+    def init[SeqT: Seq](self: SeqT) -> SeqT:
         return type(self)(init_iter(self.data))
 
-    def tail(self: SeqT) -> SeqT:
+    def tail[SeqT: Seq](self: SeqT) -> SeqT:
         return type(self)(tail_iter(self.data))
 
-    def foreach(self: SeqT, func: Callable[[Tco], None]) -> SeqT:
+    def foreach[SeqT: Seq](self: SeqT, func: Callable[[T], None]) -> SeqT:
         for elem in self.data:
             func(elem)
         return self
 
-    def exists(self, func: Callable[[Tco], bool]) -> "Seq[bool]":
+    def exists(self, func: Callable[[T], bool]) -> "Seq[bool]":
         return Seq(some(any(map(func, self.data))))
 
-    def forall(self, func: Callable[[Tco], bool]) -> "Seq[bool]":
+    def forall(self, func: Callable[[T], bool]) -> "Seq[bool]":
         return Seq(some(all(map(func, self.data))))
 
-    def union(self: SeqT, other: SeqT) -> SeqT:
+    def union[SeqT: Seq](self: SeqT, other: SeqT) -> SeqT:
         return type(self)(sorted(set(self.data).union(set(other.data))))
 
-    def intersect(self: SeqT, other: SeqT) -> SeqT:
+    def intersect[SeqT: Seq](self: SeqT, other: SeqT) -> SeqT:
         return type(self)(sorted(set(self.data).intersection(set(other.data))))
 
-    def zip(self, other: "Seq[TT]") -> "Seq[tuple[Tco, TT]]":
+    def zip[U](self, other: "Seq[U]") -> "Seq[tuple[T, U]]":
         return Seq(zip(self.data, other.data))
 
-    def zip_fill(self, other: "Seq[TT]", fill: Tco | TT | None = None) -> "Seq[tuple[Tco, TT]]":
+    def zip_fill[U](self, other: "Seq[U]", fill: T | U | None = None) -> "Seq[tuple[T, U]]":
         return Seq(itertools.zip_longest(self.data, other.data, fillvalue=fill))
 
 

iker/common/utils/span.py

@@ -1,7 +1,6 @@
 import enum
 import itertools
 from collections.abc import Sequence
-from typing import TypeVar
 
 __all__ = [
     "SpanRelation",
@@ -11,8 +10,6 @@ __all__ = [
     "spans_subtract",
 ]
 
-T = TypeVar("T")
-
 
 class SpanRelation(enum.IntEnum):
     LeftIn = 0x1
@@ -69,7 +66,7 @@ def span_relation(a: tuple[float, float], b: tuple[float, float]) -> int:
     return rel
 
 
-def spans_union(a: Sequence[tuple[T, T]], *bs: Sequence[tuple[T, T]]) -> list[tuple[T, T]]:
+def spans_union[T](a: Sequence[tuple[T, T]], *bs: Sequence[tuple[T, T]]) -> list[tuple[T, T]]:
     """
     Computes the union of the given span lists. The spans in each of the lists must be sorted and must not
     mutually overlap.
@@ -123,7 +120,7 @@ def spans_union(a: Sequence[tuple[T, T]], *bs: Sequence[tuple[T, T]]) -> list[tu
     return a
 
 
-def spans_intersect(a: Sequence[tuple[T, T]], *bs: Sequence[tuple[T, T]]) -> list[tuple[T, T]]:
+def spans_intersect[T](a: Sequence[tuple[T, T]], *bs: Sequence[tuple[T, T]]) -> list[tuple[T, T]]:
     """
     Computes the intersection of the given span lists. The spans in each of the lists must be sorted and must not
     mutually overlap.
@@ -161,7 +158,7 @@ def spans_intersect(a: Sequence[tuple[T, T]], *bs: Sequence[tuple[T, T]]) -> lis
     return a
 
 
-def spans_subtract(a: Sequence[tuple[T, T]], *bs: Sequence[tuple[T, T]]) -> list[tuple[T, T]]:
+def spans_subtract[T](a: Sequence[tuple[T, T]], *bs: Sequence[tuple[T, T]]) -> list[tuple[T, T]]:
     """
     Computes the subtraction on the first span list by the remaining span lists. The spans in each of the lists must be
     sorted and must not mutually overlap.

{iker_python_common-1.0.56.dist-info → iker_python_common-1.0.58.dist-info}/METADATA

@@ -1,18 +1,17 @@
 Metadata-Version: 2.4
 Name: iker-python-common
-Version: 1.0.56
+Version: 1.0.58
 Classifier: Programming Language :: Python :: 3
-Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
 Classifier: Programming Language :: Python :: 3.13
-Requires-Python: <3.14,>=3.11
+Classifier: Programming Language :: Python :: 3.14
+Requires-Python: <3.15,>=3.12
 Requires-Dist: boto3>=1.35
 Requires-Dist: docker>=7.1
-Requires-Dist: numpy>=1.26
+Requires-Dist: numpy>=2.3
 Requires-Dist: psycopg>=3.2
 Requires-Dist: pymysql>=1.1
-Requires-Dist: sqlalchemy>=1.4
-Requires-Dist: typing-extensions; python_version < "3.12"
+Requires-Dist: sqlalchemy>=2.0
 Provides-Extra: all
 Requires-Dist: iker-python-common; extra == "all"
 Provides-Extra: test
@@ -23,4 +22,3 @@ Requires-Dist: pytest-mysql>=3.0; extra == "test"
 Requires-Dist: pytest-order>=1.3; extra == "test"
 Requires-Dist: pytest-postgresql>=6.1; extra == "test"
 Requires-Dist: pytest>=8.3; extra == "test"
-Requires-Dist: sqlalchemy>=2.0; extra == "test"

{iker_python_common-1.0.56.dist-info → iker_python_common-1.0.58.dist-info}/RECORD

@@ -6,20 +6,20 @@ iker/common/utils/csv.py,sha256=_V9OUrKcojec2L-hWagEIVnL2uvGjyJAFTrD7tHNr48,7573
 iker/common/utils/dbutils.py,sha256=zXZVJCz7HZPityFRF7sHRRMpMraegV_hyYnzApUUPhY,11852
 iker/common/utils/dockerutils.py,sha256=n2WuzXaZB6_WocSljvPOnfExSIjIHRUbuWp2oBbaPKQ,8004
 iker/common/utils/dtutils.py,sha256=86vbaa4pgcBWERZvTfJ92PKB3IimxP6tf0O11ho2Ffk,12554
-iker/common/utils/funcutils.py,sha256=A08f5wjoLgLQKyRJcYeWJnqVm2QcerIx0l-Se2600bc,5869
-iker/common/utils/jsonutils.py,sha256=xYKimWtsqQKiQDQr3EMIhpGrmWSNPzgZR1Sdz60CxSo,16536
+iker/common/utils/funcutils.py,sha256=hHk7UHI-h92F8CFff-SZGvfhSlZ-CkO2dI8GWa6V81Q,5734
+iker/common/utils/jsonutils.py,sha256=Df4uxEgIejEhZdrfmiT4DX2aewEX0Pqbl1n4OCN4YdI,15970
 iker/common/utils/logger.py,sha256=FJaai6Sbchy4wKHcUMUCrrkBcXvIxq4qByERZ_TJBps,3881
-iker/common/utils/numutils.py,sha256=vg739jMqx3W1H_IxzzSJKhtEGZEnQrNgsp_tDKhEVck,4432
-iker/common/utils/randutils.py,sha256=PuQVSKNOtXTgQh8QCifMMgsGzmevkrInSSKpnqD361Q,12816
+iker/common/utils/numutils.py,sha256=p6Rz1qyCcUru3v1zDy2PM-nds2NWJdL5A_vLmG-kswk,4294
+iker/common/utils/randutils.py,sha256=Sxf852B18CJ-MfrEDsv1ROO_brmz79dRZ4jpJiH65v4,12843
 iker/common/utils/retry.py,sha256=H9lR6pp_jzgOwKTM-dOWIddjTlQbK-ijcwuDmVvurZM,8938
 iker/common/utils/s3utils.py,sha256=rb-JVCJuIbmVn4ml7MQ7qKD8Z25t8xnU_u4oY1-APe4,9368
-iker/common/utils/sequtils.py,sha256=MfYL82TygBRlGK4sw0RJcoB5P3hO6l7saVH5oZ3YDP8,25003
+iker/common/utils/sequtils.py,sha256=Wc8RcbNjVYSJYZv_07SOKWfYjhmGWz9_RXWbG2-tE1o,25060
 iker/common/utils/shutils.py,sha256=44_Qkzkhrs9LsfDflsaY_4Va0IpVLU3o8K_NvqCB04w,7859
-iker/common/utils/span.py,sha256=yiXqk86cLKxkMdkO3pAHEfU5bUvHsGo3p--pAWo_yfM,5999
+iker/common/utils/span.py,sha256=u_KuWi2U7QDMUotl4AeW2_57ItL3YhVDSeCwaOiFDvs,5963
 iker/common/utils/strutils.py,sha256=Tu_qFeH3K-SfwvMxdrZAc9iLPV8ZmtX4ntyyFGNslf8,5094
 iker/common/utils/testutils.py,sha256=2VieV5yeCDntSKQSpIeyqRT8BZmZYE_ArMeQz3g7fXY,5568
 iker/common/utils/typeutils.py,sha256=RVkYkFRgDrx77OHFH7PavMV0AIB0S8ly40rs4g7JWE4,8220
-iker_python_common-1.0.56.dist-info/METADATA,sha256=y_ebpJlajc26_a9MU-e0FkOgN77Jci4UEitKwvfI15c,1001
-iker_python_common-1.0.56.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-iker_python_common-1.0.56.dist-info/top_level.txt,sha256=4_B8Prfc_lxFafFYTQThIU1ZqOYQ4pHHHnJ_fQ_oHs8,5
-iker_python_common-1.0.56.dist-info/RECORD,,
+iker_python_common-1.0.58.dist-info/METADATA,sha256=dI9O2Xjd_YKTQkPvtA_xf9ANw2-vdsJDFC1k8FO0m7A,894
+iker_python_common-1.0.58.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+iker_python_common-1.0.58.dist-info/top_level.txt,sha256=4_B8Prfc_lxFafFYTQThIU1ZqOYQ4pHHHnJ_fQ_oHs8,5
+iker_python_common-1.0.58.dist-info/RECORD,,