fix remaining issues

Author: tylerhutcherson

redisvl/extensions/llmcache/schema.py

@@ -1,6 +1,6 @@
 from typing import Any, Dict, List, Optional
 
-from pydantic import BaseModel, Field, field_validator, model_validator
+from pydantic import BaseModel, ConfigDict, Field, field_validator, model_validator
 
 from redisvl.extensions.constants import (
     CACHE_VECTOR_FIELD_NAME,
@@ -80,33 +80,33 @@ class CacheHit(BaseModel):
     filters: Optional[Dict[str, Any]] = Field(default=None)
     """Optional filter data stored on the cache entry for customizing retrieval"""
 
+    # Allow extra fields to simplify handling filters
+    model_config = ConfigDict(extra="allow")
+
     @model_validator(mode="before")
     @classmethod
-    def validate_cache_hit(cls, values):
+    def validate_cache_hit(cls, values: Dict[str, Any]) -> Dict[str, Any]:
         # Deserialize metadata if necessary
         if "metadata" in values and isinstance(values["metadata"], str):
             values["metadata"] = deserialize(values["metadata"])
 
-        # Separate filters from other fields
-        known_fields = set(cls.model_fields.keys())
-        filters = {k: v for k, v in values.items() if k not in known_fields}
-
-        # Add filters to valuesgiy s
-        if filters:
-            values["filters"] = filters
-
-        # Remove filter fields from the main values
-        for k in filters:
-            values.pop(k)
+        # Collect any extra fields and store them as filters
+        extra_data = values.pop("__pydantic_extra__", {}) or {}
+        if extra_data:
+            current_filters = values.get("filters") or {}
+            if not isinstance(current_filters, dict):
+                current_filters = {}
+            current_filters.update(extra_data)
+            values["filters"] = current_filters
 
         return values
 
-    def to_dict(self) -> Dict:
+    def to_dict(self) -> Dict[str, Any]:
+        """Convert this model to a dictionary, merging filters into the result."""
         data = self.model_dump(exclude_none=True)
-        if self.filters:
-            data.update(self.filters)
+        if data.get("filters"):
+            data.update(data["filters"])
             del data["filters"]
-
         return data
 
 

redisvl/extensions/llmcache/semantic.py

@@ -141,7 +141,7 @@ def __init__(
             existing_index = SearchIndex.from_existing(
                 name, redis_client=self._index.client
             )
-            if existing_index.schema != self._index.schema:
+            if existing_index.schema.to_dict() != self._index.schema.to_dict():
                 raise ValueError(
                     f"Existing index {name} schema does not match the user provided schema for the semantic cache. "
                     "If you wish to overwrite the index schema, set overwrite=True during initialization."

redisvl/extensions/router.py

@@ -1,7 +1,9 @@
+import warnings
 from enum import Enum
-from typing import Dict, List, Optional
+from typing import Any, Dict, List, Optional
 
-from pydantic import BaseModel, Field, field_validator
+from pydantic import BaseModel, ConfigDict, Field, field_validator, model_validator
+from typing_extensions import Annotated
 
 from redisvl.extensions.constants import ROUTE_VECTOR_FIELD_NAME
 from redisvl.schema import IndexSchema
@@ -16,7 +18,7 @@ class Route(BaseModel):
     """List of reference phrases for the route."""
     metadata: Dict[str, str] = Field(default={})
     """Metadata associated with the route."""
-    distance_threshold: float = Field(default=0.5)
+    distance_threshold: Annotated[float, Field(strict=True, default=0.5, gt=0, le=1)]
     """Distance threshold for matching the route."""
 
     @field_validator("name")
@@ -35,13 +37,6 @@ def references_must_not_be_empty(cls, v):
             raise ValueError("All references must be non-empty strings")
         return v
 
-    @field_validator("distance_threshold")
-    @classmethod
-    def distance_threshold_must_be_positive(cls, v):
-        if v is not None and v <= 0:
-            raise ValueError("Route distance threshold must be greater than zero")
-        return v
-
 
 class RouteMatch(BaseModel):
     """Model representing a matched route with distance information."""
@@ -66,28 +61,26 @@ class DistanceAggregationMethod(Enum):
 class RoutingConfig(BaseModel):
     """Configuration for routing behavior."""
 
-    # distance_threshold: float = Field(default=0.5)
-    """The threshold for semantic distance."""
-    max_k: int = Field(default=1)
-
+    """The maximum number of top matches to return."""
+    max_k: Annotated[int, Field(strict=True, default=1, gt=0)] = 1
     """Aggregation method to use to classify queries."""
     aggregation_method: DistanceAggregationMethod = Field(
         default=DistanceAggregationMethod.avg
     )
 
-    """The maximum number of top matches to return."""
-    distance_threshold: float = Field(
-        default=0.5,
-        deprecated=True,
-        description="Global distance threshold is deprecated all distance_thresholds now apply at route level.",
-    )
+    model_config = ConfigDict(extra="ignore")
 
-    @field_validator("max_k")
+    @model_validator(mode="before")
     @classmethod
-    def max_k_must_be_positive(cls, v):
-        if v <= 0:
-            raise ValueError("max_k must be a positive integer")
-        return v
+    def remove_distance_threshold(cls, values: Dict[str, Any]) -> Dict[str, Any]:
+        if "distance_threshold" in values:
+            warnings.warn(
+                "The 'distance_threshold' field is deprecated and will be ignored. Set distance_threshold per Route.",
+                DeprecationWarning,
+                stacklevel=2,
+            )
+            values.pop("distance_threshold")
+        return values
 
 
 class SemanticRouterIndexSchema(IndexSchema):

redisvl/extensions/router/schema.py

@@ -123,7 +123,7 @@ def _initialize_index(
             existing_index = SearchIndex.from_existing(
                 self.name, redis_client=self._index.client
             )
-            if existing_index.schema != self._index.schema:
+            if existing_index.schema.to_dict() != self._index.schema.to_dict():
                 raise ValueError(
                     f"Existing index {self.name} schema does not match the user provided schema for the semantic router. "
                     "If you wish to overwrite the index schema, set overwrite=True during initialization."

redisvl/extensions/router/semantic.py

@@ -110,7 +110,7 @@ def __init__(
             existing_index = SearchIndex.from_existing(
                 name, redis_client=self._index.client
             )
-            if existing_index.schema != self._index.schema:
+            if existing_index.schema.to_dict() != self._index.schema.to_dict():
                 raise ValueError(
                     f"Existing index {name} schema does not match the user provided schema for the semantic session. "
                     "If you wish to overwrite the index schema, set overwrite=True during initialization."

redisvl/extensions/session_manager/semantic_session.py

@@ -77,6 +77,7 @@ def wrapper(func):
         @wraps(func)
         def inner(*args, **kwargs):
             argument_names = func.__code__.co_varnames
+            print(argument_names, flush=True)
 
             if argument in argument_names:
                 warn(message, DeprecationWarning, stacklevel=2)

redisvl/utils/utils.py

@@ -20,4 +20,3 @@ vectorizer:
 routing_config:
   max_k: 2
   aggregation_method: avg
-  distance_threshold: 0.3

schemas/semantic_router.yaml

@@ -6,9 +6,12 @@
 from redis.exceptions import ConnectionError
 
 from redisvl.exceptions import RedisModuleVersionError
-from redisvl.extensions.llmcache.semantic import SemanticCache
 from redisvl.extensions.router import SemanticRouter
-from redisvl.extensions.router.schema import Route, RoutingConfig
+from redisvl.extensions.router.schema import (
+    DistanceAggregationMethod,
+    Route,
+    RoutingConfig,
+)
 from redisvl.redis.connection import compare_versions
 from redisvl.utils.vectorize.text.huggingface import HFTextVectorizer
 
@@ -58,7 +61,6 @@ def disable_deprecation_warnings():
 def test_initialize_router(semantic_router):
     assert semantic_router.name == "test-router"
     assert len(semantic_router.routes) == 2
-    assert semantic_router.routing_config.distance_threshold == 0.3
     assert semantic_router.routing_config.max_k == 2
 
 
@@ -114,10 +116,13 @@ def test_multiple_query(semantic_router):
 
 
 def test_update_routing_config(semantic_router):
-    new_config = RoutingConfig(distance_threshold=0.5, max_k=1)
+    new_config = RoutingConfig(max_k=27, aggregation_method="min")
     semantic_router.update_routing_config(new_config)
-    assert semantic_router.routing_config.distance_threshold == 0.5
-    assert semantic_router.routing_config.max_k == 1
+    assert semantic_router.routing_config.max_k == 27
+    assert (
+        semantic_router.routing_config.aggregation_method
+        == DistanceAggregationMethod.min
+    )
 
 
 def test_vector_query(semantic_router):
@@ -189,7 +194,7 @@ def test_from_dict(semantic_router):
     new_router = SemanticRouter.from_dict(
         router_dict, redis_client=semantic_router._index.client, overwrite=True
     )
-    assert new_router == semantic_router
+    assert new_router.to_dict() == router_dict
 
 
 def test_to_yaml(semantic_router):
@@ -203,7 +208,7 @@ def test_from_yaml(semantic_router):
     new_router = SemanticRouter.from_yaml(
         yaml_file, redis_client=semantic_router._index.client, overwrite=True
     )
-    assert new_router == semantic_router
+    assert new_router.to_dict() == semantic_router.to_dict()
 
 
 def test_to_dict_missing_fields():
@@ -290,14 +295,14 @@ def test_different_vector_dtypes(redis_url, routes):
 def test_bad_dtype_connecting_to_exiting_router(redis_url, routes):
     try:
         router = SemanticRouter(
-            name="float64 router",
+            name="float64-router",
             routes=routes,
             dtype="float64",
             redis_url=redis_url,
         )
 
         same_type = SemanticRouter(
-            name="float64 router",
+            name="float64-router",
             routes=routes,
             dtype="float64",
             redis_url=redis_url,
@@ -308,7 +313,7 @@ def test_bad_dtype_connecting_to_exiting_router(redis_url, routes):
 
     with pytest.raises(ValueError):
         bad_type = SemanticRouter(
-            name="float64 router",
+            name="float64-router",
             routes=routes,
             dtype="float16",
             redis_url=redis_url,

tests/integration/test_semantic_router.py

@@ -74,7 +74,7 @@ def test_route_invalid_threshold_zero():
             metadata={"key": "value"},
             distance_threshold=0,
         )
-    assert "Route distance threshold must be greater than zero" in str(excinfo.value)
+    assert "Input should be greater than 0" in str(excinfo.value)
 
 
 def test_route_invalid_threshold_negative():
@@ -85,7 +85,7 @@ def test_route_invalid_threshold_negative():
             metadata={"key": "value"},
             distance_threshold=-0.1,
         )
-    assert "Route distance threshold must be greater than zero" in str(excinfo.value)
+    assert "Input should be greater than 0" in str(excinfo.value)
 
 
 def test_route_match():
@@ -115,4 +115,4 @@ def test_routing_config_valid():
 def test_routing_config_invalid_max_k():
     with pytest.raises(ValidationError) as excinfo:
         RoutingConfig(max_k=0)
-    assert "max_k must be a positive integer" in str(excinfo.value)
+    assert "Input should be greater than 0" in str(excinfo.value)