glide_sync.sync_commands.standalone_commands

StandaloneCommands

Bases: CoreCommands

Source code in doc-gen/valkey-glide/python/glide-sync/glide_sync/sync_commands/standalone_commands.py

class StandaloneCommands(CoreCommands):

    def custom_command(self, command_args: List[TEncodable]) -> TResult:
        """
        Executes a single command, without checking inputs.
        See the [Valkey GLIDE Documentation](https://glide.valkey.io/concepts/client-features/custom-commands/)
        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.

        Returns:
            TResult: The returning value depends on the executed command.

        Example:
            >>> connection.customCommand(["CLIENT", "LIST","TYPE", "PUBSUB"])
            # Expected Output: A list of all pub/sub clients


        """
        return self._execute_command(RequestType.CustomCommand, command_args)

    def info(
        self,
        sections: Optional[List[InfoSection]] = None,
    ) -> bytes:
        """
        Get information and statistics about the server.

        See [valkey.io](https://valkey.io/commands/info/) for details.

        Args:
            sections (Optional[List[InfoSection]]): A list of InfoSection values specifying which sections of
                information to retrieve. When no parameter is provided, the default option is assumed.

        Returns:
            bytes: Returns bytes containing the information for the sections requested.
        """
        args: List[TEncodable] = (
            [section.value for section in sections] if sections else []
        )
        return cast(bytes, self._execute_command(RequestType.Info, args))

    def exec(
        self,
        batch: Batch,
        raise_on_error: bool,
        options: Optional[BatchOptions] = None,
    ) -> Optional[List[TResult]]:
        """
        Executes a batch by processing the queued commands.

        See [Valkey Transactions (Atomic Batches)](https://valkey.io/docs/topics/transactions/) and
        [Valkey Pipelines (Non-Atomic Batches)](https://valkey.io/docs/topics/pipelining/) for details.

        Notes:
            - Atomic Batches - Transactions: If the transaction fails due to a ``WATCH`` command,
              ``exec`` will return ``None``.

        Args:
            batch (Batch): A ``Batch`` containing the commands to execute.
            raise_on_error (bool): Determines how errors are handled within the batch response.
                When set to ``True``, the first encountered error in the batch will be raised as a
                ``RequestError`` exception after all retries and reconnections have been executed.
                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``.
            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.
                If the batch fails due to a ``WATCH`` command, ``exec`` will return ``None``.

        Example (Atomic Batch - Transaction):
            >>> transaction = Batch(is_atomic=True)  # Atomic (Transaction)
            >>> transaction.set("key", "1")
            >>> transaction.incr("key")
            >>> transaction.get("key")
            >>> result = await client.exec(transaction, raise_on_error=True)
            >>> print(f"Transaction Batch Result: {result}")
            # Expected Output: Transaction Batch Result: [OK, 2, b'2']

        Example (Non-Atomic Batch - Pipeline):
            >>> pipeline = Batch(is_atomic=False)  # Non-Atomic (Pipeline)
            >>> pipeline.set("key1", "value1")
            >>> pipeline.set("key2", "value2")
            >>> pipeline.get("key1")
            >>> pipeline.get("key2")
            >>> result = await client.exec(pipeline, raise_on_error=True)
            >>> print(f"Pipeline Batch Result: {result}")
            # 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
            ...     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
            ...     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 self._execute_batch(
            commands,
            is_atomic=batch.is_atomic,
            raise_on_error=raise_on_error,
            timeout=timeout,
        )

    def config_resetstat(self) -> TOK:
        """
        Resets the statistics reported by the server using the INFO and LATENCY HISTOGRAM commands.

        See [valkey.io](https://valkey.io/commands/config-resetstat/) for details.

        Returns:
            OK: Returns "OK" to confirm that the statistics were successfully reset.
        """
        return cast(TOK, self._execute_command(RequestType.ConfigResetStat, []))

    def config_rewrite(self) -> TOK:
        """
        Rewrite the configuration file with the current configuration.

        See [valkey.io](https://valkey.io/commands/config-rewrite/) for details.

        Returns:
            OK: OK is returned when the configuration was rewritten properly.

            Otherwise, an error is raised.
        """
        return cast(TOK, self._execute_command(RequestType.ConfigRewrite, []))

    def client_id(
        self,
    ) -> int:
        """
        Returns the current connection id.

        See [valkey.io](https://valkey.io/commands/client-id/) for more information.

        Returns:
            int: the id of the client.
        """
        return cast(int, self._execute_command(RequestType.ClientId, []))

    def ping(self, message: Optional[TEncodable] = None) -> bytes:
        """
        Ping the server.

        See [valkey.io](https://valkey.io/commands/ping/) for more details.

        Args:
            message (Optional[TEncodable]): An optional message to include in the PING command. If not provided,
                the server will respond with b"PONG". If provided, the server will respond with a copy of the message.

        Returns:
            bytes: b"PONG" if `message` is not provided.

            Otherwise return a copy of `message`.

        Examples:
            >>> client.ping()
                b"PONG"
            >>> client.ping("Hello")
                b"Hello"
        """
        argument = [] if message is None else [message]
        return cast(bytes, self._execute_command(RequestType.Ping, argument))

    def config_get(self, parameters: List[TEncodable]) -> Dict[bytes, bytes]:
        """
        Get the values of configuration parameters.
        Starting from server version 7, command supports multiple parameters

        See [valkey.io](https://valkey.io/commands/config-get/) for details.

        Args:
            parameters (List[TEncodable]): A list of configuration parameter names to retrieve values for.

        Returns:
            Dict[bytes, bytes]: A dictionary of values corresponding to the configuration parameters.

        Examples:
            >>> client.config_get(["timeout"] , RandomNode())
                {b'timeout': b'1000'}
            >>> client.config_get([b"timeout" , "maxmemory"])
                {b'timeout': b'1000', b'maxmemory': b'1GB'}
        """
        return cast(
            Dict[bytes, bytes],
            self._execute_command(RequestType.ConfigGet, parameters),
        )

    def config_set(self, parameters_map: Mapping[TEncodable, TEncodable]) -> TOK:
        """
        Set configuration parameters to the specified values.
        Starting from server version 7, command supports multiple parameters.

        See [valkey.io](https://valkey.io/commands/config-set/) for details.

        Args:
            parameters_map (Mapping[TEncodable, TEncodable]): A map consisting of configuration
                parameters and their respective values to set.

        Returns:
            OK: Returns OK if all configurations have been successfully set.

            Otherwise, raises an error.

        Examples:
            >>> config_set({"timeout": "1000", "maxmemory": "1GB"})
                OK
        """
        parameters: List[TEncodable] = []
        for pair in parameters_map.items():
            parameters.extend(pair)
        return cast(TOK, self._execute_command(RequestType.ConfigSet, parameters))

    def client_getname(self) -> Optional[bytes]:
        """
        Get the name of the primary's connection.

        See [valkey.io](https://valkey.io/commands/client-getname/) for more details.

        Returns:
            Optional[bytes]: Returns the name of the client connection as a byte string if a name is set.

            `None` if no name is assigned.

        Examples:
            >>> client.client_getname()
                b'Connection Name'
        """
        return cast(
            Optional[bytes], self._execute_command(RequestType.ClientGetName, [])
        )

    def client_tracking_info(self) -> ClientTrackingInfo:
        """
        Returns information about the current client connection's use
        of the server assisted client side caching feature.

        See [valkey.io](https://valkey.io/commands/client-trackinginfo/) for more details.

        Returns:
            ClientTrackingInfo: The tracking info for the client.

        Examples:
            >>> info = client.client_tracking_info()
            >>> print(info.flags)
                {'off'}
            >>> print(info.redirect)
                -1
        """
        return _parse_client_tracking_info(
            cast(
                Mapping,
                self._execute_command(RequestType.ClientTrackingInfo, []),
            ),
        )

    def dbsize(self) -> int:
        """
        Returns the number of keys in the currently selected database.

        See [valkey.io](https://valkey.io/commands/dbsize) for more details.

        Returns:
            int: The number of keys in the currently selected database.

        Examples:
            >>> client.dbsize()
                10  # Indicates there are 10 keys in the current database.
        """
        return cast(int, self._execute_command(RequestType.DBSize, []))

    def echo(self, message: TEncodable) -> bytes:
        """
        Echoes the provided `message` back.

        See [valkey.io](https://valkey.io/commands/echo) for more details.

        Args:
            message (TEncodable): The message to be echoed back.

        Returns:
            bytes: The provided `message`.

        Examples:
            >>> client.echo("Valkey GLIDE")
                b'Valkey GLIDE'
        """
        return cast(bytes, self._execute_command(RequestType.Echo, [message]))

    def function_load(self, library_code: TEncodable, replace: bool = False) -> bytes:
        """
        Loads a library to Valkey.

        See [valkey.io](https://valkey.io/commands/function-load/) for more details.

        Args:
            library_code (TEncodable): The source code that implements the library.
            replace (bool): Whether the given library should overwrite a library with the same name if
                it already exists.

        Returns:
            bytes: The library name that was loaded.

        Examples:
            >>> code = "#!lua name=mylib \\n redis.register_function('myfunc', function(keys, args) return args[1] end)"
            >>> client.function_load(code, True)
                b"mylib"

        Since: Valkey 7.0.0.
        """
        return cast(
            bytes,
            self._execute_command(
                RequestType.FunctionLoad,
                ["REPLACE", library_code] if replace else [library_code],
            ),
        )

    def function_list(
        self, library_name_pattern: Optional[TEncodable] = None, with_code: bool = False
    ) -> TFunctionListResponse:
        """
        Returns information about the functions and libraries.

        See [valkey.io](https://valkey.io/commands/function-list/) for more details.

        Args:
            library_name_pattern (Optional[TEncodable]):  A wildcard pattern for matching library names.
            with_code (bool): Specifies whether to request the library code from the server or not.

        Returns:
            TFunctionListResponse: Info about all or
            selected libraries and their functions.

        Examples:
            >>> response = client.function_list("myLib?_backup", True)
                [{
                    b"library_name": b"myLib5_backup",
                    b"engine": b"LUA",
                    b"functions": [{
                        b"name": b"myfunc",
                        b"description": None,
                        b"flags": {b"no-writes"},
                    }],
                    b"library_code": b"#!lua name=mylib \\n sever.register_function('myfunc', function(keys, args) " \
                                     b"return args[1] end)"
                }]

        Since: Valkey 7.0.0.
        """
        args = []
        if library_name_pattern is not None:
            args.extend(["LIBRARYNAME", library_name_pattern])
        if with_code:
            args.append("WITHCODE")
        return cast(
            TFunctionListResponse,
            self._execute_command(
                RequestType.FunctionList,
                args,
            ),
        )

    def function_flush(self, mode: Optional[FlushMode] = None) -> TOK:
        """
        Deletes all function libraries.

        See [valkey.io](https://valkey.io/commands/function-flush/) for more details.

        Args:
            mode (Optional[FlushMode]): The flushing mode, could be either `SYNC` or `ASYNC`.

        Returns:
            TOK: A simple `OK`.

        Examples:
            >>> client.function_flush(FlushMode.SYNC)
                "OK"

        Since: Valkey 7.0.0.
        """
        return cast(
            TOK,
            self._execute_command(
                RequestType.FunctionFlush,
                [mode.value] if mode else [],
            ),
        )

    def function_delete(self, library_name: TEncodable) -> TOK:
        """
        Deletes a library and all its functions.

        See [valkey.io](https://valkey.io/commands/function-delete/) for more details.

        Args:
            library_code (TEncodable): The library name to delete

        Returns:
            TOK: A simple `OK`.

        Examples:
            >>> client.function_delete("my_lib")
                "OK"

        Since: Valkey 7.0.0.
        """
        return cast(
            TOK,
            self._execute_command(
                RequestType.FunctionDelete,
                [library_name],
            ),
        )

    def function_kill(self) -> TOK:
        """
        Kills a function that is currently executing.
        This command only terminates read-only functions.

        FUNCTION KILL runs on all nodes of the server, including primary and replicas.

        See [valkey.io](https://valkey.io/commands/function-kill/) for more details.

        Returns:
            TOK: A simple `OK`.

        Examples:
            >>> client.function_kill()
                "OK"

        Since: Valkey 7.0.0.
        """
        return cast(
            TOK,
            self._execute_command(RequestType.FunctionKill, []),
        )

    def function_stats(self) -> TFunctionStatsFullResponse:
        """
        Returns information about the function that's currently running and information about the
        available execution engines.

        FUNCTION STATS runs on all nodes of the server, including primary and replicas.
        The response includes a mapping from node address to the command response for that node.

        See [valkey.io](https://valkey.io/commands/function-stats/) for more details

        Returns:
            TFunctionStatsFullResponse: A Map where the key is the node address and the value is a Map of two keys:

                - `running_script` with information about the running script.
                - `engines` with information about available engines and their stats.

            See example for more details.

        Examples:
            >>> client.function_stats()
                {b"addr": {                         # Response from the master node
                    b'running_script': {
                        b'name': b'foo',
                        b'command': [b'FCALL', b'foo', b'0', b'hello'],
                        b'duration_ms': 7758
                    },
                    b'engines': {
                        b'LUA': {
                            b'libraries_count': 1,
                            b'functions_count': 1,
                        }
                    }
                },
                b"addr2": {                         # Response from a replica
                    b'running_script': None,
                    b"engines": {
                        b'LUA': {
                            b'libraries_count': 1,
                            b'functions_count': 1,
                        }
                    }
                }}

        Since: Valkey version 7.0.0.
        """
        return cast(
            TFunctionStatsFullResponse,
            self._execute_command(RequestType.FunctionStats, []),
        )

    def function_dump(self) -> bytes:
        """
        Returns the serialized payload of all loaded libraries.

        See [valkey.io](https://valkey.io/commands/function-dump/) for more details.

        Returns:
            bytes: The serialized payload of all loaded libraries.

        Examples:
            >>> payload = client.function_dump()
                # The serialized payload of all loaded libraries. This response can
                # be used to restore loaded functions on any Valkey instance.
            >>> client.function_restore(payload)
                "OK" # The serialized dump response was used to restore the libraries.

        Since: Valkey 7.0.0.
        """
        return cast(bytes, self._execute_command(RequestType.FunctionDump, []))

    def function_restore(
        self, payload: TEncodable, policy: Optional[FunctionRestorePolicy] = None
    ) -> TOK:
        """
        Restores libraries from the serialized payload returned by the `function_dump` command.

        See [valkey.io](https://valkey.io/commands/function-restore/) for more details.

        Args:
            payload (TEncodable): The serialized data from the `function_dump` command.
            policy (Optional[FunctionRestorePolicy]): A policy for handling existing libraries.

        Returns:
            TOK: OK.

        Examples:
            >>> payload = client.function_dump()
                # The serialized payload of all loaded libraries. This response can
                # be used to restore loaded functions on any Valkey instance.
            >>> client.function_restore(payload)
                "OK" # The serialized dump response was used to restore the libraries.
            >>> client.function_restore(payload, FunctionRestorePolicy.FLUSH)
                "OK" # The serialized dump response was used to restore the libraries with the specified policy.

        Since: Valkey 7.0.0.
        """
        args: List[TEncodable] = [payload]
        if policy is not None:
            args.append(policy.value)

        return cast(TOK, self._execute_command(RequestType.FunctionRestore, args))

    def time(self) -> List[bytes]:
        """
        Returns the server time.

        See [valkey.io](https://valkey.io/commands/time/) for more details.

        Returns:
            List[bytes]:  The current server time as a two items `array`:
            A Unix timestamp and the amount of microseconds already elapsed in the current second.
            The returned `array` is in a [Unix timestamp, Microseconds already elapsed] format.

        Examples:
            >>> client.time()
                [b'1710925775', b'913580']
        """
        return cast(
            List[bytes],
            self._execute_command(RequestType.Time, []),
        )

    def lastsave(self) -> int:
        """
        Returns the Unix time of the last DB save timestamp or startup timestamp if no save was made since then.

        See [valkey.io](https://valkey.io/commands/lastsave) for more details.

        Returns:
            int: The Unix time of the last successful DB save.

        Examples:
            >>> client.lastsave()
                1710925775  # Unix time of the last DB save
        """
        return cast(
            int,
            self._execute_command(RequestType.LastSave, []),
        )

    def save(self) -> TOK:
        """
        Synchronously saves the dataset to disk.

        See [valkey.io](https://valkey.io/commands/save) for more details.

        Returns:
            TOK: A simple OK response.

        Examples:
            >>> client.save()
                OK
        """
        return cast(
            TOK,
            self._execute_command(RequestType.Save, []),
        )

    def bgsave(self) -> str:
        """
        Asynchronously saves the dataset to disk in the background.

        See [valkey.io](https://valkey.io/commands/bgsave) for more details.

        Returns:
            str: A non-empty status string.

        Examples:
            >>> client.bgsave()
                "Background saving started"
        """
        return cast(
            str,
            self._execute_command(RequestType.BgSave, []),
        )

    def bgsave_schedule(self) -> str:
        """
        Schedules a background save of the database.

        See [valkey.io](https://valkey.io/commands/bgsave) for more details.

        Returns:
            str: A non-empty status string.

        Examples:
            >>> client.bgsave_schedule()
                "Background saving scheduled"
        """
        return cast(
            str,
            self._execute_command(RequestType.BgSave, ["SCHEDULE"]),
        )

    def bgsave_cancel(self) -> str:
        """
        Aborts all in-progress and scheduled background saves.

        See [valkey.io](https://valkey.io/commands/bgsave) for more details.

        Note:
            Since: Valkey 8.1.

        Returns:
            str: A non-empty status string.

        Examples:
            >>> client.bgsave_cancel()
                "Background saving cancelled"
        """
        return cast(
            str,
            self._execute_command(RequestType.BgSave, ["CANCEL"]),
        )

    def bgrewriteaof(self) -> str:
        """
        Initiates a background rewrite of the append-only file (AOF).

        See [valkey.io](https://valkey.io/commands/bgrewriteaof) for more details.

        Returns:
            str: A non-empty status string.

        Examples:
            >>> client.bgrewriteaof()
                "Background append only file rewriting started"
        """
        return cast(
            str,
            self._execute_command(RequestType.BgRewriteAof, []),
        )

    def publish(self, message: TEncodable, channel: TEncodable) -> int:
        """
        Publish a message on pubsub channel.

        See [valkey.io](https://valkey.io/commands/publish) for more details.

        Args:
            message (TEncodable): Message to publish
            channel (TEncodable): Channel to publish the message on.

        Returns:
            int: Number of subscriptions in primary node that received the message.

            **Note:** this value does not include subscriptions that configured on replicas.

        Examples:
            >>> client.publish("Hi all!", "global-channel")
                1 # This message was posted to 1 subscription which is configured on primary node
        """
        return cast(int, self._execute_command(RequestType.Publish, [channel, message]))

    def flushall(self, flush_mode: Optional[FlushMode] = None) -> TOK:
        """
        Deletes all the keys of all the existing databases. This command never fails.

        See [valkey.io](https://valkey.io/commands/flushall) for more details.

        Args:
            flush_mode (Optional[FlushMode]): The flushing mode, could be either `SYNC` or `ASYNC`.

        Returns:
            TOK: A simple OK response.

        Examples:
            >>> client.flushall(FlushMode.ASYNC)
                OK  # This command never fails.
        """
        args: List[TEncodable] = []
        if flush_mode is not None:
            args.append(flush_mode.value)

        return cast(
            TOK,
            self._execute_command(RequestType.FlushAll, args),
        )

    def flushdb(self, flush_mode: Optional[FlushMode] = None) -> TOK:
        """
        Deletes all the keys of the currently selected database. This command never fails.

        See [valkey.io](https://valkey.io/commands/flushdb) for more details.

        Args:
            flush_mode (Optional[FlushMode]): The flushing mode, could be either `SYNC` or `ASYNC`.

        Returns:
            TOK: A simple OK response.

        Examples:
            >>> client.flushdb()
                OK  # The keys of the currently selected database were deleted.
            >>> client.flushdb(FlushMode.ASYNC)
                OK  # The keys of the currently selected database were deleted asynchronously.
        """
        args: List[TEncodable] = []
        if flush_mode is not None:
            args.append(flush_mode.value)

        return cast(
            TOK,
            self._execute_command(RequestType.FlushDB, args),
        )

    def copy(
        self,
        source: TEncodable,
        destination: TEncodable,
        destinationDB: Optional[int] = None,
        replace: Optional[bool] = None,
    ) -> bool:
        """
        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.

        Args:
            source (TEncodable): The key to the source value.
            destination (TEncodable): The key where the value should be copied to.
            destinationDB (Optional[int]): The alternative logical database index for the destination key.
            replace (Optional[bool]): If the destination key should be removed before copying the value to it.

        Returns:
            bool: True if the source was copied.

            Otherwise, return False.

        Examples:
            >>> client.set("source", "sheep")
            >>> client.copy(b"source", b"destination", 1, False)
                True # Source was copied
            >>> client.select(1)
            >>> client.get("destination")
                b"sheep"

        Since: Valkey version 6.2.0.
        """
        args: List[TEncodable] = [source, destination]
        if destinationDB is not None:
            args.extend(["DB", str(destinationDB)])
        if replace is True:
            args.append("REPLACE")
        return cast(
            bool,
            self._execute_command(RequestType.Copy, args),
        )

    def lolwut(
        self,
        version: Optional[int] = None,
        parameters: Optional[List[int]] = None,
    ) -> bytes:
        """
        Displays a piece of generative computer art and the Valkey version.

        See [valkey.io](https://valkey.io/commands/lolwut) for more details.

        Args:
            version (Optional[int]): Version of computer art to generate.
            parameters (Optional[List[int]]): Additional set of arguments in order to change the output:

                - For version `5`, those are length of the line, number of squares per row, and number of squares per column.
                - For version `6`, those are number of columns and number of lines.

        Returns:
            bytes: A piece of generative computer art along with the current Valkey version.

        Examples:
            >>> client.lolwut(6, [40, 20]);
                b"Redis ver. 7.2.3" # Indicates the current Valkey version
            >>> client.lolwut(5, [30, 5, 5]);
                b"Redis ver. 7.2.3" # Indicates the current Valkey version
        """
        args: List[TEncodable] = []
        if version is not None:
            args.extend(["VERSION", str(version)])
        if parameters:
            for var in parameters:
                args.append(str(var))
        return cast(
            bytes,
            self._execute_command(RequestType.Lolwut, args),
        )

    def random_key(self) -> Optional[bytes]:
        """
        Returns a random existing key name from the currently selected database.

        See [valkey.io](https://valkey.io/commands/randomkey) for more details.

        Returns:
            Optional[bytes]: A random existing key name from the currently selected database.

        Examples:
            >>> client.random_key()
                b"random_key_name"  # "random_key_name" is a random existing key name from the currently selected database.
        """
        return cast(
            Optional[bytes],
            self._execute_command(RequestType.RandomKey, []),
        )

    def wait(
        self,
        numreplicas: int,
        timeout: int,
    ) -> int:
        """
        Blocks the current client until all the previous write commands are successfully transferred
        and acknowledged by at least `numreplicas` of replicas. If `timeout` is
        reached, the command returns even if the specified number of replicas were not yet reached.

        See [valkey.io](https://valkey.io/commands/wait) for more details.

        Args:
            numreplicas (int): The number of replicas to reach.
            timeout (int): The timeout value specified in milliseconds. A value of 0 will block indefinitely.

        Returns:
            int: The number of replicas reached by all the writes performed in the context of the current connection.

        Examples:
            >>> client.set("key", "value");
            >>> client.wait(1, 1000);
            # return 1 when a replica is reached or 0 if 1000ms is reached.
        """
        args: List[TEncodable] = [str(numreplicas), str(timeout)]
        return cast(
            int,
            self._execute_command(RequestType.Wait, args),
        )

    def unwatch(self) -> TOK:
        """
        Flushes all the previously watched keys for an atomic batch (Transaction). Executing a transaction will
        automatically flush all previously watched keys.

        See [valkey.io](https://valkey.io/commands/unwatch) for more details.

        Returns:
            TOK: A simple "OK" response.

        Examples:
            >>> client.unwatch()
                'OK'
        """
        return cast(
            TOK,
            self._execute_command(RequestType.UnWatch, []),
        )

    def script_exists(self, sha1s: List[TEncodable]) -> List[bool]:
        """
        Check existence of scripts in the script cache by their SHA1 digest.

        See [valkey.io](https://valkey.io/commands/script-exists) for more details.

        Args:
            sha1s (List[TEncodable]): List of SHA1 digests of the scripts to check.

        Returns:
            List[bool]: A list of boolean values indicating the existence of each script.

        Examples:
            >>> client.script_exists(["sha1_digest1", "sha1_digest2"])
                [True, False]
        """
        return cast(List[bool], self._execute_command(RequestType.ScriptExists, sha1s))

    def script_flush(self, mode: Optional[FlushMode] = None) -> TOK:
        """
        Flush the Lua scripts cache.

        See [valkey.io](https://valkey.io/commands/script-flush) for more details.

        Args:
            mode (Optional[FlushMode]): The flushing mode, could be either `SYNC` or `ASYNC`.

        Returns:
            TOK: A simple `OK` response.

        Examples:
            >>> client.script_flush()
                "OK"

            >>> client.script_flush(FlushMode.ASYNC)
                "OK"
        """

        return cast(
            TOK,
            self._execute_command(
                RequestType.ScriptFlush, [mode.value] if mode else []
            ),
        )

    def script_kill(self) -> TOK:
        """
        Kill the currently executing Lua script, assuming no write operation was yet performed by the script.

        See [valkey.io](https://valkey.io/commands/script-kill) for more details.

        Returns:
            TOK: A simple `OK` response.

        Examples:
            >>> client.script_kill()
                "OK"
        """
        return cast(TOK, self._execute_command(RequestType.ScriptKill, []))

    def invoke_script(
        self,
        script: Script,
        keys: Optional[List[TEncodable]] = None,
        args: Optional[List[TEncodable]] = None,
    ) -> TResult:
        """
        Invokes a Lua script with its keys and arguments.
        This method simplifies the process of invoking scripts on a the server by using an object that represents a Lua script.
        The script loading, argument preparation, and execution will all be handled internally.
        If the script has not already been loaded, it will be loaded automatically using the `SCRIPT LOAD` command.
        After that, it will be invoked using the `EVALSHA` command.

        See [SCRIPT LOAD](https://valkey.io/commands/script-load/) and [EVALSHA](https://valkey.io/commands/evalsha/)
        for more details.

        Args:
            script (Script): The Lua script to execute.
            keys (Optional[List[TEncodable]]): The keys that are used in the script.
            args (Optional[List[TEncodable]]): The arguments for the script.

        Returns:
            TResult: a value that depends on the script that was executed.

        Examples:
            >>> lua_script = Script("return { KEYS[1], ARGV[1] }")
            >>> client.invoke_script(lua_script, keys=["foo"], args=["bar"])
                [b"foo", b"bar"]
        """
        return self._execute_script(script.get_hash(), keys, args)

    def scan(
        self,
        cursor: TEncodable,
        match: Optional[TEncodable] = None,
        count: Optional[int] = None,
        type: Optional[ObjectType] = None,
    ) -> List[Union[bytes, List[bytes]]]:
        """
        Incrementally iterate over a collection of keys.
        SCAN is a cursor based iterator. This means that at every call of the command,
        the server returns an updated cursor that the user needs to use as the cursor argument in the next call.
        An iteration starts when the cursor is set to "0", and terminates when the cursor returned by the server is "0".

        A full iteration always retrieves all the elements that were present
        in the collection from the start to the end of a full iteration.
        Elements that were not constantly present in the collection during a full iteration, may be returned or not.

        See [valkey.io](https://valkey.io/commands/scan) for more details.

        Args:
            cursor (TResult): The cursor used for iteration. For the first iteration, the cursor should be set to "0".

                - Using a non-zero cursor in the first iteration, or an invalid cursor at any iteration, will lead to
                  undefined results.
                - Using the same cursor in multiple iterations will, in case nothing changed between the iterations,
                  return the same elements multiple times.
                - If the the db has changed, it may result an undefined behavior.

            match (Optional[TResult]): A pattern to match keys against.
            count (Optional[int]): The number of keys to return per iteration.

                - The number of keys returned per iteration is not guaranteed to be the same as the count argument.
                - The argument is used as a hint for the server to know how many "steps" it can use to retrieve the keys.
                - The default value is 10.

            type (ObjectType): The type of object to scan for.

        Returns:
            List[Union[bytes, List[bytes]]]: A List containing the next cursor value and a list of keys,
            formatted as [cursor, [key1, key2, ...]]

        Examples:
            >>> result = client.scan(b'0')
                print(result) #[b'17', [b'key1', b'key2', b'key3', b'key4', b'key5', b'set1', b'set2', b'set3']]
                first_cursor_result = result[0]
                result = client.scan(first_cursor_result)
                print(result) #[b'349', [b'key4', b'key5', b'set1', b'hash1', b'zset1', b'list1', b'list2',
                                        b'list3', b'zset2', b'zset3', b'zset4', b'zset5', b'zset6']]
                result = client.scan(result[0])
                print(result) #[b'0', [b'key6', b'key7']]
            >>> result = client.scan(first_cursor_result, match=b'key*', count=2)
                print(result) #[b'6', [b'key4', b'key5']]
            >>> result = client.scan("0", type=ObjectType.Set)
                print(result) #[b'362', [b'set1', b'set2', b'set3']]
        """
        args = [cursor]
        if match:
            args.extend(["MATCH", match])
        if count:
            args.extend(["COUNT", str(count)])
        if type:
            args.extend(["TYPE", type.value])
        return cast(
            List[Union[bytes, List[bytes]]],
            self._execute_command(RequestType.Scan, args),
        )

    def client_pause(self, timeout: int, mode: Optional[ClientPauseMode] = None) -> TOK:
        """
        Suspends all clients for the specified timeout.

        See [valkey.io](https://valkey.io/commands/client-pause/) for more details.

        Args:
            timeout (int): The time in milliseconds to pause clients.
            mode (Optional[ClientPauseMode]): The pause mode to use.

        Returns:
            TOK: A simple OK response.

        Examples:
            >>> client.client_pause(1000)
                OK
            >>> client.client_pause(5000, ClientPauseMode.WRITE)
                OK
        """
        args: List[TEncodable] = [str(timeout)]
        if mode is not None:
            args.append(mode.value)
        return cast(TOK, self._execute_command(RequestType.ClientPause, args))

    def client_unpause(self) -> TOK:
        """
        Resumes processing commands on all clients.

        See [valkey.io](https://valkey.io/commands/client-unpause/) for more details.

        Returns:
            TOK: A simple OK response.

        Examples:
            >>> client.client_unpause()
                OK
        """
        return cast(TOK, self._execute_command(RequestType.ClientUnpause, []))

    def latency_history(self, event: TEncodable) -> List[LatencyEntry]:
        """
        Returns the latency spike time series for the specified event.

        See [valkey.io](https://valkey.io/commands/latency-history/) for details.

        Args:
            event (TEncodable): The name of the latency event (e.g., ``"command"``).

        Returns:
            List[LatencyEntry]: A list of LatencyEntry for the event, or an empty list
                if the event doesn't exist.

        Examples:
            >>> history = client.latency_history("command")
            >>> for entry in history:
            ...     print(f"Time: {entry.time}, Latency: {entry.latency}")
        """
        return _parse_latency_history(
            cast(
                List,
                self._execute_command(RequestType.LatencyHistory, [event]),
            ),
        )

    def latency_latest(self) -> List[LatencyEventInfo]:
        """
        Reports the latest latency events logged by the server.

        See [valkey.io](https://valkey.io/commands/latency-latest/) for details.

        Returns:
            List[LatencyEventInfo]: A list of LatencyEventInfo for the latest latency events.

        Examples:
            >>> latest = client.latency_latest()
            >>> for info in latest:
            ...     print(f"Event: {info.event_name}, Latest: {info.latest_duration}")
        """
        return _parse_latency_latest(
            cast(
                List,
                self._execute_command(RequestType.LatencyLatest, []),
            ),
        )

    def latency_reset(self, *events: TEncodable) -> int:
        """
        Resets the latency spike time series for all or specified events.
        If no events are provided, resets the latency spike time series for all events.

        See [valkey.io](https://valkey.io/commands/latency-reset/) for details.

        Args:
            *events (TEncodable): The event names to reset. If none provided, resets
                all events.

        Returns:
            int: The number of event time series that were reset.

        Examples:
            >>> client.latency_reset()
                2
            >>> client.latency_reset("command")
                1
        """
        return cast(
            int,
            self._execute_command(RequestType.LatencyReset, list(events)),
        )

    def failover(
        self,
        host: Optional[TEncodable] = None,
        port: Optional[int] = None,
        force: bool = False,
        abort: bool = False,
        timeout_ms: Optional[int] = None,
    ) -> TOK:
        """
        Starts a coordinated failover from the connected primary to one of its replicas.
        This is the standalone equivalent of CLUSTER FAILOVER.

        See [valkey.io](https://valkey.io/commands/failover/) for more details.

        Args:
            host (Optional[TEncodable]): The host of the target replica (requires port).
            port (Optional[int]): The port of the target replica (requires host).
            force (bool): If True, forces failover after timeout (requires host, port, and timeout_ms).
            abort (bool): If True, aborts an ongoing failover.
            timeout_ms (Optional[int]): Timeout in milliseconds.

        Returns:
            TOK: A simple OK response.

        Examples:
            >>> client.failover()
                OK
            >>> client.failover(abort=True)
                OK
        """
        args: List[TEncodable] = []
        if (host is None) != (port is None):
            raise ValueError("Both host and port must be provided together")
        if force and (host is None or port is None):
            raise ValueError("force requires host and port to be specified")
        if abort:
            args.append("ABORT")
        else:
            if host is not None and port is not None:
                args.extend(["TO", host, str(port)])
                if force:
                    args.append("FORCE")
            if timeout_ms is not None:
                args.extend(["TIMEOUT", str(timeout_ms)])
        return cast(TOK, self._execute_command(RequestType.FailOver, args))

    def replicaof(self, host: TEncodable, port: int) -> TOK:
        """
        Makes the server a replica of the specified primary.

        See [valkey.io](https://valkey.io/commands/replicaof/) for more details.

        Args:
            host (TEncodable): The host of the primary to replicate.
            port (int): The port of the primary to replicate.

        Returns:
            TOK: A simple OK response.

        Examples:
            >>> client.replicaof("localhost", 6379)
                OK
        """
        return cast(
            TOK, self._execute_command(RequestType.ReplicaOf, [host, str(port)])
        )

    def replicaof_no_one(self) -> TOK:
        """
        Promotes the current server to a primary by stopping replication.

        See [valkey.io](https://valkey.io/commands/replicaof/) for more details.

        Returns:
            TOK: A simple OK response.

        Examples:
            >>> client.replicaof_no_one()
                OK
        """
        return cast(TOK, self._execute_command(RequestType.ReplicaOf, ["NO", "ONE"]))

    def migrate(
        self,
        host: str,
        port: int,
        keys: Union[TEncodable, List[TEncodable]],
        destination_db: int,
        timeout: int,
        options: Optional[MigrateOptions] = None,
    ) -> str:
        """
        Atomically transfers one or more keys from a source Valkey instance to a destination
        Valkey instance. On success, the key(s) are deleted from the source instance.
        Pass a list to migrate multiple keys in one command.

        See [valkey.io](https://valkey.io/commands/migrate/) for details.

        Args:
            host (str): The host of the destination Valkey instance.
            port (int): The port of the destination Valkey instance.
            keys (Union[TEncodable, List[TEncodable]]): The key or list of keys to migrate.
            destination_db (int): The database index on the destination instance.
            timeout (int): The maximum idle time in milliseconds for the bulk-transfer.
            options (Optional[MigrateOptions]): Additional migration options.

        Returns:
            str: "OK" on success, or "NOKEY" if no keys were found.

        Examples:
            >>> client.migrate("127.0.0.1", 6380, "mykey", 0, 5000)
            >>> client.migrate("127.0.0.1", 6380, ["key1", "key2"], 0, 5000)
        """
        if isinstance(keys, list):
            if len(keys) == 0:
                raise ValueError("migrate: 'keys' list must not be empty")
            args: List[TEncodable] = [
                host,
                str(port),
                "",
                str(destination_db),
                str(timeout),
            ]
            if options:
                args.extend(options.to_args())
            args += ["KEYS"] + list(keys)
        else:
            args = [host, str(port), keys, str(destination_db), str(timeout)]
            if options:
                args.extend(options.to_args())
        return cast(
            str,
            self._execute_command(RequestType.Migrate, args),
        )

    # TODO #6166: move to shared base class

    def memory_doctor(self) -> str:
        """
        Returns a report about memory problems detected by the server.

        See [valkey.io](https://valkey.io/commands/memory-doctor/) for details.

        Returns:
            str: The memory diagnostic report.

        Examples:
            >>> report = client.memory_doctor()
            >>> print("Memory report:", report)
        """
        response = self._execute_command(RequestType.MemoryDoctor, [])
        return cast(bytes, response).decode()

    def memory_malloc_stats(self) -> str:
        """
        Returns the internal statistics of the memory allocator.

        See [valkey.io](https://valkey.io/commands/memory-malloc-stats/) for details.

        Returns:
            str: The memory allocator statistics.

        Examples:
            >>> report = client.memory_malloc_stats()
            >>> print("Allocator stats:", report)
        """
        response = self._execute_command(RequestType.MemoryMallocStats, [])
        return cast(bytes, response).decode()

    def memory_purge(self) -> TOK:
        """
        Asks the server to reclaim memory from the allocator back to the operating system.

        See [valkey.io](https://valkey.io/commands/memory-purge/) for details.

        Returns:
            TOK: A simple "OK" response.

        Examples:
            >>> client.memory_purge()
                "OK"
        """
        return cast(TOK, self._execute_command(RequestType.MemoryPurge, []))

    def memory_stats(self) -> MemoryStats:
        """
        Returns detailed memory consumption statistics of the server.

        See [valkey.io](https://valkey.io/commands/memory-stats/) for details.

        Returns:
            MemoryStats: A ``MemoryStats`` object containing detailed memory usage
                statistics.

        Examples:
            >>> stats = client.memory_stats()
            >>> print(f"Peak allocated: {stats.peak_allocated}")
            >>> print(f"Total allocated: {stats.total_allocated}")
        """
        return _parse_memory_stats(
            cast(
                Mapping,
                self._execute_command(RequestType.MemoryStats, []),
            ),
        )

custom_command(command_args)

Executes a single command, without checking inputs. See the Valkey GLIDE Documentation 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.

Parameters:

Name	Type	Description	Default
command_args	List[TEncodable]	List of the command's arguments, where each argument is either a string or bytes.	required

Returns:

Name	Type	Description
TResult	TResult	The returning value depends on the executed command.

Example

connection.customCommand(["CLIENT", "LIST","TYPE", "PUBSUB"])

Expected Output: A list of all pub/sub clients

Source code in doc-gen/valkey-glide/python/glide-sync/glide_sync/sync_commands/standalone_commands.py

def custom_command(self, command_args: List[TEncodable]) -> TResult:
    """
    Executes a single command, without checking inputs.
    See the [Valkey GLIDE Documentation](https://glide.valkey.io/concepts/client-features/custom-commands/)
    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.

    Returns:
        TResult: The returning value depends on the executed command.

    Example:
        >>> connection.customCommand(["CLIENT", "LIST","TYPE", "PUBSUB"])
        # Expected Output: A list of all pub/sub clients


    """
    return self._execute_command(RequestType.CustomCommand, command_args)

info(sections=None)

Get information and statistics about the server.

See valkey.io for details.

Parameters:

Name	Type	Description	Default
sections	Optional[List[InfoSection]]	A list of InfoSection values specifying which sections of information to retrieve. When no parameter is provided, the default option is assumed.	None

Returns:

Name	Type	Description
bytes	bytes	Returns bytes containing the information for the sections requested.

Source code in doc-gen/valkey-glide/python/glide-sync/glide_sync/sync_commands/standalone_commands.py

def info(
    self,
    sections: Optional[List[InfoSection]] = None,
) -> bytes:
    """
    Get information and statistics about the server.

    See [valkey.io](https://valkey.io/commands/info/) for details.

    Args:
        sections (Optional[List[InfoSection]]): A list of InfoSection values specifying which sections of
            information to retrieve. When no parameter is provided, the default option is assumed.

    Returns:
        bytes: Returns bytes containing the information for the sections requested.
    """
    args: List[TEncodable] = (
        [section.value for section in sections] if sections else []
    )
    return cast(bytes, self._execute_command(RequestType.Info, args))

exec(batch, raise_on_error, options=None)

Executes a batch by processing the queued commands.

See Valkey Transactions (Atomic Batches) and Valkey Pipelines (Non-Atomic Batches) for details.

Notes

• Atomic Batches - Transactions: If the transaction fails due to a WATCH command, exec will return None.

Parameters:

Name	Type	Description	Default
batch	Batch	A Batch containing the commands to execute.	required
raise_on_error	bool	Determines how errors are handled within the batch response. When set to True, the first encountered error in the batch will be raised as a RequestError exception after all retries and reconnections have been executed. 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.	required
options	Optional[BatchOptions]	A BatchOptions object containing execution options.	None

Returns:

Type	Description
Optional[List[TResult]]	Optional[List[TResult]]: An array of results, where each entry corresponds to a command's execution result. If the batch fails due to a WATCH command, exec will return None.

Example (Atomic Batch - Transaction): >>> transaction = Batch(is_atomic=True) # Atomic (Transaction) >>> transaction.set("key", "1") >>> transaction.incr("key") >>> transaction.get("key") >>> result = await client.exec(transaction, raise_on_error=True) >>> print(f"Transaction Batch Result: {result}") # Expected Output: Transaction Batch Result: [OK, 2, b'2']

Example (Non-Atomic Batch - Pipeline): >>> pipeline = Batch(is_atomic=False) # Non-Atomic (Pipeline) >>> pipeline.set("key1", "value1") >>> pipeline.set("key2", "value2") >>> pipeline.get("key1") >>> pipeline.get("key2") >>> result = await client.exec(pipeline, raise_on_error=True) >>> print(f"Pipeline Batch Result: {result}") # 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 ... 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 ... options=options ... ) >>> print(f"Pipeline Result: {result}") # Expected Output: Pipeline Result: [OK, OK, b'value1', b'value2']

Source code in doc-gen/valkey-glide/python/glide-sync/glide_sync/sync_commands/standalone_commands.py

def exec(
    self,
    batch: Batch,
    raise_on_error: bool,
    options: Optional[BatchOptions] = None,
) -> Optional[List[TResult]]:
    """
    Executes a batch by processing the queued commands.

    See [Valkey Transactions (Atomic Batches)](https://valkey.io/docs/topics/transactions/) and
    [Valkey Pipelines (Non-Atomic Batches)](https://valkey.io/docs/topics/pipelining/) for details.

    Notes:
        - Atomic Batches - Transactions: If the transaction fails due to a ``WATCH`` command,
          ``exec`` will return ``None``.

    Args:
        batch (Batch): A ``Batch`` containing the commands to execute.
        raise_on_error (bool): Determines how errors are handled within the batch response.
            When set to ``True``, the first encountered error in the batch will be raised as a
            ``RequestError`` exception after all retries and reconnections have been executed.
            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``.
        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.
            If the batch fails due to a ``WATCH`` command, ``exec`` will return ``None``.

    Example (Atomic Batch - Transaction):
        >>> transaction = Batch(is_atomic=True)  # Atomic (Transaction)
        >>> transaction.set("key", "1")
        >>> transaction.incr("key")
        >>> transaction.get("key")
        >>> result = await client.exec(transaction, raise_on_error=True)
        >>> print(f"Transaction Batch Result: {result}")
        # Expected Output: Transaction Batch Result: [OK, 2, b'2']

    Example (Non-Atomic Batch - Pipeline):
        >>> pipeline = Batch(is_atomic=False)  # Non-Atomic (Pipeline)
        >>> pipeline.set("key1", "value1")
        >>> pipeline.set("key2", "value2")
        >>> pipeline.get("key1")
        >>> pipeline.get("key2")
        >>> result = await client.exec(pipeline, raise_on_error=True)
        >>> print(f"Pipeline Batch Result: {result}")
        # 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
        ...     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
        ...     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 self._execute_batch(
        commands,
        is_atomic=batch.is_atomic,
        raise_on_error=raise_on_error,
        timeout=timeout,
    )

config_resetstat()

Resets the statistics reported by the server using the INFO and LATENCY HISTOGRAM commands.

See valkey.io for details.

Returns:

Name	Type	Description
OK	TOK	Returns "OK" to confirm that the statistics were successfully reset.

Source code in doc-gen/valkey-glide/python/glide-sync/glide_sync/sync_commands/standalone_commands.py

def config_resetstat(self) -> TOK:
    """
    Resets the statistics reported by the server using the INFO and LATENCY HISTOGRAM commands.

    See [valkey.io](https://valkey.io/commands/config-resetstat/) for details.

    Returns:
        OK: Returns "OK" to confirm that the statistics were successfully reset.
    """
    return cast(TOK, self._execute_command(RequestType.ConfigResetStat, []))

config_rewrite()

Rewrite the configuration file with the current configuration.

See valkey.io for details.

Returns:

Name	Type	Description
OK	TOK	OK is returned when the configuration was rewritten properly.
	TOK	Otherwise, an error is raised.

Source code in doc-gen/valkey-glide/python/glide-sync/glide_sync/sync_commands/standalone_commands.py

def config_rewrite(self) -> TOK:
    """
    Rewrite the configuration file with the current configuration.

    See [valkey.io](https://valkey.io/commands/config-rewrite/) for details.

    Returns:
        OK: OK is returned when the configuration was rewritten properly.

        Otherwise, an error is raised.
    """
    return cast(TOK, self._execute_command(RequestType.ConfigRewrite, []))

client_id()

Returns the current connection id.

See valkey.io for more information.

Returns:

Name	Type	Description
int	int	the id of the client.

Source code in doc-gen/valkey-glide/python/glide-sync/glide_sync/sync_commands/standalone_commands.py

def client_id(
    self,
) -> int:
    """
    Returns the current connection id.

    See [valkey.io](https://valkey.io/commands/client-id/) for more information.

    Returns:
        int: the id of the client.
    """
    return cast(int, self._execute_command(RequestType.ClientId, []))

ping(message=None)

Ping the server.

See valkey.io for more details.

Parameters:

Name	Type	Description	Default
message	Optional[TEncodable]	An optional message to include in the PING command. If not provided, the server will respond with b"PONG". If provided, the server will respond with a copy of the message.	None

Returns:

Name	Type	Description
bytes	bytes	b"PONG" if message is not provided.
	bytes	Otherwise return a copy of message.

Examples:

>>> client.ping()
    b"PONG"
>>> client.ping("Hello")
    b"Hello"

Source code in doc-gen/valkey-glide/python/glide-sync/glide_sync/sync_commands/standalone_commands.py

def ping(self, message: Optional[TEncodable] = None) -> bytes:
    """
    Ping the server.

    See [valkey.io](https://valkey.io/commands/ping/) for more details.

    Args:
        message (Optional[TEncodable]): An optional message to include in the PING command. If not provided,
            the server will respond with b"PONG". If provided, the server will respond with a copy of the message.

    Returns:
        bytes: b"PONG" if `message` is not provided.

        Otherwise return a copy of `message`.

    Examples:
        >>> client.ping()
            b"PONG"
        >>> client.ping("Hello")
            b"Hello"
    """
    argument = [] if message is None else [message]
    return cast(bytes, self._execute_command(RequestType.Ping, argument))

config_get(parameters)

Get the values of configuration parameters. Starting from server version 7, command supports multiple parameters

See valkey.io for details.

Parameters:

Name	Type	Description	Default
parameters	List[TEncodable]	A list of configuration parameter names to retrieve values for.	required

Returns:

Type	Description
Dict[bytes, bytes]	Dict[bytes, bytes]: A dictionary of values corresponding to the configuration parameters.

Examples:

>>> client.config_get(["timeout"] , RandomNode())
    {b'timeout': b'1000'}
>>> client.config_get([b"timeout" , "maxmemory"])
    {b'timeout': b'1000', b'maxmemory': b'1GB'}

Source code in doc-gen/valkey-glide/python/glide-sync/glide_sync/sync_commands/standalone_commands.py

def config_get(self, parameters: List[TEncodable]) -> Dict[bytes, bytes]:
    """
    Get the values of configuration parameters.
    Starting from server version 7, command supports multiple parameters

    See [valkey.io](https://valkey.io/commands/config-get/) for details.

    Args:
        parameters (List[TEncodable]): A list of configuration parameter names to retrieve values for.

    Returns:
        Dict[bytes, bytes]: A dictionary of values corresponding to the configuration parameters.

    Examples:
        >>> client.config_get(["timeout"] , RandomNode())
            {b'timeout': b'1000'}
        >>> client.config_get([b"timeout" , "maxmemory"])
            {b'timeout': b'1000', b'maxmemory': b'1GB'}
    """
    return cast(
        Dict[bytes, bytes],
        self._execute_command(RequestType.ConfigGet, parameters),
    )

config_set(parameters_map)

Set configuration parameters to the specified values. Starting from server version 7, command supports multiple parameters.

See valkey.io for details.

Parameters:

Name	Type	Description	Default
parameters_map	Mapping[TEncodable, TEncodable]	A map consisting of configuration parameters and their respective values to set.	required

Returns:

Name	Type	Description
OK	TOK	Returns OK if all configurations have been successfully set.
	TOK	Otherwise, raises an error.

Examples:

>>> config_set({"timeout": "1000", "maxmemory": "1GB"})
    OK

Source code in doc-gen/valkey-glide/python/glide-sync/glide_sync/sync_commands/standalone_commands.py

def config_set(self, parameters_map: Mapping[TEncodable, TEncodable]) -> TOK:
    """
    Set configuration parameters to the specified values.
    Starting from server version 7, command supports multiple parameters.

    See [valkey.io](https://valkey.io/commands/config-set/) for details.

    Args:
        parameters_map (Mapping[TEncodable, TEncodable]): A map consisting of configuration
            parameters and their respective values to set.

    Returns:
        OK: Returns OK if all configurations have been successfully set.

        Otherwise, raises an error.

    Examples:
        >>> config_set({"timeout": "1000", "maxmemory": "1GB"})
            OK
    """
    parameters: List[TEncodable] = []
    for pair in parameters_map.items():
        parameters.extend(pair)
    return cast(TOK, self._execute_command(RequestType.ConfigSet, parameters))

client_getname()

Get the name of the primary's connection.

See valkey.io for more details.

Returns:

Type	Description
Optional[bytes]	Optional[bytes]: Returns the name of the client connection as a byte string if a name is set.
Optional[bytes]	None if no name is assigned.

Examples:

>>> client.client_getname()
    b'Connection Name'

Source code in doc-gen/valkey-glide/python/glide-sync/glide_sync/sync_commands/standalone_commands.py

def client_getname(self) -> Optional[bytes]:
    """
    Get the name of the primary's connection.

    See [valkey.io](https://valkey.io/commands/client-getname/) for more details.

    Returns:
        Optional[bytes]: Returns the name of the client connection as a byte string if a name is set.

        `None` if no name is assigned.

    Examples:
        >>> client.client_getname()
            b'Connection Name'
    """
    return cast(
        Optional[bytes], self._execute_command(RequestType.ClientGetName, [])
    )

client_tracking_info()

Returns information about the current client connection's use of the server assisted client side caching feature.

See valkey.io for more details.

Returns:

Name	Type	Description
ClientTrackingInfo	ClientTrackingInfo	The tracking info for the client.

Examples:

>>> info = client.client_tracking_info()
>>> print(info.flags)
    {'off'}
>>> print(info.redirect)
    -1

Source code in doc-gen/valkey-glide/python/glide-sync/glide_sync/sync_commands/standalone_commands.py

def client_tracking_info(self) -> ClientTrackingInfo:
    """
    Returns information about the current client connection's use
    of the server assisted client side caching feature.

    See [valkey.io](https://valkey.io/commands/client-trackinginfo/) for more details.

    Returns:
        ClientTrackingInfo: The tracking info for the client.

    Examples:
        >>> info = client.client_tracking_info()
        >>> print(info.flags)
            {'off'}
        >>> print(info.redirect)
            -1
    """
    return _parse_client_tracking_info(
        cast(
            Mapping,
            self._execute_command(RequestType.ClientTrackingInfo, []),
        ),
    )

dbsize()

Returns the number of keys in the currently selected database.

See valkey.io for more details.

Returns:

Name	Type	Description
int	int	The number of keys in the currently selected database.

Examples:

>>> client.dbsize()
    10  # Indicates there are 10 keys in the current database.

Source code in doc-gen/valkey-glide/python/glide-sync/glide_sync/sync_commands/standalone_commands.py

def dbsize(self) -> int:
    """
    Returns the number of keys in the currently selected database.

    See [valkey.io](https://valkey.io/commands/dbsize) for more details.

    Returns:
        int: The number of keys in the currently selected database.

    Examples:
        >>> client.dbsize()
            10  # Indicates there are 10 keys in the current database.
    """
    return cast(int, self._execute_command(RequestType.DBSize, []))

echo(message)

Echoes the provided message back.

See valkey.io for more details.

Parameters:

Name	Type	Description	Default
message	TEncodable	The message to be echoed back.	required

Returns:

Name	Type	Description
bytes	bytes	The provided message.

Examples:

>>> client.echo("Valkey GLIDE")
    b'Valkey GLIDE'

Source code in doc-gen/valkey-glide/python/glide-sync/glide_sync/sync_commands/standalone_commands.py

def echo(self, message: TEncodable) -> bytes:
    """
    Echoes the provided `message` back.

    See [valkey.io](https://valkey.io/commands/echo) for more details.

    Args:
        message (TEncodable): The message to be echoed back.

    Returns:
        bytes: The provided `message`.

    Examples:
        >>> client.echo("Valkey GLIDE")
            b'Valkey GLIDE'
    """
    return cast(bytes, self._execute_command(RequestType.Echo, [message]))

function_load(library_code, replace=False)

Loads a library to Valkey.

See valkey.io for more details.

Parameters:

Name	Type	Description	Default
library_code	TEncodable	The source code that implements the library.	required
replace	bool	Whether the given library should overwrite a library with the same name if it already exists.	False

Returns:

Name	Type	Description
bytes	bytes	The library name that was loaded.

Examples:

>>> code = "#!lua name=mylib \n redis.register_function('myfunc', function(keys, args) return args[1] end)"
>>> client.function_load(code, True)
    b"mylib"

Since: Valkey 7.0.0.

Source code in doc-gen/valkey-glide/python/glide-sync/glide_sync/sync_commands/standalone_commands.py

def function_load(self, library_code: TEncodable, replace: bool = False) -> bytes:
    """
    Loads a library to Valkey.

    See [valkey.io](https://valkey.io/commands/function-load/) for more details.

    Args:
        library_code (TEncodable): The source code that implements the library.
        replace (bool): Whether the given library should overwrite a library with the same name if
            it already exists.

    Returns:
        bytes: The library name that was loaded.

    Examples:
        >>> code = "#!lua name=mylib \\n redis.register_function('myfunc', function(keys, args) return args[1] end)"
        >>> client.function_load(code, True)
            b"mylib"

    Since: Valkey 7.0.0.
    """
    return cast(
        bytes,
        self._execute_command(
            RequestType.FunctionLoad,
            ["REPLACE", library_code] if replace else [library_code],
        ),
    )

function_list(library_name_pattern=None, with_code=False)

Returns information about the functions and libraries.

See valkey.io for more details.

Parameters:

Name	Type	Description	Default
library_name_pattern	Optional[TEncodable]	A wildcard pattern for matching library names.	None
with_code	bool	Specifies whether to request the library code from the server or not.	False

Returns:

Name	Type	Description
TFunctionListResponse	TFunctionListResponse	Info about all or
	TFunctionListResponse	selected libraries and their functions.

Examples:

>>> response = client.function_list("myLib?_backup", True)
    [{
        b"library_name": b"myLib5_backup",
        b"engine": b"LUA",
        b"functions": [{
            b"name": b"myfunc",
            b"description": None,
            b"flags": {b"no-writes"},
        }],
        b"library_code": b"#!lua name=mylib \n sever.register_function('myfunc', function(keys, args) "                                      b"return args[1] end)"
    }]

Since: Valkey 7.0.0.

Source code in doc-gen/valkey-glide/python/glide-sync/glide_sync/sync_commands/standalone_commands.py

def function_list(
    self, library_name_pattern: Optional[TEncodable] = None, with_code: bool = False
) -> TFunctionListResponse:
    """
    Returns information about the functions and libraries.

    See [valkey.io](https://valkey.io/commands/function-list/) for more details.

    Args:
        library_name_pattern (Optional[TEncodable]):  A wildcard pattern for matching library names.
        with_code (bool): Specifies whether to request the library code from the server or not.

    Returns:
        TFunctionListResponse: Info about all or
        selected libraries and their functions.

    Examples:
        >>> response = client.function_list("myLib?_backup", True)
            [{
                b"library_name": b"myLib5_backup",
                b"engine": b"LUA",
                b"functions": [{
                    b"name": b"myfunc",
                    b"description": None,
                    b"flags": {b"no-writes"},
                }],
                b"library_code": b"#!lua name=mylib \\n sever.register_function('myfunc', function(keys, args) " \
                                 b"return args[1] end)"
            }]

    Since: Valkey 7.0.0.
    """
    args = []
    if library_name_pattern is not None:
        args.extend(["LIBRARYNAME", library_name_pattern])
    if with_code:
        args.append("WITHCODE")
    return cast(
        TFunctionListResponse,
        self._execute_command(
            RequestType.FunctionList,
            args,
        ),
    )

function_flush(mode=None)

Deletes all function libraries.

See valkey.io for more details.

Parameters:

Name	Type	Description	Default
mode	Optional[FlushMode]	The flushing mode, could be either SYNC or ASYNC.	None

Returns:

Name	Type	Description
TOK	TOK	A simple OK.

Examples:

>>> client.function_flush(FlushMode.SYNC)
    "OK"

Since: Valkey 7.0.0.

Source code in doc-gen/valkey-glide/python/glide-sync/glide_sync/sync_commands/standalone_commands.py

def function_flush(self, mode: Optional[FlushMode] = None) -> TOK:
    """
    Deletes all function libraries.

    See [valkey.io](https://valkey.io/commands/function-flush/) for more details.

    Args:
        mode (Optional[FlushMode]): The flushing mode, could be either `SYNC` or `ASYNC`.

    Returns:
        TOK: A simple `OK`.

    Examples:
        >>> client.function_flush(FlushMode.SYNC)
            "OK"

    Since: Valkey 7.0.0.
    """
    return cast(
        TOK,
        self._execute_command(
            RequestType.FunctionFlush,
            [mode.value] if mode else [],
        ),
    )

function_delete(library_name)

Deletes a library and all its functions.

See valkey.io for more details.

Parameters:

Name	Type	Description	Default
library_code	TEncodable	The library name to delete	required

Returns:

Name	Type	Description
TOK	TOK	A simple OK.

Examples:

>>> client.function_delete("my_lib")
    "OK"

Since: Valkey 7.0.0.

Source code in doc-gen/valkey-glide/python/glide-sync/glide_sync/sync_commands/standalone_commands.py

def function_delete(self, library_name: TEncodable) -> TOK:
    """
    Deletes a library and all its functions.

    See [valkey.io](https://valkey.io/commands/function-delete/) for more details.

    Args:
        library_code (TEncodable): The library name to delete

    Returns:
        TOK: A simple `OK`.

    Examples:
        >>> client.function_delete("my_lib")
            "OK"

    Since: Valkey 7.0.0.
    """
    return cast(
        TOK,
        self._execute_command(
            RequestType.FunctionDelete,
            [library_name],
        ),
    )

function_kill()

Kills a function that is currently executing. This command only terminates read-only functions.

FUNCTION KILL runs on all nodes of the server, including primary and replicas.

See valkey.io for more details.

Returns:

Name	Type	Description
TOK	TOK	A simple OK.

Examples:

>>> client.function_kill()
    "OK"

Since: Valkey 7.0.0.

Source code in doc-gen/valkey-glide/python/glide-sync/glide_sync/sync_commands/standalone_commands.py

def function_kill(self) -> TOK:
    """
    Kills a function that is currently executing.
    This command only terminates read-only functions.

    FUNCTION KILL runs on all nodes of the server, including primary and replicas.

    See [valkey.io](https://valkey.io/commands/function-kill/) for more details.

    Returns:
        TOK: A simple `OK`.

    Examples:
        >>> client.function_kill()
            "OK"

    Since: Valkey 7.0.0.
    """
    return cast(
        TOK,
        self._execute_command(RequestType.FunctionKill, []),
    )

function_stats()

Returns information about the function that's currently running and information about the available execution engines.

FUNCTION STATS runs on all nodes of the server, including primary and replicas. The response includes a mapping from node address to the command response for that node.

See valkey.io for more details

Returns:

Name	Type	Description
TFunctionStatsFullResponse	TFunctionStatsFullResponse	A Map where the key is the node address and the value is a Map of two keys: running_script with information about the running script. engines with information about available engines and their stats.
	TFunctionStatsFullResponse	See example for more details.

Examples:

>>> client.function_stats()
    {b"addr": {                         # Response from the master node
        b'running_script': {
            b'name': b'foo',
            b'command': [b'FCALL', b'foo', b'0', b'hello'],
            b'duration_ms': 7758
        },
        b'engines': {
            b'LUA': {
                b'libraries_count': 1,
                b'functions_count': 1,
            }
        }
    },
    b"addr2": {                         # Response from a replica
        b'running_script': None,
        b"engines": {
            b'LUA': {
                b'libraries_count': 1,
                b'functions_count': 1,
            }
        }
    }}

Since: Valkey version 7.0.0.

Source code in doc-gen/valkey-glide/python/glide-sync/glide_sync/sync_commands/standalone_commands.py

def function_stats(self) -> TFunctionStatsFullResponse:
    """
    Returns information about the function that's currently running and information about the
    available execution engines.

    FUNCTION STATS runs on all nodes of the server, including primary and replicas.
    The response includes a mapping from node address to the command response for that node.

    See [valkey.io](https://valkey.io/commands/function-stats/) for more details

    Returns:
        TFunctionStatsFullResponse: A Map where the key is the node address and the value is a Map of two keys:

            - `running_script` with information about the running script.
            - `engines` with information about available engines and their stats.

        See example for more details.

    Examples:
        >>> client.function_stats()
            {b"addr": {                         # Response from the master node
                b'running_script': {
                    b'name': b'foo',
                    b'command': [b'FCALL', b'foo', b'0', b'hello'],
                    b'duration_ms': 7758
                },
                b'engines': {
                    b'LUA': {
                        b'libraries_count': 1,
                        b'functions_count': 1,
                    }
                }
            },
            b"addr2": {                         # Response from a replica
                b'running_script': None,
                b"engines": {
                    b'LUA': {
                        b'libraries_count': 1,
                        b'functions_count': 1,
                    }
                }
            }}

    Since: Valkey version 7.0.0.
    """
    return cast(
        TFunctionStatsFullResponse,
        self._execute_command(RequestType.FunctionStats, []),
    )

function_dump()

Returns the serialized payload of all loaded libraries.

See valkey.io for more details.

Returns:

Name	Type	Description
bytes	bytes	The serialized payload of all loaded libraries.

Examples:

>>> payload = client.function_dump()
    # The serialized payload of all loaded libraries. This response can
    # be used to restore loaded functions on any Valkey instance.
>>> client.function_restore(payload)
    "OK" # The serialized dump response was used to restore the libraries.

Since: Valkey 7.0.0.

Source code in doc-gen/valkey-glide/python/glide-sync/glide_sync/sync_commands/standalone_commands.py

def function_dump(self) -> bytes:
    """
    Returns the serialized payload of all loaded libraries.

    See [valkey.io](https://valkey.io/commands/function-dump/) for more details.

    Returns:
        bytes: The serialized payload of all loaded libraries.

    Examples:
        >>> payload = client.function_dump()
            # The serialized payload of all loaded libraries. This response can
            # be used to restore loaded functions on any Valkey instance.
        >>> client.function_restore(payload)
            "OK" # The serialized dump response was used to restore the libraries.

    Since: Valkey 7.0.0.
    """
    return cast(bytes, self._execute_command(RequestType.FunctionDump, []))

function_restore(payload, policy=None)

Restores libraries from the serialized payload returned by the function_dump command.

See valkey.io for more details.

Parameters:

Name	Type	Description	Default
payload	TEncodable	The serialized data from the function_dump command.	required
policy	Optional[FunctionRestorePolicy]	A policy for handling existing libraries.	None

Returns:

Name	Type	Description
TOK	TOK	OK.

Examples:

>>> payload = client.function_dump()
    # The serialized payload of all loaded libraries. This response can
    # be used to restore loaded functions on any Valkey instance.
>>> client.function_restore(payload)
    "OK" # The serialized dump response was used to restore the libraries.
>>> client.function_restore(payload, FunctionRestorePolicy.FLUSH)
    "OK" # The serialized dump response was used to restore the libraries with the specified policy.

Since: Valkey 7.0.0.

Source code in doc-gen/valkey-glide/python/glide-sync/glide_sync/sync_commands/standalone_commands.py

def function_restore(
    self, payload: TEncodable, policy: Optional[FunctionRestorePolicy] = None
) -> TOK:
    """
    Restores libraries from the serialized payload returned by the `function_dump` command.

    See [valkey.io](https://valkey.io/commands/function-restore/) for more details.

    Args:
        payload (TEncodable): The serialized data from the `function_dump` command.
        policy (Optional[FunctionRestorePolicy]): A policy for handling existing libraries.

    Returns:
        TOK: OK.

    Examples:
        >>> payload = client.function_dump()
            # The serialized payload of all loaded libraries. This response can
            # be used to restore loaded functions on any Valkey instance.
        >>> client.function_restore(payload)
            "OK" # The serialized dump response was used to restore the libraries.
        >>> client.function_restore(payload, FunctionRestorePolicy.FLUSH)
            "OK" # The serialized dump response was used to restore the libraries with the specified policy.

    Since: Valkey 7.0.0.
    """
    args: List[TEncodable] = [payload]
    if policy is not None:
        args.append(policy.value)

    return cast(TOK, self._execute_command(RequestType.FunctionRestore, args))

time()

Returns the server time.

See valkey.io for more details.

Returns:

Type	Description
List[bytes]	List[bytes]: The current server time as a two items array:
List[bytes]	A Unix timestamp and the amount of microseconds already elapsed in the current second.
List[bytes]	The returned array is in a [Unix timestamp, Microseconds already elapsed] format.

Examples:

>>> client.time()
    [b'1710925775', b'913580']

Source code in doc-gen/valkey-glide/python/glide-sync/glide_sync/sync_commands/standalone_commands.py

def time(self) -> List[bytes]:
    """
    Returns the server time.

    See [valkey.io](https://valkey.io/commands/time/) for more details.

    Returns:
        List[bytes]:  The current server time as a two items `array`:
        A Unix timestamp and the amount of microseconds already elapsed in the current second.
        The returned `array` is in a [Unix timestamp, Microseconds already elapsed] format.

    Examples:
        >>> client.time()
            [b'1710925775', b'913580']
    """
    return cast(
        List[bytes],
        self._execute_command(RequestType.Time, []),
    )

lastsave()

Returns the Unix time of the last DB save timestamp or startup timestamp if no save was made since then.

See valkey.io for more details.

Returns:

Name	Type	Description
int	int	The Unix time of the last successful DB save.

Examples:

>>> client.lastsave()
    1710925775  # Unix time of the last DB save

Source code in doc-gen/valkey-glide/python/glide-sync/glide_sync/sync_commands/standalone_commands.py

def lastsave(self) -> int:
    """
    Returns the Unix time of the last DB save timestamp or startup timestamp if no save was made since then.

    See [valkey.io](https://valkey.io/commands/lastsave) for more details.

    Returns:
        int: The Unix time of the last successful DB save.

    Examples:
        >>> client.lastsave()
            1710925775  # Unix time of the last DB save
    """
    return cast(
        int,
        self._execute_command(RequestType.LastSave, []),
    )

save()

Synchronously saves the dataset to disk.

See valkey.io for more details.

Returns:

Name	Type	Description
TOK	TOK	A simple OK response.

Examples:

>>> client.save()
    OK

Source code in doc-gen/valkey-glide/python/glide-sync/glide_sync/sync_commands/standalone_commands.py

def save(self) -> TOK:
    """
    Synchronously saves the dataset to disk.

    See [valkey.io](https://valkey.io/commands/save) for more details.

    Returns:
        TOK: A simple OK response.

    Examples:
        >>> client.save()
            OK
    """
    return cast(
        TOK,
        self._execute_command(RequestType.Save, []),
    )

bgsave()

Asynchronously saves the dataset to disk in the background.

See valkey.io for more details.

Returns:

Name	Type	Description
str	str	A non-empty status string.

Examples:

>>> client.bgsave()
    "Background saving started"

Source code in doc-gen/valkey-glide/python/glide-sync/glide_sync/sync_commands/standalone_commands.py

def bgsave(self) -> str:
    """
    Asynchronously saves the dataset to disk in the background.

    See [valkey.io](https://valkey.io/commands/bgsave) for more details.

    Returns:
        str: A non-empty status string.

    Examples:
        >>> client.bgsave()
            "Background saving started"
    """
    return cast(
        str,
        self._execute_command(RequestType.BgSave, []),
    )

bgsave_schedule()

Schedules a background save of the database.

See valkey.io for more details.

Returns:

Name	Type	Description
str	str	A non-empty status string.

Examples:

>>> client.bgsave_schedule()
    "Background saving scheduled"

Source code in doc-gen/valkey-glide/python/glide-sync/glide_sync/sync_commands/standalone_commands.py

def bgsave_schedule(self) -> str:
    """
    Schedules a background save of the database.

    See [valkey.io](https://valkey.io/commands/bgsave) for more details.

    Returns:
        str: A non-empty status string.

    Examples:
        >>> client.bgsave_schedule()
            "Background saving scheduled"
    """
    return cast(
        str,
        self._execute_command(RequestType.BgSave, ["SCHEDULE"]),
    )

bgsave_cancel()

Aborts all in-progress and scheduled background saves.

See valkey.io for more details.

Note

Since: Valkey 8.1.

Returns:

Name	Type	Description
str	str	A non-empty status string.

Examples:

>>> client.bgsave_cancel()
    "Background saving cancelled"

Source code in doc-gen/valkey-glide/python/glide-sync/glide_sync/sync_commands/standalone_commands.py

def bgsave_cancel(self) -> str:
    """
    Aborts all in-progress and scheduled background saves.

    See [valkey.io](https://valkey.io/commands/bgsave) for more details.

    Note:
        Since: Valkey 8.1.

    Returns:
        str: A non-empty status string.

    Examples:
        >>> client.bgsave_cancel()
            "Background saving cancelled"
    """
    return cast(
        str,
        self._execute_command(RequestType.BgSave, ["CANCEL"]),
    )

bgrewriteaof()

Initiates a background rewrite of the append-only file (AOF).

See valkey.io for more details.

Returns:

Name	Type	Description
str	str	A non-empty status string.

Examples:

>>> client.bgrewriteaof()
    "Background append only file rewriting started"

Source code in doc-gen/valkey-glide/python/glide-sync/glide_sync/sync_commands/standalone_commands.py

def bgrewriteaof(self) -> str:
    """
    Initiates a background rewrite of the append-only file (AOF).

    See [valkey.io](https://valkey.io/commands/bgrewriteaof) for more details.

    Returns:
        str: A non-empty status string.

    Examples:
        >>> client.bgrewriteaof()
            "Background append only file rewriting started"
    """
    return cast(
        str,
        self._execute_command(RequestType.BgRewriteAof, []),
    )

publish(message, channel)

Publish a message on pubsub channel.

See valkey.io for more details.

Parameters:

Name	Type	Description	Default
message	TEncodable	Message to publish	required
channel	TEncodable	Channel to publish the message on.	required

Returns:

Name	Type	Description
int	int	Number of subscriptions in primary node that received the message.
	int	Note: this value does not include subscriptions that configured on replicas.

Examples:

>>> client.publish("Hi all!", "global-channel")
    1 # This message was posted to 1 subscription which is configured on primary node

Source code in doc-gen/valkey-glide/python/glide-sync/glide_sync/sync_commands/standalone_commands.py

def publish(self, message: TEncodable, channel: TEncodable) -> int:
    """
    Publish a message on pubsub channel.

    See [valkey.io](https://valkey.io/commands/publish) for more details.

    Args:
        message (TEncodable): Message to publish
        channel (TEncodable): Channel to publish the message on.

    Returns:
        int: Number of subscriptions in primary node that received the message.

        **Note:** this value does not include subscriptions that configured on replicas.

    Examples:
        >>> client.publish("Hi all!", "global-channel")
            1 # This message was posted to 1 subscription which is configured on primary node
    """
    return cast(int, self._execute_command(RequestType.Publish, [channel, message]))

flushall(flush_mode=None)

Deletes all the keys of all the existing databases. This command never fails.

See valkey.io for more details.

Parameters:

Name	Type	Description	Default
flush_mode	Optional[FlushMode]	The flushing mode, could be either SYNC or ASYNC.	None

Returns:

Name	Type	Description
TOK	TOK	A simple OK response.

Examples:

>>> client.flushall(FlushMode.ASYNC)
    OK  # This command never fails.

Source code in doc-gen/valkey-glide/python/glide-sync/glide_sync/sync_commands/standalone_commands.py

def flushall(self, flush_mode: Optional[FlushMode] = None) -> TOK:
    """
    Deletes all the keys of all the existing databases. This command never fails.

    See [valkey.io](https://valkey.io/commands/flushall) for more details.

    Args:
        flush_mode (Optional[FlushMode]): The flushing mode, could be either `SYNC` or `ASYNC`.

    Returns:
        TOK: A simple OK response.

    Examples:
        >>> client.flushall(FlushMode.ASYNC)
            OK  # This command never fails.
    """
    args: List[TEncodable] = []
    if flush_mode is not None:
        args.append(flush_mode.value)

    return cast(
        TOK,
        self._execute_command(RequestType.FlushAll, args),
    )

flushdb(flush_mode=None)

Deletes all the keys of the currently selected database. This command never fails.

See valkey.io for more details.

Parameters:

Name	Type	Description	Default
flush_mode	Optional[FlushMode]	The flushing mode, could be either SYNC or ASYNC.	None

Returns:

Name	Type	Description
TOK	TOK	A simple OK response.

Examples:

>>> client.flushdb()
    OK  # The keys of the currently selected database were deleted.
>>> client.flushdb(FlushMode.ASYNC)
    OK  # The keys of the currently selected database were deleted asynchronously.

Source code in doc-gen/valkey-glide/python/glide-sync/glide_sync/sync_commands/standalone_commands.py

def flushdb(self, flush_mode: Optional[FlushMode] = None) -> TOK:
    """
    Deletes all the keys of the currently selected database. This command never fails.

    See [valkey.io](https://valkey.io/commands/flushdb) for more details.

    Args:
        flush_mode (Optional[FlushMode]): The flushing mode, could be either `SYNC` or `ASYNC`.

    Returns:
        TOK: A simple OK response.

    Examples:
        >>> client.flushdb()
            OK  # The keys of the currently selected database were deleted.
        >>> client.flushdb(FlushMode.ASYNC)
            OK  # The keys of the currently selected database were deleted asynchronously.
    """
    args: List[TEncodable] = []
    if flush_mode is not None:
        args.append(flush_mode.value)

    return cast(
        TOK,
        self._execute_command(RequestType.FlushDB, args),
    )

copy(source, destination, destinationDB=None, replace=None)

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 for more details.

Parameters:

Name	Type	Description	Default
source	TEncodable	The key to the source value.	required
destination	TEncodable	The key where the value should be copied to.	required
destinationDB	Optional[int]	The alternative logical database index for the destination key.	None
replace	Optional[bool]	If the destination key should be removed before copying the value to it.	None

Returns:

Name	Type	Description
bool	bool	True if the source was copied.
	bool	Otherwise, return False.

Examples:

>>> client.set("source", "sheep")
>>> client.copy(b"source", b"destination", 1, False)
    True # Source was copied
>>> client.select(1)
>>> client.get("destination")
    b"sheep"

Since: Valkey version 6.2.0.

Source code in doc-gen/valkey-glide/python/glide-sync/glide_sync/sync_commands/standalone_commands.py

def copy(
    self,
    source: TEncodable,
    destination: TEncodable,
    destinationDB: Optional[int] = None,
    replace: Optional[bool] = None,
) -> bool:
    """
    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.

    Args:
        source (TEncodable): The key to the source value.
        destination (TEncodable): The key where the value should be copied to.
        destinationDB (Optional[int]): The alternative logical database index for the destination key.
        replace (Optional[bool]): If the destination key should be removed before copying the value to it.

    Returns:
        bool: True if the source was copied.

        Otherwise, return False.

    Examples:
        >>> client.set("source", "sheep")
        >>> client.copy(b"source", b"destination", 1, False)
            True # Source was copied
        >>> client.select(1)
        >>> client.get("destination")
            b"sheep"

    Since: Valkey version 6.2.0.
    """
    args: List[TEncodable] = [source, destination]
    if destinationDB is not None:
        args.extend(["DB", str(destinationDB)])
    if replace is True:
        args.append("REPLACE")
    return cast(
        bool,
        self._execute_command(RequestType.Copy, args),
    )

lolwut(version=None, parameters=None)

Displays a piece of generative computer art and the Valkey version.

See valkey.io for more details.

Parameters:

Name	Type	Description	Default
version	Optional[int]	Version of computer art to generate.	None
parameters	Optional[List[int]]	Additional set of arguments in order to change the output: For version 5, those are length of the line, number of squares per row, and number of squares per column. For version 6, those are number of columns and number of lines.	None

Returns:

Name	Type	Description
bytes	bytes	A piece of generative computer art along with the current Valkey version.

Examples:

>>> client.lolwut(6, [40, 20]);
    b"Redis ver. 7.2.3" # Indicates the current Valkey version
>>> client.lolwut(5, [30, 5, 5]);
    b"Redis ver. 7.2.3" # Indicates the current Valkey version

Source code in doc-gen/valkey-glide/python/glide-sync/glide_sync/sync_commands/standalone_commands.py

def lolwut(
    self,
    version: Optional[int] = None,
    parameters: Optional[List[int]] = None,
) -> bytes:
    """
    Displays a piece of generative computer art and the Valkey version.

    See [valkey.io](https://valkey.io/commands/lolwut) for more details.

    Args:
        version (Optional[int]): Version of computer art to generate.
        parameters (Optional[List[int]]): Additional set of arguments in order to change the output:

            - For version `5`, those are length of the line, number of squares per row, and number of squares per column.
            - For version `6`, those are number of columns and number of lines.

    Returns:
        bytes: A piece of generative computer art along with the current Valkey version.

    Examples:
        >>> client.lolwut(6, [40, 20]);
            b"Redis ver. 7.2.3" # Indicates the current Valkey version
        >>> client.lolwut(5, [30, 5, 5]);
            b"Redis ver. 7.2.3" # Indicates the current Valkey version
    """
    args: List[TEncodable] = []
    if version is not None:
        args.extend(["VERSION", str(version)])
    if parameters:
        for var in parameters:
            args.append(str(var))
    return cast(
        bytes,
        self._execute_command(RequestType.Lolwut, args),
    )

random_key()

Returns a random existing key name from the currently selected database.

See valkey.io for more details.

Returns:

Type	Description
Optional[bytes]	Optional[bytes]: A random existing key name from the currently selected database.

Examples:

>>> client.random_key()
    b"random_key_name"  # "random_key_name" is a random existing key name from the currently selected database.

Source code in doc-gen/valkey-glide/python/glide-sync/glide_sync/sync_commands/standalone_commands.py

def random_key(self) -> Optional[bytes]:
    """
    Returns a random existing key name from the currently selected database.

    See [valkey.io](https://valkey.io/commands/randomkey) for more details.

    Returns:
        Optional[bytes]: A random existing key name from the currently selected database.

    Examples:
        >>> client.random_key()
            b"random_key_name"  # "random_key_name" is a random existing key name from the currently selected database.
    """
    return cast(
        Optional[bytes],
        self._execute_command(RequestType.RandomKey, []),
    )

wait(numreplicas, timeout)

Blocks the current client until all the previous write commands are successfully transferred and acknowledged by at least numreplicas of replicas. If timeout is reached, the command returns even if the specified number of replicas were not yet reached.

See valkey.io for more details.

Parameters:

Name	Type	Description	Default
numreplicas	int	The number of replicas to reach.	required
timeout	int	The timeout value specified in milliseconds. A value of 0 will block indefinitely.	required

Returns:

Name	Type	Description
int	int	The number of replicas reached by all the writes performed in the context of the current connection.

Examples:

>>> client.set("key", "value");
>>> client.wait(1, 1000);
# return 1 when a replica is reached or 0 if 1000ms is reached.

Source code in doc-gen/valkey-glide/python/glide-sync/glide_sync/sync_commands/standalone_commands.py

def wait(
    self,
    numreplicas: int,
    timeout: int,
) -> int:
    """
    Blocks the current client until all the previous write commands are successfully transferred
    and acknowledged by at least `numreplicas` of replicas. If `timeout` is
    reached, the command returns even if the specified number of replicas were not yet reached.

    See [valkey.io](https://valkey.io/commands/wait) for more details.

    Args:
        numreplicas (int): The number of replicas to reach.
        timeout (int): The timeout value specified in milliseconds. A value of 0 will block indefinitely.

    Returns:
        int: The number of replicas reached by all the writes performed in the context of the current connection.

    Examples:
        >>> client.set("key", "value");
        >>> client.wait(1, 1000);
        # return 1 when a replica is reached or 0 if 1000ms is reached.
    """
    args: List[TEncodable] = [str(numreplicas), str(timeout)]
    return cast(
        int,
        self._execute_command(RequestType.Wait, args),
    )

unwatch()

Flushes all the previously watched keys for an atomic batch (Transaction). Executing a transaction will automatically flush all previously watched keys.

See valkey.io for more details.

Returns:

Name	Type	Description
TOK	TOK	A simple "OK" response.

Examples:

>>> client.unwatch()
    'OK'

Source code in doc-gen/valkey-glide/python/glide-sync/glide_sync/sync_commands/standalone_commands.py

def unwatch(self) -> TOK:
    """
    Flushes all the previously watched keys for an atomic batch (Transaction). Executing a transaction will
    automatically flush all previously watched keys.

    See [valkey.io](https://valkey.io/commands/unwatch) for more details.

    Returns:
        TOK: A simple "OK" response.

    Examples:
        >>> client.unwatch()
            'OK'
    """
    return cast(
        TOK,
        self._execute_command(RequestType.UnWatch, []),
    )

script_exists(sha1s)

Check existence of scripts in the script cache by their SHA1 digest.

See valkey.io for more details.

Parameters:

Name	Type	Description	Default
sha1s	List[TEncodable]	List of SHA1 digests of the scripts to check.	required

Returns:

Type	Description
List[bool]	List[bool]: A list of boolean values indicating the existence of each script.

Examples:

>>> client.script_exists(["sha1_digest1", "sha1_digest2"])
    [True, False]

Source code in doc-gen/valkey-glide/python/glide-sync/glide_sync/sync_commands/standalone_commands.py

def script_exists(self, sha1s: List[TEncodable]) -> List[bool]:
    """
    Check existence of scripts in the script cache by their SHA1 digest.

    See [valkey.io](https://valkey.io/commands/script-exists) for more details.

    Args:
        sha1s (List[TEncodable]): List of SHA1 digests of the scripts to check.

    Returns:
        List[bool]: A list of boolean values indicating the existence of each script.

    Examples:
        >>> client.script_exists(["sha1_digest1", "sha1_digest2"])
            [True, False]
    """
    return cast(List[bool], self._execute_command(RequestType.ScriptExists, sha1s))

script_flush(mode=None)

Flush the Lua scripts cache.

See valkey.io for more details.

Parameters:

Name	Type	Description	Default
mode	Optional[FlushMode]	The flushing mode, could be either SYNC or ASYNC.	None

Returns:

Name	Type	Description
TOK	TOK	A simple OK response.

Examples:

>>> client.script_flush()
    "OK"

>>> client.script_flush(FlushMode.ASYNC)
    "OK"

Source code in doc-gen/valkey-glide/python/glide-sync/glide_sync/sync_commands/standalone_commands.py

def script_flush(self, mode: Optional[FlushMode] = None) -> TOK:
    """
    Flush the Lua scripts cache.

    See [valkey.io](https://valkey.io/commands/script-flush) for more details.

    Args:
        mode (Optional[FlushMode]): The flushing mode, could be either `SYNC` or `ASYNC`.

    Returns:
        TOK: A simple `OK` response.

    Examples:
        >>> client.script_flush()
            "OK"

        >>> client.script_flush(FlushMode.ASYNC)
            "OK"
    """

    return cast(
        TOK,
        self._execute_command(
            RequestType.ScriptFlush, [mode.value] if mode else []
        ),
    )

script_kill()

Kill the currently executing Lua script, assuming no write operation was yet performed by the script.

See valkey.io for more details.

Returns:

Name	Type	Description
TOK	TOK	A simple OK response.

Examples:

>>> client.script_kill()
    "OK"

Source code in doc-gen/valkey-glide/python/glide-sync/glide_sync/sync_commands/standalone_commands.py

def script_kill(self) -> TOK:
    """
    Kill the currently executing Lua script, assuming no write operation was yet performed by the script.

    See [valkey.io](https://valkey.io/commands/script-kill) for more details.

    Returns:
        TOK: A simple `OK` response.

    Examples:
        >>> client.script_kill()
            "OK"
    """
    return cast(TOK, self._execute_command(RequestType.ScriptKill, []))

invoke_script(script, keys=None, args=None)

Invokes a Lua script with its keys and arguments. This method simplifies the process of invoking scripts on a the server by using an object that represents a Lua script. The script loading, argument preparation, and execution will all be handled internally. If the script has not already been loaded, it will be loaded automatically using the SCRIPT LOAD command. After that, it will be invoked using the EVALSHA command.

See SCRIPT LOAD and EVALSHA for more details.

Parameters:

Name	Type	Description	Default
script	Script	The Lua script to execute.	required
keys	Optional[List[TEncodable]]	The keys that are used in the script.	None
args	Optional[List[TEncodable]]	The arguments for the script.	None

Returns:

Name	Type	Description
TResult	TResult	a value that depends on the script that was executed.

Examples:

>>> lua_script = Script("return { KEYS[1], ARGV[1] }")
>>> client.invoke_script(lua_script, keys=["foo"], args=["bar"])
    [b"foo", b"bar"]

Source code in doc-gen/valkey-glide/python/glide-sync/glide_sync/sync_commands/standalone_commands.py

def invoke_script(
    self,
    script: Script,
    keys: Optional[List[TEncodable]] = None,
    args: Optional[List[TEncodable]] = None,
) -> TResult:
    """
    Invokes a Lua script with its keys and arguments.
    This method simplifies the process of invoking scripts on a the server by using an object that represents a Lua script.
    The script loading, argument preparation, and execution will all be handled internally.
    If the script has not already been loaded, it will be loaded automatically using the `SCRIPT LOAD` command.
    After that, it will be invoked using the `EVALSHA` command.

    See [SCRIPT LOAD](https://valkey.io/commands/script-load/) and [EVALSHA](https://valkey.io/commands/evalsha/)
    for more details.

    Args:
        script (Script): The Lua script to execute.
        keys (Optional[List[TEncodable]]): The keys that are used in the script.
        args (Optional[List[TEncodable]]): The arguments for the script.

    Returns:
        TResult: a value that depends on the script that was executed.

    Examples:
        >>> lua_script = Script("return { KEYS[1], ARGV[1] }")
        >>> client.invoke_script(lua_script, keys=["foo"], args=["bar"])
            [b"foo", b"bar"]
    """
    return self._execute_script(script.get_hash(), keys, args)

scan(cursor, match=None, count=None, type=None)

Incrementally iterate over a collection of keys. SCAN is a cursor based iterator. This means that at every call of the command, the server returns an updated cursor that the user needs to use as the cursor argument in the next call. An iteration starts when the cursor is set to "0", and terminates when the cursor returned by the server is "0".

A full iteration always retrieves all the elements that were present in the collection from the start to the end of a full iteration. Elements that were not constantly present in the collection during a full iteration, may be returned or not.

See valkey.io for more details.

Parameters:

Name	Type	Description	Default
cursor	TResult	The cursor used for iteration. For the first iteration, the cursor should be set to "0". Using a non-zero cursor in the first iteration, or an invalid cursor at any iteration, will lead to undefined results. Using the same cursor in multiple iterations will, in case nothing changed between the iterations, return the same elements multiple times. If the the db has changed, it may result an undefined behavior.	required
match	Optional[TResult]	A pattern to match keys against.	None
count	Optional[int]	The number of keys to return per iteration. The number of keys returned per iteration is not guaranteed to be the same as the count argument. The argument is used as a hint for the server to know how many "steps" it can use to retrieve the keys. The default value is 10.	None
type	ObjectType	The type of object to scan for.	None

Returns:

Type	Description
List[Union[bytes, List[bytes]]]	List[Union[bytes, List[bytes]]]: A List containing the next cursor value and a list of keys,
List[Union[bytes, List[bytes]]]	formatted as [cursor, [key1, key2, ...]]

Examples:

>>> result = client.scan(b'0')
    print(result) #[b'17', [b'key1', b'key2', b'key3', b'key4', b'key5', b'set1', b'set2', b'set3']]
    first_cursor_result = result[0]
    result = client.scan(first_cursor_result)
    print(result) #[b'349', [b'key4', b'key5', b'set1', b'hash1', b'zset1', b'list1', b'list2',
                            b'list3', b'zset2', b'zset3', b'zset4', b'zset5', b'zset6']]
    result = client.scan(result[0])
    print(result) #[b'0', [b'key6', b'key7']]
>>> result = client.scan(first_cursor_result, match=b'key*', count=2)
    print(result) #[b'6', [b'key4', b'key5']]
>>> result = client.scan("0", type=ObjectType.Set)
    print(result) #[b'362', [b'set1', b'set2', b'set3']]

Source code in doc-gen/valkey-glide/python/glide-sync/glide_sync/sync_commands/standalone_commands.py

def scan(
    self,
    cursor: TEncodable,
    match: Optional[TEncodable] = None,
    count: Optional[int] = None,
    type: Optional[ObjectType] = None,
) -> List[Union[bytes, List[bytes]]]:
    """
    Incrementally iterate over a collection of keys.
    SCAN is a cursor based iterator. This means that at every call of the command,
    the server returns an updated cursor that the user needs to use as the cursor argument in the next call.
    An iteration starts when the cursor is set to "0", and terminates when the cursor returned by the server is "0".

    A full iteration always retrieves all the elements that were present
    in the collection from the start to the end of a full iteration.
    Elements that were not constantly present in the collection during a full iteration, may be returned or not.

    See [valkey.io](https://valkey.io/commands/scan) for more details.

    Args:
        cursor (TResult): The cursor used for iteration. For the first iteration, the cursor should be set to "0".

            - Using a non-zero cursor in the first iteration, or an invalid cursor at any iteration, will lead to
              undefined results.
            - Using the same cursor in multiple iterations will, in case nothing changed between the iterations,
              return the same elements multiple times.
            - If the the db has changed, it may result an undefined behavior.

        match (Optional[TResult]): A pattern to match keys against.
        count (Optional[int]): The number of keys to return per iteration.

            - The number of keys returned per iteration is not guaranteed to be the same as the count argument.
            - The argument is used as a hint for the server to know how many "steps" it can use to retrieve the keys.
            - The default value is 10.

        type (ObjectType): The type of object to scan for.

    Returns:
        List[Union[bytes, List[bytes]]]: A List containing the next cursor value and a list of keys,
        formatted as [cursor, [key1, key2, ...]]

    Examples:
        >>> result = client.scan(b'0')
            print(result) #[b'17', [b'key1', b'key2', b'key3', b'key4', b'key5', b'set1', b'set2', b'set3']]
            first_cursor_result = result[0]
            result = client.scan(first_cursor_result)
            print(result) #[b'349', [b'key4', b'key5', b'set1', b'hash1', b'zset1', b'list1', b'list2',
                                    b'list3', b'zset2', b'zset3', b'zset4', b'zset5', b'zset6']]
            result = client.scan(result[0])
            print(result) #[b'0', [b'key6', b'key7']]
        >>> result = client.scan(first_cursor_result, match=b'key*', count=2)
            print(result) #[b'6', [b'key4', b'key5']]
        >>> result = client.scan("0", type=ObjectType.Set)
            print(result) #[b'362', [b'set1', b'set2', b'set3']]
    """
    args = [cursor]
    if match:
        args.extend(["MATCH", match])
    if count:
        args.extend(["COUNT", str(count)])
    if type:
        args.extend(["TYPE", type.value])
    return cast(
        List[Union[bytes, List[bytes]]],
        self._execute_command(RequestType.Scan, args),
    )

client_pause(timeout, mode=None)

Suspends all clients for the specified timeout.

See valkey.io for more details.

Parameters:

Name	Type	Description	Default
timeout	int	The time in milliseconds to pause clients.	required
mode	Optional[ClientPauseMode]	The pause mode to use.	None

Returns:

Name	Type	Description
TOK	TOK	A simple OK response.

Examples:

>>> client.client_pause(1000)
    OK
>>> client.client_pause(5000, ClientPauseMode.WRITE)
    OK

Source code in doc-gen/valkey-glide/python/glide-sync/glide_sync/sync_commands/standalone_commands.py

def client_pause(self, timeout: int, mode: Optional[ClientPauseMode] = None) -> TOK:
    """
    Suspends all clients for the specified timeout.

    See [valkey.io](https://valkey.io/commands/client-pause/) for more details.

    Args:
        timeout (int): The time in milliseconds to pause clients.
        mode (Optional[ClientPauseMode]): The pause mode to use.

    Returns:
        TOK: A simple OK response.

    Examples:
        >>> client.client_pause(1000)
            OK
        >>> client.client_pause(5000, ClientPauseMode.WRITE)
            OK
    """
    args: List[TEncodable] = [str(timeout)]
    if mode is not None:
        args.append(mode.value)
    return cast(TOK, self._execute_command(RequestType.ClientPause, args))

client_unpause()

Resumes processing commands on all clients.

See valkey.io for more details.

Returns:

Name	Type	Description
TOK	TOK	A simple OK response.

Examples:

>>> client.client_unpause()
    OK

Source code in doc-gen/valkey-glide/python/glide-sync/glide_sync/sync_commands/standalone_commands.py

def client_unpause(self) -> TOK:
    """
    Resumes processing commands on all clients.

    See [valkey.io](https://valkey.io/commands/client-unpause/) for more details.

    Returns:
        TOK: A simple OK response.

    Examples:
        >>> client.client_unpause()
            OK
    """
    return cast(TOK, self._execute_command(RequestType.ClientUnpause, []))

latency_history(event)

Returns the latency spike time series for the specified event.

See valkey.io for details.

Parameters:

Name	Type	Description	Default
event	TEncodable	The name of the latency event (e.g., "command").	required

Returns:

Type	Description
List[LatencyEntry]	List[LatencyEntry]: A list of LatencyEntry for the event, or an empty list if the event doesn't exist.

Examples:

>>> history = client.latency_history("command")
>>> for entry in history:
...     print(f"Time: {entry.time}, Latency: {entry.latency}")

Source code in doc-gen/valkey-glide/python/glide-sync/glide_sync/sync_commands/standalone_commands.py

def latency_history(self, event: TEncodable) -> List[LatencyEntry]:
    """
    Returns the latency spike time series for the specified event.

    See [valkey.io](https://valkey.io/commands/latency-history/) for details.

    Args:
        event (TEncodable): The name of the latency event (e.g., ``"command"``).

    Returns:
        List[LatencyEntry]: A list of LatencyEntry for the event, or an empty list
            if the event doesn't exist.

    Examples:
        >>> history = client.latency_history("command")
        >>> for entry in history:
        ...     print(f"Time: {entry.time}, Latency: {entry.latency}")
    """
    return _parse_latency_history(
        cast(
            List,
            self._execute_command(RequestType.LatencyHistory, [event]),
        ),
    )

latency_latest()

Reports the latest latency events logged by the server.

See valkey.io for details.

Returns:

Type	Description
List[LatencyEventInfo]	List[LatencyEventInfo]: A list of LatencyEventInfo for the latest latency events.

Examples:

>>> latest = client.latency_latest()
>>> for info in latest:
...     print(f"Event: {info.event_name}, Latest: {info.latest_duration}")

Source code in doc-gen/valkey-glide/python/glide-sync/glide_sync/sync_commands/standalone_commands.py

def latency_latest(self) -> List[LatencyEventInfo]:
    """
    Reports the latest latency events logged by the server.

    See [valkey.io](https://valkey.io/commands/latency-latest/) for details.

    Returns:
        List[LatencyEventInfo]: A list of LatencyEventInfo for the latest latency events.

    Examples:
        >>> latest = client.latency_latest()
        >>> for info in latest:
        ...     print(f"Event: {info.event_name}, Latest: {info.latest_duration}")
    """
    return _parse_latency_latest(
        cast(
            List,
            self._execute_command(RequestType.LatencyLatest, []),
        ),
    )

latency_reset(*events)

Resets the latency spike time series for all or specified events. If no events are provided, resets the latency spike time series for all events.

See valkey.io for details.

Parameters:

Name	Type	Description	Default
*events	TEncodable	The event names to reset. If none provided, resets all events.	()

Returns:

Name	Type	Description
int	int	The number of event time series that were reset.

Examples:

>>> client.latency_reset()
    2
>>> client.latency_reset("command")
    1

Source code in doc-gen/valkey-glide/python/glide-sync/glide_sync/sync_commands/standalone_commands.py

def latency_reset(self, *events: TEncodable) -> int:
    """
    Resets the latency spike time series for all or specified events.
    If no events are provided, resets the latency spike time series for all events.

    See [valkey.io](https://valkey.io/commands/latency-reset/) for details.

    Args:
        *events (TEncodable): The event names to reset. If none provided, resets
            all events.

    Returns:
        int: The number of event time series that were reset.

    Examples:
        >>> client.latency_reset()
            2
        >>> client.latency_reset("command")
            1
    """
    return cast(
        int,
        self._execute_command(RequestType.LatencyReset, list(events)),
    )

failover(host=None, port=None, force=False, abort=False, timeout_ms=None)

Starts a coordinated failover from the connected primary to one of its replicas. This is the standalone equivalent of CLUSTER FAILOVER.

See valkey.io for more details.

Parameters:

Name	Type	Description	Default
host	Optional[TEncodable]	The host of the target replica (requires port).	None
port	Optional[int]	The port of the target replica (requires host).	None
force	bool	If True, forces failover after timeout (requires host, port, and timeout_ms).	False
abort	bool	If True, aborts an ongoing failover.	False
timeout_ms	Optional[int]	Timeout in milliseconds.	None

Returns:

Name	Type	Description
TOK	TOK	A simple OK response.

Examples:

>>> client.failover()
    OK
>>> client.failover(abort=True)
    OK

Source code in doc-gen/valkey-glide/python/glide-sync/glide_sync/sync_commands/standalone_commands.py

def failover(
    self,
    host: Optional[TEncodable] = None,
    port: Optional[int] = None,
    force: bool = False,
    abort: bool = False,
    timeout_ms: Optional[int] = None,
) -> TOK:
    """
    Starts a coordinated failover from the connected primary to one of its replicas.
    This is the standalone equivalent of CLUSTER FAILOVER.

    See [valkey.io](https://valkey.io/commands/failover/) for more details.

    Args:
        host (Optional[TEncodable]): The host of the target replica (requires port).
        port (Optional[int]): The port of the target replica (requires host).
        force (bool): If True, forces failover after timeout (requires host, port, and timeout_ms).
        abort (bool): If True, aborts an ongoing failover.
        timeout_ms (Optional[int]): Timeout in milliseconds.

    Returns:
        TOK: A simple OK response.

    Examples:
        >>> client.failover()
            OK
        >>> client.failover(abort=True)
            OK
    """
    args: List[TEncodable] = []
    if (host is None) != (port is None):
        raise ValueError("Both host and port must be provided together")
    if force and (host is None or port is None):
        raise ValueError("force requires host and port to be specified")
    if abort:
        args.append("ABORT")
    else:
        if host is not None and port is not None:
            args.extend(["TO", host, str(port)])
            if force:
                args.append("FORCE")
        if timeout_ms is not None:
            args.extend(["TIMEOUT", str(timeout_ms)])
    return cast(TOK, self._execute_command(RequestType.FailOver, args))

replicaof(host, port)

Makes the server a replica of the specified primary.

See valkey.io for more details.

Parameters:

Name	Type	Description	Default
host	TEncodable	The host of the primary to replicate.	required
port	int	The port of the primary to replicate.	required

Returns:

Name	Type	Description
TOK	TOK	A simple OK response.

Examples:

>>> client.replicaof("localhost", 6379)
    OK

Source code in doc-gen/valkey-glide/python/glide-sync/glide_sync/sync_commands/standalone_commands.py

def replicaof(self, host: TEncodable, port: int) -> TOK:
    """
    Makes the server a replica of the specified primary.

    See [valkey.io](https://valkey.io/commands/replicaof/) for more details.

    Args:
        host (TEncodable): The host of the primary to replicate.
        port (int): The port of the primary to replicate.

    Returns:
        TOK: A simple OK response.

    Examples:
        >>> client.replicaof("localhost", 6379)
            OK
    """
    return cast(
        TOK, self._execute_command(RequestType.ReplicaOf, [host, str(port)])
    )

replicaof_no_one()

Promotes the current server to a primary by stopping replication.

See valkey.io for more details.

Returns:

Name	Type	Description
TOK	TOK	A simple OK response.

Examples:

>>> client.replicaof_no_one()
    OK

Source code in doc-gen/valkey-glide/python/glide-sync/glide_sync/sync_commands/standalone_commands.py

def replicaof_no_one(self) -> TOK:
    """
    Promotes the current server to a primary by stopping replication.

    See [valkey.io](https://valkey.io/commands/replicaof/) for more details.

    Returns:
        TOK: A simple OK response.

    Examples:
        >>> client.replicaof_no_one()
            OK
    """
    return cast(TOK, self._execute_command(RequestType.ReplicaOf, ["NO", "ONE"]))

migrate(host, port, keys, destination_db, timeout, options=None)

Atomically transfers one or more keys from a source Valkey instance to a destination Valkey instance. On success, the key(s) are deleted from the source instance. Pass a list to migrate multiple keys in one command.

See valkey.io for details.

Parameters:

Name	Type	Description	Default
host	str	The host of the destination Valkey instance.	required
port	int	The port of the destination Valkey instance.	required
keys	Union[TEncodable, List[TEncodable]]	The key or list of keys to migrate.	required
destination_db	int	The database index on the destination instance.	required
timeout	int	The maximum idle time in milliseconds for the bulk-transfer.	required
options	Optional[MigrateOptions]	Additional migration options.	None

Returns:

Name	Type	Description
str	str	"OK" on success, or "NOKEY" if no keys were found.

Examples:

>>> client.migrate("127.0.0.1", 6380, "mykey", 0, 5000)
>>> client.migrate("127.0.0.1", 6380, ["key1", "key2"], 0, 5000)

Source code in doc-gen/valkey-glide/python/glide-sync/glide_sync/sync_commands/standalone_commands.py

def migrate(
    self,
    host: str,
    port: int,
    keys: Union[TEncodable, List[TEncodable]],
    destination_db: int,
    timeout: int,
    options: Optional[MigrateOptions] = None,
) -> str:
    """
    Atomically transfers one or more keys from a source Valkey instance to a destination
    Valkey instance. On success, the key(s) are deleted from the source instance.
    Pass a list to migrate multiple keys in one command.

    See [valkey.io](https://valkey.io/commands/migrate/) for details.

    Args:
        host (str): The host of the destination Valkey instance.
        port (int): The port of the destination Valkey instance.
        keys (Union[TEncodable, List[TEncodable]]): The key or list of keys to migrate.
        destination_db (int): The database index on the destination instance.
        timeout (int): The maximum idle time in milliseconds for the bulk-transfer.
        options (Optional[MigrateOptions]): Additional migration options.

    Returns:
        str: "OK" on success, or "NOKEY" if no keys were found.

    Examples:
        >>> client.migrate("127.0.0.1", 6380, "mykey", 0, 5000)
        >>> client.migrate("127.0.0.1", 6380, ["key1", "key2"], 0, 5000)
    """
    if isinstance(keys, list):
        if len(keys) == 0:
            raise ValueError("migrate: 'keys' list must not be empty")
        args: List[TEncodable] = [
            host,
            str(port),
            "",
            str(destination_db),
            str(timeout),
        ]
        if options:
            args.extend(options.to_args())
        args += ["KEYS"] + list(keys)
    else:
        args = [host, str(port), keys, str(destination_db), str(timeout)]
        if options:
            args.extend(options.to_args())
    return cast(
        str,
        self._execute_command(RequestType.Migrate, args),
    )

memory_doctor()

Returns a report about memory problems detected by the server.

See valkey.io for details.

Returns:

Name	Type	Description
str	str	The memory diagnostic report.

Examples:

>>> report = client.memory_doctor()
>>> print("Memory report:", report)

Source code in doc-gen/valkey-glide/python/glide-sync/glide_sync/sync_commands/standalone_commands.py

def memory_doctor(self) -> str:
    """
    Returns a report about memory problems detected by the server.

    See [valkey.io](https://valkey.io/commands/memory-doctor/) for details.

    Returns:
        str: The memory diagnostic report.

    Examples:
        >>> report = client.memory_doctor()
        >>> print("Memory report:", report)
    """
    response = self._execute_command(RequestType.MemoryDoctor, [])
    return cast(bytes, response).decode()

memory_malloc_stats()

Returns the internal statistics of the memory allocator.

See valkey.io for details.

Returns:

Name	Type	Description
str	str	The memory allocator statistics.

Examples:

>>> report = client.memory_malloc_stats()
>>> print("Allocator stats:", report)

Source code in doc-gen/valkey-glide/python/glide-sync/glide_sync/sync_commands/standalone_commands.py

def memory_malloc_stats(self) -> str:
    """
    Returns the internal statistics of the memory allocator.

    See [valkey.io](https://valkey.io/commands/memory-malloc-stats/) for details.

    Returns:
        str: The memory allocator statistics.

    Examples:
        >>> report = client.memory_malloc_stats()
        >>> print("Allocator stats:", report)
    """
    response = self._execute_command(RequestType.MemoryMallocStats, [])
    return cast(bytes, response).decode()

memory_purge()

Asks the server to reclaim memory from the allocator back to the operating system.

See valkey.io for details.

Returns:

Name	Type	Description
TOK	TOK	A simple "OK" response.

Examples:

>>> client.memory_purge()
    "OK"

Source code in doc-gen/valkey-glide/python/glide-sync/glide_sync/sync_commands/standalone_commands.py

def memory_purge(self) -> TOK:
    """
    Asks the server to reclaim memory from the allocator back to the operating system.

    See [valkey.io](https://valkey.io/commands/memory-purge/) for details.

    Returns:
        TOK: A simple "OK" response.

    Examples:
        >>> client.memory_purge()
            "OK"
    """
    return cast(TOK, self._execute_command(RequestType.MemoryPurge, []))

memory_stats()

Returns detailed memory consumption statistics of the server.

See valkey.io for details.

Returns:

Name	Type	Description
MemoryStats	MemoryStats	A MemoryStats object containing detailed memory usage statistics.

Examples:

>>> stats = client.memory_stats()
>>> print(f"Peak allocated: {stats.peak_allocated}")
>>> print(f"Total allocated: {stats.total_allocated}")

Source code in doc-gen/valkey-glide/python/glide-sync/glide_sync/sync_commands/standalone_commands.py

def memory_stats(self) -> MemoryStats:
    """
    Returns detailed memory consumption statistics of the server.

    See [valkey.io](https://valkey.io/commands/memory-stats/) for details.

    Returns:
        MemoryStats: A ``MemoryStats`` object containing detailed memory usage
            statistics.

    Examples:
        >>> stats = client.memory_stats()
        >>> print(f"Peak allocated: {stats.peak_allocated}")
        >>> print(f"Total allocated: {stats.total_allocated}")
    """
    return _parse_memory_stats(
        cast(
            Mapping,
            self._execute_command(RequestType.MemoryStats, []),
        ),
    )