iker-python-common 1.0.59__py3-none-any.whl → 1.0.60__py3-none-any.whl

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/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.59.dist-info → iker_python_common-1.0.60.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: iker-python-common
-Version: 1.0.59
+Version: 1.0.60
 Classifier: Programming Language :: Python :: 3
 Classifier: Programming Language :: Python :: 3.12
 Classifier: Programming Language :: Python :: 3.13

{iker_python_common-1.0.59.dist-info → iker_python_common-1.0.60.dist-info}/RECORD

@@ -6,8 +6,8 @@ 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=hHk7UHI-h92F8CFff-SZGvfhSlZ-CkO2dI8GWa6V81Q,5734
-iker/common/utils/jsonutils.py,sha256=Df4uxEgIejEhZdrfmiT4DX2aewEX0Pqbl1n4OCN4YdI,15970
+iker/common/utils/funcutils.py,sha256=4AkkvK9_Z2tgk1-Sp6-vLLVhI15cIgN9xW58QqL5QL4,7780
+iker/common/utils/jsonutils.py,sha256=AkziMAYVQDODHRqZC-c1x7VqI2hHY3Kxrw7gmoss8mU,18527
 iker/common/utils/logger.py,sha256=FJaai6Sbchy4wKHcUMUCrrkBcXvIxq4qByERZ_TJBps,3881
 iker/common/utils/numutils.py,sha256=p6Rz1qyCcUru3v1zDy2PM-nds2NWJdL5A_vLmG-kswk,4294
 iker/common/utils/randutils.py,sha256=Sxf852B18CJ-MfrEDsv1ROO_brmz79dRZ4jpJiH65v4,12843
@@ -18,7 +18,7 @@ iker/common/utils/span.py,sha256=u_KuWi2U7QDMUotl4AeW2_57ItL3YhVDSeCwaOiFDvs,596
 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.59.dist-info/METADATA,sha256=C3LhE0abnoE8e5KeGHrKj2DmN8RCL8fP7M9aWY6KVE0,813
-iker_python_common-1.0.59.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-iker_python_common-1.0.59.dist-info/top_level.txt,sha256=4_B8Prfc_lxFafFYTQThIU1ZqOYQ4pHHHnJ_fQ_oHs8,5
-iker_python_common-1.0.59.dist-info/RECORD,,
+iker_python_common-1.0.60.dist-info/METADATA,sha256=2B3f-_-H83ceea3JraxM602M47-BcdClWBtZIZLF_I0,813
+iker_python_common-1.0.60.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+iker_python_common-1.0.60.dist-info/top_level.txt,sha256=4_B8Prfc_lxFafFYTQThIU1ZqOYQ4pHHHnJ_fQ_oHs8,5
+iker_python_common-1.0.60.dist-info/RECORD,,