comparator-recommender 0.1.1__py3-none-any.whl

comparator_recommender/__init__.py

@@ -0,0 +1,10 @@
+"""Comparator Recommender plugin configuration MWE."""
+
+from comparator_recommender.config import ComparatorRecommenderConfig
+from comparator_recommender.plugin import ComparatorRecommenderPlugin, plugin
+
+__all__ = [
+    "ComparatorRecommenderConfig",
+    "ComparatorRecommenderPlugin",
+    "plugin",
+]

comparator_recommender/adapters.py

@@ -0,0 +1,57 @@
+"""Connections to the comparator catalogue and its embedding model."""
+
+from collections.abc import Callable
+from dataclasses import dataclass
+
+from groundworkers.plugins import PluginReadinessResult
+from oa_configurator import ResolvedDatabase
+from omop_llm import ModelBackend
+
+from comparator_recommender.backends import (
+    ComparatorSelectorBackend,
+    PostgresComparatorSelectorBackend,
+)
+
+
+@dataclass(frozen=True)
+class ComparatorDataAdapter:
+    """Own the database-backed comparator operations."""
+
+    database: ResolvedDatabase
+    backend: ComparatorSelectorBackend
+
+    @classmethod
+    def build(
+        cls,
+        database: ResolvedDatabase,
+        model_backend_factory: Callable[[], ModelBackend] | None = None,
+        model_source: str | None = None,
+    ) -> "ComparatorDataAdapter":
+        return cls(
+            database=database,
+            backend=PostgresComparatorSelectorBackend(
+                engine=database.create_engine(register_claims=False),
+                schema=database.schema_name or "public",
+                model_backend_factory=model_backend_factory,
+                model_source=model_source,
+            ),
+        )
+
+    def find_target(self, name: str, top_n: int) -> list[tuple[int, str]]:
+        return self.backend.find_target(name, top_n)
+
+    def recommend_comparators(
+        self, target_id: int, top_n: int, min_databases: int
+    ) -> list[tuple[float, str]]:
+        return self.backend.recommend_comparators(target_id, top_n, min_databases)
+
+    def insert_data(self, cohort_table_path: str, similarity_table_path: str) -> None:
+        self.backend.insert_data(cohort_table_path, similarity_table_path)
+
+    def create_embedding_vectors(self) -> None:
+        self.backend.create_embedding_vectors()
+
+    def verify_readiness(self) -> PluginReadinessResult:
+        """Return the backend's read-only readiness report."""
+
+        return self.backend.verify_readiness()

comparator_recommender/backends/__init__.py

@@ -0,0 +1,6 @@
+"""Backend implementations for comparator catalogue storage."""
+
+from comparator_recommender.backends.base import ComparatorSelectorBackend
+from comparator_recommender.backends.postgresql import PostgresComparatorSelectorBackend
+
+__all__ = ["ComparatorSelectorBackend", "PostgresComparatorSelectorBackend"]

comparator_recommender/backends/base.py

@@ -0,0 +1,54 @@
+"""Storage-independent comparator backend contract."""
+
+from __future__ import annotations
+
+from abc import ABC, abstractmethod
+from collections.abc import Callable
+
+from groundworkers.plugins import PluginReadinessResult
+from omop_llm import ModelBackend
+from sqlalchemy import Engine
+
+
+class ComparatorSelectorBackend(ABC):
+    """Operations required by the comparator recommender service."""
+
+    def __init__(
+        self,
+        engine: Engine,
+        schema: str,
+        model_backend_factory: Callable[[], ModelBackend] | None = None,
+        model_source: str | None = None,
+    ) -> None:
+        if not schema.strip():
+            raise ValueError("schema must not be empty")
+        self.engine = engine
+        self.schema = schema
+        self.model_backend_factory = model_backend_factory
+        self.model_source = model_source
+
+    def pre_initialise_store(self) -> None:
+        """Prepare mutating setup prerequisites; the default is a no-op.
+
+        Backend construction and readiness checks are deliberately read-only.
+        Mutating setup operations call this hook explicitly when needed.
+        """
+
+    @abstractmethod
+    def find_target(self, name: str, top_n: int) -> list[tuple[int, str]]: ...
+
+    @abstractmethod
+    def recommend_comparators(
+        self, target_id: int, top_n: int, min_databases: int
+    ) -> list[tuple[float, str]]: ...
+
+    @abstractmethod
+    def insert_data(
+        self, cohort_table_path: str, similarity_table_path: str
+    ) -> None: ...
+
+    @abstractmethod
+    def create_embedding_vectors(self) -> None: ...
+
+    @abstractmethod
+    def verify_readiness(self) -> PluginReadinessResult: ...