Deprecate dtype arg to SemanticCache, SemanticRouter

Instead of using `dtype`, pass a vectorizer instance to the constructor
to specify the vectorizer's dtype.

Author: abrookins

redisvl/extensions/llmcache/semantic.py

@@ -22,7 +22,7 @@
 from redisvl.index import AsyncSearchIndex, SearchIndex
 from redisvl.query import RangeQuery
 from redisvl.query.filter import FilterExpression
-from redisvl.utils.utils import current_timestamp, serialize, validate_vector_dims
+from redisvl.utils.utils import current_timestamp, deprecated_argument, serialize, validate_vector_dims
 from redisvl.utils.vectorize import BaseVectorizer, HFTextVectorizer
 
 
@@ -32,6 +32,7 @@ class SemanticCache(BaseLLMCache):
     _index: SearchIndex
     _aindex: Optional[AsyncSearchIndex] = None
 
+    @deprecated_argument("dtype", "vectorizer")
     def __init__(
         self,
         name: str = "llmcache",

redisvl/extensions/router/semantic.py

@@ -20,7 +20,7 @@
 from redisvl.query import RangeQuery
 from redisvl.redis.utils import convert_bytes, hashify, make_dict
 from redisvl.utils.log import get_logger
-from redisvl.utils.utils import model_to_dict
+from redisvl.utils.utils import deprecated_argument, model_to_dict
 from redisvl.utils.vectorize import (
     BaseVectorizer,
     HFTextVectorizer,
@@ -47,6 +47,7 @@ class SemanticRouter(BaseModel):
     class Config:
         arbitrary_types_allowed = True
 
+    @deprecated_argument("dtype", "vectorizer")
     def __init__(
         self,
         name: str,
@@ -72,9 +73,17 @@ def __init__(
             connection_kwargs (Dict[str, Any]): The connection arguments
                 for the redis client. Defaults to empty {}.
         """
-        # Set vectorizer default
-        if vectorizer is None:
-            dtype = kwargs.get("dtype")
+        dtype = kwargs.get("dtype")
+
+        # Validate a provided vectorizer or set the default
+        if vectorizer:
+            if not isinstance(vectorizer, BaseVectorizer):
+                raise TypeError("Must provide a valid redisvl.vectorizer class.")
+            if dtype and vectorizer.dtype != dtype:
+                raise ValueError(
+                    f"Provided dtype {dtype} does not match vectorizer dtype {vectorizer.dtype}"
+                )
+        else:
             vectorizer_kwargs = {"dtype": dtype} if dtype else {}
             vectorizer = HFTextVectorizer(**vectorizer_kwargs)
 
@@ -87,10 +96,9 @@ def __init__(
             vectorizer=vectorizer,
             routing_config=routing_config,
         )
-        self._initialize_index(
-            redis_client, redis_url, overwrite, vectorizer.dtype, **connection_kwargs
-        )
+        self._initialize_index(redis_client, redis_url, overwrite, **connection_kwargs)
 
+    @deprecated_argument("dtype")
     def _initialize_index(
         self,
         redis_client: Optional[Redis] = None,
@@ -101,7 +109,7 @@ def _initialize_index(
     ):
         """Initialize the search index and handle Redis connection."""
         schema = SemanticRouterIndexSchema.from_params(
-            self.name, self.vectorizer.dims, dtype
+            self.name, self.vectorizer.dims, self.vectorizer.dtype
         )
         self._index = SearchIndex(schema=schema)
 
@@ -170,9 +178,7 @@ def _add_routes(self, routes: List[Route]):
         for route in routes:
             # embed route references as a single batch
             reference_vectors = self.vectorizer.embed_many(
-                [reference for reference in route.references],
-                as_buffer=True,
-                dtype=self._index.schema.fields[ROUTE_VECTOR_FIELD_NAME].attrs.datatype,  # type: ignore[union-attr]
+                [reference for reference in route.references], as_buffer=True
             )
             # set route references
             for i, reference in enumerate(route.references):
@@ -249,7 +255,6 @@ def _classify_route(
             vector_field_name=ROUTE_VECTOR_FIELD_NAME,
             distance_threshold=distance_threshold,
             return_fields=["route_name"],
-            dtype=self._index.schema.fields[ROUTE_VECTOR_FIELD_NAME].attrs.datatype,  # type: ignore[union-attr]
         )
 
         aggregate_request = self._build_aggregate_request(
@@ -302,7 +307,6 @@ def _classify_multi_route(
             vector_field_name=ROUTE_VECTOR_FIELD_NAME,
             distance_threshold=distance_threshold,
             return_fields=["route_name"],
-            dtype=self._index.schema.fields[ROUTE_VECTOR_FIELD_NAME].attrs.datatype,  # type: ignore[union-attr]
         )
         aggregate_request = self._build_aggregate_request(
             vector_range_query, aggregation_method, max_k

redisvl/utils/utils.py

@@ -1,8 +1,10 @@
+from functools import wraps
 import json
 from enum import Enum
 from time import time
-from typing import Any, Dict
+from typing import Any, Callable, Dict, Optional
 from uuid import uuid4
+from warnings import warn
 
 from pydantic.v1 import BaseModel
 
@@ -57,3 +59,32 @@ def serialize(data: Dict[str, Any]) -> str:
 def deserialize(data: str) -> Dict[str, Any]:
     """Deserialize the input from a string."""
     return json.loads(data)
+
+
+def deprecated_argument(argument: str, replacement: Optional[str] = None) -> Callable:
+    """
+    Decorator to warn if a deprecated argument is passed.
+
+    When the wrapped function is called, the decorator will warn if the
+    deprecated argument is passed as an argument or keyword argument.
+    """
+
+    message = f"Argument {argument} is deprecated and will be removed in the next major release."
+    if replacement:
+        message += f" Use {replacement} instead."
+
+    def wrapper(func):
+        @wraps(func)
+        def inner(*args, **kwargs):
+            argument_names = func.__code__.co_varnames
+
+            if argument in argument_names:
+                warn(message, DeprecationWarning, stacklevel=2)
+            elif argument in kwargs:
+                warn(message, DeprecationWarning, stacklevel=2)
+
+            return func(*args, **kwargs)
+
+        return inner
+
+    return wrapper

tests/integration/test_llmcache.py

@@ -885,11 +885,10 @@ def test_bad_dtype_connecting_to_existing_cache(redis_url):
             name="float64_cache", dtype="float16", redis_url=redis_url
         )
 
-
 def test_vectorizer_dtype_mismatch():
     with pytest.raises(ValueError):
         SemanticCache(
-            name="test_cache",
+            name="test_dtype_mismatch",
             dtype="float32",
             vectorizer=HFTextVectorizer(dtype="float16"),
         )
@@ -898,12 +897,17 @@ def test_vectorizer_dtype_mismatch():
 def test_invalid_vectorizer():
     with pytest.raises(TypeError):
         SemanticCache(
-            name="test_cache",
+            name="test_invalid_vectorizer",
             vectorizer="invalid_vectorizer",  # type: ignore
         )
 
 
 def test_passes_through_dtype_to_default_vectorizer():
     # The default is float32, so we should see float64 if we pass it in.
-    cache = SemanticCache(name="test_cache", dtype="float64")
+    cache = SemanticCache(name="test_pass_through_dtype)", dtype="float64")
     assert cache._vectorizer.dtype == "float64"
+
+
+def test_deprecated_dtype_argument():
+    with pytest.warns(DeprecationWarning):
+        SemanticCache(name="test_deprecated_dtype", dtype="float32")

tests/unit/test_utils.py

@@ -1,13 +1,13 @@
 import numpy as np
 import pytest
-from ml_dtypes import bfloat16
 
 from redisvl.redis.utils import (
     array_to_buffer,
     buffer_to_array,
     convert_bytes,
     make_dict,
 )
+from redisvl.utils.utils import deprecated_argument
 
 
 def test_even_number_of_elements():
@@ -146,3 +146,94 @@ def test_conversion_with_invalid_floats():
     array = [float("inf"), float("-inf"), float("nan")]
     result = array_to_buffer(array, "float16")
     assert len(result) > 0  # Simple check to ensure it returns anything
+
+
+class TestDeprecatedArgument:
+    def test_deprecation_warning_text_with_replacement(self):
+        @deprecated_argument("dtype", "vectorizer")
+        def test_func(dtype=None, vectorizer=None):
+            pass
+
+        with pytest.warns(DeprecationWarning) as record:
+            test_func(dtype="float32")
+
+        assert len(record) == 1
+        assert str(record[0].message) == (
+            "Argument dtype is deprecated and will be removed"
+            " in the next major release. Use vectorizer instead."
+        )
+
+    def test_deprecation_warning_text_without_replacement(self):
+        @deprecated_argument("dtype")
+        def test_func(dtype=None):
+            pass
+
+        with pytest.warns(DeprecationWarning) as record:
+            test_func(dtype="float32")
+
+        assert len(record) == 1
+        assert str(record[0].message) == (
+            "Argument dtype is deprecated and will be removed"
+            " in the next major release."
+        )
+
+    def test_function_argument(self):
+        @deprecated_argument("dtype", "vectorizer")
+        def test_func(dtype=None, vectorizer=None):
+            pass
+
+        with pytest.warns(DeprecationWarning):
+            test_func(dtype="float32")
+
+    def test_function_keyword_argument(self):
+        @deprecated_argument("dtype", "vectorizer")
+        def test_func(dtype=None, vectorizer=None):
+            pass
+
+        with pytest.warns(DeprecationWarning):
+            test_func(vectorizer="float32")
+
+    def test_class_method_argument(self):
+        class TestClass:
+            @deprecated_argument("dtype", "vectorizer")
+            def test_method(self, dtype=None, vectorizer=None):
+                pass
+
+        with pytest.warns(DeprecationWarning):
+            TestClass().test_method(dtype="float32")
+
+    def test_class_method_keyword_argument(self):
+        class TestClass:
+            @deprecated_argument("dtype", "vectorizer")
+            def test_method(self, dtype=None, vectorizer=None):
+                pass
+
+        with pytest.warns(DeprecationWarning):
+            TestClass().test_method(vectorizer="float32")
+
+    def test_class_init_argument(self):
+        class TestClass:
+            @deprecated_argument("dtype", "vectorizer")
+            def __init__(self, dtype=None, vectorizer=None):
+                pass
+
+        with pytest.warns(DeprecationWarning):
+            TestClass(dtype="float32")
+
+    def test_class_init_keyword_argument(self):
+        class TestClass:
+            @deprecated_argument("dtype", "vectorizer")
+            def __init__(self, dtype=None, vectorizer=None):
+                pass
+
+        with pytest.warns(DeprecationWarning):
+            TestClass(dtype="float32")
+
+    async def test_async_function_argument(self):
+        @deprecated_argument("dtype", "vectorizer")
+        async def test_func(dtype=None, vectorizer=None):
+            return 1
+
+        with pytest.warns(DeprecationWarning):
+            result = await test_func(dtype="float32")
+        assert result == 1