cbrkit 0.28.2__tar.gz → 0.28.4__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: cbrkit
-Version: 0.28.2
+Version: 0.28.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
@@ -40,6 +40,7 @@ Requires-Dist: pydantic-settings>=2,<3 ; extra == 'api'
 Requires-Dist: python-multipart>=0.0.15,<1 ; extra == 'api'
 Requires-Dist: uvicorn[standard]>=0.30,<1 ; extra == 'api'
 Requires-Dist: fastmcp>=2,<3 ; extra == 'api'
+Requires-Dist: jsonref>=1,<2 ; extra == 'api'
 Requires-Dist: chonkie>=1,<2 ; extra == 'chunking'
 Requires-Dist: typer>=0.9,<1 ; extra == 'cli'
 Requires-Dist: ranx>=0.3,<1 ; extra == 'eval'

{cbrkit-0.28.2 → cbrkit-0.28.4}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "cbrkit"
-version = "0.28.2"
+version = "0.28.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"
@@ -58,6 +58,7 @@ api = [
     "python-multipart>=0.0.15,<1",
     "uvicorn[standard]>=0.30,<1",
     "fastmcp>=2,<3",
+    "jsonref>=1,<2"
 ]
 chunking = ["chonkie>=1,<2"]
 cli = ["typer>=0.9,<1"]

{cbrkit-0.28.2 → cbrkit-0.28.4}/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.4}/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.4}/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.4}/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.4/src/cbrkit/system.py

@@ -0,0 +1,250 @@
+from collections.abc import Callable
+from dataclasses import dataclass
+from typing import Annotated, Any, cast
+
+from pydantic import BaseModel
+
+import cbrkit
+from cbrkit.typing import Float, MaybeSequence
+
+__all__ = [
+    "System",
+    "to_fastapi",
+    "to_fastmcp",
+    "to_pydantic_ai",
+]
+
+
+@dataclass(slots=True, frozen=True)
+class System[
+    K: str | int,
+    V: BaseModel,
+    S: Float,
+    R1: BaseModel | None,
+    R2: BaseModel | None,
+]:
+    casebase: cbrkit.typing.Casebase[K, V]
+    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,
+        config: 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.retriever_factory(config),
+        ).default_query
+
+    def reuse(
+        self,
+        query: V,
+        config: 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_factory(config),
+        ).default_query
+
+    def cycle(
+        self,
+        query: V,
+        retrieve_config: R1,
+        reuse_config: 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.retriever_factory(retrieve_config),
+            self.reuser_factory(reuse_config),
+        ).final_step.default_query
+
+
+with cbrkit.helpers.optional_dependencies():
+    from fastapi import APIRouter, Body, FastAPI
+
+    @dataclass(slots=True, frozen=True)
+    class FastAPISystem[
+        K: str | int,
+        V: BaseModel,
+        S: Float,
+        R1: BaseModel | None,
+        R2: BaseModel | None,
+    ]:
+        system: System[K, V, S, R1, R2]
+
+        def retrieve(
+            self,
+            query: Annotated[V, Body],
+            config: R1,
+        ) -> cbrkit.retrieval.QueryResultStep[K, V, S]:
+            return self.system.retrieve(query, config)
+
+        def reuse(
+            self,
+            query: Annotated[V, Body],
+            config: R2,
+        ) -> cbrkit.retrieval.QueryResultStep[K, V, S]:
+            return self.system.reuse(query, config)
+
+        def cycle(
+            self,
+            query: Annotated[V, Body],
+            retrieve_config: R1,
+            reuse_config: R2,
+        ) -> cbrkit.retrieval.QueryResultStep[K, V, S]:
+            return self.system.cycle(query, retrieve_config, reuse_config)
+
+        def casebase(self) -> cbrkit.typing.Casebase[K, V]:
+            return self.system.casebase
+
+        def case(self, key: K) -> V | None:
+            return self.system.casebase.get(key)
+
+    def to_fastapi[
+        K: str | int,
+        V: BaseModel,
+        S: Float,
+        R1: BaseModel | None,
+        R2: BaseModel | None,
+        T: APIRouter | FastAPI,
+    ](system: System[K, V, S, R1, R2], app: T) -> T:
+        fastapi_system = FastAPISystem(system)
+
+        if system.retriever_factory:
+            app.post("/retrieve")(fastapi_system.retrieve)
+
+        if system.reuser_factory:
+            app.post("/reuse")(fastapi_system.reuse)
+
+        if system.retriever_factory and system.reuser_factory:
+            app.post("/cycle")(fastapi_system.cycle)
+
+        app.get("/casebase")(fastapi_system.casebase)
+
+        app.get("/casebase/{key}")(fastapi_system.case)
+
+        return app
+
+
+with cbrkit.helpers.optional_dependencies():
+    import jsonref
+    from fastmcp import FastMCP
+    from fastmcp.tools.tool import FunctionTool
+    from fastmcp.utilities.json_schema import compress_schema
+
+    # https://github.com/jlowin/fastmcp/pull/1427
+    def dereference_schema(schema: dict[str, Any]) -> dict[str, Any]:
+        return compress_schema(
+            cast(
+                dict[str, Any],
+                jsonref.replace_refs(
+                    schema,
+                    jsonschema=True,
+                    merge_props=True,
+                    lazy_load=False,
+                    proxies=False,
+                ),
+            )
+        )
+
+    def dereference_tool(tool: FunctionTool) -> None:
+        tool.parameters = dereference_schema(tool.parameters)
+
+        if tool.output_schema is not None:
+            tool.output_schema = dereference_schema(tool.output_schema)
+
+    @dataclass(slots=True, frozen=True)
+    class FastMCPSystem[
+        K: str | int,
+        V: BaseModel,
+        S: Float,
+        R1: BaseModel | None,
+        R2: BaseModel | None,
+    ]:
+        system: System[K, V, S, R1, R2]
+
+        def retrieve(
+            self,
+            query: V,
+            config: R1,
+        ) -> cbrkit.retrieval.QueryResultStep[K, V, S]:
+            return self.system.retrieve(query, config)
+
+        def reuse(
+            self,
+            query: V,
+            config: R2,
+        ) -> cbrkit.retrieval.QueryResultStep[K, V, S]:
+            return self.system.reuse(query, config)
+
+        def cycle(
+            self,
+            query: V,
+            retrieve_config: R1,
+            reuse_config: R2,
+        ) -> cbrkit.retrieval.QueryResultStep[K, V, S]:
+            return self.system.cycle(query, retrieve_config, reuse_config)
+
+        def casebase(self) -> cbrkit.typing.Casebase[K, V]:
+            return self.system.casebase
+
+        def case(self, key: K) -> V | None:
+            return self.system.casebase.get(key)
+
+    def to_fastmcp[
+        K: str | int,
+        V: BaseModel,
+        S: Float,
+        R1: BaseModel | None,
+        R2: BaseModel | None,
+        T: FastMCP,
+    ](system: System[K, V, S, R1, R2], app: T) -> T:
+        fastmcp_system = FastMCPSystem(system)
+
+        if system.retriever_factory:
+            dereference_tool(app.tool("retrieve")(fastmcp_system.retrieve))
+
+        if system.reuser_factory:
+            dereference_tool(app.tool("reuse")(fastmcp_system.reuse))
+
+        if system.retriever_factory and system.reuser_factory:
+            dereference_tool(app.tool("cycle")(fastmcp_system.cycle))
+
+        app.resource("casebase://{key}")(fastmcp_system.case)
+
+        return app
+
+
+with cbrkit.helpers.optional_dependencies():
+    from pydantic_ai.toolsets import FunctionToolset
+
+    def to_pydantic_ai(system: System) -> FunctionToolset[None]:
+        tools: list[Callable[..., Any]] = []
+
+        if system.retriever_factory:
+            tools.append(system.retrieve)
+
+        if system.reuser_factory:
+            tools.append(system.reuse)
+
+        if system.retriever_factory and system.reuser_factory:
+            tools.append(system.cycle)
+
+        return FunctionToolset(tools)

cbrkit-0.28.2/src/cbrkit/system.py

@@ -1,152 +0,0 @@
-from collections.abc import Callable, Mapping, Sequence
-from dataclasses import dataclass, field
-
-from pydantic import BaseModel
-from typing_extensions import Any
-
-import cbrkit
-from cbrkit.helpers import produce_sequence
-from cbrkit.typing import Float, MaybeSequence
-
-__all__ = [
-    "System",
-    "to_fastapi",
-    "to_fastmcp",
-    "to_pydantic_ai",
-]
-
-
-@dataclass(slots=True, frozen=True)
-class System[K: str | int, V: BaseModel, S: Float, P: str]:
-    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
-
-    def retrieve(
-        self,
-        query: V,
-        retriever_pipeline: P,
-        limit: int | None = None,
-    ) -> cbrkit.retrieval.QueryResultStep[K, V, S]:
-        return cbrkit.retrieval.apply_query(
-            self.casebase,
-            query,
-            self.get_retriever_pipeline(retriever_pipeline, limit),
-        ).default_query
-
-    def reuse(
-        self,
-        query: V,
-        reuser_pipeline: P,
-    ) -> cbrkit.retrieval.QueryResultStep[K, V, S]:
-        return cbrkit.reuse.apply_query(
-            self.casebase,
-            query,
-            self.reuser_pipelines[reuser_pipeline],
-        ).default_query
-
-    def cycle(
-        self,
-        query: V,
-        retriever_pipeline: P,
-        reuser_pipeline: P,
-        limit: int | None = None,
-    ) -> cbrkit.retrieval.QueryResultStep[K, V, S]:
-        return cbrkit.cycle.apply_query(
-            self.casebase,
-            query,
-            self.get_retriever_pipeline(retriever_pipeline, limit),
-            self.reuser_pipelines[reuser_pipeline],
-        ).final_step.default_query
-
-    @property
-    def tools(self) -> list[Callable[..., Any]]:
-        res: list[Callable[..., Any]] = []
-
-        if self.retriever_pipelines:
-            res.append(self.retrieve)
-
-        if self.reuser_pipelines:
-            res.append(self.reuse)
-
-        if self.retriever_pipelines and self.reuser_pipelines:
-            res.append(self.cycle)
-
-        return res
-
-    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,
-        }
-
-    @property
-    def prompts(self) -> list[Callable[..., Any]]:
-        return []
-
-
-with cbrkit.helpers.optional_dependencies():
-    from fastapi import FastAPI
-
-    def to_fastapi(system: System, app: FastAPI) -> FastAPI:
-        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)
-
-        for value in system.prompts:
-            app.post(f"/prompt/{value.__name__}")(value)
-
-        return app
-
-
-with cbrkit.helpers.optional_dependencies():
-    from fastmcp import FastMCP
-
-    def to_fastmcp[T](system: System, app: FastMCP[T]) -> FastMCP[T]:
-        for value in system.tools:
-            app.tool(value)
-
-        for key, value in system.resources.items():
-            app.resource(f"cbrkit://{key}")(value)
-
-        for value in system.prompts:
-            app.prompt(value)
-
-        return app
-
-
-with cbrkit.helpers.optional_dependencies():
-    from pydantic_ai.toolsets import FunctionToolset
-
-    def to_pydantic_ai(system: System) -> FunctionToolset[None]:
-        return FunctionToolset(system.tools)