iker-python-common 1.0.56__tar.gz → 1.0.58__tar.gz

{iker_python_common-1.0.56 → iker_python_common-1.0.58}/.github/workflows/pr.yml

@@ -15,7 +15,7 @@ jobs:
       options: --user github
     strategy:
       matrix:
-        python-version: [ "3.11", "3.12", "3.13" ]
+        python-version: [ "3.12", "3.13", "3.14" ]
     steps:
       - name: Checkout
         uses: actions/checkout@v4

{iker_python_common-1.0.56 → iker_python_common-1.0.58}/.github/workflows/push.yml

@@ -20,7 +20,7 @@ jobs:
       - name: Setup Python
         uses: actions/setup-python@v5
         with:
-          python-version: "3.13"
+          python-version: "3.14"
 
       - name: Build and Upload
         run: |

{iker_python_common-1.0.56 → iker_python_common-1.0.58}/PKG-INFO

@@ -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 → iker_python_common-1.0.58}/README.md

@@ -13,7 +13,7 @@ the [official site](https://www.anaconda.com/products/distribution)
 Create a Conda environment and install the modules and their dependencies in it
 
 ```shell
-conda create -n iker python=3.13
+conda create -n iker python=3.14
 conda activate iker
 
 pip install .

{iker_python_common-1.0.56 → iker_python_common-1.0.58}/pyproject.toml

@@ -1,7 +1,7 @@
 [build-system]
 requires = [
-    "setuptools>=75.0",
-    "setuptools-scm>=8.0",
+    "setuptools>=80.0",
+    "setuptools-scm>=9.0",
     "iker-python-setup>=1.0",
 ]
 build-backend = "setuptools.build_meta"
@@ -10,11 +10,10 @@ build-backend = "setuptools.build_meta"
 dev = [
     "boto3>=1.35",
     "docker>=7.1",
-    "numpy>=1.26",
+    "numpy>=2.3",
     "psycopg>=3.2",
     "pymysql>=1.1",
-    "sqlalchemy>=1.4",
-    "typing-extensions; python_version<'3.12'"
+    "sqlalchemy>=2.0",
 ]
 test = [
     "ddt>=1.7",
@@ -24,27 +23,25 @@ test = [
     "pytest-order>=1.3",
     "pytest-postgresql>=6.1",
     "pytest>=8.3",
-    "sqlalchemy>=2.0",
 ]
 
 [project]
 name = "iker-python-common"
 dynamic = ["version"]
-requires-python = ">=3.11,<3.14"
+requires-python = ">=3.12,<3.15"
 classifiers = [
     "Programming Language :: Python :: 3",
-    "Programming Language :: Python :: 3.11",
     "Programming Language :: Python :: 3.12",
     "Programming Language :: Python :: 3.13",
+    "Programming Language :: Python :: 3.14",
 ]
 dependencies = [
     "boto3>=1.35",
     "docker>=7.1",
-    "numpy>=1.26",
+    "numpy>=2.3",
     "psycopg>=3.2",
     "pymysql>=1.1",
-    "sqlalchemy>=1.4",
-    "typing-extensions; python_version<'3.12'"
+    "sqlalchemy>=2.0",
 ]
 
 [project.optional-dependencies]
@@ -59,7 +56,6 @@ test = [
     "pytest-order>=1.3",
     "pytest-postgresql>=6.1",
     "pytest>=8.3",
-    "sqlalchemy>=2.0",
 ]
 
 [tool.setuptools]

{iker_python_common-1.0.56 → iker_python_common-1.0.58}/src/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_python_common-1.0.56 → iker_python_common-1.0.58}/src/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_python_common-1.0.56 → iker_python_common-1.0.58}/src/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_python_common-1.0.56 → iker_python_common-1.0.58}/src/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.