cbrkit 0.23.2__tar.gz → 0.24.0__tar.gz

{cbrkit-0.23.2/src/cbrkit.egg-info → cbrkit-0.24.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: cbrkit
-Version: 0.23.2
+Version: 0.24.0
 Summary: Customizable Case-Based Reasoning (CBR) toolkit for Python with a built-in API and CLI
 Author-email: Mirko Lenz <mirko@mirkolenz.com>
 Project-URL: Repository, https://github.com/wi2trier/cbrkit

{cbrkit-0.23.2 → cbrkit-0.24.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "cbrkit"
-version = "0.23.2"
+version = "0.24.0"
 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.23.2 → cbrkit-0.24.0}/src/cbrkit/loaders.py

@@ -46,7 +46,7 @@ def read(data: ReadableType) -> str:
     elif isinstance(data, bytes | bytearray):
         return data.decode("utf-8")
 
-    return read(data.read())
+    return read(data.read())  # pyright: ignore
 
 
 @dataclass(slots=True, frozen=True)
@@ -102,7 +102,7 @@ class csv(ConversionFunc[Iterable[str] | ReadableType, dict[int, dict[str, str]]
         if isinstance(source, ReadableType):
             source = read(source).splitlines()
 
-        reader = csvlib.DictReader(source)
+        reader = csvlib.DictReader(source)  # pyright: ignore
         data: dict[int, dict[str, str]] = {}
         row: dict[str, str]
 

{cbrkit-0.23.2 → cbrkit-0.24.0}/src/cbrkit/retrieval/__init__.py

@@ -1,7 +1,7 @@
 from ..helpers import optional_dependencies
 from ..model import QueryResultStep, Result, ResultStep
 from .apply import apply_batches, apply_queries, apply_query
-from .build import build, dropout, transpose, transpose_value
+from .build import build, distribute, dropout, transpose, transpose_value
 
 with optional_dependencies():
     from .rerank import cohere
@@ -17,6 +17,7 @@ __all__ = [
     "transpose",
     "transpose_value",
     "dropout",
+    "distribute",
     "apply_batches",
     "apply_queries",
     "apply_query",

{cbrkit-0.23.2 → cbrkit-0.24.0}/src/cbrkit/retrieval/build.py

@@ -1,4 +1,4 @@
-import math
+import itertools
 from collections.abc import Sequence
 from dataclasses import dataclass
 from multiprocessing.pool import Pool
@@ -119,6 +119,33 @@ def transpose_value[K, V, S: Float](
     return transpose(retriever_func, get_value)
 
 
+@dataclass(slots=True, frozen=True)
+class distribute[K, V, S: Float](RetrieverFunc[K, V, S]):
+    """Distributes the retrieval process by passing each batch separately to the retriever function.
+
+    Args:
+        retriever_func: The retriever function to be used.
+            Typically constructed with the `build` function.
+        multiprocessing: Either a boolean to enable multiprocessing with all cores
+            or an integer to specify the number of processes to use or a multiprocessing.Pool object.
+
+    Returns:
+        A retriever function that distributes the retrieval process.
+    """
+
+    retriever_func: RetrieverFunc[K, V, S]
+    multiprocessing: Pool | int | bool
+
+    def __call_batch__(self, x: Casebase[K, V], y: V) -> SimMap[K, S]:
+        return self.retriever_func([(x, y)])[0]
+
+    @override
+    def __call__(
+        self, batches: Sequence[tuple[Casebase[K, V], V]]
+    ) -> Sequence[SimMap[K, S]]:
+        return mp_starmap(self.__call_batch__, batches, self.multiprocessing, logger)
+
+
 @dataclass(slots=True, frozen=True)
 class build[K, V, S: Float](RetrieverFunc[K, V, S]):
     """Based on the similarity function this function creates a retriever function.
@@ -153,24 +180,12 @@ class build[K, V, S: Float](RetrieverFunc[K, V, S]):
 
     similarity_func: MaybeFactory[AnySimFunc[V, S]]
     multiprocessing: Pool | int | bool = False
-    chunksize: int | None = None
-
-    def __call_single__(self, x: Casebase[K, V], y: V) -> SimMap[K, S]:
-        sim_func = batchify_sim(self.similarity_func)
-        flat_batches = [(x, y) for x in x.values()]
-        flat_sims: Sequence[S] = sim_func(flat_batches)
-
-        return {key: sim for key, sim in zip(x.keys(), flat_sims, strict=True)}
+    chunksize: int = 0
 
     @override
     def __call__(
         self, batches: Sequence[tuple[Casebase[K, V], V]]
     ) -> Sequence[SimMap[K, S]]:
-        if self.chunksize is None:
-            return mp_starmap(
-                self.__call_single__, batches, self.multiprocessing, logger
-            )
-
         sim_func = batchify_sim(self.similarity_func)
         similarities: list[dict[K, S]] = [{} for _ in range(len(batches))]
 
@@ -183,15 +198,15 @@ class build[K, V, S: Float](RetrieverFunc[K, V, S]):
                 flat_batches_index.append((idx, key))
                 flat_batches.append((case, query))
 
-        if use_mp(self.multiprocessing):
-            chunksize = self.chunksize or math.ceil(
-                len(flat_batches) / mp_count(self.multiprocessing)
+        if use_mp(self.multiprocessing) or self.chunksize > 0:
+            chunksize = (
+                self.chunksize
+                if self.chunksize > 0
+                else len(flat_batches) // mp_count(self.multiprocessing)
             )
             batch_chunks = list(chunkify(flat_batches, chunksize))
             sim_chunks = mp_map(sim_func, batch_chunks, self.multiprocessing, logger)
-
-            for sim_chunk in sim_chunks:
-                flat_sims.extend(sim_chunk)
+            flat_sims = list(itertools.chain.from_iterable(sim_chunks))
 
         else:
             flat_sims = sim_func(flat_batches)

{cbrkit-0.23.2 → cbrkit-0.24.0}/src/cbrkit/retrieval/rerank.py

@@ -150,7 +150,7 @@ with optional_dependencies():
             batches: Sequence[tuple[Casebase[K, str], str]],
         ) -> Sequence[dict[K, float]]:
             if isinstance(self.model, str):
-                model = SentenceTransformer(self.model, device=self.device)
+                model = SentenceTransformer(self.model, device=self.device)  # pyright: ignore
             else:
                 model = self.model
 

{cbrkit-0.23.2 → cbrkit-0.24.0}/src/cbrkit/sim/embed.py

@@ -357,7 +357,7 @@ with optional_dependencies():
             self._metadata = {}
 
             if isinstance(model, str):
-                self.model = SentenceTransformer(model)
+                self.model = SentenceTransformer(model)  # pyright: ignore
                 self._metadata["model"] = model
             else:
                 self.model = model

{cbrkit-0.23.2 → cbrkit-0.24.0}/src/cbrkit/sim/graphs/__init__.py

@@ -1,7 +1,12 @@
 from ...helpers import optional_dependencies
-from . import astar
+from . import astar, greedy
 from .brute_force import brute_force
-from .common import ElementMatcher, GraphSim, default_element_matcher
+from .common import (
+    ElementMatcher,
+    GraphSim,
+    default_element_matcher,
+    type_element_matcher,
+)
 from .isomorphism import isomorphism
 from .precompute import precompute
 
@@ -13,6 +18,7 @@ with optional_dependencies():
 
 __all__ = [
     "astar",
+    "greedy",
     "brute_force",
     "isomorphism",
     "precompute",
@@ -21,4 +27,5 @@ __all__ = [
     "GraphSim",
     "ElementMatcher",
     "default_element_matcher",
+    "type_element_matcher",
 ]

{cbrkit-0.23.2 → cbrkit-0.24.0}/src/cbrkit/sim/graphs/astar.py

@@ -2,7 +2,7 @@ import heapq
 import itertools
 from collections import defaultdict
 from collections.abc import Mapping, Sequence
-from dataclasses import dataclass, field
+from dataclasses import InitVar, dataclass, field
 from typing import Protocol, override
 
 from frozendict import frozendict
@@ -406,14 +406,18 @@ class init1[K, N, E, G](InitFunc[K, N, E, G]):
         )
 
 
-@dataclass(slots=True, frozen=True)
+@dataclass(slots=True, init=False)
 class init2[K, N, E, G](InitFunc[K, N, E, G]):
-    legal_node_mapping: LegalMappingFunc[K, N, E, G] = field(
-        default_factory=lambda: legal_node_mapping(default_element_matcher)
-    )
-    legal_edge_mapping: LegalMappingFunc[K, N, E, G] = field(
-        default_factory=lambda: legal_edge_mapping(default_element_matcher)
-    )
+    legal_node_mapping: LegalMappingFunc[K, N, E, G]
+    legal_edge_mapping: LegalMappingFunc[K, N, E, G]
+
+    def __init__(
+        self,
+        node_matcher: ElementMatcher[N],
+        edge_matcher: ElementMatcher[E] = default_element_matcher,
+    ):
+        self.legal_node_mapping = legal_node_mapping(node_matcher)
+        self.legal_edge_mapping = legal_edge_mapping(edge_matcher)
 
     def __call__(
         self,
@@ -525,7 +529,7 @@ class legal_edge_mapping[K, N, E, G](LegalMappingFunc[K, N, E, G]):
         )
 
 
-@dataclass(slots=True, frozen=True)
+@dataclass(slots=True)
 class build[K, N, E, G](SimFunc[Graph[K, N, E, G], GraphSim[K]]):
     """
     Performs the A* algorithm proposed by [Bergmann and Gil (2014)](https://doi.org/10.1016/j.is.2012.07.005) to compute the similarity between a query graph and the graphs in the casebase.
@@ -546,18 +550,22 @@ class build[K, N, E, G](SimFunc[Graph[K, N, E, G], GraphSim[K]]):
 
     past_cost_func: PastSimFunc[K, N, E, G]
     future_cost_func: FutureSimFunc[K, N, E, G]
+    node_matcher: InitVar[ElementMatcher[N]]
+    edge_matcher: InitVar[ElementMatcher[E]] = default_element_matcher
     selection_func: SelectionFunc[K, N, E, G] = field(default_factory=select2)
     init_func: InitFunc[K, N, E, G] = field(default_factory=init1)
-    legal_node_mapping: LegalMappingFunc[K, N, E, G] = field(
-        default_factory=lambda: legal_node_mapping(default_element_matcher)
-    )
-    legal_edge_mapping: LegalMappingFunc[K, N, E, G] = field(
-        default_factory=lambda: legal_edge_mapping(default_element_matcher)
-    )
     queue_limit: int = 10000
+    legal_node_mapping: LegalMappingFunc[K, N, E, G] = field(init=False)
+    legal_edge_mapping: LegalMappingFunc[K, N, E, G] = field(init=False)
     # TODO: Currently not implemented as described in the paper, needs further investigation
     allow_case_oriented_mapping: bool = False
 
+    def __post_init__(
+        self, node_matcher: ElementMatcher[N], edge_matcher: ElementMatcher[E]
+    ) -> None:
+        self.legal_node_mapping = legal_node_mapping(node_matcher)
+        self.legal_edge_mapping = legal_edge_mapping(edge_matcher)
+
     def expand_node(
         self,
         x: Graph[K, N, E, G],

{cbrkit-0.23.2 → cbrkit-0.24.0}/src/cbrkit/sim/graphs/common.py

@@ -17,4 +17,8 @@ class ElementMatcher[T](Protocol):
 
 
 def default_element_matcher(x: Any, y: Any) -> bool:
+    return True
+
+
+def type_element_matcher(x: Any, y: Any) -> bool:
     return type(x) is type(y)

cbrkit-0.24.0/src/cbrkit/sim/graphs/greedy.py

@@ -0,0 +1,363 @@
+import itertools
+from collections.abc import Callable, Mapping, Sequence
+from dataclasses import dataclass
+from typing import Literal, Protocol, override
+
+from frozendict import frozendict
+
+from ...helpers import (
+    batchify_sim,
+    get_logger,
+    unpack_float,
+    unpack_floats,
+)
+from ...model.graph import (
+    Edge,
+    Graph,
+    Node,
+)
+from ...typing import AnySimFunc, BatchSimFunc, Float, SimFunc, StructuredValue
+from ..wrappers import transpose_value
+from .common import ElementMatcher, GraphSim, default_element_matcher
+
+logger = get_logger(__name__)
+
+__all__ = [
+    "build",
+    "init1",
+    "default_edge_sim",
+    "State",
+    "StateSim",
+    "InitFunc",
+    "LegalMappingFunc",
+    "build",
+    "legal_node_mapping",
+    "legal_edge_mapping",
+]
+
+
+@dataclass(slots=True, frozen=True)
+class State[K]:
+    # mappings are from y to x
+    mapped_nodes: frozendict[K, K]
+    mapped_edges: frozendict[K, K]
+    open_node_pairs: frozenset[tuple[K, K]]
+    open_edge_pairs: frozenset[tuple[K, K]]
+
+
+@dataclass(slots=True, frozen=True)
+class StateSim[K](StructuredValue[float]):
+    node_similarities: Mapping[K, float]
+    edge_similarities: Mapping[K, float]
+
+
+class InitFunc[K, N, E, G](Protocol):
+    def __call__(
+        self,
+        x: Graph[K, N, E, G],
+        y: Graph[K, N, E, G],
+        /,
+    ) -> State[K]: ...
+
+
+class LegalMappingFunc[K, N, E, G](Protocol):
+    def __call__(
+        self,
+        x: Graph[K, N, E, G],
+        y: Graph[K, N, E, G],
+        state: State[K],
+        x_key: K,
+        y_key: K,
+    ) -> bool: ...
+
+
+@dataclass(slots=True, frozen=True)
+class init1[K, N, E, G](InitFunc[K, N, E, G]):
+    def __call__(
+        self,
+        x: Graph[K, N, E, G],
+        y: Graph[K, N, E, G],
+    ) -> State[K]:
+        return State(
+            frozendict(),
+            frozendict(),
+            frozenset(itertools.product(y.nodes.keys(), x.nodes.keys())),
+            frozenset(itertools.product(y.edges.keys(), x.edges.keys())),
+        )
+
+
+@dataclass(slots=True, frozen=True)
+class default_edge_sim[K, N, E](BatchSimFunc[Edge[K, N, E], Float]):
+    node_sim_func: BatchSimFunc[Node[K, N], Float]
+
+    @override
+    def __call__(
+        self, batches: Sequence[tuple[Edge[K, N, E], Edge[K, N, E]]]
+    ) -> list[float]:
+        source_sims = self.node_sim_func([(x.source, y.source) for x, y in batches])
+        target_sims = self.node_sim_func([(x.target, y.target) for x, y in batches])
+
+        return [
+            0.5 * (unpack_float(source) + unpack_float(target))
+            for source, target in zip(source_sims, target_sims, strict=True)
+        ]
+
+
+@dataclass(slots=True, frozen=True)
+class legal_node_mapping[K, N, E, G](LegalMappingFunc[K, N, E, G]):
+    matcher: ElementMatcher[N]
+
+    def __call__(
+        self,
+        x: Graph[K, N, E, G],
+        y: Graph[K, N, E, G],
+        state: State[K],
+        x_key: K,
+        y_key: K,
+    ) -> bool:
+        return (
+            y_key not in state.mapped_nodes.keys()
+            and x_key not in state.mapped_nodes.values()
+            and self.matcher(x.nodes[x_key].value, y.nodes[y_key].value)
+        )
+
+
+@dataclass(slots=True, frozen=True)
+class legal_edge_mapping[K, N, E, G](LegalMappingFunc[K, N, E, G]):
+    matcher: ElementMatcher[E]
+
+    def __call__(
+        self,
+        x: Graph[K, N, E, G],
+        y: Graph[K, N, E, G],
+        state: State[K],
+        x_key: K,
+        y_key: K,
+    ) -> bool:
+        x_value = x.edges[x_key]
+        y_value = y.edges[y_key]
+        mapped_x_source_key = state.mapped_nodes.get(y_value.source.key)
+        mapped_x_target_key = state.mapped_nodes.get(y_value.target.key)
+
+        return (
+            y_key not in state.mapped_edges.keys()
+            and x_key not in state.mapped_edges.values()
+            and self.matcher(x_value.value, y_value.value)
+            # if the nodes are already mapped, check if they are mapped legally
+            and (
+                mapped_x_source_key is None or x_value.source.key == mapped_x_source_key
+            )
+            and (
+                mapped_x_target_key is None or x_value.target.key == mapped_x_target_key
+            )
+        )
+
+
+@dataclass(slots=True, init=False)
+class build[K, N, E, G](SimFunc[Graph[K, N, E, G], GraphSim[K]]):
+    """
+    Performs the A* algorithm proposed by [Bergmann and Gil (2014)](https://doi.org/10.1016/j.is.2012.07.005) to compute the similarity between a query graph and the graphs in the casebase.
+
+    Args:
+        past_cost_func: A heuristic function to compute the costs of all previous steps.
+        future_cost_func: A heuristic function to compute the future costs.
+        selection_func: A function to select the next node or edge to be mapped.
+        init_func: A function to initialize the state.
+        node_matcher: A function that returns true if two nodes can be mapped legally.
+        edge_matcher: A function that returns true if two edges can be mapped legally.
+        queue_limit: 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.
+
+    Returns:
+        The similarity between the query graph and the most similar graph in the casebase.
+    """
+
+    node_sim_func: BatchSimFunc[Node[K, N], Float]
+    edge_sim_func: BatchSimFunc[Edge[K, N, E], Float]
+    init_func: InitFunc[K, N, E, G]
+    legal_node_mapping: LegalMappingFunc[K, N, E, G]
+    legal_edge_mapping: LegalMappingFunc[K, N, E, G]
+    start_with: Literal["nodes", "edges"]
+
+    def __init__(
+        self,
+        node_sim_func: AnySimFunc[N, Float],
+        node_matcher: ElementMatcher[N],
+        edge_sim_func: AnySimFunc[Edge[K, N, E], Float] | None = None,
+        edge_matcher: ElementMatcher[E] = default_element_matcher,
+        init_func: InitFunc[K, N, E, G] | None = None,
+        start_with: Literal["nodes", "edges"] = "nodes",
+    ) -> None:
+        self.legal_node_mapping = legal_node_mapping(node_matcher)
+        self.legal_edge_mapping = legal_edge_mapping(edge_matcher)
+
+        self.node_sim_func = batchify_sim(transpose_value(node_sim_func))
+        self.edge_sim_func = (
+            default_edge_sim(self.node_sim_func)
+            if edge_sim_func is None
+            else batchify_sim(edge_sim_func)
+        )
+        self.init_func = init_func if init_func else init1()
+
+        self.start_with = start_with
+
+    def compute_similarity(
+        self,
+        x: Graph[K, N, E, G],
+        y: Graph[K, N, E, G],
+        s: State[K],
+    ) -> StateSim[K]:
+        """Function to compute the similarity based on the current state"""
+
+        node_sims = unpack_floats(
+            self.node_sim_func(
+                [
+                    (x.nodes[x_key], y.nodes[y_key])
+                    for y_key, x_key in s.mapped_nodes.items()
+                ]
+            )
+        )
+
+        edge_sims = unpack_floats(
+            self.edge_sim_func(
+                [
+                    (x.edges[x_key], y.edges[y_key])
+                    for y_key, x_key in s.mapped_edges.items()
+                ]
+            )
+        )
+
+        all_sims = itertools.chain(node_sims, edge_sims)
+        total_elements = len(y.nodes) + len(y.edges)
+
+        return StateSim(
+            sum(all_sims) / total_elements,
+            dict(zip(s.mapped_nodes.keys(), node_sims, strict=True)),
+            dict(zip(s.mapped_edges.keys(), edge_sims, strict=True)),
+        )
+
+    def expand_edges(
+        self,
+        x: Graph[K, N, E, G],
+        y: Graph[K, N, E, G],
+        state: State[K],
+    ) -> list[State[K]]:
+        """Expand the current state by adding all possible edge mappings"""
+
+        new_states = []
+
+        for y_key, x_key in state.open_edge_pairs:
+            if self.legal_edge_mapping(x, y, state, x_key, y_key):
+                new_state = State(
+                    state.mapped_nodes,
+                    state.mapped_edges.set(y_key, x_key),
+                    state.open_node_pairs,
+                    state.open_edge_pairs
+                    - {
+                        (y, x)
+                        for y, x in itertools.product(y.edges.keys(), x.edges.keys())
+                        if y == y_key or x == x_key
+                    },
+                )
+                new_states.append(new_state)
+
+        return new_states
+
+    def expand_nodes(
+        self,
+        x: Graph[K, N, E, G],
+        y: Graph[K, N, E, G],
+        state: State[K],
+    ) -> list[State[K]]:
+        """Expand the current state by adding all possible node mappings"""
+
+        new_states = []
+
+        for y_key, x_key in state.open_node_pairs:
+            if self.legal_node_mapping(x, y, state, x_key, y_key):
+                new_state = State(
+                    state.mapped_nodes.set(y_key, x_key),
+                    state.mapped_edges,
+                    state.open_node_pairs
+                    - {
+                        (y, x)
+                        for y, x in itertools.product(y.nodes.keys(), x.nodes.keys())
+                        if y == y_key or x == x_key
+                    },
+                    state.open_edge_pairs,
+                )
+                new_states.append(new_state)
+
+        return new_states
+
+    def expand(
+        self,
+        x: Graph[K, N, E, G],
+        y: Graph[K, N, E, G],
+        current_state: State[K],
+        current_sim: StateSim[K],
+        expand_func: Callable[
+            [Graph[K, N, E, G], Graph[K, N, E, G], State[K]], list[State[K]]
+        ],
+    ) -> tuple[State[K], StateSim[K]]:
+        """Expand the current state by adding all possible mappings"""
+
+        while True:
+            # Iterate over all open pairs and find the best pair
+            new_states = expand_func(x, y, current_state)
+            new_sims = [self.compute_similarity(x, y, state) for state in new_states]
+
+            best_sim, best_state = max(
+                zip(new_sims, new_states, strict=True), key=lambda item: item[0].value
+            )
+
+            # If no better pair is found, break the loop
+            if best_state == current_state and best_sim == current_sim:
+                break
+
+            # Update the current state and similarity
+            current_state = best_state
+            current_sim = best_sim
+
+        return current_state, current_sim
+
+    def __call__(
+        self,
+        x: Graph[K, N, E, G],
+        y: Graph[K, N, E, G],
+    ) -> GraphSim[K]:
+        """Perform greedy graph matching of the query y against the case x"""
+
+        current_state = self.init_func(x, y)
+        current_sim = self.compute_similarity(x, y, current_state)
+
+        if self.start_with == "edges":
+            current_state, current_sim = self.expand(
+                x, y, current_state, current_sim, self.expand_edges
+            )
+            current_state, current_sim = self.expand(
+                x, y, current_state, current_sim, self.expand_nodes
+            )
+        elif self.start_with == "nodes":
+            current_state, current_sim = self.expand(
+                x, y, current_state, current_sim, self.expand_nodes
+            )
+            current_state, current_sim = self.expand(
+                x, y, current_state, current_sim, self.expand_edges
+            )
+        else:
+            raise ValueError(
+                f"Invalid start_with value: {self.start_with}. Expected 'nodes' or 'edges'."
+            )
+
+        return GraphSim(
+            current_sim.value,
+            dict(current_state.mapped_nodes),
+            dict(current_state.mapped_edges),
+            dict(current_sim.node_similarities)
+            if isinstance(current_sim, StateSim)
+            else {},
+            dict(current_sim.edge_similarities)
+            if isinstance(current_sim, StateSim)
+            else {},
+        )

{cbrkit-0.23.2 → cbrkit-0.24.0}/src/cbrkit/sim/graphs/isomorphism.py

@@ -31,9 +31,9 @@ class isomorphism[K, N, E, G](SimFunc[Graph[K, N, E, G], GraphSim[K]]):
     """
 
     node_sim_func: AnySimFunc[N, Float]
-    aggregator: AggregatorFunc[Any, Float] = default_aggregator
-    node_matcher: ElementMatcher[N] = default_element_matcher
+    node_matcher: ElementMatcher[N]
     edge_matcher: ElementMatcher[E] = default_element_matcher
+    aggregator: AggregatorFunc[Any, Float] = default_aggregator
     id_order: bool = True
     subgraph: bool = True
     induced: bool = True

{cbrkit-0.23.2 → cbrkit-0.24.0}/src/cbrkit/synthesis/providers/anthropic.py

@@ -1,6 +1,6 @@
 from collections.abc import Iterable, Sequence
 from dataclasses import dataclass, field
-from typing import Literal, cast, override
+from typing import Any, Literal, cast, override
 
 from pydantic import BaseModel
 
@@ -40,8 +40,7 @@ def pydantic_to_anthropic_schema(model: type[BaseModel], description: str = "")
 
 
 with optional_dependencies():
-    from anthropic import AsyncAnthropic
-    from anthropic._types import NOT_GIVEN, Body, Headers, NotGiven, Query
+    from anthropic import NOT_GIVEN, AsyncAnthropic, NotGiven
     from anthropic.types import (
         MessageParam,
         MetadataParam,
@@ -68,9 +67,9 @@ with optional_dependencies():
         tools: Iterable[ToolParam] | NotGiven = NOT_GIVEN
         top_k: int | NotGiven = NOT_GIVEN
         top_p: float | NotGiven = NOT_GIVEN
-        extra_headers: Headers | None = None
-        extra_query: Query | None = None
-        extra_body: Body | None = None
+        extra_headers: Any | None = None
+        extra_query: Any | None = None
+        extra_body: Any | None = None
         timeout: float | Timeout | NotGiven | None = NOT_GIVEN
 
         @override

{cbrkit-0.23.2 → cbrkit-0.24.0}/src/cbrkit/synthesis/providers/openai.py

@@ -1,7 +1,7 @@
 from collections.abc import Sequence
 from dataclasses import dataclass, field
 from types import UnionType
-from typing import Literal, Union, cast, get_args, get_origin, override
+from typing import Any, Literal, Union, cast, get_args, get_origin, override
 
 from pydantic import BaseModel, ValidationError
 
@@ -12,8 +12,7 @@ logger = get_logger(__name__)
 
 with optional_dependencies():
     from httpx import Timeout
-    from openai import AsyncOpenAI, pydantic_function_tool
-    from openai._types import NOT_GIVEN, Body, Headers, NotGiven, Query
+    from openai import NOT_GIVEN, AsyncOpenAI, NotGiven, pydantic_function_tool
     from openai.types.chat import (
         ChatCompletionMessageParam,
         ChatCompletionNamedToolChoiceParam,
@@ -43,9 +42,9 @@ with optional_dependencies():
         temperature: float | None = None
         top_logprobs: int | None = None
         top_p: float | None = None
-        extra_headers: Headers | None = None
-        extra_query: Query | None = None
-        extra_body: Body | None = None
+        extra_headers: Any | None = None
+        extra_query: Any | None = None
+        extra_body: Any | None = None
         timeout: float | Timeout | None = None
 
         @override

{cbrkit-0.23.2 → cbrkit-0.24.0/src/cbrkit.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: cbrkit
-Version: 0.23.2
+Version: 0.24.0
 Summary: Customizable Case-Based Reasoning (CBR) toolkit for Python with a built-in API and CLI
 Author-email: Mirko Lenz <mirko@mirkolenz.com>
 Project-URL: Repository, https://github.com/wi2trier/cbrkit

{cbrkit-0.23.2 → cbrkit-0.24.0}/src/cbrkit.egg-info/SOURCES.txt

@@ -51,6 +51,7 @@ src/cbrkit/sim/graphs/alignment.py
 src/cbrkit/sim/graphs/astar.py
 src/cbrkit/sim/graphs/brute_force.py
 src/cbrkit/sim/graphs/common.py
+src/cbrkit/sim/graphs/greedy.py
 src/cbrkit/sim/graphs/isomorphism.py
 src/cbrkit/sim/graphs/precompute.py
 src/cbrkit/synthesis/__init__.py

{cbrkit-0.23.2 → cbrkit-0.24.0}/tests/test_graph.py

@@ -35,6 +35,7 @@ def test_astar():
     graph_sim = cbrkit.sim.graphs.astar.build(
         cbrkit.sim.graphs.astar.g1(node_sim),
         cbrkit.sim.graphs.astar.h2(node_sim),
+        node_matcher=cbrkit.sim.graphs.type_element_matcher,
     )
     retriever = cbrkit.retrieval.build(graph_sim)