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

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

@@ -1,12 +1,11 @@
 Metadata-Version: 2.4
 Name: iker-python-common
-Version: 1.0.58
+Version: 1.0.60
 Classifier: Programming Language :: Python :: 3
 Classifier: Programming Language :: Python :: 3.12
 Classifier: Programming Language :: Python :: 3.13
 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>=2.3
 Requires-Dist: psycopg>=3.2
@@ -16,7 +15,6 @@ Provides-Extra: all
 Requires-Dist: iker-python-common; extra == "all"
 Provides-Extra: test
 Requires-Dist: ddt>=1.7; extra == "test"
-Requires-Dist: moto[all,ec2,s3]>=5.0; extra == "test"
 Requires-Dist: pytest-cov>=5.0; extra == "test"
 Requires-Dist: pytest-mysql>=3.0; extra == "test"
 Requires-Dist: pytest-order>=1.3; extra == "test"

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

@@ -8,7 +8,6 @@ build-backend = "setuptools.build_meta"
 
 [dependency-groups]
 dev = [
-    "boto3>=1.35",
     "docker>=7.1",
     "numpy>=2.3",
     "psycopg>=3.2",
@@ -17,7 +16,6 @@ dev = [
 ]
 test = [
     "ddt>=1.7",
-    "moto[ec2,s3,all]>=5.0",
     "pytest-cov>=5.0",
     "pytest-mysql>=3.0",
     "pytest-order>=1.3",
@@ -36,7 +34,6 @@ classifiers = [
     "Programming Language :: Python :: 3.14",
 ]
 dependencies = [
-    "boto3>=1.35",
     "docker>=7.1",
     "numpy>=2.3",
     "psycopg>=3.2",
@@ -50,7 +47,6 @@ all = [
 ]
 test = [
     "ddt>=1.7",
-    "moto[ec2,s3,all]>=5.0",
     "pytest-cov>=5.0",
     "pytest-mysql>=3.0",
     "pytest-order>=1.3",

{iker_python_common-1.0.58 → iker_python_common-1.0.60}/src/iker/common/utils/funcutils.py

@@ -1,8 +1,12 @@
 import functools
 from collections.abc import Callable
-from typing import Protocol
+from typing import Any, Protocol
 
 __all__ = [
+    "const",
+    "first",
+    "second",
+    "packed",
     "identity",
     "composable",
     "singleton",
@@ -12,6 +16,70 @@ __all__ = [
 ]
 
 
+def const[T](value: T) -> Callable[..., T]:
+    """
+    Returns a function that always returns the specified ``value``, regardless of the input arguments.
+
+    :param value: The constant value to return.
+    :return: A function that takes any arguments and returns ``value``.
+    """
+
+    def getter(*args: Any, **kwargs: Any) -> T:
+        return value
+
+    return getter
+
+
+def first[K]() -> Callable[[tuple[K, Any]], K]:
+    """
+    Returns a function that extracts the first element (key) from a 2-tuple.
+
+    :return: A function that takes a 2-tuple and returns its first element.
+    """
+
+    def getter(item: tuple[K, Any]) -> K:
+        if not isinstance(item, tuple) or len(item) != 2:
+            raise ValueError("item must be a 2-tuple")
+        return item[0]
+
+    return getter
+
+
+def second[V]() -> Callable[[tuple[Any, V]], V]:
+    """
+    Returns a function that extracts the second element (value) from a 2-tuple.
+
+    :return: A function that takes a 2-tuple and returns its second element.
+    """
+
+    def getter(item: tuple[Any, V]) -> V:
+        if not isinstance(item, tuple) or len(item) != 2:
+            raise ValueError("item must be a 2-tuple")
+        return item[1]
+
+    return getter
+
+
+def packed[R](func: Callable[..., R]) -> Callable[[tuple[Any, ...]], R]:
+    """
+    Wraps a function to accept its arguments as a single tuple, unpacking them when called. This is useful for
+    scenarios where arguments are naturally grouped in tuples, such as when working with data structures like maps or
+    lists of tuples, or when interfacing with APIs that provide arguments in tuple form.
+
+    >>> data = [(1, 2), (3, 4), (5, 6)]
+    >>> sums = map(packed(lambda x, y: x + y), data)
+
+    :param func: The function to wrap.
+    :return: A function that takes a tuple of arguments and calls the original function with them unpacked.
+    """
+
+    @functools.wraps(func)
+    def wrapper(args: tuple[Any, ...]) -> R:
+        return func(*args)
+
+    return wrapper
+
+
 def identity[T](instance: T) -> T:
     """
     Returns the input ``instance`` unchanged. This is a utility function often used as a default or placeholder.

{iker_python_common-1.0.58 → iker_python_common-1.0.60}/src/iker/common/utils/jsonutils.py

@@ -1,5 +1,5 @@
 import math
-from collections.abc import Callable, Mapping, MutableMapping, MutableSequence, Sequence, Set
+from collections.abc import Callable, Generator, Mapping, MutableMapping, MutableSequence, Sequence, Set
 from typing import Any, SupportsFloat, SupportsInt
 
 from iker.common.utils.numutils import is_normal_real
@@ -24,6 +24,8 @@ __all__ = [
     "json_traverse",
     "json_reformat",
     "json_sanitize",
+    "json_difference",
+    "json_equals",
     "json_compare",
 ]
 
@@ -347,79 +349,134 @@ def json_sanitize(obj: Any, *, str_inf_nan: bool = True, str_unregistered: bool
                          unregistered_formatter=unregistered_formatter)
 
 
-def json_compare(
+def json_difference(
     a: JsonTypeCompatible,
     b: JsonTypeCompatible,
+    node_path: NodePath | None = None,
     *,
     int_strict: bool = False,
     float_tol: float = 1e-5,
     list_order: bool = True,
     dict_extra: bool = False,
-) -> bool:
+) -> Generator[tuple[NodePath, str], None, None]:
     """
-    Compares two JSON-like structures for equality, with options for integer strictness, float tolerance, list order,
-    and dictionary key matching.
+    Compares two JSON-like structures and yields differences found, with options for integer strictness, float
+    tolerance, list order, and dictionary key matching.
 
     :param a: The first JSON-compatible object to compare.
     :param b: The second JSON-compatible object to compare.
+    :param node_path: The current node path during recursion (used internally).
     :param int_strict: Whether to require strict integer type matching.
     :param float_tol: The tolerance for comparing float values.
     :param list_order: Whether to require list order to match.
     :param dict_extra: Whether to allow extra keys in dictionaries.
-    :return: ``True`` if the structures are considered equal, ``False`` otherwise.
+    :return: Tuples of node paths and difference descriptions.
     """
     if a is None or b is None:
-        return a is None and b is None
+        if not (a is None and b is None):
+            yield node_path, "one value is None while the other is not"
+        return
 
     if isinstance(a, (str, bool)):
         if type(a) != type(b):
-            return False
-        return a == b
+            yield node_path, f"type mismatch: '{type(a)}' vs '{type(b)}'"
+        elif a != b:
+            yield node_path, f"value mismatch: '{a}' vs '{b}'"
+        return
 
     if isinstance(a, (SupportsFloat, SupportsInt)) and isinstance(b, (SupportsFloat, SupportsInt)):
         isint_a = isinstance(a, int) or not isinstance(a, SupportsFloat)
         isint_b = isinstance(b, int) or not isinstance(b, SupportsFloat)
         if isint_a and isint_b:
-            return int(a) == int(b)
+            if int(a) != int(b):
+                yield node_path, f"integer value mismatch: '{int(a)}' vs '{int(b)}'"
+            return
         if int_strict and (isint_a or isint_b):
-            return False
+            yield node_path, "integer type mismatch under strict mode"
+            return
         va = int(a) if isint_a else float(a)
         vb = int(b) if isint_b else float(b)
-        if math.isnan(va) and math.isnan(vb):
-            return True
+        if math.isnan(va) or math.isnan(vb):
+            if not (math.isnan(va) and math.isnan(vb)):
+                yield node_path, "NaN mismatch"
+            return
         if math.isinf(va) and math.isinf(vb):
-            return va == vb
-        return abs(va - vb) <= float_tol
+            if va != vb:
+                yield node_path, "infinity sign mismatch"
+            return
+        if abs(va - vb) > float_tol:
+            yield node_path, f"float value mismatch: '{va}' vs '{vb}' with tolerance '{float_tol}'"
+        return
 
     if isinstance(a, Mapping) and isinstance(b, Mapping):
         if not dict_extra and set(a.keys()) != set(b.keys()):
-            return False
-        return all(json_compare(a[k],
-                                b[k],
-                                int_strict=int_strict,
-                                float_tol=float_tol,
-                                list_order=list_order,
-                                dict_extra=dict_extra)
-                   for k in set(a.keys()) & set(b.keys()))
+            yield node_path, f"dictionary key mismatch: '{set(a.keys())}' vs '{set(b.keys())}'"
+            return
+        for k in set(a.keys()) & set(b.keys()):
+            yield from json_difference(a[k],
+                                       b[k],
+                                       (node_path or []) + [k],
+                                       int_strict=int_strict,
+                                       float_tol=float_tol,
+                                       list_order=list_order,
+                                       dict_extra=dict_extra)
+        return
 
     if isinstance(a, Sequence) and isinstance(b, Sequence):
         if len(a) != len(b):
-            return False
+            yield node_path, f"list length mismatch: '{len(a)}' vs '{len(b)}'"
+            return
         if list_order:
-            return all(json_compare(va,
-                                    vb,
-                                    int_strict=int_strict,
-                                    float_tol=float_tol,
-                                    list_order=list_order,
-                                    dict_extra=dict_extra)
-                       for va, vb in zip(a, b))
+            for i, (va, vb) in enumerate(zip(a, b)):
+                yield from json_difference(va,
+                                           vb,
+                                           (node_path or []) + [i],
+                                           int_strict=int_strict,
+                                           float_tol=float_tol,
+                                           list_order=list_order,
+                                           dict_extra=dict_extra)
         else:
-            return all(json_compare(va,
-                                    vb,
-                                    int_strict=int_strict,
-                                    float_tol=float_tol,
-                                    list_order=list_order,
-                                    dict_extra=dict_extra)
-                       for va, vb in zip(sorted(a), sorted(b)))
-
-    raise ValueError(f"incompatible type '{type(a)}' and '{type(b)}'")
+            for i, (va, vb) in enumerate(zip(sorted(a), sorted(b))):
+                yield from json_difference(va,
+                                           vb,
+                                           (node_path or []) + [i],
+                                           int_strict=int_strict,
+                                           float_tol=float_tol,
+                                           list_order=list_order,
+                                           dict_extra=dict_extra)
+        return
+
+    yield node_path, f"type mismatch: '{type(a)}' vs '{type(b)}'"
+
+
+def json_equals(
+    a: JsonTypeCompatible,
+    b: JsonTypeCompatible,
+    *,
+    int_strict: bool = False,
+    float_tol: float = 1e-5,
+    list_order: bool = True,
+    dict_extra: bool = False,
+) -> bool:
+    """
+    Compares two JSON-like structures for equality based on specified criteria.
+
+    :param a: The first JSON-compatible object to compare.
+    :param b: The second JSON-compatible object to compare.
+    :param int_strict: Whether to require strict integer type matching.
+    :param float_tol: The tolerance for comparing float values.
+    :param list_order: Whether to require list order to match.
+    :param dict_extra: Whether to allow extra keys in dictionaries.
+    :return: ``True`` if the structures are considered equal, ``False`` otherwise.
+    """
+    return next(json_difference(a,
+                                b,
+                                node_path=[],
+                                int_strict=int_strict,
+                                float_tol=float_tol,
+                                list_order=list_order,
+                                dict_extra=dict_extra),
+                None) is None
+
+
+json_compare = json_equals

{iker_python_common-1.0.58 → iker_python_common-1.0.60}/src/iker/common/utils/shutils.py

@@ -95,7 +95,11 @@ def path_depth(root: str, child: str) -> int:
     return child_expanded[len(root_expanded):].count(os.sep)
 
 
-def glob_match(names: list[str], include_patterns: list[str] = None, exclude_patterns: list[str] = None) -> list[str]:
+def glob_match(
+    names: list[str],
+    include_patterns: list[str] | None = None,
+    exclude_patterns: list[str] | None = None,
+) -> list[str]:
     """
     Applies the given inclusive and exclusive glob patterns to the given ``names`` and returns the filtered result.
 
@@ -121,8 +125,8 @@ class CopyFuncProtocol(Protocol):
 def listfile(
     path: str,
     *,
-    include_patterns: list[str] = None,
-    exclude_patterns: list[str] = None,
+    include_patterns: list[str] | None = None,
+    exclude_patterns: list[str] | None = None,
     depth: int = 0,
 ) -> list[str]:
     """
@@ -153,8 +157,8 @@ def copy(
     src: str,
     dst: str,
     *,
-    include_patterns: list[str] = None,
-    exclude_patterns: list[str] = None,
+    include_patterns: list[str] | None = None,
+    exclude_patterns: list[str] | None = None,
     depth: int = 0,
     follow_symlinks: bool = False,
     ignore_dangling_symlinks: bool = False,

{iker_python_common-1.0.58 → iker_python_common-1.0.60}/src/iker_python_common.egg-info/PKG-INFO

@@ -1,12 +1,11 @@
 Metadata-Version: 2.4
 Name: iker-python-common
-Version: 1.0.58
+Version: 1.0.60
 Classifier: Programming Language :: Python :: 3
 Classifier: Programming Language :: Python :: 3.12
 Classifier: Programming Language :: Python :: 3.13
 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>=2.3
 Requires-Dist: psycopg>=3.2
@@ -16,7 +15,6 @@ Provides-Extra: all
 Requires-Dist: iker-python-common; extra == "all"
 Provides-Extra: test
 Requires-Dist: ddt>=1.7; extra == "test"
-Requires-Dist: moto[all,ec2,s3]>=5.0; extra == "test"
 Requires-Dist: pytest-cov>=5.0; extra == "test"
 Requires-Dist: pytest-mysql>=3.0; extra == "test"
 Requires-Dist: pytest-order>=1.3; extra == "test"

{iker_python_common-1.0.58 → iker_python_common-1.0.60}/src/iker_python_common.egg-info/SOURCES.txt

@@ -10,16 +10,6 @@ setup.py
 resources/unittest/config/config.cfg
 resources/unittest/csv/data.csv
 resources/unittest/csv/data.tsv
-resources/unittest/s3utils/dir.baz/file.bar.baz
-resources/unittest/s3utils/dir.baz/file.foo.bar
-resources/unittest/s3utils/dir.baz/file.foo.baz
-resources/unittest/s3utils/dir.foo/file.bar
-resources/unittest/s3utils/dir.foo/file.baz
-resources/unittest/s3utils/dir.foo/file.foo
-resources/unittest/s3utils/dir.foo/dir.foo.bar/file.bar.baz
-resources/unittest/s3utils/dir.foo/dir.foo.bar/file.foo.bar
-resources/unittest/s3utils/dir.foo/dir.foo.bar/file.foo.baz
-resources/unittest/s3utils/dir.foo/dir.foo.bar/dir.foo.bar.baz/file.foo.bar.baz
 resources/unittest/shutils/dir.baz/file.bar.baz
 resources/unittest/shutils/dir.baz/file.foo.bar
 resources/unittest/shutils/dir.baz/file.foo.baz
@@ -44,7 +34,6 @@ src/iker/common/utils/logger.py
 src/iker/common/utils/numutils.py
 src/iker/common/utils/randutils.py
 src/iker/common/utils/retry.py
-src/iker/common/utils/s3utils.py
 src/iker/common/utils/sequtils.py
 src/iker/common/utils/shutils.py
 src/iker/common/utils/span.py
@@ -72,7 +61,6 @@ test/iker_tests/common/utils/logger_test.py
 test/iker_tests/common/utils/numutils_test.py
 test/iker_tests/common/utils/randutils_test.py
 test/iker_tests/common/utils/retry_test.py
-test/iker_tests/common/utils/s3utils_test.py
 test/iker_tests/common/utils/sequtils_test.py
 test/iker_tests/common/utils/shutils_test.py
 test/iker_tests/common/utils/span_test.py

{iker_python_common-1.0.58 → iker_python_common-1.0.60}/src/iker_python_common.egg-info/requires.txt

@@ -1,4 +1,3 @@
-boto3>=1.35
 docker>=7.1
 numpy>=2.3
 psycopg>=3.2
@@ -10,7 +9,6 @@ iker-python-common
 
 [test]
 ddt>=1.7
-moto[all,ec2,s3]>=5.0
 pytest-cov>=5.0
 pytest-mysql>=3.0
 pytest-order>=1.3

{iker_python_common-1.0.58 → iker_python_common-1.0.60}/test/iker_tests/common/utils/funcutils_test.py

@@ -4,6 +4,7 @@ import unittest
 import ddt
 
 from iker.common.utils.funcutils import composable, identity
+from iker.common.utils.funcutils import const, first, packed, second
 from iker.common.utils.funcutils import lazy, memorized, singleton, unique_returns
 from iker.common.utils.randutils import randomizer
 
@@ -19,6 +20,45 @@ class Counter(object):
 @ddt.ddt
 class FuncUtilsTest(unittest.TestCase):
 
+    def test_const(self):
+        self.assertEqual(5, const(5)())
+        self.assertEqual(5, const(5)(1, 2, 3))
+        self.assertEqual(5, const(5)(a=1, b=2))
+
+        self.assertEqual("hello", const("hello")())
+        self.assertEqual("hello", const("hello")(1, 2, 3))
+        self.assertEqual("hello", const("hello")(a=1, b=2))
+
+    def test_first(self):
+        self.assertEqual(1, first()((1, "a")))
+        self.assertEqual("key", first()(("key", 12)))
+        self.assertEqual((1, 2), first()(((1, 2), "value")))
+
+        with self.assertRaises(ValueError):
+            first()((1, 2, 3))
+        with self.assertRaises(ValueError):
+            first()(123)
+
+    def test_second(self):
+        self.assertEqual("a", second()((1, "a")))
+        self.assertEqual(12, second()(("key", 12)))
+        self.assertEqual("value", second()(((1, 2), "value")))
+
+        with self.assertRaises(ValueError):
+            second()((1, 2, 3))
+        with self.assertRaises(ValueError):
+            second()(123)
+
+    def test_packed(self):
+        self.assertEqual(3, packed(lambda x, y: x + y)((1, 2)))
+        self.assertEqual(12, packed(lambda x, y, z: x + y + z)((3, 4, 5)))
+        self.assertEqual("aab", packed(lambda a, b, x, y: a * x + b * y)(("a", "b", 2, 1)))
+
+        with self.assertRaises(TypeError):
+            packed(lambda x, y, z: x ** y ** z)((2, 3, 4, 5))
+        with self.assertRaises(TypeError):
+            packed(lambda x, y, z: x ** y ** z)((2, 3))
+
     def test_identity(self):
         self.assertEqual(1, identity(1))
         self.assertEqual("test", identity("test"))