use routes

tests/unit/test_layer.py

@@ -2,10 +2,10 @@ import pytest
 
 from semantic_router.encoders import BaseEncoder, CohereEncoder, OpenAIEncoder
 from semantic_router.layer import (
-    DecisionLayer,
-    HybridDecisionLayer,
+    RouteLayer,
+    HybridRouteLayer,
 )  # Replace with the actual module name
-from semantic_router.schema import Decision
+from semantic_router.schema import Route
 
 
 def mock_encoder_call(utterances):
@@ -38,159 +38,159 @@ def openai_encoder(mocker):
 
 
 @pytest.fixture
-def decisions():
+def routes():
     return [
-        Decision(name="Decision 1", utterances=["Hello", "Hi"]),
-        Decision(name="Decision 2", utterances=["Goodbye", "Bye", "Au revoir"]),
+        Route(name="Route 1", utterances=["Hello", "Hi"]),
+        Route(name="Route 2", utterances=["Goodbye", "Bye", "Au revoir"]),
     ]
 
 
-class TestDecisionLayer:
-    def test_initialization(self, openai_encoder, decisions):
-        decision_layer = DecisionLayer(encoder=openai_encoder, decisions=decisions)
-        assert decision_layer.score_threshold == 0.82
-        assert len(decision_layer.index) == 5
-        assert len(set(decision_layer.categories)) == 2
+class TestRouteLayer:
+    def test_initialization(self, openai_encoder, routes):
+        route_layer = RouteLayer(encoder=openai_encoder, routes=routes)
+        assert route_layer.score_threshold == 0.82
+        assert len(route_layer.index) == 5
+        assert len(set(route_layer.categories)) == 2
 
     def test_initialization_different_encoders(self, cohere_encoder, openai_encoder):
-        decision_layer_cohere = DecisionLayer(encoder=cohere_encoder)
-        assert decision_layer_cohere.score_threshold == 0.3
-
-        decision_layer_openai = DecisionLayer(encoder=openai_encoder)
-        assert decision_layer_openai.score_threshold == 0.82
-
-    def test_add_decision(self, openai_encoder):
-        decision_layer = DecisionLayer(encoder=openai_encoder)
-        decision = Decision(name="Decision 3", utterances=["Yes", "No"])
-        decision_layer.add(decision)
-        assert len(decision_layer.index) == 2
-        assert len(set(decision_layer.categories)) == 1
-
-    def test_add_multiple_decisions(self, openai_encoder, decisions):
-        decision_layer = DecisionLayer(encoder=openai_encoder)
-        for decision in decisions:
-            decision_layer.add(decision)
-        assert len(decision_layer.index) == 5
-        assert len(set(decision_layer.categories)) == 2
-
-    def test_query_and_classification(self, openai_encoder, decisions):
-        decision_layer = DecisionLayer(encoder=openai_encoder, decisions=decisions)
-        query_result = decision_layer("Hello")
-        assert query_result in ["Decision 1", "Decision 2"]
+        route_layer_cohere = RouteLayer(encoder=cohere_encoder)
+        assert route_layer_cohere.score_threshold == 0.3
+
+        route_layer_openai = RouteLayer(encoder=openai_encoder)
+        assert route_layer_openai.score_threshold == 0.82
+
+    def test_add_route(self, openai_encoder):
+        route_layer = RouteLayer(encoder=openai_encoder)
+        route = Route(name="Route 3", utterances=["Yes", "No"])
+        route_layer.add(route)
+        assert len(route_layer.index) == 2
+        assert len(set(route_layer.categories)) == 1
+
+    def test_add_multiple_routes(self, openai_encoder, routes):
+        route_layer = RouteLayer(encoder=openai_encoder)
+        for route in routes:
+            route_layer.add(route)
+        assert len(route_layer.index) == 5
+        assert len(set(route_layer.categories)) == 2
+
+    def test_query_and_classification(self, openai_encoder, routes):
+        route_layer = RouteLayer(encoder=openai_encoder, routes=routes)
+        query_result = route_layer("Hello")
+        assert query_result in ["Route 1", "Route 2"]
 
     def test_query_with_no_index(self, openai_encoder):
-        decision_layer = DecisionLayer(encoder=openai_encoder)
-        assert decision_layer("Anything") is None
+        route_layer = RouteLayer(encoder=openai_encoder)
+        assert route_layer("Anything") is None
 
-    def test_semantic_classify(self, openai_encoder, decisions):
-        decision_layer = DecisionLayer(encoder=openai_encoder, decisions=decisions)
-        classification, score = decision_layer._semantic_classify(
+    def test_semantic_classify(self, openai_encoder, routes):
+        route_layer = RouteLayer(encoder=openai_encoder, routes=routes)
+        classification, score = route_layer._semantic_classify(
             [
-                {"decision": "Decision 1", "score": 0.9},
-                {"decision": "Decision 2", "score": 0.1},
+                {"route": "Route 1", "score": 0.9},
+                {"route": "Route 2", "score": 0.1},
             ]
         )
-        assert classification == "Decision 1"
+        assert classification == "Route 1"
         assert score == [0.9]
 
-    def test_semantic_classify_multiple_decisions(self, openai_encoder, decisions):
-        decision_layer = DecisionLayer(encoder=openai_encoder, decisions=decisions)
-        classification, score = decision_layer._semantic_classify(
+    def test_semantic_classify_multiple_routes(self, openai_encoder, routes):
+        route_layer = RouteLayer(encoder=openai_encoder, routes=routes)
+        classification, score = route_layer._semantic_classify(
             [
-                {"decision": "Decision 1", "score": 0.9},
-                {"decision": "Decision 2", "score": 0.1},
-                {"decision": "Decision 1", "score": 0.8},
+                {"route": "Route 1", "score": 0.9},
+                {"route": "Route 2", "score": 0.1},
+                {"route": "Route 1", "score": 0.8},
             ]
         )
-        assert classification == "Decision 1"
+        assert classification == "Route 1"
         assert score == [0.9, 0.8]
 
     def test_pass_threshold(self, openai_encoder):
-        decision_layer = DecisionLayer(encoder=openai_encoder)
-        assert not decision_layer._pass_threshold([], 0.5)
-        assert decision_layer._pass_threshold([0.6, 0.7], 0.5)
+        route_layer = RouteLayer(encoder=openai_encoder)
+        assert not route_layer._pass_threshold([], 0.5)
+        assert route_layer._pass_threshold([0.6, 0.7], 0.5)
 
     def test_failover_score_threshold(self, base_encoder):
-        decision_layer = DecisionLayer(encoder=base_encoder)
-        assert decision_layer.score_threshold == 0.82
+        route_layer = RouteLayer(encoder=base_encoder)
+        assert route_layer.score_threshold == 0.82
 
 
-class TestHybridDecisionLayer:
-    def test_initialization(self, openai_encoder, decisions):
-        decision_layer = HybridDecisionLayer(
-            encoder=openai_encoder, decisions=decisions
+class TestHybridRouteLayer:
+    def test_initialization(self, openai_encoder, routes):
+        route_layer = HybridRouteLayer(
+            encoder=openai_encoder, routes=routes
         )
-        assert decision_layer.score_threshold == 0.82
-        assert len(decision_layer.index) == 5
-        assert len(set(decision_layer.categories)) == 2
+        assert route_layer.score_threshold == 0.82
+        assert len(route_layer.index) == 5
+        assert len(set(route_layer.categories)) == 2
 
     def test_initialization_different_encoders(self, cohere_encoder, openai_encoder):
-        decision_layer_cohere = HybridDecisionLayer(encoder=cohere_encoder)
-        assert decision_layer_cohere.score_threshold == 0.3
-
-        decision_layer_openai = HybridDecisionLayer(encoder=openai_encoder)
-        assert decision_layer_openai.score_threshold == 0.82
-
-    def test_add_decision(self, openai_encoder):
-        decision_layer = HybridDecisionLayer(encoder=openai_encoder)
-        decision = Decision(name="Decision 3", utterances=["Yes", "No"])
-        decision_layer.add(decision)
-        assert len(decision_layer.index) == 2
-        assert len(set(decision_layer.categories)) == 1
-
-    def test_add_multiple_decisions(self, openai_encoder, decisions):
-        decision_layer = HybridDecisionLayer(encoder=openai_encoder)
-        for decision in decisions:
-            decision_layer.add(decision)
-        assert len(decision_layer.index) == 5
-        assert len(set(decision_layer.categories)) == 2
-
-    def test_query_and_classification(self, openai_encoder, decisions):
-        decision_layer = HybridDecisionLayer(
-            encoder=openai_encoder, decisions=decisions
+        route_layer_cohere = HybridRouteLayer(encoder=cohere_encoder)
+        assert route_layer_cohere.score_threshold == 0.3
+
+        route_layer_openai = HybridRouteLayer(encoder=openai_encoder)
+        assert route_layer_openai.score_threshold == 0.82
+
+    def test_add_route(self, openai_encoder):
+        route_layer = HybridRouteLayer(encoder=openai_encoder)
+        route = Route(name="Route 3", utterances=["Yes", "No"])
+        route_layer.add(route)
+        assert len(route_layer.index) == 2
+        assert len(set(route_layer.categories)) == 1
+
+    def test_add_multiple_routes(self, openai_encoder, routes):
+        route_layer = HybridRouteLayer(encoder=openai_encoder)
+        for route in routes:
+            route_layer.add(route)
+        assert len(route_layer.index) == 5
+        assert len(set(route_layer.categories)) == 2
+
+    def test_query_and_classification(self, openai_encoder, routes):
+        route_layer = HybridRouteLayer(
+            encoder=openai_encoder, routes=routes
         )
-        query_result = decision_layer("Hello")
-        assert query_result in ["Decision 1", "Decision 2"]
+        query_result = route_layer("Hello")
+        assert query_result in ["Route 1", "Route 2"]
 
     def test_query_with_no_index(self, openai_encoder):
-        decision_layer = HybridDecisionLayer(encoder=openai_encoder)
-        assert decision_layer("Anything") is None
+        route_layer = HybridRouteLayer(encoder=openai_encoder)
+        assert route_layer("Anything") is None
 
-    def test_semantic_classify(self, openai_encoder, decisions):
-        decision_layer = HybridDecisionLayer(
-            encoder=openai_encoder, decisions=decisions
+    def test_semantic_classify(self, openai_encoder, routes):
+        route_layer = HybridRouteLayer(
+            encoder=openai_encoder, routes=routes
         )
-        classification, score = decision_layer._semantic_classify(
+        classification, score = route_layer._semantic_classify(
             [
-                {"decision": "Decision 1", "score": 0.9},
-                {"decision": "Decision 2", "score": 0.1},
+                {"route": "Route 1", "score": 0.9},
+                {"route": "Route 2", "score": 0.1},
             ]
         )
-        assert classification == "Decision 1"
+        assert classification == "Route 1"
         assert score == [0.9]
 
-    def test_semantic_classify_multiple_decisions(self, openai_encoder, decisions):
-        decision_layer = HybridDecisionLayer(
-            encoder=openai_encoder, decisions=decisions
+    def test_semantic_classify_multiple_routes(self, openai_encoder, routes):
+        route_layer = HybridRouteLayer(
+            encoder=openai_encoder, routes=routes
         )
-        classification, score = decision_layer._semantic_classify(
+        classification, score = route_layer._semantic_classify(
             [
-                {"decision": "Decision 1", "score": 0.9},
-                {"decision": "Decision 2", "score": 0.1},
-                {"decision": "Decision 1", "score": 0.8},
+                {"route": "Route 1", "score": 0.9},
+                {"route": "Route 2", "score": 0.1},
+                {"route": "Route 1", "score": 0.8},
             ]
         )
-        assert classification == "Decision 1"
+        assert classification == "Route 1"
         assert score == [0.9, 0.8]
 
     def test_pass_threshold(self, openai_encoder):
-        decision_layer = HybridDecisionLayer(encoder=openai_encoder)
-        assert not decision_layer._pass_threshold([], 0.5)
-        assert decision_layer._pass_threshold([0.6, 0.7], 0.5)
+        route_layer = HybridRouteLayer(encoder=openai_encoder)
+        assert not route_layer._pass_threshold([], 0.5)
+        assert route_layer._pass_threshold([0.6, 0.7], 0.5)
 
     def test_failover_score_threshold(self, base_encoder):
-        decision_layer = HybridDecisionLayer(encoder=base_encoder)
-        assert decision_layer.score_threshold == 0.82
+        route_layer = HybridRouteLayer(encoder=base_encoder)
+        assert route_layer.score_threshold == 0.82
 
 
 # Add more tests for edge cases and error handling as needed.

tests/unit/test_schema.py

@@ -2,7 +2,7 @@ import pytest
 
 from semantic_router.schema import (
     CohereEncoder,
-    Decision,
+    Route,
     Encoder,
     EncoderType,
     OpenAIEncoder,
@@ -46,16 +46,16 @@ class TestSemanticSpaceDataclass:
     def test_semanticspace_initialization(self):
         semantic_space = SemanticSpace()
         assert semantic_space.id == ""
-        assert semantic_space.decisions == []
+        assert semantic_space.routes == []
 
-    def test_semanticspace_add_decision(self):
-        decision = Decision(
+    def test_semanticspace_add_route(self):
+        route = Route(
             name="test", utterances=["hello", "hi"], description="greeting"
         )
         semantic_space = SemanticSpace()
-        semantic_space.add(decision)
+        semantic_space.add(route)
 
-        assert len(semantic_space.decisions) == 1
-        assert semantic_space.decisions[0].name == "test"
-        assert semantic_space.decisions[0].utterances == ["hello", "hi"]
-        assert semantic_space.decisions[0].description == "greeting"
+        assert len(semantic_space.routes) == 1
+        assert semantic_space.routes[0].name == "test"
+        assert semantic_space.routes[0].utterances == ["hello", "hi"]
+        assert semantic_space.routes[0].description == "greeting"