cbrkit 0.26.4__tar.gz → 0.26.5__tar.gz

{cbrkit-0.26.4 → cbrkit-0.26.5}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: cbrkit
-Version: 0.26.4
+Version: 0.26.5
 Summary: Customizable Case-Based Reasoning (CBR) toolkit for Python with a built-in API and CLI
 Keywords: cbr,case-based reasoning,api,similarity,nlp,retrieval,cli,tool,library
 Author: Mirko Lenz

{cbrkit-0.26.4 → cbrkit-0.26.5}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "cbrkit"
-version = "0.26.4"
+version = "0.26.5"
 description = "Customizable Case-Based Reasoning (CBR) toolkit for Python with a built-in API and CLI"
 authors = [{ name = "Mirko Lenz", email = "mirko@mirkolenz.com" }]
 readme = "README.md"

{cbrkit-0.26.4 → cbrkit-0.26.5}/src/cbrkit/eval/common.py

@@ -244,7 +244,7 @@ def kendall_tau(
         qrel_relevant = {k for k, v in qrels[key].items() if v >= relevance_level}
         sorted_qrel_relevant = sorted(qrel_relevant, key=lambda x: qrels[key][x])
 
-        sorted_run = sorted(run.keys(), key=lambda x: run[key][x], reverse=True)
+        sorted_run = sorted(run[key].keys(), key=lambda x: run[key][x], reverse=True)
         run_k = sorted_run[: k if k > 0 else len(sorted_run)]
 
         max_idx = min(len(run_k), len(sorted_qrel_relevant))

{cbrkit-0.26.4 → cbrkit-0.26.5}/src/cbrkit/eval/retrieval.py

@@ -1,7 +1,7 @@
 from collections.abc import Sequence
 from typing import Any, Literal
 
-from ..helpers import round, scale, unpack_float
+from ..helpers import normalize_and_scale, round, unpack_float
 from ..retrieval import Result, ResultStep
 from ..typing import EvalMetricFunc, Float, QueryCaseMatrix
 from .common import DEFAULT_METRICS, compute
@@ -65,12 +65,10 @@ def retrieval_step_to_qrels[Q, C, S: Float](
         min_sim = 0.0
         max_sim = 1.0
 
-    qrel_factor = max_qrel - min_qrel
-
     return {
         query: {
             case: round(
-                scale(sim, min_sim, max_sim) * qrel_factor + min_qrel,
+                normalize_and_scale(sim, min_sim, max_sim, min_qrel, max_qrel),
                 round_mode,
             )
             for case, sim in entry.items()

{cbrkit-0.26.4 → cbrkit-0.26.5}/src/cbrkit/helpers.py

@@ -71,6 +71,8 @@ __all__ = [
     "load_callables_map",
     "load_callables",
     "load_object",
+    "normalize",
+    "normalize_and_scale",
     "log_batch",
     "mp_count",
     "mp_map",
@@ -605,6 +607,30 @@ def scale(value: float, lower: float, upper: float) -> float:
     return value * (upper - lower) + lower
 
 
+def normalize(value: float, value_min: float, value_max: float) -> float:
+    """Normalize a value from [value_min, value_max] to [0, 1]."""
+    if value_max == value_min:
+        # Handle edge case where all values are identical
+        return 0.0
+
+    return (value - value_min) / (value_max - value_min)
+
+
+def normalize_and_scale(
+    value: float,
+    value_min: float,
+    value_max: float,
+    target_min: float,
+    target_max: float,
+) -> float:
+    """Normalize a value from [value_min, value_max] to [target_min, target_max]."""
+    # First normalize to [0, 1]
+    normalized = normalize(value, value_min, value_max)
+
+    # Then scale to target range
+    return scale(normalized, target_min, target_max)
+
+
 def load_object(import_name: str) -> Any:
     """Import an object based on a string.
 

{cbrkit-0.26.4 → cbrkit-0.26.5}/src/cbrkit/sim/graphs/astar.py

@@ -1,7 +1,7 @@
 import heapq
-from collections.abc import Collection, Mapping
+from collections.abc import Mapping
 from dataclasses import dataclass, field
-from typing import Any, Protocol, cast
+from typing import Protocol
 
 from ...helpers import (
     get_logger,
@@ -13,11 +13,7 @@ from ...model.graph import (
     Node,
 )
 from ...typing import SimFunc
-from .common import (
-    GraphSim,
-    SearchGraphSimFunc,
-    SearchState,
-)
+from .common import GraphSim, SearchGraphSimFunc, SearchState, next_elem, sorted_iter
 
 __all__ = [
     "HeuristicFunc",
@@ -34,33 +30,6 @@ __all__ = [
 logger = get_logger(__name__)
 
 
-def next_elem[K](elements: Collection[K]) -> K:
-    """Select the next element from a set deterministically.
-
-    If elements are sortable, returns the smallest one.
-    Otherwise, returns the first element from iteration.
-
-    Args:
-        elements: Set of elements to choose from
-
-    Returns:
-        A single element from the set
-
-    Raises:
-        ValueError: If the set is empty
-    """
-    if not elements:
-        raise ValueError("Cannot select from empty set")
-
-    if len(elements) == 1:
-        return next(iter(elements))
-
-    try:
-        return min(cast(Collection[Any], elements))
-    except TypeError:
-        return next(iter(elements))
-
-
 @dataclass(slots=True, frozen=True, order=True)
 class PriorityState[K]:
     priority: float
@@ -207,7 +176,7 @@ class select2[K, N, E, G](SelectionFunc[K, N, E, G]):
 
         edge_candidates = {
             key
-            for key in s.open_y_edges
+            for key in sorted_iter(s.open_y_edges)
             if y.edges[key].source.key not in s.open_y_nodes
             and y.edges[key].target.key not in s.open_y_nodes
         }
@@ -290,15 +259,10 @@ class select3[K, N, E, G](SelectionFunc[K, N, E, G]):
             }
 
         # select the one with the lowest key
-        try:
-            best_selection = min(
-                best_selections,
-                key=lambda item: cast(Any, item[0]),
-            )
-        except TypeError:
-            best_selection = next(iter(best_selections))
-
-        selection_key, selection_type = best_selection
+        selection_key, selection_type = next_elem(
+            best_selections,
+            key=lambda item: item[0],
+        )
 
         if selection_type == "edge":
             edge = y.edges[selection_key]

{cbrkit-0.26.4 → cbrkit-0.26.5}/src/cbrkit/sim/graphs/common.py

@@ -1,6 +1,6 @@
 import itertools
 from collections import defaultdict
-from collections.abc import Mapping, Sequence
+from collections.abc import Callable, Collection, Iterable, Mapping, Sequence
 from dataclasses import dataclass, field
 from typing import Any, Protocol, cast
 
@@ -247,6 +247,44 @@ class SearchState[K]:
     open_x_edges: frozenset[K]
 
 
+def sorted_iter[K](iterable: Iterable[K]) -> Iterable[K]:
+    """Sort an iterable if possible, otherwise return it unchanged."""
+    try:
+        return sorted(cast(Iterable[Any], iterable))
+    except TypeError:
+        return iterable
+
+
+def next_elem[K](
+    elements: Collection[K],
+    key: Callable[[K], Any] | None = None,
+) -> K:
+    """Select the next element from a set deterministically.
+
+    If elements are sortable, returns the smallest one.
+    Otherwise, returns the first element from iteration.
+
+    Args:
+        elements: Set of elements to choose from
+
+    Returns:
+        A single element from the set
+
+    Raises:
+        ValueError: If the set is empty
+    """
+    if not elements:
+        raise ValueError("Cannot select from empty set")
+
+    if len(elements) == 1:
+        return next(iter(elements))
+
+    try:
+        return min(cast(Iterable[Any], elements), key=key)
+    except TypeError:
+        return next(iter(elements))
+
+
 class SearchStateInit[K, N, E, G](Protocol):
     def __call__(
         self,
@@ -413,7 +451,7 @@ class SearchGraphSimFunc[K, N, E, G](BaseGraphSimFunc[K, N, E, G]):
                 state.open_x_nodes - {x_key},
                 state.open_x_edges,
             )
-            for x_key in state.open_x_nodes
+            for x_key in sorted_iter(state.open_x_nodes)
             if self.legal_node_mapping(x, y, state, x_key, y_key)
         ]
 
@@ -447,7 +485,7 @@ class SearchGraphSimFunc[K, N, E, G](BaseGraphSimFunc[K, N, E, G]):
                 state.open_x_nodes,
                 state.open_x_edges - {x_key},
             )
-            for x_key in state.open_x_edges
+            for x_key in sorted_iter(state.open_x_edges)
             if self.legal_edge_mapping(x, y, state, x_key, y_key)
         ]
 
@@ -473,10 +511,9 @@ class SearchGraphSimFunc[K, N, E, G](BaseGraphSimFunc[K, N, E, G]):
         y_key: K,
     ) -> list[SearchState[K]]:
         """Expand a given edge and map its source/target node if not already mapped"""
-
         next_states: list[SearchState[K]] = []
 
-        for x_key in state.open_x_edges:
+        for x_key in sorted_iter(state.open_x_edges):
             next_state = state
             x_source_key = x.edges[x_key].source.key
             x_target_key = x.edges[x_key].target.key