valkey-glide 1.3.5__cp39-cp39-macosx_11_0_arm64.whl → 2.2.2__cp39-cp39-macosx_11_0_arm64.whl

glide_shared/commands/server_modules/json_options.py

@@ -0,0 +1,93 @@
+# Copyright Valkey GLIDE Project Contributors - SPDX Identifier: Apache-2.0
+
+from typing import List, Optional
+
+from glide_shared.constants import TEncodable
+
+
+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
+
+
+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

{glide/async_commands → glide_shared/commands}/sorted_set.py

@@ -3,8 +3,8 @@
 from enum import Enum
 from typing import List, Optional, Tuple, Union, cast
 
-from glide.async_commands.command_args import Limit, OrderBy
-from glide.constants import TEncodable
+from glide_shared.commands.command_args import Limit, OrderBy
+from glide_shared.constants import TEncodable
 
 
 class InfBound(Enum):
@@ -15,14 +15,18 @@ class InfBound(Enum):
     POS_INF = {"score_arg": "+inf", "lex_arg": "+"}
     """
     Positive infinity bound for sorted set.
-        score_arg: represents numeric positive infinity (+inf).
-        lex_arg: represents lexicographic positive infinity (+).
+
+    `score_arg`: represents numeric positive infinity (+inf).
+
+    `lex_arg`: represents lexicographic positive infinity (+).
     """
     NEG_INF = {"score_arg": "-inf", "lex_arg": "-"}
     """
     Negative infinity bound for sorted set.
-        score_arg: represents numeric negative infinity (-inf).
-        lex_arg: represents lexicographic negative infinity (-).
+
+    `score_arg`: represents numeric negative infinity (-inf).
+
+    `lex_arg`: represents lexicographic negative infinity (-).
     """
 
 
@@ -49,8 +53,8 @@ class ScoreFilter(Enum):
     """
     Defines which elements to pop from a sorted set.
 
-    ScoreFilter is a mandatory option for ZMPOP (https://valkey.io/commands/zmpop)
-    and BZMPOP (https://valkey.io/commands/bzmpop).
+    ScoreFilter is a mandatory option for [ZMPOP](https://valkey.io/commands/zmpop)
+    and [BZMPOP](https://valkey.io/commands/bzmpop).
     """
 
     MIN = "MIN"
@@ -97,7 +101,7 @@ class RangeByIndex:
 
     The `start` and `end` arguments represent zero-based indexes.
 
-    Args:
+    Attributes:
         start (int): The start index of the range.
         end (int): The end index of the range.
     """
@@ -113,10 +117,11 @@ class RangeByScore:
 
     The `start` and `end` arguments represent score boundaries.
 
-    Args:
+    Attributes:
         start (Union[InfBound, ScoreBoundary]): The start score boundary.
         end (Union[InfBound, ScoreBoundary]): The end score boundary.
-        limit (Optional[Limit]): The limit argument for a range query. Defaults to None. See `Limit` class for more information.
+        limit (Optional[Limit]): The limit argument for a range query. Defaults to None. See `Limit`
+            class for more information.
     """
 
     def __init__(
@@ -126,9 +131,9 @@ class RangeByScore:
         limit: Optional[Limit] = None,
     ):
         self.start = (
-            start.value["score_arg"] if type(start) == InfBound else start.value
+            start.value["score_arg"] if isinstance(start, InfBound) else start.value
         )
-        self.end = end.value["score_arg"] if type(end) == InfBound else end.value
+        self.end = end.value["score_arg"] if isinstance(end, InfBound) else end.value
         self.limit = limit
 
 
@@ -138,10 +143,11 @@ class RangeByLex:
 
     The `start` and `end` arguments represent lexicographical boundaries.
 
-    Args:
+    Attributes:
         start (Union[InfBound, LexBoundary]): The start lexicographic boundary.
         end (Union[InfBound, LexBoundary]): The end lexicographic boundary.
-        limit (Optional[Limit]): The limit argument for a range query. Defaults to None. See `Limit` class for more information.
+        limit (Optional[Limit]): The limit argument for a range query. Defaults to None. See `Limit` class
+            for more information.
     """
 
     def __init__(
@@ -150,24 +156,28 @@ class RangeByLex:
         end: Union[InfBound, LexBoundary],
         limit: Optional[Limit] = None,
     ):
-        self.start = start.value["lex_arg"] if type(start) == InfBound else start.value
-        self.end = end.value["lex_arg"] if type(end) == InfBound else end.value
+        self.start = (
+            start.value["lex_arg"] if isinstance(start, InfBound) else start.value
+        )
+        self.end = end.value["lex_arg"] if isinstance(end, InfBound) else end.value
         self.limit = limit
 
 
 class GeospatialData:
-    def __init__(self, longitude: float, latitude: float):
-        """
-        Represents a geographic position defined by longitude and latitude.
+    """
+    Represents a geographic position defined by longitude and latitude.
 
-        The exact limits, as specified by EPSG:900913 / EPSG:3785 / OSGEO:41001 are the following:
-            - Valid longitudes are from -180 to 180 degrees.
-            - Valid latitudes are from -85.05112878 to 85.05112878 degrees.
+    The exact limits, as specified by EPSG:900913 / EPSG:3785 / OSGEO:41001 are the following:
 
-        Args:
-            longitude (float): The longitude coordinate.
-            latitude (float): The latitude coordinate.
-        """
+        - Valid longitudes are from -180 to 180 degrees.
+        - Valid latitudes are from -85.05112878 to 85.05112878 degrees.
+
+    Attributes:
+        longitude (float): The longitude coordinate.
+        latitude (float): The latitude coordinate.
+    """
+
+    def __init__(self, longitude: float, latitude: float):
         self.longitude = longitude
         self.latitude = latitude
 
@@ -199,7 +209,7 @@ class GeoSearchByRadius:
     """
     Represents search criteria of searching within a certain radius from a specified point.
 
-    Args:
+    Attributes:
         radius (float): Radius of the search area.
         unit (GeoUnit): Unit of the radius. See `GeoUnit`.
     """
@@ -225,7 +235,7 @@ class GeoSearchByBox:
     """
     Represents search criteria of searching within a specified rectangular area.
 
-    Args:
+    Attributes:
         width (float): Width of the bounding box.
         height (float): Height of the bounding box
         unit (GeoUnit): Unit of the radius. See `GeoUnit`.
@@ -253,10 +263,10 @@ class GeoSearchCount:
     """
     Represents the count option for limiting the number of results in a GeoSearch.
 
-    Args:
+    Attributes:
         count (int): The maximum number of results to return.
         any_option (bool): Whether to allow returning as enough matches are found.
-        This means that the results returned may not be the ones closest to the specified point. Default to False.
+            This means that the results returned may not be the ones closest to the specified point. Default to False.
     """
 
     def __init__(self, count: int, any_option: bool = False):

{glide/async_commands → glide_shared/commands}/stream.py

@@ -4,12 +4,20 @@ from __future__ import annotations
 from abc import ABC, abstractmethod
 from typing import List, Optional, Union
 
-from glide.constants import TEncodable
+from glide_shared.constants import TEncodable
 
 
 class StreamTrimOptions(ABC):
     """
     Abstract base class for stream trim options.
+
+    Attributes:
+        exact (bool): If `true`, the stream will be trimmed exactly.
+            Otherwise the stream will be trimmed in a near-exact manner, which is more efficient.
+        threshold (Union[TEncodable, int]): Threshold for trimming.
+        method (str): Method for trimming (e.g., MINID, MAXLEN).
+        limit (Optional[int]): Max number of entries to be trimmed. Defaults to None.
+            Note: If `exact` is set to `True`, `limit` cannot be specified.
     """
 
     @abstractmethod
@@ -22,14 +30,6 @@ class StreamTrimOptions(ABC):
     ):
         """
         Initialize stream trim options.
-
-        Args:
-            exact (bool): If `true`, the stream will be trimmed exactly.
-                Otherwise the stream will be trimmed in a near-exact manner, which is more efficient.
-            threshold (Union[TEncodable, int]): Threshold for trimming.
-            method (str): Method for trimming (e.g., MINID, MAXLEN).
-            limit (Optional[int]): Max number of entries to be trimmed. Defaults to None.
-                Note: If `exact` is set to `True`, `limit` cannot be specified.
         """
         if exact and limit:
             raise ValueError(
@@ -60,18 +60,18 @@ class StreamTrimOptions(ABC):
 class TrimByMinId(StreamTrimOptions):
     """
     Stream trim option to trim by minimum ID.
+
+    Attributes:
+        exact (bool): If `true`, the stream will be trimmed exactly.
+            Otherwise the stream will be trimmed in a near-exact manner, which is more efficient.
+        threshold (TEncodable): Threshold for trimming by minimum ID.
+        limit (Optional[int]): Max number of entries to be trimmed. Defaults to None.
+            Note: If `exact` is set to `True`, `limit` cannot be specified.
     """
 
     def __init__(self, exact: bool, threshold: TEncodable, limit: Optional[int] = None):
         """
         Initialize trim option by minimum ID.
-
-        Args:
-            exact (bool): If `true`, the stream will be trimmed exactly.
-                Otherwise the stream will be trimmed in a near-exact manner, which is more efficient.
-            threshold (TEncodable): Threshold for trimming by minimum ID.
-            limit (Optional[int]): Max number of entries to be trimmed. Defaults to None.
-                Note: If `exact` is set to `True`, `limit` cannot be specified.
         """
         super().__init__(exact, threshold, "MINID", limit)
 
@@ -79,18 +79,18 @@ class TrimByMinId(StreamTrimOptions):
 class TrimByMaxLen(StreamTrimOptions):
     """
     Stream trim option to trim by maximum length.
+
+    Attributes:
+        exact (bool): If `true`, the stream will be trimmed exactly.
+            Otherwise the stream will be trimmed in a near-exact manner, which is more efficient.
+        threshold (int): Threshold for trimming by maximum length.
+        limit (Optional[int]): Max number of entries to be trimmed. Defaults to None.
+            Note: If `exact` is set to `True`, `limit` cannot be specified.
     """
 
     def __init__(self, exact: bool, threshold: int, limit: Optional[int] = None):
         """
         Initialize trim option by maximum length.
-
-        Args:
-            exact (bool): If `true`, the stream will be trimmed exactly.
-                Otherwise the stream will be trimmed in a near-exact manner, which is more efficient.
-            threshold (int): Threshold for trimming by maximum length.
-            limit (Optional[int]): Max number of entries to be trimmed. Defaults to None.
-                Note: If `exact` is set to `True`, `limit` cannot be specified.
         """
         super().__init__(exact, threshold, "MAXLEN", limit)
 
@@ -98,6 +98,13 @@ class TrimByMaxLen(StreamTrimOptions):
 class StreamAddOptions:
     """
     Options for adding entries to a stream.
+
+    Attributes:
+        id (Optional[TEncodable]): ID for the new entry. If set, the new entry will be added with this ID. If not
+            specified, '*' is used.
+        make_stream (bool, optional): If set to False, a new stream won't be created if no stream matches the given key.
+        trim (Optional[StreamTrimOptions]): If set, the add operation will also trim the older entries in the stream.
+            See `StreamTrimOptions`.
     """
 
     def __init__(
@@ -108,11 +115,6 @@ class StreamAddOptions:
     ):
         """
         Initialize stream add options.
-
-        Args:
-            id (Optional[TEncodable]): ID for the new entry. If set, the new entry will be added with this ID. If not specified, '*' is used.
-            make_stream (bool, optional): If set to False, a new stream won't be created if no stream matches the given key.
-            trim (Optional[StreamTrimOptions]): If set, the add operation will also trim the older entries in the stream. See `StreamTrimOptions`.
         """
         self.id = id
         self.make_stream = make_stream
@@ -178,6 +180,9 @@ class IdBound(StreamRangeBound):
     Inclusive (closed) stream ID boundary used to specify a range of IDs to search. Stream ID bounds can be complete
     with a timestamp and sequence number separated by a dash ("-"), for example "1526985054069-0". Stream ID bounds can
     also be incomplete, with just a timestamp.
+
+    Attributes:
+        stream_id (str): The stream ID.
     """
 
     @staticmethod
@@ -193,9 +198,6 @@ class IdBound(StreamRangeBound):
     def __init__(self, stream_id: TEncodable):
         """
         Creates a stream ID boundary for a range search.
-
-        Args:
-            stream_id (str): The stream ID.
         """
         self.stream_id = stream_id
 
@@ -210,6 +212,9 @@ class ExclusiveIdBound(StreamRangeBound):
     be incomplete, with just a timestamp.
 
     Since: Valkey version 6.2.0.
+
+    Attributes:
+        stream_id (TEncodable): The stream ID.
     """
 
     EXCLUSIVE_BOUND_VALKEY_API = "("
@@ -227,9 +232,6 @@ class ExclusiveIdBound(StreamRangeBound):
     def __init__(self, stream_id: TEncodable):
         """
         Creates a stream ID boundary for a range search.
-
-        Args:
-            stream_id (TEncodable): The stream ID.
         """
         if isinstance(stream_id, bytes):
             stream_id = stream_id.decode("utf-8")
@@ -240,18 +242,19 @@ class ExclusiveIdBound(StreamRangeBound):
 
 
 class StreamReadOptions:
+    """
+    Options for reading entries from streams. Can be used as an optional argument to `XREAD`.
+
+    Attributes:
+        block_ms (Optional[int]): If provided, the request will be blocked for the set amount of milliseconds or
+            until the server has the required number of entries. Equivalent to `BLOCK` in the Valkey API.
+        count (Optional[int]): The maximum number of elements requested. Equivalent to `COUNT` in the Valkey API.
+    """
+
     READ_COUNT_VALKEY_API = "COUNT"
     READ_BLOCK_VALKEY_API = "BLOCK"
 
     def __init__(self, block_ms: Optional[int] = None, count: Optional[int] = None):
-        """
-        Options for reading entries from streams. Can be used as an optional argument to `XREAD`.
-
-        Args:
-            block_ms (Optional[int]): If provided, the request will be blocked for the set amount of milliseconds or
-                until the server has the required number of entries. Equivalent to `BLOCK` in the Valkey API.
-            count (Optional[int]): The maximum number of elements requested. Equivalent to `COUNT` in the Valkey API.
-        """
         self.block_ms = block_ms
         self.count = count
 
@@ -273,19 +276,20 @@ class StreamReadOptions:
 
 
 class StreamGroupOptions:
+    """
+    Options for creating stream consumer groups. Can be used as an optional argument to `XGROUP CREATE`.
+
+    Attributes:
+        make_stream (bool): If set to True and the stream doesn't exist, this creates a new stream with a
+            length of 0.
+        entries_read: (Optional[int]): A value representing the number of stream entries already read by the
+            group. This option can only be specified if you are using Valkey version 7.0.0 or above.
+    """
+
     MAKE_STREAM_VALKEY_API = "MKSTREAM"
     ENTRIES_READ_VALKEY_API = "ENTRIESREAD"
 
     def __init__(self, make_stream: bool = False, entries_read: Optional[int] = None):
-        """
-        Options for creating stream consumer groups. Can be used as an optional argument to `XGROUP CREATE`.
-
-        Args:
-            make_stream (bool): If set to True and the stream doesn't exist, this creates a new stream with a
-                length of 0.
-            entries_read: (Optional[int]): A value representing the number of stream entries already read by the
-                group. This option can only be specified if you are using Valkey version 7.0.0 or above.
-        """
         self.make_stream = make_stream
         self.entries_read = entries_read
 
@@ -307,22 +311,23 @@ class StreamGroupOptions:
 
 
 class StreamReadGroupOptions(StreamReadOptions):
+    """
+    Options for reading entries from streams using a consumer group. Can be used as an optional argument to
+    `XREADGROUP`.
+
+    Attributes:
+        no_ack (bool): If set, messages are not added to the Pending Entries List (PEL). This is equivalent to
+            acknowledging the message when it is read. Equivalent to `NOACK` in the Valkey API.
+        block_ms (Optional[int]): If provided, the request will be blocked for the set amount of milliseconds or
+            until the server has the required number of entries. Equivalent to `BLOCK` in the Valkey API.
+        count (Optional[int]): The maximum number of elements requested. Equivalent to `COUNT` in the Valkey API.
+    """
+
     READ_NOACK_VALKEY_API = "NOACK"
 
     def __init__(
         self, no_ack=False, block_ms: Optional[int] = None, count: Optional[int] = None
     ):
-        """
-        Options for reading entries from streams using a consumer group. Can be used as an optional argument to
-        `XREADGROUP`.
-
-        Args:
-            no_ack (bool): If set, messages are not added to the Pending Entries List (PEL). This is equivalent to
-                acknowledging the message when it is read. Equivalent to `NOACK` in the Valkey API.
-            block_ms (Optional[int]): If provided, the request will be blocked for the set amount of milliseconds or
-                until the server has the required number of entries. Equivalent to `BLOCK` in the Valkey API.
-            count (Optional[int]): The maximum number of elements requested. Equivalent to `COUNT` in the Valkey API.
-        """
         super().__init__(block_ms=block_ms, count=count)
         self.no_ack = no_ack
 
@@ -341,6 +346,15 @@ class StreamReadGroupOptions(StreamReadOptions):
 
 
 class StreamPendingOptions:
+    """
+    Options for `XPENDING` that can be used to filter returned items by minimum idle time and consumer name.
+
+    Attributes:
+        min_idle_time_ms (Optional[int]): Filters pending entries by their minimum idle time in milliseconds. This
+            option can only be specified if you are using Valkey version 6.2.0 or above.
+        consumer_name (Optional[TEncodable]): Filters pending entries by consumer name.
+    """
+
     IDLE_TIME_VALKEY_API = "IDLE"
 
     def __init__(
@@ -348,19 +362,30 @@ class StreamPendingOptions:
         min_idle_time_ms: Optional[int] = None,
         consumer_name: Optional[TEncodable] = None,
     ):
-        """
-        Options for `XPENDING` that can be used to filter returned items by minimum idle time and consumer name.
-
-        Args:
-            min_idle_time_ms (Optional[int]): Filters pending entries by their minimum idle time in milliseconds. This
-                option can only be specified if you are using Valkey version 6.2.0 or above.
-            consumer_name (Optional[TEncodable]): Filters pending entries by consumer name.
-        """
         self.min_idle_time = min_idle_time_ms
         self.consumer_name = consumer_name
 
 
 class StreamClaimOptions:
+    """
+    Options for `XCLAIM`.
+
+    Attributes:
+        idle (Optional[int]): Set the idle time (last time it was delivered) of the message in milliseconds. If idle
+            is not specified, an idle of `0` is assumed, that is, the time count is reset because the message now has a
+            new owner trying to process it.
+        idle_unix_time (Optional[int]): This is the same as idle but instead of a relative amount of milliseconds,
+            it sets the idle time to a specific Unix time (in milliseconds). This is useful in order to rewrite the AOF
+            file generating `XCLAIM` commands.
+        retry_count (Optional[int]): Set the retry counter to the specified value. This counter is incremented every
+            time a message is delivered again. Normally `XCLAIM` does not alter this counter, which is just served to
+            clients when the `XPENDING` command is called: this way clients can detect anomalies, like messages that
+            are never processed for some reason after a big number of delivery attempts.
+        is_force (Optional[bool]): Creates the pending message entry in the PEL even if certain specified IDs are not
+            already in the PEL assigned to a different client. However, the message must exist in the stream, otherwise
+            the IDs of non-existing messages are ignored.
+    """
+
     IDLE_VALKEY_API = "IDLE"
     TIME_VALKEY_API = "TIME"
     RETRY_COUNT_VALKEY_API = "RETRYCOUNT"
@@ -374,24 +399,6 @@ class StreamClaimOptions:
         retry_count: Optional[int] = None,
         is_force: Optional[bool] = False,
     ):
-        """
-        Options for `XCLAIM`.
-
-        Args:
-            idle (Optional[int]): Set the idle time (last time it was delivered) of the message in milliseconds. If idle
-                is not specified, an idle of `0` is assumed, that is, the time count is reset because the message now has a
-                new owner trying to process it.
-            idle_unix_time (Optional[int]): This is the same as idle but instead of a relative amount of milliseconds,
-                it sets the idle time to a specific Unix time (in milliseconds). This is useful in order to rewrite the AOF
-                file generating `XCLAIM` commands.
-            retry_count (Optional[int]): Set the retry counter to the specified value. This counter is incremented every
-                time a message is delivered again. Normally `XCLAIM` does not alter this counter, which is just served to
-                clients when the `XPENDING` command is called: this way clients can detect anomalies, like messages that
-                are never processed for some reason after a big number of delivery attempts.
-            is_force (Optional[bool]): Creates the pending message entry in the PEL even if certain specified IDs are not
-                already in the PEL assigned to a different client. However, the message must exist in the stream, otherwise
-                the IDs of non-existing messages are ignored.
-        """
         self.idle = idle
         self.idle_unix_time = idle_unix_time
         self.retry_count = retry_count