cbrkit 0.28.2__tar.gz → 0.28.3__tar.gz

{cbrkit-0.28.2 → cbrkit-0.28.3}/PKG-INFO

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

@@ -1,6 +1,6 @@
 [project]
 name = "cbrkit"
-version = "0.28.2"
+version = "0.28.3"
 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.28.2 → cbrkit-0.28.3}/src/cbrkit/eval/__init__.py

@@ -4,7 +4,13 @@ Please refer to the official documentation for more information on the available
 <https://amenra.github.io/ranx/metrics/>
 """
 
-from .common import compute, compute_score_metrics, generate_metrics, parse_metric
+from .common import (
+    compute,
+    compute_score_metrics,
+    generate_metrics,
+    parse_metric,
+    similarities_to_qrels,
+)
 from .retrieval import (
     retrieval,
     retrieval_step,
@@ -17,6 +23,7 @@ __all__ = [
     "generate_metrics",
     "parse_metric",
     "compute_score_metrics",
+    "similarities_to_qrels",
     "retrieval",
     "retrieval_step",
     "retrieval_step_to_qrels",

{cbrkit-0.28.2 → cbrkit-0.28.3}/src/cbrkit/eval/common.py

@@ -2,9 +2,16 @@ import itertools
 import statistics
 import warnings
 from collections.abc import Callable, Iterable, Mapping, Sequence
-from typing import Any, cast
-
-from ..helpers import get_logger, unpack_float, unpack_floats
+from typing import Any, Literal, cast
+
+from ..helpers import (
+    get_logger,
+    normalize_and_scale,
+    round,
+    sim_map2ranking,
+    unpack_float,
+    unpack_floats,
+)
 from ..typing import ConversionFunc, EvalMetricFunc, Float, QueryCaseMatrix
 
 logger = get_logger(__name__)
@@ -388,3 +395,41 @@ def generate_metrics(
         generate_metric(*args)
         for args in itertools.product(metrics, ks, relevance_levels)
     ]
+
+
+def similarities_to_qrels[Q, C](
+    similarities: QueryCaseMatrix[Q, C, float],
+    max_qrel: int | None = None,
+    min_qrel: int = 1,
+    round_mode: Literal["floor", "ceil", "nearest"] = "nearest",
+    auto_scale: bool = True,
+) -> QueryCaseMatrix[Q, C, int]:
+    if max_qrel is None:
+        return {
+            query: {
+                case: rank
+                for rank, case in enumerate(
+                    reversed(sim_map2ranking(case_sims)),
+                    start=min_qrel,
+                )
+            }
+            for query, case_sims in similarities.items()
+        }
+
+    if auto_scale:
+        min_sim = min(min(entries.values()) for entries in similarities.values())
+        max_sim = max(max(entries.values()) for entries in similarities.values())
+    else:
+        min_sim = 0.0
+        max_sim = 1.0
+
+    return {
+        query: {
+            case: round(
+                normalize_and_scale(sim, min_sim, max_sim, min_qrel, max_qrel),
+                round_mode,
+            )
+            for case, sim in case_sims.items()
+        }
+        for query, case_sims in similarities.items()
+    }

{cbrkit-0.28.2 → cbrkit-0.28.3}/src/cbrkit/eval/retrieval.py

@@ -1,10 +1,10 @@
 from collections.abc import Sequence
 from typing import Any, Literal
 
-from ..helpers import normalize_and_scale, round, unpack_float
+from ..helpers import unpack_float
 from ..retrieval import Result, ResultStep
 from ..typing import EvalMetricFunc, Float, QueryCaseMatrix
-from .common import DEFAULT_METRICS, compute
+from .common import DEFAULT_METRICS, compute, similarities_to_qrels
 
 
 def retrieval_step[Q, C, S: Float](
@@ -45,36 +45,17 @@ def retrieval_step_to_qrels[Q, C, S: Float](
     round_mode: Literal["floor", "ceil", "nearest"] = "nearest",
     auto_scale: bool = True,
 ) -> QueryCaseMatrix[Q, C, int]:
-    if max_qrel is None:
-        return {
-            query: {
-                case: rank
-                for rank, case in enumerate(reversed(entry.ranking), start=min_qrel)
-            }
-            for query, entry in result.queries.items()
-        }
-
-    sims = {
+    unpacked_sims = {
         query: {case: unpack_float(value) for case, value in entry.similarities.items()}
         for query, entry in result.queries.items()
     }
-    if auto_scale:
-        min_sim = min(min(entries.values()) for entries in sims.values())
-        max_sim = max(max(entries.values()) for entries in sims.values())
-    else:
-        min_sim = 0.0
-        max_sim = 1.0
-
-    return {
-        query: {
-            case: round(
-                normalize_and_scale(sim, min_sim, max_sim, min_qrel, max_qrel),
-                round_mode,
-            )
-            for case, sim in entry.items()
-        }
-        for query, entry in sims.items()
-    }
+    return similarities_to_qrels(
+        unpacked_sims,
+        max_qrel,
+        min_qrel,
+        round_mode,
+        auto_scale,
+    )
 
 
 def retrieval_to_qrels[Q, C, S: Float](

{cbrkit-0.28.2 → cbrkit-0.28.3}/src/cbrkit/sim/embed.py

@@ -197,7 +197,7 @@ class cache(BatchConversionFunc[str, NumpyArray]):
                         id INTEGER PRIMARY KEY AUTOINCREMENT,
                         text TEXT NOT NULL UNIQUE,
                         vector BLOB NOT NULL
-                    )
+                    ) STRICT
                 """)
                 con.commit()
 

{cbrkit-0.28.2 → cbrkit-0.28.3}/src/cbrkit/system.py

@@ -1,11 +1,10 @@
-from collections.abc import Callable, Mapping, Sequence
-from dataclasses import dataclass, field
+from collections.abc import Callable
+from dataclasses import dataclass
 
 from pydantic import BaseModel
 from typing_extensions import Any
 
 import cbrkit
-from cbrkit.helpers import produce_sequence
 from cbrkit.typing import Float, MaybeSequence
 
 __all__ = [
@@ -17,76 +16,76 @@ __all__ = [
 
 
 @dataclass(slots=True, frozen=True)
-class System[K: str | int, V: BaseModel, S: Float, P: str]:
+class System[
+    K: str | int,
+    V: BaseModel,
+    S: Float,
+    R2: BaseModel | None,
+    R1: BaseModel | None,
+]:
     casebase: cbrkit.typing.Casebase[K, V]
-    retriever_pipelines: Mapping[
-        P, MaybeSequence[cbrkit.typing.RetrieverFunc[K, V, S]]
-    ] = field(default_factory=dict)
-    reuser_pipelines: Mapping[P, MaybeSequence[cbrkit.typing.ReuserFunc[K, V, S]]] = (
-        field(default_factory=dict)
-    )
-
-    def get_retriever_pipeline(
-        self, name: P, limit: int | None
-    ) -> Sequence[cbrkit.typing.RetrieverFunc[K, V, S]]:
-        retrievers = produce_sequence(self.retriever_pipelines[name])
-
-        if limit is not None:
-            *head_retrievers, tail_retriever = retrievers
-            retrievers = head_retrievers + [
-                cbrkit.retrieval.dropout(tail_retriever, limit=limit)
-            ]
-
-        return retrievers
+    retriever_factory: (
+        Callable[[R1], MaybeSequence[cbrkit.typing.RetrieverFunc[K, V, S]]] | None
+    ) = None
+    reuser_factory: (
+        Callable[[R2], MaybeSequence[cbrkit.typing.ReuserFunc[K, V, S]]] | None
+    ) = None
 
     def retrieve(
         self,
         query: V,
-        retriever_pipeline: P,
-        limit: int | None = None,
+        parameters: R1,
     ) -> cbrkit.retrieval.QueryResultStep[K, V, S]:
+        if not self.retriever_factory:
+            raise ValueError("Retriever factory is not defined.")
+
         return cbrkit.retrieval.apply_query(
             self.casebase,
             query,
-            self.get_retriever_pipeline(retriever_pipeline, limit),
+            self.retriever_factory(parameters),
         ).default_query
 
     def reuse(
         self,
         query: V,
-        reuser_pipeline: P,
+        parameters: R2,
     ) -> cbrkit.retrieval.QueryResultStep[K, V, S]:
+        if not self.reuser_factory:
+            raise ValueError("Reuser factory is not defined.")
+
         return cbrkit.reuse.apply_query(
             self.casebase,
             query,
-            self.reuser_pipelines[reuser_pipeline],
+            self.reuser_factory(parameters),
         ).default_query
 
     def cycle(
         self,
         query: V,
-        retriever_pipeline: P,
-        reuser_pipeline: P,
-        limit: int | None = None,
+        retrieve_parameters: R1,
+        reuse_parameters: R2,
     ) -> cbrkit.retrieval.QueryResultStep[K, V, S]:
+        if not self.retriever_factory or not self.reuser_factory:
+            raise ValueError("Retriever or reuser factory is not defined.")
+
         return cbrkit.cycle.apply_query(
             self.casebase,
             query,
-            self.get_retriever_pipeline(retriever_pipeline, limit),
-            self.reuser_pipelines[reuser_pipeline],
+            self.retriever_factory(retrieve_parameters),
+            self.reuser_factory(reuse_parameters),
         ).final_step.default_query
 
     @property
     def tools(self) -> list[Callable[..., Any]]:
         res: list[Callable[..., Any]] = []
 
-        if self.retriever_pipelines:
+        if self.retriever_factory:
             res.append(self.retrieve)
 
-        if self.reuser_pipelines:
+        if self.reuser_factory:
             res.append(self.reuse)
 
-        if self.retriever_pipelines and self.reuser_pipelines:
+        if self.retriever_factory and self.reuser_factory:
             res.append(self.cycle)
 
         return res
@@ -94,18 +93,10 @@ class System[K: str | int, V: BaseModel, S: Float, P: str]:
     def get_case(self, name: K) -> V:
         return self.casebase[name]
 
-    def get_retriever_names(self) -> list[str]:
-        return list(self.retriever_pipelines.keys())
-
-    def get_reuser_names(self) -> list[str]:
-        return list(self.reuser_pipelines.keys())
-
     @property
     def resources(self) -> dict[str, Callable[..., Any]]:
         return {
-            "casebase/{name}": self.get_case,
-            "pipelines/retrieve": self.get_retriever_names,
-            "pipelines/reuse": self.get_reuser_names,
+            "casebase://{name}": self.get_case,
         }
 
     @property
@@ -114,14 +105,14 @@ class System[K: str | int, V: BaseModel, S: Float, P: str]:
 
 
 with cbrkit.helpers.optional_dependencies():
-    from fastapi import FastAPI
+    from fastapi import APIRouter, FastAPI
 
-    def to_fastapi(system: System, app: FastAPI) -> FastAPI:
+    def to_fastapi[T: APIRouter | FastAPI](system: System, app: T) -> T:
         for value in system.tools:
             app.post(f"/tool/{value.__name__}")(value)
 
         for key, value in system.resources.items():
-            app.get(f"/resource/{key}")(value)
+            app.get(f"/resource/{key.replace('://', '/')}")(value)
 
         for value in system.prompts:
             app.post(f"/prompt/{value.__name__}")(value)
@@ -132,12 +123,12 @@ with cbrkit.helpers.optional_dependencies():
 with cbrkit.helpers.optional_dependencies():
     from fastmcp import FastMCP
 
-    def to_fastmcp[T](system: System, app: FastMCP[T]) -> FastMCP[T]:
+    def to_fastmcp[T: FastMCP](system: System, app: T) -> T:
         for value in system.tools:
             app.tool(value)
 
         for key, value in system.resources.items():
-            app.resource(f"cbrkit://{key}")(value)
+            app.resource(key)(value)
 
         for value in system.prompts:
             app.prompt(value)