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

glide_shared/commands/core_options.py

@@ -0,0 +1,407 @@
+# Copyright Valkey GLIDE Project Contributors - SPDX Identifier: Apache-2.0
+from dataclasses import dataclass
+from datetime import datetime, timedelta
+from enum import Enum
+from typing import List, Optional, Type, Union, get_args
+
+from glide_shared.commands.command_args import Limit, OrderBy
+from glide_shared.constants import TEncodable
+
+
+@dataclass
+class PubSubMsg:
+    """
+    Describes the incoming pubsub message
+
+    Attributes:
+        message (TEncodable): Incoming message.
+        channel (TEncodable): Name of an channel that triggered the message.
+        pattern (Optional[TEncodable]): Pattern that triggered the message.
+    """
+
+    message: TEncodable
+    channel: TEncodable
+    pattern: Optional[TEncodable]
+
+
+class ConditionalChange(Enum):
+    """
+    A condition to the `SET`, `ZADD` and `GEOADD` commands.
+    """
+
+    ONLY_IF_EXISTS = "XX"
+    """ Only update key / elements that already exist. Equivalent to `XX` in the Valkey API. """
+
+    ONLY_IF_DOES_NOT_EXIST = "NX"
+    """ Only set key / add elements that does not already exist. Equivalent to `NX` in the Valkey API. """
+
+
+class HashFieldConditionalChange(Enum):
+    """
+    Field conditional change options for HSETEX command.
+    """
+
+    ONLY_IF_ALL_EXIST = "FXX"
+    """ Only set fields if all of them already exist. Equivalent to `FXX` in the Valkey API. """
+
+    ONLY_IF_NONE_EXIST = "FNX"
+    """ Only set fields if none of them already exist. Equivalent to `FNX` in the Valkey API. """
+
+
+@dataclass
+class OnlyIfEqual:
+    """
+    Change condition to the `SET` command,
+    For additional conditonal options see ConditionalChange
+
+    - comparison_value - value to compare to the current value of a key.
+
+    If comparison_value is equal to the key, it will overwrite the value of key to the new provided value
+    Equivalent to the IFEQ comparison-value in the Valkey API
+    """
+
+    comparison_value: TEncodable
+
+
+class ExpiryType(Enum):
+    """
+    SET option: The type of the expiry.
+    """
+
+    SEC = 0, Union[int, timedelta]
+    """
+    Set the specified expire time, in seconds. Equivalent to `EX` in the Valkey API.
+    """
+
+    MILLSEC = 1, Union[int, timedelta]
+    """
+    Set the specified expire time, in milliseconds. Equivalent to `PX` in the Valkey API.
+    """
+
+    UNIX_SEC = 2, Union[int, datetime]
+    """
+    Set the specified Unix time at which the key will expire, in seconds. Equivalent to `EXAT` in the Valkey API.
+    """
+
+    UNIX_MILLSEC = 3, Union[int, datetime]
+    """
+    Set the specified Unix time at which the key will expire, in milliseconds. Equivalent to `PXAT` in the Valkey API.
+    """
+
+    KEEP_TTL = 4, Type[None]
+    """
+    Retain the time to live associated with the key. Equivalent to `KEEPTTL` in the Valkey API.
+    """
+
+
+class ExpiryTypeGetEx(Enum):
+    """
+    GetEx option: The type of the expiry.
+    """
+
+    SEC = 0, Union[int, timedelta]
+    """ Set the specified expire time, in seconds. Equivalent to `EX` in the Valkey API. """
+
+    MILLSEC = 1, Union[int, timedelta]
+    """ Set the specified expire time, in milliseconds. Equivalent to `PX` in the Valkey API. """
+
+    UNIX_SEC = 2, Union[int, datetime]
+    """ Set the specified Unix time at which the key will expire, in seconds. Equivalent to `EXAT` in the Valkey API. """
+
+    UNIX_MILLSEC = 3, Union[int, datetime]
+    """ Set the specified Unix time at which the key will expire, in milliseconds. Equivalent to `PXAT` in the Valkey API. """
+
+    PERSIST = 4, Type[None]
+    """ Remove the time to live associated with the key. Equivalent to `PERSIST` in the Valkey API. """
+
+
+class InfoSection(Enum):
+    """
+    INFO option: a specific section of information:
+
+    When no parameter is provided, the default option is assumed.
+    """
+
+    SERVER = "server"
+    """ General information about the server """
+
+    CLIENTS = "clients"
+    """ Client connections section """
+
+    MEMORY = "memory"
+    """ Memory consumption related information """
+
+    PERSISTENCE = "persistence"
+    """ RDB and AOF related information """
+
+    STATS = "stats"
+    """ General statistics """
+
+    REPLICATION = "replication"
+    """ Master/replica replication information """
+
+    CPU = "cpu"
+    """ CPU consumption statistics """
+
+    COMMAND_STATS = "commandstats"
+    """ Valkey command statistics """
+
+    LATENCY_STATS = "latencystats"
+    """ Valkey command latency percentile distribution statistics """
+
+    SENTINEL = "sentinel"
+    """ Valkey Sentinel section (only applicable to Sentinel instances) """
+
+    CLUSTER = "cluster"
+    """ Valkey Cluster section """
+
+    MODULES = "modules"
+    """ Modules section """
+
+    KEYSPACE = "keyspace"
+    """ Database related statistics """
+
+    ERROR_STATS = "errorstats"
+    """ Valkey error statistics """
+
+    ALL = "all"
+    """ Return all sections (excluding module generated ones) """
+
+    DEFAULT = "default"
+    """ Return only the default set of sections """
+
+    EVERYTHING = "everything"
+    """ Includes all and modules """
+
+
+class ExpireOptions(Enum):
+    """
+    EXPIRE option: options for setting key expiry.
+    """
+
+    HasNoExpiry = "NX"
+    """ Set expiry only when the key has no expiry (Equivalent to "NX" in Valkey). """
+
+    HasExistingExpiry = "XX"
+    """ Set expiry only when the key has an existing expiry (Equivalent to "XX" in Valkey). """
+
+    NewExpiryGreaterThanCurrent = "GT"
+    """
+    Set expiry only when the new expiry is greater than the current one (Equivalent to "GT" in Valkey).
+    """
+
+    NewExpiryLessThanCurrent = "LT"
+    """
+    Set expiry only when the new expiry is less than the current one (Equivalent to "LT" in Valkey).
+    """
+
+
+class UpdateOptions(Enum):
+    """
+    Options for updating elements of a sorted set key.
+    """
+
+    LESS_THAN = "LT"
+    """ Only update existing elements if the new score is less than the current score. """
+
+    GREATER_THAN = "GT"
+    """ Only update existing elements if the new score is greater than the current score. """
+
+
+class ExpirySet:
+    """
+    SET option: Represents the expiry type and value to be executed with "SET" command.
+
+    Attributes:
+        cmd_arg (str): The expiry type.
+        value (str): The value for the expiry type.
+    """
+
+    def __init__(
+        self,
+        expiry_type: ExpiryType,
+        value: Optional[Union[int, datetime, timedelta]],
+    ) -> None:
+        self.set_expiry_type_and_value(expiry_type, value)
+
+    def __eq__(self, other: "object") -> bool:
+        if not isinstance(other, ExpirySet):
+            return NotImplemented
+        return self.expiry_type == other.expiry_type and self.value == other.value
+
+    def set_expiry_type_and_value(
+        self, expiry_type: ExpiryType, value: Optional[Union[int, datetime, timedelta]]
+    ):
+        """
+        Args:
+            expiry_type (ExpiryType): The expiry type.
+            value (Optional[Union[int, datetime, timedelta]]): The value of the expiration type. The type of expiration
+                determines the type of expiration value:
+
+                    - SEC: Union[int, timedelta]
+                    - MILLSEC: Union[int, timedelta]
+                    - UNIX_SEC: Union[int, datetime]
+                    - UNIX_MILLSEC: Union[int, datetime]
+                    - KEEP_TTL: Type[None]
+        """
+        if not isinstance(value, get_args(expiry_type.value[1])):
+            raise ValueError(
+                f"The value of {expiry_type} should be of type {expiry_type.value[1]}"
+            )
+        self.expiry_type = expiry_type
+        if self.expiry_type == ExpiryType.SEC:
+            self.cmd_arg = "EX"
+            if isinstance(value, timedelta):
+                value = int(value.total_seconds())
+        elif self.expiry_type == ExpiryType.MILLSEC:
+            self.cmd_arg = "PX"
+            if isinstance(value, timedelta):
+                value = int(value.total_seconds() * 1000)
+        elif self.expiry_type == ExpiryType.UNIX_SEC:
+            self.cmd_arg = "EXAT"
+            if isinstance(value, datetime):
+                value = int(value.timestamp())
+        elif self.expiry_type == ExpiryType.UNIX_MILLSEC:
+            self.cmd_arg = "PXAT"
+            if isinstance(value, datetime):
+                value = int(value.timestamp() * 1000)
+        elif self.expiry_type == ExpiryType.KEEP_TTL:
+            self.cmd_arg = "KEEPTTL"
+        self.value = str(value) if value else None
+
+    def get_cmd_args(self) -> List[str]:
+        return [self.cmd_arg] if self.value is None else [self.cmd_arg, self.value]
+
+
+class ExpiryGetEx:
+    """
+    GetEx option: Represents the expiry type and value to be executed with "GetEx" command.
+
+    Attributes:
+        cmd_arg (str): The expiry type.
+        value (str): The value for the expiry type.
+    """
+
+    def __init__(
+        self,
+        expiry_type: ExpiryTypeGetEx,
+        value: Optional[Union[int, datetime, timedelta]],
+    ) -> None:
+        self.set_expiry_type_and_value(expiry_type, value)
+
+    def set_expiry_type_and_value(
+        self,
+        expiry_type: ExpiryTypeGetEx,
+        value: Optional[Union[int, datetime, timedelta]],
+    ):
+        """
+        Args:
+            expiry_type (ExpiryType): The expiry type.
+            value (Optional[Union[int, datetime, timedelta]]): The value of the expiration type. The type of expiration
+                determines the type of expiration value:
+
+                    - SEC: Union[int, timedelta]
+                    - MILLSEC: Union[int, timedelta]
+                    - UNIX_SEC: Union[int, datetime]
+                    - UNIX_MILLSEC: Union[int, datetime]
+                    - PERSIST: Type[None]
+        """
+        if not isinstance(value, get_args(expiry_type.value[1])):
+            raise ValueError(
+                f"The value of {expiry_type} should be of type {expiry_type.value[1]}"
+            )
+        self.expiry_type = expiry_type
+        if self.expiry_type == ExpiryTypeGetEx.SEC:
+            self.cmd_arg = "EX"
+            if isinstance(value, timedelta):
+                value = int(value.total_seconds())
+        elif self.expiry_type == ExpiryTypeGetEx.MILLSEC:
+            self.cmd_arg = "PX"
+            if isinstance(value, timedelta):
+                value = int(value.total_seconds() * 1000)
+        elif self.expiry_type == ExpiryTypeGetEx.UNIX_SEC:
+            self.cmd_arg = "EXAT"
+            if isinstance(value, datetime):
+                value = int(value.timestamp())
+        elif self.expiry_type == ExpiryTypeGetEx.UNIX_MILLSEC:
+            self.cmd_arg = "PXAT"
+            if isinstance(value, datetime):
+                value = int(value.timestamp() * 1000)
+        elif self.expiry_type == ExpiryTypeGetEx.PERSIST:
+            self.cmd_arg = "PERSIST"
+        self.value = str(value) if value else None
+
+    def get_cmd_args(self) -> List[str]:
+        return [self.cmd_arg] if self.value is None else [self.cmd_arg, self.value]
+
+
+class InsertPosition(Enum):
+    BEFORE = "BEFORE"
+    AFTER = "AFTER"
+
+
+class FlushMode(Enum):
+    """
+    Defines flushing mode for:
+
+    `FLUSHALL` command and `FUNCTION FLUSH` command.
+
+    See [FLUSHAL](https://valkey.io/commands/flushall/) and [FUNCTION-FLUSH](https://valkey.io/commands/function-flush/)
+    for details
+
+    SYNC was introduced in version 6.2.0.
+    """
+
+    ASYNC = "ASYNC"
+    SYNC = "SYNC"
+
+
+class FunctionRestorePolicy(Enum):
+    """
+    Options for the FUNCTION RESTORE command.
+    """
+
+    APPEND = "APPEND"
+    """ Appends the restored libraries to the existing libraries and aborts on collision. This is the default policy. """
+
+    FLUSH = "FLUSH"
+    """ Deletes all existing libraries before restoring the payload. """
+
+    REPLACE = "REPLACE"
+    """
+    Appends the restored libraries to the existing libraries, replacing any existing ones in case
+    of name collisions. Note that this policy doesn't prevent function name collisions, only libraries.
+    """
+
+
+def _build_sort_args(
+    key: TEncodable,
+    by_pattern: Optional[TEncodable] = None,
+    limit: Optional[Limit] = None,
+    get_patterns: Optional[List[TEncodable]] = None,
+    order: Optional[OrderBy] = None,
+    alpha: Optional[bool] = None,
+    store: Optional[TEncodable] = None,
+) -> List[TEncodable]:
+    args = [key]
+
+    if by_pattern:
+        args.extend(["BY", by_pattern])
+
+    if limit:
+        args.extend(["LIMIT", str(limit.offset), str(limit.count)])
+
+    if get_patterns:
+        for pattern in get_patterns:
+            args.extend(["GET", pattern])
+
+    if order:
+        args.append(order.value)
+
+    if alpha:
+        args.append("ALPHA")
+
+    if store:
+        args.extend(["STORE", store])
+
+    return args

{glide/async_commands → glide_shared/commands}/server_modules/ft_options/ft_aggregate_options.py

@@ -2,11 +2,11 @@
 from abc import ABC, abstractmethod
 from typing import List, Mapping, Optional
 
-from glide.async_commands.command_args import OrderBy
-from glide.async_commands.server_modules.ft_options.ft_constants import (
+from glide_shared.commands.command_args import OrderBy
+from glide_shared.commands.server_modules.ft_options.ft_constants import (
     FtAggregateKeywords,
 )
-from glide.constants import TEncodable
+from glide_shared.constants import TEncodable
 
 
 class FtAggregateClause(ABC):

{glide/async_commands → glide_shared/commands}/server_modules/ft_options/ft_create_options.py

@@ -3,8 +3,10 @@ from abc import ABC, abstractmethod
 from enum import Enum
 from typing import List, Optional
 
-from glide.async_commands.server_modules.ft_options.ft_constants import FtCreateKeywords
-from glide.constants import TEncodable
+from glide_shared.commands.server_modules.ft_options.ft_constants import (
+    FtCreateKeywords,
+)
+from glide_shared.constants import TEncodable
 
 
 class FieldType(Enum):

{glide/async_commands → glide_shared/commands}/server_modules/ft_options/ft_profile_options.py

@@ -2,16 +2,16 @@
 from enum import Enum
 from typing import List, Optional, Union, 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 (
     FtProfileKeywords,
 )
-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 TEncodable
+from glide_shared.constants import TEncodable
 
 
 class QueryType(Enum):

{glide/async_commands → glide_shared/commands}/server_modules/ft_options/ft_search_options.py

@@ -2,8 +2,10 @@
 
 from typing import List, Mapping, Optional
 
-from glide.async_commands.server_modules.ft_options.ft_constants import FtSearchKeywords
-from glide.constants import TEncodable
+from glide_shared.commands.server_modules.ft_options.ft_constants import (
+    FtSearchKeywords,
+)
+from glide_shared.constants import TEncodable
 
 
 class FtSearchLimit:

{glide/async_commands → glide_shared/commands}/server_modules/json_batch.py

@@ -22,14 +22,14 @@ Examples:
 
 from typing import List, Optional, Union
 
-from glide.async_commands.batch import TBatch
-from glide.async_commands.core import ConditionalChange
-from glide.async_commands.server_modules.glide_json import (
+from glide_shared.commands.batch import TBatch
+from glide_shared.commands.core_options import ConditionalChange
+from glide_shared.commands.server_modules.json_options import (
     JsonArrIndexOptions,
     JsonArrPopOptions,
     JsonGetOptions,
 )
-from glide.constants import TEncodable
+from glide_shared.constants import TEncodable
 
 
 def set(

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):

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

@@ -4,7 +4,7 @@ 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):