valkey-glide 2.0.0rc3__cp310-cp310-macosx_11_0_arm64.whl → 2.2.3__cp310-cp310-macosx_11_0_arm64.whl

glide/async_commands/{server_modules/ft.py → ft.py}

@@ -5,24 +5,24 @@ module for `vector search` commands.
 
 from typing import List, Mapping, Optional, cast
 
-from glide.async_commands.server_modules.ft_options.ft_aggregate_options import (
+from glide_shared.commands.server_modules.ft_options.ft_aggregate_options import (
     FtAggregateOptions,
 )
-from glide.async_commands.server_modules.ft_options.ft_constants import (
+from glide_shared.commands.server_modules.ft_options.ft_constants import (
     CommandNames,
     FtCreateKeywords,
 )
-from glide.async_commands.server_modules.ft_options.ft_create_options import (
+from glide_shared.commands.server_modules.ft_options.ft_create_options import (
     Field,
     FtCreateOptions,
 )
-from glide.async_commands.server_modules.ft_options.ft_profile_options import (
+from glide_shared.commands.server_modules.ft_options.ft_profile_options import (
     FtProfileOptions,
 )
-from glide.async_commands.server_modules.ft_options.ft_search_options import (
+from glide_shared.commands.server_modules.ft_options.ft_search_options import (
     FtSearchOptions,
 )
-from glide.constants import (
+from glide_shared.constants import (
     TOK,
     FtAggregateResponse,
     FtInfoResponse,
@@ -30,7 +30,8 @@ from glide.constants import (
     FtSearchResponse,
     TEncodable,
 )
-from glide.glide_client import TGlideClient
+
+from ..glide_client import TGlideClient
 
 
 async def create(

glide/async_commands/{server_modules/glide_json.py → glide_json.py}

@@ -7,7 +7,7 @@ Examples:
     >>> import json
     >>> value = {'a': 1.0, 'b': 2}
     >>> json_str = json.dumps(value) # Convert Python dictionary to JSON string using json.dumps()
-    >>> await json.set(client, "doc", "$", json_str)
+    >>> await glide_json.set(client, "doc", "$", json_str)
         'OK'  # Indicates successful setting of the value at path '$' in the key stored at `doc`.
     >>> json_get = await glide_json.get(client, "doc", "$") # Returns the value at path '$' in the JSON document stored at
                                                             # `doc` as JSON string.
@@ -19,97 +19,20 @@ Examples:
 """
 from typing import List, Optional, Union, cast
 
-from glide.async_commands.core import ConditionalChange
-from glide.constants import TOK, TEncodable, TJsonResponse, TJsonUniversalResponse
-from glide.glide_client import TGlideClient
-
-
-class JsonGetOptions:
-    """
-    Represents options for formatting JSON data, to be used in  the [JSON.GET](https://valkey.io/commands/json.get/) command.
-
-    Args:
-        indent (Optional[str]): Sets an indentation string for nested levels. Defaults to None.
-        newline (Optional[str]): Sets a string that's printed at the end of each line. Defaults to None.
-        space (Optional[str]): Sets a string that's put between a key and a value. Defaults to None.
-    """
-
-    def __init__(
-        self,
-        indent: Optional[str] = None,
-        newline: Optional[str] = None,
-        space: Optional[str] = None,
-    ):
-        self.indent = indent
-        self.new_line = newline
-        self.space = space
-
-    def get_options(self) -> List[str]:
-        args = []
-        if self.indent:
-            args.extend(["INDENT", self.indent])
-        if self.new_line:
-            args.extend(["NEWLINE", self.new_line])
-        if self.space:
-            args.extend(["SPACE", self.space])
-        return args
-
-
-class JsonArrIndexOptions:
-    """
-    Options for the `JSON.ARRINDEX` command.
-
-    Args:
-        start (int): The inclusive start index from which the search begins. Defaults to None.
-        end (Optional[int]): The exclusive end index where the search stops. Defaults to None.
-
-    Note:
-        - If `start` is greater than `end`, the command returns `-1` to indicate that the value was not found.
-        - Indices that exceed the array bounds are automatically adjusted to the nearest valid position.
-    """
-
-    def __init__(self, start: int, end: Optional[int] = None):
-        self.start = start
-        self.end = end
-
-    def to_args(self) -> List[str]:
-        """
-        Get the options as a list of arguments for the JSON.ARRINDEX command.
-
-        Returns:
-            List[str]: A list containing the start and end indices if specified.
-        """
-        args = [str(self.start)]
-        if self.end is not None:
-            args.append(str(self.end))
-        return args
-
-
-class JsonArrPopOptions:
-    """
-    Options for the JSON.ARRPOP command.
-
-    Args:
-        path (TEncodable): The path within the JSON document.
-        index (Optional[int]): The index of the element to pop. If not specified, will pop the last element.
-            Out of boundary indexes are rounded to their respective array boundaries. Defaults to None.
-    """
-
-    def __init__(self, path: TEncodable, index: Optional[int] = None):
-        self.path = path
-        self.index = index
-
-    def to_args(self) -> List[TEncodable]:
-        """
-        Get the options as a list of arguments for the `JSON.ARRPOP` command.
-
-        Returns:
-            List[TEncodable]: A list containing the path and, if specified, the index.
-        """
-        args = [self.path]
-        if self.index is not None:
-            args.append(str(self.index))
-        return args
+from glide_shared.commands.core_options import ConditionalChange
+from glide_shared.commands.server_modules.json_options import (
+    JsonArrIndexOptions,
+    JsonArrPopOptions,
+    JsonGetOptions,
+)
+from glide_shared.constants import (
+    TOK,
+    TEncodable,
+    TJsonResponse,
+    TJsonUniversalResponse,
+)
+
+from ..glide_client import TGlideClient
 
 
 async def set(

glide/async_commands/standalone_commands.py

@@ -4,24 +4,25 @@ from __future__ import annotations
 
 from typing import Dict, List, Mapping, Optional, Union, cast
 
-from glide.async_commands.batch import Batch
-from glide.async_commands.command_args import ObjectType
-from glide.async_commands.core import (
-    CoreCommands,
+from glide.glide import Script
+from glide_shared.commands.batch import Batch
+from glide_shared.commands.batch_options import BatchOptions
+from glide_shared.commands.command_args import ObjectType
+from glide_shared.commands.core_options import (
     FlushMode,
     FunctionRestorePolicy,
     InfoSection,
 )
-from glide.constants import (
+from glide_shared.constants import (
     TOK,
     TEncodable,
     TFunctionListResponse,
     TFunctionStatsFullResponse,
     TResult,
 )
-from glide.protobuf.command_request_pb2 import RequestType
+from glide_shared.protobuf.command_request_pb2 import RequestType
 
-from ..glide import Script
+from .core import CoreCommands
 
 
 class StandaloneCommands(CoreCommands):
@@ -31,6 +32,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 +44,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 +57,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:
@@ -69,7 +77,7 @@ class StandaloneCommands(CoreCommands):
         self,
         batch: Batch,
         raise_on_error: bool,
-        timeout: Optional[int] = None,
+        options: Optional[BatchOptions] = None,
     ) -> Optional[List[TResult]]:
         """
         Executes a batch by processing the queued commands.
@@ -89,10 +97,7 @@ class StandaloneCommands(CoreCommands):
                 When set to ``False``, errors will be included as part of the batch response array, allowing
                 the caller to process both successful and failed commands together. In this case, error details
                 will be provided as instances of ``RequestError``.
-            timeout (Optional[int]): The duration in milliseconds that the client should wait for the batch request
-                to complete. This duration encompasses sending the request, awaiting a response from the server, and any
-                required reconnections or retries. If the specified timeout is exceeded for the request,
-                a timeout error will be raised. If not explicitly set, the client's default request timeout will be used.
+            options (Optional[BatchOptions]): A ``BatchOptions`` object containing execution options.
 
         Returns:
             Optional[List[TResult]]: An array of results, where each entry corresponds to a command's execution result.
@@ -118,33 +123,38 @@ class StandaloneCommands(CoreCommands):
             # Expected Output: Pipeline Batch Result: [OK, OK, b'value1', b'value2']
 
         Example (Atomic Batch - Transaction with options):
+            >>> from glide import BatchOptions
             >>> transaction = Batch(is_atomic=True)
             >>> transaction.set("key", "1")
             >>> transaction.incr("key")
             >>> transaction.custom_command(["get", "key"])
+            >>> options = BatchOptions(timeout=1000)  # Set a timeout of 1000 milliseconds
             >>> result = await client.exec(
             ...     transaction,
             ...     raise_on_error=False,  # Do not raise an error on failure
-            ...     timeout=1000  # Set a timeout of 1000 milliseconds
+            ...     options=options
             ... )
             >>> print(f"Transaction Result: {result}")
             # Expected Output: Transaction Result: [OK, 2, b'2']
 
         Example (Non-Atomic Batch - Pipeline with options):
+            >>> from glide import BatchOptions
             >>> pipeline = Batch(is_atomic=False)
             >>> pipeline.custom_command(["set", "key1", "value1"])
             >>> pipeline.custom_command(["set", "key2", "value2"])
             >>> pipeline.custom_command(["get", "key1"])
             >>> pipeline.custom_command(["get", "key2"])
+            >>> options = BatchOptions(timeout=1000)  # Set a timeout of 1000 milliseconds
             >>> result = await client.exec(
             ...     pipeline,
             ...     raise_on_error=False,  # Do not raise an error on failure
-            ...     timeout=1000  # Set a timeout of 1000 milliseconds
+            ...     options=options
             ... )
             >>> print(f"Pipeline Result: {result}")
             # Expected Output: Pipeline Result: [OK, OK, b'value1', b'value2']
         """
         commands = batch.commands[:]
+        timeout = options.timeout if options else None
         return await self._execute_batch(
             commands,
             is_atomic=batch.is_atomic,
@@ -152,20 +162,6 @@ class StandaloneCommands(CoreCommands):
             timeout=timeout,
         )
 
-    async def select(self, index: int) -> TOK:
-        """
-        Change the currently selected database.
-
-        See [valkey.io](https://valkey.io/commands/select/) for details.
-
-        Args:
-            index (int): The index of the database to select.
-
-        Returns:
-            A simple OK response.
-        """
-        return cast(TOK, await self._execute_command(RequestType.Select, [str(index)]))
-
     async def config_resetstat(self) -> TOK:
         """
         Resets the statistics reported by the server using the INFO and LATENCY HISTOGRAM commands.
@@ -619,31 +615,6 @@ class StandaloneCommands(CoreCommands):
             await self._execute_command(RequestType.LastSave, []),
         )
 
-    async def move(self, key: TEncodable, db_index: int) -> bool:
-        """
-        Move `key` from the currently selected database to the database specified by `db_index`.
-
-        See [valkey.io](https://valkey.io/commands/move/) for more details.
-
-        Args:
-            key (TEncodable): The key to move.
-            db_index (int): The index of the database to move `key` to.
-
-        Returns:
-            bool: `True` if `key` was moved.
-
-            `False` if the `key` already exists in the destination database
-            or does not exist in the source database.
-
-        Example:
-            >>> await client.move("some_key", 1)
-                True
-        """
-        return cast(
-            bool,
-            await self._execute_command(RequestType.Move, [key, str(db_index)]),
-        )
-
     async def publish(self, message: TEncodable, channel: TEncodable) -> int:
         """
         Publish a message on pubsub channel.
@@ -796,7 +767,7 @@ class StandaloneCommands(CoreCommands):
             args.extend(["VERSION", str(version)])
         if parameters:
             for var in parameters:
-                args.extend(str(var))
+                args.append(str(var))
         return cast(
             bytes,
             await self._execute_command(RequestType.Lolwut, args),
@@ -861,8 +832,6 @@ class StandaloneCommands(CoreCommands):
             TOK: A simple "OK" response.
 
         Examples:
-            >>> await client.watch("sampleKey")
-                'OK'
             >>> await client.unwatch()
                 'OK'
         """
@@ -1026,7 +995,7 @@ class StandaloneCommands(CoreCommands):
 
         Examples:
             >>> lua_script = Script("return { KEYS[1], ARGV[1] }")
-            >>> await client.invoke_script(lua_script, keys=["foo"], args=["bar"] );
+            >>> await client.invoke_script(lua_script, keys=["foo"], args=["bar"])
                 [b"foo", b"bar"]
         """
         return await self._execute_script(script.get_hash(), keys, args)

glide/glide.pyi

@@ -2,7 +2,7 @@ from collections.abc import Callable
 from enum import Enum
 from typing import List, Optional, Union
 
-from glide.constants import TResult
+from glide_shared.constants import TResult
 
 DEFAULT_TIMEOUT_IN_MILLISECONDS: int = ...
 MAX_REQUEST_ARGS_LEN: int = ...
@@ -27,6 +27,28 @@ class ClusterScanCursor:
     def get_cursor(self) -> str: ...
     def is_finished(self) -> bool: ...
 
+class OpenTelemetryConfig:
+    def __init__(
+        self,
+        traces: Optional[OpenTelemetryTracesConfig] = None,
+        metrics: Optional[OpenTelemetryMetricsConfig] = None,
+        flush_interval_ms: Optional[int] = None,
+    ) -> None: ...
+    def get_traces(self) -> Optional[OpenTelemetryTracesConfig]: ...
+    def set_traces(self, traces: OpenTelemetryTracesConfig) -> None: ...
+    def get_metrics(self) -> Optional[OpenTelemetryMetricsConfig]: ...
+
+class OpenTelemetryTracesConfig:
+    def __init__(
+        self, endpoint: str, sample_percentage: Optional[int] = None
+    ) -> None: ...
+    def get_endpoint(self) -> str: ...
+    def get_sample_percentage(self) -> Optional[int]: ...
+
+class OpenTelemetryMetricsConfig:
+    def __init__(self, endpoint: str) -> None: ...
+    def get_endpoint(self) -> str: ...
+
 def start_socket_listener_external(init_callback: Callable) -> None: ...
 def value_from_pointer(pointer: int) -> TResult: ...
 def create_leaked_value(message: str) -> int: ...
@@ -34,3 +56,6 @@ def create_leaked_bytes_vec(args_vec: List[bytes]) -> int: ...
 def get_statistics() -> dict: ...
 def py_init(level: Optional[Level], file_name: Optional[str]) -> Level: ...
 def py_log(log_level: Level, log_identifier: str, message: str) -> None: ...
+def create_otel_span(name: str) -> int: ...
+def drop_otel_span(span_ptr: int) -> None: ...
+def init_opentelemetry(config: OpenTelemetryConfig) -> None: ...