valkey-glide 2.0.0rc5__cp311-cp311-macosx_11_0_arm64.whl → 2.0.0rc7__cp311-cp311-macosx_11_0_arm64.whl

glide/async_commands/batch.py

@@ -1,9 +1,9 @@
 # Copyright Valkey GLIDE Project Contributors - SPDX Identifier: Apache-2.0
 
+import sys
 import threading
 from typing import List, Mapping, Optional, Tuple, TypeVar, Union
 
-from deprecated import deprecated
 from glide.async_commands.bitmap import (
     BitFieldGet,
     BitFieldSubCommands,
@@ -57,6 +57,11 @@ from glide.async_commands.stream import (
 from glide.constants import TEncodable
 from glide.protobuf.command_request_pb2 import RequestType
 
+if sys.version_info >= (3, 13):
+    from warnings import deprecated
+else:
+    from typing_extensions import deprecated
+
 TBatch = TypeVar("TBatch", bound="BaseBatch")
 
 
@@ -109,7 +114,7 @@ class BaseBatch:
 
     def get(self: TBatch, key: TEncodable) -> TBatch:
         """
-        Get the value associated with the given key, or null if no such value exists.
+        Get the value associated with the given key, or null if no such key exists.
 
         See [valkey.io](https://valkey.io/commands/get/) for details.
 
@@ -273,6 +278,10 @@ class BaseBatch:
         [custom command](https://github.com/valkey-io/valkey-glide/wiki/General-Concepts#custom-command)
         for details on the restrictions and limitations of the custom command API.
 
+        This function should only be used for single-response commands. Commands that don't return complete response and awaits
+        (such as SUBSCRIBE), or that return potentially more than a single response (such as XREAD), or that change the
+        client's behavior (such as entering pub/sub mode on RESP2 connections) shouldn't be called using this function.
+
         Args:
             command_args (List[TEncodable]): List of command arguments.
                 Every part of the command, including the command name and subcommands, should be added as a
@@ -312,6 +321,8 @@ class BaseBatch:
         """
         Get information and statistics about the server.
 
+        Starting from server version 7, command supports multiple section arguments.
+
         See [valkey.io](https://valkey.io/commands/info/) for details.
 
         Args:
@@ -1057,7 +1068,7 @@ class BaseBatch:
         Command response:
             Optional[Mapping[bytes, List[bytes]]]: A map of `key` name mapped to an array of popped elements.
 
-            None if no elements could be popped.
+            `None` if no elements could be popped.
 
         Since: Valkey version 7.0.0.
         """
@@ -2412,26 +2423,26 @@ class BaseBatch:
 
         Args:
             key (TEncodable): The key of the stream.
-            start (StreamRangeBound): The starting stream ID bound for the range.
+            start (StreamRangeBound): The starting stream entry ID bound for the range.
 
-                - Use `IdBound` to specify a stream ID.
-                - Use `ExclusiveIdBound` to specify an exclusive bounded stream ID.
+                - Use `IdBound` to specify a stream entry ID.
+                - Since Valkey 6.2.0, use `ExclusiveIdBound` to specify an exclusive bounded stream entry ID.
                 - Use `MinId` to start with the minimum available ID.
 
-            end (StreamRangeBound): The ending stream ID bound for the range.
+            end (StreamRangeBound): The ending stream entry ID bound for the range.
 
-                - Use `IdBound` to specify a stream ID.
-                - Use `ExclusiveIdBound` to specify an exclusive bounded stream ID.
+                - Use `IdBound` to specify a stream entry ID.
+                - Since Valkey 6.2.0, use `ExclusiveIdBound` to specify an exclusive bounded stream entry ID.
                 - Use `MaxId` to end with the maximum available ID.
 
             count (Optional[int]): An optional argument specifying the maximum count of stream entries to return.
                 If `count` is not provided, all stream entries in the range will be returned.
 
         Command response:
-            Optional[Mapping[bytes, List[List[bytes]]]]: A mapping of stream IDs to stream entry data, where entry data is a
+            Optional[Mapping[bytes, List[List[bytes]]]]: A mapping of stream entry IDs to stream entry data, where entry data is a
             list of pairings with format `[[field, entry], [field, entry], ...]`.
 
-            Returns None if the range arguments are not applicable.
+            Returns None if the range arguments are not applicable. Or if count is non-positive.
         """
         args = [key, start.to_arg(), end.to_arg()]
         if count is not None:
@@ -2454,26 +2465,26 @@ class BaseBatch:
 
         Args:
             key (TEncodable): The key of the stream.
-            end (StreamRangeBound): The ending stream ID bound for the range.
+            end (StreamRangeBound): The ending stream entry ID bound for the range.
 
-                - Use `IdBound` to specify a stream ID.
-                - Use `ExclusiveIdBound` to specify an exclusive bounded stream ID.
+                - Use `IdBound` to specify a stream entry ID.
+                - Since Valkey 6.2.0, use `ExclusiveIdBound` to specify an exclusive bounded stream entry ID.
                 - Use `MaxId` to end with the maximum available ID.
 
-            start (StreamRangeBound): The starting stream ID bound for the range.
+            start (StreamRangeBound): The starting stream entry ID bound for the range.
 
-                - Use `IdBound` to specify a stream ID.
-                - Use `ExclusiveIdBound` to specify an exclusive bounded stream ID.
+                - Use `IdBound` to specify a stream entry ID.
+                - Since Valkey 6.2.0, use `ExclusiveIdBound` to specify an exclusive bounded stream entry ID.
                 - Use `MinId` to start with the minimum available ID.
 
             count (Optional[int]): An optional argument specifying the maximum count of stream entries to return.
                 If `count` is not provided, all stream entries in the range will be returned.
 
         Command response:
-            Optional[Mapping[bytes, List[List[bytes]]]]: A mapping of stream IDs to stream entry data, where entry data is a
+            Optional[Mapping[bytes, List[List[bytes]]]]: A mapping of stream entry IDs to stream entry data, where entry data is a
             list of pairings with format `[[field, entry], [field, entry], ...]`.
 
-            Returns None if the range arguments are not applicable.
+            Returns None if the range arguments are not applicable. Or if count is non-positive.
         """
         args = [key, end.to_arg(), start.to_arg()]
         if count is not None:
@@ -2787,7 +2798,7 @@ class BaseBatch:
             min_idle_time_ms (int): Filters the claimed entries to those that have been idle for more than the specified
                 value.
             start (TEncodable): Filters the claimed entries to those that have an ID equal or greater than the specified value.
-            count (Optional[int]): Limits the number of claimed entries to the specified value.
+            count (Optional[int]): Limits the number of claimed entries to the specified value. Default value is 100.
 
         Command response:
             List[Union[str, Mapping[bytes, List[List[bytes]]], List[bytes]]]: A list containing the following elements:
@@ -2832,7 +2843,7 @@ class BaseBatch:
             min_idle_time_ms (int): Filters the claimed entries to those that have been idle for more than the specified
                 value.
             start (TEncodable): Filters the claimed entries to those that have an ID equal or greater than the specified value.
-            count (Optional[int]): Limits the number of claimed entries to the specified value.
+            count (Optional[int]): Limits the number of claimed entries to the specified value. Default value is 100.
 
         Command response:
             List[Union[bytes, List[bytes]]]: A list containing the following elements:
@@ -3263,7 +3274,7 @@ class BaseBatch:
         Commands response:
             Optional[float]: The score of the member.
 
-            If there was a conflict with choosing the XX/NX/LT/GT options, the operation aborts and None is returned.
+            If there was a conflict with choosing the XX/NX/LT/GT options, the operation aborts and `None` is returned.
         """
         args = [key]
         if existing_options:
@@ -5573,13 +5584,13 @@ class ClusterBatch(BaseBatch):
     # TODO: add all CLUSTER commands
 
 
-@deprecated(reason="Use ClusterBatch(is_atomic=True) instead.")
+@deprecated("Use Batch(is_atomic=True) instead.")
 class Transaction(Batch):
     def __init__(self):
         super().__init__(is_atomic=True)
 
 
-@deprecated(reason="Use ClusterBatch(is_atomic=True) instead.")
+@deprecated("Use ClusterBatch(is_atomic=True) instead.")
 class ClusterTransaction(ClusterBatch):
     def __init__(self):
         super().__init__(is_atomic=True)

glide/async_commands/cluster_commands.py

@@ -36,9 +36,13 @@ class ClusterCommands(CoreCommands):
         See the [Valkey GLIDE Wiki](https://github.com/valkey-io/valkey-glide/wiki/General-Concepts#custom-command)
         for details on the restrictions and limitations of the custom command API.
 
+        This function should only be used for single-response commands. Commands that don't return complete response and awaits
+        (such as SUBSCRIBE), or that return potentially more than a single response (such as XREAD), or that change the
+        client's behavior (such as entering pub/sub mode on RESP2 connections) shouldn't be called using this function.
+
             For example - Return a list of all pub/sub clients from all nodes::
 
-                connection.customCommand(["CLIENT", "LIST","TYPE", "PUBSUB"], AllNodes())
+                await client.customCommand(["CLIENT", "LIST","TYPE", "PUBSUB"], AllNodes())
 
         Args:
             command_args (List[TEncodable]): List of the command's arguments, where each argument is either a string or bytes.
@@ -63,6 +67,8 @@ class ClusterCommands(CoreCommands):
         """
         Get information and statistics about the server.
 
+        Starting from server version 7, command supports multiple section arguments.
+
         See [valkey.io](https://valkey.io/commands/info/) for details.
 
         Args:

glide/async_commands/core.py

@@ -593,7 +593,7 @@ class CoreCommands(Protocol):
 
     async def get(self, key: TEncodable) -> Optional[bytes]:
         """
-        Get the value associated with the given key, or null if no such value exists.
+        Get the value associated with the given key, or null if no such key exists.
 
         See [valkey.io](https://valkey.io/commands/get/) for details.
 
@@ -3114,26 +3114,26 @@ class CoreCommands(Protocol):
 
         Args:
             key (TEncodable): The key of the stream.
-            start (StreamRangeBound): The starting stream ID bound for the range.
+            start (StreamRangeBound): The starting stream entry ID bound for the range.
 
-                - Use `IdBound` to specify a stream ID.
-                - Use `ExclusiveIdBound` to specify an exclusive bounded stream ID.
+                - Use `IdBound` to specify a stream entry ID.
+                - Since Valkey 6.2.0, use `ExclusiveIdBound` to specify an exclusive bounded stream entry ID.
                 - Use `MinId` to start with the minimum available ID.
 
-            end (StreamRangeBound): The ending stream ID bound for the range.
+            end (StreamRangeBound): The ending stream entry ID bound for the range.
 
-                - Use `IdBound` to specify a stream ID.
-                - Use `ExclusiveIdBound` to specify an exclusive bounded stream ID.
+                - Use `IdBound` to specify a stream entry ID.
+                - Since Valkey 6.2.0, use `ExclusiveIdBound` to specify an exclusive bounded stream entry ID.
                 - Use `MaxId` to end with the maximum available ID.
 
             count (Optional[int]): An optional argument specifying the maximum count of stream entries to return.
                 If `count` is not provided, all stream entries in the range will be returned.
 
         Returns:
-            Optional[Mapping[bytes, List[List[bytes]]]]: A mapping of stream IDs to stream entry data, where entry data is a
+            Optional[Mapping[bytes, List[List[bytes]]]]: A mapping of stream entry IDs to stream entry data, where entry data is a
             list of pairings with format `[[field, entry], [field, entry], ...]`.
 
-            Returns None if the range arguments are not applicable.
+            Returns None if the range arguments are not applicable. Or if count is non-positive.
 
         Examples:
             >>> await client.xadd("mystream", [("field1", "value1")], StreamAddOptions(id="0-1"))
@@ -3168,26 +3168,26 @@ class CoreCommands(Protocol):
 
         Args:
             key (TEncodable): The key of the stream.
-            end (StreamRangeBound): The ending stream ID bound for the range.
+            end (StreamRangeBound): The ending stream entry ID bound for the range.
 
-                - Use `IdBound` to specify a stream ID.
-                - Use `ExclusiveIdBound` to specify an exclusive bounded stream ID.
+                - Use `IdBound` to specify a stream entry ID.
+                - Since Valkey 6.2.0, use `ExclusiveIdBound` to specify an exclusive bounded stream entry ID.
                 - Use `MaxId` to end with the maximum available ID.
 
-            start (StreamRangeBound): The starting stream ID bound for the range.
+            start (StreamRangeBound): The starting stream entry ID bound for the range.
 
-                - Use `IdBound` to specify a stream ID.
-                - Use `ExclusiveIdBound` to specify an exclusive bounded stream ID.
+                - Use `IdBound` to specify a stream entry ID.
+                - Since Valkey 6.2.0, use `ExclusiveIdBound` to specify an exclusive bounded stream entry ID.
                 - Use `MinId` to start with the minimum available ID.
 
             count (Optional[int]): An optional argument specifying the maximum count of stream entries to return.
                 If `count` is not provided, all stream entries in the range will be returned.
 
         Returns:
-            Optional[Mapping[bytes, List[List[bytes]]]]: A mapping of stream IDs to stream entry data, where entry data is a
+            Optional[Mapping[bytes, List[List[bytes]]]]: A mapping of stream entry IDs to stream entry data, where entry data is a
             list of pairings with format `[[field, entry], [field, entry], ...]`.
 
-            Returns None if the range arguments are not applicable.
+            Returns None if the range arguments are not applicable. Or if count is non-positive.
 
         Examples:
             >>> await client.xadd("mystream", [("field1", "value1")], StreamAddOptions(id="0-1"))
@@ -3273,7 +3273,7 @@ class CoreCommands(Protocol):
             key (TEncodable): The key of the stream.
             group_name (TEncodable): The newly created consumer group name.
             group_id (TEncodable): The stream entry ID that specifies the last delivered entry in the stream from the new
-                group’s perspective. The special ID "$" can be used to specify the last entry in the stream.
+                group's perspective. The special ID "$" can be used to specify the last entry in the stream.
             options (Optional[StreamGroupOptions]): Options for creating the stream group.
 
         Returns:
@@ -3733,7 +3733,7 @@ class CoreCommands(Protocol):
             min_idle_time_ms (int): Filters the claimed entries to those that have been idle for more than the specified
                 value.
             start (TEncodable): Filters the claimed entries to those that have an ID equal or greater than the specified value.
-            count (Optional[int]): Limits the number of claimed entries to the specified value.
+            count (Optional[int]): Limits the number of claimed entries to the specified value. Default value is 100.
 
         Returns:
             List[Union[bytes, Mapping[bytes, List[List[bytes]]], List[bytes]]]: A list containing the following elements:
@@ -3820,7 +3820,7 @@ class CoreCommands(Protocol):
             min_idle_time_ms (int): Filters the claimed entries to those that have been idle for more than the specified
                 value.
             start (TEncodable): Filters the claimed entries to those that have an ID equal or greater than the specified value.
-            count (Optional[int]): Limits the number of claimed entries to the specified value.
+            count (Optional[int]): Limits the number of claimed entries to the specified value. Default value is 100.
 
         Returns:
             List[Union[bytes, List[bytes]]]: A list containing the following elements:

glide/async_commands/standalone_commands.py

@@ -31,6 +31,10 @@ class StandaloneCommands(CoreCommands):
         See the [Valkey GLIDE Wiki](https://github.com/valkey-io/valkey-glide/wiki/General-Concepts#custom-command)
         for details on the restrictions and limitations of the custom command API.
 
+        This function should only be used for single-response commands. Commands that don't return complete response and awaits
+        (such as SUBSCRIBE), or that return potentially more than a single response (such as XREAD), or that change the
+        client's behavior (such as entering pub/sub mode on RESP2 connections) shouldn't be called using this function.
+
         Args:
             command_args (List[TEncodable]): List of the command's arguments, where each argument is either a string or bytes.
             Every part of the command, including the command name and subcommands, should be added as a separate value in args.
@@ -39,7 +43,8 @@ class StandaloneCommands(CoreCommands):
             TResult: The returning value depends on the executed command.
 
         Example:
-            >>> connection.customCommand(["CLIENT", "LIST","TYPE", "PUBSUB"])
+            >>> await client.customCommand(["CLIENT", "LIST", "TYPE", "PUBSUB"])
+            # Expected Output: A list of all pub/sub clients
 
         """
         return await self._execute_command(RequestType.CustomCommand, command_args)
@@ -51,6 +56,8 @@ class StandaloneCommands(CoreCommands):
         """
         Get information and statistics about the server.
 
+        Starting from server version 7, command supports multiple section arguments.
+
         See [valkey.io](https://valkey.io/commands/info/) for details.
 
         Args:

glide/glide_client.py

@@ -1,9 +1,24 @@
 # Copyright Valkey GLIDE Project Contributors - SPDX Identifier: Apache-2.0
 
-import asyncio
 import sys
 import threading
-from typing import Any, Dict, List, Optional, Tuple, Type, Union, cast
+from typing import (
+    TYPE_CHECKING,
+    Any,
+    Awaitable,
+    Dict,
+    List,
+    Optional,
+    Set,
+    Tuple,
+    Type,
+    Union,
+    cast,
+)
+
+import anyio
+import sniffio
+from anyio import to_thread
 
 from glide.async_commands.cluster_commands import ClusterCommands
 from glide.async_commands.command_args import ObjectType
@@ -38,12 +53,18 @@ from .glide import (
 )
 
 if sys.version_info >= (3, 11):
-    import asyncio as async_timeout
     from typing import Self
 else:
-    import async_timeout
     from typing_extensions import Self
 
+if TYPE_CHECKING:
+    import asyncio
+
+    import trio
+
+    TTask = Union[asyncio.Task[None], trio.lowlevel.Task]
+    TFuture = Union[asyncio.Future[Any], "_CompatFuture"]
+
 
 def get_request_error_class(
     error_type: Optional[RequestErrorType.ValueType],
@@ -59,23 +80,94 @@ def get_request_error_class(
     return RequestError
 
 
+class _CompatFuture:
+    """anyio shim for asyncio.Future-like functionality"""
+
+    def __init__(self) -> None:
+        self._is_done = anyio.Event()
+        self._result: Any = None
+        self._exception: Optional[Exception] = None
+
+    def set_result(self, result: Any) -> None:
+        self._result = result
+        self._is_done.set()
+
+    def set_exception(self, exception: Exception) -> None:
+        self._exception = exception
+        self._is_done.set()
+
+    def done(self) -> bool:
+        return self._is_done.is_set()
+
+    def __await__(self):
+        return self._is_done.wait().__await__()
+
+    def result(self) -> Any:
+        if self._exception:
+            raise self._exception
+
+        return self._result
+
+
+def _get_new_future_instance() -> "TFuture":
+    if sniffio.current_async_library() == "asyncio":
+        import asyncio
+
+        return asyncio.get_running_loop().create_future()
+
+    # _CompatFuture is also compatible with asyncio, but is not as closely integrated
+    # into the asyncio event loop and thus introduces a noticeable performance
+    # degradation. so we only use it for trio
+    return _CompatFuture()
+
+
 class BaseClient(CoreCommands):
     def __init__(self, config: BaseClientConfiguration):
         """
         To create a new client, use the `create` classmethod
         """
         self.config: BaseClientConfiguration = config
-        self._available_futures: Dict[int, asyncio.Future] = {}
+        self._available_futures: Dict[int, "TFuture"] = {}
         self._available_callback_indexes: List[int] = list()
         self._buffered_requests: List[TRequest] = list()
         self._writer_lock = threading.Lock()
         self.socket_path: Optional[str] = None
-        self._reader_task: Optional[asyncio.Task] = None
+        self._reader_task: Optional["TTask"] = None
         self._is_closed: bool = False
-        self._pubsub_futures: List[asyncio.Future] = []
+        self._pubsub_futures: List["TFuture"] = []
         self._pubsub_lock = threading.Lock()
         self._pending_push_notifications: List[Response] = list()
 
+        self._pending_tasks: Optional[Set[Awaitable[None]]] = None
+        """asyncio-only to avoid gc on pending write tasks"""
+
+    def _create_task(self, task, *args, **kwargs):
+        """framework agnostic free-floating task shim"""
+        framework = sniffio.current_async_library()
+        if framework == "trio":
+            from functools import partial
+
+            import trio
+
+            return trio.lowlevel.spawn_system_task(partial(task, **kwargs), *args)
+        elif framework == "asyncio":
+            import asyncio
+
+            # the asyncio event loop holds weak refs to tasks, so it's recommended to
+            # hold strong refs to them during their lifetime to prevent garbage
+            # collection
+            t = asyncio.create_task(task(*args, **kwargs))
+
+            if self._pending_tasks is None:
+                self._pending_tasks = set()
+
+            self._pending_tasks.add(t)
+            t.add_done_callback(self._pending_tasks.discard)
+
+            return t
+
+        raise RuntimeError(f"Unsupported async framework {framework}")
+
     @classmethod
     async def create(cls, config: BaseClientConfiguration) -> Self:
         """Creates a Glide client.
@@ -148,8 +240,8 @@ class BaseClient(CoreCommands):
         """
         config = config
         self = cls(config)
-        init_future: asyncio.Future = asyncio.Future()
-        loop = asyncio.get_event_loop()
+
+        init_event: threading.Event = threading.Event()
 
         def init_callback(socket_path: Optional[str], err: Optional[str]):
             if err is not None:
@@ -161,7 +253,7 @@ class BaseClient(CoreCommands):
             else:
                 # Received socket path
                 self.socket_path = socket_path
-                loop.call_soon_threadsafe(init_future.set_result, True)
+                init_event.set()
 
         start_socket_listener_external(init_callback=init_callback)
 
@@ -169,36 +261,27 @@ class BaseClient(CoreCommands):
         # level or higher
         ClientLogger.log(LogLevel.INFO, "connection info", "new connection established")
         # Wait for the socket listener to complete its initialization
-        await init_future
+        await to_thread.run_sync(init_event.wait)
         # Create UDS connection
         await self._create_uds_connection()
+
         # Start the reader loop as a background task
-        self._reader_task = asyncio.create_task(self._reader_loop())
+        self._reader_task = self._create_task(self._reader_loop)
+
         # Set the client configurations
         await self._set_connection_configurations()
+
         return self
 
     async def _create_uds_connection(self) -> None:
         try:
             # Open an UDS connection
-            async with async_timeout.timeout(DEFAULT_TIMEOUT_IN_MILLISECONDS):
-                reader, writer = await asyncio.open_unix_connection(
-                    path=self.socket_path
+            with anyio.fail_after(DEFAULT_TIMEOUT_IN_MILLISECONDS):
+                self._stream = await anyio.connect_unix(
+                    path=cast(str, self.socket_path)
                 )
-            self._reader = reader
-            self._writer = writer
         except Exception as e:
-            await self.close(f"Failed to create UDS connection: {e}")
-            raise
-
-    def __del__(self) -> None:
-        try:
-            if self._reader_task:
-                self._reader_task.cancel()
-        except RuntimeError as e:
-            if "no running event loop" in str(e):
-                # event loop already closed
-                pass
+            raise ClosingError("Failed to create UDS connection") from e
 
     async def close(self, err_message: Optional[str] = None) -> None:
         """
@@ -210,25 +293,24 @@ class BaseClient(CoreCommands):
             closing all open futures.
             Defaults to None.
         """
-        self._is_closed = True
-        for response_future in self._available_futures.values():
-            if not response_future.done():
-                err_message = "" if err_message is None else err_message
-                response_future.set_exception(ClosingError(err_message))
-        try:
-            self._pubsub_lock.acquire()
-            for pubsub_future in self._pubsub_futures:
-                if not pubsub_future.done() and not pubsub_future.cancelled():
-                    pubsub_future.set_exception(ClosingError(""))
-        finally:
-            self._pubsub_lock.release()
+        if not self._is_closed:
+            self._is_closed = True
+            err_message = "" if err_message is None else err_message
+            for response_future in self._available_futures.values():
+                if not response_future.done():
+                    response_future.set_exception(ClosingError(err_message))
+            try:
+                self._pubsub_lock.acquire()
+                for pubsub_future in self._pubsub_futures:
+                    if not pubsub_future.done():
+                        pubsub_future.set_exception(ClosingError(err_message))
+            finally:
+                self._pubsub_lock.release()
 
-        self._writer.close()
-        await self._writer.wait_closed()
-        self.__del__()
+            await self._stream.aclose()
 
-    def _get_future(self, callback_idx: int) -> asyncio.Future:
-        response_future: asyncio.Future = asyncio.Future()
+    def _get_future(self, callback_idx: int) -> "TFuture":
+        response_future: "TFuture" = _get_new_future_instance()
         self._available_futures.update({callback_idx: response_future})
         return response_future
 
@@ -237,14 +319,15 @@ class BaseClient(CoreCommands):
 
     async def _set_connection_configurations(self) -> None:
         conn_request = self._get_protobuf_conn_request()
-        response_future: asyncio.Future = self._get_future(0)
-        await self._write_or_buffer_request(conn_request)
+        response_future: "TFuture" = self._get_future(0)
+        self._create_write_task(conn_request)
         await response_future
-        if response_future.result() is not OK:
-            raise ClosingError(response_future.result())
+        res = response_future.result()
+        if res is not OK:
+            raise ClosingError(res)
 
     def _create_write_task(self, request: TRequest):
-        asyncio.create_task(self._write_or_buffer_request(request))
+        self._create_task(self._write_or_buffer_request, request)
 
     async def _write_or_buffer_request(self, request: TRequest):
         self._buffered_requests.append(request)
@@ -252,7 +335,21 @@ class BaseClient(CoreCommands):
             try:
                 while len(self._buffered_requests) > 0:
                     await self._write_buffered_requests_to_socket()
-
+            except Exception as e:
+                # trio system tasks cannot raise exceptions, so gracefully propagate
+                # any error to the pending future instead
+                callback_idx = (
+                    request.callback_idx if isinstance(request, CommandRequest) else 0
+                )
+                res_future = self._available_futures.pop(callback_idx, None)
+                if res_future:
+                    res_future.set_exception(e)
+                else:
+                    ClientLogger.log(
+                        LogLevel.WARN,
+                        "unhandled response error",
+                        f"Unhandled response error for unknown request: {callback_idx}",
+                    )
             finally:
                 self._writer_lock.release()
 
@@ -262,8 +359,7 @@ class BaseClient(CoreCommands):
         b_arr = bytearray()
         for request in requests:
             ProtobufCodec.encode_delimited(b_arr, request)
-        self._writer.write(b_arr)
-        await self._writer.drain()
+        await self._stream.send(b_arr)
 
     def _encode_arg(self, arg: TEncodable) -> bytes:
         """
@@ -417,14 +513,15 @@ class BaseClient(CoreCommands):
             )
 
         # locking might not be required
-        response_future: asyncio.Future = asyncio.Future()
+        response_future: "TFuture" = _get_new_future_instance()
         try:
             self._pubsub_lock.acquire()
             self._pubsub_futures.append(response_future)
             self._complete_pubsub_futures_safe()
         finally:
             self._pubsub_lock.release()
-        return await response_future
+        await response_future
+        return response_future.result()
 
     def try_get_pubsub_message(self) -> Optional[CoreCommands.PubSubMsg]:
         if self._is_closed:
@@ -457,8 +554,7 @@ class BaseClient(CoreCommands):
     def _cancel_pubsub_futures_with_exception_safe(self, exception: ConnectionError):
         while len(self._pubsub_futures):
             next_future = self._pubsub_futures.pop(0)
-            if not next_future.cancelled():
-                next_future.set_exception(exception)
+            next_future.set_exception(exception)
 
     def _notification_to_pubsub_message_safe(
         self, response: Response
@@ -538,10 +634,16 @@ class BaseClient(CoreCommands):
                 if response.HasField("closing_error")
                 else f"Client Error - closing due to unknown error. callback index:  {response.callback_idx}"
             )
+            exc = ClosingError(err_msg)
             if res_future is not None:
-                res_future.set_exception(ClosingError(err_msg))
-            await self.close(err_msg)
-            raise ClosingError(err_msg)
+                res_future.set_exception(exc)
+            else:
+                ClientLogger.log(
+                    LogLevel.WARN,
+                    "unhandled response error",
+                    f"Unhandled response error for unknown request: {response.callback_idx}",
+                )
+            raise exc
         else:
             self._available_callback_indexes.append(response.callback_idx)
             if response.HasField("request_error"):
@@ -561,9 +663,7 @@ class BaseClient(CoreCommands):
                 if response.HasField("closing_error")
                 else "Client Error - push notification without resp_pointer"
             )
-            await self.close(err_msg)
             raise ClosingError(err_msg)
-
         try:
             self._pubsub_lock.acquire()
             callback, context = self.config._get_pubsub_callback_and_context()
@@ -579,30 +679,36 @@ class BaseClient(CoreCommands):
 
     async def _reader_loop(self) -> None:
         # Socket reader loop
-        remaining_read_bytes = bytearray()
-        while True:
-            read_bytes = await self._reader.read(DEFAULT_READ_BYTES_SIZE)
-            if len(read_bytes) == 0:
-                err_msg = "The communication layer was unexpectedly closed."
-                await self.close(err_msg)
-                raise ClosingError(err_msg)
-            read_bytes = remaining_read_bytes + bytearray(read_bytes)
-            read_bytes_view = memoryview(read_bytes)
-            offset = 0
-            while offset <= len(read_bytes):
+        try:
+            remaining_read_bytes = bytearray()
+            while True:
                 try:
-                    response, offset = ProtobufCodec.decode_delimited(
-                        read_bytes, read_bytes_view, offset, Response
+                    read_bytes = await self._stream.receive(DEFAULT_READ_BYTES_SIZE)
+                except (anyio.ClosedResourceError, anyio.EndOfStream):
+                    raise ClosingError(
+                        "The communication layer was unexpectedly closed."
                     )
-                except PartialMessageException:
-                    # Received only partial response, break the inner loop
-                    remaining_read_bytes = read_bytes[offset:]
-                    break
-                response = cast(Response, response)
-                if response.is_push:
-                    await self._process_push(response=response)
-                else:
-                    await self._process_response(response=response)
+                read_bytes = remaining_read_bytes + bytearray(read_bytes)
+                read_bytes_view = memoryview(read_bytes)
+                offset = 0
+                while offset <= len(read_bytes):
+                    try:
+                        response, offset = ProtobufCodec.decode_delimited(
+                            read_bytes, read_bytes_view, offset, Response
+                        )
+                    except PartialMessageException:
+                        # Received only partial response, break the inner loop
+                        remaining_read_bytes = read_bytes[offset:]
+                        break
+                    response = cast(Response, response)
+                    if response.is_push:
+                        await self._process_push(response=response)
+                    else:
+                        await self._process_response(response=response)
+        except Exception as e:
+            # close and stop reading at terminal exceptions from incoming responses or
+            # stream closures
+            await self.close(str(e))
 
     async def get_statistics(self) -> dict:
         return get_statistics()

glide/routes.py

@@ -10,9 +10,14 @@ from glide.protobuf.command_request_pb2 import SlotTypes as ProtoSlotTypes
 
 class SlotType(Enum):
     PRIMARY = 1
+    """
+    Address a primary node.
+    """
 
     REPLICA = 2
     """
+    Address a replica node.
+
     `REPLICA` overrides the `read_from_replica` configuration. If it's used the request
     will be routed to a replica, even if the strategy is `ALWAYS_FROM_MASTER`.
     """
@@ -38,6 +43,10 @@ class AllNodes(Route):
 
 
 class AllPrimaries(Route):
+    """
+    Route request to all primary nodes.
+    """
+
     pass
 
 
@@ -53,6 +62,13 @@ class RandomNode(Route):
 
 
 class SlotKeyRoute(Route):
+    """Routes a request to a node by its slot key
+
+    Attributes:
+        slot_type (SlotType): Defines type of the node being addressed.
+        slot_key (str): The request will be sent to nodes managing this key.
+    """
+
     def __init__(self, slot_type: SlotType, slot_key: str) -> None:
         super().__init__()
         self.slot_type = slot_type
@@ -60,6 +76,15 @@ class SlotKeyRoute(Route):
 
 
 class SlotIdRoute(Route):
+    """Routes a request to a node by its slot ID
+
+    Attributes:
+        slot_type (SlotType): Defines type of the node being addressed.
+        slot_id (int): Slot number. There are 16384 slots in a Valkey cluster, and each shard
+            manages a slot range. Unless the slot is known, it's better to route using
+            `SlotType.PRIMARY`
+    """
+
     def __init__(self, slot_type: SlotType, slot_id: int) -> None:
         super().__init__()
         self.slot_type = slot_type

{valkey_glide-2.0.0rc5.dist-info → valkey_glide-2.0.0rc7.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: valkey-glide
-Version: 2.0.0rc5
+Version: 2.0.0rc7
 Classifier: Topic :: Database
 Classifier: Topic :: Utilities
 Classifier: License :: OSI Approved :: Apache Software License
@@ -9,7 +9,7 @@ Classifier: Topic :: Software Development
 Classifier: Programming Language :: Rust
 Classifier: Programming Language :: Python :: Implementation :: CPython
 Classifier: Programming Language :: Python :: Implementation :: PyPy
-Requires-Dist: async-timeout>=4.0.2; python_version < '3.11'
+Requires-Dist: anyio>=4.9.0
 Requires-Dist: typing-extensions>=4.8.0; python_version < '3.11'
 Requires-Dist: protobuf>=3.20
 Summary: An open source Valkey client library that supports Valkey and Redis open source 6.2, 7.0, 7.2 and 8.0.
@@ -18,9 +18,19 @@ License: Apache-2.0
 Requires-Python: >=3.9
 Description-Content-Type: text/markdown; charset=UTF-8; variant=GFM
 
-# Valkey GLIDE
+# Welcome to Valkey GLIDE!
 
-Valkey General Language Independent Driver for the Enterprise (GLIDE), is an open-source Valkey client library. Valkey GLIDE is one of the official client libraries for Valkey, and it supports all Valkey commands. Valkey GLIDE supports Valkey 7.2 and above, and Redis open-source 6.2, 7.0 and 7.2. Application programmers use Valkey GLIDE to safely and reliably connect their applications to Valkey- and Redis OSS- compatible services. Valkey GLIDE is designed for reliability, optimized performance, and high-availability, for Valkey and Redis OSS based applications. It is sponsored and supported by AWS, and is pre-configured with best practices learned from over a decade of operating Redis OSS-compatible services used by hundreds of thousands of customers. To help ensure consistency in application development and operations, Valkey GLIDE is implemented using a core driver framework, written in Rust, with language specific extensions. This design ensures consistency in features across languages and reduces overall complexity.
+Valkey General Language Independent Driver for the Enterprise (GLIDE) is the official open-source Valkey client library, proudly part of the Valkey organization. Our mission is to make your experience with Valkey and Redis OSS seamless and enjoyable. Whether you're a seasoned developer or just starting out, Valkey GLIDE is here to support you every step of the way.
+
+# Why Choose Valkey GLIDE?
+
+- **Community and Open Source**: Join our vibrant community and contribute to the project. We are always here to respond, and the client is for the community.
+- **Reliability**: Built with best practices learned from over a decade of operating Redis OSS-compatible services.
+- **Performance**: Optimized for high performance and low latency.
+- **High Availability**: Designed to ensure your applications are always up and running.
+- **Cross-Language Support**: Implemented using a core driver framework written in Rust, with language-specific extensions to ensure consistency and reduce complexity.
+- **Stability and Fault Tolerance**: We brought our years of experience to create a bulletproof client.
+- **Backed and Supported by AWS and GCP**: Ensuring robust support and continuous improvement of the project.
 
 ## Documentation
 
@@ -47,6 +57,7 @@ Linux:
 macOS:
 
 -   macOS 14.7 (Apple silicon/aarch_64)
+-   macOS 13.7 (x86_64/amd64)
 
 ## Python Supported Versions
 
@@ -58,6 +69,8 @@ macOS:
 | 3.12           |
 | 3.13           |
 
+Valkey GLIDE transparently supports both the `asyncio` and `trio` concurrency frameworks.
+
 ## Installation and Setup
 
 ### Installing via Package Manager (pip)
@@ -125,3 +138,7 @@ For complete examples with error handling, please refer to the [cluster example]
 
 Development instructions for local building & testing the package are in the [DEVELOPER.md](https://github.com/valkey-io/valkey-glide/blob/main/python/DEVELOPER.md#build-from-source) file.
 
+## Community and Feedback
+
+We encourage you to join our community to support, share feedback, and ask questions. You can approach us for anything on our Valkey Slack: [Join Valkey Slack](https://join.slack.com/t/valkey-oss-developer/shared_invite/zt-2nxs51chx-EB9hu9Qdch3GMfRcztTSkQ).
+

{valkey_glide-2.0.0rc5.dist-info → valkey_glide-2.0.0rc7.dist-info}/RECORD

@@ -1,12 +1,12 @@
-valkey_glide-2.0.0rc5.dist-info/METADATA,sha256=Ux9L-LWvcJmiXrXK0pnolsTIN8YmLR87X5D7ChZybpI,5091
-valkey_glide-2.0.0rc5.dist-info/WHEEL,sha256=8hoTVLxyLdG351Jq1HozDQCHHiKu32mfNA2_wpcO9P4,106
+valkey_glide-2.0.0rc7.dist-info/METADATA,sha256=JZCHx9sqjhS0Tj05RJ22jjPa_QvUQmDfNMQ0IknjfHE,5650
+valkey_glide-2.0.0rc7.dist-info/WHEEL,sha256=8hoTVLxyLdG351Jq1HozDQCHHiKu32mfNA2_wpcO9P4,106
 glide/config.py,sha256=1IkmvCPLU9nm7EpwcvYT3URoLWApWGr6eSRmuyPXDyA,28891
 glide/protobuf_codec.py,sha256=xwt4-D4WbvNIY_vjOd-00c73HOyNjWq7nN-Z718PBVA,3667
 glide/constants.py,sha256=Kb-wTQrcshjCivNXcrrOzz7xp7pNL_-Gt6Updiq9k4o,4354
 glide/async_commands/sorted_set.py,sha256=nALPJQNNjW7dAqXMDJIur_xDwnJzQCdqxtx5zXYCRNM,11458
-glide/async_commands/batch.py,sha256=oInDvW-7XPQtm9kJYWMdILCEjzlKCv6H--SeG-fDjcg,229669
+glide/async_commands/batch.py,sha256=DOCXFbIZWNuBzIi_6P1Qt3HvRZVblBwoUxr_4imE8A4,230468
 glide/async_commands/__init__.py,sha256=_tbTAFATlzp4L2qe-H77PpAQK-16VsV-y7uKNUKLC_o,136
-glide/async_commands/core.py,sha256=ydb0dFsJN6KLttSdbjOLMcK5RahUBIsX7X5QxgyooIg,316222
+glide/async_commands/core.py,sha256=NS8jfMonU46KGPUZV5csKAueajwZlhs5FJI-aCSlLBY,316484
 glide/async_commands/server_modules/glide_json.py,sha256=cf93MG6GioA7hFLPn1vNMjipoUt6G-qJ2oK9E91KRkw,63120
 glide/async_commands/server_modules/json_batch.py,sha256=XBySnoRJnm1ABPYBnajHmPK6C-Wr9uk3gjNg2s7wVm8,36631
 glide/async_commands/server_modules/ft.py,sha256=xOV22Znj9z9clKK5XZUL8UhthSbiA1F2H11EOKtMJCg,16840
@@ -16,13 +16,13 @@ glide/async_commands/server_modules/ft_options/ft_create_options.py,sha256=hz-H8
 glide/async_commands/server_modules/ft_options/ft_profile_options.py,sha256=19t7pHHFu-Vbp_1e5XSNHHDjnssU4kI49wglE0YskDk,4273
 glide/async_commands/server_modules/ft_options/ft_constants.py,sha256=r9uLAExg2qThjwOBC8LxqXBITF0fwa5xfnD7EXnyPrw,1704
 glide/async_commands/stream.py,sha256=y3tmuOc-Ndnjvc__xybBcf2wqoNUQ1H1hPXYerpwNA8,15582
-glide/async_commands/standalone_commands.py,sha256=_7WN5eBc_-oQ1j3BHW4X4JVqEMkL2Eihdl5_0MEPvUU,38991
-glide/async_commands/cluster_commands.py,sha256=tD45_xUV0nyxuEDDhgTVenREx-O_l-yAY277UTv1xEI,61537
+glide/async_commands/standalone_commands.py,sha256=vfqXTIU5YLMsHUD9MD3Qi1vccD9QMSQuH38mpo_5rjU,39510
+glide/async_commands/cluster_commands.py,sha256=trG0vZCMZxrkziYBFlFvLZ3nMUvfS6r-BRkRwb9Gif0,61994
 glide/async_commands/command_args.py,sha256=55vpSxeQr8wFU7olkFTEecl66wPk1g6vWxVYj16UvXs,2529
 glide/async_commands/bitmap.py,sha256=ZHGLcKBP7RADtANqIR7PWdIW_gfDBFgpkIsQ-T4QFBQ,10125
 glide/__init__.py,sha256=nCbDQf344sIuXbaCsivrjBjkQ3kaP_ArT3IQnzTUFx8,7372
 glide/glide.pyi,sha256=K2CeC-F0E8vlr-rbko-E0PofzFoWl4da-xUQSuvuFDo,1105
-glide/glide_client.py,sha256=LVx6gJNoD9KxG26eKbSLgj8TZP6M-ZVR0n1qOnABKUU,28695
+glide/glide_client.py,sha256=n9Vp7vjqRjHNK24YqHU35YkeDUriberJC5RPPS4_EeI,31870
 glide/logger.py,sha256=IhlrmIDF4IufCOszQu2WnMZeyBfH21kVr8KwDlBqDP0,3800
 glide/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 glide/exceptions.py,sha256=ZI_LwIduoR-1jHm9-6jWZkx90AqCJLRtjbv4iESIEEA,1194
@@ -32,6 +32,6 @@ glide/protobuf/command_request_pb2.py,sha256=Kl07aQBGu8i3oFqbT-uZByWVaTCjYuDeYb0
 glide/protobuf/connection_request_pb2.py,sha256=rqnCM3pR4X74eEJzBFhsQ27SKxdtYI5vS-mbWFaQ7js,5706
 glide/protobuf/command_request_pb2.pyi,sha256=DYnPAmwzyygCdCpW1R1CDGZB_O6zQRJp51K8Wr4CpFc,52470
 glide/protobuf/response_pb2.py,sha256=r3_OFhf8HZvEmBSigSyBzG7S7kWl7CCgVMog4HgMFXM,2025
-glide/routes.py,sha256=Y958gbY-o53cG4-SqaN-enrZXByZyp8BYVkOk5YeB8U,3725
-glide/glide.cpython-311-darwin.so,sha256=JHsy63BTqxidl432lrcJrIdkiFNU5WJtCodTA0OkSWk,6592256
-valkey_glide-2.0.0rc5.dist-info/RECORD,,
+glide/routes.py,sha256=ZcLV_HrMzAYxHJW7uk905gdhOZbchBDSHlG1LVF7BJ4,4439
+glide/glide.cpython-311-darwin.so,sha256=Awk81cX8i0nWX9qDZGLedkRfA_Iu3nvOYdWhPcliJdo,6642208
+valkey_glide-2.0.0rc7.dist-info/RECORD,,