cbrkit 0.26.3__tar.gz → 0.26.4__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: cbrkit
-Version: 0.26.3
+Version: 0.26.4
 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.3 → cbrkit-0.26.4}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "cbrkit"
-version = "0.26.3"
+version = "0.26.4"
 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.3 → cbrkit-0.26.4}/src/cbrkit/sim/graphs/astar.py

@@ -1,7 +1,7 @@
 import heapq
-from collections.abc import Mapping
+from collections.abc import Collection, Mapping
 from dataclasses import dataclass, field
-from typing import Protocol
+from typing import Any, Protocol, cast
 
 from ...helpers import (
     get_logger,
@@ -34,6 +34,33 @@ __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
@@ -157,15 +184,11 @@ class select1[K, N, E, G](SelectionFunc[K, N, E, G]):
     ) -> None | tuple[K, GraphElementType]:
         """Select the next node or edge to be mapped"""
 
-        try:
-            return next(iter(s.open_y_nodes)), "node"
-        except StopIteration:
-            pass
+        if s.open_y_nodes:
+            return next_elem(s.open_y_nodes), "node"
 
-        try:
-            return next(iter(s.open_y_edges)), "edge"
-        except StopIteration:
-            pass
+        if s.open_y_edges:
+            return next_elem(s.open_y_edges), "edge"
 
         return None
 
@@ -182,20 +205,18 @@ class select2[K, N, E, G](SelectionFunc[K, N, E, G]):
     ) -> None | tuple[K, GraphElementType]:
         """Select the next node or edge to be mapped"""
 
-        try:
-            return next(
-                key
-                for key in 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
-            ), "edge"
-        except StopIteration:
-            pass
+        edge_candidates = {
+            key
+            for key in 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
+        }
 
-        try:
-            return next(iter(s.open_y_nodes)), "node"
-        except StopIteration:
-            pass
+        if edge_candidates:
+            return next_elem(edge_candidates), "edge"
+
+        if s.open_y_nodes:
+            return next_elem(s.open_y_nodes), "node"
 
         return None
 
@@ -246,19 +267,36 @@ class select3[K, N, E, G](SelectionFunc[K, N, E, G]):
 
         if not heuristic_scores:
             # Fallback: select any remaining node or edge for null mapping
+            # Use sorted to ensure deterministic selection
             if s.open_y_nodes:
-                return next(iter(s.open_y_nodes)), "node"
+                return next_elem(s.open_y_nodes), "node"
             elif s.open_y_edges:
-                return next(iter(s.open_y_edges)), "edge"
+                return next_elem(s.open_y_edges), "edge"
             return None
 
+        # Find the maximum heuristic score
         max_score = max(heuristic_scores.values())
-        best_selections = [
+        best_selections = {
             key for key, value in heuristic_scores.items() if value == max_score
-        ]
+        }
 
         # if multiple selections have the same score, select the one with the lowest number of possible mappings
-        best_selection = min(best_selections, key=lambda key: mapping_options[key])
+        if len(best_selections) > 1:
+            min_mapping_options = min(mapping_options[key] for key in best_selections)
+            best_selections = {
+                key
+                for key in best_selections
+                if mapping_options[key] == min_mapping_options
+            }
+
+        # 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
 
@@ -290,7 +328,7 @@ class build[K, N, E, G](
         beam_width: Limits the queue size which prunes the search space.
             This leads to a faster search and less memory usage but also introduces a similarity error.
             Disabled by default. Based on [Neuhaus et al. (2006)](https://doi.org/10.1007/11815921_17).
-        pathlength_weight: Add a penalty for states with few mapped elements that already have a low similarity.
+        pathlength_weight: Favor long partial edit paths over shorter ones.
             Disabled by default. Based on [Neuhaus et al. (2006)](https://doi.org/10.1007/11815921_17).
 
     Returns:
@@ -356,22 +394,11 @@ class build[K, N, E, G](
         prio = 1 - (past_sim + future_sim)
 
         if self.pathlength_weight > 0:
-            node_null_mapping = (
-                set(y.nodes.keys())
-                - set(state.node_mapping.keys())
-                - set(state.open_y_nodes)
-            )
-            edge_null_mapping = (
-                set(y.edges.keys())
-                - set(state.edge_mapping.keys())
-                - set(state.open_y_edges)
-            )
-            num_paths = (
-                len(state.node_mapping)
-                + len(state.edge_mapping)
-                + len(node_null_mapping)
-                + len(edge_null_mapping)
-            )
+            # Calculate the number of mapping decisions made so far (partial edit path length)
+            # This includes actual mappings plus null mappings (elements processed but not mapped)
+            total_y_elements = len(y.nodes) + len(y.edges)
+            open_y_elements = len(state.open_y_nodes) + len(state.open_y_edges)
+            num_paths = total_y_elements - open_y_elements
             return prio / (self.pathlength_weight**num_paths)
 
         return prio
@@ -432,7 +459,8 @@ class build[K, N, E, G](
                 heapq.heappush(open_set, PriorityState(next_prio, next_state))
 
             if self.beam_width > 0 and len(open_set) > self.beam_width:
-                open_set = open_set[: self.beam_width]
+                open_set = heapq.nsmallest(self.beam_width, open_set)
+                heapq.heapify(open_set)
 
         return self.similarity(
             x,