diff --git a/tests/unit/test_layer.py b/tests/unit/test_layer.py
index a746c4ec8f220f0896abb5c415749cb7b62a5796..0571071af6c8be476a4f23e7b648135cdb9d74be 100644
--- a/tests/unit/test_layer.py
+++ b/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.
diff --git a/tests/unit/test_schema.py b/tests/unit/test_schema.py
index 2563bf0bc21b7769f96d1119fdc29b6afab66d1a..9128835a4d164f2c60512ff20f7df90dde3b705c 100644
--- a/tests/unit/test_schema.py
+++ b/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"