More cleanup

Author: abrookins

redisvl/extensions/llmcache/semantic.py

@@ -176,14 +176,12 @@ async def _get_async_index(self) -> AsyncSearchIndex:
         """Lazily construct the async search index class."""
         # Construct async index if necessary
         if not self._aindex:
-            redis_client = self.redis_kwargs["redis_client"]
-            redis_url = self.redis_kwargs["redis_url"]
-            connection_kwargs = self.redis_kwargs["connection_kwargs"]
-            
-            self._aindex = AsyncSearchIndex(schema=self._index.schema,
-                                            redis_client=redis_client,
-                                            redis_url=redis_url,
-                                            **connection_kwargs)
+            self._aindex = AsyncSearchIndex(
+                schema=self._index.schema,
+                redis_client=self.redis_kwargs["redis_client"],
+                redis_url=self.redis_kwargs["redis_url"],
+                **self.redis_kwargs["connection_kwargs"]
+            )
         return self._aindex
 
     @property

redisvl/index/index.py

@@ -14,9 +14,9 @@
     List,
     Optional,
     Union,
+    cast,
 )
 import warnings
-
 from redisvl.utils.utils import deprecated_function
 
 if TYPE_CHECKING:
@@ -797,11 +797,6 @@ class AsyncSearchIndex(BaseSearchIndex):
 
     """
 
-    # TODO: The `aredis.Redis` type is not working for type checks.
-    _redis_client: Optional[redis.asyncio.Redis] = None
-    _redis_url: Optional[str] = None
-    _redis_kwargs: Dict[str, Any] = {}
-
     def __init__(
         self,
         schema: IndexSchema,
@@ -842,7 +837,6 @@ def __init__(
     async def disconnect(self):
         """Asynchronously disconnect and cleanup the underlying async redis connection."""
         if self._redis_client is not None:
-            print(self._redis_client)
             await self._redis_client.aclose()  # type: ignore
         self._redis_client = None
 
@@ -867,7 +861,9 @@ async def from_existing(
         if redis_client and redis_url:
             raise ValueError("Cannot provide both redis_client and redis_url")
         elif redis_url:
-            redis_client = RedisConnectionFactory.get_async_redis_connection(url=redis_url, **kwargs)
+            redis_client = RedisConnectionFactory.get_async_redis_connection(
+                url=redis_url, **kwargs
+            )
         elif redis_client:
             pass
         else:
@@ -895,46 +891,36 @@ async def from_existing(
         schema = IndexSchema.from_dict(schema_dict)
         return cls(schema, redis_client=redis_client, **kwargs)
 
-    @deprecated_function("client", "Use await self.get_client()")
     @property
-    def client(self) -> aredis.Redis:
+    def client(self) -> Optional[aredis.Redis]:
         """The underlying redis-py client object."""
-        if self._redis_client is None:
-            if asyncio.current_task() is not None:
-                warnings.warn("Risk of deadlock! Use await self.get_client() if you are "
-                              "in an async context.")
-            redis_client = asyncio.run_coroutine_threadsafe(self.get_client(), asyncio.get_event_loop())
-            client = redis_client.result()
-        else:
-            client = self._redis_client
-        return client
+        return self._redis_client
 
+    @deprecated_function("connect", "Pass connection parameters in __init__.")
     async def connect(self, redis_url: Optional[str] = None, **kwargs):
         """[DEPRECATED] Connect to a Redis instance. Use connection parameters in __init__."""
-        import warnings
-
         warnings.warn(
             "connect() is deprecated; pass connection parameters in __init__",
             DeprecationWarning,
         )
-        client = RedisConnectionFactory.connect(
+        client: redis.asyncio.Redis = RedisConnectionFactory.connect(
             redis_url=redis_url, use_async=True, **kwargs
-        )
+        )  # type: ignore
         return await self.set_client(client)
 
-    @deprecated_function("set_client", "Pass connection parameters in __init__")
-    async def set_client(self, redis_client: Optional[aredis.Redis]):
+    @deprecated_function("set_client", "Pass connection parameters in __init__.")
+    async def set_client(self, redis_client: aredis.Redis):
         """
         [DEPRECATED] Manually set the Redis client to use with the search index.
         This method is deprecated; please provide connection parameters in __init__.
         """
-        if self._redis_client is not None:
-            await self._redis_client.aclose()  # type: ignore
+        redis_client = await self._validate_client(redis_client)
+        await self.disconnect()
         async with self._lock:
             self._redis_client = redis_client
         return self
 
-    async def get_client(self) -> aredis.Redis:
+    async def _get_client(self):
         """Lazily instantiate and return the async Redis client."""
         if self._redis_client is None:
             async with self._lock:
@@ -951,6 +937,23 @@ async def get_client(self) -> aredis.Redis:
             )
         return self._redis_client
 
+    async def get_client(self) -> aredis.Redis:
+        """Return this index's async Redis client."""
+        return await self._get_client()
+
+    async def _validate_client(self, redis_client: aredis.Redis) -> aredis.Redis:
+        if isinstance(redis_client, redis.Redis):
+            warnings.warn(
+                "Converting sync Redis client to async client is deprecated "
+                "and will be removed in the next major version. Please use an "
+                "async Redis client instead.",
+                DeprecationWarning,
+            )
+            redis_client = RedisConnectionFactory.sync_to_async_redis(redis_client)
+        elif not isinstance(redis_client, aredis.Redis):
+            raise ValueError("Invalid client type: must be redis.asyncio.Redis")
+        return redis_client
+
     async def create(self, overwrite: bool = False, drop: bool = False) -> None:
         """Asynchronously create an index in Redis with the current schema
             and properties.
@@ -1171,7 +1174,7 @@ async def search(self, *args, **kwargs) -> "Result":
         """
         client = await self.get_client()
         try:
-            return client.ft(self.schema.index.name).search(*args, **kwargs)
+            return await client.ft(self.schema.index.name).search(*args, **kwargs)
         except Exception as e:
             raise RedisSearchError(f"Error while searching: {str(e)}") from e
 
@@ -1262,7 +1265,7 @@ async def listall(self) -> List[str]:
         Returns:
             List[str]: The list of indices in the database.
         """
-        client: aredis.Redis = await self.get_client()
+        client = await self.get_client()
         return convert_bytes(await client.execute_command("FT._LIST"))
 
     async def exists(self) -> bool:
@@ -1283,7 +1286,7 @@ async def info(self, name: Optional[str] = None) -> Dict[str, Any]:
         Returns:
             dict: A dictionary containing the information about the index.
         """
-        client: aredis.Redis = await self.get_client()
+        client = await self.get_client()
         index_name = name or self.schema.index.name
         return await type(self)._info(index_name, client)
 

redisvl/redis/connection.py

@@ -1,5 +1,5 @@
 import os
-from typing import Any, Dict, List, Optional, Type
+from typing import Any, Dict, List, Optional, Type, Union
 
 from redis import Redis
 from redis.asyncio import Connection as AsyncConnection
@@ -12,6 +12,7 @@
 from redisvl.exceptions import RedisModuleVersionError
 from redisvl.redis.constants import DEFAULT_REQUIRED_MODULES
 from redisvl.redis.utils import convert_bytes
+from redisvl.utils.utils import deprecated_function
 from redisvl.version import __version__
 
 
@@ -191,7 +192,7 @@ class RedisConnectionFactory:
     @classmethod
     def connect(
         cls, redis_url: Optional[str] = None, use_async: bool = False, **kwargs
-    ) -> None:
+    ) -> Union[Redis, AsyncRedis]:
         """Create a connection to the Redis database based on a URL and some
         connection kwargs.
 
@@ -260,14 +261,15 @@ def get_async_redis_connection(url: Optional[str] = None, **kwargs) -> AsyncRedi
         # fallback to env var REDIS_URL
         return AsyncRedis.from_url(get_address_from_env(), **kwargs)
 
+    @deprecated_function("sync_to_async_redis", "Please use an async Redis client instead.")
     @staticmethod
     def sync_to_async_redis(redis_client: Redis) -> AsyncRedis:
         # pick the right connection class
         connection_class: Type[AbstractConnection] = (
             AsyncSSLConnection
             if redis_client.connection_pool.connection_class == SSLConnection
             else AsyncConnection
-        )
+        ) # type: ignore
         # make async client
         return AsyncRedis.from_pool(  # type: ignore
             AsyncConnectionPool(

redisvl/utils/utils.py

@@ -100,7 +100,7 @@ def deprecated_function(name: Optional[str] = None, replacement: Optional[str] =
     def decorator(func):
         fn_name = name or func.__name__
         warning_message = f"Function {fn_name} is deprecated and will be " \
-            "removed in the next major release."
+            "removed in the next major release. "
         if replacement:
             warning_message += replacement
 

tests/integration/test_async_search_index.py

@@ -33,7 +33,7 @@ def test_search_index_properties(index_schema, async_index):
     assert async_index.schema == index_schema
     # custom settings
     assert async_index.name == index_schema.index.name == "my_index"
-    assert async_index.client == None
+    assert async_index.client is None
     # default settings
     assert async_index.prefix == index_schema.index.prefix == "rvl"
     assert async_index.key_separator == index_schema.index.key_separator == ":"
@@ -45,7 +45,7 @@ def test_search_index_properties(index_schema, async_index):
 
 def test_search_index_from_yaml(async_index_from_yaml):
     assert async_index_from_yaml.name == "json-test"
-    assert async_index_from_yaml.client == None
+    assert async_index_from_yaml.client is None
     assert async_index_from_yaml.prefix == "json"
     assert async_index_from_yaml.key_separator == ":"
     assert async_index_from_yaml.storage_type == StorageType.JSON
@@ -54,7 +54,7 @@ def test_search_index_from_yaml(async_index_from_yaml):
 
 def test_search_index_from_dict(async_index_from_dict):
     assert async_index_from_dict.name == "my_index"
-    assert async_index_from_dict.client == None
+    assert async_index_from_dict.client is None
     assert async_index_from_dict.prefix == "rvl"
     assert async_index_from_dict.key_separator == ":"
     assert async_index_from_dict.storage_type == StorageType.HASH
@@ -156,7 +156,7 @@ async def test_search_index_set_client(async_client, client, async_index):
     await async_index.set_client(client)
 
     await async_index.disconnect()
-    assert async_index.client == None
+    assert async_index.client is None
 
 
 @pytest.mark.asyncio