valkey-glide 2.1.0rc3__cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl → 2.2.1rc3__cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl

glide/__init__.py

@@ -1,5 +1,9 @@
 # Copyright Valkey GLIDE Project Contributors - SPDX Identifier: Apache-2.0
 
+import sys
+import types
+import warnings
+
 from glide.glide import (
     ClusterScanCursor,
     OpenTelemetryConfig,
@@ -78,6 +82,7 @@ from glide_shared import (
     GlideClusterClientConfiguration,
     GlideError,
     HashFieldConditionalChange,
+    IamAuthConfig,
     IdBound,
     InfBound,
     InfoSection,
@@ -112,6 +117,7 @@ from glide_shared import (
     ScoreBoundary,
     ScoreFilter,
     ServerCredentials,
+    ServiceType,
     SignedEncoding,
     SlotIdRoute,
     SlotKeyRoute,
@@ -159,6 +165,56 @@ from .glide_client import GlideClient, GlideClusterClient, TGlideClient
 from .logger import Level as LogLevel
 from .logger import Logger
 
+_glide_module = sys.modules[__name__]
+
+_legacy_modules = [
+    "glide.exceptions",
+    "glide.config",
+    "glide.constants",
+    "glide.routes",
+    "glide.async_commands",
+    "glide.async_commands.batch",
+    "glide.async_commands.batch_options",
+    "glide.async_commands.bitmap",
+    "glide.async_commands.command_args",
+    "glide.async_commands.server_modules",
+    "glide.async_commands.server_modules.ft_options",
+    "glide.async_commands.server_modules.ft_options.ft_aggregate_options",
+    "glide.async_commands.server_modules.ft_options.ft_create_options",
+    "glide.async_commands.server_modules.ft_options.ft_profile_options",
+    "glide.async_commands.server_modules.ft_options.ft_search_options",
+    "glide.async_commands.server_modules.glide_json",
+    "glide.async_commands.sorted_set",
+    "glide.async_commands.stream",
+]
+
+
+class _LegacyModule(types.ModuleType):
+    """Proxy for a deprecated module that warns when first accessed."""
+
+    def __init__(self, name):
+        super().__init__(name)
+        self._warned = False
+
+    def __getattr__(self, name):
+        if not self._warned:
+            warnings.warn(
+                f"Importing from '{self.__name__}' is deprecated. "
+                f"Please import directly from 'glide' instead.",
+                DeprecationWarning,
+                stacklevel=2,
+            )
+            self._warned = True
+
+        # Access the attribute from the real top-level glide module
+        return getattr(_glide_module, name)
+
+
+# Replace old modules with lazy proxy modules
+for old_name in _legacy_modules:
+    if old_name not in sys.modules:
+        sys.modules[old_name] = _LegacyModule(old_name)
+
 __all__ = [
     # Client
     "TGlideClient",
@@ -181,6 +237,8 @@ __all__ = [
     "BackoffStrategy",
     "ReadFrom",
     "ServerCredentials",
+    "ServiceType",
+    "IamAuthConfig",
     "NodeAddress",
     "OpenTelemetryConfig",
     "OpenTelemetryMetricsConfig",

glide/async_commands/cluster_commands.py

@@ -1066,11 +1066,17 @@ class ClusterCommands(CoreCommands):
         self,
         source: TEncodable,
         destination: TEncodable,
+        # TODO next major release the arguments replace and destinationDB must have their order
+        # swapped to align with the standalone order.
+        # At the moment of the patch release 2.1.1. we can't have a breaking change
         replace: Optional[bool] = None,
+        destinationDB: Optional[int] = None,
     ) -> bool:
         """
-        Copies the value stored at the `source` to the `destination` key. When `replace` is True,
-        removes the `destination` key first if it already exists, otherwise performs no action.
+        Copies the value stored at the `source` to the `destination` key. If `destinationDB`
+        is specified, the value will be copied to the database specified by `destinationDB`,
+        otherwise the current database will be used. When `replace` is True, removes the
+        `destination` key first if it already exists, otherwise performs no action.
 
         See [valkey.io](https://valkey.io/commands/copy) for more details.
 
@@ -1081,6 +1087,7 @@ class ClusterCommands(CoreCommands):
             source (TEncodable): The key to the source value.
             destination (TEncodable): The key where the value should be copied to.
             replace (Optional[bool]): If the destination key should be removed before copying the value to it.
+            destinationDB (Optional[int]): The alternative logical database index for the destination key.
 
         Returns:
             bool: True if the source was copied. Otherwise, returns False.
@@ -1089,12 +1096,20 @@ class ClusterCommands(CoreCommands):
             >>> await client.set("source", "sheep")
             >>> await client.copy(b"source", b"destination")
                 True # Source was copied
+            >>> await client.copy(b"source", b"destination", destinationDB=1)
+                True # Source was copied to DB 1
+            >>> await client.select(1)
             >>> await client.get("destination")
                 b"sheep"
 
         Since: Valkey version 6.2.0.
+               The destinationDB argument is available since Valkey 9.0.0
         """
+
+        # Build command arguments
         args: List[TEncodable] = [source, destination]
+        if destinationDB is not None:
+            args.extend(["DB", str(destinationDB)])
         if replace is True:
             args.append("REPLACE")
         return cast(
@@ -1141,7 +1156,7 @@ class ClusterCommands(CoreCommands):
             args.extend(["VERSION", str(version)])
         if parameters:
             for var in parameters:
-                args.extend(str(var))
+                args.append(str(var))
         return cast(
             TClusterResponse[bytes],
             await self._execute_command(RequestType.Lolwut, args, route),

glide/async_commands/core.py

@@ -139,6 +139,27 @@ class CoreCommands(Protocol):
             TOK, await self._update_connection_password(password, immediate_auth)
         )
 
+    async def _refresh_iam_token(self) -> TResult: ...
+
+    async def refresh_iam_token(self) -> TOK:
+        """
+        Manually refresh the IAM token for the current connection.
+
+        This method is only available if the client was created with IAM authentication.
+        It triggers an immediate refresh of the IAM token and updates the connection.
+
+        Returns:
+            TOK: A simple OK response on success.
+
+        Raises:
+            ConfigurationError: If the client is not using IAM authentication.
+
+        Example:
+            >>> await client.refresh_iam_token()
+            'OK'
+        """
+        return cast(TOK, await self._refresh_iam_token())
+
     async def set(
         self,
         key: TEncodable,
@@ -430,6 +451,34 @@ class CoreCommands(Protocol):
         """
         return cast(int, await self._execute_command(RequestType.Del, keys))
 
+    async def move(self, key: TEncodable, db_index: int) -> bool:
+        """
+        Move key from the currently selected database to the specified destination database.
+
+        Note:
+            For cluster mode move command is supported since Valkey 9.0.0
+
+        See [valkey.io](https://valkey.io/commands/move/) for more details.
+
+        Args:
+            key (TEncodable): The key to move.
+            db_index (int): The destination database number.
+
+        Returns:
+            bool: True if the key was moved successfully, False if the key does not exist
+            or was already present in the destination database.
+
+        Examples:
+            >>> await client.move("some_key", 1)
+                True  # The key was successfully moved to database 1
+            >>> await client.move("nonexistent_key", 1)
+                False  # The key does not exist
+        """
+        return cast(
+            bool,
+            await self._execute_command(RequestType.Move, [key, str(db_index)]),
+        )
+
     async def incr(self, key: TEncodable) -> int:
         """
         Increments the number stored at `key` by one. If the key does not exist, it is set to 0 before performing the
@@ -1120,7 +1169,7 @@ class CoreCommands(Protocol):
             - `-2`: field does not exist or key does not exist
 
         Examples:
-            >>> await client.hsetex("my_hash", {"field1": "value1", "field2": "value2"}, expiry=ExpirySet(ExpiryType.EX, 10))
+            >>> await client.hsetex("my_hash", {"field1": "value1", "field2": "value2"}, expiry=ExpirySet(ExpiryType.SEC, 10))
             >>> await client.httl("my_hash", ["field1", "field2", "non_existent_field"])
                 [9, 9, -2]  # field1 and field2 have ~9 seconds left, non_existent_field doesn't exist
 
@@ -1150,7 +1199,7 @@ class CoreCommands(Protocol):
             - `-2`: field does not exist or key does not exist
 
         Examples:
-            >>> await client.hsetex("my_hash", {"field1": "value1", "field2": "value2"}, expiry=ExpirySet(ExpiryType.PX, 10000))
+            >>> await client.hsetex("my_hash", {"field1": "value1", "field2": "value2"}, expiry=ExpirySet(ExpiryType.MILLSEC, 10000))
             >>> await client.hpttl("my_hash", ["field1", "field2", "non_existent_field"])
                 [9500, 9500, -2]  # field1 and field2 have ~9500 milliseconds left, non_existent_field doesn't exist
 
@@ -1182,7 +1231,7 @@ class CoreCommands(Protocol):
         Examples:
             >>> import time
             >>> future_timestamp = int(time.time()) + 60  # 60 seconds from now
-            >>> await client.hsetex("my_hash", {"field1": "value1", "field2": "value2"}, expiry=ExpirySet(ExpiryType.EXAT, future_timestamp))
+            >>> await client.hsetex("my_hash", {"field1": "value1", "field2": "value2"}, expiry=ExpirySet(ExpiryType.UNIX_SEC, future_timestamp))
             >>> await client.hexpiretime("my_hash", ["field1", "field2", "non_existent_field"])
                 [future_timestamp, future_timestamp, -2]  # field1 and field2 expire at future_timestamp, non_existent_field doesn't exist
 
@@ -1216,7 +1265,7 @@ class CoreCommands(Protocol):
         Examples:
             >>> import time
             >>> future_timestamp_ms = int(time.time() * 1000) + 60000  # 60 seconds from now in milliseconds
-            >>> await client.hsetex("my_hash", {"field1": "value1", "field2": "value2"}, expiry=ExpirySet(ExpiryType.PXAT, future_timestamp_ms))
+            >>> await client.hsetex("my_hash", {"field1": "value1", "field2": "value2"}, expiry=ExpirySet(ExpiryType.UNIX_MILLSEC, future_timestamp_ms))
             >>> await client.hpexpiretime("my_hash", ["field1", "field2", "non_existent_field"])
                 [future_timestamp_ms, future_timestamp_ms, -2]  # field1 and field2 expire at future_timestamp_ms, non_existent_field doesn't exist
 
@@ -1249,17 +1298,17 @@ class CoreCommands(Protocol):
                 - ONLY_IF_ALL_EXIST (FXX): Only set fields if all of them already exist.
                 - ONLY_IF_NONE_EXIST (FNX): Only set fields if none of them already exist.
             expiry (Optional[ExpirySet]): Expiration options for the fields:
-                - EX: Expiration time in seconds.
-                - PX: Expiration time in milliseconds.
-                - EXAT: Absolute expiration time in seconds (Unix timestamp).
-                - PXAT: Absolute expiration time in milliseconds (Unix timestamp).
-                - KEEPTTL: Retain existing TTL.
+                - SEC (EX): Expiration time in seconds.
+                - MILLSEC (PX): Expiration time in milliseconds.
+                - UNIX_SEC (EXAT): Absolute expiration time in seconds (Unix timestamp).
+                - UNIX_MILLSEC (PXAT): Absolute expiration time in milliseconds (Unix timestamp).
+                - KEEP_TTL (KEEPTTL): Retain existing TTL.
 
         Returns:
             int: 1 if all fields were set successfully, 0 if none were set due to conditional constraints.
 
         Examples:
-            >>> await client.hsetex("my_hash", {"field1": "value1", "field2": "value2"}, expiry=ExpirySet(ExpiryType.EX, 10))
+            >>> await client.hsetex("my_hash", {"field1": "value1", "field2": "value2"}, expiry=ExpirySet(ExpiryType.SEC, 10))
                 1  # All fields set with 10 second expiration
             >>> await client.hsetex("my_hash", {"field3": "value3"}, field_conditional_change=HashFieldConditionalChange.ONLY_IF_ALL_EXIST)
                 1  # Field set because field already exists
@@ -1305,10 +1354,10 @@ class CoreCommands(Protocol):
             key (TEncodable): The key of the hash.
             fields (List[TEncodable]): The list of fields to retrieve from the hash.
             expiry (Optional[ExpiryGetEx]): Expiration options for the retrieved fields:
-                - EX: Expiration time in seconds.
-                - PX: Expiration time in milliseconds.
-                - EXAT: Absolute expiration time in seconds (Unix timestamp).
-                - PXAT: Absolute expiration time in milliseconds (Unix timestamp).
+                - SEC (EX): Expiration time in seconds.
+                - MILLSEC (PX): Expiration time in milliseconds.
+                - UNIX_SEC (EXAT): Absolute expiration time in seconds (Unix timestamp).
+                - UNIX_MILLSEC (PXAT): Absolute expiration time in milliseconds (Unix timestamp).
                 - PERSIST: Remove expiration from the fields.
 
         Returns:
@@ -1317,10 +1366,10 @@ class CoreCommands(Protocol):
             If `key` does not exist, it is treated as an empty hash, and the function returns a list of null values.
 
         Examples:
-            >>> await client.hsetex("my_hash", {"field1": "value1", "field2": "value2"}, expiry=ExpirySet(ExpiryType.EX, 10))
+            >>> await client.hsetex("my_hash", {"field1": "value1", "field2": "value2"}, expiry=ExpirySet(ExpiryType.SEC, 10))
             >>> await client.hgetex("my_hash", ["field1", "field2"])
                 [b"value1", b"value2"]
-            >>> await client.hgetex("my_hash", ["field1"], expiry=ExpiryGetEx(ExpiryTypeGetEx.EX, 20))
+            >>> await client.hgetex("my_hash", ["field1"], expiry=ExpiryGetEx(ExpiryTypeGetEx.SEC, 20))
                 [b"value1"]  # field1 now has 20 second expiration
             >>> await client.hgetex("my_hash", ["field1"], expiry=ExpiryGetEx(ExpiryTypeGetEx.PERSIST, None))
                 [b"value1"]  # field1 expiration removed
@@ -1374,7 +1423,7 @@ class CoreCommands(Protocol):
             - `2`: Field was deleted immediately (when seconds is 0 or timestamp is in the past).
 
         Examples:
-            >>> await client.hsetex("my_hash", {"field1": "value1", "field2": "value2"}, expiry=ExpirySet(ExpiryType.EX, 10))
+            >>> await client.hsetex("my_hash", {"field1": "value1", "field2": "value2"}, expiry=ExpirySet(ExpiryType.SEC, 10))
             >>> await client.hexpire("my_hash", 20, ["field1", "field2"])
                 [1, 1]  # Both fields' expiration set to 20 seconds
             >>> await client.hexpire("my_hash", 30, ["field1"], option=ExpireOptions.NewExpiryGreaterThanCurrent)
@@ -1420,7 +1469,7 @@ class CoreCommands(Protocol):
             - `-2`: Field does not exist or key does not exist.
 
         Examples:
-            >>> await client.hsetex("my_hash", {"field1": "value1", "field2": "value2"}, expiry=ExpirySet(ExpiryType.EX, 10))
+            >>> await client.hsetex("my_hash", {"field1": "value1", "field2": "value2"}, expiry=ExpirySet(ExpiryType.SEC, 10))
             >>> await client.hpersist("my_hash", ["field1", "field2"])
                 [1, 1]  # Both fields made persistent
             >>> await client.hpersist("my_hash", ["field1"])
@@ -1467,7 +1516,7 @@ class CoreCommands(Protocol):
             - `2`: Field was deleted immediately (when milliseconds is 0 or timestamp is in the past).
 
         Examples:
-            >>> await client.hsetex("my_hash", {"field1": "value1", "field2": "value2"}, expiry=ExpirySet(ExpiryType.PX, 10000))
+            >>> await client.hsetex("my_hash", {"field1": "value1", "field2": "value2"}, expiry=ExpirySet(ExpiryType.MILLSEC, 10000))
             >>> await client.hpexpire("my_hash", 20000, ["field1", "field2"])
                 [1, 1]  # Both fields' expiration set to 20000 milliseconds
             >>> await client.hpexpire("my_hash", 30000, ["field1"], option=ExpireOptions.NewExpiryGreaterThanCurrent)
@@ -1528,7 +1577,7 @@ class CoreCommands(Protocol):
         Examples:
             >>> import time
             >>> future_timestamp = int(time.time()) + 60  # 60 seconds from now
-            >>> await client.hsetex("my_hash", {"field1": "value1", "field2": "value2"}, expiry=ExpirySet(ExpiryType.EX, 10))
+            >>> await client.hsetex("my_hash", {"field1": "value1", "field2": "value2"}, expiry=ExpirySet(ExpiryType.SEC, 10))
             >>> await client.hexpireat("my_hash", future_timestamp, ["field1", "field2"])
                 [1, 1]  # Both fields' expiration set to future_timestamp
             >>> past_timestamp = int(time.time()) - 60  # 60 seconds ago
@@ -1588,7 +1637,7 @@ class CoreCommands(Protocol):
         Examples:
             >>> import time
             >>> future_timestamp_ms = int(time.time() * 1000) + 60000  # 60 seconds from now in milliseconds
-            >>> await client.hsetex("my_hash", {"field1": "value1", "field2": "value2"}, expiry=ExpirySet(ExpiryType.PX, 10000))
+            >>> await client.hsetex("my_hash", {"field1": "value1", "field2": "value2"}, expiry=ExpirySet(ExpiryType.MILLSEC, 10000))
             >>> await client.hpexpireat("my_hash", future_timestamp_ms, ["field1", "field2"])
                 [1, 1]  # Both fields' expiration set to future_timestamp_ms
             >>> past_timestamp_ms = int(time.time() * 1000) - 60000  # 60 seconds ago in milliseconds
@@ -2242,6 +2291,20 @@ class CoreCommands(Protocol):
         """
         return cast(int, await self._execute_command(RequestType.SAdd, [key] + members))
 
+    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 srem(self, key: TEncodable, members: List[TEncodable]) -> int:
         """
         Remove specified members from the set stored at `key`.

glide/async_commands/standalone_commands.py

@@ -162,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.
@@ -629,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.
@@ -806,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),

glide/glide_client.py

@@ -48,6 +48,7 @@ from glide_shared.exceptions import (
 from glide_shared.protobuf.command_request_pb2 import (
     Command,
     CommandRequest,
+    RefreshIamToken,
     RequestType,
 )
 from glide_shared.protobuf.connection_request_pb2 import ConnectionRequest
@@ -338,7 +339,7 @@ class BaseClient(CoreCommands):
                     request.callback_idx if isinstance(request, CommandRequest) else 0
                 )
                 res_future = self._available_futures.pop(callback_idx, None)
-                if res_future:
+                if res_future and not res_future.done():
                     res_future.set_exception(e)
                 else:
                     ClientLogger.log(
@@ -355,7 +356,10 @@ class BaseClient(CoreCommands):
         b_arr = bytearray()
         for request in requests:
             ProtobufCodec.encode_delimited(b_arr, request)
-        await self._stream.send(b_arr)
+        try:
+            await self._stream.send(b_arr)
+        except (anyio.ClosedResourceError, anyio.EndOfStream):
+            raise ClosingError("The communication layer was unexpectedly closed.")
 
     def _encode_arg(self, arg: TEncodable) -> bytes:
         """
@@ -754,6 +758,15 @@ class BaseClient(CoreCommands):
                 self.config.credentials.password = password or ""
         return response
 
+    async def _refresh_iam_token(self) -> TResult:
+        request = CommandRequest()
+        request.callback_idx = self._get_callback_index()
+        request.refresh_iam_token.CopyFrom(
+            RefreshIamToken()
+        )  # Empty message, just triggers the refresh
+        response = await self._write_request_await_response(request)
+        return response
+
 
 class GlideClusterClient(BaseClient, ClusterCommands):
     """

glide_shared/__init__.py

@@ -119,12 +119,14 @@ from .config import (
     BackoffStrategy,
     GlideClientConfiguration,
     GlideClusterClientConfiguration,
+    IamAuthConfig,
     NodeAddress,
     PeriodicChecksManualInterval,
     PeriodicChecksStatus,
     ProtocolVersion,
     ReadFrom,
     ServerCredentials,
+    ServiceType,
     TlsAdvancedConfiguration,
 )
 from .constants import (
@@ -186,6 +188,8 @@ __all__ = [
     "BackoffStrategy",
     "ReadFrom",
     "ServerCredentials",
+    "ServiceType",
+    "IamAuthConfig",
     "NodeAddress",
     "ProtocolVersion",
     "PeriodicChecksManualInterval",

glide_shared/commands/batch.py

@@ -403,6 +403,27 @@ class BaseBatch:
         """
         return self.append_command(RequestType.ConfigResetStat, [])
 
+    def move(self: TBatch, key: TEncodable, db_index: int) -> "TBatch":
+        """
+        Move `key` from the currently selected database to the database specified by `db_index`.
+
+        Note:
+            For cluster mode move command is supported since Valkey 9.0.0
+
+        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.
+
+        Commands response:
+            bool: True if `key` was moved.
+
+            False if the `key` already exists in the destination database
+            or does not exist in the source database.
+        """
+        return self.append_command(RequestType.Move, [key, str(db_index)])
+
     def mset(self: TBatch, key_value_map: Mapping[TEncodable, TEncodable]) -> TBatch:
         """
         Set multiple keys to multiple values in a single atomic operation.
@@ -5070,7 +5091,7 @@ class BaseBatch:
             args.extend(["VERSION", str(version)])
         if parameters:
             for var in parameters:
-                args.extend(str(var))
+                args.append(str(var))
         return self.append_command(RequestType.Lolwut, args)
 
     def random_key(self: TBatch) -> TBatch:
@@ -5754,25 +5775,6 @@ class Batch(BaseBatch):
 
     """
 
-    # TODO: add SLAVEOF and all SENTINEL commands
-    def move(self, key: TEncodable, db_index: int) -> "Batch":
-        """
-        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.
-
-        Commands response:
-            bool: True if `key` was moved.
-
-            False if the `key` already exists in the destination database
-            or does not exist in the source database.
-        """
-        return self.append_command(RequestType.Move, [key, str(db_index)])
-
     def select(self, index: int) -> "Batch":
         """
         Change the currently selected database.
@@ -5883,7 +5885,11 @@ class ClusterBatch(BaseBatch):
         self,
         source: TEncodable,
         destination: TEncodable,
+        # TODO next major release the arguments replace and destinationDB must have their order
+        # swapped to align with the standalone order.
+        # At the moment of the patch release 2.1.1. we can't have a breaking change
         replace: Optional[bool] = None,
+        destinationDB: Optional[int] = None,
     ) -> "ClusterBatch":
         """
         Copies the value stored at the `source` to the `destination` key. When `replace` is True,
@@ -5895,15 +5901,17 @@ class ClusterBatch(BaseBatch):
             source (TEncodable): The key to the source value.
             destination (TEncodable): The key where the value should be copied to.
             replace (Optional[bool]): If the destination key should be removed before copying the value to it.
-
+            destinationDB (Optional[int]): The alternative logical database index for the destination key.
         Command response:
             bool: True if the source was copied.
 
             Otherwise, return False.
 
-        Since: Valkey version 6.2.0.
+        Since: Valkey version 9.0.0.
         """
         args = [source, destination]
+        if destinationDB is not None:
+            args.extend(["DB", str(destinationDB)])
         if replace is not None:
             args.append("REPLACE")