fix: add sim score to tests and sync call

Author: jamescalam

semantic_router/routers/base.py

@@ -639,6 +639,8 @@ def _pass_routes(
                         route.llm = self.llm
                 # call dynamic route to generate the function_call content
                 route_choice = route(query=text)
+                if route_choice is not None and route_choice.similarity_score is None:
+                    route_choice.similarity_score = total_score
                 passed_routes.append(route_choice)
             elif passed and route is not None and simulate_static:
                 passed_routes.append(

semantic_router/routers/hybrid.py

@@ -91,7 +91,7 @@ def add(self, routes: List[Route] | Route):
         """Add a route to the local HybridRouter and index.
 
         :param route: The route to add.
-        :type route: Route 
+        :type route: Route
         """
 
         if self.sparse_encoder is None:
@@ -359,7 +359,7 @@ def __call__(
             limit=limit,
         )
         return route_choices
-    
+
     async def acall(
         self,
         text: Optional[str] = None,
@@ -396,8 +396,7 @@ async def acall(
             if text is None:
                 raise ValueError("Either text or vector must be provided")
             vector, potential_sparse_vector = await self._async_encode(
-                text=[text],
-                input_type="queries"
+                text=[text], input_type="queries"
             )
         # convert to numpy array if not already
         vector = xq_reshape(xq=vector)

tests/unit/test_router.py

@@ -205,6 +205,7 @@ def routes_4():
         Route(name="Route 2", utterances=["Asparagus"]),
     ]
 
+
 @pytest.fixture
 def routes_5():
     return [
@@ -662,9 +663,90 @@ async def test_async_encode(
     ],
 )
 class TestRouter:
-    def test_limit_parameter(
-        self, router_cls, routes_5, mocker
-    ):
+    def test_query_parameter(self, router_cls, routes_5, mocker):
+        """Test that we return expected values in RouteChoice objects."""
+        # Create router with mock encoders
+        dense_encoder = MockSymmetricDenseEncoder(name="Dense Encoder")
+        if router_cls == HybridRouter:
+            sparse_encoder = MockSymmetricSparseEncoder(name="Sparse Encoder")
+            router = router_cls(
+                encoder=dense_encoder,
+                sparse_encoder=sparse_encoder,
+                routes=routes_5,
+                auto_sync="local",
+            )
+        else:
+            router = router_cls(
+                encoder=dense_encoder,
+                routes=routes_5,
+                auto_sync="local",
+            )
+
+        # Setup a mock for the similarity calculation method
+        _ = mocker.patch.object(
+            router,
+            "_score_routes",
+            return_value=[
+                ("Route 1", 0.9, [0.1, 0.2, 0.3]),
+                ("Route 2", 0.8, [0.4, 0.5, 0.6]),
+                ("Route 3", 0.7, [0.7, 0.8, 0.9]),
+                ("Route 4", 0.6, [1.0, 1.1, 1.2]),
+            ],
+        )
+
+        # Test without limit (should return only the top match)
+        result = router("test query")
+        assert result is not None
+        assert isinstance(result, RouteChoice)
+
+        # Confirm we have Route 1 and sim score
+        assert result.name == "Route 1"
+        assert result.similarity_score == 0.9
+        assert result.function_call is None
+
+    @pytest.mark.asyncio
+    async def test_async_query_parameter(self, router_cls, routes_5, mocker):
+        """Test that we return expected values in RouteChoice objects."""
+        # Create router with mock encoders
+        dense_encoder = MockSymmetricDenseEncoder(name="Dense Encoder")
+        if router_cls == HybridRouter:
+            sparse_encoder = MockSymmetricSparseEncoder(name="Sparse Encoder")
+            router = router_cls(
+                encoder=dense_encoder,
+                sparse_encoder=sparse_encoder,
+                routes=routes_5,
+                auto_sync="local",
+            )
+        else:
+            router = router_cls(
+                encoder=dense_encoder,
+                routes=routes_5,
+                auto_sync="local",
+            )
+
+        # Setup a mock for the similarity calculation method
+        _ = mocker.patch.object(
+            router,
+            "_score_routes",
+            return_value=[
+                ("Route 1", 0.9, [0.1, 0.2, 0.3]),
+                ("Route 2", 0.8, [0.4, 0.5, 0.6]),
+                ("Route 3", 0.7, [0.7, 0.8, 0.9]),
+                ("Route 4", 0.6, [1.0, 1.1, 1.2]),
+            ],
+        )
+
+        # Test without limit (should return only the top match)
+        result = await router.acall("test query")
+        assert result is not None
+        assert isinstance(result, RouteChoice)
+
+        # Confirm we have Route 1 and sim score
+        assert result.name == "Route 1"
+        assert result.similarity_score == 0.9
+        assert result.function_call is None
+
+    def test_limit_parameter(self, router_cls, routes_5, mocker):
         """Test that the limit parameter works correctly for sync router calls."""
         # Create router with mock encoders
         dense_encoder = MockSymmetricDenseEncoder(name="Dense Encoder")
@@ -711,9 +793,7 @@ def test_limit_parameter(
         assert len(result) == 4  # Should return all matches
 
     @pytest.mark.asyncio
-    async def test_async_limit_parameter(
-        self, router_cls, routes_5, mocker
-    ):
+    async def test_async_limit_parameter(self, router_cls, routes_5, mocker):
         """Test that the limit parameter works correctly for async router calls."""
         # Create router with mock encoders
         dense_encoder = MockSymmetricDenseEncoder(name="Dense Encoder")