feat: full mocking

Makefile

@@ -12,11 +12,11 @@ lint lint_diff:
 	poetry run mypy $(PYTHON_FILES)
 
 test:
-	poetry run pytest -vv --cov=semantic_router --cov-report=term-missing --cov-report=xml
+	poetry run pytest -vv --cov=semantic_router --cov-report=term-missing --cov-report=xml --exitfirst --maxfail=1 
 
 test_functional:
-	poetry run pytest -vv -n 20 tests/functional
+	poetry run pytest -vv --exitfirst --maxfail=1 tests/functional
 test_unit:
-	poetry run pytest -vv -n 20 tests/unit
+	poetry run pytest -vv --exitfirst --maxfail=1 tests/unit
 test_integration:
-	poetry run pytest -vv -n 20 tests/integration
+	poetry run pytest -vv --exitfirst --maxfail=1 tests/integration

docs/00-introduction.ipynb

@@ -279,62 +279,6 @@
         "sr(\"I'm interested in learning about llama 2\")"
       ]
     },
-    {
-      "cell_type": "markdown",
-      "metadata": {
-        "id": "dDZF2eN4f3p4"
-      },
-      "source": [
-        "We can also retrieve multiple routes with its associated score:"
-      ]
-    },
-    {
-      "cell_type": "code",
-      "execution_count": null,
-      "metadata": {
-        "id": "n27I7kmpf3p4",
-        "outputId": "2138e077-190b-41b7-a3eb-4fd76e2f59c2"
-      },
-      "outputs": [
-        {
-          "data": {
-            "text/plain": [
-              "[RouteChoice(name='politics', function_call=None, similarity_score=0.8595844842560181),\n",
-              " RouteChoice(name='chitchat', function_call=None, similarity_score=0.8356704527362284)]"
-            ]
-          },
-          "execution_count": 9,
-          "metadata": {},
-          "output_type": "execute_result"
-        }
-      ],
-      "source": [
-        "sr.retrieve_multiple_routes(\"Hi! How are you doing in politics??\")"
-      ]
-    },
-    {
-      "cell_type": "code",
-      "execution_count": null,
-      "metadata": {
-        "id": "zi4XJ7Amf3p4",
-        "outputId": "cf05cd65-d4f4-454a-ef05-77f16f37cc8f"
-      },
-      "outputs": [
-        {
-          "data": {
-            "text/plain": [
-              "[]"
-            ]
-          },
-          "execution_count": 10,
-          "metadata": {},
-          "output_type": "execute_result"
-        }
-      ],
-      "source": [
-        "sr.retrieve_multiple_routes(\"I'm interested in learning about llama 2\")"
-      ]
-    },
     {
       "cell_type": "markdown",
       "metadata": {},

semantic_router/encoders/bm25.py

@@ -57,6 +57,7 @@ def fit(self, routes: List[Route]):
         self.model.fit(corpus=utterances)
 
     def __call__(self, docs: List[str]) -> list[SparseEmbedding]:
+        print(f"JBTEMP: {docs}")
         if self.model is None:
             raise ValueError("Model or index mapping is not initialized.")
         if len(docs) == 1:

semantic_router/index/base.py

@@ -15,6 +15,12 @@
 RETRY_WAIT_TIME = 2.5
 
 
+class IndexConfig(BaseModel):
+    type: str
+    dimensions: int
+    vectors: int
+
+
 class BaseIndex(BaseModel):
     """
     Base class for indices using Pydantic's BaseModel.
@@ -38,6 +44,7 @@ def add(
         utterances: List[Any],
         function_schemas: Optional[List[Dict[str, Any]]] = None,
         metadata_list: List[Dict[str, Any]] = [],
+        **kwargs,
     ):
         """Add embeddings to the index.
         This method should be implemented by subclasses.
@@ -51,6 +58,7 @@ async def aadd(
         utterances: List[str],
         function_schemas: Optional[Optional[List[Dict[str, Any]]]] = None,
         metadata_list: List[Dict[str, Any]] = [],
+        **kwargs,
     ):
         """Add vectors to the index asynchronously.
         This method should be implemented by subclasses.
@@ -62,6 +70,7 @@ async def aadd(
             utterances=utterances,
             function_schemas=function_schemas,
             metadata_list=metadata_list,
+            **kwargs,
         )
 
     def get_utterances(self) -> List[Utterance]:
@@ -143,10 +152,17 @@ def delete(self, route_name: str):
         """
         raise NotImplementedError("This method should be implemented by subclasses.")
 
-    def describe(self) -> Dict:
+    def describe(self) -> IndexConfig:
+        """
+        Returns an IndexConfig object with index details such as type, dimensions, and
+        total vector count.
+        This method should be implemented by subclasses.
+        """
+        raise NotImplementedError("This method should be implemented by subclasses.")
+
+    def is_ready(self) -> bool:
         """
-        Returns a dictionary with index details such as type, dimensions, and total
-        vector count.
+        Checks if the index is ready to be used.
         This method should be implemented by subclasses.
         """
         raise NotImplementedError("This method should be implemented by subclasses.")
@@ -238,7 +254,7 @@ async def _async_read_config(
         :return: The config parameter that was read.
         :rtype: ConfigParameter
         """
-        logger.warning("Async method not implemented.")
+        logger.warning("_async_read_config method not implemented.")
         return self._read_config(field=field, scope=scope)
 
     def _write_config(self, config: ConfigParameter) -> ConfigParameter:
@@ -353,6 +369,7 @@ async def alock(
         """Lock/unlock the index for a given scope (if applicable). If index
         already locked/unlocked, raises ValueError.
         """
+        logger.warning(f"JBTEMP alock method called with {value=} {wait=} {scope=}")
         start_time = datetime.now()
         while True:
             if await self._ais_locked(scope=scope) != value:

semantic_router/index/hybrid_local.py

@@ -25,6 +25,7 @@ def add(
         function_schemas: Optional[List[Dict[str, Any]]] = None,
         metadata_list: List[Dict[str, Any]] = [],
         sparse_embeddings: Optional[List[SparseEmbedding]] = None,
+        **kwargs,
     ):
         if sparse_embeddings is None:
             raise ValueError("Sparse embeddings are required for HybridLocalIndex.")
@@ -66,13 +67,6 @@ def get_utterances(self) -> List[Utterance]:
             return []
         return [Utterance.from_tuple(x) for x in zip(self.routes, self.utterances)]
 
-    def describe(self) -> Dict:
-        return {
-            "type": self.type,
-            "dimensions": self.index.shape[1] if self.index is not None else 0,
-            "vectors": self.index.shape[0] if self.index is not None else 0,
-        }
-
     def _sparse_dot_product(
         self, vec_a: dict[int, float], vec_b: dict[int, float]
     ) -> float:

semantic_router/index/local.py

@@ -3,7 +3,7 @@
 import numpy as np
 
 from semantic_router.schema import ConfigParameter, SparseEmbedding, Utterance
-from semantic_router.index.base import BaseIndex
+from semantic_router.index.base import BaseIndex, IndexConfig
 from semantic_router.linear import similarity_matrix, top_scores
 from semantic_router.utils.logger import logger
 from typing import Any
@@ -26,6 +26,7 @@ def add(
         utterances: List[str],
         function_schemas: Optional[List[Dict[str, Any]]] = None,
         metadata_list: List[Dict[str, Any]] = [],
+        **kwargs,
     ):
         embeds = np.array(embeddings)  # type: ignore
         routes_arr = np.array(routes)
@@ -74,12 +75,18 @@ def get_utterances(self) -> List[Utterance]:
             return []
         return [Utterance.from_tuple(x) for x in zip(self.routes, self.utterances)]
 
-    def describe(self) -> Dict:
-        return {
-            "type": self.type,
-            "dimensions": self.index.shape[1] if self.index is not None else 0,
-            "vectors": self.index.shape[0] if self.index is not None else 0,
-        }
+    def describe(self) -> IndexConfig:
+        return IndexConfig(
+            type=self.type,
+            dimensions=self.index.shape[1] if self.index is not None else 0,
+            vectors=self.index.shape[0] if self.index is not None else 0,
+        )
+
+    def is_ready(self) -> bool:
+        """
+        Checks if the index is ready to be used.
+        """
+        return self.index is not None and self.routes is not None
 
     def query(
         self,