redis API Reference

Python Library Documentation: class AuthenticationError in module redis.exceptions

class AuthenticationError(ConnectionError)
 |  AuthenticationError(*args, status_code: str | None = None)
 |
 |  Method resolution order:
 |      AuthenticationError
 |      ConnectionError
 |      RedisError
 |      builtins.Exception
 |      builtins.BaseException
 |      builtins.object
 |
 |  Methods defined here:
 |
 |  __init__(self, *args, status_code: str | None = None)
 |      Initialize self.  See help(type(self)) for accurate signature.
 |
 |  ----------------------------------------------------------------------
 |  Methods inherited from RedisError:
 |
 |  __repr__(self)
 |      Return repr(self).
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from RedisError:
 |
 |  __weakref__
 |      list of weak references to the object
 |
 |  ----------------------------------------------------------------------
 |  Static methods inherited from builtins.Exception:
 |
 |  __new__(*args, **kwargs) class method of builtins.Exception
 |      Create and return a new object.  See help(type) for accurate signature.
 |
 |  ----------------------------------------------------------------------
 |  Methods inherited from builtins.BaseException:
 |
 |  __getattribute__(self, name, /)
 |      Return getattr(self, name).
 |
 |  __reduce__(...)
 |      Helper for pickle.
 |
 |  __setstate__(...)
 |
 |  __str__(self, /)
 |      Return str(self).
 |
 |  add_note(...)
 |      Exception.add_note(note) --
 |      add a note to the exception
 |
 |  with_traceback(...)
 |      Exception.with_traceback(tb) --
 |      set self.__traceback__ to tb and return self.
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from builtins.BaseException:
 |
 |  __cause__
 |      exception cause
 |
 |  __context__
 |      exception context
 |
 |  __dict__
 |
 |  __suppress_context__
 |
 |  __traceback__
 |
 |  args

Python Library Documentation: class AuthenticationWrongNumberOfArgsError in module redis.exceptions

class AuthenticationWrongNumberOfArgsError(ResponseError)
 |  AuthenticationWrongNumberOfArgsError(*args, status_code: str | None = None)
 |
 |  An error to indicate that the wrong number of args
 |  were sent to the AUTH command
 |
 |  Method resolution order:
 |      AuthenticationWrongNumberOfArgsError
 |      ResponseError
 |      RedisError
 |      builtins.Exception
 |      builtins.BaseException
 |      builtins.object
 |
 |  Methods defined here:
 |
 |  __init__(self, *args, status_code: str | None = None)
 |      Initialize self.  See help(type(self)) for accurate signature.
 |
 |  ----------------------------------------------------------------------
 |  Methods inherited from RedisError:
 |
 |  __repr__(self)
 |      Return repr(self).
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from RedisError:
 |
 |  __weakref__
 |      list of weak references to the object
 |
 |  ----------------------------------------------------------------------
 |  Static methods inherited from builtins.Exception:
 |
 |  __new__(*args, **kwargs) class method of builtins.Exception
 |      Create and return a new object.  See help(type) for accurate signature.
 |
 |  ----------------------------------------------------------------------
 |  Methods inherited from builtins.BaseException:
 |
 |  __getattribute__(self, name, /)
 |      Return getattr(self, name).
 |
 |  __reduce__(...)
 |      Helper for pickle.
 |
 |  __setstate__(...)
 |
 |  __str__(self, /)
 |      Return str(self).
 |
 |  add_note(...)
 |      Exception.add_note(note) --
 |      add a note to the exception
 |
 |  with_traceback(...)
 |      Exception.with_traceback(tb) --
 |      set self.__traceback__ to tb and return self.
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from builtins.BaseException:
 |
 |  __cause__
 |      exception cause
 |
 |  __context__
 |      exception context
 |
 |  __dict__
 |
 |  __suppress_context__
 |
 |  __traceback__
 |
 |  args

Python Library Documentation: class BlockingConnectionPool in module redis.connection

class BlockingConnectionPool(ConnectionPool)
 |  BlockingConnectionPool(max_connections=50, timeout=20, connection_class=<class 'redis.connection.Connection'>, queue_class=<class 'queue.LifoQueue'>, **connection_kwargs)
 |
 |  Thread-safe blocking connection pool::
 |
 |      >>> from redis.client import Redis
 |      >>> client = Redis(connection_pool=BlockingConnectionPool())
 |
 |  It performs the same function as the default
 |  :py:class:`~redis.ConnectionPool` implementation, in that,
 |  it maintains a pool of reusable connections that can be shared by
 |  multiple redis clients (safely across threads if required).
 |
 |  The difference is that, in the event that a client tries to get a
 |  connection from the pool when all of connections are in use, rather than
 |  raising a :py:class:`~redis.ConnectionError` (as the default
 |  :py:class:`~redis.ConnectionPool` implementation does), it
 |  makes the client wait ("blocks") for a specified number of seconds until
 |  a connection becomes available.
 |
 |  Use ``max_connections`` to increase / decrease the pool size::
 |
 |      >>> pool = BlockingConnectionPool(max_connections=10)
 |
 |  Use ``timeout`` to tell it either how many seconds to wait for a connection
 |  to become available, or to block forever:
 |
 |      >>> # Block forever.
 |      >>> pool = BlockingConnectionPool(timeout=None)
 |
 |      >>> # Raise a ``ConnectionError`` after five seconds if a connection is
 |      >>> # not available.
 |      >>> pool = BlockingConnectionPool(timeout=5)
 |
 |  Method resolution order:
 |      BlockingConnectionPool
 |      ConnectionPool
 |      MaintNotificationsAbstractConnectionPool
 |      ConnectionPoolInterface
 |      abc.ABC
 |      builtins.object
 |
 |  Methods defined here:
 |
 |  __del__(self) -> None
 |      Clean up connection pool and record metrics when garbage collected.
 |
 |  __init__(self, max_connections=50, timeout=20, connection_class=<class 'redis.connection.Connection'>, queue_class=<class 'queue.LifoQueue'>, **connection_kwargs)
 |      Initialize self.  See help(type(self)) for accurate signature.
 |
 |  disconnect(self, inuse_connections: bool = True)
 |      Disconnects either all connections in the pool or just the free connections.
 |
 |  get_connection(self, command_name=None, *keys, **options)
 |      Get a connection, blocking for ``self.timeout`` until a connection
 |      is available from the pool.
 |
 |      If the connection returned is ``None`` then creates a new connection.
 |      Because we use a last-in first-out queue, the existing connections
 |      (having been returned to the pool after the initial ``None`` values
 |      were added) will be returned before ``None`` values. This means we only
 |      create new connections when we need to, i.e.: the actual number of
 |      connections will only increase in response to demand.
 |
 |  make_connection(self)
 |      Make a fresh connection.
 |
 |  release(self, connection)
 |      Releases the connection back to the pool.
 |
 |  reset(self)
 |
 |  set_in_maintenance(self, in_maintenance: bool)
 |      Sets a flag that this Blocking ConnectionPool is in maintenance mode.
 |
 |      This is used to prevent new connections from being created while we are in maintenance mode.
 |      The pool will be in maintenance mode only when we are processing a MOVING notification.
 |
 |  ----------------------------------------------------------------------
 |  Data and other attributes defined here:
 |
 |  __abstractmethods__ = frozenset()
 |
 |  ----------------------------------------------------------------------
 |  Methods inherited from ConnectionPool:
 |
 |  __enter__(self: ~_CP) -> ~_CP
 |
 |  __exit__(self, exc_type, exc_value, traceback) -> None
 |
 |  __repr__(self) -> str
 |      Return repr(self).
 |
 |  close(self) -> None
 |      Close the pool, disconnecting all connections
 |
 |  get_connection_count(self) -> List[tuple[int, dict]]
 |      Returns a connection count (both idle and in use).
 |
 |  get_encoder(self) -> redis._parsers.encoders.Encoder
 |      Return an encoder based on encoding settings
 |
 |  get_protocol(self)
 |      Returns:
 |          The RESP protocol version, or ``None`` if the protocol is not specified,
 |          in which case the server default will be used.
 |
 |  owns_connection(self, connection: 'Connection') -> int
 |
 |  re_auth_callback(self, token: redis.auth.token.TokenInterface)
 |
 |  set_retry(self, retry: redis.retry.Retry) -> None
 |
 |  ----------------------------------------------------------------------
 |  Class methods inherited from ConnectionPool:
 |
 |  from_url(url: str, **kwargs) -> ~_CP
 |      Return a connection pool configured from the given URL.
 |
 |      For example::
 |
 |          redis://[[username]:[password]]@localhost:6379/0
 |          rediss://[[username]:[password]]@localhost:6379/0
 |          unix://[username@]/path/to/socket.sock?db=0[&password=password]
 |
 |      Three URL schemes are supported:
 |
 |      - `redis://` creates a TCP socket connection. See more at:
 |        <https://www.iana.org/assignments/uri-schemes/prov/redis>
 |      - `rediss://` creates a SSL wrapped TCP socket connection. See more at:
 |        <https://www.iana.org/assignments/uri-schemes/prov/rediss>
 |      - ``unix://``: creates a Unix Domain Socket connection.
 |
 |      The username, password, hostname, path and all querystring values
 |      are passed through urllib.parse.unquote in order to replace any
 |      percent-encoded values with their corresponding characters.
 |
 |      There are several ways to specify a database number. The first value
 |      found will be used:
 |
 |          1. A ``db`` querystring option, e.g. redis://localhost?db=0
 |          2. If using the redis:// or rediss:// schemes, the path argument
 |             of the url, e.g. redis://localhost/0
 |          3. A ``db`` keyword argument to this function.
 |
 |      If none of these options are specified, the default db=0 is used.
 |
 |      All querystring options are cast to their appropriate Python types.
 |      Boolean arguments can be specified with string values "True"/"False"
 |      or "Yes"/"No". Values that cannot be properly cast cause a
 |      ``ValueError`` to be raised. Once parsed, the querystring arguments
 |      and keyword arguments are passed to the ``ConnectionPool``'s
 |      class initializer. In the case of conflicting arguments, querystring
 |      arguments always win.
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from ConnectionPool:
 |
 |  connection_kwargs
 |
 |  ----------------------------------------------------------------------
 |  Data and other attributes inherited from ConnectionPool:
 |
 |  OMIT_REPR_KEYS = frozenset({'himport_registry'})
 |
 |  SENSITIVE_REPR_KEYS = frozenset({'credential_provider', 'password', 's...
 |
 |  ----------------------------------------------------------------------
 |  Methods inherited from MaintNotificationsAbstractConnectionPool:
 |
 |  disconnect_free_connections(self, moving_address_src: Optional[str] = None)
 |      Disconnect all free/available connections.
 |      This is used when a cluster node is migrated to a different address.
 |
 |      :param moving_address_src: The address of the node that is being moved.
 |
 |  maint_notifications_enabled(self)
 |      Returns:
 |          True if the maintenance notifications are enabled, False otherwise.
 |          The maintenance notifications config is stored in the pool handler.
 |          If the pool handler is not set, the maintenance notifications are not enabled.
 |
 |  update_active_connections_for_reconnect(self, moving_address_src: Optional[str] = None)
 |      Mark all active connections for reconnect.
 |      This is used when a cluster node is migrated to a different address.
 |
 |      :param moving_address_src: The address of the node that is being moved.
 |
 |  update_connection_kwargs(self, **kwargs)
 |      Update the connection kwargs for all future connections.
 |
 |      This method updates the connection kwargs for all future connections created by the pool.
 |      Existing connections are not affected.
 |
 |  update_connection_settings(self, conn: 'MaintNotificationsAbstractConnection', state: Optional[ForwardRef('MaintenanceState')] = None, maintenance_notification_hash: Optional[int] = None, host_address: Optional[str] = None, relaxed_timeout: Optional[float] = None, update_notification_hash: bool = False, reset_host_address: bool = False, reset_relaxed_timeout: bool = False)
 |      Update the settings for a single connection.
 |
 |  update_connections_settings(self, state: Optional[ForwardRef('MaintenanceState')] = None, maintenance_notification_hash: Optional[int] = None, host_address: Optional[str] = None, relaxed_timeout: Optional[float] = None, matching_address: Optional[str] = None, matching_notification_hash: Optional[int] = None, matching_pattern: Literal['connected_address', 'configured_address', 'notification_hash'] = 'connected_address', update_notification_hash: bool = False, reset_host_address: bool = False, reset_relaxed_timeout: bool = False, include_free_connections: bool = True)
 |      Update the settings for all matching connections in the pool.
 |
 |      This method does not create new connections.
 |      This method does not affect the connection kwargs.
 |
 |      :param state: The maintenance state to set for the connection.
 |      :param maintenance_notification_hash: The hash of the maintenance notification
 |                                             to set for the connection.
 |      :param host_address: The host address to set for the connection.
 |      :param relaxed_timeout: The relaxed timeout to set for the connection.
 |      :param matching_address: The address to match for the connection.
 |      :param matching_notification_hash: The notification hash to match for the connection.
 |      :param matching_pattern: The pattern to match for the connection.
 |      :param update_notification_hash: Whether to update the notification hash for the connection.
 |      :param reset_host_address: Whether to reset the host address to the original address.
 |      :param reset_relaxed_timeout: Whether to reset the relaxed timeout to the original timeout.
 |      :param include_free_connections: Whether to include free/available connections.
 |
 |  update_maint_notifications_config(self, maint_notifications_config: redis.maint_notifications.MaintNotificationsConfig, oss_cluster_maint_notifications_handler: Optional[redis.maint_notifications.OSSMaintNotificationsHandler] = None)
 |      Updates the maintenance notifications configuration.
 |      This method should be called only if the pool was created
 |      without enabling the maintenance notifications and
 |      in a later point in time maintenance notifications
 |      are requested to be enabled.
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from MaintNotificationsAbstractConnectionPool:
 |
 |  __dict__
 |      dictionary for instance variables
 |
 |  __weakref__
 |      list of weak references to the object

Python Library Documentation: class BusyLoadingError in module redis.exceptions

class BusyLoadingError(ConnectionError)
 |  BusyLoadingError(*args, status_code: str | None = None)
 |
 |  Method resolution order:
 |      BusyLoadingError
 |      ConnectionError
 |      RedisError
 |      builtins.Exception
 |      builtins.BaseException
 |      builtins.object
 |
 |  Methods defined here:
 |
 |  __init__(self, *args, status_code: str | None = None)
 |      Initialize self.  See help(type(self)) for accurate signature.
 |
 |  ----------------------------------------------------------------------
 |  Methods inherited from RedisError:
 |
 |  __repr__(self)
 |      Return repr(self).
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from RedisError:
 |
 |  __weakref__
 |      list of weak references to the object
 |
 |  ----------------------------------------------------------------------
 |  Static methods inherited from builtins.Exception:
 |
 |  __new__(*args, **kwargs) class method of builtins.Exception
 |      Create and return a new object.  See help(type) for accurate signature.
 |
 |  ----------------------------------------------------------------------
 |  Methods inherited from builtins.BaseException:
 |
 |  __getattribute__(self, name, /)
 |      Return getattr(self, name).
 |
 |  __reduce__(...)
 |      Helper for pickle.
 |
 |  __setstate__(...)
 |
 |  __str__(self, /)
 |      Return str(self).
 |
 |  add_note(...)
 |      Exception.add_note(note) --
 |      add a note to the exception
 |
 |  with_traceback(...)
 |      Exception.with_traceback(tb) --
 |      set self.__traceback__ to tb and return self.
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from builtins.BaseException:
 |
 |  __cause__
 |      exception cause
 |
 |  __context__
 |      exception context
 |
 |  __dict__
 |
 |  __suppress_context__
 |
 |  __traceback__
 |
 |  args

Python Library Documentation: class ChannelType in module redis.keyspace_notifications

class ChannelType(enum.Enum)
 |  ChannelType(*values)
 |
 |  Enum representing the type of a Redis keyspace notification channel.
 |
 |  Redis provides two types of keyspace notifications and four subkey
 |  notification types:
 |
 |  - KEYSPACE: ``__keyspace@{db}__:{key}`` — data is the event type.
 |  - KEYEVENT: ``__keyevent@{db}__:{event}`` — data is the key name.
 |  - SUBKEYSPACE: ``__subkeyspace@{db}__:{key}`` — data is event + subkeys.
 |  - SUBKEYEVENT: ``__subkeyevent@{db}__:{event}`` — data is key + subkeys.
 |  - SUBKEYSPACEITEM: ``__subkeyspaceitem@{db}__:{key}\n{subkey}`` — data
 |    is the event type.
 |  - SUBKEYSPACEEVENT: ``__subkeyspaceevent@{db}__:{event}|{key}`` — data
 |    is a subkey list.
 |
 |  Examples:
 |      >>> get_channel_type("__keyspace@0__:mykey")
 |      ChannelType.KEYSPACE
 |      >>> get_channel_type("__subkeyspace@0__:myhash")
 |      ChannelType.SUBKEYSPACE
 |
 |  Method resolution order:
 |      ChannelType
 |      enum.Enum
 |      builtins.object
 |
 |  Data and other attributes defined here:
 |
 |  KEYEVENT = <ChannelType.KEYEVENT: 'keyevent'>
 |
 |  KEYSPACE = <ChannelType.KEYSPACE: 'keyspace'>
 |
 |  SUBKEYEVENT = <ChannelType.SUBKEYEVENT: 'subkeyevent'>
 |
 |  SUBKEYSPACE = <ChannelType.SUBKEYSPACE: 'subkeyspace'>
 |
 |  SUBKEYSPACEEVENT = <ChannelType.SUBKEYSPACEEVENT: 'subkeyspaceevent'>
 |
 |  SUBKEYSPACEITEM = <ChannelType.SUBKEYSPACEITEM: 'subkeyspaceitem'>
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from enum.Enum:
 |
 |  name
 |      The name of the Enum member.
 |
 |  value
 |      The value of the Enum member.
 |
 |  ----------------------------------------------------------------------
 |  Static methods inherited from enum.EnumType:
 |
 |  __contains__(value)
 |      Return True if `value` is in `cls`.
 |
 |      `value` is in `cls` if:
 |      1) `value` is a member of `cls`, or
 |      2) `value` is the value of one of the `cls`'s members.
 |
 |  __getitem__(name)
 |      Return the member matching `name`.
 |
 |  __iter__()
 |      Return members in definition order.
 |
 |  __len__()
 |      Return the number of members (no aliases)
 |
 |  ----------------------------------------------------------------------
 |  Readonly properties inherited from enum.EnumType:
 |
 |  __members__
 |      Returns a mapping of member name->value.
 |
 |      This mapping lists all enum members, including aliases. Note that this
 |      is a read-only view of the internal mapping.

Python Library Documentation: class ChildDeadlockedError in module redis.exceptions

class ChildDeadlockedError(builtins.Exception)
 |  Error indicating that a child process is deadlocked after a fork()
 |
 |  Method resolution order:
 |      ChildDeadlockedError
 |      builtins.Exception
 |      builtins.BaseException
 |      builtins.object
 |
 |  Data descriptors defined here:
 |
 |  __weakref__
 |      list of weak references to the object
 |
 |  ----------------------------------------------------------------------
 |  Methods inherited from builtins.Exception:
 |
 |  __init__(self, /, *args, **kwargs)
 |      Initialize self.  See help(type(self)) for accurate signature.
 |
 |  ----------------------------------------------------------------------
 |  Static methods inherited from builtins.Exception:
 |
 |  __new__(*args, **kwargs) class method of builtins.Exception
 |      Create and return a new object.  See help(type) for accurate signature.
 |
 |  ----------------------------------------------------------------------
 |  Methods inherited from builtins.BaseException:
 |
 |  __getattribute__(self, name, /)
 |      Return getattr(self, name).
 |
 |  __reduce__(...)
 |      Helper for pickle.
 |
 |  __repr__(self, /)
 |      Return repr(self).
 |
 |  __setstate__(...)
 |
 |  __str__(self, /)
 |      Return str(self).
 |
 |  add_note(...)
 |      Exception.add_note(note) --
 |      add a note to the exception
 |
 |  with_traceback(...)
 |      Exception.with_traceback(tb) --
 |      set self.__traceback__ to tb and return self.
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from builtins.BaseException:
 |
 |  __cause__
 |      exception cause
 |
 |  __context__
 |      exception context
 |
 |  __dict__
 |
 |  __suppress_context__
 |
 |  __traceback__
 |
 |  args

Python Library Documentation: class ClusterKeyspaceNotifications in module redis.keyspace_notifications

class ClusterKeyspaceNotifications(AbstractKeyspaceNotifications)
 |  ClusterKeyspaceNotifications(redis_cluster: 'RedisCluster', key_prefix: 'str | bytes | None' = None, ignore_subscribe_messages: 'bool' = True)
 |
 |  Manages keyspace notification subscriptions across all nodes in a Redis Cluster.
 |
 |  In Redis Cluster, keyspace notifications are NOT broadcast between nodes.
 |  Each node only emits notifications for keys it owns. This class automatically
 |  subscribes to all primary nodes in the cluster and handles topology changes.
 |
 |  Method resolution order:
 |      ClusterKeyspaceNotifications
 |      AbstractKeyspaceNotifications
 |      KeyspaceNotificationsInterface
 |      abc.ABC
 |      builtins.object
 |
 |  Methods defined here:
 |
 |  __init__(self, redis_cluster: 'RedisCluster', key_prefix: 'str | bytes | None' = None, ignore_subscribe_messages: 'bool' = True)
 |      Initialize the cluster keyspace notification manager.
 |
 |      Note: Keyspace notifications must be enabled on all Redis cluster nodes via
 |      the ``notify-keyspace-events`` configuration option. This is a server-side
 |      configuration that should be done by your infrastructure/operations team.
 |
 |      Args:
 |          redis_cluster: A RedisCluster instance
 |          key_prefix: Optional prefix to filter and strip from keys in notifications
 |          ignore_subscribe_messages: If True, subscribe/unsubscribe confirmations
 |                                    are not returned by get_message/listen
 |
 |  close(self)
 |      Close all pubsub connections and clean up resources.
 |
 |  get_message(self, ignore_subscribe_messages: 'bool | None' = None, timeout: 'float' = 0.0) -> 'KeyNotification | None'
 |      Get the next keyspace notification if one is available.
 |
 |      This method polls all node pubsubs in round-robin fashion until
 |      a message is received or the timeout expires.
 |      If a connection error occurs, subscriptions are automatically refreshed.
 |
 |      Args:
 |          ignore_subscribe_messages: If True, skip subscribe/unsubscribe messages.
 |                                    Defaults to the value set in __init__ (True).
 |          timeout: Total time to wait for a message (distributed across all nodes)
 |
 |      Returns:
 |          A KeyNotification if a notification is available, None otherwise.
 |
 |  listen(self)
 |      Listen for keyspace notifications from all cluster nodes.
 |
 |      This is a generator that yields KeyNotification objects as they arrive.
 |      It blocks until a notification is received.
 |
 |      Yields:
 |          KeyNotification objects for each keyspace/keyevent notification.
 |
 |      Example:
 |          >>> for notification in ksn.listen():
 |          ...     print(f"{notification.key}: {notification.event_type}")
 |
 |  refresh_subscriptions(self)
 |      Refresh subscriptions after a topology change.
 |
 |      This method is called automatically when topology changes are detected
 |      or when connection errors occur. You can also call it manually if needed.
 |
 |      This method:
 |      1. Discovers any new primary nodes and subscribes them
 |      2. Removes pubsubs for nodes that are no longer primaries
 |      3. Re-creates broken pubsub connections for existing nodes
 |
 |  ----------------------------------------------------------------------
 |  Readonly properties defined here:
 |
 |  subscribed
 |      Check if there are any active subscriptions and not closed.
 |
 |  ----------------------------------------------------------------------
 |  Data and other attributes defined here:
 |
 |  __abstractmethods__ = frozenset()
 |
 |  ----------------------------------------------------------------------
 |  Methods inherited from AbstractKeyspaceNotifications:
 |
 |  __enter__(self)
 |
 |  __exit__(self, _exc_type, _exc_val, _exc_tb)
 |
 |  run_in_thread(self, poll_timeout: 'float' = 0.0, daemon: 'bool' = False, exception_handler: 'Callable[[BaseException, KeyspaceNotificationsInterface, KeyspaceWorkerThread], None] | None' = None) -> 'KeyspaceWorkerThread'
 |      Start a background thread that polls for notifications and triggers handlers.
 |
 |      This method spawns a thread that continuously calls get_message() to
 |      process incoming notifications. When a notification arrives, any
 |      registered handler for that channel/pattern is invoked automatically.
 |
 |      All subscriptions must have handlers registered before calling this method.
 |
 |      Args:
 |          poll_timeout: Timeout in seconds for get_message() calls. When no message
 |                       is available, the thread waits up to this long before checking
 |                       again. Default 0.0 (non-blocking). WARNING: the default
 |                       causes a CPU spin-loop. It is preferred to pass a positive
 |                       value (e.g. 0.1 or 1.0).
 |          daemon: If True, the thread will be a daemon thread and will be
 |                 terminated when the main program exits. Default False.
 |          exception_handler: Optional callback invoked when an exception occurs
 |                            in the worker thread. Receives (exception, notifications,
 |                            thread) as arguments. If None, exceptions are raised.
 |
 |      Returns:
 |          KeyspaceWorkerThread: The started worker thread. Call stop() on it
 |                               to stop the thread and close the notifications.
 |
 |      Raises:
 |          RedisError: If any subscription doesn't have a handler registered.
 |
 |      Example:
 |          >>> def my_handler(notification):
 |          ...     print(f"Got: {notification.key} - {notification.event_type}")
 |          >>>
 |          >>> notifications.subscribe(KeyspaceChannel("user:*"), handler=my_handler)
 |          >>> thread = notifications.run_in_thread(poll_timeout=0.1, daemon=True)
 |          >>> # ... handlers are called automatically ...
 |          >>> thread.stop()
 |
 |  subscribe(self, *channels: 'ChannelT', handler: 'SyncHandlerT | None' = None)
 |      Subscribe to keyspace notification channels.
 |
 |      Automatically detects whether each channel is a pattern (contains
 |      wildcards like *, ?, [) or an exact channel name and uses the
 |      appropriate Redis subscribe command internally.
 |
 |      Args:
 |          *channels: Channels to subscribe to. Can be strings, KeyspaceChannel,
 |                    or KeyeventChannel objects. Patterns are auto-detected.
 |          handler: Optional callback function that receives KeyNotification
 |                  objects. If provided, notifications are passed to the handler
 |                  instead of being returned by get_message()/listen().
 |
 |  subscribe_keyevent(self, event: 'str', db: 'int' = 0, handler: 'SyncHandlerT | None' = None)
 |      Subscribe to keyevent notifications for specific event types.
 |
 |      Args:
 |          event: The event type to monitor (e.g., EventType.SET or "set")
 |          db: The database number (default 0).
 |          handler: Optional callback for notifications.
 |
 |      Example:
 |          >>> ksn.subscribe_keyevent(EventType.SET)
 |          >>> ksn.subscribe_keyevent(EventType.EXPIRED, handler=my_handler)
 |
 |  subscribe_keyspace(self, key_or_pattern: 'str', db: 'int' = 0, handler: 'SyncHandlerT | None' = None)
 |      Subscribe to keyspace notifications for specific keys.
 |
 |      Args:
 |          key_or_pattern: The key or pattern to monitor. Use '*' for wildcards.
 |          db: The database number (default 0).
 |          handler: Optional callback for notifications.
 |
 |      Example:
 |          >>> ksn.subscribe_keyspace("user:123", db=0)
 |          >>> ksn.subscribe_keyspace("user:*", db=0)
 |
 |  subscribe_subkeyevent(self, event: 'str', db: 'int' = 0, handler: 'SyncHandlerT | None' = None)
 |      Subscribe to subkeyevent notifications for specific event types.
 |
 |      Receives the affected key and subkeys when the given event occurs.
 |
 |      Args:
 |          event: The event type to monitor (e.g., "hset", "hdel").
 |          db: The database number (default 0).
 |          handler: Optional callback for notifications.
 |
 |  subscribe_subkeyspace(self, key_or_pattern: 'str', db: 'int' = 0, handler: 'SyncHandlerT | None' = None)
 |      Subscribe to subkeyspace notifications for specific keys.
 |
 |      Receives events with affected subkeys (fields) for the given key.
 |
 |      Args:
 |          key_or_pattern: The key or pattern to monitor.
 |          db: The database number (default 0).
 |          handler: Optional callback for notifications.
 |
 |  subscribe_subkeyspaceevent(self, event: 'str', key_or_pattern: 'str', db: 'int' = 0, handler: 'SyncHandlerT | None' = None)
 |      Subscribe to subkeyspaceevent notifications for an event on a key.
 |
 |      Receives the affected subkeys when the given event occurs on the
 |      given key.
 |
 |      Args:
 |          event: The event type to monitor.
 |          key_or_pattern: The key or pattern to monitor.
 |          db: The database number (default 0).
 |          handler: Optional callback for notifications.
 |
 |  subscribe_subkeyspaceitem(self, key_or_pattern: 'str', subkey_or_pattern: 'str', db: 'int' = 0, handler: 'SyncHandlerT | None' = None)
 |      Subscribe to subkeyspaceitem notifications for a specific subkey.
 |
 |      Receives the event type when the given subkey of the given key is
 |      modified.
 |
 |      Args:
 |          key_or_pattern: The key or pattern to monitor.
 |          subkey_or_pattern: The subkey (field) or pattern to monitor.
 |          db: The database number (default 0).
 |          handler: Optional callback for notifications.
 |
 |  unsubscribe(self, *channels: 'ChannelT')
 |      Unsubscribe from keyspace notification channels.
 |
 |      Automatically detects whether each channel is a pattern or exact
 |      channel and uses the appropriate Redis unsubscribe command.
 |
 |      Args:
 |          *channels: Channels to unsubscribe from.
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from KeyspaceNotificationsInterface:
 |
 |  __dict__
 |      dictionary for instance variables
 |
 |  __weakref__
 |      list of weak references to the object

Python Library Documentation: class Connection in module redis.connection

class Connection(AbstractConnection)
 |  Connection(host='localhost', port=6379, socket_keepalive=True, socket_keepalive_options=<object object at 0x0000017B991493E0>, socket_type=0, **kwargs)
 |
 |  Manages TCP communication to and from a Redis server
 |
 |  Method resolution order:
 |      Connection
 |      AbstractConnection
 |      MaintNotificationsAbstractConnection
 |      ConnectionInterface
 |      builtins.object
 |
 |  Methods defined here:
 |
 |  __init__(self, host='localhost', port=6379, socket_keepalive=True, socket_keepalive_options=<object object at 0x0000017B991493E0>, socket_type=0, **kwargs)
 |      Initialize a TCP connection.
 |
 |      Parameters
 |      ----------
 |      socket_keepalive : bool
 |          If `True`, TCP keepalive is enabled for TCP socket connections.
 |      socket_keepalive_options : Mapping[int, int | bytes] | object | None
 |          Mapping of TCP keepalive socket option constants to values, for
 |          example `{socket.TCP_KEEPIDLE: 30}`. If left unspecified, redis-py
 |          uses TCP keepalive defaults when `socket_keepalive` is enabled:
 |          idle 30 seconds, interval 5 seconds, and 3 probes. Platform-specific
 |          options that are not available are skipped. Pass `None` or `{}` to
 |          avoid setting additional TCP keepalive options.
 |
 |  repr_pieces(self)
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors defined here:
 |
 |  host
 |
 |  ----------------------------------------------------------------------
 |  Methods inherited from AbstractConnection:
 |
 |  __del__(self)
 |
 |  __repr__(self)
 |      Return repr(self).
 |
 |  can_read(self, timeout: float = 0) -> bool
 |      Poll the socket to see if there's data that can be read.
 |
 |  check_health(self)
 |      Check the health of the connection with a PING/PONG
 |
 |  connect(self)
 |      Connects to the Redis server if not already connected
 |
 |  connect_check_health(self, check_health: bool = True, retry_socket_connect: bool = True)
 |
 |  deregister_connect_callback(self, callback)
 |      De-register a previously registered callback.  It will no-longer receive
 |      notifications on connection events.  Calling this is not required when the
 |      listener goes away, since the callbacks are kept as weak methods.
 |
 |  disconnect(self, *args, **kwargs)
 |      Disconnects from the Redis server
 |
 |  extract_connection_details(self) -> str
 |
 |  get_protocol(self) -> Union[int, str]
 |      Returns:
 |          The RESP protocol version, or ``None`` if the protocol is not specified,
 |          in which case the server default will be used.
 |
 |  mark_for_reconnect(self)
 |      Mark the connection to be reconnected on the next command.
 |      This is useful when a connection is moved to a different node.
 |
 |  on_connect(self)
 |
 |  on_connect_check_health(self, check_health: bool = True)
 |      Initialize the connection, authenticate and select a database
 |
 |  pack_command(self, *args)
 |      Pack a series of arguments into the Redis protocol
 |
 |  pack_commands(self, commands)
 |      Pack multiple commands into the Redis protocol
 |
 |  re_auth(self)
 |
 |  read_response(self, disable_decoding=False, *, timeout: Union[float, object] = <object object at 0x0000017B991493E0>, disconnect_on_error=True, push_request=False)
 |      Read the response from a previously sent command
 |
 |  register_connect_callback(self, callback)
 |      Register a callback to be called when the connection is established either
 |      initially or reconnected.  This allows listeners to issue commands that
 |      are ephemeral to the connection, for example pub/sub subscription or
 |      key tracking.  The callback must be a _method_ and will be kept as
 |      a weak reference.
 |
 |  reset_should_reconnect(self)
 |      Reset the internal flag to False.
 |
 |  send_command(self, *args, **kwargs)
 |      Pack and send a command to the Redis server
 |
 |  send_packed_command(self, command, check_health=True)
 |      Send an already packed command to the Redis server
 |
 |  set_parser(self, parser_class)
 |      Creates a new instance of parser_class with socket size:
 |      _socket_read_size and assigns it to the parser for the connection
 |      :param parser_class: The required parser class
 |
 |  set_re_auth_token(self, token: redis.auth.token.TokenInterface)
 |
 |  should_reconnect(self)
 |      Returns True if the connection should be reconnected.
 |
 |  ----------------------------------------------------------------------
 |  Readonly properties inherited from AbstractConnection:
 |
 |  is_connected
 |      Return ``True`` if the connection to the server is active.
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from AbstractConnection:
 |
 |  handshake_metadata
 |
 |  socket_connect_timeout
 |
 |  socket_timeout
 |
 |  ----------------------------------------------------------------------
 |  Methods inherited from MaintNotificationsAbstractConnection:
 |
 |  activate_maint_notifications_handling_if_enabled(self, check_health=True)
 |
 |  add_maint_start_notification(self, id: int)
 |
 |  add_skipped_end_notification(self, id: int)
 |
 |  get_processed_start_notifications(self) -> set
 |
 |  get_resolved_ip(self) -> Optional[str]
 |      Extract the resolved IP address from an
 |      established connection or resolve it from the host.
 |
 |      First tries to get the actual IP from the socket (most accurate),
 |      then falls back to DNS resolution if needed.
 |
 |      Returns:
 |          str: The resolved IP address, or None if it cannot be determined
 |
 |  get_skipped_end_notifications(self) -> set
 |
 |  getpeername(self)
 |      Returns the peer name of the connection.
 |
 |  reset_received_notifications(self)
 |
 |  reset_tmp_settings(self, reset_host_address: bool = False, reset_relaxed_timeout: bool = False)
 |
 |  set_maint_notifications_cluster_handler_for_connection(self, oss_cluster_maint_notifications_handler: redis.maint_notifications.OSSMaintNotificationsHandler)
 |
 |  set_maint_notifications_pool_handler_for_connection(self, maint_notifications_pool_handler: redis.maint_notifications.MaintNotificationsPoolHandler)
 |
 |  set_tmp_settings(self, tmp_host_address: Union[str, object, NoneType] = <object object at 0x0000017B991493E0>, tmp_relaxed_timeout: Optional[float] = -1)
 |      SENTINEL keeps the host unchanged. -1 keeps the relaxed timeout unchanged.
 |
 |  update_current_socket_timeout(self, relaxed_timeout: Optional[float] = None)
 |
 |  update_parser_timeout(self, timeout: Optional[float] = None)
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from MaintNotificationsAbstractConnection:
 |
 |  __dict__
 |      dictionary for instance variables
 |
 |  __weakref__
 |      list of weak references to the object
 |
 |  maintenance_state

Python Library Documentation: class ConnectionError in module redis.exceptions

class ConnectionError(RedisError)
 |  ConnectionError(*args, status_code: str | None = None)
 |
 |  Method resolution order:
 |      ConnectionError
 |      RedisError
 |      builtins.Exception
 |      builtins.BaseException
 |      builtins.object
 |
 |  Methods defined here:
 |
 |  __init__(self, *args, status_code: str | None = None)
 |      Initialize self.  See help(type(self)) for accurate signature.
 |
 |  ----------------------------------------------------------------------
 |  Methods inherited from RedisError:
 |
 |  __repr__(self)
 |      Return repr(self).
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from RedisError:
 |
 |  __weakref__
 |      list of weak references to the object
 |
 |  ----------------------------------------------------------------------
 |  Static methods inherited from builtins.Exception:
 |
 |  __new__(*args, **kwargs) class method of builtins.Exception
 |      Create and return a new object.  See help(type) for accurate signature.
 |
 |  ----------------------------------------------------------------------
 |  Methods inherited from builtins.BaseException:
 |
 |  __getattribute__(self, name, /)
 |      Return getattr(self, name).
 |
 |  __reduce__(...)
 |      Helper for pickle.
 |
 |  __setstate__(...)
 |
 |  __str__(self, /)
 |      Return str(self).
 |
 |  add_note(...)
 |      Exception.add_note(note) --
 |      add a note to the exception
 |
 |  with_traceback(...)
 |      Exception.with_traceback(tb) --
 |      set self.__traceback__ to tb and return self.
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from builtins.BaseException:
 |
 |  __cause__
 |      exception cause
 |
 |  __context__
 |      exception context
 |
 |  __dict__
 |
 |  __suppress_context__
 |
 |  __traceback__
 |
 |  args

Python Library Documentation: class ConnectionPool in module redis.connection

class ConnectionPool(MaintNotificationsAbstractConnectionPool, ConnectionPoolInterface)
 |  ConnectionPool(connection_class=<class 'redis.connection.Connection'>, max_connections: Optional[int] = None, cache_factory: Optional[redis.cache.CacheFactoryInterface] = None, maint_notifications_config: Optional[redis.maint_notifications.MaintNotificationsConfig] = None, **connection_kwargs)
 |
 |  Create a connection pool. ``If max_connections`` is set, then this
 |  object raises :py:class:`~redis.exceptions.ConnectionError` when the pool's
 |  limit is reached.
 |
 |  By default, TCP connections are created unless ``connection_class``
 |  is specified. Use class:`.UnixDomainSocketConnection` for
 |  unix sockets.
 |  :py:class:`~redis.SSLConnection` can be used for SSL enabled connections.
 |
 |  If ``maint_notifications_config`` is provided, the connection pool will support
 |  maintenance notifications.
 |  Maintenance notifications are supported only with RESP3.
 |  If the ``maint_notifications_config`` is not provided but the ``protocol`` is 3,
 |  the maintenance notifications will be enabled by default.
 |
 |  Any additional keyword arguments are passed to the constructor of
 |  ``connection_class``.
 |
 |  Method resolution order:
 |      ConnectionPool
 |      MaintNotificationsAbstractConnectionPool
 |      ConnectionPoolInterface
 |      abc.ABC
 |      builtins.object
 |
 |  Methods defined here:
 |
 |  __del__(self) -> None
 |      Clean up connection pool and record metrics when garbage collected.
 |
 |  __enter__(self: ~_CP) -> ~_CP
 |
 |  __exit__(self, exc_type, exc_value, traceback) -> None
 |
 |  __init__(self, connection_class=<class 'redis.connection.Connection'>, max_connections: Optional[int] = None, cache_factory: Optional[redis.cache.CacheFactoryInterface] = None, maint_notifications_config: Optional[redis.maint_notifications.MaintNotificationsConfig] = None, **connection_kwargs)
 |      Initialize self.  See help(type(self)) for accurate signature.
 |
 |  __repr__(self) -> str
 |      Return repr(self).
 |
 |  close(self) -> None
 |      Close the pool, disconnecting all connections
 |
 |  disconnect(self, inuse_connections: bool = True) -> None
 |      Disconnects connections in the pool
 |
 |      If ``inuse_connections`` is True, disconnect connections that are
 |      currently in use, potentially by other threads. Otherwise only disconnect
 |      connections that are idle in the pool.
 |
 |  get_connection(self, command_name=None, *keys, **options) -> 'Connection'
 |      Get a connection from the pool
 |
 |  get_connection_count(self) -> List[tuple[int, dict]]
 |      Returns a connection count (both idle and in use).
 |
 |  get_encoder(self) -> redis._parsers.encoders.Encoder
 |      Return an encoder based on encoding settings
 |
 |  get_protocol(self)
 |      Returns:
 |          The RESP protocol version, or ``None`` if the protocol is not specified,
 |          in which case the server default will be used.
 |
 |  make_connection(self) -> 'ConnectionInterface'
 |      Create a new connection
 |
 |  owns_connection(self, connection: 'Connection') -> int
 |
 |  re_auth_callback(self, token: redis.auth.token.TokenInterface)
 |
 |  release(self, connection: 'Connection') -> None
 |      Releases the connection back to the pool
 |
 |  reset(self) -> None
 |
 |  set_retry(self, retry: redis.retry.Retry) -> None
 |
 |  ----------------------------------------------------------------------
 |  Class methods defined here:
 |
 |  from_url(url: str, **kwargs) -> ~_CP
 |      Return a connection pool configured from the given URL.
 |
 |      For example::
 |
 |          redis://[[username]:[password]]@localhost:6379/0
 |          rediss://[[username]:[password]]@localhost:6379/0
 |          unix://[username@]/path/to/socket.sock?db=0[&password=password]
 |
 |      Three URL schemes are supported:
 |
 |      - `redis://` creates a TCP socket connection. See more at:
 |        <https://www.iana.org/assignments/uri-schemes/prov/redis>
 |      - `rediss://` creates a SSL wrapped TCP socket connection. See more at:
 |        <https://www.iana.org/assignments/uri-schemes/prov/rediss>
 |      - ``unix://``: creates a Unix Domain Socket connection.
 |
 |      The username, password, hostname, path and all querystring values
 |      are passed through urllib.parse.unquote in order to replace any
 |      percent-encoded values with their corresponding characters.
 |
 |      There are several ways to specify a database number. The first value
 |      found will be used:
 |
 |          1. A ``db`` querystring option, e.g. redis://localhost?db=0
 |          2. If using the redis:// or rediss:// schemes, the path argument
 |             of the url, e.g. redis://localhost/0
 |          3. A ``db`` keyword argument to this function.
 |
 |      If none of these options are specified, the default db=0 is used.
 |
 |      All querystring options are cast to their appropriate Python types.
 |      Boolean arguments can be specified with string values "True"/"False"
 |      or "Yes"/"No". Values that cannot be properly cast cause a
 |      ``ValueError`` to be raised. Once parsed, the querystring arguments
 |      and keyword arguments are passed to the ``ConnectionPool``'s
 |      class initializer. In the case of conflicting arguments, querystring
 |      arguments always win.
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors defined here:
 |
 |  connection_kwargs
 |
 |  ----------------------------------------------------------------------
 |  Data and other attributes defined here:
 |
 |  OMIT_REPR_KEYS = frozenset({'himport_registry'})
 |
 |  SENSITIVE_REPR_KEYS = frozenset({'credential_provider', 'password', 's...
 |
 |  __abstractmethods__ = frozenset()
 |
 |  ----------------------------------------------------------------------
 |  Methods inherited from MaintNotificationsAbstractConnectionPool:
 |
 |  disconnect_free_connections(self, moving_address_src: Optional[str] = None)
 |      Disconnect all free/available connections.
 |      This is used when a cluster node is migrated to a different address.
 |
 |      :param moving_address_src: The address of the node that is being moved.
 |
 |  maint_notifications_enabled(self)
 |      Returns:
 |          True if the maintenance notifications are enabled, False otherwise.
 |          The maintenance notifications config is stored in the pool handler.
 |          If the pool handler is not set, the maintenance notifications are not enabled.
 |
 |  update_active_connections_for_reconnect(self, moving_address_src: Optional[str] = None)
 |      Mark all active connections for reconnect.
 |      This is used when a cluster node is migrated to a different address.
 |
 |      :param moving_address_src: The address of the node that is being moved.
 |
 |  update_connection_kwargs(self, **kwargs)
 |      Update the connection kwargs for all future connections.
 |
 |      This method updates the connection kwargs for all future connections created by the pool.
 |      Existing connections are not affected.
 |
 |  update_connection_settings(self, conn: 'MaintNotificationsAbstractConnection', state: Optional[ForwardRef('MaintenanceState')] = None, maintenance_notification_hash: Optional[int] = None, host_address: Optional[str] = None, relaxed_timeout: Optional[float] = None, update_notification_hash: bool = False, reset_host_address: bool = False, reset_relaxed_timeout: bool = False)
 |      Update the settings for a single connection.
 |
 |  update_connections_settings(self, state: Optional[ForwardRef('MaintenanceState')] = None, maintenance_notification_hash: Optional[int] = None, host_address: Optional[str] = None, relaxed_timeout: Optional[float] = None, matching_address: Optional[str] = None, matching_notification_hash: Optional[int] = None, matching_pattern: Literal['connected_address', 'configured_address', 'notification_hash'] = 'connected_address', update_notification_hash: bool = False, reset_host_address: bool = False, reset_relaxed_timeout: bool = False, include_free_connections: bool = True)
 |      Update the settings for all matching connections in the pool.
 |
 |      This method does not create new connections.
 |      This method does not affect the connection kwargs.
 |
 |      :param state: The maintenance state to set for the connection.
 |      :param maintenance_notification_hash: The hash of the maintenance notification
 |                                             to set for the connection.
 |      :param host_address: The host address to set for the connection.
 |      :param relaxed_timeout: The relaxed timeout to set for the connection.
 |      :param matching_address: The address to match for the connection.
 |      :param matching_notification_hash: The notification hash to match for the connection.
 |      :param matching_pattern: The pattern to match for the connection.
 |      :param update_notification_hash: Whether to update the notification hash for the connection.
 |      :param reset_host_address: Whether to reset the host address to the original address.
 |      :param reset_relaxed_timeout: Whether to reset the relaxed timeout to the original timeout.
 |      :param include_free_connections: Whether to include free/available connections.
 |
 |  update_maint_notifications_config(self, maint_notifications_config: redis.maint_notifications.MaintNotificationsConfig, oss_cluster_maint_notifications_handler: Optional[redis.maint_notifications.OSSMaintNotificationsHandler] = None)
 |      Updates the maintenance notifications configuration.
 |      This method should be called only if the pool was created
 |      without enabling the maintenance notifications and
 |      in a later point in time maintenance notifications
 |      are requested to be enabled.
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from MaintNotificationsAbstractConnectionPool:
 |
 |  __dict__
 |      dictionary for instance variables
 |
 |  __weakref__
 |      list of weak references to the object

Python Library Documentation: class CredentialProvider in module redis.credentials

class CredentialProvider(builtins.object)
 |  Credentials Provider.
 |
 |  Methods defined here:
 |
 |  get_credentials(self) -> Union[Tuple[str], Tuple[str, str]]
 |
 |  async get_credentials_async(self) -> Union[Tuple[str], Tuple[str, str]]
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors defined here:
 |
 |  __dict__
 |      dictionary for instance variables
 |
 |  __weakref__
 |      list of weak references to the object

Python Library Documentation: class CrossSlotTransactionError in module redis.exceptions

class CrossSlotTransactionError(RedisClusterException)
 |  CrossSlotTransactionError(*args: object) -> None
 |
 |  Raised when a transaction or watch is triggered in a pipeline
 |  and not all keys or all commands belong to the same slot.
 |
 |  Method resolution order:
 |      CrossSlotTransactionError
 |      RedisClusterException
 |      builtins.Exception
 |      builtins.BaseException
 |      builtins.object
 |
 |  Methods inherited from RedisClusterException:
 |
 |  __init__(self, *args: object) -> None
 |      Initialize self.  See help(type(self)) for accurate signature.
 |
 |  __repr__(self)
 |      Return repr(self).
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from RedisClusterException:
 |
 |  __weakref__
 |      list of weak references to the object
 |
 |  ----------------------------------------------------------------------
 |  Static methods inherited from builtins.Exception:
 |
 |  __new__(*args, **kwargs) class method of builtins.Exception
 |      Create and return a new object.  See help(type) for accurate signature.
 |
 |  ----------------------------------------------------------------------
 |  Methods inherited from builtins.BaseException:
 |
 |  __getattribute__(self, name, /)
 |      Return getattr(self, name).
 |
 |  __reduce__(...)
 |      Helper for pickle.
 |
 |  __setstate__(...)
 |
 |  __str__(self, /)
 |      Return str(self).
 |
 |  add_note(...)
 |      Exception.add_note(note) --
 |      add a note to the exception
 |
 |  with_traceback(...)
 |      Exception.with_traceback(tb) --
 |      set self.__traceback__ to tb and return self.
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from builtins.BaseException:
 |
 |  __cause__
 |      exception cause
 |
 |  __context__
 |      exception context
 |
 |  __dict__
 |
 |  __suppress_context__
 |
 |  __traceback__
 |
 |  args

Python Library Documentation: class DataError in module redis.exceptions

class DataError(RedisError)
 |  DataError(*args, status_code: str | None = None)
 |
 |  Method resolution order:
 |      DataError
 |      RedisError
 |      builtins.Exception
 |      builtins.BaseException
 |      builtins.object
 |
 |  Methods inherited from RedisError:
 |
 |  __init__(self, *args, status_code: str | None = None)
 |      Initialize self.  See help(type(self)) for accurate signature.
 |
 |  __repr__(self)
 |      Return repr(self).
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from RedisError:
 |
 |  __weakref__
 |      list of weak references to the object
 |
 |  ----------------------------------------------------------------------
 |  Static methods inherited from builtins.Exception:
 |
 |  __new__(*args, **kwargs) class method of builtins.Exception
 |      Create and return a new object.  See help(type) for accurate signature.
 |
 |  ----------------------------------------------------------------------
 |  Methods inherited from builtins.BaseException:
 |
 |  __getattribute__(self, name, /)
 |      Return getattr(self, name).
 |
 |  __reduce__(...)
 |      Helper for pickle.
 |
 |  __setstate__(...)
 |
 |  __str__(self, /)
 |      Return str(self).
 |
 |  add_note(...)
 |      Exception.add_note(note) --
 |      add a note to the exception
 |
 |  with_traceback(...)
 |      Exception.with_traceback(tb) --
 |      set self.__traceback__ to tb and return self.
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from builtins.BaseException:
 |
 |  __cause__
 |      exception cause
 |
 |  __context__
 |      exception context
 |
 |  __dict__
 |
 |  __suppress_context__
 |
 |  __traceback__
 |
 |  args

Python Library Documentation: class DriverInfo in module redis.driver_info

class DriverInfo(builtins.object)
 |  DriverInfo(name: 'Optional[str] | object' = <object object at 0x0000017B991493E0>, lib_version: 'Optional[str] | object' = <object object at 0x0000017B991493E0>, _upstream: 'List[str]' = <factory>) -> None
 |
 |  Driver information used to build the CLIENT SETINFO LIB-NAME and LIB-VER values.
 |
 |  This class consolidates all driver metadata (redis-py version and upstream drivers)
 |  into a single object that is propagated through connection pools and connections.
 |
 |  The formatted name follows the pattern::
 |
 |      name(driver1_vVersion1;driver2_vVersion2)
 |
 |  Parameters
 |  ----------
 |  name : str, optional
 |      The base library name. If omitted, defaults to "redis-py". If None,
 |      LIB-NAME will not be sent.
 |  lib_version : str, optional
 |      The redis-py library version. If omitted, the version will be determined
 |      automatically from the installed package. If None, LIB-VER will not be sent.
 |
 |  Examples
 |  --------
 |  >>> info = DriverInfo()
 |  >>> info.formatted_name
 |  'redis-py'
 |
 |  >>> info = DriverInfo().add_upstream_driver("django-redis", "5.4.0")
 |  >>> info.formatted_name
 |  'redis-py(django-redis_v5.4.0)'
 |
 |  >>> info = DriverInfo(lib_version="5.0.0")
 |  >>> info.lib_version
 |  '5.0.0'
 |
 |  Methods defined here:
 |
 |  __eq__(self, other)
 |      Return self==value.
 |
 |  __init__(self, name: 'Optional[str] | object' = <object object at 0x0000017B991493E0>, lib_version: 'Optional[str] | object' = <object object at 0x0000017B991493E0>, _upstream: 'List[str]' = <factory>) -> None
 |      Initialize self.  See help(type(self)) for accurate signature.
 |
 |  __post_init__(self)
 |      Initialize default metadata if not explicitly provided.
 |
 |  __repr__(self)
 |      Return repr(self).
 |
 |  add_upstream_driver(self, driver_name: 'str', driver_version: 'str') -> "'DriverInfo'"
 |      Add an upstream driver to this instance and return self.
 |
 |      The most recently added driver appears first in :pyattr:`formatted_name`.
 |
 |  ----------------------------------------------------------------------
 |  Readonly properties defined here:
 |
 |  formatted_name
 |      Return the base name with upstream drivers encoded, if any.
 |
 |      With no upstream drivers, this is just :pyattr:`name`. Otherwise::
 |
 |          name(driver1_vX;driver2_vY)
 |
 |  upstream_drivers
 |      Return a copy of the upstream driver entries.
 |
 |      Each entry is in the form ``"driver-name_vversion"``.
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors defined here:
 |
 |  __dict__
 |      dictionary for instance variables
 |
 |  __weakref__
 |      list of weak references to the object
 |
 |  ----------------------------------------------------------------------
 |  Data and other attributes defined here:
 |
 |  __annotations__ = {'_upstream': 'List[str]', 'lib_version': 'Optional[...
 |
 |  __dataclass_fields__ = {'_upstream': Field(name='_upstream',type='List...
 |
 |  __dataclass_params__ = _DataclassParams(init=True,repr=True,eq=True,or...
 |
 |  __hash__ = None
 |
 |  __match_args__ = ('name', 'lib_version', '_upstream')
 |
 |  lib_version = <object object>
 |
 |  name = <object object>

Python Library Documentation: class EventType in module redis.keyspace_notifications

class EventType(builtins.object)
 |  Common Redis keyspace notification event type constants.
 |
 |  These are provided for convenience and IDE autocomplete. You can use
 |  any string as an event type - new Redis events will work without
 |  needing library updates.
 |
 |  Data descriptors defined here:
 |
 |  __dict__
 |      dictionary for instance variables
 |
 |  __weakref__
 |      list of weak references to the object
 |
 |  ----------------------------------------------------------------------
 |  Data and other attributes defined here:
 |
 |  APPEND = 'append'
 |
 |  BLMOVE = 'blmove'
 |
 |  BLPOP = 'blpop'
 |
 |  BRPOP = 'brpop'
 |
 |  BZPOPMAX = 'bzpopmax'
 |
 |  BZPOPMIN = 'bzpopmin'
 |
 |  COPY_TO = 'copy_to'
 |
 |  DECR = 'decr'
 |
 |  DECRBY = 'decrby'
 |
 |  DEL = 'del'
 |
 |  EVICTED = 'evicted'
 |
 |  EXPIRE = 'expire'
 |
 |  EXPIREAT = 'expireat'
 |
 |  EXPIRED = 'expired'
 |
 |  GETDEL = 'getdel'
 |
 |  GETEX = 'getex'
 |
 |  HDEL = 'hdel'
 |
 |  HINCRBY = 'hincrby'
 |
 |  HINCRBYFLOAT = 'hincrbyfloat'
 |
 |  HSET = 'hset'
 |
 |  HSETNX = 'hsetnx'
 |
 |  INCR = 'incr'
 |
 |  INCRBY = 'incrby'
 |
 |  INCRBYFLOAT = 'incrbyfloat'
 |
 |  LINSERT = 'linsert'
 |
 |  LMOVE = 'lmove'
 |
 |  LPOP = 'lpop'
 |
 |  LPUSH = 'lpush'
 |
 |  LSET = 'lset'
 |
 |  LTRIM = 'ltrim'
 |
 |  MOVE = 'move'
 |
 |  NEW = 'new'
 |
 |  PERSIST = 'persist'
 |
 |  PEXPIRE = 'pexpire'
 |
 |  PEXPIREAT = 'pexpireat'
 |
 |  RENAME = 'rename'
 |
 |  RENAME_FROM = 'rename_from'
 |
 |  RENAME_TO = 'rename_to'
 |
 |  RESTORE = 'restore'
 |
 |  RPOP = 'rpop'
 |
 |  RPUSH = 'rpush'
 |
 |  SADD = 'sadd'
 |
 |  SDIFFSTORE = 'sdiffstore'
 |
 |  SET = 'set'
 |
 |  SETEX = 'setex'
 |
 |  SETIFEQ = 'setifeq'
 |
 |  SETIFGT = 'setifgt'
 |
 |  SETIFLT = 'setiflt'
 |
 |  SETIFNE = 'setifne'
 |
 |  SETNX = 'setnx'
 |
 |  SETRANGE = 'setrange'
 |
 |  SINTERSTORE = 'sinterstore'
 |
 |  SMOVE = 'smove'
 |
 |  SORTSTORE = 'sortstore'
 |
 |  SPOP = 'spop'
 |
 |  SREM = 'srem'
 |
 |  SUNIONSTORE = 'sunionstore'
 |
 |  UNLINK = 'unlink'
 |
 |  XADD = 'xadd'
 |
 |  XAUTOCLAIM = 'xautoclaim'
 |
 |  XCLAIM = 'xclaim'
 |
 |  XDEL = 'xdel'
 |
 |  XGROUP_CREATE = 'xgroup-create'
 |
 |  XGROUP_CREATECONSUMER = 'xgroup-createconsumer'
 |
 |  XGROUP_DELCONSUMER = 'xgroup-delconsumer'
 |
 |  XGROUP_DESTROY = 'xgroup-destroy'
 |
 |  XGROUP_SETID = 'xgroup-setid'
 |
 |  XREADGROUP = 'xreadgroup'
 |
 |  XSETID = 'xsetid'
 |
 |  XTRIM = 'xtrim'
 |
 |  ZADD = 'zadd'
 |
 |  ZDIFFSTORE = 'zdiffstore'
 |
 |  ZINCRBY = 'zincrby'
 |
 |  ZINTERSTORE = 'zinterstore'
 |
 |  ZPOPMAX = 'zpopmax'
 |
 |  ZPOPMIN = 'zpopmin'
 |
 |  ZRANGESTORE = 'zrangestore'
 |
 |  ZREM = 'zrem'
 |
 |  ZREMRANGEBYLEX = 'zremrangebylex'
 |
 |  ZREMRANGEBYRANK = 'zremrangebyrank'
 |
 |  ZREMRANGEBYSCORE = 'zremrangebyscore'
 |
 |  ZUNIONSTORE = 'zunionstore'

Python Library Documentation: class InvalidPipelineStack in module redis.exceptions

class InvalidPipelineStack(RedisClusterException)
 |  InvalidPipelineStack(*args: object) -> None
 |
 |  Raised on unexpected response length on pipelines. This is
 |  most likely a handling error on the stack.
 |
 |  Method resolution order:
 |      InvalidPipelineStack
 |      RedisClusterException
 |      builtins.Exception
 |      builtins.BaseException
 |      builtins.object
 |
 |  Methods inherited from RedisClusterException:
 |
 |  __init__(self, *args: object) -> None
 |      Initialize self.  See help(type(self)) for accurate signature.
 |
 |  __repr__(self)
 |      Return repr(self).
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from RedisClusterException:
 |
 |  __weakref__
 |      list of weak references to the object
 |
 |  ----------------------------------------------------------------------
 |  Static methods inherited from builtins.Exception:
 |
 |  __new__(*args, **kwargs) class method of builtins.Exception
 |      Create and return a new object.  See help(type) for accurate signature.
 |
 |  ----------------------------------------------------------------------
 |  Methods inherited from builtins.BaseException:
 |
 |  __getattribute__(self, name, /)
 |      Return getattr(self, name).
 |
 |  __reduce__(...)
 |      Helper for pickle.
 |
 |  __setstate__(...)
 |
 |  __str__(self, /)
 |      Return str(self).
 |
 |  add_note(...)
 |      Exception.add_note(note) --
 |      add a note to the exception
 |
 |  with_traceback(...)
 |      Exception.with_traceback(tb) --
 |      set self.__traceback__ to tb and return self.
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from builtins.BaseException:
 |
 |  __cause__
 |      exception cause
 |
 |  __context__
 |      exception context
 |
 |  __dict__
 |
 |  __suppress_context__
 |
 |  __traceback__
 |
 |  args

Python Library Documentation: class InvalidResponse in module redis.exceptions

class InvalidResponse(RedisError)
 |  InvalidResponse(*args, status_code: str | None = None)
 |
 |  Method resolution order:
 |      InvalidResponse
 |      RedisError
 |      builtins.Exception
 |      builtins.BaseException
 |      builtins.object
 |
 |  Methods inherited from RedisError:
 |
 |  __init__(self, *args, status_code: str | None = None)
 |      Initialize self.  See help(type(self)) for accurate signature.
 |
 |  __repr__(self)
 |      Return repr(self).
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from RedisError:
 |
 |  __weakref__
 |      list of weak references to the object
 |
 |  ----------------------------------------------------------------------
 |  Static methods inherited from builtins.Exception:
 |
 |  __new__(*args, **kwargs) class method of builtins.Exception
 |      Create and return a new object.  See help(type) for accurate signature.
 |
 |  ----------------------------------------------------------------------
 |  Methods inherited from builtins.BaseException:
 |
 |  __getattribute__(self, name, /)
 |      Return getattr(self, name).
 |
 |  __reduce__(...)
 |      Helper for pickle.
 |
 |  __setstate__(...)
 |
 |  __str__(self, /)
 |      Return str(self).
 |
 |  add_note(...)
 |      Exception.add_note(note) --
 |      add a note to the exception
 |
 |  with_traceback(...)
 |      Exception.with_traceback(tb) --
 |      set self.__traceback__ to tb and return self.
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from builtins.BaseException:
 |
 |  __cause__
 |      exception cause
 |
 |  __context__
 |      exception context
 |
 |  __dict__
 |
 |  __suppress_context__
 |
 |  __traceback__
 |
 |  args

Python Library Documentation: class KeyNotification in module redis.keyspace_notifications

class KeyNotification(builtins.object)
 |  KeyNotification(key: 'str', event_type: 'str', database: 'int', channel: 'str', is_keyspace: 'bool', data: 'str', subkeys: 'list[str]' = None) -> None
 |
 |  Represents a parsed Redis keyspace, keyevent, or subkey notification.
 |
 |  This class provides convenient access to the notification details
 |  like key, event type, database number, and affected subkeys.
 |
 |  Attributes:
 |      key: The Redis key that was affected (for keyspace notifications)
 |           or the key name from the message data (for keyevent notifications)
 |      event_type: The type of operation that occurred (e.g., "set", "del").
 |                 This is a plain string, so new Redis events work automatically.
 |                 Compare against EventType constants or any string.
 |      database: The database number where the event occurred
 |      channel: The original channel name
 |      is_keyspace: True if this is a keyspace notification, False for keyevent
 |      data: The raw data payload from the notification message.
 |      subkeys: List of affected subkeys (fields) for subkey notifications.
 |              Empty list for regular keyspace/keyevent notifications.
 |
 |  Methods defined here:
 |
 |  __eq__(self, other)
 |      Return self==value.
 |
 |  __init__(self, key: 'str', event_type: 'str', database: 'int', channel: 'str', is_keyspace: 'bool', data: 'str', subkeys: 'list[str]' = None) -> None
 |      Initialize self.  See help(type(self)) for accurate signature.
 |
 |  __post_init__(self)
 |
 |  __repr__(self)
 |      Return repr(self).
 |
 |  key_starts_with(self, prefix: 'str | bytes') -> 'bool'
 |      Check if the key starts with the given prefix.
 |
 |  ----------------------------------------------------------------------
 |  Class methods defined here:
 |
 |  from_message(message: 'dict[str, Any] | None', key_prefix: 'str | bytes | None' = None) -> 'KeyNotification | None'
 |      Parse a pub/sub message into a KeyNotification.
 |
 |      Args:
 |          message: A pub/sub message dict with 'channel', 'data', and 'type' keys
 |          key_prefix: Optional prefix to filter and strip from keys.
 |                     If provided, only notifications for keys starting with
 |                     this prefix will be returned, and the prefix will be
 |                     stripped from the key.
 |
 |      Returns:
 |          A KeyNotification if the message is a valid keyspace/keyevent
 |          notification, None otherwise.
 |
 |      Example:
 |          >>> message = {
 |          ...     'type': 'pmessage',
 |          ...     'pattern': '__keyspace@0__:user:*',
 |          ...     'channel': '__keyspace@0__:user:123',
 |          ...     'data': 'set'
 |          ... }
 |          >>> notification = KeyNotification.from_message(message)
 |          >>> notification.key
 |          'user:123'
 |          >>> notification.event_type
 |          'set'
 |
 |  try_parse(channel: 'str | bytes', data: 'str | bytes', key_prefix: 'str | bytes | None' = None) -> 'KeyNotification | None'
 |      Try to parse a channel and data into a KeyNotification.
 |
 |      This is a lower-level method that takes the channel and data directly,
 |      useful when working with callback-based subscription handlers.
 |
 |      Args:
 |          channel: The channel name (e.g., "__keyspace@0__:mykey")
 |          data: The message data (event type for keyspace, key for keyevent)
 |          key_prefix: Optional prefix to filter and strip from keys
 |
 |      Returns:
 |          A KeyNotification if valid, None otherwise.
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors defined here:
 |
 |  __dict__
 |      dictionary for instance variables
 |
 |  __weakref__
 |      list of weak references to the object
 |
 |  ----------------------------------------------------------------------
 |  Data and other attributes defined here:
 |
 |  __annotations__ = {'_KEYEVENT_PATTERN': 'ClassVar[re.Pattern]', '_KEYS...
 |
 |  __dataclass_fields__ = {'_KEYEVENT_PATTERN': Field(name='_KEYEVENT_PAT...
 |
 |  __dataclass_params__ = _DataclassParams(init=True,repr=True,eq=True,or...
 |
 |  __hash__ = None
 |
 |  __match_args__ = ('key', 'event_type', 'database', 'channel', 'is_keys...
 |
 |  subkeys = None

Python Library Documentation: class KeyeventChannel in module redis.keyspace_notifications

class KeyeventChannel(builtins.object)
 |  KeyeventChannel(event: 'str', db: 'int' = 0)
 |
 |  Represents a keyevent notification channel for subscribing to event types.
 |
 |  Keyevent notifications publish the key name as the message when the specified
 |  event type occurs on any key.
 |
 |  This class can be used directly with subscribe()/psubscribe() as it implements
 |  __str__ to return the channel string.
 |
 |  Attributes:
 |      event: The event type to monitor
 |      db: The database number (defaults to 0, the only database in Redis Cluster)
 |      is_pattern: Whether this channel contains wildcards
 |
 |  Examples:
 |      >>> channel = KeyeventChannel(EventType.SET, db=0)
 |      >>> str(channel)
 |      '__keyevent@0__:set'
 |
 |      >>> channel = KeyeventChannel.all_events(db=0)
 |      >>> str(channel)
 |      '__keyevent@0__:*'
 |
 |      >>> # Use with KeyspaceNotifications
 |      >>> notifications = KeyspaceNotifications(redis_client)
 |      >>> notifications.subscribe(channel)
 |
 |  Methods defined here:
 |
 |  __eq__(self, other: 'object') -> 'bool'
 |      Return self==value.
 |
 |  __hash__(self) -> 'int'
 |      Return hash(self).
 |
 |  __init__(self, event: 'str', db: 'int' = 0)
 |      Create a keyevent notification channel.
 |
 |      Args:
 |          event: The event type to monitor (e.g., EventType.SET or "set")
 |          db: The database number. Defaults to 0 (the only database in Redis Cluster).
 |
 |  __repr__(self) -> 'str'
 |      Return repr(self).
 |
 |  __str__(self) -> 'str'
 |      Return str(self).
 |
 |  ----------------------------------------------------------------------
 |  Class methods defined here:
 |
 |  all_events(db: 'int' = 0) -> "'KeyeventChannel'"
 |      Create a keyevent pattern for subscribing to all event types.
 |
 |      This is equivalent to KeyeventChannel("*").
 |
 |      Args:
 |          db: The database number. Defaults to 0 (the only database in Redis Cluster).
 |
 |      Returns:
 |          A KeyeventChannel configured to receive all events.
 |
 |      Examples:
 |          >>> channel = KeyeventChannel.all_events()
 |          >>> str(channel)
 |          '__keyevent@0__:*'
 |
 |  ----------------------------------------------------------------------
 |  Readonly properties defined here:
 |
 |  is_pattern
 |      Check if this channel contains wildcards and should use psubscribe.
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors defined here:
 |
 |  __dict__
 |      dictionary for instance variables
 |
 |  __weakref__
 |      list of weak references to the object
 |
 |  ----------------------------------------------------------------------
 |  Data and other attributes defined here:
 |
 |  PREFIX = '__keyevent@'
 |
 |  __annotations__ = {'PREFIX': 'ClassVar[str]'}

Python Library Documentation: class KeyspaceChannel in module redis.keyspace_notifications

class KeyspaceChannel(builtins.object)
 |  KeyspaceChannel(key_or_pattern: 'str', db: 'int' = 0)
 |
 |  Represents a keyspace notification channel for subscribing to events on keys.
 |
 |  Keyspace notifications publish the event type (e.g., "set", "del") as the message
 |  when a key matching the pattern is modified.
 |
 |  This class can be used directly with subscribe()/psubscribe() as it implements
 |  __str__ to return the channel string.
 |
 |  Attributes:
 |      key_or_pattern: The key or pattern to monitor (use '*' for wildcards)
 |      db: The database number (defaults to 0, the only database in Redis Cluster)
 |      is_pattern: Whether this channel contains wildcards
 |
 |  Examples:
 |      >>> channel = KeyspaceChannel("user:123", db=0)
 |      >>> str(channel)
 |      '__keyspace@0__:user:123'
 |
 |      >>> # Pattern subscription (wildcards are auto-detected)
 |      >>> channel = KeyspaceChannel("user:*", db=0)
 |      >>> str(channel)
 |      '__keyspace@0__:user:*'
 |
 |      >>> # Use with KeyspaceNotifications
 |      >>> notifications = KeyspaceNotifications(redis_client)
 |      >>> notifications.subscribe(channel)
 |
 |  Methods defined here:
 |
 |  __eq__(self, other: 'object') -> 'bool'
 |      Return self==value.
 |
 |  __hash__(self) -> 'int'
 |      Return hash(self).
 |
 |  __init__(self, key_or_pattern: 'str', db: 'int' = 0)
 |      Create a keyspace notification channel.
 |
 |      Args:
 |          key_or_pattern: The key or pattern to monitor. Use '*' for wildcards.
 |          db: The database number. Defaults to 0 (the only database in Redis Cluster).
 |
 |  __repr__(self) -> 'str'
 |      Return repr(self).
 |
 |  __str__(self) -> 'str'
 |      Return str(self).
 |
 |  ----------------------------------------------------------------------
 |  Readonly properties defined here:
 |
 |  is_pattern
 |      Check if this channel contains wildcards and should use psubscribe.
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors defined here:
 |
 |  __dict__
 |      dictionary for instance variables
 |
 |  __weakref__
 |      list of weak references to the object
 |
 |  ----------------------------------------------------------------------
 |  Data and other attributes defined here:
 |
 |  PREFIX = '__keyspace@'
 |
 |  __annotations__ = {'PREFIX': 'ClassVar[str]'}

Python Library Documentation: class KeyspaceNotifications in module redis.keyspace_notifications

class KeyspaceNotifications(AbstractKeyspaceNotifications)
 |  KeyspaceNotifications(redis_client: 'Redis', key_prefix: 'str | bytes | None' = None, ignore_subscribe_messages: 'bool' = True)
 |
 |  Manages keyspace notification subscriptions for standalone Redis.
 |
 |  For standalone Redis, keyspace notifications work with a single PubSub
 |  connection. This class wraps that connection and provides:
 |  - Automatic pattern vs exact channel detection
 |  - KeyNotification parsing with optional key_prefix filtering
 |  - Convenience methods for keyspace and keyevent subscriptions
 |  - Context manager and run_in_thread support
 |
 |  Method resolution order:
 |      KeyspaceNotifications
 |      AbstractKeyspaceNotifications
 |      KeyspaceNotificationsInterface
 |      abc.ABC
 |      builtins.object
 |
 |  Methods defined here:
 |
 |  __init__(self, redis_client: 'Redis', key_prefix: 'str | bytes | None' = None, ignore_subscribe_messages: 'bool' = True)
 |      Initialize the standalone keyspace notification manager.
 |
 |      Note: Keyspace notifications must be enabled on the Redis server via
 |      the ``notify-keyspace-events`` configuration option. This is a server-side
 |      configuration that should be done by your infrastructure/operations team.
 |
 |      Args:
 |          redis_client: A Redis client instance
 |          key_prefix: Optional prefix to filter and strip from keys in notifications
 |          ignore_subscribe_messages: If True, subscribe/unsubscribe confirmations
 |                                    are not returned by get_message/listen
 |
 |  close(self)
 |      Close the pubsub connection and clean up resources.
 |
 |  get_message(self, ignore_subscribe_messages: 'bool | None' = None, timeout: 'float' = 0.0) -> 'KeyNotification | None'
 |      Get the next keyspace notification if one is available.
 |
 |      Note: If a handler was registered for the channel, pubsub will call
 |      the handler directly and this method returns None for that message.
 |
 |      Args:
 |          ignore_subscribe_messages: If True, skip subscribe/unsubscribe messages.
 |                                    Defaults to the value set in __init__ (True).
 |          timeout: Time to wait for a message.
 |
 |      Returns:
 |          A KeyNotification if a notification is available and no handler
 |          was registered for the channel, None otherwise.
 |
 |  listen(self)
 |      Listen for keyspace notifications.
 |
 |      This is a generator that yields KeyNotification objects as they arrive.
 |      It blocks until a notification is received.
 |
 |      Yields:
 |          KeyNotification objects for each keyspace/keyevent notification.
 |
 |      Example:
 |          >>> for notification in ksn.listen():
 |          ...     print(f"{notification.key}: {notification.event_type}")
 |
 |  ----------------------------------------------------------------------
 |  Readonly properties defined here:
 |
 |  subscribed
 |      Check if there are any active subscriptions and not closed.
 |
 |  ----------------------------------------------------------------------
 |  Data and other attributes defined here:
 |
 |  __abstractmethods__ = frozenset()
 |
 |  ----------------------------------------------------------------------
 |  Methods inherited from AbstractKeyspaceNotifications:
 |
 |  __enter__(self)
 |
 |  __exit__(self, _exc_type, _exc_val, _exc_tb)
 |
 |  run_in_thread(self, poll_timeout: 'float' = 0.0, daemon: 'bool' = False, exception_handler: 'Callable[[BaseException, KeyspaceNotificationsInterface, KeyspaceWorkerThread], None] | None' = None) -> 'KeyspaceWorkerThread'
 |      Start a background thread that polls for notifications and triggers handlers.
 |
 |      This method spawns a thread that continuously calls get_message() to
 |      process incoming notifications. When a notification arrives, any
 |      registered handler for that channel/pattern is invoked automatically.
 |
 |      All subscriptions must have handlers registered before calling this method.
 |
 |      Args:
 |          poll_timeout: Timeout in seconds for get_message() calls. When no message
 |                       is available, the thread waits up to this long before checking
 |                       again. Default 0.0 (non-blocking). WARNING: the default
 |                       causes a CPU spin-loop. It is preferred to pass a positive
 |                       value (e.g. 0.1 or 1.0).
 |          daemon: If True, the thread will be a daemon thread and will be
 |                 terminated when the main program exits. Default False.
 |          exception_handler: Optional callback invoked when an exception occurs
 |                            in the worker thread. Receives (exception, notifications,
 |                            thread) as arguments. If None, exceptions are raised.
 |
 |      Returns:
 |          KeyspaceWorkerThread: The started worker thread. Call stop() on it
 |                               to stop the thread and close the notifications.
 |
 |      Raises:
 |          RedisError: If any subscription doesn't have a handler registered.
 |
 |      Example:
 |          >>> def my_handler(notification):
 |          ...     print(f"Got: {notification.key} - {notification.event_type}")
 |          >>>
 |          >>> notifications.subscribe(KeyspaceChannel("user:*"), handler=my_handler)
 |          >>> thread = notifications.run_in_thread(poll_timeout=0.1, daemon=True)
 |          >>> # ... handlers are called automatically ...
 |          >>> thread.stop()
 |
 |  subscribe(self, *channels: 'ChannelT', handler: 'SyncHandlerT | None' = None)
 |      Subscribe to keyspace notification channels.
 |
 |      Automatically detects whether each channel is a pattern (contains
 |      wildcards like *, ?, [) or an exact channel name and uses the
 |      appropriate Redis subscribe command internally.
 |
 |      Args:
 |          *channels: Channels to subscribe to. Can be strings, KeyspaceChannel,
 |                    or KeyeventChannel objects. Patterns are auto-detected.
 |          handler: Optional callback function that receives KeyNotification
 |                  objects. If provided, notifications are passed to the handler
 |                  instead of being returned by get_message()/listen().
 |
 |  subscribe_keyevent(self, event: 'str', db: 'int' = 0, handler: 'SyncHandlerT | None' = None)
 |      Subscribe to keyevent notifications for specific event types.
 |
 |      Args:
 |          event: The event type to monitor (e.g., EventType.SET or "set")
 |          db: The database number (default 0).
 |          handler: Optional callback for notifications.
 |
 |      Example:
 |          >>> ksn.subscribe_keyevent(EventType.SET)
 |          >>> ksn.subscribe_keyevent(EventType.EXPIRED, handler=my_handler)
 |
 |  subscribe_keyspace(self, key_or_pattern: 'str', db: 'int' = 0, handler: 'SyncHandlerT | None' = None)
 |      Subscribe to keyspace notifications for specific keys.
 |
 |      Args:
 |          key_or_pattern: The key or pattern to monitor. Use '*' for wildcards.
 |          db: The database number (default 0).
 |          handler: Optional callback for notifications.
 |
 |      Example:
 |          >>> ksn.subscribe_keyspace("user:123", db=0)
 |          >>> ksn.subscribe_keyspace("user:*", db=0)
 |
 |  subscribe_subkeyevent(self, event: 'str', db: 'int' = 0, handler: 'SyncHandlerT | None' = None)
 |      Subscribe to subkeyevent notifications for specific event types.
 |
 |      Receives the affected key and subkeys when the given event occurs.
 |
 |      Args:
 |          event: The event type to monitor (e.g., "hset", "hdel").
 |          db: The database number (default 0).
 |          handler: Optional callback for notifications.
 |
 |  subscribe_subkeyspace(self, key_or_pattern: 'str', db: 'int' = 0, handler: 'SyncHandlerT | None' = None)
 |      Subscribe to subkeyspace notifications for specific keys.
 |
 |      Receives events with affected subkeys (fields) for the given key.
 |
 |      Args:
 |          key_or_pattern: The key or pattern to monitor.
 |          db: The database number (default 0).
 |          handler: Optional callback for notifications.
 |
 |  subscribe_subkeyspaceevent(self, event: 'str', key_or_pattern: 'str', db: 'int' = 0, handler: 'SyncHandlerT | None' = None)
 |      Subscribe to subkeyspaceevent notifications for an event on a key.
 |
 |      Receives the affected subkeys when the given event occurs on the
 |      given key.
 |
 |      Args:
 |          event: The event type to monitor.
 |          key_or_pattern: The key or pattern to monitor.
 |          db: The database number (default 0).
 |          handler: Optional callback for notifications.
 |
 |  subscribe_subkeyspaceitem(self, key_or_pattern: 'str', subkey_or_pattern: 'str', db: 'int' = 0, handler: 'SyncHandlerT | None' = None)
 |      Subscribe to subkeyspaceitem notifications for a specific subkey.
 |
 |      Receives the event type when the given subkey of the given key is
 |      modified.
 |
 |      Args:
 |          key_or_pattern: The key or pattern to monitor.
 |          subkey_or_pattern: The subkey (field) or pattern to monitor.
 |          db: The database number (default 0).
 |          handler: Optional callback for notifications.
 |
 |  unsubscribe(self, *channels: 'ChannelT')
 |      Unsubscribe from keyspace notification channels.
 |
 |      Automatically detects whether each channel is a pattern or exact
 |      channel and uses the appropriate Redis unsubscribe command.
 |
 |      Args:
 |          *channels: Channels to unsubscribe from.
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from KeyspaceNotificationsInterface:
 |
 |  __dict__
 |      dictionary for instance variables
 |
 |  __weakref__
 |      list of weak references to the object

Python Library Documentation: class KeyspaceNotificationsInterface in module redis.keyspace_notifications

class KeyspaceNotificationsInterface(abc.ABC)
 |  Interface for keyspace notification managers.
 |
 |  This interface provides a consistent API for both standalone (KeyspaceNotifications)
 |  and cluster (ClusterKeyspaceNotifications) implementations, allowing the same
 |  code patterns to work with both standalone and cluster Redis deployments.
 |
 |  Method resolution order:
 |      KeyspaceNotificationsInterface
 |      abc.ABC
 |      builtins.object
 |
 |  Methods defined here:
 |
 |  __enter__(self)
 |
 |  __exit__(self, _exc_type, _exc_val, _exc_tb)
 |
 |  close(self)
 |      Close the notification manager and clean up resources.
 |
 |  get_message(self, ignore_subscribe_messages: 'bool | None' = None, timeout: 'float' = 0.0) -> 'KeyNotification | None'
 |      Get the next keyspace notification if one is available.
 |
 |  listen(self)
 |      Listen for keyspace notifications.
 |
 |  run_in_thread(self, poll_timeout: 'float' = 0.0, daemon: 'bool' = False, exception_handler: 'Callable[[BaseException, KeyspaceNotificationsInterface, KeyspaceWorkerThread], None] | None' = None) -> 'KeyspaceWorkerThread'
 |      Start a background thread that polls for notifications.
 |
 |  subscribe(self, *channels: 'ChannelT', handler: 'SyncHandlerT | None' = None)
 |      Subscribe to keyspace notification channels.
 |
 |  subscribe_keyevent(self, event: 'str', db: 'int' = 0, handler: 'SyncHandlerT | None' = None)
 |      Subscribe to keyevent notifications for specific event types.
 |
 |  subscribe_keyspace(self, key_or_pattern: 'str', db: 'int' = 0, handler: 'SyncHandlerT | None' = None)
 |      Subscribe to keyspace notifications for specific keys.
 |
 |  subscribe_subkeyevent(self, event: 'str', db: 'int' = 0, handler: 'SyncHandlerT | None' = None)
 |      Subscribe to subkeyevent notifications for specific event types.
 |
 |  subscribe_subkeyspace(self, key_or_pattern: 'str', db: 'int' = 0, handler: 'SyncHandlerT | None' = None)
 |      Subscribe to subkeyspace notifications for specific keys.
 |
 |  subscribe_subkeyspaceevent(self, event: 'str', key_or_pattern: 'str', db: 'int' = 0, handler: 'SyncHandlerT | None' = None)
 |      Subscribe to subkeyspaceevent notifications for an event on a key.
 |
 |  subscribe_subkeyspaceitem(self, key_or_pattern: 'str', subkey_or_pattern: 'str', db: 'int' = 0, handler: 'SyncHandlerT | None' = None)
 |      Subscribe to subkeyspaceitem notifications for a specific subkey.
 |
 |  unsubscribe(self, *channels: 'ChannelT')
 |      Unsubscribe from keyspace notification channels.
 |
 |  ----------------------------------------------------------------------
 |  Readonly properties defined here:
 |
 |  subscribed
 |      Check if there are any active subscriptions and not closed.
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors defined here:
 |
 |  __dict__
 |      dictionary for instance variables
 |
 |  __weakref__
 |      list of weak references to the object
 |
 |  ----------------------------------------------------------------------
 |  Data and other attributes defined here:
 |
 |  __abstractmethods__ = frozenset({'__enter__', '__exit__', 'close', 'ge...

Python Library Documentation: class KeyspaceWorkerThread in module redis.keyspace_notifications

class KeyspaceWorkerThread(threading.Thread)
 |  KeyspaceWorkerThread(notifications: 'KeyspaceNotificationsInterface', poll_timeout: 'float', daemon: 'bool' = False, exception_handler: 'Callable[[BaseException, KeyspaceNotificationsInterface, KeyspaceWorkerThread], None] | None' = None)
 |
 |  Background thread for processing keyspace notifications.
 |
 |  This thread continuously polls for notifications and invokes registered
 |  handlers. It works with both KeyspaceNotifications (standalone) and
 |  ClusterKeyspaceNotifications.
 |
 |  Example:
 |      >>> thread = notifications.run_in_thread(poll_timeout=0.1)
 |      >>> # ... handlers are called automatically ...
 |      >>> thread.stop()
 |
 |  Method resolution order:
 |      KeyspaceWorkerThread
 |      threading.Thread
 |      builtins.object
 |
 |  Methods defined here:
 |
 |  __init__(self, notifications: 'KeyspaceNotificationsInterface', poll_timeout: 'float', daemon: 'bool' = False, exception_handler: 'Callable[[BaseException, KeyspaceNotificationsInterface, KeyspaceWorkerThread], None] | None' = None)
 |      This constructor should always be called with keyword arguments. Arguments are:
 |
 |      *group* should be None; reserved for future extension when a ThreadGroup
 |      class is implemented.
 |
 |      *target* is the callable object to be invoked by the run()
 |      method. Defaults to None, meaning nothing is called.
 |
 |      *name* is the thread name. By default, a unique name is constructed of
 |      the form "Thread-N" where N is a small decimal number.
 |
 |      *args* is a list or tuple of arguments for the target invocation. Defaults to ().
 |
 |      *kwargs* is a dictionary of keyword arguments for the target
 |      invocation. Defaults to {}.
 |
 |      If a subclass overrides the constructor, it must make sure to invoke
 |      the base class constructor (Thread.__init__()) before doing anything
 |      else to the thread.
 |
 |  run(self) -> 'None'
 |      Main loop that polls for notifications and triggers handlers.
 |
 |  stop(self) -> 'None'
 |      Stop the worker thread.
 |
 |      This signals the thread to exit its run loop. The thread will close
 |      the notifications object before terminating.
 |
 |  ----------------------------------------------------------------------
 |  Methods inherited from threading.Thread:
 |
 |  __repr__(self)
 |      Return repr(self).
 |
 |  getName(self)
 |      Return a string used for identification purposes only.
 |
 |      This method is deprecated, use the name attribute instead.
 |
 |  isDaemon(self)
 |      Return whether this thread is a daemon.
 |
 |      This method is deprecated, use the daemon attribute instead.
 |
 |  is_alive(self)
 |      Return whether the thread is alive.
 |
 |      This method returns True just before the run() method starts until just
 |      after the run() method terminates. See also the module function
 |      enumerate().
 |
 |  join(self, timeout=None)
 |      Wait until the thread terminates.
 |
 |      This blocks the calling thread until the thread whose join() method is
 |      called terminates -- either normally or through an unhandled exception
 |      or until the optional timeout occurs.
 |
 |      When the timeout argument is present and not None, it should be a
 |      floating-point number specifying a timeout for the operation in seconds
 |      (or fractions thereof). As join() always returns None, you must call
 |      is_alive() after join() to decide whether a timeout happened -- if the
 |      thread is still alive, the join() call timed out.
 |
 |      When the timeout argument is not present or None, the operation will
 |      block until the thread terminates.
 |
 |      A thread can be join()ed many times.
 |
 |      join() raises a RuntimeError if an attempt is made to join the current
 |      thread as that would cause a deadlock. It is also an error to join() a
 |      thread before it has been started and attempts to do so raises the same
 |      exception.
 |
 |  setDaemon(self, daemonic)
 |      Set whether this thread is a daemon.
 |
 |      This method is deprecated, use the .daemon property instead.
 |
 |  setName(self, name)
 |      Set the name string for this thread.
 |
 |      This method is deprecated, use the name attribute instead.
 |
 |  start(self)
 |      Start the thread's activity.
 |
 |      It must be called at most once per thread object. It arranges for the
 |      object's run() method to be invoked in a separate thread of control.
 |
 |      This method will raise a RuntimeError if called more than once on the
 |      same thread object.
 |
 |  ----------------------------------------------------------------------
 |  Readonly properties inherited from threading.Thread:
 |
 |  ident
 |      Thread identifier of this thread or None if it has not been started.
 |
 |      This is a nonzero integer. See the get_ident() function. Thread
 |      identifiers may be recycled when a thread exits and another thread is
 |      created. The identifier is available even after the thread has exited.
 |
 |  native_id
 |      Native integral thread ID of this thread, or None if it has not been started.
 |
 |      This is a non-negative integer. See the get_native_id() function.
 |      This represents the Thread ID as reported by the kernel.
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from threading.Thread:
 |
 |  __dict__
 |      dictionary for instance variables
 |
 |  __weakref__
 |      list of weak references to the object
 |
 |  daemon
 |      A boolean value indicating whether this thread is a daemon thread.
 |
 |      This must be set before start() is called, otherwise RuntimeError is
 |      raised. Its initial value is inherited from the creating thread; the
 |      main thread is not a daemon thread and therefore all threads created in
 |      the main thread default to daemon = False.
 |
 |      The entire Python program exits when only daemon threads are left.
 |
 |  name
 |      A string used for identification purposes only.
 |
 |      It has no semantics. Multiple threads may be given the same name. The
 |      initial name is set by the constructor.

Python Library Documentation: class MaxConnectionsError in module redis.exceptions

class MaxConnectionsError(ConnectionError)
 |  MaxConnectionsError(*args, status_code: str | None = None)
 |
 |  Raised when a connection pool has reached its max_connections limit.
 |  This indicates pool exhaustion rather than an actual connection failure.
 |
 |  Method resolution order:
 |      MaxConnectionsError
 |      ConnectionError
 |      RedisError
 |      builtins.Exception
 |      builtins.BaseException
 |      builtins.object
 |
 |  Methods inherited from ConnectionError:
 |
 |  __init__(self, *args, status_code: str | None = None)
 |      Initialize self.  See help(type(self)) for accurate signature.
 |
 |  ----------------------------------------------------------------------
 |  Methods inherited from RedisError:
 |
 |  __repr__(self)
 |      Return repr(self).
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from RedisError:
 |
 |  __weakref__
 |      list of weak references to the object
 |
 |  ----------------------------------------------------------------------
 |  Static methods inherited from builtins.Exception:
 |
 |  __new__(*args, **kwargs) class method of builtins.Exception
 |      Create and return a new object.  See help(type) for accurate signature.
 |
 |  ----------------------------------------------------------------------
 |  Methods inherited from builtins.BaseException:
 |
 |  __getattribute__(self, name, /)
 |      Return getattr(self, name).
 |
 |  __reduce__(...)
 |      Helper for pickle.
 |
 |  __setstate__(...)
 |
 |  __str__(self, /)
 |      Return str(self).
 |
 |  add_note(...)
 |      Exception.add_note(note) --
 |      add a note to the exception
 |
 |  with_traceback(...)
 |      Exception.with_traceback(tb) --
 |      set self.__traceback__ to tb and return self.
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from builtins.BaseException:
 |
 |  __cause__
 |      exception cause
 |
 |  __context__
 |      exception context
 |
 |  __dict__
 |
 |  __suppress_context__
 |
 |  __traceback__
 |
 |  args

Python Library Documentation: class OutOfMemoryError in module redis.exceptions

class OutOfMemoryError(ResponseError)
 |  OutOfMemoryError(*args, status_code: str | None = None)
 |
 |  Indicates the database is full. Can only occur when either:
 |    * Redis maxmemory-policy=noeviction
 |    * Redis maxmemory-policy=volatile* and there are no evictable keys
 |
 |  For more information see `Memory optimization in Redis <https://redis.io/docs/management/optimization/memory-optimization/#memory-allocation>`_. # noqa
 |
 |  Method resolution order:
 |      OutOfMemoryError
 |      ResponseError
 |      RedisError
 |      builtins.Exception
 |      builtins.BaseException
 |      builtins.object
 |
 |  Methods inherited from RedisError:
 |
 |  __init__(self, *args, status_code: str | None = None)
 |      Initialize self.  See help(type(self)) for accurate signature.
 |
 |  __repr__(self)
 |      Return repr(self).
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from RedisError:
 |
 |  __weakref__
 |      list of weak references to the object
 |
 |  ----------------------------------------------------------------------
 |  Static methods inherited from builtins.Exception:
 |
 |  __new__(*args, **kwargs) class method of builtins.Exception
 |      Create and return a new object.  See help(type) for accurate signature.
 |
 |  ----------------------------------------------------------------------
 |  Methods inherited from builtins.BaseException:
 |
 |  __getattribute__(self, name, /)
 |      Return getattr(self, name).
 |
 |  __reduce__(...)
 |      Helper for pickle.
 |
 |  __setstate__(...)
 |
 |  __str__(self, /)
 |      Return str(self).
 |
 |  add_note(...)
 |      Exception.add_note(note) --
 |      add a note to the exception
 |
 |  with_traceback(...)
 |      Exception.with_traceback(tb) --
 |      set self.__traceback__ to tb and return self.
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from builtins.BaseException:
 |
 |  __cause__
 |      exception cause
 |
 |  __context__
 |      exception context
 |
 |  __dict__
 |
 |  __suppress_context__
 |
 |  __traceback__
 |
 |  args

Python Library Documentation: class PubSubError in module redis.exceptions

class PubSubError(RedisError)
 |  PubSubError(*args, status_code: str | None = None)
 |
 |  Method resolution order:
 |      PubSubError
 |      RedisError
 |      builtins.Exception
 |      builtins.BaseException
 |      builtins.object
 |
 |  Methods inherited from RedisError:
 |
 |  __init__(self, *args, status_code: str | None = None)
 |      Initialize self.  See help(type(self)) for accurate signature.
 |
 |  __repr__(self)
 |      Return repr(self).
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from RedisError:
 |
 |  __weakref__
 |      list of weak references to the object
 |
 |  ----------------------------------------------------------------------
 |  Static methods inherited from builtins.Exception:
 |
 |  __new__(*args, **kwargs) class method of builtins.Exception
 |      Create and return a new object.  See help(type) for accurate signature.
 |
 |  ----------------------------------------------------------------------
 |  Methods inherited from builtins.BaseException:
 |
 |  __getattribute__(self, name, /)
 |      Return getattr(self, name).
 |
 |  __reduce__(...)
 |      Helper for pickle.
 |
 |  __setstate__(...)
 |
 |  __str__(self, /)
 |      Return str(self).
 |
 |  add_note(...)
 |      Exception.add_note(note) --
 |      add a note to the exception
 |
 |  with_traceback(...)
 |      Exception.with_traceback(tb) --
 |      set self.__traceback__ to tb and return self.
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from builtins.BaseException:
 |
 |  __cause__
 |      exception cause
 |
 |  __context__
 |      exception context
 |
 |  __dict__
 |
 |  __suppress_context__
 |
 |  __traceback__
 |
 |  args

Python Library Documentation: class ReadOnlyError in module redis.exceptions

class ReadOnlyError(ResponseError)
 |  ReadOnlyError(*args, status_code: str | None = None)
 |
 |  Method resolution order:
 |      ReadOnlyError
 |      ResponseError
 |      RedisError
 |      builtins.Exception
 |      builtins.BaseException
 |      builtins.object
 |
 |  Methods inherited from RedisError:
 |
 |  __init__(self, *args, status_code: str | None = None)
 |      Initialize self.  See help(type(self)) for accurate signature.
 |
 |  __repr__(self)
 |      Return repr(self).
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from RedisError:
 |
 |  __weakref__
 |      list of weak references to the object
 |
 |  ----------------------------------------------------------------------
 |  Static methods inherited from builtins.Exception:
 |
 |  __new__(*args, **kwargs) class method of builtins.Exception
 |      Create and return a new object.  See help(type) for accurate signature.
 |
 |  ----------------------------------------------------------------------
 |  Methods inherited from builtins.BaseException:
 |
 |  __getattribute__(self, name, /)
 |      Return getattr(self, name).
 |
 |  __reduce__(...)
 |      Helper for pickle.
 |
 |  __setstate__(...)
 |
 |  __str__(self, /)
 |      Return str(self).
 |
 |  add_note(...)
 |      Exception.add_note(note) --
 |      add a note to the exception
 |
 |  with_traceback(...)
 |      Exception.with_traceback(tb) --
 |      set self.__traceback__ to tb and return self.
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from builtins.BaseException:
 |
 |  __cause__
 |      exception cause
 |
 |  __context__
 |      exception context
 |
 |  __dict__
 |
 |  __suppress_context__
 |
 |  __traceback__
 |
 |  args

Python Library Documentation: class Redis in module redis.client

class Redis(redis.commands.redismodules.RedisModuleCommands, redis.commands.core.CoreCommands, redis.commands.sentinel.SentinelCommands)
 |  Redis(host: str = 'localhost', port: int = 6379, db: int = 0, password: str | None = None, socket_timeout: float | None = 5, socket_connect_timeout: float | None = 5, socket_read_size: int = 32768, socket_keepalive: bool | None = True, socket_keepalive_options: Union[Mapping[int, int | bytes], object, NoneType] = <object object at 0x0000017B991493E0>, connection_pool: redis.connection.ConnectionPool | None = None, unix_socket_path: str | None = None, encoding: str = 'utf-8', encoding_errors: str = 'strict', decode_responses: bool = False, retry_on_timeout: bool = False, retry: redis.retry.Retry = <redis.retry.Retry object at 0x0000017B9C6BD640>, retry_on_error: Optional[List[Type[Exception]]] = None, ssl: bool = False, ssl_keyfile: str | None = None, ssl_certfile: str | None = None, ssl_cert_reqs: 'str | ssl.VerifyMode' = 'required', ssl_include_verify_flags: Optional[List[ForwardRef('ssl.VerifyFlags')]] = None, ssl_exclude_verify_flags: Optional[List[ForwardRef('ssl.VerifyFlags')]] = None, ssl_ca_certs: str | None = None, ssl_ca_path: str | None = None, ssl_ca_data: str | None = None, ssl_check_hostname: bool = True, ssl_password: str | None = None, ssl_validate_ocsp: bool = False, ssl_validate_ocsp_stapled: bool = False, ssl_ocsp_context: 'OpenSSL.SSL.Context | None' = None, ssl_ocsp_expected_cert: str | None = None, ssl_min_version: 'ssl.TLSVersion | None' = None, ssl_ciphers: str | None = None, max_connections: int | None = None, single_connection_client: bool = False, health_check_interval: int = 0, client_name: str | None = None, lib_name: str | object | None = <object object at 0x0000017B991493E0>, lib_version: str | object | None = <object object at 0x0000017B991493E0>, driver_info: redis.driver_info.DriverInfo | object | None = <object object at 0x0000017B991493E0>, username: str | None = None, redis_connect_func: Optional[Callable[[], NoneType]] = None, credential_provider: redis.credentials.CredentialProvider | None = None, protocol: int | None = None, legacy_responses: bool = True, cache: redis.cache.CacheInterface | None = None, cache_config: redis.cache.CacheConfig | None = None, event_dispatcher: redis.event.EventDispatcher | None = None, maint_notifications_config: redis.maint_notifications.MaintNotificationsConfig | None = None, oss_cluster_maint_notifications_handler: redis.maint_notifications.OSSMaintNotificationsHandler | None = None) -> None
 |
 |  Implementation of the Redis protocol.
 |
 |  This abstract class provides a Python interface to all Redis commands
 |  and an implementation of the Redis protocol.
 |
 |  Pipelines derive from this, implementing how
 |  the commands are sent and received to the Redis server. Based on
 |  configuration, an instance will either use a ConnectionPool, or
 |  Connection object to talk to redis.
 |
 |  It is not safe to pass PubSub or Pipeline objects between threads.
 |
 |  Method resolution order:
 |      Redis
 |      redis.commands.redismodules.RedisModuleCommands
 |      redis.commands.core.CoreCommands
 |      redis.commands.core.ACLCommands
 |      redis.commands.core.ClusterCommands
 |      redis.commands.core.DataAccessCommands
 |      redis.commands.core.BasicKeyCommands
 |      redis.commands.core.HyperlogCommands
 |      redis.commands.core.HashCommands
 |      redis.commands.core.GeoCommands
 |      redis.commands.core.ListCommands
 |      redis.commands.core.ArrayCommands
 |      redis.commands.core.ScanCommands
 |      redis.commands.core.SetCommands
 |      redis.commands.core.StreamCommands
 |      redis.commands.core.SortedSetCommands
 |      redis.commands.core.ManagementCommands
 |      redis.commands.core.ModuleCommands
 |      redis.commands.core.PubSubCommands
 |      redis.commands.core.ScriptCommands
 |      redis.typing.CommandsProtocol
 |      typing.Protocol
 |      typing.Generic
 |      redis.commands.core.FunctionCommands
 |      redis.commands.sentinel.SentinelCommands
 |      builtins.object
 |
 |  Methods defined here:
 |
 |  __del__(self)
 |
 |  __enter__(self)
 |
 |  __exit__(self, exc_type, exc_value, traceback)
 |
 |  __init__(self, host: str = 'localhost', port: int = 6379, db: int = 0, password: str | None = None, socket_timeout: float | None = 5, socket_connect_timeout: float | None = 5, socket_read_size: int = 32768, socket_keepalive: bool | None = True, socket_keepalive_options: Union[Mapping[int, int | bytes], object, NoneType] = <object object at 0x0000017B991493E0>, connection_pool: redis.connection.ConnectionPool | None = None, unix_socket_path: str | None = None, encoding: str = 'utf-8', encoding_errors: str = 'strict', decode_responses: bool = False, retry_on_timeout: bool = False, retry: redis.retry.Retry = <redis.retry.Retry object at 0x0000017B9C6BD640>, retry_on_error: Optional[List[Type[Exception]]] = None, ssl: bool = False, ssl_keyfile: str | None = None, ssl_certfile: str | None = None, ssl_cert_reqs: 'str | ssl.VerifyMode' = 'required', ssl_include_verify_flags: Optional[List[ForwardRef('ssl.VerifyFlags')]] = None, ssl_exclude_verify_flags: Optional[List[ForwardRef('ssl.VerifyFlags')]] = None, ssl_ca_certs: str | None = None, ssl_ca_path: str | None = None, ssl_ca_data: str | None = None, ssl_check_hostname: bool = True, ssl_password: str | None = None, ssl_validate_ocsp: bool = False, ssl_validate_ocsp_stapled: bool = False, ssl_ocsp_context: 'OpenSSL.SSL.Context | None' = None, ssl_ocsp_expected_cert: str | None = None, ssl_min_version: 'ssl.TLSVersion | None' = None, ssl_ciphers: str | None = None, max_connections: int | None = None, single_connection_client: bool = False, health_check_interval: int = 0, client_name: str | None = None, lib_name: str | object | None = <object object at 0x0000017B991493E0>, lib_version: str | object | None = <object object at 0x0000017B991493E0>, driver_info: redis.driver_info.DriverInfo | object | None = <object object at 0x0000017B991493E0>, username: str | None = None, redis_connect_func: Optional[Callable[[], NoneType]] = None, credential_provider: redis.credentials.CredentialProvider | None = None, protocol: int | None = None, legacy_responses: bool = True, cache: redis.cache.CacheInterface | None = None, cache_config: redis.cache.CacheConfig | None = None, event_dispatcher: redis.event.EventDispatcher | None = None, maint_notifications_config: redis.maint_notifications.MaintNotificationsConfig | None = None, oss_cluster_maint_notifications_handler: redis.maint_notifications.OSSMaintNotificationsHandler | None = None) -> None
 |      Initialize a new Redis client.
 |
 |      To specify a retry policy for specific errors, you have two options:
 |
 |      1. Set the `retry_on_error` to a list of the error/s to retry on, and
 |      you can also set `retry` to a valid `Retry` object(in case the default
 |      one is not appropriate) - with this approach the retries will be triggered
 |      on the default errors specified in the Retry object enriched with the
 |      errors specified in `retry_on_error`.
 |
 |      2. Define a `Retry` object with configured 'supported_errors' and set
 |      it to the `retry` parameter - with this approach you completely redefine
 |      the errors on which retries will happen.
 |
 |      `retry_on_timeout` is deprecated - please include the TimeoutError
 |      either in the Retry object or in the `retry_on_error` list.
 |
 |      When 'connection_pool' is provided - the retry configuration of the
 |      provided pool will be used.
 |
 |      Args:
 |
 |      socket_keepalive:
 |          if `True`, TCP keepalive is enabled for TCP socket connections.
 |          Argument is ignored when connection_pool is provided.
 |      socket_keepalive_options:
 |          mapping of TCP keepalive socket option constants to values, for
 |          example `{socket.TCP_KEEPIDLE: 30}`. If left unspecified, redis-py
 |          uses TCP keepalive defaults when `socket_keepalive` is enabled:
 |          idle 30 seconds, interval 5 seconds, and 3 probes. Platform-specific
 |          options that are not available are skipped. Pass `None` or `{}` to
 |          avoid setting additional TCP keepalive options. Argument is ignored
 |          when connection_pool is provided.
 |      single_connection_client:
 |          if `True`, connection pool is not used. In that case `Redis`
 |          instance use is not thread safe.
 |      decode_responses:
 |          if `True`, the response will be decoded to utf-8.
 |          Argument is ignored when connection_pool is provided.
 |      driver_info:
 |          Optional DriverInfo object to identify upstream libraries.
 |          If provided, lib_name and lib_version are ignored.
 |          If not provided, a DriverInfo will be created from lib_name and lib_version.
 |          Explicit None disables CLIENT SETINFO.
 |          Argument is ignored when connection_pool is provided.
 |      lib_name:
 |          **Deprecated.** Use driver_info instead. Library name for CLIENT SETINFO.
 |      lib_version:
 |          **Deprecated.** Use driver_info instead. Library version for CLIENT SETINFO.
 |      maint_notifications_config:
 |          configures the pool to support maintenance notifications - see
 |          `redis.maint_notifications.MaintNotificationsConfig` for details.
 |          Only supported with RESP3
 |          If not provided and protocol is RESP3, the maintenance notifications
 |          will be enabled by default (logic is included in the connection pool
 |          initialization).
 |          Argument is ignored when connection_pool is provided.
 |      oss_cluster_maint_notifications_handler:
 |          handler for OSS cluster notifications - see
 |          `redis.maint_notifications.OSSMaintNotificationsHandler` for details.
 |          Only supported with RESP3
 |          Argument is ignored when connection_pool is provided.
 |
 |  __repr__(self) -> str
 |      Return repr(self).
 |
 |  client(self)
 |
 |  close(self) -> None
 |
 |  execute_command(self, *args, **options)
 |      # COMMAND EXECUTION AND PROTOCOL PARSING
 |
 |  get_cache(self) -> Optional[redis.cache.CacheInterface]
 |
 |  get_connection_kwargs(self) -> Dict
 |      Get the connection's key-word arguments
 |
 |  get_encoder(self) -> 'Encoder'
 |      Get the connection pool's encoder
 |
 |  get_retry(self) -> Optional[redis.retry.Retry]
 |
 |  himport_discard(self, fieldset_name: str) -> int
 |      Remove a fieldset from the registry.
 |
 |      Returns ``1`` if it was registered, ``0`` otherwise. On a pooled client the
 |      server-side ``DISCARD`` is reconciled lazily when each connection is next
 |      used for ``himport_set``. On a single connection client it runs immediately
 |      on the pinned connection when it is live; while that connection is not
 |      connected there is nothing prepared on the server to discard (its tracking is
 |      reset on connect), so no server call is made.
 |
 |  himport_discard_all(self) -> int
 |      Remove all fieldsets from the registry.
 |
 |      Returns the number removed from the registry. Server-side removal follows the
 |      same live/lazy rule as :meth:`himport_discard`.
 |
 |  himport_prepare(self, fieldset_name: str, fields: Iterable[Union[bytes, bytearray, memoryview, str, int, float]]) -> bool
 |      Declare an HIMPORT fieldset for use by :meth:`himport_set`.
 |
 |      Registers ``fieldset_name`` (ordered ``fields``, verbatim) in the client's
 |      shared registry. On a pooled client the server-side ``PREPARE`` is deferred
 |      and bundled into the next ``himport_set`` per connection. On a single
 |      connection client it is run immediately when the pinned connection is live;
 |      while that connection is not connected there is no session state to prepare,
 |      so the next ``himport_set`` prepares it lazily instead.
 |
 |  keyspace_notifications(self, key_prefix: Union[str, bytes, NoneType] = None, ignore_subscribe_messages: bool = True) -> 'KeyspaceNotifications'
 |      Return a :class:`~redis.keyspace_notifications.KeyspaceNotifications`
 |      object for subscribing to keyspace and keyevent notifications.
 |
 |      Note: Keyspace notifications must be enabled on the Redis server via
 |      the ``notify-keyspace-events`` configuration option.
 |
 |      Args:
 |          key_prefix: Optional prefix to filter and strip from keys in
 |                      notifications.
 |          ignore_subscribe_messages: If True, subscribe/unsubscribe
 |                                    confirmations are not returned by
 |                                    get_message/listen.
 |
 |  load_external_module(self, funcname, func) -> None
 |      This function can be used to add externally defined redis modules,
 |      and their namespaces to the redis client.
 |
 |      funcname - A string containing the name of the function to create
 |      func - The function, being added to this class.
 |
 |      ex: Assume that one has a custom redis module named foomod that
 |      creates command named 'foo.dothing' and 'foo.anotherthing' in redis.
 |      To load function functions into this namespace:
 |
 |      from redis import Redis
 |      from foomodule import F
 |      r = Redis()
 |      r.load_external_module("foo", F)
 |      r.foo().dothing('your', 'arguments')
 |
 |      For a concrete example see the reimport of the redisjson module in
 |      tests/test_connection.py::test_loading_external_modules
 |
 |  lock(self, name: str, timeout: Optional[float] = None, sleep: float = 0.1, blocking: bool = True, blocking_timeout: Optional[float] = None, lock_class: Optional[Any] = None, thread_local: bool = True, raise_on_release_error: bool = True)
 |      Return a new Lock object using key ``name`` that mimics
 |      the behavior of threading.Lock.
 |
 |      If specified, ``timeout`` indicates a maximum life for the lock.
 |      By default, it will remain locked until release() is called.
 |
 |      ``sleep`` indicates the amount of time to sleep per loop iteration
 |      when the lock is in blocking mode and another client is currently
 |      holding the lock.
 |
 |      ``blocking`` indicates whether calling ``acquire`` should block until
 |      the lock has been acquired or to fail immediately, causing ``acquire``
 |      to return False and the lock not being acquired. Defaults to True.
 |      Note this value can be overridden by passing a ``blocking``
 |      argument to ``acquire``.
 |
 |      ``blocking_timeout`` indicates the maximum amount of time in seconds to
 |      spend trying to acquire the lock. A value of ``None`` indicates
 |      continue trying forever. ``blocking_timeout`` can be specified as a
 |      float or integer, both representing the number of seconds to wait.
 |
 |      ``lock_class`` forces the specified lock implementation. Note that as
 |      of redis-py 3.0, the only lock class we implement is ``Lock`` (which is
 |      a Lua-based lock). So, it's unlikely you'll need this parameter, unless
 |      you have created your own custom lock class.
 |
 |      ``thread_local`` indicates whether the lock token is placed in
 |      thread-local storage. By default, the token is placed in thread local
 |      storage so that a thread only sees its token, not a token set by
 |      another thread. Consider the following timeline:
 |
 |          time: 0, thread-1 acquires `my-lock`, with a timeout of 5 seconds.
 |                   thread-1 sets the token to "abc"
 |          time: 1, thread-2 blocks trying to acquire `my-lock` using the
 |                   Lock instance.
 |          time: 5, thread-1 has not yet completed. redis expires the lock
 |                   key.
 |          time: 5, thread-2 acquired `my-lock` now that it's available.
 |                   thread-2 sets the token to "xyz"
 |          time: 6, thread-1 finishes its work and calls release(). if the
 |                   token is *not* stored in thread local storage, then
 |                   thread-1 would see the token value as "xyz" and would be
 |                   able to successfully release the thread-2's lock.
 |
 |      ``raise_on_release_error`` indicates whether to raise an exception when
 |      the lock is no longer owned when exiting the context manager. By default,
 |      this is True, meaning an exception will be raised. If False, the warning
 |      will be logged and the exception will be suppressed.
 |
 |      In some use cases it's necessary to disable thread local storage. For
 |      example, if you have code where one thread acquires a lock and passes
 |      that lock instance to a worker thread to release later. If thread
 |      local storage isn't disabled in this case, the worker thread won't see
 |      the token set by the thread that acquired the lock. Our assumption
 |      is that these cases aren't common and as such default to using
 |      thread local storage.
 |
 |  monitor(self)
 |
 |  parse_response(self, connection, command_name, **options)
 |      Parses a response from the Redis server
 |
 |  pipeline(self, transaction=True, shard_hint=None) -> 'Pipeline'
 |      Return a new pipeline object that can queue multiple commands for
 |      later execution. ``transaction`` indicates whether all commands
 |      should be executed atomically. Apart from making a group of operations
 |      atomic, pipelines are useful for reducing the back-and-forth overhead
 |      between the client and server.
 |
 |  pubsub(self, **kwargs)
 |      Return a Publish/Subscribe object. With this object, you can
 |      subscribe to channels and listen for messages that get published to
 |      them.
 |
 |  set_response_callback(self, command: str, callback: Callable) -> None
 |      Set a custom Response Callback
 |
 |  set_retry(self, retry: redis.retry.Retry) -> None
 |
 |  transaction(self, func: Callable[[ForwardRef('Pipeline')], NoneType], *watches, **kwargs) -> Union[List[Any], Any, NoneType]
 |      Convenience method for executing the callable `func` as a transaction
 |      while watching all keys specified in `watches`. The 'func' callable
 |      should expect a single argument which is a Pipeline object.
 |
 |  ----------------------------------------------------------------------
 |  Class methods defined here:
 |
 |  __subclasshook__ = _proto_hook(other) from typing
 |
 |  from_pool(connection_pool: redis.connection.ConnectionPool) -> 'Redis'
 |      Return a Redis client from the given connection pool.
 |      The Redis client will take ownership of the connection pool and
 |      close it when the Redis client is closed.
 |
 |      Because the client closes (disconnects all connections in) the pool
 |      when it is closed or garbage-collected, the pool must not be shared
 |      with other clients. Constructing multiple clients from the same pool
 |      via ``from_pool`` -- for example one per request across threads -- is
 |      not thread safe: when one client is closed it will disconnect
 |      connections still in use by the others.
 |
 |      To share a single pool across clients, construct the pool explicitly
 |      and manage its lifecycle instead. Unlike ``from_pool``, the plain
 |      ``Redis(connection_pool=pool)`` constructor does not take ownership of
 |      the pool and will not close it, so a pool created this way can be
 |      safely shared across clients. ``ConnectionPool`` supports the context
 |      manager protocol for this::
 |
 |          with ConnectionPool.from_url(url) as pool:
 |              r = Redis(connection_pool=pool)
 |
 |  from_url(url: str, **kwargs) -> 'Redis'
 |      Return a Redis client object configured from the given URL
 |
 |      For example::
 |
 |          redis://[[username]:[password]]@localhost:6379/0
 |          rediss://[[username]:[password]]@localhost:6379/0
 |          unix://[username@]/path/to/socket.sock?db=0[&password=password]
 |
 |      Three URL schemes are supported:
 |
 |      - `redis://` creates a TCP socket connection. See more at:
 |        <https://www.iana.org/assignments/uri-schemes/prov/redis>
 |      - `rediss://` creates a SSL wrapped TCP socket connection. See more at:
 |        <https://www.iana.org/assignments/uri-schemes/prov/rediss>
 |      - ``unix://``: creates a Unix Domain Socket connection.
 |
 |      The username, password, hostname, path and all querystring values
 |      are passed through urllib.parse.unquote in order to replace any
 |      percent-encoded values with their corresponding characters.
 |
 |      There are several ways to specify a database number. The first value
 |      found will be used:
 |
 |          1. A ``db`` querystring option, e.g. redis://localhost?db=0
 |          2. If using the redis:// or rediss:// schemes, the path argument
 |             of the url, e.g. redis://localhost/0
 |          3. A ``db`` keyword argument to this function.
 |
 |      If none of these options are specified, the default db=0 is used.
 |
 |      All querystring options are cast to their appropriate Python types.
 |      Boolean arguments can be specified with string values "True"/"False"
 |      or "Yes"/"No". Values that cannot be properly cast cause a
 |      ``ValueError`` to be raised. Once parsed, the querystring arguments
 |      and keyword arguments are passed to the ``ConnectionPool``'s
 |      class initializer. In the case of conflicting arguments, querystring
 |      arguments always win.
 |
 |  ----------------------------------------------------------------------
 |  Readonly properties defined here:
 |
 |  himport_registry
 |      The client's HIMPORT fieldset registry (contains empty
 |      schema registry if none was declared).
 |
 |      Read-only: the registry is mutated only through the HIMPORT command methods.
 |
 |  ----------------------------------------------------------------------
 |  Data and other attributes defined here:
 |
 |  __abstractmethods__ = frozenset()
 |
 |  __annotations__ = {'_is_async_client': typing.Literal[False]}
 |
 |  __parameters__ = ()
 |
 |  ----------------------------------------------------------------------
 |  Methods inherited from redis.commands.redismodules.RedisModuleCommands:
 |
 |  bf(self) -> 'BFBloom'
 |      Access the bloom namespace.
 |
 |  cf(self) -> 'CFBloom'
 |      Access the bloom namespace.
 |
 |  cms(self) -> 'CMSBloom'
 |      Access the bloom namespace.
 |
 |  ft(self, index_name='idx') -> 'Search'
 |      Access the search namespace, providing support for redis search.
 |
 |  json(self, encoder=<json.encoder.JSONEncoder object at 0x0000017B9C588F50>, decoder=<json.decoder.JSONDecoder object at 0x0000017B9C588FB0>) -> 'JSON'
 |      Access the json namespace, providing support for redis json.
 |
 |  tdigest(self) -> 'TDigestBloom'
 |      Access the bloom namespace.
 |
 |  topk(self) -> 'TOPKBloom'
 |      Access the bloom namespace.
 |
 |  ts(self) -> 'TimeSeries'
 |      Access the timeseries namespace, providing support for
 |      redis timeseries data.
 |
 |  vset(self) -> 'VectorSet'
 |      Access the VectorSet commands namespace.
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from redis.commands.redismodules.RedisModuleCommands:
 |
 |  __dict__
 |      dictionary for instance variables
 |
 |  __weakref__
 |      list of weak references to the object
 |
 |  ----------------------------------------------------------------------
 |  Methods inherited from redis.commands.core.ACLCommands:
 |
 |  acl_cat(self, category: 'str | None' = None, **kwargs) -> 'list[bytes | str] | Awaitable[list[bytes | str]]'
 |      Returns a list of categories or commands within a category.
 |
 |      If ``category`` is not supplied, returns a list of all categories.
 |      If ``category`` is supplied, returns a list of all commands within
 |      that category.
 |
 |      For more information, see https://redis.io/commands/acl-cat
 |
 |  acl_deluser(self, *username: 'str', **kwargs) -> 'int | Awaitable[int]'
 |      Delete the ACL for the specified ``username``\s
 |
 |      For more information, see https://redis.io/commands/acl-deluser
 |
 |  acl_dryrun(self, username: 'str', *args: 'EncodableT', **kwargs) -> 'bytes | str | Awaitable[bytes | str]'
 |      Simulate the execution of a given command by a given ``username``.
 |
 |      For more information, see https://redis.io/commands/acl-dryrun
 |
 |  acl_genpass(self, bits: 'int | None' = None, **kwargs) -> 'bytes | str | Awaitable[bytes | str]'
 |      Generate a random password value.
 |      If ``bits`` is supplied then use this number of bits, rounded to
 |      the next multiple of 4.
 |      See: https://redis.io/commands/acl-genpass
 |
 |  acl_getuser(self, username: 'str', **kwargs) -> 'ACLGetUserData | Awaitable[ACLGetUserData]'
 |      Get the ACL details for the specified ``username``.
 |
 |      If ``username`` does not exist, return None
 |
 |      For more information, see https://redis.io/commands/acl-getuser
 |
 |  acl_help(self, **kwargs) -> 'list[bytes | str] | Awaitable[list[bytes | str]]'
 |      The ACL HELP command returns helpful text describing
 |      the different subcommands.
 |
 |      For more information, see https://redis.io/commands/acl-help
 |
 |  acl_list(self, **kwargs) -> 'list[bytes | str] | Awaitable[list[bytes | str]]'
 |      Return a list of all ACLs on the server
 |
 |      For more information, see https://redis.io/commands/acl-list
 |
 |  acl_load(self, **kwargs) -> 'bool | Awaitable[bool]'
 |      Load ACL rules from the configured ``aclfile``.
 |
 |      Note that the server must be configured with the ``aclfile``
 |      directive to be able to load ACL rules from an aclfile.
 |
 |      For more information, see https://redis.io/commands/acl-load
 |
 |  acl_log(self, count: 'int | None' = None, **kwargs) -> 'ACLLogData | Awaitable[ACLLogData]'
 |      Get ACL logs as a list.
 |      :param int count: Get logs[0:count].
 |      :rtype: List.
 |
 |      For more information, see https://redis.io/commands/acl-log
 |
 |  acl_log_reset(self, **kwargs) -> 'bool | Awaitable[bool]'
 |      Reset ACL logs.
 |      :rtype: Boolean.
 |
 |      For more information, see https://redis.io/commands/acl-log
 |
 |  acl_save(self, **kwargs) -> 'bool | Awaitable[bool]'
 |      Save ACL rules to the configured ``aclfile``.
 |
 |      Note that the server must be configured with the ``aclfile``
 |      directive to be able to save ACL rules to an aclfile.
 |
 |      For more information, see https://redis.io/commands/acl-save
 |
 |  acl_setuser(self, username: 'str', enabled: 'bool' = False, nopass: 'bool' = False, passwords: 'str | Iterable[str] | None' = None, hashed_passwords: 'str | Iterable[str] | None' = None, categories: 'Iterable[str] | None' = None, commands: 'Iterable[str] | None' = None, keys: 'Iterable[KeyT] | None' = None, channels: 'Iterable[ChannelT] | None' = None, selectors: 'Iterable[Tuple[str, KeyT]] | None' = None, reset: 'bool' = False, reset_keys: 'bool' = False, reset_channels: 'bool' = False, reset_passwords: 'bool' = False, **kwargs) -> 'bool | Awaitable[bool]'
 |      Create or update an ACL user.
 |
 |      Create or update the ACL for `username`. If the user already exists,
 |      the existing ACL is completely overwritten and replaced with the
 |      specified values.
 |
 |      For more information, see https://redis.io/commands/acl-setuser
 |
 |      Args:
 |          username: The name of the user whose ACL is to be created or updated.
 |          enabled: Indicates whether the user should be allowed to authenticate.
 |                   Defaults to `False`.
 |          nopass: Indicates whether the user can authenticate without a password.
 |                  This cannot be `True` if `passwords` are also specified.
 |          passwords: A list of plain text passwords to add to or remove from the user.
 |                     Each password must be prefixed with a '+' to add or a '-' to
 |                     remove. For convenience, a single prefixed string can be used
 |                     when adding or removing a single password.
 |          hashed_passwords: A list of SHA-256 hashed passwords to add to or remove
 |                            from the user. Each hashed password must be prefixed with
 |                            a '+' to add or a '-' to remove. For convenience, a single
 |                            prefixed string can be used when adding or removing a
 |                            single password.
 |          categories: A list of strings representing category permissions. Each string
 |                      must be prefixed with either a '+' to add the category
 |                      permission or a '-' to remove the category permission.
 |          commands: A list of strings representing command permissions. Each string
 |                    must be prefixed with either a '+' to add the command permission
 |                    or a '-' to remove the command permission.
 |          keys: A list of key patterns to grant the user access to. Key patterns allow
 |                ``'*'`` to support wildcard matching. For example, ``'*'`` grants
 |                access to all keys while ``'cache:*'`` grants access to all keys that
 |                are prefixed with ``cache:``.
 |                `keys` should not be prefixed with a ``'~'``.
 |          reset: Indicates whether the user should be fully reset prior to applying
 |                 the new ACL. Setting this to `True` will remove all existing
 |                 passwords, flags, and privileges from the user and then apply the
 |                 specified rules. If `False`, the user's existing passwords, flags,
 |                 and privileges will be kept and any new specified rules will be
 |                 applied on top.
 |          reset_keys: Indicates whether the user's key permissions should be reset
 |                      prior to applying any new key permissions specified in `keys`.
 |                      If `False`, the user's existing key permissions will be kept and
 |                      any new specified key permissions will be applied on top.
 |          reset_channels: Indicates whether the user's channel permissions should be
 |                          reset prior to applying any new channel permissions
 |                          specified in `channels`. If `False`, the user's existing
 |                          channel permissions will be kept and any new specified
 |                          channel permissions will be applied on top.
 |          reset_passwords: Indicates whether to remove all existing passwords and the
 |                           `nopass` flag from the user prior to applying any new
 |                           passwords specified in `passwords` or `hashed_passwords`.
 |                           If `False`, the user's existing passwords and `nopass`
 |                           status will be kept and any new specified passwords or
 |                           hashed passwords will be applied on top.
 |
 |  acl_users(self, **kwargs) -> 'list[bytes | str] | Awaitable[list[bytes | str]]'
 |      Returns a list of all registered users on the server.
 |
 |      For more information, see https://redis.io/commands/acl-users
 |
 |  acl_whoami(self, **kwargs) -> 'bytes | str | Awaitable[bytes | str]'
 |      Get the username for the current connection
 |
 |      For more information, see https://redis.io/commands/acl-whoami
 |
 |  ----------------------------------------------------------------------
 |  Methods inherited from redis.commands.core.ClusterCommands:
 |
 |  cluster(self, cluster_arg, *args, **kwargs) -> 'Any | Awaitable[Any]'
 |
 |  readonly(self, **kwargs) -> 'bool | Awaitable[bool]'
 |      Enables read queries for a connection to a Redis Cluster replica node.
 |
 |      For more information, see https://redis.io/commands/readonly
 |
 |  readwrite(self, **kwargs) -> 'bool | Awaitable[bool]'
 |      Disables read queries for a connection to a Redis Cluster slave node.
 |
 |      For more information, see https://redis.io/commands/readwrite
 |
 |  ----------------------------------------------------------------------
 |  Methods inherited from redis.commands.core.BasicKeyCommands:
 |
 |  __contains__ = exists(self, *names: 'KeyT') -> 'int | Awaitable[int]'
 |
 |  __delitem__(self, name: 'KeyT')
 |
 |  __getitem__(self, name: 'KeyT')
 |      Return the value at key ``name``, raises a KeyError if the key
 |      doesn't exist.
 |
 |  __setitem__(self, name: 'KeyT', value: 'EncodableT')
 |
 |  append(self, key: 'KeyT', value: 'EncodableT') -> 'int | Awaitable[int]'
 |      Appends the string ``value`` to the value at ``key``. If ``key``
 |      doesn't already exist, create it with a value of ``value``.
 |      Returns the new length of the value at ``key``.
 |
 |      For more information, see https://redis.io/commands/append
 |
 |  bitcount(self, key: 'KeyT', start: 'int | None' = None, end: 'int | None' = None, mode: 'str | None' = None) -> 'int | Awaitable[int]'
 |      Returns the count of set bits in the value of ``key``.  Optional
 |      ``start`` and ``end`` parameters indicate which bytes to consider
 |
 |      For more information, see https://redis.io/commands/bitcount
 |
 |  bitfield(self: "Union['redis.client.Redis', 'redis.asyncio.client.Redis']", key: 'KeyT', default_overflow: 'str | None' = None) -> 'BitFieldOperation'
 |      Return a BitFieldOperation instance to conveniently construct one or
 |      more bitfield operations on ``key``.
 |
 |      For more information, see https://redis.io/commands/bitfield
 |
 |  bitfield_ro(self: "Union['redis.client.Redis', 'redis.asyncio.client.Redis']", key: 'KeyT', encoding: 'str', offset: 'BitfieldOffsetT', items: 'list[tuple[str, BitfieldOffsetT]] | None' = None) -> 'list[int] | Awaitable[list[int]]'
 |      Return an array of the specified bitfield values
 |      where the first value is found using ``encoding`` and ``offset``
 |      parameters and remaining values are result of corresponding
 |      encoding/offset pairs in optional list ``items``
 |      Read-only variant of the BITFIELD command.
 |
 |      For more information, see https://redis.io/commands/bitfield_ro
 |
 |  bitop(self, operation: 'str', dest: 'KeyT', *keys: 'KeyT') -> 'int | Awaitable[int]'
 |      Perform a bitwise operation using ``operation`` between ``keys`` and
 |      store the result in ``dest``.
 |
 |      For more information, see https://redis.io/commands/bitop
 |
 |  bitpos(self, key: 'KeyT', bit: 'int', start: 'int | None' = None, end: 'int | None' = None, mode: 'str | None' = None) -> 'int | Awaitable[int]'
 |      Return the position of the first bit set to 1 or 0 in a string.
 |      ``start`` and ``end`` defines search range. The range is interpreted
 |      as a range of bytes and not a range of bits, so start=0 and end=2
 |      means to look at the first three bytes.
 |
 |      For more information, see https://redis.io/commands/bitpos
 |
 |  blmove(self, first_list: 'str', second_list: 'str', timeout: 'int', src: 'str' = 'LEFT', dest: 'str' = 'RIGHT') -> 'bytes | str | None | Awaitable[bytes | str | None]'
 |      Blocking version of lmove.
 |
 |      For more information, see https://redis.io/commands/blmove
 |
 |  blmovem(self, first_list: 'str', second_list: 'str', timeout: 'float', src: 'str' = 'LEFT', dest: 'str' = 'RIGHT', count: 'int | None' = None, mode: "Literal['COUNT', 'EXACTLY'] | None" = None, ordering: "Literal['OBO', 'BULK'] | None" = None) -> 'list[bytes | str] | None | Awaitable[list[bytes | str] | None]'
 |      Blocking version of lmovem.
 |
 |      Blocks until elements are available to move or ``timeout`` (in seconds)
 |      is reached; a ``timeout`` of ``0`` blocks indefinitely. With ``COUNT``
 |      the command unblocks once at least one element is available and moves
 |      ``min(count, available)``; with ``EXACTLY`` it blocks until the source
 |      holds at least ``count`` elements, then moves exactly ``count``
 |      atomically. On timeout ``None`` is returned and nothing is moved.
 |
 |      As with ``lmovem``, ``ordering`` (OBO or BULK) is required whenever
 |      ``count`` is given.
 |
 |      For more information, see https://redis.io/commands/blmovem
 |
 |  copy(self, source: 'str', destination: 'str', destination_db: 'str | None' = None, replace: 'bool' = False) -> 'bool | Awaitable[bool]'
 |      Copy the value stored in the ``source`` key to the ``destination`` key.
 |
 |      ``destination_db`` an alternative destination database. By default,
 |      the ``destination`` key is created in the source Redis database.
 |
 |      ``replace`` whether the ``destination`` key should be removed before
 |      copying the value to it. By default, the value is not copied if
 |      the ``destination`` key already exists.
 |
 |      For more information, see https://redis.io/commands/copy
 |
 |  decr = decrby(self, name: 'KeyT', amount: 'int' = 1) -> 'int | Awaitable[int]'
 |
 |  decrby(self, name: 'KeyT', amount: 'int' = 1) -> 'int | Awaitable[int]'
 |      Decrements the value of ``key`` by ``amount``.  If no key exists,
 |      the value will be initialized as 0 - ``amount``
 |
 |      For more information, see https://redis.io/commands/decrby
 |
 |  delete(self, *names: 'KeyT') -> 'int | Awaitable[int]'
 |      Delete one or more keys specified by ``names``
 |
 |  delex(self, name: 'KeyT', ifeq: 'bytes | str | None' = None, ifne: 'bytes | str | None' = None, ifdeq: 'str | None' = None, ifdne: 'str | None' = None) -> 'int | Awaitable[int]'
 |      Conditionally removes the specified key.
 |
 |      Warning:
 |      **Experimental** since 7.1.
 |      This API may change or be removed without notice.
 |      The API may change based on feedback.
 |
 |      Arguments:
 |          name: KeyT - the key to delete
 |          ifeq match-valu: Optional[Union[bytes, str]] - Delete the key only if its value is equal to match-value
 |          ifne match-value: Optional[Union[bytes, str]] - Delete the key only if its value is not equal to match-value
 |          ifdeq match-digest: Optional[str] - Delete the key only if the digest of its value is equal to match-digest
 |          ifdne match-digest: Optional[str] - Delete the key only if the digest of its value is not equal to match-digest
 |
 |      Returns:
 |          int: 1 if the key was deleted, 0 otherwise.
 |      Raises:
 |          redis.exceptions.ResponseError: if key exists but is not a string
 |                                          and a condition is specified.
 |          ValueError: if more than one condition is provided.
 |
 |
 |      Requires Redis 8.4 or greater.
 |      For more information, see https://redis.io/commands/delex
 |
 |  digest(self, name: 'KeyT') -> 'str | bytes | None | Awaitable[str | bytes | None]'
 |      Return the digest of the value stored at the specified key.
 |
 |      Warning:
 |      **Experimental** since 7.1.
 |      This API may change or be removed without notice.
 |      The API may change based on feedback.
 |
 |      Arguments:
 |        - name: KeyT - the key to get the digest of
 |
 |      Returns:
 |        - None if the key does not exist
 |        - (bulk string) the XXH3 digest of the value as a hex string
 |      Raises:
 |        - ResponseError if key exists but is not a string
 |
 |
 |      Requires Redis 8.4 or greater.
 |      For more information, see https://redis.io/commands/digest
 |
 |  digest_local(self, value: 'bytes | str') -> 'bytes | str'
 |      Compute the hexadecimal digest of the value locally, without sending it to the server.
 |
 |      This is useful for conditional operations like IFDEQ/IFDNE where you need to
 |      compute the digest client-side before sending a command.
 |
 |      Warning:
 |      **Experimental** - This API may change or be removed without notice.
 |
 |      Arguments:
 |        - value: Union[bytes, str] - the value to compute the digest of.
 |          If a string is provided, it will be encoded using UTF-8 before hashing,
 |          which matches Redis's default encoding behavior.
 |
 |      Returns:
 |        - (str | bytes) the XXH3 digest of the value as a hex string (16 hex characters).
 |          Returns bytes if decode_responses is False, otherwise returns str.
 |
 |      For more information, see https://redis.io/commands/digest
 |
 |  dump(self, name: 'KeyT') -> 'bytes | None | Awaitable[bytes | None]'
 |      Return a serialized version of the value stored at the specified key.
 |      If key does not exist a nil bulk reply is returned.
 |
 |      For more information, see https://redis.io/commands/dump
 |
 |  exists(self, *names: 'KeyT') -> 'int | Awaitable[int]'
 |      Returns the number of ``names`` that exist
 |
 |      For more information, see https://redis.io/commands/exists
 |
 |  expire(self, name: 'KeyT', time: 'ExpiryT', nx: 'bool' = False, xx: 'bool' = False, gt: 'bool' = False, lt: 'bool' = False) -> 'bool | Awaitable[bool]'
 |      Set an expire flag on key ``name`` for ``time`` seconds with given
 |      ``option``. ``time`` can be represented by an integer or a Python timedelta
 |      object.
 |
 |      Valid options are:
 |          NX -> Set expiry only when the key has no expiry
 |          XX -> Set expiry only when the key has an existing expiry
 |          GT -> Set expiry only when the new expiry is greater than current one
 |          LT -> Set expiry only when the new expiry is less than current one
 |
 |      For more information, see https://redis.io/commands/expire
 |
 |  expireat(self, name: 'KeyT', when: 'AbsExpiryT', nx: 'bool' = False, xx: 'bool' = False, gt: 'bool' = False, lt: 'bool' = False) -> 'bool | Awaitable[bool]'
 |      Set an expire flag on key ``name`` with given ``option``. ``when``
 |      can be represented as an integer indicating unix time or a Python
 |      datetime object.
 |
 |      Valid options are:
 |          -> NX -- Set expiry only when the key has no expiry
 |          -> XX -- Set expiry only when the key has an existing expiry
 |          -> GT -- Set expiry only when the new expiry is greater than current one
 |          -> LT -- Set expiry only when the new expiry is less than current one
 |
 |      For more information, see https://redis.io/commands/expireat
 |
 |  expiretime(self, key: 'str') -> 'int | Awaitable[int]'
 |      Returns the absolute Unix timestamp (since January 1, 1970) in seconds
 |      at which the given key will expire.
 |
 |      For more information, see https://redis.io/commands/expiretime
 |
 |  get(self, name: 'KeyT') -> 'bytes | str | None | Awaitable[bytes | str | None]'
 |      Return the value at key ``name``, or None if the key doesn't exist
 |
 |      For more information, see https://redis.io/commands/get
 |
 |  getbit(self, name: 'KeyT', offset: 'int') -> 'int | Awaitable[int]'
 |      Returns an integer indicating the value of ``offset`` in ``name``
 |
 |      For more information, see https://redis.io/commands/getbit
 |
 |  getdel(self, name: 'KeyT') -> 'bytes | str | None | Awaitable[bytes | str | None]'
 |      Get the value at key ``name`` and delete the key. This command
 |      is similar to GET, except for the fact that it also deletes
 |      the key on success (if and only if the key's value type
 |      is a string).
 |
 |      For more information, see https://redis.io/commands/getdel
 |
 |  getex(self, name: 'KeyT', ex: 'ExpiryT | None' = None, px: 'ExpiryT | None' = None, exat: 'AbsExpiryT | None' = None, pxat: 'AbsExpiryT | None' = None, persist: 'bool' = False) -> 'bytes | str | None | Awaitable[bytes | str | None]'
 |      Get the value of key and optionally set its expiration.
 |      GETEX is similar to GET, but is a write command with
 |      additional options. All time parameters can be given as
 |      datetime.timedelta or integers.
 |
 |      ``ex`` sets an expire flag on key ``name`` for ``ex`` seconds.
 |
 |      ``px`` sets an expire flag on key ``name`` for ``px`` milliseconds.
 |
 |      ``exat`` sets an expire flag on key ``name`` for ``ex`` seconds,
 |      specified in unix time.
 |
 |      ``pxat`` sets an expire flag on key ``name`` for ``ex`` milliseconds,
 |      specified in unix time.
 |
 |      ``persist`` remove the time to live associated with ``name``.
 |
 |      For more information, see https://redis.io/commands/getex
 |
 |  getrange(self, key: 'KeyT', start: 'int', end: 'int') -> 'bytes | str | Awaitable[bytes | str]'
 |      Returns the substring of the string value stored at ``key``,
 |      determined by the offsets ``start`` and ``end`` (both are inclusive)
 |
 |      For more information, see https://redis.io/commands/getrange
 |
 |  getset(self, name: 'KeyT', value: 'EncodableT') -> 'bytes | str | None | Awaitable[bytes | str | None]'
 |      Sets the value at key ``name`` to ``value``
 |      and returns the old value at key ``name`` atomically.
 |
 |      As per Redis 6.2, GETSET is considered deprecated.
 |      Please use SET with GET parameter in new code.
 |
 |      For more information, see https://redis.io/commands/getset
 |
 |  hrandfield(self, key: 'KeyT', count: 'int | None' = None, withvalues: 'bool' = False) -> 'HRandFieldResponse | Awaitable[HRandFieldResponse]'
 |      Return a random field from the hash value stored at key.
 |
 |      count: if the argument is positive, return an array of distinct fields.
 |      If called with a negative count, the behavior changes and the command
 |      is allowed to return the same field multiple times. In this case,
 |      the number of returned fields is the absolute value of the
 |      specified count.
 |      withvalues: The optional WITHVALUES modifier changes the reply so it
 |      includes the respective values of the randomly selected hash fields.
 |
 |      For more information, see https://redis.io/commands/hrandfield
 |
 |  incr = incrby(self, name: 'KeyT', amount: 'int' = 1) -> 'int | Awaitable[int]'
 |
 |  incrby(self, name: 'KeyT', amount: 'int' = 1) -> 'int | Awaitable[int]'
 |      Increments the value of ``key`` by ``amount``.  If no key exists,
 |      the value will be initialized as ``amount``
 |
 |      For more information, see https://redis.io/commands/incrby
 |
 |  incrbyfloat(self, name: 'KeyT', amount: 'float' = 1.0) -> 'float | Awaitable[float]'
 |      Increments the value at key ``name`` by floating ``amount``.
 |      If no key exists, the value will be initialized as ``amount``
 |
 |      For more information, see https://redis.io/commands/incrbyfloat
 |
 |  increx(self, name: 'KeyT', *, byfloat: 'EncodableT | None' = None, byint: 'EncodableT | None' = None, lbound: 'EncodableT | None' = None, ubound: 'EncodableT | None' = None, saturate: 'bool' = False, ex: 'ExpiryT | None' = None, px: 'ExpiryT | None' = None, exat: 'AbsExpiryT | None' = None, pxat: 'AbsExpiryT | None' = None, persist: 'bool' = False, enx: 'bool' = False) -> 'list[Number | bytes | str] | Awaitable[list[Number | bytes | str]]'
 |      Increment the numeric value at key ``name`` and return the new value
 |      and the actual increment.
 |
 |      ``byfloat`` increments a floating point value by the provided amount.
 |
 |      ``byint`` increments an integer value by the provided amount.
 |
 |      If neither ``byfloat`` nor ``byint`` is specified, the value is
 |      incremented by one.
 |
 |      ``lbound`` and ``ubound`` constrain the valid range of the result.
 |
 |      If ``saturate`` is True, out-of-bounds results are saturated to the
 |      specified bound, or to the type limit when no bound is specified.
 |      Otherwise, out-of-bounds results are rejected, leaving the value and
 |      TTL unchanged and returning the current value and zero as the actual
 |      increment.
 |
 |      ``enx`` applies the expiration only when the key does not already
 |      have an expiration, and requires ``ex``, ``px``, ``exat``, or ``pxat``.
 |
 |  keys(self, pattern: 'PatternT' = '*', **kwargs) -> 'list[bytes | str] | Awaitable[list[bytes | str]]'
 |      Returns a list of keys matching ``pattern``
 |
 |      For more information, see https://redis.io/commands/keys
 |
 |  lcs(self, key1: 'str', key2: 'str', len: 'bool | None' = False, idx: 'bool | None' = False, minmatchlen: 'int | None' = 0, withmatchlen: 'bool | None' = False) -> 'LCSCommandResponse | Awaitable[LCSCommandResponse]'
 |      Find the longest common subsequence between ``key1`` and ``key2``.
 |      If ``len`` is true the length of the match will be returned.
 |      If ``idx`` is true the match position in each strings will be returned.
 |      ``minmatchlen`` restrict the list of matches to the ones of
 |      the given ``minmatchlen``.
 |      If ``withmatchlen`` the length of the match also will be returned.
 |      For more information, see https://redis.io/commands/lcs
 |
 |  lmove(self, first_list: 'str', second_list: 'str', src: 'str' = 'LEFT', dest: 'str' = 'RIGHT') -> 'bytes | str | None | Awaitable[bytes | str | None]'
 |      Atomically returns and removes the first/last element of a list,
 |      pushing it as the first/last element on the destination list.
 |      Returns the element being popped and pushed.
 |
 |      For more information, see https://redis.io/commands/lmove
 |
 |  lmovem(self, first_list: 'str', second_list: 'str', src: 'str' = 'LEFT', dest: 'str' = 'RIGHT', count: 'int | None' = None, mode: "Literal['COUNT', 'EXACTLY'] | None" = None, ordering: "Literal['OBO', 'BULK'] | None" = None) -> 'list[bytes | str] | None | Awaitable[list[bytes | str] | None]'
 |      Atomically moves multiple elements from one end of the ``first_list``
 |      to one end of the ``second_list``, returning the moved elements in
 |      destination order.
 |
 |      ``src`` and ``dest`` are the ends to pop from / push to, either
 |      ``LEFT`` (head) or ``RIGHT`` (tail).
 |
 |      When ``count`` is given, ``mode`` selects how many elements to move:
 |      ``COUNT`` (the default) moves up to ``count`` elements, while
 |      ``EXACTLY`` moves exactly ``count`` elements or nothing at all. When
 |      ``count`` is not given a single element is moved.
 |
 |      ``ordering`` controls the order at the destination: ``OBO`` pushes each
 |      element as it is popped (reversing block order, stack semantics) while
 |      ``BULK`` preserves the original relative order (queue semantics). It is
 |      required whenever ``count`` is given.
 |
 |      Returns the array of moved elements, or ``None`` if nothing was moved.
 |
 |      For more information, see https://redis.io/commands/lmovem
 |
 |  mget(self, keys: 'KeysT', *args: 'EncodableT') -> 'list[bytes | str | None] | Awaitable[list[bytes | str | None]]'
 |      Returns a list of values ordered identically to ``keys``
 |
 |      ** Important ** When this method is used with Cluster clients, all keys
 |              must be in the same hash slot, otherwise a RedisClusterException
 |              will be raised.
 |
 |      For more information, see https://redis.io/commands/mget
 |
 |  move(self, name: 'KeyT', db: 'int') -> 'bool | Awaitable[bool]'
 |      Moves the key ``name`` to a different Redis database ``db``
 |
 |      For more information, see https://redis.io/commands/move
 |
 |  mset(self, mapping: 'Mapping[AnyKeyT, EncodableT]') -> 'bool | Awaitable[bool]'
 |      Sets key/values based on a mapping. Mapping is a dictionary of
 |      key/value pairs. Both keys and values should be strings or types that
 |      can be cast to a string via str().
 |
 |      ** Important ** When this method is used with Cluster clients, all keys
 |              must be in the same hash slot, otherwise a RedisClusterException
 |              will be raised.
 |
 |      For more information, see https://redis.io/commands/mset
 |
 |  msetex(self, mapping: 'Mapping[AnyKeyT, EncodableT]', data_persist_option: 'DataPersistOptions | None' = None, ex: 'ExpiryT | None' = None, px: 'ExpiryT | None' = None, exat: 'AbsExpiryT | None' = None, pxat: 'AbsExpiryT | None' = None, keepttl: 'bool' = False) -> 'int | Awaitable[int]'
 |      Sets key/values based on the provided ``mapping`` items.
 |
 |      ** Important ** When this method is used with Cluster clients, all keys
 |                      must be in the same hash slot, otherwise a RedisClusterException
 |                      will be raised.
 |
 |      ``mapping`` accepts a dict of key/value pairs that will be added to the database.
 |
 |      ``data_persist_option`` can be set to ``NX`` or ``XX`` to control the
 |          behavior of the command.
 |          ``NX`` will set the value for each provided key to each
 |              provided value only if all do not already exist.
 |          ``XX`` will set the value for each provided key to each
 |              provided value only if all already exist.
 |
 |      ``ex`` sets an expire flag on the keys in ``mapping`` for ``ex`` seconds.
 |
 |      ``px`` sets an expire flag on the keys in ``mapping`` for ``px`` milliseconds.
 |
 |      ``exat`` sets an expire flag on the keys in ``mapping`` for ``exat`` seconds,
 |          specified in unix time.
 |
 |      ``pxat`` sets an expire flag on the keys in ``mapping`` for ``pxat`` milliseconds,
 |          specified in unix time.
 |
 |      ``keepttl`` if True, retain the time to live associated with the keys.
 |
 |      Returns the number of fields that were added.
 |
 |      Available since Redis 8.4
 |      For more information, see https://redis.io/commands/msetex
 |
 |  msetnx(self, mapping: 'Mapping[AnyKeyT, EncodableT]') -> 'bool | Awaitable[bool]'
 |      Sets key/values based on a mapping if none of the keys are already set.
 |      Mapping is a dictionary of key/value pairs. Both keys and values
 |      should be strings or types that can be cast to a string via str().
 |      Returns a boolean indicating if the operation was successful.
 |
 |      ** Important ** When this method is used with Cluster clients, all keys
 |                      must be in the same hash slot, otherwise a RedisClusterException
 |                      will be raised.
 |
 |      For more information, see https://redis.io/commands/msetnx
 |
 |  persist(self, name: 'KeyT') -> 'bool | Awaitable[bool]'
 |      Removes an expiration on ``name``
 |
 |      For more information, see https://redis.io/commands/persist
 |
 |  pexpire(self, name: 'KeyT', time: 'ExpiryT', nx: 'bool' = False, xx: 'bool' = False, gt: 'bool' = False, lt: 'bool' = False) -> 'bool | Awaitable[bool]'
 |      Set an expire flag on key ``name`` for ``time`` milliseconds
 |      with given ``option``. ``time`` can be represented by an
 |      integer or a Python timedelta object.
 |
 |      Valid options are:
 |          NX -> Set expiry only when the key has no expiry
 |          XX -> Set expiry only when the key has an existing expiry
 |          GT -> Set expiry only when the new expiry is greater than current one
 |          LT -> Set expiry only when the new expiry is less than current one
 |
 |      For more information, see https://redis.io/commands/pexpire
 |
 |  pexpireat(self, name: 'KeyT', when: 'AbsExpiryT', nx: 'bool' = False, xx: 'bool' = False, gt: 'bool' = False, lt: 'bool' = False) -> 'bool | Awaitable[bool]'
 |      Set an expire flag on key ``name`` with given ``option``. ``when``
 |      can be represented as an integer representing unix time in
 |      milliseconds (unix time * 1000) or a Python datetime object.
 |
 |      Valid options are:
 |          NX -> Set expiry only when the key has no expiry
 |          XX -> Set expiry only when the key has an existing expiry
 |          GT -> Set expiry only when the new expiry is greater than current one
 |          LT -> Set expiry only when the new expiry is less than current one
 |
 |      For more information, see https://redis.io/commands/pexpireat
 |
 |  pexpiretime(self, key: 'str') -> 'int | Awaitable[int]'
 |      Returns the absolute Unix timestamp (since January 1, 1970) in milliseconds
 |      at which the given key will expire.
 |
 |      For more information, see https://redis.io/commands/pexpiretime
 |
 |  psetex(self, name: 'KeyT', time_ms: 'ExpiryT', value: 'EncodableT') -> 'bool | Awaitable[bool]'
 |      Set the value of key ``name`` to ``value`` that expires in ``time_ms``
 |      milliseconds. ``time_ms`` can be represented by an integer or a Python
 |      timedelta object
 |
 |      For more information, see https://redis.io/commands/psetex
 |
 |  pttl(self, name: 'KeyT') -> 'int | Awaitable[int]'
 |      Returns the number of milliseconds until the key ``name`` will expire
 |
 |      For more information, see https://redis.io/commands/pttl
 |
 |  randomkey(self, **kwargs) -> 'bytes | str | None | Awaitable[bytes | str | None]'
 |      Returns the name of a random key
 |
 |      For more information, see https://redis.io/commands/randomkey
 |
 |  rename(self, src: 'KeyT', dst: 'KeyT') -> 'bool | Awaitable[bool]'
 |      Rename key ``src`` to ``dst``
 |
 |      For more information, see https://redis.io/commands/rename
 |
 |  renamenx(self, src: 'KeyT', dst: 'KeyT') -> 'bool | Awaitable[bool]'
 |      Rename key ``src`` to ``dst`` if ``dst`` doesn't already exist
 |
 |      For more information, see https://redis.io/commands/renamenx
 |
 |  restore(self, name: 'KeyT', ttl: 'float', value: 'EncodableT', replace: 'bool' = False, absttl: 'bool' = False, idletime: 'int | None' = None, frequency: 'int | None' = None) -> 'bytes | str | Awaitable[bytes | str]'
 |      Create a key using the provided serialized value, previously obtained
 |      using DUMP.
 |
 |      ``replace`` allows an existing key on ``name`` to be overridden. If
 |      it's not specified an error is raised on collision.
 |
 |      ``absttl`` if True, specified ``ttl`` should represent an absolute Unix
 |      timestamp in milliseconds in which the key will expire. (Redis 5.0 or
 |      greater).
 |
 |      ``idletime`` Used for eviction, this is the number of seconds the
 |      key must be idle, prior to execution.
 |
 |      ``frequency`` Used for eviction, this is the frequency counter of
 |      the object stored at the key, prior to execution.
 |
 |      For more information, see https://redis.io/commands/restore
 |
 |  set(self, name: 'KeyT', value: 'EncodableT', ex: 'ExpiryT | None' = None, px: 'ExpiryT | None' = None, nx: 'bool' = False, xx: 'bool' = False, keepttl: 'bool' = False, get: 'bool' = False, exat: 'AbsExpiryT | None' = None, pxat: 'AbsExpiryT | None' = None, ifeq: 'bytes | str | None' = None, ifne: 'bytes | str | None' = None, ifdeq: 'str | None' = None, ifdne: 'str | None' = None) -> 'bool | str | bytes | None | Awaitable[bool | str | bytes | None]'
 |      Set the value at key ``name`` to ``value``
 |
 |      Warning:
 |      **Experimental** since 7.1.
 |      The usage of the arguments ``ifeq``, ``ifne``, ``ifdeq``, and ``ifdne``
 |      is experimental. The API or returned results when those parameters are used
 |      may change based on feedback.
 |
 |      ``ex`` sets an expire flag on key ``name`` for ``ex`` seconds.
 |
 |      ``px`` sets an expire flag on key ``name`` for ``px`` milliseconds.
 |
 |      ``nx`` if set to True, set the value at key ``name`` to ``value`` only
 |          if it does not exist.
 |
 |      ``xx`` if set to True, set the value at key ``name`` to ``value`` only
 |          if it already exists.
 |
 |      ``keepttl`` if True, retain the time to live associated with the key.
 |          (Available since Redis 6.0)
 |
 |      ``get`` if True, set the value at key ``name`` to ``value`` and return
 |          the old value stored at key, or None if the key did not exist.
 |          (Available since Redis 6.2)
 |
 |      ``exat`` sets an expire flag on key ``name`` for ``ex`` seconds,
 |          specified in unix time.
 |
 |      ``pxat`` sets an expire flag on key ``name`` for ``ex`` milliseconds,
 |          specified in unix time.
 |
 |      ``ifeq`` set the value at key ``name`` to ``value`` only if the current
 |          value exactly matches the argument.
 |          If key doesn’t exist - it won’t be created.
 |          (Requires Redis 8.4 or greater)
 |
 |      ``ifne`` set the value at key ``name`` to ``value`` only if the current
 |          value does not exactly match the argument.
 |          If key doesn’t exist - it will be created.
 |          (Requires Redis 8.4 or greater)
 |
 |      ``ifdeq`` set the value at key ``name`` to ``value`` only if the current
 |          value XXH3 hex digest exactly matches the argument.
 |          If key doesn’t exist - it won’t be created.
 |          (Requires Redis 8.4 or greater)
 |
 |      ``ifdne`` set the value at key ``name`` to ``value`` only if the current
 |          value XXH3 hex digest does not exactly match the argument.
 |          If key doesn’t exist - it will be created.
 |          (Requires Redis 8.4 or greater)
 |
 |      For more information, see https://redis.io/commands/set
 |
 |  setbit(self, name: 'KeyT', offset: 'int', value: 'int') -> 'int | Awaitable[int]'
 |      Flag the ``offset`` in ``name`` as ``value``. Returns an integer
 |      indicating the previous value of ``offset``.
 |
 |      For more information, see https://redis.io/commands/setbit
 |
 |  setex(self, name: 'KeyT', time: 'ExpiryT', value: 'EncodableT') -> 'bool | Awaitable[bool]'
 |      Set the value of key ``name`` to ``value`` that expires in ``time``
 |      seconds. ``time`` can be represented by an integer or a Python
 |      timedelta object.
 |
 |      As per Redis 2.6.12, SETEX is considered deprecated.
 |      Please use SET with EX parameter in new code.
 |
 |      For more information, see https://redis.io/commands/setex
 |
 |  setnx(self, name: 'KeyT', value: 'EncodableT') -> 'bool | Awaitable[bool]'
 |      Set the value of key ``name`` to ``value`` if key doesn't exist
 |
 |      For more information, see https://redis.io/commands/setnx
 |
 |  setrange(self, name: 'KeyT', offset: 'int', value: 'EncodableT') -> 'int | Awaitable[int]'
 |      Overwrite bytes in the value of ``name`` starting at ``offset`` with
 |      ``value``. If ``offset`` plus the length of ``value`` exceeds the
 |      length of the original value, the new value will be larger than before.
 |      If ``offset`` exceeds the length of the original value, null bytes
 |      will be used to pad between the end of the previous value and the start
 |      of what's being injected.
 |
 |      Returns the length of the new string.
 |
 |      For more information, see https://redis.io/commands/setrange
 |
 |  stralgo(self, algo: "Literal['LCS']", value1: 'KeyT', value2: 'KeyT', specific_argument: "Literal['strings'] | Literal['keys']" = 'strings', len: 'bool' = False, idx: 'bool' = False, minmatchlen: 'int | None' = None, withmatchlen: 'bool' = False, **kwargs) -> 'StralgoResponse | Awaitable[StralgoResponse]'
 |      Implements complex algorithms that operate on strings.
 |      Right now the only algorithm implemented is the LCS algorithm
 |      (longest common substring). However new algorithms could be
 |      implemented in the future.
 |
 |      ``algo`` Right now must be LCS
 |      ``value1`` and ``value2`` Can be two strings or two keys
 |      ``specific_argument`` Specifying if the arguments to the algorithm
 |      will be keys or strings. strings is the default.
 |      ``len`` Returns just the len of the match.
 |      ``idx`` Returns the match positions in each string.
 |      ``minmatchlen`` Restrict the list of matches to the ones of a given
 |      minimal length. Can be provided only when ``idx`` set to True.
 |      ``withmatchlen`` Returns the matches with the len of the match.
 |      Can be provided only when ``idx`` set to True.
 |
 |      For more information, see https://redis.io/commands/stralgo
 |
 |  strlen(self, name: 'KeyT') -> 'int | Awaitable[int]'
 |      Return the number of bytes stored in the value of ``name``
 |
 |      For more information, see https://redis.io/commands/strlen
 |
 |  substr(self, name: 'KeyT', start: 'int', end: 'int' = -1) -> 'bytes | str | Awaitable[bytes | str]'
 |      Return a substring of the string at key ``name``. ``start`` and ``end``
 |      are 0-based integers specifying the portion of the string to return.
 |
 |  touch(self, *args: 'KeyT') -> 'int | Awaitable[int]'
 |      Alters the last access time of a key(s) ``*args``. A key is ignored
 |      if it does not exist.
 |
 |      For more information, see https://redis.io/commands/touch
 |
 |  ttl(self, name: 'KeyT') -> 'int | Awaitable[int]'
 |      Returns the number of seconds until the key ``name`` will expire
 |
 |      For more information, see https://redis.io/commands/ttl
 |
 |  type(self, name: 'KeyT') -> 'bytes | str | Awaitable[bytes | str]'
 |      Returns the type of key ``name``
 |
 |      For more information, see https://redis.io/commands/type
 |
 |  unlink(self, *names: 'KeyT') -> 'int | Awaitable[int]'
 |      Unlink one or more keys specified by ``names``
 |
 |      For more information, see https://redis.io/commands/unlink
 |
 |  unwatch(self) -> 'None'
 |      Unwatches all previously watched keys for a transaction
 |
 |      For more information, see https://redis.io/commands/unwatch
 |
 |  watch(self, *names: 'KeyT') -> 'None'
 |      Watches the values at keys ``names``, or None if the key doesn't exist
 |
 |      For more information, see https://redis.io/commands/watch
 |
 |  ----------------------------------------------------------------------
 |  Methods inherited from redis.commands.core.HyperlogCommands:
 |
 |  pfadd(self, name: 'KeyT', *values: 'FieldT') -> 'int | Awaitable[int]'
 |      Adds the specified elements to the specified HyperLogLog.
 |
 |      For more information, see https://redis.io/commands/pfadd
 |
 |  pfcount(self, *sources: 'KeyT') -> 'int | Awaitable[int]'
 |      Return the approximated cardinality of
 |      the set observed by the HyperLogLog at key(s).
 |
 |      For more information, see https://redis.io/commands/pfcount
 |
 |  pfmerge(self, dest: 'KeyT', *sources: 'KeyT') -> 'bool | Awaitable[bool]'
 |      Merge N different HyperLogLogs into a single one.
 |
 |      For more information, see https://redis.io/commands/pfmerge
 |
 |  ----------------------------------------------------------------------
 |  Methods inherited from redis.commands.core.HashCommands:
 |
 |  hdel(self, name: 'KeyT', *keys: 'FieldT') -> 'int | Awaitable[int]'
 |      Delete ``keys`` from hash ``name``
 |
 |      For more information, see https://redis.io/commands/hdel
 |
 |  hexists(self, name: 'KeyT', key: 'FieldT') -> 'bool | Awaitable[bool]'
 |      Returns a boolean indicating if ``key`` exists within hash ``name``
 |
 |      For more information, see https://redis.io/commands/hexists
 |
 |  hexpire(self, name: 'KeyT', seconds: 'ExpiryT', *fields: 'FieldT', nx: 'bool' = False, xx: 'bool' = False, gt: 'bool' = False, lt: 'bool' = False) -> 'list[int] | Awaitable[list[int]]'
 |      Sets or updates the expiration time for fields within a hash key, using relative
 |      time in seconds.
 |
 |      If a field already has an expiration time, the behavior of the update can be
 |      controlled using the `nx`, `xx`, `gt`, and `lt` parameters.
 |
 |      The return value provides detailed information about the outcome for each field.
 |
 |      For more information, see https://redis.io/commands/hexpire
 |
 |      Args:
 |          name: The name of the hash key.
 |          seconds: Expiration time in seconds, relative. Can be an integer, or a
 |                   Python `timedelta` object.
 |          fields: List of fields within the hash to apply the expiration time to.
 |          nx: Set expiry only when the field has no expiry.
 |          xx: Set expiry only when the field has an existing expiry.
 |          gt: Set expiry only when the new expiry is greater than the current one.
 |          lt: Set expiry only when the new expiry is less than the current one.
 |
 |      Returns:
 |          Returns a list which contains for each field in the request:
 |              - `-2` if the field does not exist, or if the key does not exist.
 |              - `0` if the specified NX | XX | GT | LT condition was not met.
 |              - `1` if the expiration time was set or updated.
 |              - `2` if the field was deleted because the specified expiration time is
 |                in the past.
 |
 |  hexpireat(self, name: 'KeyT', unix_time_seconds: 'AbsExpiryT', *fields: 'FieldT', nx: 'bool' = False, xx: 'bool' = False, gt: 'bool' = False, lt: 'bool' = False) -> 'list[int] | Awaitable[list[int]]'
 |      Sets or updates the expiration time for fields within a hash key, using an
 |      absolute Unix timestamp in seconds.
 |
 |      If a field already has an expiration time, the behavior of the update can be
 |      controlled using the `nx`, `xx`, `gt`, and `lt` parameters.
 |
 |      The return value provides detailed information about the outcome for each field.
 |
 |      For more information, see https://redis.io/commands/hexpireat
 |
 |      Args:
 |          name: The name of the hash key.
 |          unix_time_seconds: Expiration time as Unix timestamp in seconds. Can be an
 |                             integer or a Python `datetime` object.
 |          fields: List of fields within the hash to apply the expiration time to.
 |          nx: Set expiry only when the field has no expiry.
 |          xx: Set expiry only when the field has an existing expiration time.
 |          gt: Set expiry only when the new expiry is greater than the current one.
 |          lt: Set expiry only when the new expiry is less than the current one.
 |
 |      Returns:
 |          Returns a list which contains for each field in the request:
 |              - `-2` if the field does not exist, or if the key does not exist.
 |              - `0` if the specified NX | XX | GT | LT condition was not met.
 |              - `1` if the expiration time was set or updated.
 |              - `2` if the field was deleted because the specified expiration time is
 |                in the past.
 |
 |  hexpiretime(self, key: 'KeyT', *fields: 'FieldT') -> 'list[int] | Awaitable[list[int]]'
 |      Returns the expiration times of hash fields as Unix timestamps in seconds.
 |
 |      For more information, see https://redis.io/commands/hexpiretime
 |
 |      Args:
 |          key: The hash key.
 |          fields: A list of fields within the hash for which to get the expiration
 |                  time.
 |
 |      Returns:
 |          Returns a list which contains for each field in the request:
 |              - `-2` if the field does not exist, or if the key does not exist.
 |              - `-1` if the field exists but has no associated expire time.
 |              - A positive integer representing the expiration Unix timestamp in
 |                seconds, if the field has an associated expiration time.
 |
 |  hget(self, name: 'KeyT', key: 'FieldT') -> 'bytes | str | None | Awaitable[bytes | str | None]'
 |      Return the value of ``key`` within the hash ``name``
 |
 |      For more information, see https://redis.io/commands/hget
 |
 |  hgetall(self, name: 'KeyT') -> 'dict[bytes | str, bytes | str] | Awaitable[dict[bytes | str, bytes | str]]'
 |      Return a Python dict of the hash's name/value pairs
 |
 |      For more information, see https://redis.io/commands/hgetall
 |
 |  hgetdel(self, name: 'KeyT', *keys: 'FieldT') -> 'list[bytes | str | None] | Awaitable[list[bytes | str | None]]'
 |      Return the value of ``key`` within the hash ``name`` and
 |      delete the field in the hash.
 |      This command is similar to HGET, except for the fact that it also deletes
 |      the key on success from the hash with the provided ```name```.
 |
 |      Available since Redis 8.0
 |      For more information, see https://redis.io/commands/hgetdel
 |
 |  hgetex(self, name: 'KeyT', *keys: 'FieldT', ex: 'ExpiryT | None' = None, px: 'ExpiryT | None' = None, exat: 'AbsExpiryT | None' = None, pxat: 'AbsExpiryT | None' = None, persist: 'bool' = False) -> 'list[bytes | str | None] | Awaitable[list[bytes | str | None]]'
 |      Return the values of ``key`` and ``keys`` within the hash ``name``
 |      and optionally set their expiration.
 |
 |      ``ex`` sets an expire flag on ``kyes`` for ``ex`` seconds.
 |
 |      ``px`` sets an expire flag on ``keys`` for ``px`` milliseconds.
 |
 |      ``exat`` sets an expire flag on ``keys`` for ``ex`` seconds,
 |      specified in unix time.
 |
 |      ``pxat`` sets an expire flag on ``keys`` for ``ex`` milliseconds,
 |      specified in unix time.
 |
 |      ``persist`` remove the time to live associated with the ``keys``.
 |
 |      Available since Redis 8.0
 |      For more information, see https://redis.io/commands/hgetex
 |
 |  himport_discard_all_internal(self) -> 'int | Awaitable[int]'
 |      Send ``HIMPORT DISCARDALL`` (returns the number of fieldsets removed).
 |
 |      .. warning::
 |          Internal wire mapping — not for direct use on a pooled client. It
 |          DISCARDs on a single arbitrary borrowed connection and bypasses the
 |          client's shared fieldset registry, leaving other connections and the
 |          registry out of sync. Use the client's ``himport_discard_all`` instead;
 |          call this only on a pinned single-connection client where you manage
 |          session state yourself.
 |
 |  himport_discard_internal(self, fieldset_name: 'str') -> 'int | Awaitable[int]'
 |      Send ``HIMPORT DISCARD fieldset_name`` (``1`` removed, ``0`` not found).
 |
 |      .. warning::
 |          Internal wire mapping — not for direct use on a pooled client. It
 |          DISCARDs on a single arbitrary borrowed connection and bypasses the
 |          client's shared fieldset registry, leaving other connections and the
 |          registry out of sync. Use the client's ``himport_discard`` instead; call
 |          this only on a pinned single-connection client where you manage session
 |          state yourself.
 |
 |  himport_prepare_internal(self, fieldset_name: 'str', fields: 'Iterable[FieldT]') -> 'bool | Awaitable[bool]'
 |      Send ``HIMPORT PREPARE fieldset_name field [field ...]``.
 |
 |      Registers the ordered field list under ``fieldset_name`` in the executing
 |      connection's session. Fields are sent in the caller's order, unmodified.
 |
 |      .. warning::
 |          Internal wire mapping — not for direct use on a pooled client. It
 |          PREPAREs on a single arbitrary borrowed connection and bypasses the
 |          client's shared fieldset registry, so other connections stay unaware and
 |          reintroduce the nondeterministic "no such fieldset" the HIMPORT design
 |          prevents. Use the client's ``himport_prepare`` instead; call this only
 |          on a pinned single-connection client where you manage session state
 |          yourself.
 |
 |  himport_set(self, key: 'KeyT', fieldset_name: 'str', values: 'Iterable[EncodableT]') -> 'bool | Awaitable[bool]'
 |      Create/replace ``key`` as a hash using ``fieldset_name``'s field list.
 |
 |      Values are sent in the caller's order and map positionally to the prepared
 |      fields. The fieldset is prepared on the serving connection on first use
 |      (PREPARE bundled with SET in one write) and reused on subsequent calls;
 |      runtime discards are reconciled on the next use of the connection. All of
 |      this happens inside the normal command path, so retry, disconnect-on-error
 |      and (for the cluster) routing / MOVED-ASK apply exactly as for any command.
 |
 |      .. note::
 |          Recovery from a mid-connection fieldset loss (the server dropping the
 |          prepared fieldset without dropping the socket, e.g. ``RESET`` or
 |          ``maxmemory-clients`` eviction) applies only to a standalone
 |          ``himport_set`` call: it catches the resulting ``no such fieldset`` and
 |          re-prepares on the same socket, retrying the SET once. A ``himport_set``
 |          buffered in a **pipeline or transaction** has no such per-command
 |          recovery — its fieldset is PREPAREd once as a pre-flight before the
 |          batch, and if the server loses it between that pre-flight and the batch
 |          the SET fails and surfaces as an error in the batch results. Callers who
 |          need the automatic recovery should issue those sets outside a pipeline.
 |
 |  hincrby(self, name: 'KeyT', key: 'FieldT', amount: 'int' = 1) -> 'int | Awaitable[int]'
 |      Increment the value of ``key`` in hash ``name`` by ``amount``
 |
 |      For more information, see https://redis.io/commands/hincrby
 |
 |  hincrbyfloat(self, name: 'KeyT', key: 'FieldT', amount: 'float' = 1.0) -> 'float | Awaitable[float]'
 |      Increment the value of ``key`` in hash ``name`` by floating ``amount``
 |
 |      For more information, see https://redis.io/commands/hincrbyfloat
 |
 |  hkeys(self, name: 'KeyT') -> 'list[bytes | str] | Awaitable[list[bytes | str]]'
 |      Return the list of keys within hash ``name``
 |
 |      For more information, see https://redis.io/commands/hkeys
 |
 |  hlen(self, name: 'KeyT') -> 'int | Awaitable[int]'
 |      Return the number of elements in hash ``name``
 |
 |      For more information, see https://redis.io/commands/hlen
 |
 |  hmget(self, name: 'KeyT', keys: 'FieldT | Iterable[FieldT]', *args: 'FieldT') -> 'list[bytes | str | None] | Awaitable[list[bytes | str | None]]'
 |      Returns a list of values ordered identically to ``keys``
 |
 |      For more information, see https://redis.io/commands/hmget
 |
 |  hmset(self, name: 'KeyT', mapping: 'Mapping[FieldT, EncodableT]') -> 'bool | Awaitable[bool]'
 |      Set key to value within hash ``name`` for each corresponding
 |      key and value from the ``mapping`` dict.
 |
 |      For more information, see https://redis.io/commands/hmset
 |
 |  hpersist(self, name: 'KeyT', *fields: 'FieldT') -> 'list[int] | Awaitable[list[int]]'
 |      Removes the expiration time for each specified field in a hash.
 |
 |      For more information, see https://redis.io/commands/hpersist
 |
 |      Args:
 |          name: The name of the hash key.
 |          fields: A list of fields within the hash from which to remove the
 |                  expiration time.
 |
 |      Returns:
 |          Returns a list which contains for each field in the request:
 |              - `-2` if the field does not exist, or if the key does not exist.
 |              - `-1` if the field exists but has no associated expiration time.
 |              - `1` if the expiration time was successfully removed from the field.
 |
 |  hpexpire(self, name: 'KeyT', milliseconds: 'ExpiryT', *fields: 'FieldT', nx: 'bool' = False, xx: 'bool' = False, gt: 'bool' = False, lt: 'bool' = False) -> 'list[int] | Awaitable[list[int]]'
 |      Sets or updates the expiration time for fields within a hash key, using relative
 |      time in milliseconds.
 |
 |      If a field already has an expiration time, the behavior of the update can be
 |      controlled using the `nx`, `xx`, `gt`, and `lt` parameters.
 |
 |      The return value provides detailed information about the outcome for each field.
 |
 |      For more information, see https://redis.io/commands/hpexpire
 |
 |      Args:
 |          name: The name of the hash key.
 |          milliseconds: Expiration time in milliseconds, relative. Can be an integer,
 |                        or a Python `timedelta` object.
 |          fields: List of fields within the hash to apply the expiration time to.
 |          nx: Set expiry only when the field has no expiry.
 |          xx: Set expiry only when the field has an existing expiry.
 |          gt: Set expiry only when the new expiry is greater than the current one.
 |          lt: Set expiry only when the new expiry is less than the current one.
 |
 |      Returns:
 |          Returns a list which contains for each field in the request:
 |              - `-2` if the field does not exist, or if the key does not exist.
 |              - `0` if the specified NX | XX | GT | LT condition was not met.
 |              - `1` if the expiration time was set or updated.
 |              - `2` if the field was deleted because the specified expiration time is
 |                in the past.
 |
 |  hpexpireat(self, name: 'KeyT', unix_time_milliseconds: 'AbsExpiryT', *fields: 'FieldT', nx: 'bool' = False, xx: 'bool' = False, gt: 'bool' = False, lt: 'bool' = False) -> 'list[int] | Awaitable[list[int]]'
 |      Sets or updates the expiration time for fields within a hash key, using an
 |      absolute Unix timestamp in milliseconds.
 |
 |      If a field already has an expiration time, the behavior of the update can be
 |      controlled using the `nx`, `xx`, `gt`, and `lt` parameters.
 |
 |      The return value provides detailed information about the outcome for each field.
 |
 |      For more information, see https://redis.io/commands/hpexpireat
 |
 |      Args:
 |          name: The name of the hash key.
 |          unix_time_milliseconds: Expiration time as Unix timestamp in milliseconds.
 |                                  Can be an integer or a Python `datetime` object.
 |          fields: List of fields within the hash to apply the expiry.
 |          nx: Set expiry only when the field has no expiry.
 |          xx: Set expiry only when the field has an existing expiry.
 |          gt: Set expiry only when the new expiry is greater than the current one.
 |          lt: Set expiry only when the new expiry is less than the current one.
 |
 |      Returns:
 |          Returns a list which contains for each field in the request:
 |              - `-2` if the field does not exist, or if the key does not exist.
 |              - `0` if the specified NX | XX | GT | LT condition was not met.
 |              - `1` if the expiration time was set or updated.
 |              - `2` if the field was deleted because the specified expiration time is
 |                in the past.
 |
 |  hpexpiretime(self, key: 'KeyT', *fields: 'FieldT') -> 'list[int] | Awaitable[list[int]]'
 |      Returns the expiration times of hash fields as Unix timestamps in milliseconds.
 |
 |      For more information, see https://redis.io/commands/hpexpiretime
 |
 |      Args:
 |          key: The hash key.
 |          fields: A list of fields within the hash for which to get the expiration
 |                  time.
 |
 |      Returns:
 |          Returns a list which contains for each field in the request:
 |              - `-2` if the field does not exist, or if the key does not exist.
 |              - `-1` if the field exists but has no associated expire time.
 |              - A positive integer representing the expiration Unix timestamp in
 |                milliseconds, if the field has an associated expiration time.
 |
 |  hpttl(self, key: 'KeyT', *fields: 'FieldT') -> 'list[int] | Awaitable[list[int]]'
 |      Returns the TTL (Time To Live) in milliseconds for each specified field within a
 |      hash key.
 |
 |      For more information, see https://redis.io/commands/hpttl
 |
 |      Args:
 |          key: The hash key.
 |          fields: A list of fields within the hash for which to get the TTL.
 |
 |      Returns:
 |          Returns a list which contains for each field in the request:
 |              - `-2` if the field does not exist, or if the key does not exist.
 |              - `-1` if the field exists but has no associated expire time.
 |              - A positive integer representing the TTL in milliseconds if the field
 |                has an associated expiration time.
 |
 |  hset(self, name: 'KeyT', key: 'FieldT | None' = None, value: 'EncodableT | None' = None, mapping: 'Mapping[FieldT, EncodableT] | None' = None, items: 'Sequence[EncodableT] | None' = None) -> 'int | Awaitable[int]'
 |      Set ``key`` to ``value`` within hash ``name``,
 |      ``mapping`` accepts a dict of key/value pairs that will be
 |      added to hash ``name``.
 |      ``items`` accepts a list of key/value pairs that will be
 |      added to hash ``name``.
 |      Returns the number of fields that were added.
 |
 |      For more information, see https://redis.io/commands/hset
 |
 |  hsetex(self, name: 'KeyT', key: 'FieldT | None' = None, value: 'EncodableT | None' = None, mapping: 'Mapping[FieldT, EncodableT] | None' = None, items: 'Sequence[EncodableT] | None' = None, ex: 'ExpiryT | None' = None, px: 'ExpiryT | None' = None, exat: 'AbsExpiryT | None' = None, pxat: 'AbsExpiryT | None' = None, data_persist_option: 'HashDataPersistOptions | None' = None, keepttl: 'bool' = False) -> 'int | Awaitable[int]'
 |      Set ``key`` to ``value`` within hash ``name``
 |
 |      ``mapping`` accepts a dict of key/value pairs that will be
 |      added to hash ``name``.
 |
 |      ``items`` accepts a list of key/value pairs that will be
 |      added to hash ``name``.
 |
 |      ``ex`` sets an expire flag on ``keys`` for ``ex`` seconds.
 |
 |      ``px`` sets an expire flag on ``keys`` for ``px`` milliseconds.
 |
 |      ``exat`` sets an expire flag on ``keys`` for ``ex`` seconds,
 |          specified in unix time.
 |
 |      ``pxat`` sets an expire flag on ``keys`` for ``ex`` milliseconds,
 |          specified in unix time.
 |
 |      ``data_persist_option`` can be set to ``FNX`` or ``FXX`` to control the
 |          behavior of the command.
 |          ``FNX`` will set the value for each provided key to each
 |              provided value only if all do not already exist.
 |          ``FXX`` will set the value for each provided key to each
 |              provided value only if all already exist.
 |
 |      ``keepttl`` if True, retain the time to live associated with the keys.
 |
 |      Returns the number of fields that were added.
 |
 |      Available since Redis 8.0
 |      For more information, see https://redis.io/commands/hsetex
 |
 |  hsetnx(self, name: 'KeyT', key: 'FieldT', value: 'EncodableT') -> 'int | Awaitable[int]'
 |      Set ``key`` to ``value`` within hash ``name`` if ``key`` does not
 |      exist.  Returns 1 if HSETNX created a field, otherwise 0.
 |
 |      For more information, see https://redis.io/commands/hsetnx
 |
 |  hstrlen(self, name: 'KeyT', key: 'FieldT') -> 'int | Awaitable[int]'
 |      Return the number of bytes stored in the value of ``key``
 |      within hash ``name``
 |
 |      For more information, see https://redis.io/commands/hstrlen
 |
 |  httl(self, key: 'KeyT', *fields: 'FieldT') -> 'list[int] | Awaitable[list[int]]'
 |      Returns the TTL (Time To Live) in seconds for each specified field within a hash
 |      key.
 |
 |      For more information, see https://redis.io/commands/httl
 |
 |      Args:
 |          key: The hash key.
 |          fields: A list of fields within the hash for which to get the TTL.
 |
 |      Returns:
 |          Returns a list which contains for each field in the request:
 |              - `-2` if the field does not exist, or if the key does not exist.
 |              - `-1` if the field exists but has no associated expire time.
 |              - A positive integer representing the TTL in seconds if the field has
 |                an associated expiration time.
 |
 |  hvals(self, name: 'KeyT') -> 'list[bytes | str] | Awaitable[list[bytes | str]]'
 |      Return the list of values within hash ``name``
 |
 |      For more information, see https://redis.io/commands/hvals
 |
 |  ----------------------------------------------------------------------
 |  Methods inherited from redis.commands.core.GeoCommands:
 |
 |  geoadd(self, name: 'KeyT', values: 'Sequence[EncodableT]', nx: 'bool' = False, xx: 'bool' = False, ch: 'bool' = False) -> 'int | Awaitable[int]'
 |      Add the specified geospatial items to the specified key identified
 |      by the ``name`` argument. The Geospatial items are given as ordered
 |      members of the ``values`` argument, each item or place is formed by
 |      the triad longitude, latitude and name.
 |
 |      Note: You can use ZREM to remove elements.
 |
 |      ``nx`` forces ZADD to only create new elements and not to update
 |      scores for elements that already exist.
 |
 |      ``xx`` forces ZADD to only update scores of elements that already
 |      exist. New elements will not be added.
 |
 |      ``ch`` modifies the return value to be the numbers of elements changed.
 |      Changed elements include new elements that were added and elements
 |      whose scores changed.
 |
 |      For more information, see https://redis.io/commands/geoadd
 |
 |  geodist(self, name: 'KeyT', place1: 'FieldT', place2: 'FieldT', unit: 'str | None' = None) -> 'float | None | Awaitable[float | None]'
 |      Return the distance between ``place1`` and ``place2`` members of the
 |      ``name`` key.
 |      The units must be one of the following : m, km mi, ft. By default
 |      meters are used.
 |
 |      For more information, see https://redis.io/commands/geodist
 |
 |  geohash(self, name: 'KeyT', *values: 'FieldT') -> 'list[bytes | str | None] | Awaitable[list[bytes | str | None]]'
 |      Return the geo hash string for each item of ``values`` members of
 |      the specified key identified by the ``name`` argument.
 |
 |      For more information, see https://redis.io/commands/geohash
 |
 |  geopos(self, name: 'KeyT', *values: 'FieldT') -> 'list[GeoCoordinate | None] | Awaitable[list[GeoCoordinate | None]]'
 |      Return the positions of each item of ``values`` as members of
 |      the specified key identified by the ``name`` argument. Each position
 |      is represented by the pairs lon and lat.
 |
 |      For more information, see https://redis.io/commands/geopos
 |
 |  georadius(self, name: 'KeyT', longitude: 'float', latitude: 'float', radius: 'float', unit: 'str | None' = None, withdist: 'bool' = False, withcoord: 'bool' = False, withhash: 'bool' = False, count: 'int | None' = None, sort: 'str | None' = None, store: 'KeyT | None' = None, store_dist: 'KeyT | None' = None, any: 'bool' = False) -> 'GeoRadiusResponse | Awaitable[GeoRadiusResponse]'
 |      Return the members of the specified key identified by the
 |      ``name`` argument which are within the borders of the area specified
 |      with the ``latitude`` and ``longitude`` location and the maximum
 |      distance from the center specified by the ``radius`` value.
 |
 |      The units must be one of the following : m, km mi, ft. By default
 |
 |      ``withdist`` indicates to return the distances of each place.
 |
 |      ``withcoord`` indicates to return the latitude and longitude of
 |      each place.
 |
 |      ``withhash`` indicates to return the geohash string of each place.
 |
 |      ``count`` indicates to return the number of elements up to N.
 |
 |      ``sort`` indicates to return the places in a sorted way, ASC for
 |      nearest to fairest and DESC for fairest to nearest.
 |
 |      ``store`` indicates to save the places names in a sorted set named
 |      with a specific key, each element of the destination sorted set is
 |      populated with the score got from the original geo sorted set.
 |
 |      ``store_dist`` indicates to save the places names in a sorted set
 |      named with a specific key, instead of ``store`` the sorted set
 |      destination score is set with the distance.
 |
 |      For more information, see https://redis.io/commands/georadius
 |
 |  georadiusbymember(self, name: 'KeyT', member: 'FieldT', radius: 'float', unit: 'str | None' = None, withdist: 'bool' = False, withcoord: 'bool' = False, withhash: 'bool' = False, count: 'int | None' = None, sort: 'str | None' = None, store: 'Union[KeyT, None]' = None, store_dist: 'Union[KeyT, None]' = None, any: 'bool' = False) -> 'GeoRadiusResponse | Awaitable[GeoRadiusResponse]'
 |      This command is exactly like ``georadius`` with the sole difference
 |      that instead of taking, as the center of the area to query, a longitude
 |      and latitude value, it takes the name of a member already existing
 |      inside the geospatial index represented by the sorted set.
 |
 |      For more information, see https://redis.io/commands/georadiusbymember
 |
 |  geosearch(self, name: 'KeyT', member: 'FieldT | None' = None, longitude: 'float | None' = None, latitude: 'float | None' = None, unit: 'str' = 'm', radius: 'float | None' = None, width: 'float | None' = None, height: 'float | None' = None, sort: 'str | None' = None, count: 'int | None' = None, any: 'bool' = False, withcoord: 'bool' = False, withdist: 'bool' = False, withhash: 'bool' = False) -> 'GeoSearchResponse | Awaitable[GeoSearchResponse]'
 |      Return the members of specified key identified by the
 |      ``name`` argument, which are within the borders of the
 |      area specified by a given shape. This command extends the
 |      GEORADIUS command, so in addition to searching within circular
 |      areas, it supports searching within rectangular areas.
 |
 |      This command should be used in place of the deprecated
 |      GEORADIUS and GEORADIUSBYMEMBER commands.
 |
 |      ``member`` Use the position of the given existing
 |       member in the sorted set. Can't be given with ``longitude``
 |       and ``latitude``.
 |
 |      ``longitude`` and ``latitude`` Use the position given by
 |      this coordinates. Can't be given with ``member``
 |      ``radius`` Similar to GEORADIUS, search inside circular
 |      area according the given radius. Can't be given with
 |      ``height`` and ``width``.
 |      ``height`` and ``width`` Search inside an axis-aligned
 |      rectangle, determined by the given height and width.
 |      Can't be given with ``radius``
 |
 |      ``unit`` must be one of the following : m, km, mi, ft.
 |      `m` for meters (the default value), `km` for kilometers,
 |      `mi` for miles and `ft` for feet.
 |
 |      ``sort`` indicates to return the places in a sorted way,
 |      ASC for nearest to furthest and DESC for furthest to nearest.
 |
 |      ``count`` limit the results to the first count matching items.
 |
 |      ``any`` is set to True, the command will return as soon as
 |      enough matches are found. Can't be provided without ``count``
 |
 |      ``withdist`` indicates to return the distances of each place.
 |      ``withcoord`` indicates to return the latitude and longitude of
 |      each place.
 |
 |      ``withhash`` indicates to return the geohash string of each place.
 |
 |      For more information, see https://redis.io/commands/geosearch
 |
 |  geosearchstore(self, dest: 'KeyT', name: 'KeyT', member: 'FieldT | None' = None, longitude: 'float | None' = None, latitude: 'float | None' = None, unit: 'str' = 'm', radius: 'float | None' = None, width: 'float | None' = None, height: 'float | None' = None, sort: 'str | None' = None, count: 'int | None' = None, any: 'bool' = False, storedist: 'bool' = False) -> 'int | Awaitable[int]'
 |      This command is like GEOSEARCH, but stores the result in
 |      ``dest``. By default, it stores the results in the destination
 |      sorted set with their geospatial information.
 |      if ``store_dist`` set to True, the command will stores the
 |      items in a sorted set populated with their distance from the
 |      center of the circle or box, as a floating-point number.
 |
 |      For more information, see https://redis.io/commands/geosearchstore
 |
 |  ----------------------------------------------------------------------
 |  Methods inherited from redis.commands.core.ListCommands:
 |
 |  blmpop(self, timeout: 'float', numkeys: 'int', *args: 'str', direction: 'str', count: 'int | None' = 1) -> 'ListMultiPopResponse | Awaitable[ListMultiPopResponse]'
 |      Pop ``count`` values (default 1) from first non-empty in the list
 |      of provided key names.
 |
 |      When all lists are empty this command blocks the connection until another
 |      client pushes to it or until the timeout, timeout of 0 blocks indefinitely
 |
 |      For more information, see https://redis.io/commands/blmpop
 |
 |  blpop(self, keys: 'KeysT', timeout: 'Number | None' = 0) -> 'BlockingListPopResponse | Awaitable[BlockingListPopResponse]'
 |      LPOP a value off of the first non-empty list
 |      named in ``keys``.
 |
 |      If none of the lists in ``keys`` has a value to LPOP, then block
 |      for ``timeout`` seconds, or until a value gets pushed on to one
 |      of the lists.
 |
 |      If timeout is 0, then block indefinitely.
 |
 |      For more information, see https://redis.io/commands/blpop
 |
 |  brpop(self, keys: 'KeysT', timeout: 'Number | None' = 0) -> 'BlockingListPopResponse | Awaitable[BlockingListPopResponse]'
 |      RPOP a value off of the first non-empty list
 |      named in ``keys``.
 |
 |      If none of the lists in ``keys`` has a value to RPOP, then block
 |      for ``timeout`` seconds, or until a value gets pushed on to one
 |      of the lists.
 |
 |      If timeout is 0, then block indefinitely.
 |
 |      For more information, see https://redis.io/commands/brpop
 |
 |  brpoplpush(self, src: 'KeyT', dst: 'KeyT', timeout: 'Number | None' = 0) -> 'bytes | str | None | Awaitable[bytes | str | None]'
 |      Pop a value off the tail of ``src``, push it on the head of ``dst``
 |      and then return it.
 |
 |      This command blocks until a value is in ``src`` or until ``timeout``
 |      seconds elapse, whichever is first. A ``timeout`` value of 0 blocks
 |      forever.
 |
 |      For more information, see https://redis.io/commands/brpoplpush
 |
 |  lindex(self, name: 'KeyT', index: 'int') -> 'bytes | str | None | Awaitable[bytes | str | None]'
 |      Return the item from list ``name`` at position ``index``
 |
 |      Negative indexes are supported and will return an item at the
 |      end of the list
 |
 |      For more information, see https://redis.io/commands/lindex
 |
 |  linsert(self, name: 'KeyT', where: 'str', refvalue: 'str', value: 'str') -> 'int | Awaitable[int]'
 |      Insert ``value`` in list ``name`` either immediately before or after
 |      [``where``] ``refvalue``
 |
 |      Returns the new length of the list on success or -1 if ``refvalue``
 |      is not in the list.
 |
 |      For more information, see https://redis.io/commands/linsert
 |
 |  llen(self, name: 'KeyT') -> 'int | Awaitable[int]'
 |      Return the length of the list ``name``
 |
 |      For more information, see https://redis.io/commands/llen
 |
 |  lmpop(self, num_keys: 'int', *args: 'str', direction: 'str', count: 'int | None' = 1) -> 'ListMultiPopResponse | Awaitable[ListMultiPopResponse]'
 |      Pop ``count`` values (default 1) first non-empty list key from the list
 |      of args provided key names.
 |
 |      For more information, see https://redis.io/commands/lmpop
 |
 |  lpop(self, name: 'KeyT', count: 'int | None' = None) -> 'bytes | str | list[bytes | str] | None | Awaitable[bytes | str | list[bytes | str] | None]'
 |      Removes and returns the first elements of the list ``name``.
 |
 |      By default, the command pops a single element from the beginning of
 |      the list. When provided with the optional ``count`` argument, the reply
 |      will consist of up to count elements, depending on the list's length.
 |
 |      For more information, see https://redis.io/commands/lpop
 |
 |  lpos(self, name: 'KeyT', value: 'str', rank: 'int | None' = None, count: 'int | None' = None, maxlen: 'int | None' = None) -> 'int | list[int] | None | Awaitable[int | list[int] | None]'
 |      Get position of ``value`` within the list ``name``
 |
 |       If specified, ``rank`` indicates the "rank" of the first element to
 |       return in case there are multiple copies of ``value`` in the list.
 |       By default, LPOS returns the position of the first occurrence of
 |       ``value`` in the list. When ``rank`` 2, LPOS returns the position of
 |       the second ``value`` in the list. If ``rank`` is negative, LPOS
 |       searches the list in reverse. For example, -1 would return the
 |       position of the last occurrence of ``value`` and -2 would return the
 |       position of the next to last occurrence of ``value``.
 |
 |       If specified, ``count`` indicates that LPOS should return a list of
 |       up to ``count`` positions. A ``count`` of 2 would return a list of
 |       up to 2 positions. A ``count`` of 0 returns a list of all positions
 |       matching ``value``. When ``count`` is specified and but ``value``
 |       does not exist in the list, an empty list is returned.
 |
 |       If specified, ``maxlen`` indicates the maximum number of list
 |       elements to scan. A ``maxlen`` of 1000 will only return the
 |       position(s) of items within the first 1000 entries in the list.
 |       A ``maxlen`` of 0 (the default) will scan the entire list.
 |
 |       For more information, see https://redis.io/commands/lpos
 |
 |  lpush(self, name: 'KeyT', *values: 'FieldT') -> 'int | Awaitable[int]'
 |      Push ``values`` onto the head of the list ``name``
 |
 |      For more information, see https://redis.io/commands/lpush
 |
 |  lpushx(self, name: 'KeyT', *values: 'FieldT') -> 'int | Awaitable[int]'
 |      Push ``value`` onto the head of the list ``name`` if ``name`` exists
 |
 |      For more information, see https://redis.io/commands/lpushx
 |
 |  lrange(self, name: 'KeyT', start: 'int', end: 'int') -> 'list[bytes | str] | Awaitable[list[bytes | str]]'
 |      Return a slice of the list ``name`` between
 |      position ``start`` and ``end``
 |
 |      ``start`` and ``end`` can be negative numbers just like
 |      Python slicing notation
 |
 |      For more information, see https://redis.io/commands/lrange
 |
 |  lrem(self, name: 'KeyT', count: 'int', value: 'str') -> 'int | Awaitable[int]'
 |      Remove the first ``count`` occurrences of elements equal to ``value``
 |      from the list stored at ``name``.
 |
 |      The count argument influences the operation in the following ways:
 |          count > 0: Remove elements equal to value moving from head to tail.
 |          count < 0: Remove elements equal to value moving from tail to head.
 |          count = 0: Remove all elements equal to value.
 |
 |          For more information, see https://redis.io/commands/lrem
 |
 |  lset(self, name: 'KeyT', index: 'int', value: 'str') -> 'bool | Awaitable[bool]'
 |      Set element at ``index`` of list ``name`` to ``value``
 |
 |      For more information, see https://redis.io/commands/lset
 |
 |  ltrim(self, name: 'KeyT', start: 'int', end: 'int') -> 'bool | Awaitable[bool]'
 |      Trim the list ``name``, removing all values not within the slice
 |      between ``start`` and ``end``
 |
 |      ``start`` and ``end`` can be negative numbers just like
 |      Python slicing notation
 |
 |      For more information, see https://redis.io/commands/ltrim
 |
 |  rpop(self, name: 'KeyT', count: 'int | None' = None) -> 'bytes | str | list[bytes | str] | None | Awaitable[bytes | str | list[bytes | str] | None]'
 |      Removes and returns the last elements of the list ``name``.
 |
 |      By default, the command pops a single element from the end of the list.
 |      When provided with the optional ``count`` argument, the reply will
 |      consist of up to count elements, depending on the list's length.
 |
 |      For more information, see https://redis.io/commands/rpop
 |
 |  rpoplpush(self, src: 'KeyT', dst: 'KeyT') -> 'bytes | str | None | Awaitable[bytes | str | None]'
 |      RPOP a value off of the ``src`` list and atomically LPUSH it
 |      on to the ``dst`` list.  Returns the value.
 |
 |      For more information, see https://redis.io/commands/rpoplpush
 |
 |  rpush(self, name: 'KeyT', *values: 'FieldT') -> 'int | Awaitable[int]'
 |      Push ``values`` onto the tail of the list ``name``
 |
 |      For more information, see https://redis.io/commands/rpush
 |
 |  rpushx(self, name: 'KeyT', *values: 'str') -> 'int | Awaitable[int]'
 |      Push ``value`` onto the tail of the list ``name`` if ``name`` exists
 |
 |      For more information, see https://redis.io/commands/rpushx
 |
 |  sort(self, name: 'KeyT', start: 'int | None' = None, num: 'int | None' = None, by: 'str | None' = None, get: 'list[str] | None' = None, desc: 'bool' = False, alpha: 'bool' = False, store: 'str | None' = None, groups: 'bool | None' = False) -> 'SortResponse | Awaitable[SortResponse]'
 |      Sort and return the list, set or sorted set at ``name``.
 |
 |      ``start`` and ``num`` allow for paging through the sorted data
 |
 |      ``by`` allows using an external key to weight and sort the items.
 |          Use an "*" to indicate where in the key the item value is located
 |
 |      ``get`` allows for returning items from external keys rather than the
 |          sorted data itself.  Use an "*" to indicate where in the key
 |          the item value is located
 |
 |      ``desc`` allows for reversing the sort
 |
 |      ``alpha`` allows for sorting lexicographically rather than numerically
 |
 |      ``store`` allows for storing the result of the sort into
 |          the key ``store``
 |
 |      ``groups`` if set to True and if ``get`` contains at least two
 |          elements, sort will return a list of tuples, each containing the
 |          values fetched from the arguments to ``get``.
 |
 |      For more information, see https://redis.io/commands/sort
 |
 |  sort_ro(self, key: 'str', start: 'int | None' = None, num: 'int | None' = None, by: 'str | None' = None, get: 'list[str] | None' = None, desc: 'bool' = False, alpha: 'bool' = False) -> 'list[bytes | str] | Awaitable[list[bytes | str]]'
 |      Returns the elements contained in the list, set or sorted set at key.
 |      (read-only variant of the SORT command)
 |
 |      ``start`` and ``num`` allow for paging through the sorted data
 |
 |      ``by`` allows using an external key to weight and sort the items.
 |          Use an "*" to indicate where in the key the item value is located
 |
 |      ``get`` allows for returning items from external keys rather than the
 |          sorted data itself.  Use an "*" to indicate where in the key
 |          the item value is located
 |
 |      ``desc`` allows for reversing the sort
 |
 |      ``alpha`` allows for sorting lexicographically rather than numerically
 |
 |      For more information, see https://redis.io/commands/sort_ro
 |
 |  ----------------------------------------------------------------------
 |  Methods inherited from redis.commands.core.ArrayCommands:
 |
 |  arcount(self, name: 'KeyT') -> 'int | Awaitable[int]'
 |      Return the number of non-empty elements in the array stored at
 |      ``name``. Returns 0 if ``name`` does not exist.
 |
 |      For more information, see https://redis.io/commands/arcount
 |
 |  ardel(self, name: 'KeyT', *indices: 'int') -> 'int | Awaitable[int]'
 |      Delete elements at the specified ``indices`` in the array stored at
 |      ``name``. Deleting an index that does not exist counts as zero
 |      elements deleted and does not modify the array.
 |
 |      Returns the number of elements deleted.
 |
 |      For more information, see https://redis.io/commands/ardel
 |
 |  ardelrange(self, name: 'KeyT', *ranges: 'tuple[int, int]') -> 'int | Awaitable[int]'
 |      Delete elements within one or more inclusive index ranges in the
 |      array stored at ``name``. Each range is a ``(start, end)`` tuple.
 |      If ``start`` is greater than ``end`` for a given pair, the range is
 |      processed in ascending order regardless. Multiple pairs may overlap;
 |      each element is counted at most once.
 |
 |      Returns the number of elements deleted.
 |
 |      For more information, see https://redis.io/commands/ardelrange
 |
 |  arget(self, name: 'KeyT', index: 'int') -> 'bytes | str | None | Awaitable[bytes | str | None]'
 |      Return the value at ``index`` in the array stored at ``name``.
 |
 |      Returns ``None`` if ``name`` does not exist or no value is set at
 |      ``index``.
 |
 |      For more information, see https://redis.io/commands/arget
 |
 |  argetrange(self, name: 'KeyT', start: 'int', end: 'int') -> 'list[bytes | str | None] | Awaitable[list[bytes | str | None]]'
 |      Return the values in the inclusive index range [``start``, ``end``]
 |      in the array stored at ``name``. If ``start`` is greater than ``end``,
 |      elements are returned in reverse index order.
 |
 |      For more information, see https://redis.io/commands/argetrange
 |
 |  argrep(self, name: 'KeyT', start: 'int', end: 'int', predicates: 'list[tuple[ArrayPredicateType, EncodableT]]', combinator: 'ArrayPredicateCombinator | None' = None, limit: 'int | None' = None, withvalues: 'bool' = False, nocase: 'bool' = False) -> 'list[int] | list[list[int | bytes | str]] | Awaitable[list[int] | list[list[int | bytes | str]]]'
 |      Search elements of the array stored at ``name`` within the inclusive
 |      index range [``start``, ``end``] using one or more textual
 |      ``predicates``. Each predicate is a ``(type, value)`` tuple where
 |      ``type`` is a member of ``ArrayPredicateType``
 |      (``EXACT``, ``MATCH``, ``GLOB``, ``RE``).
 |
 |      Multiple predicates are combined via ``combinator``
 |      (``ArrayPredicateCombinator.AND`` or ``OR``); the server defaults to
 |      OR when omitted. ``limit`` caps the number of matches.
 |      ``withvalues=True`` returns a list of ``[index, value]`` pairs
 |      (``[[idx, val], ...]``) instead of a flat list of indices.
 |      ``nocase=True`` makes all comparisons case-insensitive.
 |
 |      Without ``withvalues``, returns a flat list of matching indices in
 |      traversal order. With ``withvalues``, returns a list of
 |      ``[index, value]`` pairs in traversal order. Empty slots are
 |      skipped.
 |
 |      For more information, see https://redis.io/commands/argrep
 |
 |  arinfo(self, name: 'KeyT', full: 'bool' = False) -> 'dict[str, int] | Awaitable[dict[str, int]]'
 |      Return metadata about the array stored at ``name`` as a dictionary.
 |      When ``full`` is ``True``, additionally include per-slice statistics
 |      (dense/sparse slice counts, average sizes, fill rates), which makes
 |      the call O(N) instead of O(1).
 |
 |      Raises ``ResponseError`` when the key does not exist.
 |
 |      For more information, see https://redis.io/commands/arinfo
 |
 |  arinsert(self, name: 'KeyT', *values: 'FieldT') -> 'int | Awaitable[int]'
 |      Insert one or more ``values`` at consecutive indices in the array
 |      stored at ``name``, beginning at the current insert cursor position.
 |      The cursor advances by one for each value inserted. Use ``ARNEXT``
 |      to inspect the current cursor position and ``ARSEEK`` to reposition
 |      it.
 |
 |      Returns the last index where a value was inserted.
 |
 |      For more information, see https://redis.io/commands/arinsert
 |
 |  arlastitems(self, name: 'KeyT', count: 'int', rev: 'bool' = False) -> 'list[bytes | str | None] | Awaitable[list[bytes | str | None]]'
 |      Return up to ``count`` most recently inserted elements from the array
 |      stored at ``name``. If the array contains fewer elements than
 |      ``count``, all elements are returned.
 |
 |      When ``rev`` is ``True``, elements are returned in reverse
 |      chronological order (most recent first) instead of the default
 |      oldest-first order.
 |
 |      For more information, see https://redis.io/commands/arlastitems
 |
 |  arlen(self, name: 'KeyT') -> 'int | Awaitable[int]'
 |      Return the length of the array stored at ``name``, defined as the
 |      maximum set index plus one. Returns 0 if ``name`` does not exist.
 |
 |      For more information, see https://redis.io/commands/arlen
 |
 |  armget(self, name: 'KeyT', *indices: 'int') -> 'list[bytes | str | None] | Awaitable[list[bytes | str | None]]'
 |      Return the values at the specified ``indices`` in the array stored at
 |      ``name``. The reply preserves the order of the requested indices and
 |      returns ``None`` for any index that is not set or when ``name`` does
 |      not exist.
 |
 |      For more information, see https://redis.io/commands/armget
 |
 |  armset(self, name: 'KeyT', mapping: 'Mapping[int, FieldT]') -> 'int | Awaitable[int]'
 |      Set multiple index/value pairs in the array stored at ``name``.
 |      ``mapping`` is a dictionary of zero-based integer indices to values.
 |      Pairs may be non-contiguous and in any order.
 |
 |      Returns the number of new slots that were set (previously empty).
 |
 |      For more information, see https://redis.io/commands/armset
 |
 |  arnext(self, name: 'KeyT') -> 'int | None | Awaitable[int | None]'
 |      Return the next index ``ARINSERT`` would use for the array stored at
 |      ``name``. Returns 0 if ``name`` does not exist or no insert happened
 |      yet, and ``None`` when the insertion cursor is exhausted (next insert
 |      would overflow).
 |
 |      For more information, see https://redis.io/commands/arnext
 |
 |  arop(self, name: 'KeyT', start: 'int', end: 'int', operation: 'ArrayAggregateOperations', value: 'EncodableT | None' = None) -> 'bytes | str | int | None | Awaitable[bytes | str | int | None]'
 |      Perform an aggregate ``operation`` on elements of the array stored at
 |      ``name`` in the inclusive index range [``start``, ``end``]. The range
 |      is always scanned from the lower to the higher index regardless of
 |      argument order.
 |
 |      ``operation`` is one of the members of ``ArrayAggregateOperations``.
 |      ``value`` is required when ``operation`` is
 |      ``ArrayAggregateOperations.MATCH`` and specifies the value to compare
 |      against.
 |
 |      Returns a bulk string for ``SUM``, ``MIN`` and ``MAX``, an integer
 |      for ``AND``, ``OR``, ``XOR``, ``MATCH`` and ``USED``, or ``None``
 |      when no elements match the operation.
 |
 |      For more information, see https://redis.io/commands/arop
 |
 |  arring(self, name: 'KeyT', size: 'int', *values: 'FieldT') -> 'int | Awaitable[int]'
 |      Insert one or more ``values`` into the array stored at ``name`` as a
 |      fixed-size ring buffer of ``size`` slots. Each value is placed at
 |      ``insert_idx % size``, wrapping back to index 0 once the end is
 |      reached and overwriting older values when full. If ``size`` is
 |      smaller than the current window, the array is truncated to fit.
 |
 |      Returns the last index where a value was inserted.
 |
 |      For more information, see https://redis.io/commands/arring
 |
 |  arscan(self, name: 'KeyT', start: 'int', end: 'int', limit: 'int | None' = None) -> 'list[list[int | bytes | str]] | Awaitable[list[list[int | bytes | str]]]'
 |      Iterate populated elements of the array stored at ``name`` in the
 |      inclusive range [``start``, ``end``] and return a list of
 |      ``[index, value]`` pairs in traversal order:
 |      ``[[idx1, val1], [idx2, val2], ...]``. Empty slots are skipped. If
 |      ``start`` is greater than ``end``, the iteration is reversed.
 |
 |      ``limit`` caps the number of populated elements returned. When
 |      omitted, all populated elements in range are returned.
 |
 |      For more information, see https://redis.io/commands/arscan
 |
 |  arseek(self, name: 'KeyT', index: 'int') -> 'int | Awaitable[int]'
 |      Set the insert cursor of the array stored at ``name`` to ``index``.
 |      Subsequent ``ARINSERT`` and ``ARRING`` operations begin inserting at
 |      this position.
 |
 |      Returns 1 if the cursor was set, 0 if ``name`` does not exist.
 |
 |      For more information, see https://redis.io/commands/arseek
 |
 |  arset(self, name: 'KeyT', index: 'int', *values: 'FieldT') -> 'int | Awaitable[int]'
 |      Set one or more contiguous ``values`` in the array stored at ``name``
 |      starting at ``index``. When multiple values are provided, they are
 |      stored at consecutive indices beginning at ``index``.
 |
 |      Returns the number of new slots that were set (previously empty).
 |
 |      For more information, see https://redis.io/commands/arset
 |
 |  ----------------------------------------------------------------------
 |  Methods inherited from redis.commands.core.ScanCommands:
 |
 |  hscan(self, name: 'KeyT', cursor: 'int' = 0, match: 'PatternT | None' = None, count: 'int | None' = None, no_values: 'bool | None' = None) -> 'HScanResponse | Awaitable[HScanResponse]'
 |      Incrementally return key/value slices in a hash. Also return a cursor
 |      indicating the scan position.
 |
 |      ``match`` allows for filtering the keys by pattern
 |
 |      ``count`` allows for hint the minimum number of returns
 |
 |      ``no_values`` indicates to return only the keys, without values.
 |
 |      For more information, see https://redis.io/commands/hscan
 |
 |  hscan_iter(self, name: 'KeyT', match: 'Union[PatternT, None]' = None, count: 'Optional[int]' = None, no_values: 'Union[bool, None]' = None) -> 'Iterator'
 |      Make an iterator using the HSCAN command so that the client doesn't
 |      need to remember the cursor position.
 |
 |      ``match`` allows for filtering the keys by pattern
 |
 |      ``count`` allows for hint the minimum number of returns
 |
 |      ``no_values`` indicates to return only the keys, without values
 |
 |  scan(self, cursor: 'int' = 0, match: 'PatternT | None' = None, count: 'int | None' = None, _type: 'str | None' = None, **kwargs) -> 'ScanResponse | Awaitable[ScanResponse]'
 |      Incrementally return lists of key names. Also return a cursor
 |      indicating the scan position.
 |
 |      ``match`` allows for filtering the keys by pattern
 |
 |      ``count`` provides a hint to Redis about the number of keys to
 |          return per batch.
 |
 |      ``_type`` filters the returned values by a particular Redis type.
 |          Stock Redis instances allow for the following types:
 |          HASH, LIST, SET, STREAM, STRING, ZSET
 |          Additionally, Redis modules can expose other types as well.
 |
 |      For more information, see https://redis.io/commands/scan
 |
 |  scan_iter(self, match: 'Union[PatternT, None]' = None, count: 'Optional[int]' = None, _type: 'Optional[str]' = None, **kwargs) -> 'Iterator'
 |      Make an iterator using the SCAN command so that the client doesn't
 |      need to remember the cursor position.
 |
 |      ``match`` allows for filtering the keys by pattern
 |
 |      ``count`` provides a hint to Redis about the number of keys to
 |          return per batch.
 |
 |      ``_type`` filters the returned values by a particular Redis type.
 |          Stock Redis instances allow for the following types:
 |          HASH, LIST, SET, STREAM, STRING, ZSET
 |          Additionally, Redis modules can expose other types as well.
 |
 |  sscan(self, name: 'KeyT', cursor: 'int' = 0, match: 'PatternT | None' = None, count: 'int | None' = None) -> 'ScanResponse | Awaitable[ScanResponse]'
 |      Incrementally return lists of elements in a set. Also return a cursor
 |      indicating the scan position.
 |
 |      ``match`` allows for filtering the keys by pattern
 |
 |      ``count`` allows for hint the minimum number of returns
 |
 |      For more information, see https://redis.io/commands/sscan
 |
 |  sscan_iter(self, name: 'KeyT', match: 'Union[PatternT, None]' = None, count: 'Optional[int]' = None) -> 'Iterator'
 |      Make an iterator using the SSCAN command so that the client doesn't
 |      need to remember the cursor position.
 |
 |      ``match`` allows for filtering the keys by pattern
 |
 |      ``count`` allows for hint the minimum number of returns
 |
 |  zscan(self, name: 'KeyT', cursor: 'int' = 0, match: 'PatternT | None' = None, count: 'int | None' = None, score_cast_func: 'type | Callable' = <class 'float'>) -> 'ZScanResponse | Awaitable[ZScanResponse]'
 |      Incrementally return lists of elements in a sorted set. Also return a
 |      cursor indicating the scan position.
 |
 |      ``match`` allows for filtering the keys by pattern
 |
 |      ``count`` allows for hint the minimum number of returns
 |
 |      ``score_cast_func`` a callable used to cast the score return value
 |
 |      For more information, see https://redis.io/commands/zscan
 |
 |  zscan_iter(self, name: 'KeyT', match: 'Union[PatternT, None]' = None, count: 'Optional[int]' = None, score_cast_func: 'Union[type, Callable]' = <class 'float'>) -> 'Iterator'
 |      Make an iterator using the ZSCAN command so that the client doesn't
 |      need to remember the cursor position.
 |
 |      ``match`` allows for filtering the keys by pattern
 |
 |      ``count`` allows for hint the minimum number of returns
 |
 |      ``score_cast_func`` a callable used to cast the score return value
 |
 |  ----------------------------------------------------------------------
 |  Methods inherited from redis.commands.core.SetCommands:
 |
 |  sadd(self, name: 'KeyT', *values: 'FieldT') -> 'int | Awaitable[int]'
 |      Add ``value(s)`` to set ``name``
 |
 |      For more information, see https://redis.io/commands/sadd
 |
 |  scard(self, name: 'KeyT') -> 'int | Awaitable[int]'
 |      Return the number of elements in set ``name``
 |
 |      For more information, see https://redis.io/commands/scard
 |
 |  sdiff(self, keys: 'List', *args: 'List') -> 'set[bytes | str] | Awaitable[set[bytes | str]]'
 |      Return the difference of sets specified by ``keys``
 |
 |      For more information, see https://redis.io/commands/sdiff
 |
 |  sdiffcard(self, numkeys: 'int', keys: 'List[KeyT]', limit: 'int' = 0) -> 'int | Awaitable[int]'
 |      Return the cardinality of the difference between the first set and all
 |      the successive sets specified by ``keys``, without returning the
 |      difference itself.
 |
 |      When LIMIT is provided (defaults to 0 and means unlimited), the returned
 |      cardinality is capped at ``limit`` and the server may stop the
 |      computation once the capped result is known.
 |
 |      For more information, see https://redis.io/commands/sdiffcard
 |
 |  sdiffstore(self, dest: 'str', keys: 'List', *args: 'List') -> 'int | Awaitable[int]'
 |      Store the difference of sets specified by ``keys`` into a new
 |      set named ``dest``.  Returns the number of keys in the new set.
 |
 |      For more information, see https://redis.io/commands/sdiffstore
 |
 |  sinter(self, keys: 'List', *args: 'List') -> 'set[bytes | str] | Awaitable[set[bytes | str]]'
 |      Return the intersection of sets specified by ``keys``
 |
 |      For more information, see https://redis.io/commands/sinter
 |
 |  sintercard(self, numkeys: 'int', keys: 'List[KeyT]', limit: 'int' = 0) -> 'int | Awaitable[int]'
 |      Return the cardinality of the intersect of multiple sets specified by ``keys``.
 |
 |      When LIMIT provided (defaults to 0 and means unlimited), if the intersection
 |      cardinality reaches limit partway through the computation, the algorithm will
 |      exit and yield limit as the cardinality
 |
 |      For more information, see https://redis.io/commands/sintercard
 |
 |  sinterstore(self, dest: 'KeyT', keys: 'List', *args: 'List') -> 'int | Awaitable[int]'
 |      Store the intersection of sets specified by ``keys`` into a new
 |      set named ``dest``.  Returns the number of keys in the new set.
 |
 |      For more information, see https://redis.io/commands/sinterstore
 |
 |  sismember(self, name: 'KeyT', value: 'str') -> 'Literal[0] | Literal[1] | Awaitable[Literal[0] | Literal[1]]'
 |      Return whether ``value`` is a member of set ``name``:
 |      - 1 if the value is a member of the set.
 |      - 0 if the value is not a member of the set or if key does not exist.
 |
 |      For more information, see https://redis.io/commands/sismember
 |
 |  smembers(self, name: 'KeyT') -> 'set[bytes | str] | Awaitable[set[bytes | str]]'
 |      Return all members of the set ``name``
 |
 |      For more information, see https://redis.io/commands/smembers
 |
 |  smismember(self, name: 'KeyT', values: 'List', *args: 'List') -> 'list[Literal[0] | Literal[1]] | Awaitable[list[Literal[0] | Literal[1]]]'
 |      Return whether each value in ``values`` is a member of the set ``name``
 |      as a list of ``int`` in the order of ``values``:
 |      - 1 if the value is a member of the set.
 |      - 0 if the value is not a member of the set or if key does not exist.
 |
 |      For more information, see https://redis.io/commands/smismember
 |
 |  smove(self, src: 'KeyT', dst: 'KeyT', value: 'str') -> 'bool | Awaitable[bool]'
 |      Move ``value`` from set ``src`` to set ``dst`` atomically
 |
 |      For more information, see https://redis.io/commands/smove
 |
 |  spop(self, name: 'KeyT', count: 'int | None' = None) -> 'bytes | str | set[bytes | str] | None | Awaitable[bytes | str | set[bytes | str] | None]'
 |      Remove and return a random member of set ``name``
 |
 |      For more information, see https://redis.io/commands/spop
 |
 |  srandmember(self, name: 'KeyT', number: 'int | None' = None) -> 'bytes | str | list[bytes | str] | None | Awaitable[bytes | str | list[bytes | str] | None]'
 |      If ``number`` is None, returns a random member of set ``name``.
 |
 |      If ``number`` is supplied, returns a list of ``number`` random
 |      members of set ``name``. Note this is only available when running
 |      Redis 2.6+.
 |
 |      For more information, see https://redis.io/commands/srandmember
 |
 |  srem(self, name: 'KeyT', *values: 'FieldT') -> 'int | Awaitable[int]'
 |      Remove ``values`` from set ``name``
 |
 |      For more information, see https://redis.io/commands/srem
 |
 |  sunion(self, keys: 'List', *args: 'List') -> 'set[bytes | str] | Awaitable[set[bytes | str]]'
 |      Return the union of sets specified by ``keys``
 |
 |      For more information, see https://redis.io/commands/sunion
 |
 |  sunioncard(self, numkeys: 'int', keys: 'List[KeyT]', limit: 'int' = 0, approx: 'bool' = False) -> 'int | Awaitable[int]'
 |      Return the cardinality of the union of multiple sets specified by
 |      ``keys``, without returning the union itself.
 |
 |      When ``approx`` is True, the ``APPROX`` option is sent and the server
 |      returns an approximate cardinality computed using HyperLogLog.
 |
 |      When LIMIT is provided (defaults to 0 and means unlimited), the returned
 |      cardinality is capped at ``limit``. In exact mode the result equals
 |      ``limit`` when the real cardinality exceeds ``limit``; in approximate
 |      mode the result will not exceed ``limit``. Options are emitted in the
 |      canonical order ``APPROX`` before ``LIMIT``.
 |
 |      For more information, see https://redis.io/commands/sunioncard
 |
 |  sunionstore(self, dest: 'KeyT', keys: 'List', *args: 'List') -> 'int | Awaitable[int]'
 |      Store the union of sets specified by ``keys`` into a new
 |      set named ``dest``.  Returns the number of keys in the new set.
 |
 |      For more information, see https://redis.io/commands/sunionstore
 |
 |  ----------------------------------------------------------------------
 |  Methods inherited from redis.commands.core.StreamCommands:
 |
 |  xack(self, name: 'KeyT', groupname: 'GroupT', *ids: 'StreamIdT') -> 'int | Awaitable[int]'
 |      Acknowledges the successful processing of one or more messages.
 |
 |      Args:
 |          name: name of the stream.
 |          groupname: name of the consumer group.
 |          *ids: message ids to acknowledge.
 |
 |      For more information, see https://redis.io/commands/xack
 |
 |  xackdel(self, name: 'KeyT', groupname: 'GroupT', *ids: 'StreamIdT', ref_policy: "Literal['KEEPREF', 'DELREF', 'ACKED']" = 'KEEPREF') -> 'int | Awaitable[int]'
 |      Combines the functionality of XACK and XDEL. Acknowledges the specified
 |      message IDs in the given consumer group and simultaneously attempts to
 |      delete the corresponding entries from the stream.
 |
 |  xadd(self, name: 'KeyT', fields: 'Dict[FieldT, EncodableT]', id: 'StreamIdT' = '*', maxlen: 'Optional[int]' = None, approximate: 'bool' = True, nomkstream: 'bool' = False, minid: 'Union[StreamIdT, None]' = None, limit: 'int | None' = None, ref_policy: "Literal['KEEPREF', 'DELREF', 'ACKED'] | None" = None, idmpauto: 'str | None' = None, idmp: 'tuple[str, bytes] | None' = None) -> 'bytes | str | Awaitable[bytes | str]'
 |      Add to a stream.
 |      name: name of the stream
 |      fields: dict of field/value pairs to insert into the stream
 |      id: Location to insert this record. By default it is appended.
 |      maxlen: truncate old stream members beyond this size.
 |      Can't be specified with minid.
 |      approximate: actual stream length may be slightly more than maxlen
 |      nomkstream: When set to true, do not make a stream
 |      minid: the minimum id in the stream to query.
 |      Can't be specified with maxlen.
 |      limit: specifies the maximum number of entries to retrieve
 |      ref_policy: optional reference policy for consumer groups when trimming:
 |          - KEEPREF (default): When trimming, preserves references in consumer groups' PEL
 |          - DELREF: When trimming, removes all references from consumer groups' PEL
 |          - ACKED: When trimming, only removes entries acknowledged by all consumer groups
 |      idmpauto: Producer ID for automatic idempotent ID calculation.
 |          Automatically calculates an idempotent ID based on entry content to prevent
 |          duplicate entries. Can only be used with id='*'. Creates an IDMP map if it
 |          doesn't exist yet. The producer ID must be unique per producer and consistent
 |          across restarts.
 |      idmp: Tuple of (producer_id, idempotent_id) for explicit idempotent ID.
 |          Uses a specific idempotent ID to prevent duplicate entries. Can only be used
 |          with id='*'. The producer ID must be unique per producer and consistent across
 |          restarts. The idempotent ID must be unique per message and per producer.
 |          Shorter idempotent IDs require less memory and allow faster processing.
 |          Creates an IDMP map if it doesn't exist yet.
 |
 |      For more information, see https://redis.io/commands/xadd
 |
 |  xautoclaim(self, name: 'KeyT', groupname: 'GroupT', consumername: 'ConsumerT', min_idle_time: 'int', start_id: 'StreamIdT' = '0-0', count: 'int | None' = None, justid: 'bool' = False) -> 'list[Any] | Awaitable[list[Any]]'
 |      Transfers ownership of pending stream entries that match the specified
 |      criteria. Conceptually, equivalent to calling XPENDING and then XCLAIM,
 |      but provides a more straightforward way to deal with message delivery
 |      failures via SCAN-like semantics.
 |      name: name of the stream.
 |      groupname: name of the consumer group.
 |      consumername: name of a consumer that claims the message.
 |      min_idle_time: filter messages that were idle less than this amount of
 |      milliseconds.
 |      start_id: filter messages with equal or greater ID.
 |      count: optional integer, upper limit of the number of entries that the
 |      command attempts to claim. Set to 100 by default.
 |      justid: optional boolean, false by default. Return just an array of IDs
 |      of messages successfully claimed, without returning the actual message
 |
 |      For more information, see https://redis.io/commands/xautoclaim
 |
 |  xcfgset(self, name: 'KeyT', idmp_duration: 'int | None' = None, idmp_maxsize: 'int | None' = None) -> 'bytes | str | Awaitable[bytes | str]'
 |      Configure the idempotency parameters for a stream's IDMP map.
 |
 |      Sets how long Redis remembers each idempotent ID (iid) and the maximum
 |      number of iids to track. This command clears the existing IDMP map
 |      (Redis forgets all previously stored iids), but only if the configuration
 |      value actually changes.
 |
 |      Args:
 |          name: The name of the stream.
 |          idmp_duration: How long Redis remembers each iid in seconds.
 |              Default: 100 seconds (or value set by stream-idmp-duration config).
 |              Minimum: 1 second, Maximum: 300 seconds.
 |              Redis won't forget an iid for this duration (unless maxsize is reached).
 |              Should accommodate application crash recovery time.
 |          idmp_maxsize: Maximum number of iids Redis remembers per producer ID (pid).
 |              Default: 100 iids (or value set by stream-idmp-maxsize config).
 |              Minimum: 1 iid, Maximum: 1,000,000 (1M) iids.
 |              Should be set to: mark-delay [in msec] × (messages/msec) + margin.
 |              Example: 10K msgs/sec (10 msgs/msec), 80 msec mark-delay
 |              → maxsize = 10 × 80 + margin = 1000 iids.
 |
 |      Returns:
 |          OK on success.
 |
 |      For more information, see https://redis.io/commands/xcfgset
 |
 |  xclaim(self, name: 'KeyT', groupname: 'GroupT', consumername: 'ConsumerT', min_idle_time: 'int', message_ids: 'Union[List[StreamIdT], Tuple[StreamIdT]]', idle: 'int | None' = None, time: 'int | None' = None, retrycount: 'int | None' = None, force: 'bool' = False, justid: 'bool' = False) -> 'XClaimResponse | Awaitable[XClaimResponse]'
 |      Changes the ownership of a pending message.
 |
 |      name: name of the stream.
 |
 |      groupname: name of the consumer group.
 |
 |      consumername: name of a consumer that claims the message.
 |
 |      min_idle_time: filter messages that were idle less than this amount of
 |      milliseconds
 |
 |      message_ids: non-empty list or tuple of message IDs to claim
 |
 |      idle: optional. Set the idle time (last time it was delivered) of the
 |      message in ms
 |
 |      time: optional integer. This is the same as idle but instead of a
 |      relative amount of milliseconds, it sets the idle time to a specific
 |      Unix time (in milliseconds).
 |
 |      retrycount: optional integer. set the retry counter to the specified
 |      value. This counter is incremented every time a message is delivered
 |      again.
 |
 |      force: optional boolean, false by default. Creates the pending message
 |      entry in the PEL even if certain specified IDs are not already in the
 |      PEL assigned to a different client.
 |
 |      justid: optional boolean, false by default. Return just an array of IDs
 |      of messages successfully claimed, without returning the actual message
 |
 |      For more information, see https://redis.io/commands/xclaim
 |
 |  xdel(self, name: 'KeyT', *ids: 'StreamIdT') -> 'int | Awaitable[int]'
 |      Deletes one or more messages from a stream.
 |
 |      Args:
 |          name: name of the stream.
 |          *ids: message ids to delete.
 |
 |      For more information, see https://redis.io/commands/xdel
 |
 |  xdelex(self, name: 'KeyT', *ids: 'StreamIdT', ref_policy: "Literal['KEEPREF', 'DELREF', 'ACKED']" = 'KEEPREF') -> 'int | Awaitable[int]'
 |      Extended version of XDEL that provides more control over how message entries
 |      are deleted concerning consumer groups.
 |
 |  xgroup_create(self, name: 'KeyT', groupname: 'GroupT', id: 'StreamIdT' = '$', mkstream: 'bool' = False, entries_read: 'int | None' = None) -> 'bool | Awaitable[bool]'
 |      Create a new consumer group associated with a stream.
 |      name: name of the stream.
 |      groupname: name of the consumer group.
 |      id: ID of the last item in the stream to consider already delivered.
 |
 |      For more information, see https://redis.io/commands/xgroup-create
 |
 |  xgroup_createconsumer(self, name: 'KeyT', groupname: 'GroupT', consumername: 'ConsumerT') -> 'int | Awaitable[int]'
 |      Consumers in a consumer group are auto-created every time a new
 |      consumer name is mentioned by some command.
 |      They can be explicitly created by using this command.
 |      name: name of the stream.
 |      groupname: name of the consumer group.
 |      consumername: name of consumer to create.
 |
 |      See: https://redis.io/commands/xgroup-createconsumer
 |
 |  xgroup_delconsumer(self, name: 'KeyT', groupname: 'GroupT', consumername: 'ConsumerT') -> 'int | Awaitable[int]'
 |      Remove a specific consumer from a consumer group.
 |      Returns the number of pending messages that the consumer had before it
 |      was deleted.
 |      name: name of the stream.
 |      groupname: name of the consumer group.
 |      consumername: name of consumer to delete
 |
 |      For more information, see https://redis.io/commands/xgroup-delconsumer
 |
 |  xgroup_destroy(self, name: 'KeyT', groupname: 'GroupT') -> 'bool | Awaitable[bool]'
 |      Destroy a consumer group.
 |      name: name of the stream.
 |      groupname: name of the consumer group.
 |
 |      For more information, see https://redis.io/commands/xgroup-destroy
 |
 |  xgroup_setid(self, name: 'KeyT', groupname: 'GroupT', id: 'StreamIdT', entries_read: 'int | None' = None) -> 'bool | Awaitable[bool]'
 |      Set the consumer group last delivered ID to something else.
 |      name: name of the stream.
 |      groupname: name of the consumer group.
 |      id: ID of the last item in the stream to consider already delivered.
 |
 |      For more information, see https://redis.io/commands/xgroup-setid
 |
 |  xinfo_consumers(self, name: 'KeyT', groupname: 'GroupT') -> 'list[dict[str, Any]] | Awaitable[list[dict[str, Any]]]'
 |      Returns general information about the consumers in the group.
 |      name: name of the stream.
 |      groupname: name of the consumer group.
 |
 |      For more information, see https://redis.io/commands/xinfo-consumers
 |
 |  xinfo_groups(self, name: 'KeyT') -> 'list[dict[str, Any]] | Awaitable[list[dict[str, Any]]]'
 |      Returns general information about the consumer groups of the stream.
 |      name: name of the stream.
 |
 |      For more information, see https://redis.io/commands/xinfo-groups
 |
 |  xinfo_stream(self, name: 'KeyT', full: 'bool' = False) -> 'dict[str, Any] | Awaitable[dict[str, Any]]'
 |      Returns general information about the stream.
 |      name: name of the stream.
 |      full: optional boolean, false by default. Return full summary
 |
 |      For more information, see https://redis.io/commands/xinfo-stream
 |
 |  xlen(self, name: 'KeyT') -> 'int | Awaitable[int]'
 |      Returns the number of elements in a given stream.
 |
 |      For more information, see https://redis.io/commands/xlen
 |
 |  xnack(self, name: 'KeyT', groupname: 'GroupT', mode: "Literal['SILENT', 'FAIL', 'FATAL']", *ids: 'StreamIdT', retrycount: 'int | None' = None, force: 'bool' = False) -> 'int | Awaitable[int]'
 |      Negatively acknowledges one or more messages in a consumer group's
 |      Pending Entries List (PEL).
 |
 |      Args:
 |          name: name of the stream.
 |          groupname: name of the consumer group.
 |          mode: the nacking mode. One of SILENT, FAIL, or FATAL.
 |              SILENT: consumer shutting down; decrements delivery counter.
 |              FAIL: consumer unable to process; delivery counter unchanged.
 |              FATAL: invalid/malicious message; delivery counter set to max.
 |          *ids: one or more message IDs to NACK.
 |          retrycount: optional integer >= 0. Overrides the mode's implicit
 |              delivery counter adjustment with an exact value.
 |          force: if True, creates a new unowned PEL entry for any ID not
 |              already in the group's PEL.
 |
 |      Returns:
 |          The number of messages successfully NACKed.
 |
 |      For more information, see https://redis.io/commands/xnack
 |
 |  xpending(self, name: 'KeyT', groupname: 'GroupT') -> 'dict[str, Any] | Awaitable[dict[str, Any]]'
 |      Returns information about pending messages of a group.
 |      name: name of the stream.
 |      groupname: name of the consumer group.
 |
 |      For more information, see https://redis.io/commands/xpending
 |
 |  xpending_range(self, name: 'KeyT', groupname: 'GroupT', min: 'StreamIdT', max: 'StreamIdT', count: 'int', consumername: 'ConsumerT | None' = None, idle: 'int | None' = None) -> 'XPendingRangeResponse | Awaitable[XPendingRangeResponse]'
 |      Returns information about pending messages, in a range.
 |
 |      name: name of the stream.
 |      groupname: name of the consumer group.
 |      idle: available from  version 6.2. filter entries by their
 |      idle-time, given in milliseconds (optional).
 |      min: minimum stream ID.
 |      max: maximum stream ID.
 |      count: number of messages to return
 |      consumername: name of a consumer to filter by (optional).
 |
 |  xrange(self, name: 'KeyT', min: 'StreamIdT' = '-', max: 'StreamIdT' = '+', count: 'int | None' = None) -> 'StreamRangeResponse | None | Awaitable[StreamRangeResponse | None]'
 |      Read stream values within an interval.
 |
 |      name: name of the stream.
 |
 |      start: first stream ID. defaults to '-',
 |             meaning the earliest available.
 |
 |      finish: last stream ID. defaults to '+',
 |              meaning the latest available.
 |
 |      count: if set, only return this many items, beginning with the
 |             earliest available.
 |
 |      For more information, see https://redis.io/commands/xrange
 |
 |  xread(self, streams: 'Dict[KeyT, StreamIdT]', count: 'int | None' = None, block: 'int | None' = None, max_count: 'int | None' = None, max_size: 'int | None' = None) -> 'XReadResponse | Awaitable[XReadResponse]'
 |      Block and monitor multiple streams for new data.
 |
 |      streams: a dict of stream names to stream IDs, where
 |                 IDs indicate the last ID already seen.
 |
 |      count: if set, only return this many items per stream, beginning with
 |             the earliest available.
 |
 |      block: number of milliseconds to wait, if nothing already present.
 |
 |      max_count: if set, cap the total number of entries returned across all
 |                 streams combined. Unlike ``count`` (a per-stream limit),
 |                 this is a cumulative cap over the whole reply. Must be a
 |                 positive integer and, when ``count`` is also set, must be
 |                 greater than or equal to ``count``. Requires Redis >= 8.10.0.
 |
 |      max_size: if set, a soft cap on the total server reply size in bytes
 |                across all streams combined. Measured server-side including
 |                protocol overhead, so it is not an exact application-payload
 |                size guarantee; a single available entry larger than the cap
 |                may still be returned. Must be a positive integer. Requires
 |                Redis >= 8.10.0.
 |
 |      For more information, see https://redis.io/commands/xread
 |
 |  xreadgroup(self, groupname: 'str', consumername: 'str', streams: 'Dict[KeyT, StreamIdT]', count: 'int | None' = None, block: 'int | None' = None, noack: 'bool' = False, claim_min_idle_time: 'int | None' = None, max_count: 'int | None' = None, max_size: 'int | None' = None) -> 'XReadGroupResponse | Awaitable[XReadGroupResponse]'
 |      Read from a stream via a consumer group.
 |
 |      groupname: name of the consumer group.
 |
 |      consumername: name of the requesting consumer.
 |
 |      streams: a dict of stream names to stream IDs, where
 |             IDs indicate the last ID already seen.
 |
 |      count: if set, only return this many items per stream, beginning with
 |             the earliest available.
 |
 |      block: number of milliseconds to wait, if nothing already present.
 |      noack: do not add messages to the PEL
 |
 |      claim_min_idle_time: accepts an integer type and represents a
 |                           time interval in milliseconds
 |
 |      max_count: if set, cap the total number of entries returned across all
 |                 streams combined. Unlike ``count`` (a per-stream limit),
 |                 this is a cumulative cap over the whole reply. Must be a
 |                 positive integer and, when ``count`` is also set, must be
 |                 greater than or equal to ``count``. Requires Redis 8.10.0.
 |
 |      max_size: if set, a soft cap on the total server reply size in bytes
 |                across all streams combined. Measured server-side including
 |                protocol overhead, so it is not an exact application-payload
 |                size guarantee; a single available entry larger than the cap
 |                may still be returned. Must be a positive integer. Requires
 |                Redis 8.10.0.
 |
 |      For more information, see https://redis.io/commands/xreadgroup
 |
 |  xrevrange(self, name: 'KeyT', max: 'StreamIdT' = '+', min: 'StreamIdT' = '-', count: 'int | None' = None) -> 'StreamRangeResponse | None | Awaitable[StreamRangeResponse | None]'
 |      Read stream values within an interval, in reverse order.
 |
 |      name: name of the stream
 |
 |      start: first stream ID. defaults to '+',
 |             meaning the latest available.
 |
 |      finish: last stream ID. defaults to '-',
 |              meaning the earliest available.
 |
 |      count: if set, only return this many items, beginning with the
 |             latest available.
 |
 |      For more information, see https://redis.io/commands/xrevrange
 |
 |  xtrim(self, name: 'KeyT', maxlen: 'int | None' = None, approximate: 'bool' = True, minid: 'StreamIdT | None' = None, limit: 'int | None' = None, ref_policy: "Literal['KEEPREF', 'DELREF', 'ACKED'] | None" = None) -> 'int | Awaitable[int]'
 |      Trims old messages from a stream.
 |      name: name of the stream.
 |      maxlen: truncate old stream messages beyond this size
 |      Can't be specified with minid.
 |      approximate: actual stream length may be slightly more than maxlen
 |      minid: the minimum id in the stream to query
 |      Can't be specified with maxlen.
 |      limit: specifies the maximum number of entries to retrieve
 |      ref_policy: optional reference policy for consumer groups:
 |          - KEEPREF (default): Trims entries but preserves references in consumer groups' PEL
 |          - DELREF: Trims entries and removes all references from consumer groups' PEL
 |          - ACKED: Only trims entries that were read and acknowledged by all consumer groups
 |
 |      For more information, see https://redis.io/commands/xtrim
 |
 |  ----------------------------------------------------------------------
 |  Methods inherited from redis.commands.core.SortedSetCommands:
 |
 |  bzmpop(self, timeout: 'float', numkeys: 'int', keys: 'List[str]', min: 'bool | None' = False, max: 'bool | None' = False, count: 'int | None' = 1) -> 'ZMPopResponse | Awaitable[ZMPopResponse]'
 |      Pop ``count`` values (default 1) off of the first non-empty sorted set
 |      named in the ``keys`` list.
 |
 |      If none of the sorted sets in ``keys`` has a value to pop,
 |      then block for ``timeout`` seconds, or until a member gets added
 |      to one of the sorted sets.
 |
 |      If timeout is 0, then block indefinitely.
 |
 |      For more information, see https://redis.io/commands/bzmpop
 |
 |  bzpopmax(self, keys: 'KeysT', timeout: 'TimeoutSecT' = 0) -> 'BlockingZSetPopResponse | Awaitable[BlockingZSetPopResponse]'
 |      ZPOPMAX a value off of the first non-empty sorted set
 |      named in the ``keys`` list.
 |
 |      If none of the sorted sets in ``keys`` has a value to ZPOPMAX,
 |      then block for ``timeout`` seconds, or until a member gets added
 |      to one of the sorted sets.
 |
 |      If timeout is 0, then block indefinitely.
 |
 |      For more information, see https://redis.io/commands/bzpopmax
 |
 |  bzpopmin(self, keys: 'KeysT', timeout: 'TimeoutSecT' = 0) -> 'BlockingZSetPopResponse | Awaitable[BlockingZSetPopResponse]'
 |      ZPOPMIN a value off of the first non-empty sorted set
 |      named in the ``keys`` list.
 |
 |      If none of the sorted sets in ``keys`` has a value to ZPOPMIN,
 |      then block for ``timeout`` seconds, or until a member gets added
 |      to one of the sorted sets.
 |
 |      If timeout is 0, then block indefinitely.
 |
 |      For more information, see https://redis.io/commands/bzpopmin
 |
 |  zadd(self, name: 'KeyT', mapping: 'Mapping[AnyKeyT, EncodableT]', nx: 'bool' = False, xx: 'bool' = False, ch: 'bool' = False, incr: 'bool' = False, gt: 'bool' = False, lt: 'bool' = False) -> 'int | float | None | Awaitable[int | float | None]'
 |      Set any number of element-name, score pairs to the key ``name``. Pairs
 |      are specified as a dict of element-names keys to score values.
 |
 |      ``nx`` forces ZADD to only create new elements and not to update
 |      scores for elements that already exist.
 |
 |      ``xx`` forces ZADD to only update scores of elements that already
 |      exist. New elements will not be added.
 |
 |      ``ch`` modifies the return value to be the numbers of elements changed.
 |      Changed elements include new elements that were added and elements
 |      whose scores changed.
 |
 |      ``incr`` modifies ZADD to behave like ZINCRBY. In this mode only a
 |      single element/score pair can be specified and the score is the amount
 |      the existing score will be incremented by. When using this mode the
 |      return value of ZADD will be the new score of the element.
 |
 |      ``lt`` only updates existing elements if the new score is less than
 |      the current score. This flag doesn't prevent adding new elements.
 |
 |      ``gt`` only updates existing elements if the new score is greater than
 |      the current score. This flag doesn't prevent adding new elements.
 |
 |      The return value of ZADD varies based on the mode specified. With no
 |      options, ZADD returns the number of new elements added to the sorted
 |      set.
 |
 |      ``nx``, ``lt``, and ``gt`` are mutually exclusive options.
 |
 |      See: https://redis.io/commands/ZADD
 |
 |  zcard(self, name: 'KeyT') -> 'int | Awaitable[int]'
 |      Return the number of elements in the sorted set ``name``
 |
 |      For more information, see https://redis.io/commands/zcard
 |
 |  zcount(self, name: 'KeyT', min: 'ZScoreBoundT', max: 'ZScoreBoundT') -> 'int | Awaitable[int]'
 |      Returns the number of elements in the sorted set at key ``name`` with
 |      a score between ``min`` and ``max``.
 |
 |      For more information, see https://redis.io/commands/zcount
 |
 |  zdiff(self, keys: 'KeysT', withscores: 'bool' = False) -> 'ZSetRangeResponse | Awaitable[ZSetRangeResponse]'
 |      Returns the difference between the first and all successive input
 |      sorted sets provided in ``keys``.
 |
 |      For more information, see https://redis.io/commands/zdiff
 |
 |  zdiffstore(self, dest: 'KeyT', keys: 'KeysT') -> 'int | Awaitable[int]'
 |      Computes the difference between the first and all successive input
 |      sorted sets provided in ``keys`` and stores the result in ``dest``.
 |
 |      For more information, see https://redis.io/commands/zdiffstore
 |
 |  zincrby(self, name: 'KeyT', amount: 'float', value: 'EncodableT') -> 'float | None | Awaitable[float | None]'
 |      Increment the score of ``value`` in sorted set ``name`` by ``amount``
 |
 |      For more information, see https://redis.io/commands/zincrby
 |
 |  zinter(self, keys: 'KeysT', aggregate: 'str | None' = None, withscores: 'bool' = False) -> 'ZSetRangeResponse | Awaitable[ZSetRangeResponse]'
 |      Return the intersect of multiple sorted sets specified by ``keys``.
 |
 |      With the ``aggregate`` option, it is possible to specify how the
 |      results of the intersection are aggregated. Available aggregation
 |      modes:
 |
 |      - ``SUM`` (default): the score of an element is summed across the
 |        inputs where it exists.
 |        Score = SUM(score₁×weight₁, score₂×weight₂, ...)
 |      - ``MIN``: the resulting set will contain the minimum score of an
 |        element across the inputs where it exists.
 |        Score = MIN(score₁×weight₁, score₂×weight₂, ...)
 |      - ``MAX``: the resulting set will contain the maximum score of an
 |        element across the inputs where it exists.
 |        Score = MAX(score₁×weight₁, score₂×weight₂, ...)
 |      - ``COUNT``: ignores the original scores and counts weighted set
 |        membership. Each element's score is the sum of the weights of
 |        the input sets that contain it.
 |        Score = SUM(weight₁, weight₂, ...) for sets containing the element.
 |        When all weights are 1 (default), the score equals the number
 |        of input sets containing the element.
 |
 |      For more information, see https://redis.io/commands/zinter
 |
 |  zintercard(self, numkeys: 'int', keys: 'List[str]', limit: 'int' = 0) -> 'int | Awaitable[int]'
 |      Return the cardinality of the intersect of multiple sorted sets
 |      specified by ``keys``.
 |      When LIMIT provided (defaults to 0 and means unlimited), if the intersection
 |      cardinality reaches limit partway through the computation, the algorithm will
 |      exit and yield limit as the cardinality
 |
 |      For more information, see https://redis.io/commands/zintercard
 |
 |  zinterstore(self, dest: 'KeyT', keys: 'Sequence[KeyT] | Mapping[AnyKeyT, float]', aggregate: 'str | None' = None) -> 'int | Awaitable[int]'
 |      Intersect multiple sorted sets specified by ``keys`` into a new
 |      sorted set, ``dest``. Scores in the destination will be aggregated
 |      based on the ``aggregate``.
 |
 |      Available aggregation modes:
 |
 |      - ``SUM`` (default): the score of an element is summed across the
 |        inputs where it exists.
 |        Score = SUM(score₁×weight₁, score₂×weight₂, ...)
 |      - ``MIN``: the resulting set will contain the minimum score of an
 |        element across the inputs where it exists.
 |        Score = MIN(score₁×weight₁, score₂×weight₂, ...)
 |      - ``MAX``: the resulting set will contain the maximum score of an
 |        element across the inputs where it exists.
 |        Score = MAX(score₁×weight₁, score₂×weight₂, ...)
 |      - ``COUNT``: ignores the original scores and counts weighted set
 |        membership. Each element's score is the sum of the weights of
 |        the input sets that contain it.
 |        Score = SUM(weight₁, weight₂, ...) for sets containing the element.
 |        When all weights are 1 (default), the score equals the number
 |        of input sets containing the element.
 |
 |      For more information, see https://redis.io/commands/zinterstore
 |
 |  zlexcount(self, name: 'KeyT', min: 'EncodableT', max: 'EncodableT') -> 'int | Awaitable[int]'
 |      Return the number of items in the sorted set ``name`` between the
 |      lexicographical range ``min`` and ``max``.
 |
 |      For more information, see https://redis.io/commands/zlexcount
 |
 |  zmpop(self, num_keys: 'int', keys: 'List[str]', min: 'bool | None' = False, max: 'bool | None' = False, count: 'int | None' = 1) -> 'ZMPopResponse | Awaitable[ZMPopResponse]'
 |      Pop ``count`` values (default 1) off of the first non-empty sorted set
 |      named in the ``keys`` list.
 |      For more information, see https://redis.io/commands/zmpop
 |
 |  zmscore(self, key: 'KeyT', members: 'List[str]') -> 'list[float | None] | Awaitable[list[float | None]]'
 |      Returns the scores associated with the specified members
 |      in the sorted set stored at key.
 |      ``members`` should be a list of the member name.
 |      Return type is a list of score.
 |      If the member does not exist, a None will be returned
 |      in corresponding position.
 |
 |      For more information, see https://redis.io/commands/zmscore
 |
 |  zpopmax(self, name: 'KeyT', count: 'int | None' = None) -> 'ZSetRangeResponse | Awaitable[ZSetRangeResponse]'
 |      Remove and return up to ``count`` members with the highest scores
 |      from the sorted set ``name``.
 |
 |      For more information, see https://redis.io/commands/zpopmax
 |
 |  zpopmin(self, name: 'KeyT', count: 'int | None' = None) -> 'ZSetRangeResponse | Awaitable[ZSetRangeResponse]'
 |      Remove and return up to ``count`` members with the lowest scores
 |      from the sorted set ``name``.
 |
 |      For more information, see https://redis.io/commands/zpopmin
 |
 |  zrandmember(self, key: 'KeyT', count: 'int | None' = None, withscores: 'bool' = False) -> 'ZRandMemberResponse | Awaitable[ZRandMemberResponse]'
 |      Return a random element from the sorted set value stored at key.
 |
 |      ``count`` if the argument is positive, return an array of distinct
 |      fields. If called with a negative count, the behavior changes and
 |      the command is allowed to return the same field multiple times.
 |      In this case, the number of returned fields is the absolute value
 |      of the specified count.
 |
 |      ``withscores`` The optional WITHSCORES modifier changes the reply so it
 |      includes the respective scores of the randomly selected elements from
 |      the sorted set.
 |
 |      For more information, see https://redis.io/commands/zrandmember
 |
 |  zrange(self, name: 'KeyT', start: 'EncodableT', end: 'EncodableT', desc: 'bool' = False, withscores: 'bool' = False, score_cast_func: 'type | Callable' = <class 'float'>, byscore: 'bool' = False, bylex: 'bool' = False, offset: 'int | None' = None, num: 'int | None' = None) -> 'ZSetRangeResponse | Awaitable[ZSetRangeResponse]'
 |      Return a range of values from sorted set ``name`` between
 |      ``start`` and ``end`` sorted in ascending order.
 |
 |      ``start`` and ``end`` can be negative, indicating the end of the range.
 |
 |      ``desc`` a boolean indicating whether to sort the results in reversed
 |      order.
 |
 |      ``withscores`` indicates to return the scores along with the values.
 |      The return type is a list of (value, score) pairs.
 |
 |      ``score_cast_func`` a callable used to cast the score return value.
 |
 |      ``byscore`` when set to True, returns the range of elements from the
 |      sorted set having scores equal or between ``start`` and ``end``.
 |
 |      ``bylex`` when set to True, returns the range of elements from the
 |      sorted set between the ``start`` and ``end`` lexicographical closed
 |      range intervals.
 |      Valid ``start`` and ``end`` must start with ( or [, in order to specify
 |      whether the range interval is exclusive or inclusive, respectively.
 |
 |      ``offset`` and ``num`` are specified, then return a slice of the range.
 |      Can't be provided when using ``bylex``.
 |
 |      For more information, see https://redis.io/commands/zrange
 |
 |  zrangebylex(self, name: 'KeyT', min: 'EncodableT', max: 'EncodableT', start: 'int | None' = None, num: 'int | None' = None) -> 'list[bytes | str] | Awaitable[list[bytes | str]]'
 |      Return the lexicographical range of values from sorted set ``name``
 |      between ``min`` and ``max``.
 |
 |      If ``start`` and ``num`` are specified, then return a slice of the
 |      range.
 |
 |      For more information, see https://redis.io/commands/zrangebylex
 |
 |  zrangebyscore(self, name: 'KeyT', min: 'ZScoreBoundT', max: 'ZScoreBoundT', start: 'int | None' = None, num: 'int | None' = None, withscores: 'bool' = False, score_cast_func: 'type | Callable' = <class 'float'>) -> 'ZSetRangeResponse | Awaitable[ZSetRangeResponse]'
 |      Return a range of values from the sorted set ``name`` with scores
 |      between ``min`` and ``max``.
 |
 |      If ``start`` and ``num`` are specified, then return a slice
 |      of the range.
 |
 |      ``withscores`` indicates to return the scores along with the values.
 |      The return type is a list of (value, score) pairs
 |
 |      `score_cast_func`` a callable used to cast the score return value
 |
 |      For more information, see https://redis.io/commands/zrangebyscore
 |
 |  zrangestore(self, dest: 'KeyT', name: 'KeyT', start: 'EncodableT', end: 'EncodableT', byscore: 'bool' = False, bylex: 'bool' = False, desc: 'bool' = False, offset: 'int | None' = None, num: 'int | None' = None) -> 'int | Awaitable[int]'
 |      Stores in ``dest`` the result of a range of values from sorted set
 |      ``name`` between ``start`` and ``end`` sorted in ascending order.
 |
 |      ``start`` and ``end`` can be negative, indicating the end of the range.
 |
 |      ``byscore`` when set to True, returns the range of elements from the
 |      sorted set having scores equal or between ``start`` and ``end``.
 |
 |      ``bylex`` when set to True, returns the range of elements from the
 |      sorted set between the ``start`` and ``end`` lexicographical closed
 |      range intervals.
 |      Valid ``start`` and ``end`` must start with ( or [, in order to specify
 |      whether the range interval is exclusive or inclusive, respectively.
 |
 |      ``desc`` a boolean indicating whether to sort the results in reversed
 |      order.
 |
 |      ``offset`` and ``num`` are specified, then return a slice of the range.
 |      Can't be provided when using ``bylex``.
 |
 |      For more information, see https://redis.io/commands/zrangestore
 |
 |  zrank(self, name: 'KeyT', value: 'EncodableT', withscore: 'bool' = False, score_cast_func: 'type | Callable' = <class 'float'>) -> 'int | list[Any] | None | Awaitable[int | list[Any] | None]'
 |      Returns a 0-based value indicating the rank of ``value`` in sorted set
 |      ``name``.
 |      The optional WITHSCORE argument supplements the command's
 |      reply with the score of the element returned.
 |
 |      ``score_cast_func`` a callable used to cast the score return value
 |
 |      For more information, see https://redis.io/commands/zrank
 |
 |  zrem(self, name: 'KeyT', *values: 'FieldT') -> 'int | Awaitable[int]'
 |      Remove member ``values`` from sorted set ``name``
 |
 |      For more information, see https://redis.io/commands/zrem
 |
 |  zremrangebylex(self, name: 'KeyT', min: 'EncodableT', max: 'EncodableT') -> 'int | Awaitable[int]'
 |      Remove all elements in the sorted set ``name`` between the
 |      lexicographical range specified by ``min`` and ``max``.
 |
 |      Returns the number of elements removed.
 |
 |      For more information, see https://redis.io/commands/zremrangebylex
 |
 |  zremrangebyrank(self, name: 'KeyT', min: 'int', max: 'int') -> 'int | Awaitable[int]'
 |      Remove all elements in the sorted set ``name`` with ranks between
 |      ``min`` and ``max``. Values are 0-based, ordered from smallest score
 |      to largest. Values can be negative indicating the highest scores.
 |      Returns the number of elements removed
 |
 |      For more information, see https://redis.io/commands/zremrangebyrank
 |
 |  zremrangebyscore(self, name: 'KeyT', min: 'ZScoreBoundT', max: 'ZScoreBoundT') -> 'int | Awaitable[int]'
 |      Remove all elements in the sorted set ``name`` with scores
 |      between ``min`` and ``max``. Returns the number of elements removed.
 |
 |      For more information, see https://redis.io/commands/zremrangebyscore
 |
 |  zrevrange(self, name: 'KeyT', start: 'int', end: 'int', withscores: 'bool' = False, score_cast_func: 'type | Callable' = <class 'float'>) -> 'ZSetRangeResponse | Awaitable[ZSetRangeResponse]'
 |      Return a range of values from sorted set ``name`` between
 |      ``start`` and ``end`` sorted in descending order.
 |
 |      ``start`` and ``end`` can be negative, indicating the end of the range.
 |
 |      ``withscores`` indicates to return the scores along with the values
 |      The return type is a list of (value, score) pairs
 |
 |      ``score_cast_func`` a callable used to cast the score return value
 |
 |      For more information, see https://redis.io/commands/zrevrange
 |
 |  zrevrangebylex(self, name: 'KeyT', max: 'EncodableT', min: 'EncodableT', start: 'int | None' = None, num: 'int | None' = None) -> 'list[bytes | str] | Awaitable[list[bytes | str]]'
 |      Return the reversed lexicographical range of values from sorted set
 |      ``name`` between ``max`` and ``min``.
 |
 |      If ``start`` and ``num`` are specified, then return a slice of the
 |      range.
 |
 |      For more information, see https://redis.io/commands/zrevrangebylex
 |
 |  zrevrangebyscore(self, name: 'KeyT', max: 'ZScoreBoundT', min: 'ZScoreBoundT', start: 'int | None' = None, num: 'int | None' = None, withscores: 'bool' = False, score_cast_func: 'type | Callable' = <class 'float'>) -> 'ZSetRangeResponse | Awaitable[ZSetRangeResponse]'
 |      Return a range of values from the sorted set ``name`` with scores
 |      between ``min`` and ``max`` in descending order.
 |
 |      If ``start`` and ``num`` are specified, then return a slice
 |      of the range.
 |
 |      ``withscores`` indicates to return the scores along with the values.
 |      The return type is a list of (value, score) pairs
 |
 |      ``score_cast_func`` a callable used to cast the score return value
 |
 |      For more information, see https://redis.io/commands/zrevrangebyscore
 |
 |  zrevrank(self, name: 'KeyT', value: 'EncodableT', withscore: 'bool' = False, score_cast_func: 'type | Callable' = <class 'float'>) -> 'int | list[Any] | None | Awaitable[int | list[Any] | None]'
 |      Returns a 0-based value indicating the descending rank of
 |      ``value`` in sorted set ``name``.
 |      The optional ``withscore`` argument supplements the command's
 |      reply with the score of the element returned.
 |
 |      ``score_cast_func`` a callable used to cast the score return value
 |
 |      For more information, see https://redis.io/commands/zrevrank
 |
 |  zscore(self, name: 'KeyT', value: 'EncodableT') -> 'float | None | Awaitable[float | None]'
 |      Return the score of element ``value`` in sorted set ``name``
 |
 |      For more information, see https://redis.io/commands/zscore
 |
 |  zunion(self, keys: 'Sequence[KeyT] | Mapping[AnyKeyT, float]', aggregate: 'str | None' = None, withscores: 'bool' = False, score_cast_func: 'type | Callable' = <class 'float'>) -> 'ZSetRangeResponse | Awaitable[ZSetRangeResponse]'
 |      Return the union of multiple sorted sets specified by ``keys``.
 |      ``keys`` can be provided as dictionary of keys and their weights.
 |      Scores will be aggregated based on the ``aggregate``, or SUM if
 |      none is provided.
 |
 |      Available aggregation modes:
 |
 |      - ``SUM`` (default): the score of an element is summed across the
 |        inputs where it exists.
 |        Score = SUM(score₁×weight₁, score₂×weight₂, ...)
 |      - ``MIN``: the resulting set will contain the minimum score of an
 |        element across the inputs where it exists.
 |        Score = MIN(score₁×weight₁, score₂×weight₂, ...)
 |      - ``MAX``: the resulting set will contain the maximum score of an
 |        element across the inputs where it exists.
 |        Score = MAX(score₁×weight₁, score₂×weight₂, ...)
 |      - ``COUNT``: ignores the original scores and counts weighted set
 |        membership. Each element's score is the sum of the weights of
 |        the input sets that contain it.
 |        Score = SUM(weight₁, weight₂, ...) for sets containing the element.
 |        When all weights are 1 (default), the score equals the number
 |        of input sets containing the element.
 |
 |      ``score_cast_func`` a callable used to cast the score return value
 |
 |      For more information, see https://redis.io/commands/zunion
 |
 |  zunionstore(self, dest: 'KeyT', keys: 'Sequence[KeyT] | Mapping[AnyKeyT, float]', aggregate: 'str | None' = None) -> 'int | Awaitable[int]'
 |      Union multiple sorted sets specified by ``keys`` into
 |      a new sorted set, ``dest``. Scores in the destination will be
 |      aggregated based on the ``aggregate``, or SUM if none is provided.
 |
 |      Available aggregation modes:
 |
 |      - ``SUM`` (default): the score of an element is summed across the
 |        inputs where it exists.
 |        Score = SUM(score₁×weight₁, score₂×weight₂, ...)
 |      - ``MIN``: the resulting set will contain the minimum score of an
 |        element across the inputs where it exists.
 |        Score = MIN(score₁×weight₁, score₂×weight₂, ...)
 |      - ``MAX``: the resulting set will contain the maximum score of an
 |        element across the inputs where it exists.
 |        Score = MAX(score₁×weight₁, score₂×weight₂, ...)
 |      - ``COUNT``: ignores the original scores and counts weighted set
 |        membership. Each element's score is the sum of the weights of
 |        the input sets that contain it.
 |        Score = SUM(weight₁, weight₂, ...) for sets containing the element.
 |        When all weights are 1 (default), the score equals the number
 |        of input sets containing the element.
 |
 |      For more information, see https://redis.io/commands/zunionstore
 |
 |  ----------------------------------------------------------------------
 |  Methods inherited from redis.commands.core.ManagementCommands:
 |
 |  auth(self, password: 'str', username: 'str | None' = None, **kwargs) -> 'bool | Awaitable[bool]'
 |      Authenticates the user. If you do not pass username, Redis will try to
 |      authenticate for the "default" user. If you do pass username, it will
 |      authenticate for the given user.
 |      For more information, see https://redis.io/commands/auth
 |
 |  bgrewriteaof(self, **kwargs) -> 'bool | bytes | str | Awaitable[bool | bytes | str]'
 |      Tell the Redis server to rewrite the AOF file from data in memory.
 |
 |      For more information, see https://redis.io/commands/bgrewriteaof
 |
 |  bgsave(self, schedule: 'bool' = True, **kwargs) -> 'bool | bytes | str | Awaitable[bool | bytes | str]'
 |      Tell the Redis server to save its data to disk.  Unlike save(),
 |      this method is asynchronous and returns immediately.
 |
 |      For more information, see https://redis.io/commands/bgsave
 |
 |  client_getname(self, **kwargs) -> 'bytes | str | None | Awaitable[bytes | str | None]'
 |      Returns the current connection name
 |
 |      For more information, see https://redis.io/commands/client-getname
 |
 |  client_getredir(self, **kwargs) -> 'int | Awaitable[int]'
 |      Returns the ID (an integer) of the client to whom we are
 |      redirecting tracking notifications.
 |
 |      see: https://redis.io/commands/client-getredir
 |
 |  client_id(self, **kwargs) -> 'int | Awaitable[int]'
 |      Returns the current connection id
 |
 |      For more information, see https://redis.io/commands/client-id
 |
 |  client_info(self, **kwargs) -> 'dict[str, str | int] | Awaitable[dict[str, str | int]]'
 |      Returns information and statistics about the current
 |      client connection.
 |
 |      For more information, see https://redis.io/commands/client-info
 |
 |  client_kill(self, address: 'str', **kwargs) -> 'bool | int | Awaitable[bool | int]'
 |      Disconnects the client at ``address`` (ip:port)
 |
 |      For more information, see https://redis.io/commands/client-kill
 |
 |  client_kill_filter(self, _id: 'str | None' = None, _type: 'str | None' = None, addr: 'str | None' = None, skipme: 'bool | None' = None, laddr: 'bool | None' = None, user: 'str | None' = None, maxage: 'int | None' = None, **kwargs) -> 'int | Awaitable[int]'
 |      Disconnects client(s) using a variety of filter options
 |      :param _id: Kills a client by its unique ID field
 |      :param _type: Kills a client by type where type is one of 'normal',
 |      'master', 'slave', 'replica' or 'pubsub'
 |      :param addr: Kills a client by its 'address:port'
 |      :param skipme: If True, then the client calling the command
 |      will not get killed even if it is identified by one of the filter
 |      options. If skipme is not provided, the server defaults to skipme=True
 |      :param laddr: Kills a client by its 'local (bind) address:port'
 |      :param user: Kills a client for a specific user name
 |      :param maxage: Kills clients that are older than the specified age in seconds
 |
 |  client_list(self, _type: 'str | None' = None, client_id: 'List[EncodableT]' = [], **kwargs) -> 'list[dict[str, str]] | Awaitable[list[dict[str, str]]]'
 |      Returns a list of currently connected clients.
 |      If type of client specified, only that type will be returned.
 |
 |      :param _type: optional. one of the client types (normal, master,
 |       replica, pubsub)
 |      :param client_id: optional. a list of client ids
 |
 |      For more information, see https://redis.io/commands/client-list
 |
 |  client_no_evict(self, mode: 'str') -> 'bytes | str | Awaitable[bytes | str]'
 |      Sets the client eviction mode for the current connection.
 |
 |      For more information, see https://redis.io/commands/client-no-evict
 |
 |  client_no_touch(self, mode: 'str') -> 'bytes | str | Awaitable[bytes | str]'
 |      # The command controls whether commands sent by the client will alter
 |      # the LRU/LFU of the keys they access.
 |      # When turned on, the current client will not change LFU/LRU stats,
 |      # unless it sends the TOUCH command.
 |
 |      For more information, see https://redis.io/commands/client-no-touch
 |
 |  client_pause(self, timeout: 'int', all: 'bool' = True, **kwargs) -> 'bool | Awaitable[bool]'
 |      Suspend all the Redis clients for the specified amount of time.
 |
 |
 |      For more information, see https://redis.io/commands/client-pause
 |
 |      Args:
 |          timeout: milliseconds to pause clients
 |          all: If true (default) all client commands are blocked.
 |               otherwise, clients are only blocked if they attempt to execute
 |               a write command.
 |
 |      For the WRITE mode, some commands have special behavior:
 |
 |      * EVAL/EVALSHA: Will block client for all scripts.
 |      * PUBLISH: Will block client.
 |      * PFCOUNT: Will block client.
 |      * WAIT: Acknowledgments will be delayed, so this command will
 |          appear blocked.
 |
 |  client_reply(self, reply: "Literal['ON', 'OFF', 'SKIP']", **kwargs) -> 'bytes | str | Awaitable[bytes | str]'
 |      Enable and disable redis server replies.
 |
 |      ``reply`` Must be ON OFF or SKIP,
 |      ON - The default most with server replies to commands
 |      OFF - Disable server responses to commands
 |      SKIP - Skip the response of the immediately following command.
 |
 |      Note: When setting OFF or SKIP replies, you will need a client object
 |      with a timeout specified in seconds, and will need to catch the
 |      TimeoutError.
 |      The test_client_reply unit test illustrates this, and
 |      conftest.py has a client with a timeout.
 |
 |      See https://redis.io/commands/client-reply
 |
 |  client_setinfo(self, attr: 'str', value: 'str', **kwargs) -> 'bool | Awaitable[bool]'
 |      Sets the current connection library name or version
 |      For more information see https://redis.io/commands/client-setinfo
 |
 |  client_setname(self, name: 'str', **kwargs) -> 'bool | Awaitable[bool]'
 |      Sets the current connection name
 |
 |      For more information, see https://redis.io/commands/client-setname
 |
 |      .. note::
 |         This method sets client name only for **current** connection.
 |
 |         If you want to set a common name for all connections managed
 |         by this client, use ``client_name`` constructor argument.
 |
 |  client_tracking(self, on: 'bool' = True, clientid: 'int | None' = None, prefix: 'Sequence[KeyT]' = [], bcast: 'bool' = False, optin: 'bool' = False, optout: 'bool' = False, noloop: 'bool' = False, **kwargs) -> 'bytes | str | Awaitable[bytes | str]'
 |      Enables the tracking feature of the Redis server, that is used
 |      for server assisted client side caching.
 |
 |      ``on`` indicate for tracking on or tracking off. The default is on.
 |
 |      ``clientid`` send invalidation messages to the connection with
 |      the specified ID.
 |
 |      ``bcast`` enable tracking in broadcasting mode. In this mode
 |      invalidation messages are reported for all the prefixes
 |      specified, regardless of the keys requested by the connection.
 |
 |      ``optin``  when broadcasting is NOT active, normally don't track
 |      keys in read only commands, unless they are called immediately
 |      after a CLIENT CACHING yes command.
 |
 |      ``optout`` when broadcasting is NOT active, normally track keys in
 |      read only commands, unless they are called immediately after a
 |      CLIENT CACHING no command.
 |
 |      ``noloop`` don't send notifications about keys modified by this
 |      connection itself.
 |
 |      ``prefix``  for broadcasting, register a given key prefix, so that
 |      notifications will be provided only for keys starting with this string.
 |
 |      See https://redis.io/commands/client-tracking
 |
 |  client_tracking_off(self, clientid: 'int | None' = None, prefix: 'Sequence[KeyT]' = [], bcast: 'bool' = False, optin: 'bool' = False, optout: 'bool' = False, noloop: 'bool' = False) -> 'bytes | str | Awaitable[bytes | str]'
 |      Turn off the tracking mode.
 |      For more information, about the options look at client_tracking func.
 |
 |      See https://redis.io/commands/client-tracking
 |
 |  client_tracking_on(self, clientid: 'int | None' = None, prefix: 'Sequence[KeyT]' = [], bcast: 'bool' = False, optin: 'bool' = False, optout: 'bool' = False, noloop: 'bool' = False) -> 'bytes | str | Awaitable[bytes | str]'
 |      Turn on the tracking mode.
 |      For more information, about the options look at client_tracking func.
 |
 |      See https://redis.io/commands/client-tracking
 |
 |  client_trackinginfo(self, **kwargs) -> 'ClientTrackingInfoResponse | Awaitable[ClientTrackingInfoResponse]'
 |      Returns the information about the current client connection's
 |      use of the server assisted client side cache.
 |
 |      See https://redis.io/commands/client-trackinginfo
 |
 |  client_unblock(self, client_id: 'int', error: 'bool' = False, **kwargs) -> 'bool | Awaitable[bool]'
 |      Unblocks a connection by its client id.
 |      If ``error`` is True, unblocks the client with a special error message.
 |      If ``error`` is False (default), the client is unblocked using the
 |      regular timeout mechanism.
 |
 |      For more information, see https://redis.io/commands/client-unblock
 |
 |  client_unpause(self, **kwargs) -> 'bytes | str | Awaitable[bytes | str]'
 |      Unpause all redis clients
 |
 |      For more information, see https://redis.io/commands/client-unpause
 |
 |  command(self, **kwargs) -> 'dict[str, dict[str, Any]] | Awaitable[dict[str, dict[str, Any]]]'
 |      Returns dict reply of details about all Redis commands.
 |
 |      For more information, see https://redis.io/commands/command
 |
 |  command_count(self, **kwargs) -> 'int | Awaitable[int]'
 |
 |  command_docs(self, *args)
 |      This function throws a NotImplementedError since it is intentionally
 |      not supported.
 |
 |  command_getkeysandflags(self, *args: 'str') -> 'CommandGetKeysAndFlagsResponse | Awaitable[CommandGetKeysAndFlagsResponse]'
 |      Returns array of keys from a full Redis command and their usage flags.
 |
 |      For more information, see https://redis.io/commands/command-getkeysandflags
 |
 |  command_info(self, **kwargs) -> 'None'
 |
 |  command_list(self, module: 'str | None' = None, category: 'str | None' = None, pattern: 'str | None' = None) -> 'list[bytes | str] | Awaitable[list[bytes | str]]'
 |      Return an array of the server's command names.
 |      You can use one of the following filters:
 |      ``module``: get the commands that belong to the module
 |      ``category``: get the commands in the ACL category
 |      ``pattern``: get the commands that match the given pattern
 |
 |      For more information, see https://redis.io/commands/command-list/
 |
 |  config_get(self, pattern: 'PatternT' = '*', *args: 'PatternT', **kwargs) -> 'dict[str | None, str | None] | Awaitable[dict[str | None, str | None]]'
 |      Return a dictionary of configuration based on the ``pattern``
 |
 |      For more information, see https://redis.io/commands/config-get
 |
 |  config_resetstat(self, **kwargs) -> 'bool | Awaitable[bool]'
 |      Reset runtime statistics
 |
 |      For more information, see https://redis.io/commands/config-resetstat
 |
 |  config_rewrite(self, **kwargs) -> 'bytes | str | Awaitable[bytes | str]'
 |      Rewrite config file with the minimal change to reflect running config.
 |
 |      For more information, see https://redis.io/commands/config-rewrite
 |
 |  config_set(self, name: 'KeyT', value: 'EncodableT', *args: 'Union[KeyT, EncodableT]', **kwargs) -> 'bool | Awaitable[bool]'
 |      Set config item ``name`` with ``value``
 |
 |      For more information, see https://redis.io/commands/config-set
 |
 |  dbsize(self, **kwargs) -> 'int | Awaitable[int]'
 |      Returns the number of keys in the current database
 |
 |      For more information, see https://redis.io/commands/dbsize
 |
 |  debug_object(self, key: 'KeyT', **kwargs) -> 'dict[str, str | int] | bytes | str | Awaitable[dict[str, str | int] | bytes | str]'
 |      Returns version specific meta information about a given key
 |
 |      For more information, see https://redis.io/commands/debug-object
 |
 |  debug_segfault(self, **kwargs) -> 'None'
 |
 |  echo(self, value: 'EncodableT', **kwargs) -> 'bytes | str | Awaitable[bytes | str]'
 |      Echo the string back from the server
 |
 |      For more information, see https://redis.io/commands/echo
 |
 |  failover(self)
 |      This function throws a NotImplementedError since it is intentionally
 |      not supported.
 |
 |  flushall(self, asynchronous: 'bool' = False, **kwargs) -> 'bool | Awaitable[bool]'
 |      Delete all keys in all databases on the current host.
 |
 |      ``asynchronous`` indicates whether the operation is
 |      executed asynchronously by the server.
 |
 |      For more information, see https://redis.io/commands/flushall
 |
 |  flushdb(self, asynchronous: 'bool' = False, **kwargs) -> 'bool | Awaitable[bool]'
 |      Delete all keys in the current database.
 |
 |      ``asynchronous`` indicates whether the operation is
 |      executed asynchronously by the server.
 |
 |      For more information, see https://redis.io/commands/flushdb
 |
 |  hello(self)
 |      This function throws a NotImplementedError since it is intentionally
 |      not supported.
 |
 |  hotkeys_get(self, **kwargs) -> 'Union[Awaitable[list[dict[str | bytes, Any]]], list[dict[str | bytes, Any]]]'
 |      Retrieve the result of the ongoing collection session (if any),
 |      or the last collection session (if any).
 |
 |      HOTKEYS GET response is wrapped in an array for aggregation support.
 |      Each node returns a single-element array, allowing multiple node
 |      responses to be concatenated by DMC or other aggregators.
 |
 |      For more information, see https://redis.io/commands/hotkeys-get
 |
 |  hotkeys_reset(self, **kwargs) -> 'bytes | str | Awaitable[bytes | str]'
 |      Discard the last hotkeys collection session results (in order to save memory).
 |      Error if there is an ongoing collection session.
 |
 |      For more information, see https://redis.io/commands/hotkeys-reset
 |
 |  hotkeys_start(self, metrics: 'List[HotkeysMetricsTypes]', count: 'int | None' = None, duration: 'int | None' = None, sample_ratio: 'int | None' = None, slots: 'List[int] | None' = None, **kwargs) -> 'bytes | str | Awaitable[bytes | str]'
 |      Start collecting hotkeys data.
 |      Returns an error if there is an ongoing collection session.
 |
 |      Args:
 |          count: The number of keys to collect in each criteria (CPU and network consumption)
 |          metrics: List of metrics to track. Supported values: [HotkeysMetricsTypes.CPU, HotkeysMetricsTypes.NET]
 |          duration: Automatically stop the collection after `duration` seconds
 |          sample_ratio: Commands are sampled with probability 1/ratio (1 means no sampling)
 |          slots: Only track keys on the specified hash slots
 |
 |      For more information, see https://redis.io/commands/hotkeys-start
 |
 |  hotkeys_stop(self, **kwargs) -> 'bytes | str | Awaitable[bytes | str]'
 |      Stop the ongoing hotkeys collection session (if any).
 |      The results of the last collection session are kept for consumption with HOTKEYS GET.
 |
 |      For more information, see https://redis.io/commands/hotkeys-stop
 |
 |  info(self, section: 'Optional[str]' = None, *args: 'str', **kwargs) -> 'dict[str, Any] | Awaitable[dict[str, Any]]'
 |      Returns a dictionary containing information about the Redis server
 |
 |      The ``section`` option can be used to select a specific section
 |      of information
 |
 |      The section option is not supported by older versions of Redis Server,
 |      and will generate ResponseError
 |
 |      For more information, see https://redis.io/commands/info
 |
 |  lastsave(self, **kwargs) -> 'datetime.datetime | Awaitable[datetime.datetime]'
 |      Return a Python datetime object representing the last time the
 |      Redis database was saved to disk
 |
 |      For more information, see https://redis.io/commands/lastsave
 |
 |  latency_doctor(self)
 |      Raise a NotImplementedError, as the client will not support LATENCY DOCTOR.
 |      This function is best used within the redis-cli.
 |
 |      For more information, see https://redis.io/commands/latency-doctor
 |
 |  latency_graph(self)
 |      Raise a NotImplementedError, as the client will not support LATENCY GRAPH.
 |      This function is best used within the redis-cli.
 |
 |      For more information, see https://redis.io/commands/latency-graph.
 |
 |  latency_histogram(self, *args)
 |      This function throws a NotImplementedError since it is intentionally
 |      not supported.
 |
 |  latency_history(self, event: 'str') -> 'list[list[int]] | Awaitable[list[list[int]]]'
 |      Returns the raw data of the ``event``'s latency spikes time series.
 |
 |      For more information, see https://redis.io/commands/latency-history
 |
 |  latency_latest(self) -> 'list[list[bytes | str | int]] | Awaitable[list[list[bytes | str | int]]]'
 |      Reports the latest latency events logged.
 |
 |      For more information, see https://redis.io/commands/latency-latest
 |
 |  latency_reset(self, *events: 'str') -> 'int | Awaitable[int]'
 |      Resets the latency spikes time series of all, or only some, events.
 |
 |      For more information, see https://redis.io/commands/latency-reset
 |
 |  lolwut(self, *version_numbers: 'Union[str, float]', **kwargs) -> 'bytes | str | Awaitable[bytes | str]'
 |      Get the Redis version and a piece of generative computer art
 |
 |      See: https://redis.io/commands/lolwut
 |
 |  memory_doctor(self, **kwargs) -> 'None'
 |
 |  memory_help(self, **kwargs) -> 'None'
 |
 |  memory_malloc_stats(self, **kwargs) -> 'bytes | str | Awaitable[bytes | str]'
 |      Return an internal statistics report from the memory allocator.
 |
 |      See: https://redis.io/commands/memory-malloc-stats
 |
 |  memory_purge(self, **kwargs) -> 'bool | Awaitable[bool]'
 |      Attempts to purge dirty pages for reclamation by allocator
 |
 |      For more information, see https://redis.io/commands/memory-purge
 |
 |  memory_stats(self, **kwargs) -> 'dict[str, Any] | Awaitable[dict[str, Any]]'
 |      Return a dictionary of memory stats
 |
 |      For more information, see https://redis.io/commands/memory-stats
 |
 |  memory_usage(self, key: 'KeyT', samples: 'int | None' = None, **kwargs) -> 'int | None | Awaitable[int | None]'
 |      Return the total memory usage for key, its value and associated
 |      administrative overheads.
 |
 |      For nested data structures, ``samples`` is the number of elements to
 |      sample. If left unspecified, the server's default is 5. Use 0 to sample
 |      all elements.
 |
 |      For more information, see https://redis.io/commands/memory-usage
 |
 |  migrate(self, host: 'str', port: 'int', keys: 'KeysT', destination_db: 'int', timeout: 'int', copy: 'bool' = False, replace: 'bool' = False, auth: 'str | None' = None, **kwargs) -> 'bytes | str | Awaitable[bytes | str]'
 |      Migrate 1 or more keys from the current Redis server to a different
 |      server specified by the ``host``, ``port`` and ``destination_db``.
 |
 |      The ``timeout``, specified in milliseconds, indicates the maximum
 |      time the connection between the two servers can be idle before the
 |      command is interrupted.
 |
 |      If ``copy`` is True, the specified ``keys`` are NOT deleted from
 |      the source server.
 |
 |      If ``replace`` is True, this operation will overwrite the keys
 |      on the destination server if they exist.
 |
 |      If ``auth`` is specified, authenticate to the destination server with
 |      the password provided.
 |
 |      For more information, see https://redis.io/commands/migrate
 |
 |  object(self, infotype: 'str', key: 'KeyT', **kwargs) -> 'Any | Awaitable[Any]'
 |      Return the encoding, idletime, or refcount about the key
 |
 |  ping(self, **kwargs) -> 'Union[Awaitable[bool], bool]'
 |      Ping the Redis server to test connectivity.
 |
 |      Sends a PING command to the Redis server and returns True if the server
 |      responds with "PONG".
 |
 |      This command is useful for:
 |      - Testing whether a connection is still alive
 |      - Verifying the server's ability to serve data
 |
 |      For more information on the underlying ping command see https://redis.io/commands/ping
 |
 |  psync(self, replicationid: 'str', offset: 'int') -> 'bytes | Awaitable[bytes]'
 |      Initiates a replication stream from the master.
 |      Newer version for `sync`.
 |
 |      For more information, see https://redis.io/commands/sync
 |
 |  quit(self, **kwargs) -> 'bool | Awaitable[bool]'
 |      Ask the server to close the connection.
 |
 |      For more information, see https://redis.io/commands/quit
 |
 |  replicaof(self, *args, **kwargs) -> 'bytes | str | Awaitable[bytes | str]'
 |      Update the replication settings of a redis replica, on the fly.
 |
 |      Examples of valid arguments include:
 |
 |      NO ONE (set no replication)
 |      host port (set to the host and port of a redis server)
 |
 |      For more information, see  https://redis.io/commands/replicaof
 |
 |  reset(self) -> 'bytes | str | Awaitable[bytes | str]'
 |      Perform a full reset on the connection's server-side context.
 |
 |      See: https://redis.io/commands/reset
 |
 |  role(self) -> 'list[Any] | Awaitable[list[Any]]'
 |      Provide information on the role of a Redis instance in
 |      the context of replication, by returning if the instance
 |      is currently a master, slave, or sentinel.
 |
 |      For more information, see https://redis.io/commands/role
 |
 |  save(self, **kwargs) -> 'bool | Awaitable[bool]'
 |      Tell the Redis server to save its data to disk,
 |      blocking until the save is complete
 |
 |      For more information, see https://redis.io/commands/save
 |
 |  select(self, index: 'int', **kwargs) -> 'bool | Awaitable[bool]'
 |      Select the Redis logical database at index.
 |
 |      See: https://redis.io/commands/select
 |
 |  shutdown(self, save: 'bool' = False, nosave: 'bool' = False, now: 'bool' = False, force: 'bool' = False, abort: 'bool' = False, **kwargs) -> 'None'
 |      Shutdown the Redis server.  If Redis has persistence configured,
 |      data will be flushed before shutdown.
 |      It is possible to specify modifiers to alter the behavior of the command:
 |      ``save`` will force a DB saving operation even if no save points are configured.
 |      ``nosave`` will prevent a DB saving operation even if one or more save points
 |      are configured.
 |      ``now`` skips waiting for lagging replicas, i.e. it bypasses the first step in
 |      the shutdown sequence.
 |      ``force`` ignores any errors that would normally prevent the server from exiting
 |      ``abort`` cancels an ongoing shutdown and cannot be combined with other flags.
 |
 |      For more information, see https://redis.io/commands/shutdown
 |
 |  slaveof(self, host: 'str | None' = None, port: 'int | None' = None, **kwargs) -> 'bool | Awaitable[bool]'
 |      Set the server to be a replicated slave of the instance identified
 |      by the ``host`` and ``port``. If called without arguments, the
 |      instance is promoted to a master instead.
 |
 |      For more information, see https://redis.io/commands/slaveof
 |
 |  slowlog_get(self, num: 'int | None' = None, **kwargs) -> 'list[dict[str, Any]] | Awaitable[list[dict[str, Any]]]'
 |      Get the entries from the slowlog. If ``num`` is specified, get the
 |      most recent ``num`` items.
 |
 |      For more information, see https://redis.io/commands/slowlog-get
 |
 |  slowlog_len(self, **kwargs) -> 'int | Awaitable[int]'
 |      Get the number of items in the slowlog
 |
 |      For more information, see https://redis.io/commands/slowlog-len
 |
 |  slowlog_reset(self, **kwargs) -> 'bool | Awaitable[bool]'
 |      Remove all items in the slowlog
 |
 |      For more information, see https://redis.io/commands/slowlog-reset
 |
 |  swapdb(self, first: 'int', second: 'int', **kwargs) -> 'bool | Awaitable[bool]'
 |      Swap two databases
 |
 |      For more information, see https://redis.io/commands/swapdb
 |
 |  sync(self) -> 'bytes | Awaitable[bytes]'
 |      Initiates a replication stream from the master.
 |
 |      For more information, see https://redis.io/commands/sync
 |
 |  time(self, **kwargs) -> 'tuple[int, int] | Awaitable[tuple[int, int]]'
 |      Returns the server time as a 2-item tuple of ints:
 |      (seconds since epoch, microseconds into this second).
 |
 |      For more information, see https://redis.io/commands/time
 |
 |  wait(self, num_replicas: 'int', timeout: 'int', **kwargs) -> 'int | Awaitable[int]'
 |      Redis synchronous replication
 |      That returns the number of replicas that processed the query when
 |      we finally have at least ``num_replicas``, or when the ``timeout`` was
 |      reached.
 |
 |      For more information, see https://redis.io/commands/wait
 |
 |  waitaof(self, num_local: 'int', num_replicas: 'int', timeout: 'int', **kwargs) -> 'list[int] | Awaitable[list[int]]'
 |      This command blocks the current client until all previous write
 |      commands by that client are acknowledged as having been fsynced
 |      to the AOF of the local Redis and/or at least the specified number
 |      of replicas.
 |
 |      For more information, see https://redis.io/commands/waitaof
 |
 |  ----------------------------------------------------------------------
 |  Methods inherited from redis.commands.core.ModuleCommands:
 |
 |  command_getkeys(self, *args) -> 'list[bytes | str] | Awaitable[list[bytes | str]]'
 |
 |  module_list(self) -> 'list[dict[Any, Any]] | Awaitable[list[dict[Any, Any]]]'
 |      Returns a list of dictionaries containing the name and version of
 |      all loaded modules.
 |
 |      For more information, see https://redis.io/commands/module-list
 |
 |  module_load(self, path, *args) -> 'bool | Awaitable[bool]'
 |      Loads the module from ``path``.
 |      Passes all ``*args`` to the module, during loading.
 |      Raises ``ModuleError`` if a module is not found at ``path``.
 |
 |      For more information, see https://redis.io/commands/module-load
 |
 |  module_loadex(self, path: 'str', options: 'List[str] | None' = None, args: 'List[str] | None' = None) -> 'bytes | str | Awaitable[bytes | str]'
 |      Loads a module from a dynamic library at runtime with configuration directives.
 |
 |      For more information, see https://redis.io/commands/module-loadex
 |
 |  module_unload(self, name) -> 'bool | Awaitable[bool]'
 |      Unloads the module ``name``.
 |      Raises ``ModuleError`` if ``name`` is not in loaded modules.
 |
 |      For more information, see https://redis.io/commands/module-unload
 |
 |  ----------------------------------------------------------------------
 |  Methods inherited from redis.commands.core.PubSubCommands:
 |
 |  publish(self, channel: 'ChannelT', message: 'EncodableT', **kwargs) -> 'int | Awaitable[int]'
 |      Publish ``message`` on ``channel``.
 |      Returns the number of subscribers the message was delivered to.
 |
 |      For more information, see https://redis.io/commands/publish
 |
 |  pubsub_channels(self, pattern: 'PatternT' = '*', **kwargs) -> 'list[bytes | str] | Awaitable[list[bytes | str]]'
 |      Return a list of channels that have at least one subscriber
 |
 |      For more information, see https://redis.io/commands/pubsub-channels
 |
 |  pubsub_numpat(self, **kwargs) -> 'int | Awaitable[int]'
 |      Returns the number of subscriptions to patterns
 |
 |      For more information, see https://redis.io/commands/pubsub-numpat
 |
 |  pubsub_numsub(self, *args: 'ChannelT', **kwargs) -> 'list[tuple[bytes | str, int]] | Awaitable[list[tuple[bytes | str, int]]]'
 |      Return a list of (channel, number of subscribers) tuples
 |      for each channel given in ``*args``
 |
 |      For more information, see https://redis.io/commands/pubsub-numsub
 |
 |  pubsub_shardchannels(self, pattern: 'PatternT' = '*', **kwargs) -> 'list[bytes | str] | Awaitable[list[bytes | str]]'
 |      Return a list of shard_channels that have at least one subscriber
 |
 |      For more information, see https://redis.io/commands/pubsub-shardchannels
 |
 |  pubsub_shardnumsub(self, *args: 'ChannelT', **kwargs) -> 'list[tuple[bytes | str, int]] | Awaitable[list[tuple[bytes | str, int]]]'
 |      Return a list of (shard_channel, number of subscribers) tuples
 |      for each channel given in ``*args``
 |
 |      For more information, see https://redis.io/commands/pubsub-shardnumsub
 |
 |  spublish(self, shard_channel: 'ChannelT', message: 'EncodableT') -> 'int | Awaitable[int]'
 |      Posts a message to the given shard channel.
 |      Returns the number of clients that received the message
 |
 |      For more information, see https://redis.io/commands/spublish
 |
 |  ----------------------------------------------------------------------
 |  Methods inherited from redis.commands.core.ScriptCommands:
 |
 |  eval(self, script: 'str', numkeys: 'int', *keys_and_args: 'KeyT | EncodableT') -> 'Any | Awaitable[Any]'
 |      Execute the Lua ``script``, specifying the ``numkeys`` the script
 |      will touch and the key names and argument values in ``keys_and_args``.
 |      Returns the result of the script.
 |
 |      In practice, use the object returned by ``register_script``. This
 |      function exists purely for Redis API completion.
 |
 |      For more information, see  https://redis.io/commands/eval
 |
 |  eval_ro(self, script: 'str', numkeys: 'int', *keys_and_args: 'KeyT | EncodableT') -> 'Any | Awaitable[Any]'
 |      The read-only variant of the EVAL command
 |
 |      Execute the read-only Lua ``script`` specifying the ``numkeys`` the script
 |      will touch and the key names and argument values in ``keys_and_args``.
 |      Returns the result of the script.
 |
 |      For more information, see  https://redis.io/commands/eval_ro
 |
 |  evalsha(self, sha: 'str', numkeys: 'int', *keys_and_args: 'KeyT | EncodableT') -> 'Any | Awaitable[Any]'
 |      Use the ``sha`` to execute a Lua script already registered via EVAL
 |      or SCRIPT LOAD. Specify the ``numkeys`` the script will touch and the
 |      key names and argument values in ``keys_and_args``. Returns the result
 |      of the script.
 |
 |      In practice, use the object returned by ``register_script``. This
 |      function exists purely for Redis API completion.
 |
 |      For more information, see  https://redis.io/commands/evalsha
 |
 |  evalsha_ro(self, sha: 'str', numkeys: 'int', *keys_and_args: 'KeyT | EncodableT') -> 'Any | Awaitable[Any]'
 |      The read-only variant of the EVALSHA command
 |
 |      Use the ``sha`` to execute a read-only Lua script already registered via EVAL
 |      or SCRIPT LOAD. Specify the ``numkeys`` the script will touch and the
 |      key names and argument values in ``keys_and_args``. Returns the result
 |      of the script.
 |
 |      For more information, see  https://redis.io/commands/evalsha_ro
 |
 |  register_script(self: "Union['redis.client.Redis', 'redis.cluster.RedisCluster']", script: 'ScriptTextT') -> 'Script'
 |      Register a Lua ``script`` specifying the ``keys`` it will touch.
 |      Returns a Script object that is callable and hides the complexity of
 |      deal with scripts, keys, and shas. This is the preferred way to work
 |      with Lua scripts.
 |
 |  script_debug(self, *args) -> 'None'
 |
 |  script_exists(self, *args: 'str') -> 'list[bool] | Awaitable[list[bool]]'
 |      Check if a script exists in the script cache by specifying the SHAs of
 |      each script as ``args``. Returns a list of boolean values indicating if
 |      if each already script exists in the cache_data.
 |
 |      For more information, see  https://redis.io/commands/script-exists
 |
 |  script_flush(self, sync_type: "Literal['SYNC'] | Literal['ASYNC'] | None" = None) -> 'bool | Awaitable[bool]'
 |      Flush all scripts from the script cache_data.
 |
 |      ``sync_type`` is by default SYNC (synchronous) but it can also be
 |                    ASYNC.
 |
 |      For more information, see  https://redis.io/commands/script-flush
 |
 |  script_kill(self) -> 'bool | Awaitable[bool]'
 |      Kill the currently executing Lua script
 |
 |      For more information, see https://redis.io/commands/script-kill
 |
 |  script_load(self, script: 'ScriptTextT') -> 'str | Awaitable[str]'
 |      Load a Lua ``script`` into the script cache_data. Returns the SHA.
 |
 |      For more information, see https://redis.io/commands/script-load
 |
 |  ----------------------------------------------------------------------
 |  Data and other attributes inherited from redis.typing.CommandsProtocol:
 |
 |  __protocol_attrs__ = {'_event_dispatcher', 'execute_command'}
 |
 |  ----------------------------------------------------------------------
 |  Class methods inherited from typing.Protocol:
 |
 |  __init_subclass__(*args, **kwargs)
 |      This method is called when a class is subclassed.
 |
 |      The default implementation does nothing. It may be
 |      overridden to extend subclasses.
 |
 |  ----------------------------------------------------------------------
 |  Class methods inherited from typing.Generic:
 |
 |  __class_getitem__(...)
 |      Parameterizes a generic class.
 |
 |      At least, parameterizing a generic class is the *main* thing this
 |      method does. For example, for some generic class `Foo`, this is called
 |      when we do `Foo[int]` - there, with `cls=Foo` and `params=int`.
 |
 |      However, note that this method is also called when defining generic
 |      classes in the first place with `class Foo[T]: ...`.
 |
 |  ----------------------------------------------------------------------
 |  Methods inherited from redis.commands.core.FunctionCommands:
 |
 |  fcall(self, function, numkeys: 'int', *keys_and_args: 'Any') -> 'Any | Awaitable[Any]'
 |      Invoke a function.
 |
 |      For more information, see https://redis.io/commands/fcall
 |
 |  fcall_ro(self, function, numkeys: 'int', *keys_and_args: 'Any') -> 'Any | Awaitable[Any]'
 |      This is a read-only variant of the FCALL command that cannot
 |      execute commands that modify data.
 |
 |      For more information, see https://redis.io/commands/fcall_ro
 |
 |  function_delete(self, library: 'str') -> 'bool | Awaitable[bool]'
 |      Delete the library called ``library`` and all its functions.
 |
 |      For more information, see https://redis.io/commands/function-delete
 |
 |  function_dump(self) -> 'bytes | Awaitable[bytes]'
 |      Return the serialized payload of loaded libraries.
 |
 |      For more information, see https://redis.io/commands/function-dump
 |
 |  function_flush(self, mode: 'str' = 'SYNC') -> 'bool | Awaitable[bool]'
 |      Deletes all the libraries.
 |
 |      For more information, see https://redis.io/commands/function-flush
 |
 |  function_kill(self) -> 'bytes | str | Awaitable[bytes | str]'
 |      Kill a function that is currently executing.
 |
 |      For more information, see https://redis.io/commands/function-kill
 |
 |  function_list(self, library: 'str | None' = '*', withcode: 'bool | None' = False) -> 'list[Any] | Awaitable[list[Any]]'
 |      Return information about the functions and libraries.
 |
 |      Args:
 |
 |          library: specify a pattern for matching library names
 |          withcode: cause the server to include the libraries source implementation
 |              in the reply
 |
 |  function_load(self, code: 'str', replace: 'bool | None' = False) -> 'bytes | str | Awaitable[bytes | str]'
 |      Load a library to Redis.
 |      :param code: the source code (must start with
 |      Shebang statement that provides a metadata about the library)
 |      :param replace: changes the behavior to overwrite the existing library
 |      with the new contents.
 |      Return the library name that was loaded.
 |
 |      For more information, see https://redis.io/commands/function-load
 |
 |  function_restore(self, payload: 'str', policy: 'str | None' = 'APPEND') -> 'bool | Awaitable[bool]'
 |      Restore libraries from the serialized ``payload``.
 |      You can use the optional policy argument to provide a policy
 |      for handling existing libraries.
 |
 |      For more information, see https://redis.io/commands/function-restore
 |
 |  function_stats(self) -> 'Any | Awaitable[Any]'
 |      Return information about the function that's currently running
 |      and information about the available execution engines.
 |
 |      For more information, see https://redis.io/commands/function-stats
 |
 |  ----------------------------------------------------------------------
 |  Methods inherited from redis.commands.sentinel.SentinelCommands:
 |
 |  sentinel(self, *args)
 |      Redis Sentinel's SENTINEL command.
 |
 |  sentinel_ckquorum(self, new_master_name) -> Union[bool, Awaitable[bool]]
 |      Check if the current Sentinel configuration is able to reach the
 |      quorum needed to failover a master, and the majority needed to
 |      authorize the failover.
 |
 |      This command should be used in monitoring systems to check if a
 |      Sentinel deployment is ok.
 |
 |  sentinel_failover(self, new_master_name) -> Union[bool, Awaitable[bool]]
 |      Force a failover as if the master was not reachable, and without
 |      asking for agreement to other Sentinels (however a new version of the
 |      configuration will be published so that the other Sentinels will
 |      update their configurations).
 |
 |  sentinel_flushconfig(self) -> Union[bool, Awaitable[bool]]
 |      Force Sentinel to rewrite its configuration on disk, including the
 |      current Sentinel state.
 |
 |      Normally Sentinel rewrites the configuration every time something
 |      changes in its state (in the context of the subset of the state which
 |      is persisted on disk across restart).
 |      However sometimes it is possible that the configuration file is lost
 |      because of operation errors, disk failures, package upgrade scripts or
 |      configuration managers. In those cases a way to to force Sentinel to
 |      rewrite the configuration file is handy.
 |
 |      This command works even if the previous configuration file is
 |      completely missing.
 |
 |  sentinel_get_master_addr_by_name(self, service_name, return_responses: bool = False) -> Union[tuple[bytes | str, int], NoneType, bool, Awaitable[tuple[bytes | str, int] | None | bool]]
 |      Returns a (host, port) pair for the given ``service_name`` when return_responses is True,
 |      otherwise returns a boolean value that indicates if the command was successful.
 |
 |  sentinel_master(self, service_name, return_responses: bool = False) -> Union[dict[str, Any], bool, Awaitable[dict[str, Any] | bool]]
 |      Returns a dictionary containing the specified masters state, when return_responses is True,
 |      otherwise returns a boolean value that indicates if the command was successful.
 |
 |  sentinel_masters(self) -> Union[dict[str, dict[str, Any]], list[dict[str, Any]], Awaitable[dict[str, dict[str, Any]] | list[dict[str, Any]]]]
 |      Returns a list of dictionaries containing each master's state.
 |
 |      Important: This function is called by the Sentinel implementation and is
 |      called directly on the Redis standalone client for sentinels,
 |      so it doesn't support the "once" and "return_responses" options.
 |
 |  sentinel_monitor(self, name, ip, port, quorum) -> Union[bool, Awaitable[bool]]
 |      Add a new master to Sentinel to be monitored
 |
 |  sentinel_remove(self, name) -> Union[bool, Awaitable[bool]]
 |      Remove a master from Sentinel's monitoring
 |
 |  sentinel_reset(self, pattern) -> Union[bool, Awaitable[bool]]
 |      This command will reset all the masters with matching name.
 |      The pattern argument is a glob-style pattern.
 |
 |      The reset process clears any previous state in a master (including a
 |      failover in progress), and removes every slave and sentinel already
 |      discovered and associated with the master.
 |
 |  sentinel_sentinels(self, service_name, return_responses: bool = False) -> Union[list[dict[str, Any]], bool, Awaitable[list[dict[str, Any]] | bool]]
 |      Returns a list of sentinels for ``service_name``, when return_responses is True,
 |      otherwise returns a boolean value that indicates if the command was successful.
 |
 |  sentinel_set(self, name, option, value) -> Union[bool, Awaitable[bool]]
 |      Set Sentinel monitoring parameters for a given master
 |
 |  sentinel_slaves(self, service_name) -> Union[list[dict[str, Any]], Awaitable[list[dict[str, Any]]]]
 |      Returns a list of slaves for ``service_name``
 |
 |      Important: This function is called by the Sentinel implementation and is
 |      called directly on the Redis standalone client for sentinels,
 |      so it doesn't support the "once" and "return_responses" options.

Python Library Documentation: class RedisCluster in module redis.cluster

class RedisCluster(AbstractRedisCluster, MaintNotificationsAbstractRedisCluster, redis.commands.cluster.RedisClusterCommands)
 |  RedisCluster(host: Optional[str] = None, port: int = 6379, startup_nodes: Optional[List[ForwardRef('ClusterNode')]] = None, cluster_error_retry_attempts: int = 10, retry: Optional[ForwardRef('Retry')] = None, require_full_coverage: bool = True, reinitialize_steps: int = 5, read_from_replicas: bool = False, load_balancing_strategy: Optional[ForwardRef('LoadBalancingStrategy')] = None, dynamic_startup_nodes: bool = True, url: Optional[str] = None, address_remap: Optional[Callable[[Tuple[str, int]], Tuple[str, int]]] = None, cache: Optional[redis.cache.CacheInterface] = None, cache_config: Optional[redis.cache.CacheConfig] = None, event_dispatcher: Optional[redis.event.EventDispatcher] = None, policy_resolver: redis.commands.policies.PolicyResolver = <redis.commands.policies.StaticPolicyResolver object at 0x0000017B9C759D90>, maint_notifications_config: Optional[redis.maint_notifications.MaintNotificationsConfig] = None, **kwargs)
 |
 |  Method resolution order:
 |      RedisCluster
 |      AbstractRedisCluster
 |      MaintNotificationsAbstractRedisCluster
 |      redis.commands.cluster.RedisClusterCommands
 |      redis.commands.cluster.ClusterMultiKeyCommands
 |      redis.typing.ClusterCommandsProtocol
 |      redis.commands.cluster.ClusterManagementCommands
 |      redis.commands.core.ManagementCommands
 |      redis.commands.core.ACLCommands
 |      redis.commands.core.PubSubCommands
 |      redis.commands.cluster.ClusterDataAccessCommands
 |      redis.commands.core.DataAccessCommands
 |      redis.commands.core.BasicKeyCommands
 |      redis.commands.core.HyperlogCommands
 |      redis.commands.core.HashCommands
 |      redis.commands.core.GeoCommands
 |      redis.commands.core.ListCommands
 |      redis.commands.core.ArrayCommands
 |      redis.commands.core.ScanCommands
 |      redis.commands.core.SetCommands
 |      redis.commands.core.StreamCommands
 |      redis.commands.core.SortedSetCommands
 |      redis.commands.core.ScriptCommands
 |      redis.commands.core.FunctionCommands
 |      redis.commands.core.ModuleCommands
 |      redis.typing.CommandsProtocol
 |      typing.Protocol
 |      typing.Generic
 |      redis.commands.redismodules.RedisModuleCommands
 |      builtins.object
 |
 |  Methods defined here:
 |
 |  __del__(self)
 |
 |  __enter__(self)
 |
 |  __exit__(self, exc_type, exc_value, traceback)
 |
 |  __init__(self, host: Optional[str] = None, port: int = 6379, startup_nodes: Optional[List[ForwardRef('ClusterNode')]] = None, cluster_error_retry_attempts: int = 10, retry: Optional[ForwardRef('Retry')] = None, require_full_coverage: bool = True, reinitialize_steps: int = 5, read_from_replicas: bool = False, load_balancing_strategy: Optional[ForwardRef('LoadBalancingStrategy')] = None, dynamic_startup_nodes: bool = True, url: Optional[str] = None, address_remap: Optional[Callable[[Tuple[str, int]], Tuple[str, int]]] = None, cache: Optional[redis.cache.CacheInterface] = None, cache_config: Optional[redis.cache.CacheConfig] = None, event_dispatcher: Optional[redis.event.EventDispatcher] = None, policy_resolver: redis.commands.policies.PolicyResolver = <redis.commands.policies.StaticPolicyResolver object at 0x0000017B9C759D90>, maint_notifications_config: Optional[redis.maint_notifications.MaintNotificationsConfig] = None, **kwargs)
 |      Initialize a new RedisCluster client.
 |
 |      :param startup_nodes:
 |          List of nodes from which initial bootstrapping can be done
 |      :param host:
 |          Can be used to point to a startup node
 |      :param port:
 |          Can be used to point to a startup node
 |      :param require_full_coverage:
 |          When set to False (default value): the client will not require a
 |          full coverage of the slots. However, if not all slots are covered,
 |          and at least one node has 'cluster-require-full-coverage' set to
 |          'yes,' the server will throw a ClusterDownError for some key-based
 |          commands. See -
 |          https://redis.io/topics/cluster-tutorial#redis-cluster-configuration-parameters
 |          When set to True: all slots must be covered to construct the
 |          cluster client. If not all slots are covered, RedisClusterException
 |          will be thrown.
 |      :param read_from_replicas:
 |          @deprecated - please use load_balancing_strategy instead
 |          Enable read from replicas in READONLY mode. You can read possibly
 |          stale data.
 |          When set to true, read commands will be assigned between the
 |          primary and its replications in a Round-Robin manner.
 |      :param load_balancing_strategy:
 |          Enable read from replicas in READONLY mode and defines the load balancing
 |          strategy that will be used for cluster node selection.
 |          The data read from replicas is eventually consistent with the data in primary nodes.
 |      :param dynamic_startup_nodes:
 |          Set the RedisCluster's startup nodes to all of the discovered nodes.
 |          If true (default value), the cluster's discovered nodes will be used to
 |          determine the cluster nodes-slots mapping in the next topology refresh.
 |          It will remove the initial passed startup nodes if their endpoints aren't
 |          listed in the CLUSTER SLOTS output.
 |          If you use dynamic DNS endpoints for startup nodes but CLUSTER SLOTS lists
 |          specific IP addresses, it is best to set it to false.
 |      :param cluster_error_retry_attempts:
 |          @deprecated - Please configure the 'retry' object instead
 |          In case 'retry' object is set - this argument is ignored!
 |
 |          Number of times to retry before raising an error when
 |          :class:`~.TimeoutError` or :class:`~.ConnectionError`, :class:`~.SlotNotCoveredError` or
 |          :class:`~.ClusterDownError` are encountered
 |      :param retry:
 |          A retry object that defines the retry strategy and the number of
 |          retries for the cluster client.
 |          In current implementation for the cluster client (starting form redis-py version 6.0.0)
 |          the retry object is not yet fully utilized, instead it is used just to determine
 |          the number of retries for the cluster client.
 |          In the future releases the retry object will be used to handle the cluster client retries!
 |      :param reinitialize_steps:
 |          Specifies the number of MOVED errors that need to occur before
 |          reinitializing the whole cluster topology. If a MOVED error occurs
 |          and the cluster does not need to be reinitialized on this current
 |          error handling, only the MOVED slot will be patched with the
 |          redirected node.
 |          To reinitialize the cluster on every MOVED error, set
 |          reinitialize_steps to 1.
 |          To avoid reinitializing the cluster on moved errors, set
 |          reinitialize_steps to 0.
 |      :param address_remap:
 |          An optional callable which, when provided with an internal network
 |          address of a node, e.g. a `(host, port)` tuple, will return the address
 |          where the node is reachable.  This can be used to map the addresses at
 |          which the nodes _think_ they are, to addresses at which a client may
 |          reach them, such as when they sit behind a proxy.
 |
 |      :param maint_notifications_config:
 |          Configures the nodes connections to support maintenance notifications - see
 |          `redis.maint_notifications.MaintNotificationsConfig` for details.
 |          Only supported with RESP3.
 |          If not provided and protocol is RESP3, the maintenance notifications
 |          will be enabled by default (logic is included in the NodesManager
 |          initialization).
 |      :**kwargs:
 |          Extra arguments that will be sent into Redis instance when created
 |          (See Official redis-py doc for supported kwargs - the only limitation
 |          is that you can't provide 'retry' object as part of kwargs.
 |          [https://github.com/andymccurdy/redis-py/blob/master/redis/client.py])
 |          Some kwargs are not supported and will raise a
 |          RedisClusterException:
 |              - db (Redis do not support database SELECT in cluster mode)
 |
 |  close(self) -> None
 |
 |  determine_slot(self, *args) -> Optional[int]
 |      Figure out what slot to use based on args.
 |
 |      Raises a RedisClusterException if there's a missing key and we can't
 |          determine what slots to map the command to; or, if the keys don't
 |          all map to the same key slot.
 |
 |  disconnect_connection_pools(self)
 |
 |  execute_command(self, *args, **kwargs)
 |
 |  get_connection_kwargs(self)
 |      Get the connections' key-word arguments
 |
 |  get_default_node(self)
 |      Get the cluster's default node
 |
 |  get_encoder(self)
 |      Get the connections' encoder
 |
 |  get_node(self, host=None, port=None, node_name=None)
 |
 |  get_node_from_key(self, key, replica=False)
 |      Get the node that holds the key's slot.
 |      If replica set to True but the slot doesn't have any replicas, None is
 |      returned.
 |
 |  get_nodes(self)
 |
 |  get_nodes_from_slot(self, command: str, *args)
 |      Returns a list of nodes that hold the specified keys' slots.
 |
 |  get_primaries(self)
 |
 |  get_random_node(self)
 |
 |  get_random_primary_node(self) -> 'ClusterNode'
 |      Returns a random primary node
 |
 |  get_random_primary_or_all_nodes(self, command_name)
 |      Returns random primary or all nodes depends on READONLY mode.
 |
 |  get_redis_connection(self, node: 'ClusterNode') -> redis.client.Redis
 |
 |  get_replicas(self)
 |
 |  get_special_nodes(self) -> Optional[list['ClusterNode']]
 |      Returns a list of nodes for commands with a special policy.
 |
 |  himport_discard(self, fieldset_name: str) -> int
 |      Remove an HIMPORT fieldset cluster-wide (shared registry, applied lazily).
 |
 |  himport_discard_all(self) -> int
 |      Remove all HIMPORT fieldsets cluster-wide (shared registry, applied lazily).
 |
 |  himport_prepare(self, fieldset_name: str, fields: Iterable[Union[bytes, bytearray, memoryview, str, int, float]]) -> bool
 |      Declare an HIMPORT fieldset cluster-wide (shared registry, applied lazily).
 |
 |  keyslot(self, key)
 |      Calculate keyslot for a given key.
 |      See Keys distribution model in https://redis.io/topics/cluster-spec
 |
 |  keyspace_notifications(self, key_prefix: Union[str, bytes, NoneType] = None, ignore_subscribe_messages: bool = True) -> 'ClusterKeyspaceNotifications'
 |      Return a :class:`~redis.keyspace_notifications.ClusterKeyspaceNotifications`
 |      object for subscribing to keyspace and keyevent notifications across
 |      all primary nodes in the cluster.
 |
 |      Note: Keyspace notifications must be enabled on all Redis cluster nodes
 |      via the ``notify-keyspace-events`` configuration option.
 |
 |      Args:
 |          key_prefix: Optional prefix to filter and strip from keys in
 |                      notifications.
 |          ignore_subscribe_messages: If True, subscribe/unsubscribe
 |                                    confirmations are not returned by
 |                                    get_message/listen.
 |
 |  load_external_module(self, funcname, func)
 |      This function can be used to add externally defined redis modules,
 |      and their namespaces to the redis client.
 |
 |      ``funcname`` - A string containing the name of the function to create
 |      ``func`` - The function, being added to this class.
 |
 |  lock(self, name, timeout=None, sleep=0.1, blocking=True, blocking_timeout=None, lock_class=None, thread_local=True, raise_on_release_error: bool = True)
 |      Return a new Lock object using key ``name`` that mimics
 |      the behavior of threading.Lock.
 |
 |      If specified, ``timeout`` indicates a maximum life for the lock.
 |      By default, it will remain locked until release() is called.
 |
 |      ``sleep`` indicates the amount of time to sleep per loop iteration
 |      when the lock is in blocking mode and another client is currently
 |      holding the lock.
 |
 |      ``blocking`` indicates whether calling ``acquire`` should block until
 |      the lock has been acquired or to fail immediately, causing ``acquire``
 |      to return False and the lock not being acquired. Defaults to True.
 |      Note this value can be overridden by passing a ``blocking``
 |      argument to ``acquire``.
 |
 |      ``blocking_timeout`` indicates the maximum amount of time in seconds to
 |      spend trying to acquire the lock. A value of ``None`` indicates
 |      continue trying forever. ``blocking_timeout`` can be specified as a
 |      float or integer, both representing the number of seconds to wait.
 |
 |      ``lock_class`` forces the specified lock implementation. Note that as
 |      of redis-py 3.0, the only lock class we implement is ``Lock`` (which is
 |      a Lua-based lock). So, it's unlikely you'll need this parameter, unless
 |      you have created your own custom lock class.
 |
 |      ``thread_local`` indicates whether the lock token is placed in
 |      thread-local storage. By default, the token is placed in thread local
 |      storage so that a thread only sees its token, not a token set by
 |      another thread. Consider the following timeline:
 |
 |          time: 0, thread-1 acquires `my-lock`, with a timeout of 5 seconds.
 |                   thread-1 sets the token to "abc"
 |          time: 1, thread-2 blocks trying to acquire `my-lock` using the
 |                   Lock instance.
 |          time: 5, thread-1 has not yet completed. redis expires the lock
 |                   key.
 |          time: 5, thread-2 acquired `my-lock` now that it's available.
 |                   thread-2 sets the token to "xyz"
 |          time: 6, thread-1 finishes its work and calls release(). if the
 |                   token is *not* stored in thread local storage, then
 |                   thread-1 would see the token value as "xyz" and would be
 |                   able to successfully release the thread-2's lock.
 |
 |      ``raise_on_release_error`` indicates whether to raise an exception when
 |      the lock is no longer owned when exiting the context manager. By default,
 |      this is True, meaning an exception will be raised. If False, the warning
 |      will be logged and the exception will be suppressed.
 |
 |      In some use cases it's necessary to disable thread local storage. For
 |      example, if you have code where one thread acquires a lock and passes
 |      that lock instance to a worker thread to release later. If thread
 |      local storage isn't disabled in this case, the worker thread won't see
 |      the token set by the thread that acquired the lock. Our assumption
 |      is that these cases aren't common and as such default to using
 |      thread local storage.
 |
 |  monitor(self, target_node=None)
 |      Returns a Monitor object for the specified target node.
 |      The default cluster node will be selected if no target node was
 |      specified.
 |      Monitor is useful for handling the MONITOR command to the redis server.
 |      next_command() method returns one command from monitor
 |      listen() method yields commands from monitor.
 |
 |  on_connect(self, connection)
 |      Initialize the connection, authenticate and select a database and send
 |       READONLY if it is set during object initialization.
 |
 |  pipeline(self, transaction=None, shard_hint=None)
 |      Cluster impl:
 |          Pipelines do not work in cluster mode the same way they
 |          do in normal mode. Create a clone of this object so
 |          that simulating pipelines will work correctly. Each
 |          command will be called directly when used and
 |          when calling execute() will only return the result stack.
 |
 |  pubsub(self, node=None, host=None, port=None, **kwargs)
 |      Allows passing a ClusterNode, or host&port, to get a pubsub instance
 |      connected to the specified node
 |
 |  set_default_node(self, node)
 |      Set the default node of the cluster.
 |      :param node: 'ClusterNode'
 |      :return True if the default node was set, else False
 |
 |  set_response_callback(self, command, callback)
 |      Set a custom Response Callback
 |
 |  set_retry(self, retry: redis.retry.Retry) -> None
 |
 |  transaction(self, func, *watches, **kwargs)
 |      Convenience method for executing the callable `func` as a transaction
 |      while watching all keys specified in `watches`. The 'func' callable
 |      should expect a single argument which is a Pipeline object.
 |
 |  ----------------------------------------------------------------------
 |  Class methods defined here:
 |
 |  __subclasshook__ = _proto_hook(other) from typing
 |
 |  from_url(url: str, **kwargs: Any) -> 'RedisCluster'
 |      Return a Redis client object configured from the given URL
 |
 |      For example::
 |
 |          redis://[[username]:[password]]@localhost:6379/0
 |          rediss://[[username]:[password]]@localhost:6379/0
 |          unix://[username@]/path/to/socket.sock?db=0[&password=password]
 |
 |      Three URL schemes are supported:
 |
 |      - `redis://` creates a TCP socket connection. See more at:
 |        <https://www.iana.org/assignments/uri-schemes/prov/redis>
 |      - `rediss://` creates a SSL wrapped TCP socket connection. See more at:
 |        <https://www.iana.org/assignments/uri-schemes/prov/rediss>
 |      - ``unix://``: creates a Unix Domain Socket connection.
 |
 |      The username, password, hostname, path and all querystring values
 |      are passed through urllib.parse.unquote in order to replace any
 |      percent-encoded values with their corresponding characters.
 |
 |      There are several ways to specify a database number. The first value
 |      found will be used:
 |
 |          1. A ``db`` querystring option, e.g. redis://localhost?db=0
 |          2. If using the redis:// or rediss:// schemes, the path argument
 |             of the url, e.g. redis://localhost/0
 |          3. A ``db`` keyword argument to this function.
 |
 |      If none of these options are specified, the default db=0 is used.
 |
 |      All querystring options are cast to their appropriate Python types.
 |      Boolean arguments can be specified with string values "True"/"False"
 |      or "Yes"/"No". Values that cannot be properly cast cause a
 |      ``ValueError`` to be raised. Once parsed, the querystring arguments
 |      and keyword arguments are passed to the ``ConnectionPool``'s
 |      class initializer. In the case of conflicting arguments, querystring
 |      arguments always win.
 |
 |  ----------------------------------------------------------------------
 |  Readonly properties defined here:
 |
 |  himport_registry
 |      The cluster-wide HIMPORT fieldset registry (empty if none was declared).
 |
 |      Read-only: the registry is mutated only through the HIMPORT command methods.
 |
 |  ----------------------------------------------------------------------
 |  Data and other attributes defined here:
 |
 |  __abstractmethods__ = frozenset()
 |
 |  __annotations__ = {'_is_async_client': typing.Literal[False]}
 |
 |  __parameters__ = ()
 |
 |  ----------------------------------------------------------------------
 |  Methods inherited from AbstractRedisCluster:
 |
 |  replace_default_node(self, target_node: 'ClusterNode' = None) -> None
 |      Replace the default cluster node.
 |      A random cluster node will be chosen if target_node isn't passed, and primaries
 |      will be prioritized. The default node will not be changed if there are no other
 |      nodes in the cluster.
 |
 |      Args:
 |          target_node (ClusterNode, optional): Target node to replace the default
 |          node. Defaults to None.
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from AbstractRedisCluster:
 |
 |  __dict__
 |      dictionary for instance variables
 |
 |  __weakref__
 |      list of weak references to the object
 |
 |  ----------------------------------------------------------------------
 |  Data and other attributes inherited from AbstractRedisCluster:
 |
 |  ALL_NODES = 'all'
 |
 |  CLUSTER_COMMANDS_RESPONSE_CALLBACKS = {'CLUSTER MYSHARDID': <function ...
 |
 |  COMMAND_FLAGS = {'ACL CAT': 'default-node', 'ACL DELUSER': 'default-no...
 |
 |  DEFAULT_NODE = 'default-node'
 |
 |  ERRORS_ALLOW_RETRY = (<class 'redis.exceptions.ConnectionError'>, <cla...
 |
 |  NODE_FLAGS = {'all', 'default-node', 'primaries', 'random', 'replicas'...
 |
 |  PRIMARIES = 'primaries'
 |
 |  RANDOM = 'random'
 |
 |  REPLICAS = 'replicas'
 |
 |  RESULT_CALLBACKS = {'BGSAVE': <function AbstractRedisCluster.<lambda>>...
 |
 |  RedisClusterRequestTTL = 16
 |
 |  SEARCH_COMMANDS = (['FT.CREATE', 'FT.SEARCH', 'FT.AGGREGATE', 'FT.EXPL...
 |
 |  ----------------------------------------------------------------------
 |  Methods inherited from redis.commands.cluster.ClusterMultiKeyCommands:
 |
 |  delete(self, *keys: 'KeyT') -> 'int | Awaitable[int]'
 |      Deletes the given keys in the cluster.
 |      The keys are first split up into slots
 |      and then an DEL command is sent for every slot
 |
 |      Non-existent keys are ignored.
 |      Returns the number of keys that were deleted.
 |
 |      For more information see https://redis.io/commands/del
 |
 |  exists(self, *keys: 'KeyT') -> 'int | Awaitable[int]'
 |      Returns the number of ``names`` that exist in the
 |      whole cluster. The keys are first split up into slots
 |      and then an EXISTS command is sent for every slot
 |
 |      For more information see https://redis.io/commands/exists
 |
 |  mget_nonatomic(self, keys: 'KeysT', *args: 'KeyT') -> 'List[Any | None]'
 |      Splits the keys into different slots and then calls MGET
 |      for the keys of every slot. This operation will not be atomic
 |      if keys belong to more than one slot.
 |
 |      Returns a list of values ordered identically to ``keys``
 |
 |      For more information see https://redis.io/commands/mget
 |
 |  mset_nonatomic(self, mapping: 'Mapping[AnyKeyT, EncodableT]') -> 'List[bool]'
 |      Sets key/values based on a mapping. Mapping is a dictionary of
 |      key/value pairs. Both keys and values should be strings or types that
 |      can be cast to a string via str().
 |
 |      Splits the keys into different slots and then calls MSET
 |      for the keys of every slot. This operation will not be atomic
 |      if keys belong to more than one slot.
 |
 |      For more information see https://redis.io/commands/mset
 |
 |  touch(self, *keys: 'KeyT') -> 'int | Awaitable[int]'
 |      Updates the last access time of given keys across the
 |      cluster.
 |
 |      The keys are first split up into slots
 |      and then an TOUCH command is sent for every slot
 |
 |      Non-existent keys are ignored.
 |      Returns the number of keys that were touched.
 |
 |      For more information see https://redis.io/commands/touch
 |
 |  unlink(self, *keys: 'KeyT') -> 'int | Awaitable[int]'
 |      Remove the specified keys in a different thread.
 |
 |      The keys are first split up into slots
 |      and then an TOUCH command is sent for every slot
 |
 |      Non-existent keys are ignored.
 |      Returns the number of keys that were unlinked.
 |
 |      For more information see https://redis.io/commands/unlink
 |
 |  ----------------------------------------------------------------------
 |  Methods inherited from redis.commands.cluster.ClusterManagementCommands:
 |
 |  client_tracking_off(self, clientid: 'int | None' = None, prefix: 'Sequence[KeyT]' = [], bcast: 'bool' = False, optin: 'bool' = False, optout: 'bool' = False, noloop: 'bool' = False, target_nodes: "'TargetNodesT' | None" = 'all') -> 'ResponseT'
 |      Disables the tracking feature of the Redis server, that is used
 |      for server assisted client side caching.
 |
 |      When clientid is provided - in target_nodes only the node that owns the
 |      connection with this id should be provided.
 |      When clientid is not provided - target_nodes can be any node.
 |
 |      For more information see https://redis.io/commands/client-tracking
 |
 |  client_tracking_on(self, clientid: 'int | None' = None, prefix: 'Sequence[KeyT]' = [], bcast: 'bool' = False, optin: 'bool' = False, optout: 'bool' = False, noloop: 'bool' = False, target_nodes: "'TargetNodesT' | None" = 'all') -> 'ResponseT'
 |      Enables the tracking feature of the Redis server, that is used
 |      for server assisted client side caching.
 |
 |      When clientid is provided - in target_nodes only the node that owns the
 |      connection with this id should be provided.
 |      When clientid is not provided - target_nodes can be any node.
 |
 |      For more information see https://redis.io/commands/client-tracking
 |
 |  cluster_addslots(self, target_node: "'TargetNodesT'", *slots: 'EncodableT') -> 'bool | Awaitable[bool]'
 |      Assign new hash slots to receiving node. Sends to specified node.
 |
 |      :target_node: 'ClusterNode'
 |          The node to execute the command on
 |
 |      For more information see https://redis.io/commands/cluster-addslots
 |
 |  cluster_addslotsrange(self, target_node: "'TargetNodesT'", *slots: 'EncodableT') -> 'bool | Awaitable[bool]'
 |      Similar to the CLUSTER ADDSLOTS command.
 |      The difference between the two commands is that ADDSLOTS takes a list of slots
 |      to assign to the node, while ADDSLOTSRANGE takes a list of slot ranges
 |      (specified by start and end slots) to assign to the node.
 |
 |      :target_node: 'ClusterNode'
 |          The node to execute the command on
 |
 |      For more information see https://redis.io/commands/cluster-addslotsrange
 |
 |  cluster_bumpepoch(self, target_nodes: "'TargetNodesT' | None" = None) -> 'None'
 |
 |  cluster_count_failure_report(self, node_id: 'str') -> 'int | Awaitable[int]'
 |      Return the number of failure reports active for a given node
 |      Sends to a random node
 |
 |      For more information see https://redis.io/commands/cluster-count-failure-reports
 |
 |  cluster_countkeysinslot(self, slot_id: 'int') -> 'int | Awaitable[int]'
 |      Return the number of local keys in the specified hash slot
 |      Send to node based on specified slot_id
 |
 |      For more information see https://redis.io/commands/cluster-countkeysinslot
 |
 |  cluster_delslots(self, *slots: 'EncodableT') -> 'List[bool]'
 |      Set hash slots as unbound in the cluster.
 |      It determines by it self what node the slot is in and sends it there
 |
 |      Returns a list of the results for each processed slot.
 |
 |      For more information see https://redis.io/commands/cluster-delslots
 |
 |  cluster_delslotsrange(self, *slots: 'EncodableT') -> 'bool | Awaitable[bool]'
 |      Similar to the CLUSTER DELSLOTS command.
 |      The difference is that CLUSTER DELSLOTS takes a list of hash slots to remove
 |      from the node, while CLUSTER DELSLOTSRANGE takes a list of slot ranges to remove
 |      from the node.
 |
 |      For more information see https://redis.io/commands/cluster-delslotsrange
 |
 |  cluster_failover(self, target_node: "'TargetNodesT'", option: 'str | None' = None) -> 'bool | Awaitable[bool]'
 |      Forces a slave to perform a manual failover of its master
 |      Sends to specified node
 |
 |      :target_node: 'ClusterNode'
 |          The node to execute the command on
 |
 |      For more information see https://redis.io/commands/cluster-failover
 |
 |  cluster_flushslots(self, target_nodes: "'TargetNodesT' | None" = None) -> 'None'
 |
 |  cluster_get_keys_in_slot(self, slot: 'int', num_keys: 'int') -> 'list[bytes | str] | Awaitable[list[bytes | str]]'
 |      Returns the number of keys in the specified cluster slot
 |
 |      For more information see https://redis.io/commands/cluster-getkeysinslot
 |
 |  cluster_info(self, target_nodes: "'TargetNodesT' | None" = None) -> 'dict[str, str] | Awaitable[dict[str, str]]'
 |      Provides info about Redis Cluster node state.
 |      The command will be sent to a random node in the cluster if no target
 |      node is specified.
 |
 |      For more information see https://redis.io/commands/cluster-info
 |
 |  cluster_keyslot(self, key: 'str') -> 'int | Awaitable[int]'
 |      Returns the hash slot of the specified key
 |      Sends to random node in the cluster
 |
 |      For more information see https://redis.io/commands/cluster-keyslot
 |
 |  cluster_links(self, target_node: "'TargetNodesT'") -> 'ClusterLinksResponse | Awaitable[ClusterLinksResponse]'
 |      Each node in a Redis Cluster maintains a pair of long-lived TCP link with each
 |      peer in the cluster: One for sending outbound messages towards the peer and one
 |      for receiving inbound messages from the peer.
 |
 |      This command outputs information of all such peer links as an array.
 |
 |      For more information see https://redis.io/commands/cluster-links
 |
 |  cluster_meet(self, host: 'str', port: 'int', target_nodes: "'TargetNodesT' | None" = None) -> 'bool | Awaitable[bool]'
 |      Force a node cluster to handshake with another node.
 |      Sends to specified node.
 |
 |      For more information see https://redis.io/commands/cluster-meet
 |
 |  cluster_myid(self, target_node: "'TargetNodesT'") -> 'bytes | str | Awaitable[bytes | str]'
 |      Returns the node's id.
 |
 |      :target_node: 'ClusterNode'
 |          The node to execute the command on
 |
 |      For more information check https://redis.io/commands/cluster-myid/
 |
 |  cluster_myshardid(self, target_nodes: "'TargetNodesT' | None" = None) -> 'bytes | str | Awaitable[bytes | str]'
 |      Returns the shard ID of the node.
 |
 |      For more information see https://redis.io/commands/cluster-myshardid/
 |
 |  cluster_nodes(self) -> 'dict[str, ClusterNodeDetail] | Awaitable[dict[str, ClusterNodeDetail]]'
 |      Get Cluster config for the node.
 |      Sends to random node in the cluster
 |
 |      For more information see https://redis.io/commands/cluster-nodes
 |
 |  cluster_replicas(self, node_id: 'str', target_nodes: "'TargetNodesT' | None" = None) -> 'dict[str, ClusterNodeDetail] | Awaitable[dict[str, ClusterNodeDetail]]'
 |      Provides a list of replica nodes replicating from the specified primary
 |      target node.
 |
 |      For more information see https://redis.io/commands/cluster-replicas
 |
 |  cluster_replicate(self, target_nodes: "'TargetNodesT'", node_id: 'str') -> 'bool | Awaitable[bool]'
 |      Reconfigure a node as a slave of the specified master node
 |
 |      For more information see https://redis.io/commands/cluster-replicate
 |
 |  cluster_reset(self, soft: 'bool' = True, target_nodes: "'TargetNodesT' | None" = None) -> 'bool | Awaitable[bool]'
 |      Reset a Redis Cluster node
 |
 |      If 'soft' is True then it will send 'SOFT' argument
 |      If 'soft' is False then it will send 'HARD' argument
 |
 |      For more information see https://redis.io/commands/cluster-reset
 |
 |  cluster_save_config(self, target_nodes: "'TargetNodesT' | None" = None) -> 'bool | Awaitable[bool]'
 |      Forces the node to save cluster state on disk
 |
 |      For more information see https://redis.io/commands/cluster-saveconfig
 |
 |  cluster_set_config_epoch(self, epoch: 'int', target_nodes: "'TargetNodesT' | None" = None) -> 'bool | Awaitable[bool]'
 |      Set the configuration epoch in a new node
 |
 |      For more information see https://redis.io/commands/cluster-set-config-epoch
 |
 |  cluster_setslot(self, target_node: "'TargetNodesT'", node_id: 'str', slot_id: 'int', state: 'str') -> 'bool | Awaitable[bool]'
 |      Bind an hash slot to a specific node
 |
 |      :target_node: 'ClusterNode'
 |          The node to execute the command on
 |
 |      For more information see https://redis.io/commands/cluster-setslot
 |
 |  cluster_setslot_stable(self, slot_id: 'int') -> 'bool | Awaitable[bool]'
 |      Clears migrating / importing state from the slot.
 |      It determines by it self what node the slot is in and sends it there.
 |
 |      For more information see https://redis.io/commands/cluster-setslot
 |
 |  cluster_shards(self, target_nodes: "'TargetNodesT' | None" = None) -> 'ClusterShardsResponse | Awaitable[ClusterShardsResponse]'
 |      Returns details about the shards of the cluster.
 |
 |      For more information see https://redis.io/commands/cluster-shards
 |
 |  cluster_slots(self, target_nodes: "'TargetNodesT' | None" = None) -> 'list[Any] | Awaitable[list[Any]]'
 |      Get array of Cluster slot to node mappings
 |
 |      For more information see https://redis.io/commands/cluster-slots
 |
 |  hotkeys_get(self, **kwargs) -> 'list[dict[str | bytes, Any]]'
 |      Cluster client does not support hotkeys command. Please use the non-cluster client.
 |
 |      For more information see https://redis.io/commands/hotkeys-get
 |
 |  hotkeys_reset(self, **kwargs) -> 'str | bytes'
 |      Cluster client does not support hotkeys command. Please use the non-cluster client.
 |
 |      For more information see https://redis.io/commands/hotkeys-reset
 |
 |  hotkeys_start(self, metrics: 'List[HotkeysMetricsTypes]', count: 'int | None' = None, duration: 'int | None' = None, sample_ratio: 'int | None' = None, slots: 'List[int] | None' = None, **kwargs) -> 'str | bytes'
 |      Cluster client does not support hotkeys command. Please use the non-cluster client.
 |
 |      For more information see https://redis.io/commands/hotkeys-start
 |
 |  hotkeys_stop(self, **kwargs) -> 'str | bytes'
 |      Cluster client does not support hotkeys command. Please use the non-cluster client.
 |
 |      For more information see https://redis.io/commands/hotkeys-stop
 |
 |  readonly(self, target_nodes: "'TargetNodesT' | None" = None) -> 'ResponseT'
 |      Enables read queries.
 |      The command will be sent to the default cluster node if target_nodes is
 |      not specified.
 |
 |      For more information see https://redis.io/commands/readonly
 |
 |  readwrite(self, target_nodes: "'TargetNodesT' | None" = None) -> 'ResponseT'
 |      Disables read queries.
 |      The command will be sent to the default cluster node if target_nodes is
 |      not specified.
 |
 |      For more information see https://redis.io/commands/readwrite
 |
 |  replicaof(self, *args, **kwargs) -> 'NoReturn'
 |      Make the server a replica of another instance, or promote it as master.
 |
 |      For more information see https://redis.io/commands/replicaof
 |
 |  slaveof(self, *args, **kwargs) -> 'NoReturn'
 |      Make the server a replica of another instance, or promote it as master.
 |
 |      For more information see https://redis.io/commands/slaveof
 |
 |  swapdb(self, *args, **kwargs) -> 'NoReturn'
 |      Swaps two Redis databases.
 |
 |      For more information see https://redis.io/commands/swapdb
 |
 |  ----------------------------------------------------------------------
 |  Methods inherited from redis.commands.core.ManagementCommands:
 |
 |  auth(self, password: 'str', username: 'str | None' = None, **kwargs) -> 'bool | Awaitable[bool]'
 |      Authenticates the user. If you do not pass username, Redis will try to
 |      authenticate for the "default" user. If you do pass username, it will
 |      authenticate for the given user.
 |      For more information, see https://redis.io/commands/auth
 |
 |  bgrewriteaof(self, **kwargs) -> 'bool | bytes | str | Awaitable[bool | bytes | str]'
 |      Tell the Redis server to rewrite the AOF file from data in memory.
 |
 |      For more information, see https://redis.io/commands/bgrewriteaof
 |
 |  bgsave(self, schedule: 'bool' = True, **kwargs) -> 'bool | bytes | str | Awaitable[bool | bytes | str]'
 |      Tell the Redis server to save its data to disk.  Unlike save(),
 |      this method is asynchronous and returns immediately.
 |
 |      For more information, see https://redis.io/commands/bgsave
 |
 |  client_getname(self, **kwargs) -> 'bytes | str | None | Awaitable[bytes | str | None]'
 |      Returns the current connection name
 |
 |      For more information, see https://redis.io/commands/client-getname
 |
 |  client_getredir(self, **kwargs) -> 'int | Awaitable[int]'
 |      Returns the ID (an integer) of the client to whom we are
 |      redirecting tracking notifications.
 |
 |      see: https://redis.io/commands/client-getredir
 |
 |  client_id(self, **kwargs) -> 'int | Awaitable[int]'
 |      Returns the current connection id
 |
 |      For more information, see https://redis.io/commands/client-id
 |
 |  client_info(self, **kwargs) -> 'dict[str, str | int] | Awaitable[dict[str, str | int]]'
 |      Returns information and statistics about the current
 |      client connection.
 |
 |      For more information, see https://redis.io/commands/client-info
 |
 |  client_kill(self, address: 'str', **kwargs) -> 'bool | int | Awaitable[bool | int]'
 |      Disconnects the client at ``address`` (ip:port)
 |
 |      For more information, see https://redis.io/commands/client-kill
 |
 |  client_kill_filter(self, _id: 'str | None' = None, _type: 'str | None' = None, addr: 'str | None' = None, skipme: 'bool | None' = None, laddr: 'bool | None' = None, user: 'str | None' = None, maxage: 'int | None' = None, **kwargs) -> 'int | Awaitable[int]'
 |      Disconnects client(s) using a variety of filter options
 |      :param _id: Kills a client by its unique ID field
 |      :param _type: Kills a client by type where type is one of 'normal',
 |      'master', 'slave', 'replica' or 'pubsub'
 |      :param addr: Kills a client by its 'address:port'
 |      :param skipme: If True, then the client calling the command
 |      will not get killed even if it is identified by one of the filter
 |      options. If skipme is not provided, the server defaults to skipme=True
 |      :param laddr: Kills a client by its 'local (bind) address:port'
 |      :param user: Kills a client for a specific user name
 |      :param maxage: Kills clients that are older than the specified age in seconds
 |
 |  client_list(self, _type: 'str | None' = None, client_id: 'List[EncodableT]' = [], **kwargs) -> 'list[dict[str, str]] | Awaitable[list[dict[str, str]]]'
 |      Returns a list of currently connected clients.
 |      If type of client specified, only that type will be returned.
 |
 |      :param _type: optional. one of the client types (normal, master,
 |       replica, pubsub)
 |      :param client_id: optional. a list of client ids
 |
 |      For more information, see https://redis.io/commands/client-list
 |
 |  client_no_evict(self, mode: 'str') -> 'bytes | str | Awaitable[bytes | str]'
 |      Sets the client eviction mode for the current connection.
 |
 |      For more information, see https://redis.io/commands/client-no-evict
 |
 |  client_no_touch(self, mode: 'str') -> 'bytes | str | Awaitable[bytes | str]'
 |      # The command controls whether commands sent by the client will alter
 |      # the LRU/LFU of the keys they access.
 |      # When turned on, the current client will not change LFU/LRU stats,
 |      # unless it sends the TOUCH command.
 |
 |      For more information, see https://redis.io/commands/client-no-touch
 |
 |  client_pause(self, timeout: 'int', all: 'bool' = True, **kwargs) -> 'bool | Awaitable[bool]'
 |      Suspend all the Redis clients for the specified amount of time.
 |
 |
 |      For more information, see https://redis.io/commands/client-pause
 |
 |      Args:
 |          timeout: milliseconds to pause clients
 |          all: If true (default) all client commands are blocked.
 |               otherwise, clients are only blocked if they attempt to execute
 |               a write command.
 |
 |      For the WRITE mode, some commands have special behavior:
 |
 |      * EVAL/EVALSHA: Will block client for all scripts.
 |      * PUBLISH: Will block client.
 |      * PFCOUNT: Will block client.
 |      * WAIT: Acknowledgments will be delayed, so this command will
 |          appear blocked.
 |
 |  client_reply(self, reply: "Literal['ON', 'OFF', 'SKIP']", **kwargs) -> 'bytes | str | Awaitable[bytes | str]'
 |      Enable and disable redis server replies.
 |
 |      ``reply`` Must be ON OFF or SKIP,
 |      ON - The default most with server replies to commands
 |      OFF - Disable server responses to commands
 |      SKIP - Skip the response of the immediately following command.
 |
 |      Note: When setting OFF or SKIP replies, you will need a client object
 |      with a timeout specified in seconds, and will need to catch the
 |      TimeoutError.
 |      The test_client_reply unit test illustrates this, and
 |      conftest.py has a client with a timeout.
 |
 |      See https://redis.io/commands/client-reply
 |
 |  client_setinfo(self, attr: 'str', value: 'str', **kwargs) -> 'bool | Awaitable[bool]'
 |      Sets the current connection library name or version
 |      For more information see https://redis.io/commands/client-setinfo
 |
 |  client_setname(self, name: 'str', **kwargs) -> 'bool | Awaitable[bool]'
 |      Sets the current connection name
 |
 |      For more information, see https://redis.io/commands/client-setname
 |
 |      .. note::
 |         This method sets client name only for **current** connection.
 |
 |         If you want to set a common name for all connections managed
 |         by this client, use ``client_name`` constructor argument.
 |
 |  client_tracking(self, on: 'bool' = True, clientid: 'int | None' = None, prefix: 'Sequence[KeyT]' = [], bcast: 'bool' = False, optin: 'bool' = False, optout: 'bool' = False, noloop: 'bool' = False, **kwargs) -> 'bytes | str | Awaitable[bytes | str]'
 |      Enables the tracking feature of the Redis server, that is used
 |      for server assisted client side caching.
 |
 |      ``on`` indicate for tracking on or tracking off. The default is on.
 |
 |      ``clientid`` send invalidation messages to the connection with
 |      the specified ID.
 |
 |      ``bcast`` enable tracking in broadcasting mode. In this mode
 |      invalidation messages are reported for all the prefixes
 |      specified, regardless of the keys requested by the connection.
 |
 |      ``optin``  when broadcasting is NOT active, normally don't track
 |      keys in read only commands, unless they are called immediately
 |      after a CLIENT CACHING yes command.
 |
 |      ``optout`` when broadcasting is NOT active, normally track keys in
 |      read only commands, unless they are called immediately after a
 |      CLIENT CACHING no command.
 |
 |      ``noloop`` don't send notifications about keys modified by this
 |      connection itself.
 |
 |      ``prefix``  for broadcasting, register a given key prefix, so that
 |      notifications will be provided only for keys starting with this string.
 |
 |      See https://redis.io/commands/client-tracking
 |
 |  client_trackinginfo(self, **kwargs) -> 'ClientTrackingInfoResponse | Awaitable[ClientTrackingInfoResponse]'
 |      Returns the information about the current client connection's
 |      use of the server assisted client side cache.
 |
 |      See https://redis.io/commands/client-trackinginfo
 |
 |  client_unblock(self, client_id: 'int', error: 'bool' = False, **kwargs) -> 'bool | Awaitable[bool]'
 |      Unblocks a connection by its client id.
 |      If ``error`` is True, unblocks the client with a special error message.
 |      If ``error`` is False (default), the client is unblocked using the
 |      regular timeout mechanism.
 |
 |      For more information, see https://redis.io/commands/client-unblock
 |
 |  client_unpause(self, **kwargs) -> 'bytes | str | Awaitable[bytes | str]'
 |      Unpause all redis clients
 |
 |      For more information, see https://redis.io/commands/client-unpause
 |
 |  command(self, **kwargs) -> 'dict[str, dict[str, Any]] | Awaitable[dict[str, dict[str, Any]]]'
 |      Returns dict reply of details about all Redis commands.
 |
 |      For more information, see https://redis.io/commands/command
 |
 |  command_count(self, **kwargs) -> 'int | Awaitable[int]'
 |
 |  command_docs(self, *args)
 |      This function throws a NotImplementedError since it is intentionally
 |      not supported.
 |
 |  command_getkeysandflags(self, *args: 'str') -> 'CommandGetKeysAndFlagsResponse | Awaitable[CommandGetKeysAndFlagsResponse]'
 |      Returns array of keys from a full Redis command and their usage flags.
 |
 |      For more information, see https://redis.io/commands/command-getkeysandflags
 |
 |  command_info(self, **kwargs) -> 'None'
 |
 |  command_list(self, module: 'str | None' = None, category: 'str | None' = None, pattern: 'str | None' = None) -> 'list[bytes | str] | Awaitable[list[bytes | str]]'
 |      Return an array of the server's command names.
 |      You can use one of the following filters:
 |      ``module``: get the commands that belong to the module
 |      ``category``: get the commands in the ACL category
 |      ``pattern``: get the commands that match the given pattern
 |
 |      For more information, see https://redis.io/commands/command-list/
 |
 |  config_get(self, pattern: 'PatternT' = '*', *args: 'PatternT', **kwargs) -> 'dict[str | None, str | None] | Awaitable[dict[str | None, str | None]]'
 |      Return a dictionary of configuration based on the ``pattern``
 |
 |      For more information, see https://redis.io/commands/config-get
 |
 |  config_resetstat(self, **kwargs) -> 'bool | Awaitable[bool]'
 |      Reset runtime statistics
 |
 |      For more information, see https://redis.io/commands/config-resetstat
 |
 |  config_rewrite(self, **kwargs) -> 'bytes | str | Awaitable[bytes | str]'
 |      Rewrite config file with the minimal change to reflect running config.
 |
 |      For more information, see https://redis.io/commands/config-rewrite
 |
 |  config_set(self, name: 'KeyT', value: 'EncodableT', *args: 'Union[KeyT, EncodableT]', **kwargs) -> 'bool | Awaitable[bool]'
 |      Set config item ``name`` with ``value``
 |
 |      For more information, see https://redis.io/commands/config-set
 |
 |  dbsize(self, **kwargs) -> 'int | Awaitable[int]'
 |      Returns the number of keys in the current database
 |
 |      For more information, see https://redis.io/commands/dbsize
 |
 |  debug_object(self, key: 'KeyT', **kwargs) -> 'dict[str, str | int] | bytes | str | Awaitable[dict[str, str | int] | bytes | str]'
 |      Returns version specific meta information about a given key
 |
 |      For more information, see https://redis.io/commands/debug-object
 |
 |  debug_segfault(self, **kwargs) -> 'None'
 |
 |  echo(self, value: 'EncodableT', **kwargs) -> 'bytes | str | Awaitable[bytes | str]'
 |      Echo the string back from the server
 |
 |      For more information, see https://redis.io/commands/echo
 |
 |  failover(self)
 |      This function throws a NotImplementedError since it is intentionally
 |      not supported.
 |
 |  flushall(self, asynchronous: 'bool' = False, **kwargs) -> 'bool | Awaitable[bool]'
 |      Delete all keys in all databases on the current host.
 |
 |      ``asynchronous`` indicates whether the operation is
 |      executed asynchronously by the server.
 |
 |      For more information, see https://redis.io/commands/flushall
 |
 |  flushdb(self, asynchronous: 'bool' = False, **kwargs) -> 'bool | Awaitable[bool]'
 |      Delete all keys in the current database.
 |
 |      ``asynchronous`` indicates whether the operation is
 |      executed asynchronously by the server.
 |
 |      For more information, see https://redis.io/commands/flushdb
 |
 |  hello(self)
 |      This function throws a NotImplementedError since it is intentionally
 |      not supported.
 |
 |  info(self, section: 'Optional[str]' = None, *args: 'str', **kwargs) -> 'dict[str, Any] | Awaitable[dict[str, Any]]'
 |      Returns a dictionary containing information about the Redis server
 |
 |      The ``section`` option can be used to select a specific section
 |      of information
 |
 |      The section option is not supported by older versions of Redis Server,
 |      and will generate ResponseError
 |
 |      For more information, see https://redis.io/commands/info
 |
 |  lastsave(self, **kwargs) -> 'datetime.datetime | Awaitable[datetime.datetime]'
 |      Return a Python datetime object representing the last time the
 |      Redis database was saved to disk
 |
 |      For more information, see https://redis.io/commands/lastsave
 |
 |  latency_doctor(self)
 |      Raise a NotImplementedError, as the client will not support LATENCY DOCTOR.
 |      This function is best used within the redis-cli.
 |
 |      For more information, see https://redis.io/commands/latency-doctor
 |
 |  latency_graph(self)
 |      Raise a NotImplementedError, as the client will not support LATENCY GRAPH.
 |      This function is best used within the redis-cli.
 |
 |      For more information, see https://redis.io/commands/latency-graph.
 |
 |  latency_histogram(self, *args)
 |      This function throws a NotImplementedError since it is intentionally
 |      not supported.
 |
 |  latency_history(self, event: 'str') -> 'list[list[int]] | Awaitable[list[list[int]]]'
 |      Returns the raw data of the ``event``'s latency spikes time series.
 |
 |      For more information, see https://redis.io/commands/latency-history
 |
 |  latency_latest(self) -> 'list[list[bytes | str | int]] | Awaitable[list[list[bytes | str | int]]]'
 |      Reports the latest latency events logged.
 |
 |      For more information, see https://redis.io/commands/latency-latest
 |
 |  latency_reset(self, *events: 'str') -> 'int | Awaitable[int]'
 |      Resets the latency spikes time series of all, or only some, events.
 |
 |      For more information, see https://redis.io/commands/latency-reset
 |
 |  lolwut(self, *version_numbers: 'Union[str, float]', **kwargs) -> 'bytes | str | Awaitable[bytes | str]'
 |      Get the Redis version and a piece of generative computer art
 |
 |      See: https://redis.io/commands/lolwut
 |
 |  memory_doctor(self, **kwargs) -> 'None'
 |
 |  memory_help(self, **kwargs) -> 'None'
 |
 |  memory_malloc_stats(self, **kwargs) -> 'bytes | str | Awaitable[bytes | str]'
 |      Return an internal statistics report from the memory allocator.
 |
 |      See: https://redis.io/commands/memory-malloc-stats
 |
 |  memory_purge(self, **kwargs) -> 'bool | Awaitable[bool]'
 |      Attempts to purge dirty pages for reclamation by allocator
 |
 |      For more information, see https://redis.io/commands/memory-purge
 |
 |  memory_stats(self, **kwargs) -> 'dict[str, Any] | Awaitable[dict[str, Any]]'
 |      Return a dictionary of memory stats
 |
 |      For more information, see https://redis.io/commands/memory-stats
 |
 |  memory_usage(self, key: 'KeyT', samples: 'int | None' = None, **kwargs) -> 'int | None | Awaitable[int | None]'
 |      Return the total memory usage for key, its value and associated
 |      administrative overheads.
 |
 |      For nested data structures, ``samples`` is the number of elements to
 |      sample. If left unspecified, the server's default is 5. Use 0 to sample
 |      all elements.
 |
 |      For more information, see https://redis.io/commands/memory-usage
 |
 |  migrate(self, host: 'str', port: 'int', keys: 'KeysT', destination_db: 'int', timeout: 'int', copy: 'bool' = False, replace: 'bool' = False, auth: 'str | None' = None, **kwargs) -> 'bytes | str | Awaitable[bytes | str]'
 |      Migrate 1 or more keys from the current Redis server to a different
 |      server specified by the ``host``, ``port`` and ``destination_db``.
 |
 |      The ``timeout``, specified in milliseconds, indicates the maximum
 |      time the connection between the two servers can be idle before the
 |      command is interrupted.
 |
 |      If ``copy`` is True, the specified ``keys`` are NOT deleted from
 |      the source server.
 |
 |      If ``replace`` is True, this operation will overwrite the keys
 |      on the destination server if they exist.
 |
 |      If ``auth`` is specified, authenticate to the destination server with
 |      the password provided.
 |
 |      For more information, see https://redis.io/commands/migrate
 |
 |  object(self, infotype: 'str', key: 'KeyT', **kwargs) -> 'Any | Awaitable[Any]'
 |      Return the encoding, idletime, or refcount about the key
 |
 |  ping(self, **kwargs) -> 'Union[Awaitable[bool], bool]'
 |      Ping the Redis server to test connectivity.
 |
 |      Sends a PING command to the Redis server and returns True if the server
 |      responds with "PONG".
 |
 |      This command is useful for:
 |      - Testing whether a connection is still alive
 |      - Verifying the server's ability to serve data
 |
 |      For more information on the underlying ping command see https://redis.io/commands/ping
 |
 |  psync(self, replicationid: 'str', offset: 'int') -> 'bytes | Awaitable[bytes]'
 |      Initiates a replication stream from the master.
 |      Newer version for `sync`.
 |
 |      For more information, see https://redis.io/commands/sync
 |
 |  quit(self, **kwargs) -> 'bool | Awaitable[bool]'
 |      Ask the server to close the connection.
 |
 |      For more information, see https://redis.io/commands/quit
 |
 |  reset(self) -> 'bytes | str | Awaitable[bytes | str]'
 |      Perform a full reset on the connection's server-side context.
 |
 |      See: https://redis.io/commands/reset
 |
 |  role(self) -> 'list[Any] | Awaitable[list[Any]]'
 |      Provide information on the role of a Redis instance in
 |      the context of replication, by returning if the instance
 |      is currently a master, slave, or sentinel.
 |
 |      For more information, see https://redis.io/commands/role
 |
 |  save(self, **kwargs) -> 'bool | Awaitable[bool]'
 |      Tell the Redis server to save its data to disk,
 |      blocking until the save is complete
 |
 |      For more information, see https://redis.io/commands/save
 |
 |  select(self, index: 'int', **kwargs) -> 'bool | Awaitable[bool]'
 |      Select the Redis logical database at index.
 |
 |      See: https://redis.io/commands/select
 |
 |  shutdown(self, save: 'bool' = False, nosave: 'bool' = False, now: 'bool' = False, force: 'bool' = False, abort: 'bool' = False, **kwargs) -> 'None'
 |      Shutdown the Redis server.  If Redis has persistence configured,
 |      data will be flushed before shutdown.
 |      It is possible to specify modifiers to alter the behavior of the command:
 |      ``save`` will force a DB saving operation even if no save points are configured.
 |      ``nosave`` will prevent a DB saving operation even if one or more save points
 |      are configured.
 |      ``now`` skips waiting for lagging replicas, i.e. it bypasses the first step in
 |      the shutdown sequence.
 |      ``force`` ignores any errors that would normally prevent the server from exiting
 |      ``abort`` cancels an ongoing shutdown and cannot be combined with other flags.
 |
 |      For more information, see https://redis.io/commands/shutdown
 |
 |  slowlog_get(self, num: 'int | None' = None, **kwargs) -> 'list[dict[str, Any]] | Awaitable[list[dict[str, Any]]]'
 |      Get the entries from the slowlog. If ``num`` is specified, get the
 |      most recent ``num`` items.
 |
 |      For more information, see https://redis.io/commands/slowlog-get
 |
 |  slowlog_len(self, **kwargs) -> 'int | Awaitable[int]'
 |      Get the number of items in the slowlog
 |
 |      For more information, see https://redis.io/commands/slowlog-len
 |
 |  slowlog_reset(self, **kwargs) -> 'bool | Awaitable[bool]'
 |      Remove all items in the slowlog
 |
 |      For more information, see https://redis.io/commands/slowlog-reset
 |
 |  sync(self) -> 'bytes | Awaitable[bytes]'
 |      Initiates a replication stream from the master.
 |
 |      For more information, see https://redis.io/commands/sync
 |
 |  time(self, **kwargs) -> 'tuple[int, int] | Awaitable[tuple[int, int]]'
 |      Returns the server time as a 2-item tuple of ints:
 |      (seconds since epoch, microseconds into this second).
 |
 |      For more information, see https://redis.io/commands/time
 |
 |  wait(self, num_replicas: 'int', timeout: 'int', **kwargs) -> 'int | Awaitable[int]'
 |      Redis synchronous replication
 |      That returns the number of replicas that processed the query when
 |      we finally have at least ``num_replicas``, or when the ``timeout`` was
 |      reached.
 |
 |      For more information, see https://redis.io/commands/wait
 |
 |  waitaof(self, num_local: 'int', num_replicas: 'int', timeout: 'int', **kwargs) -> 'list[int] | Awaitable[list[int]]'
 |      This command blocks the current client until all previous write
 |      commands by that client are acknowledged as having been fsynced
 |      to the AOF of the local Redis and/or at least the specified number
 |      of replicas.
 |
 |      For more information, see https://redis.io/commands/waitaof
 |
 |  ----------------------------------------------------------------------
 |  Methods inherited from redis.commands.core.ACLCommands:
 |
 |  acl_cat(self, category: 'str | None' = None, **kwargs) -> 'list[bytes | str] | Awaitable[list[bytes | str]]'
 |      Returns a list of categories or commands within a category.
 |
 |      If ``category`` is not supplied, returns a list of all categories.
 |      If ``category`` is supplied, returns a list of all commands within
 |      that category.
 |
 |      For more information, see https://redis.io/commands/acl-cat
 |
 |  acl_deluser(self, *username: 'str', **kwargs) -> 'int | Awaitable[int]'
 |      Delete the ACL for the specified ``username``\s
 |
 |      For more information, see https://redis.io/commands/acl-deluser
 |
 |  acl_dryrun(self, username: 'str', *args: 'EncodableT', **kwargs) -> 'bytes | str | Awaitable[bytes | str]'
 |      Simulate the execution of a given command by a given ``username``.
 |
 |      For more information, see https://redis.io/commands/acl-dryrun
 |
 |  acl_genpass(self, bits: 'int | None' = None, **kwargs) -> 'bytes | str | Awaitable[bytes | str]'
 |      Generate a random password value.
 |      If ``bits`` is supplied then use this number of bits, rounded to
 |      the next multiple of 4.
 |      See: https://redis.io/commands/acl-genpass
 |
 |  acl_getuser(self, username: 'str', **kwargs) -> 'ACLGetUserData | Awaitable[ACLGetUserData]'
 |      Get the ACL details for the specified ``username``.
 |
 |      If ``username`` does not exist, return None
 |
 |      For more information, see https://redis.io/commands/acl-getuser
 |
 |  acl_help(self, **kwargs) -> 'list[bytes | str] | Awaitable[list[bytes | str]]'
 |      The ACL HELP command returns helpful text describing
 |      the different subcommands.
 |
 |      For more information, see https://redis.io/commands/acl-help
 |
 |  acl_list(self, **kwargs) -> 'list[bytes | str] | Awaitable[list[bytes | str]]'
 |      Return a list of all ACLs on the server
 |
 |      For more information, see https://redis.io/commands/acl-list
 |
 |  acl_load(self, **kwargs) -> 'bool | Awaitable[bool]'
 |      Load ACL rules from the configured ``aclfile``.
 |
 |      Note that the server must be configured with the ``aclfile``
 |      directive to be able to load ACL rules from an aclfile.
 |
 |      For more information, see https://redis.io/commands/acl-load
 |
 |  acl_log(self, count: 'int | None' = None, **kwargs) -> 'ACLLogData | Awaitable[ACLLogData]'
 |      Get ACL logs as a list.
 |      :param int count: Get logs[0:count].
 |      :rtype: List.
 |
 |      For more information, see https://redis.io/commands/acl-log
 |
 |  acl_log_reset(self, **kwargs) -> 'bool | Awaitable[bool]'
 |      Reset ACL logs.
 |      :rtype: Boolean.
 |
 |      For more information, see https://redis.io/commands/acl-log
 |
 |  acl_save(self, **kwargs) -> 'bool | Awaitable[bool]'
 |      Save ACL rules to the configured ``aclfile``.
 |
 |      Note that the server must be configured with the ``aclfile``
 |      directive to be able to save ACL rules to an aclfile.
 |
 |      For more information, see https://redis.io/commands/acl-save
 |
 |  acl_setuser(self, username: 'str', enabled: 'bool' = False, nopass: 'bool' = False, passwords: 'str | Iterable[str] | None' = None, hashed_passwords: 'str | Iterable[str] | None' = None, categories: 'Iterable[str] | None' = None, commands: 'Iterable[str] | None' = None, keys: 'Iterable[KeyT] | None' = None, channels: 'Iterable[ChannelT] | None' = None, selectors: 'Iterable[Tuple[str, KeyT]] | None' = None, reset: 'bool' = False, reset_keys: 'bool' = False, reset_channels: 'bool' = False, reset_passwords: 'bool' = False, **kwargs) -> 'bool | Awaitable[bool]'
 |      Create or update an ACL user.
 |
 |      Create or update the ACL for `username`. If the user already exists,
 |      the existing ACL is completely overwritten and replaced with the
 |      specified values.
 |
 |      For more information, see https://redis.io/commands/acl-setuser
 |
 |      Args:
 |          username: The name of the user whose ACL is to be created or updated.
 |          enabled: Indicates whether the user should be allowed to authenticate.
 |                   Defaults to `False`.
 |          nopass: Indicates whether the user can authenticate without a password.
 |                  This cannot be `True` if `passwords` are also specified.
 |          passwords: A list of plain text passwords to add to or remove from the user.
 |                     Each password must be prefixed with a '+' to add or a '-' to
 |                     remove. For convenience, a single prefixed string can be used
 |                     when adding or removing a single password.
 |          hashed_passwords: A list of SHA-256 hashed passwords to add to or remove
 |                            from the user. Each hashed password must be prefixed with
 |                            a '+' to add or a '-' to remove. For convenience, a single
 |                            prefixed string can be used when adding or removing a
 |                            single password.
 |          categories: A list of strings representing category permissions. Each string
 |                      must be prefixed with either a '+' to add the category
 |                      permission or a '-' to remove the category permission.
 |          commands: A list of strings representing command permissions. Each string
 |                    must be prefixed with either a '+' to add the command permission
 |                    or a '-' to remove the command permission.
 |          keys: A list of key patterns to grant the user access to. Key patterns allow
 |                ``'*'`` to support wildcard matching. For example, ``'*'`` grants
 |                access to all keys while ``'cache:*'`` grants access to all keys that
 |                are prefixed with ``cache:``.
 |                `keys` should not be prefixed with a ``'~'``.
 |          reset: Indicates whether the user should be fully reset prior to applying
 |                 the new ACL. Setting this to `True` will remove all existing
 |                 passwords, flags, and privileges from the user and then apply the
 |                 specified rules. If `False`, the user's existing passwords, flags,
 |                 and privileges will be kept and any new specified rules will be
 |                 applied on top.
 |          reset_keys: Indicates whether the user's key permissions should be reset
 |                      prior to applying any new key permissions specified in `keys`.
 |                      If `False`, the user's existing key permissions will be kept and
 |                      any new specified key permissions will be applied on top.
 |          reset_channels: Indicates whether the user's channel permissions should be
 |                          reset prior to applying any new channel permissions
 |                          specified in `channels`. If `False`, the user's existing
 |                          channel permissions will be kept and any new specified
 |                          channel permissions will be applied on top.
 |          reset_passwords: Indicates whether to remove all existing passwords and the
 |                           `nopass` flag from the user prior to applying any new
 |                           passwords specified in `passwords` or `hashed_passwords`.
 |                           If `False`, the user's existing passwords and `nopass`
 |                           status will be kept and any new specified passwords or
 |                           hashed passwords will be applied on top.
 |
 |  acl_users(self, **kwargs) -> 'list[bytes | str] | Awaitable[list[bytes | str]]'
 |      Returns a list of all registered users on the server.
 |
 |      For more information, see https://redis.io/commands/acl-users
 |
 |  acl_whoami(self, **kwargs) -> 'bytes | str | Awaitable[bytes | str]'
 |      Get the username for the current connection
 |
 |      For more information, see https://redis.io/commands/acl-whoami
 |
 |  ----------------------------------------------------------------------
 |  Methods inherited from redis.commands.core.PubSubCommands:
 |
 |  publish(self, channel: 'ChannelT', message: 'EncodableT', **kwargs) -> 'int | Awaitable[int]'
 |      Publish ``message`` on ``channel``.
 |      Returns the number of subscribers the message was delivered to.
 |
 |      For more information, see https://redis.io/commands/publish
 |
 |  pubsub_channels(self, pattern: 'PatternT' = '*', **kwargs) -> 'list[bytes | str] | Awaitable[list[bytes | str]]'
 |      Return a list of channels that have at least one subscriber
 |
 |      For more information, see https://redis.io/commands/pubsub-channels
 |
 |  pubsub_numpat(self, **kwargs) -> 'int | Awaitable[int]'
 |      Returns the number of subscriptions to patterns
 |
 |      For more information, see https://redis.io/commands/pubsub-numpat
 |
 |  pubsub_numsub(self, *args: 'ChannelT', **kwargs) -> 'list[tuple[bytes | str, int]] | Awaitable[list[tuple[bytes | str, int]]]'
 |      Return a list of (channel, number of subscribers) tuples
 |      for each channel given in ``*args``
 |
 |      For more information, see https://redis.io/commands/pubsub-numsub
 |
 |  pubsub_shardchannels(self, pattern: 'PatternT' = '*', **kwargs) -> 'list[bytes | str] | Awaitable[list[bytes | str]]'
 |      Return a list of shard_channels that have at least one subscriber
 |
 |      For more information, see https://redis.io/commands/pubsub-shardchannels
 |
 |  pubsub_shardnumsub(self, *args: 'ChannelT', **kwargs) -> 'list[tuple[bytes | str, int]] | Awaitable[list[tuple[bytes | str, int]]]'
 |      Return a list of (shard_channel, number of subscribers) tuples
 |      for each channel given in ``*args``
 |
 |      For more information, see https://redis.io/commands/pubsub-shardnumsub
 |
 |  spublish(self, shard_channel: 'ChannelT', message: 'EncodableT') -> 'int | Awaitable[int]'
 |      Posts a message to the given shard channel.
 |      Returns the number of clients that received the message
 |
 |      For more information, see https://redis.io/commands/spublish
 |
 |  ----------------------------------------------------------------------
 |  Methods inherited from redis.commands.cluster.ClusterDataAccessCommands:
 |
 |  scan_iter(self, match: 'PatternT | None' = None, count: 'int | None' = None, _type: 'str | None' = None, **kwargs) -> 'Iterator'
 |      Make an iterator using the SCAN command so that the client doesn't
 |      need to remember the cursor position.
 |
 |      ``match`` allows for filtering the keys by pattern
 |
 |      ``count`` provides a hint to Redis about the number of keys to
 |          return per batch.
 |
 |      ``_type`` filters the returned values by a particular Redis type.
 |          Stock Redis instances allow for the following types:
 |          HASH, LIST, SET, STREAM, STRING, ZSET
 |          Additionally, Redis modules can expose other types as well.
 |
 |  stralgo(self, algo: "Literal['LCS']", value1: 'KeyT', value2: 'KeyT', specific_argument: "Literal['strings'] | Literal['keys']" = 'strings', len: 'bool' = False, idx: 'bool' = False, minmatchlen: 'int | None' = None, withmatchlen: 'bool' = False, **kwargs) -> 'StralgoResponse | Awaitable[StralgoResponse]'
 |      Implements complex algorithms that operate on strings.
 |      Right now the only algorithm implemented is the LCS algorithm
 |      (longest common substring). However new algorithms could be
 |      implemented in the future.
 |
 |      ``algo`` Right now must be LCS
 |      ``value1`` and ``value2`` Can be two strings or two keys
 |      ``specific_argument`` Specifying if the arguments to the algorithm
 |      will be keys or strings. strings is the default.
 |      ``len`` Returns just the len of the match.
 |      ``idx`` Returns the match positions in each string.
 |      ``minmatchlen`` Restrict the list of matches to the ones of a given
 |      minimal length. Can be provided only when ``idx`` set to True.
 |      ``withmatchlen`` Returns the matches with the len of the match.
 |      Can be provided only when ``idx`` set to True.
 |
 |      For more information see https://redis.io/commands/stralgo
 |
 |  ----------------------------------------------------------------------
 |  Methods inherited from redis.commands.core.BasicKeyCommands:
 |
 |  __contains__ = exists(self, *names: 'KeyT') -> 'int | Awaitable[int]'
 |      Returns the number of ``names`` that exist
 |
 |      For more information, see https://redis.io/commands/exists
 |
 |  __delitem__(self, name: 'KeyT')
 |
 |  __getitem__(self, name: 'KeyT')
 |      Return the value at key ``name``, raises a KeyError if the key
 |      doesn't exist.
 |
 |  __setitem__(self, name: 'KeyT', value: 'EncodableT')
 |
 |  append(self, key: 'KeyT', value: 'EncodableT') -> 'int | Awaitable[int]'
 |      Appends the string ``value`` to the value at ``key``. If ``key``
 |      doesn't already exist, create it with a value of ``value``.
 |      Returns the new length of the value at ``key``.
 |
 |      For more information, see https://redis.io/commands/append
 |
 |  bitcount(self, key: 'KeyT', start: 'int | None' = None, end: 'int | None' = None, mode: 'str | None' = None) -> 'int | Awaitable[int]'
 |      Returns the count of set bits in the value of ``key``.  Optional
 |      ``start`` and ``end`` parameters indicate which bytes to consider
 |
 |      For more information, see https://redis.io/commands/bitcount
 |
 |  bitfield(self: "Union['redis.client.Redis', 'redis.asyncio.client.Redis']", key: 'KeyT', default_overflow: 'str | None' = None) -> 'BitFieldOperation'
 |      Return a BitFieldOperation instance to conveniently construct one or
 |      more bitfield operations on ``key``.
 |
 |      For more information, see https://redis.io/commands/bitfield
 |
 |  bitfield_ro(self: "Union['redis.client.Redis', 'redis.asyncio.client.Redis']", key: 'KeyT', encoding: 'str', offset: 'BitfieldOffsetT', items: 'list[tuple[str, BitfieldOffsetT]] | None' = None) -> 'list[int] | Awaitable[list[int]]'
 |      Return an array of the specified bitfield values
 |      where the first value is found using ``encoding`` and ``offset``
 |      parameters and remaining values are result of corresponding
 |      encoding/offset pairs in optional list ``items``
 |      Read-only variant of the BITFIELD command.
 |
 |      For more information, see https://redis.io/commands/bitfield_ro
 |
 |  bitop(self, operation: 'str', dest: 'KeyT', *keys: 'KeyT') -> 'int | Awaitable[int]'
 |      Perform a bitwise operation using ``operation`` between ``keys`` and
 |      store the result in ``dest``.
 |
 |      For more information, see https://redis.io/commands/bitop
 |
 |  bitpos(self, key: 'KeyT', bit: 'int', start: 'int | None' = None, end: 'int | None' = None, mode: 'str | None' = None) -> 'int | Awaitable[int]'
 |      Return the position of the first bit set to 1 or 0 in a string.
 |      ``start`` and ``end`` defines search range. The range is interpreted
 |      as a range of bytes and not a range of bits, so start=0 and end=2
 |      means to look at the first three bytes.
 |
 |      For more information, see https://redis.io/commands/bitpos
 |
 |  blmove(self, first_list: 'str', second_list: 'str', timeout: 'int', src: 'str' = 'LEFT', dest: 'str' = 'RIGHT') -> 'bytes | str | None | Awaitable[bytes | str | None]'
 |      Blocking version of lmove.
 |
 |      For more information, see https://redis.io/commands/blmove
 |
 |  blmovem(self, first_list: 'str', second_list: 'str', timeout: 'float', src: 'str' = 'LEFT', dest: 'str' = 'RIGHT', count: 'int | None' = None, mode: "Literal['COUNT', 'EXACTLY'] | None" = None, ordering: "Literal['OBO', 'BULK'] | None" = None) -> 'list[bytes | str] | None | Awaitable[list[bytes | str] | None]'
 |      Blocking version of lmovem.
 |
 |      Blocks until elements are available to move or ``timeout`` (in seconds)
 |      is reached; a ``timeout`` of ``0`` blocks indefinitely. With ``COUNT``
 |      the command unblocks once at least one element is available and moves
 |      ``min(count, available)``; with ``EXACTLY`` it blocks until the source
 |      holds at least ``count`` elements, then moves exactly ``count``
 |      atomically. On timeout ``None`` is returned and nothing is moved.
 |
 |      As with ``lmovem``, ``ordering`` (OBO or BULK) is required whenever
 |      ``count`` is given.
 |
 |      For more information, see https://redis.io/commands/blmovem
 |
 |  copy(self, source: 'str', destination: 'str', destination_db: 'str | None' = None, replace: 'bool' = False) -> 'bool | Awaitable[bool]'
 |      Copy the value stored in the ``source`` key to the ``destination`` key.
 |
 |      ``destination_db`` an alternative destination database. By default,
 |      the ``destination`` key is created in the source Redis database.
 |
 |      ``replace`` whether the ``destination`` key should be removed before
 |      copying the value to it. By default, the value is not copied if
 |      the ``destination`` key already exists.
 |
 |      For more information, see https://redis.io/commands/copy
 |
 |  decr = decrby(self, name: 'KeyT', amount: 'int' = 1) -> 'int | Awaitable[int]'
 |
 |  decrby(self, name: 'KeyT', amount: 'int' = 1) -> 'int | Awaitable[int]'
 |      Decrements the value of ``key`` by ``amount``.  If no key exists,
 |      the value will be initialized as 0 - ``amount``
 |
 |      For more information, see https://redis.io/commands/decrby
 |
 |  delex(self, name: 'KeyT', ifeq: 'bytes | str | None' = None, ifne: 'bytes | str | None' = None, ifdeq: 'str | None' = None, ifdne: 'str | None' = None) -> 'int | Awaitable[int]'
 |      Conditionally removes the specified key.
 |
 |      Warning:
 |      **Experimental** since 7.1.
 |      This API may change or be removed without notice.
 |      The API may change based on feedback.
 |
 |      Arguments:
 |          name: KeyT - the key to delete
 |          ifeq match-valu: Optional[Union[bytes, str]] - Delete the key only if its value is equal to match-value
 |          ifne match-value: Optional[Union[bytes, str]] - Delete the key only if its value is not equal to match-value
 |          ifdeq match-digest: Optional[str] - Delete the key only if the digest of its value is equal to match-digest
 |          ifdne match-digest: Optional[str] - Delete the key only if the digest of its value is not equal to match-digest
 |
 |      Returns:
 |          int: 1 if the key was deleted, 0 otherwise.
 |      Raises:
 |          redis.exceptions.ResponseError: if key exists but is not a string
 |                                          and a condition is specified.
 |          ValueError: if more than one condition is provided.
 |
 |
 |      Requires Redis 8.4 or greater.
 |      For more information, see https://redis.io/commands/delex
 |
 |  digest(self, name: 'KeyT') -> 'str | bytes | None | Awaitable[str | bytes | None]'
 |      Return the digest of the value stored at the specified key.
 |
 |      Warning:
 |      **Experimental** since 7.1.
 |      This API may change or be removed without notice.
 |      The API may change based on feedback.
 |
 |      Arguments:
 |        - name: KeyT - the key to get the digest of
 |
 |      Returns:
 |        - None if the key does not exist
 |        - (bulk string) the XXH3 digest of the value as a hex string
 |      Raises:
 |        - ResponseError if key exists but is not a string
 |
 |
 |      Requires Redis 8.4 or greater.
 |      For more information, see https://redis.io/commands/digest
 |
 |  digest_local(self, value: 'bytes | str') -> 'bytes | str'
 |      Compute the hexadecimal digest of the value locally, without sending it to the server.
 |
 |      This is useful for conditional operations like IFDEQ/IFDNE where you need to
 |      compute the digest client-side before sending a command.
 |
 |      Warning:
 |      **Experimental** - This API may change or be removed without notice.
 |
 |      Arguments:
 |        - value: Union[bytes, str] - the value to compute the digest of.
 |          If a string is provided, it will be encoded using UTF-8 before hashing,
 |          which matches Redis's default encoding behavior.
 |
 |      Returns:
 |        - (str | bytes) the XXH3 digest of the value as a hex string (16 hex characters).
 |          Returns bytes if decode_responses is False, otherwise returns str.
 |
 |      For more information, see https://redis.io/commands/digest
 |
 |  dump(self, name: 'KeyT') -> 'bytes | None | Awaitable[bytes | None]'
 |      Return a serialized version of the value stored at the specified key.
 |      If key does not exist a nil bulk reply is returned.
 |
 |      For more information, see https://redis.io/commands/dump
 |
 |  expire(self, name: 'KeyT', time: 'ExpiryT', nx: 'bool' = False, xx: 'bool' = False, gt: 'bool' = False, lt: 'bool' = False) -> 'bool | Awaitable[bool]'
 |      Set an expire flag on key ``name`` for ``time`` seconds with given
 |      ``option``. ``time`` can be represented by an integer or a Python timedelta
 |      object.
 |
 |      Valid options are:
 |          NX -> Set expiry only when the key has no expiry
 |          XX -> Set expiry only when the key has an existing expiry
 |          GT -> Set expiry only when the new expiry is greater than current one
 |          LT -> Set expiry only when the new expiry is less than current one
 |
 |      For more information, see https://redis.io/commands/expire
 |
 |  expireat(self, name: 'KeyT', when: 'AbsExpiryT', nx: 'bool' = False, xx: 'bool' = False, gt: 'bool' = False, lt: 'bool' = False) -> 'bool | Awaitable[bool]'
 |      Set an expire flag on key ``name`` with given ``option``. ``when``
 |      can be represented as an integer indicating unix time or a Python
 |      datetime object.
 |
 |      Valid options are:
 |          -> NX -- Set expiry only when the key has no expiry
 |          -> XX -- Set expiry only when the key has an existing expiry
 |          -> GT -- Set expiry only when the new expiry is greater than current one
 |          -> LT -- Set expiry only when the new expiry is less than current one
 |
 |      For more information, see https://redis.io/commands/expireat
 |
 |  expiretime(self, key: 'str') -> 'int | Awaitable[int]'
 |      Returns the absolute Unix timestamp (since January 1, 1970) in seconds
 |      at which the given key will expire.
 |
 |      For more information, see https://redis.io/commands/expiretime
 |
 |  get(self, name: 'KeyT') -> 'bytes | str | None | Awaitable[bytes | str | None]'
 |      Return the value at key ``name``, or None if the key doesn't exist
 |
 |      For more information, see https://redis.io/commands/get
 |
 |  getbit(self, name: 'KeyT', offset: 'int') -> 'int | Awaitable[int]'
 |      Returns an integer indicating the value of ``offset`` in ``name``
 |
 |      For more information, see https://redis.io/commands/getbit
 |
 |  getdel(self, name: 'KeyT') -> 'bytes | str | None | Awaitable[bytes | str | None]'
 |      Get the value at key ``name`` and delete the key. This command
 |      is similar to GET, except for the fact that it also deletes
 |      the key on success (if and only if the key's value type
 |      is a string).
 |
 |      For more information, see https://redis.io/commands/getdel
 |
 |  getex(self, name: 'KeyT', ex: 'ExpiryT | None' = None, px: 'ExpiryT | None' = None, exat: 'AbsExpiryT | None' = None, pxat: 'AbsExpiryT | None' = None, persist: 'bool' = False) -> 'bytes | str | None | Awaitable[bytes | str | None]'
 |      Get the value of key and optionally set its expiration.
 |      GETEX is similar to GET, but is a write command with
 |      additional options. All time parameters can be given as
 |      datetime.timedelta or integers.
 |
 |      ``ex`` sets an expire flag on key ``name`` for ``ex`` seconds.
 |
 |      ``px`` sets an expire flag on key ``name`` for ``px`` milliseconds.
 |
 |      ``exat`` sets an expire flag on key ``name`` for ``ex`` seconds,
 |      specified in unix time.
 |
 |      ``pxat`` sets an expire flag on key ``name`` for ``ex`` milliseconds,
 |      specified in unix time.
 |
 |      ``persist`` remove the time to live associated with ``name``.
 |
 |      For more information, see https://redis.io/commands/getex
 |
 |  getrange(self, key: 'KeyT', start: 'int', end: 'int') -> 'bytes | str | Awaitable[bytes | str]'
 |      Returns the substring of the string value stored at ``key``,
 |      determined by the offsets ``start`` and ``end`` (both are inclusive)
 |
 |      For more information, see https://redis.io/commands/getrange
 |
 |  getset(self, name: 'KeyT', value: 'EncodableT') -> 'bytes | str | None | Awaitable[bytes | str | None]'
 |      Sets the value at key ``name`` to ``value``
 |      and returns the old value at key ``name`` atomically.
 |
 |      As per Redis 6.2, GETSET is considered deprecated.
 |      Please use SET with GET parameter in new code.
 |
 |      For more information, see https://redis.io/commands/getset
 |
 |  hrandfield(self, key: 'KeyT', count: 'int | None' = None, withvalues: 'bool' = False) -> 'HRandFieldResponse | Awaitable[HRandFieldResponse]'
 |      Return a random field from the hash value stored at key.
 |
 |      count: if the argument is positive, return an array of distinct fields.
 |      If called with a negative count, the behavior changes and the command
 |      is allowed to return the same field multiple times. In this case,
 |      the number of returned fields is the absolute value of the
 |      specified count.
 |      withvalues: The optional WITHVALUES modifier changes the reply so it
 |      includes the respective values of the randomly selected hash fields.
 |
 |      For more information, see https://redis.io/commands/hrandfield
 |
 |  incr = incrby(self, name: 'KeyT', amount: 'int' = 1) -> 'int | Awaitable[int]'
 |
 |  incrby(self, name: 'KeyT', amount: 'int' = 1) -> 'int | Awaitable[int]'
 |      Increments the value of ``key`` by ``amount``.  If no key exists,
 |      the value will be initialized as ``amount``
 |
 |      For more information, see https://redis.io/commands/incrby
 |
 |  incrbyfloat(self, name: 'KeyT', amount: 'float' = 1.0) -> 'float | Awaitable[float]'
 |      Increments the value at key ``name`` by floating ``amount``.
 |      If no key exists, the value will be initialized as ``amount``
 |
 |      For more information, see https://redis.io/commands/incrbyfloat
 |
 |  increx(self, name: 'KeyT', *, byfloat: 'EncodableT | None' = None, byint: 'EncodableT | None' = None, lbound: 'EncodableT | None' = None, ubound: 'EncodableT | None' = None, saturate: 'bool' = False, ex: 'ExpiryT | None' = None, px: 'ExpiryT | None' = None, exat: 'AbsExpiryT | None' = None, pxat: 'AbsExpiryT | None' = None, persist: 'bool' = False, enx: 'bool' = False) -> 'list[Number | bytes | str] | Awaitable[list[Number | bytes | str]]'
 |      Increment the numeric value at key ``name`` and return the new value
 |      and the actual increment.
 |
 |      ``byfloat`` increments a floating point value by the provided amount.
 |
 |      ``byint`` increments an integer value by the provided amount.
 |
 |      If neither ``byfloat`` nor ``byint`` is specified, the value is
 |      incremented by one.
 |
 |      ``lbound`` and ``ubound`` constrain the valid range of the result.
 |
 |      If ``saturate`` is True, out-of-bounds results are saturated to the
 |      specified bound, or to the type limit when no bound is specified.
 |      Otherwise, out-of-bounds results are rejected, leaving the value and
 |      TTL unchanged and returning the current value and zero as the actual
 |      increment.
 |
 |      ``enx`` applies the expiration only when the key does not already
 |      have an expiration, and requires ``ex``, ``px``, ``exat``, or ``pxat``.
 |
 |  keys(self, pattern: 'PatternT' = '*', **kwargs) -> 'list[bytes | str] | Awaitable[list[bytes | str]]'
 |      Returns a list of keys matching ``pattern``
 |
 |      For more information, see https://redis.io/commands/keys
 |
 |  lcs(self, key1: 'str', key2: 'str', len: 'bool | None' = False, idx: 'bool | None' = False, minmatchlen: 'int | None' = 0, withmatchlen: 'bool | None' = False) -> 'LCSCommandResponse | Awaitable[LCSCommandResponse]'
 |      Find the longest common subsequence between ``key1`` and ``key2``.
 |      If ``len`` is true the length of the match will be returned.
 |      If ``idx`` is true the match position in each strings will be returned.
 |      ``minmatchlen`` restrict the list of matches to the ones of
 |      the given ``minmatchlen``.
 |      If ``withmatchlen`` the length of the match also will be returned.
 |      For more information, see https://redis.io/commands/lcs
 |
 |  lmove(self, first_list: 'str', second_list: 'str', src: 'str' = 'LEFT', dest: 'str' = 'RIGHT') -> 'bytes | str | None | Awaitable[bytes | str | None]'
 |      Atomically returns and removes the first/last element of a list,
 |      pushing it as the first/last element on the destination list.
 |      Returns the element being popped and pushed.
 |
 |      For more information, see https://redis.io/commands/lmove
 |
 |  lmovem(self, first_list: 'str', second_list: 'str', src: 'str' = 'LEFT', dest: 'str' = 'RIGHT', count: 'int | None' = None, mode: "Literal['COUNT', 'EXACTLY'] | None" = None, ordering: "Literal['OBO', 'BULK'] | None" = None) -> 'list[bytes | str] | None | Awaitable[list[bytes | str] | None]'
 |      Atomically moves multiple elements from one end of the ``first_list``
 |      to one end of the ``second_list``, returning the moved elements in
 |      destination order.
 |
 |      ``src`` and ``dest`` are the ends to pop from / push to, either
 |      ``LEFT`` (head) or ``RIGHT`` (tail).
 |
 |      When ``count`` is given, ``mode`` selects how many elements to move:
 |      ``COUNT`` (the default) moves up to ``count`` elements, while
 |      ``EXACTLY`` moves exactly ``count`` elements or nothing at all. When
 |      ``count`` is not given a single element is moved.
 |
 |      ``ordering`` controls the order at the destination: ``OBO`` pushes each
 |      element as it is popped (reversing block order, stack semantics) while
 |      ``BULK`` preserves the original relative order (queue semantics). It is
 |      required whenever ``count`` is given.
 |
 |      Returns the array of moved elements, or ``None`` if nothing was moved.
 |
 |      For more information, see https://redis.io/commands/lmovem
 |
 |  mget(self, keys: 'KeysT', *args: 'EncodableT') -> 'list[bytes | str | None] | Awaitable[list[bytes | str | None]]'
 |      Returns a list of values ordered identically to ``keys``
 |
 |      ** Important ** When this method is used with Cluster clients, all keys
 |              must be in the same hash slot, otherwise a RedisClusterException
 |              will be raised.
 |
 |      For more information, see https://redis.io/commands/mget
 |
 |  move(self, name: 'KeyT', db: 'int') -> 'bool | Awaitable[bool]'
 |      Moves the key ``name`` to a different Redis database ``db``
 |
 |      For more information, see https://redis.io/commands/move
 |
 |  mset(self, mapping: 'Mapping[AnyKeyT, EncodableT]') -> 'bool | Awaitable[bool]'
 |      Sets key/values based on a mapping. Mapping is a dictionary of
 |      key/value pairs. Both keys and values should be strings or types that
 |      can be cast to a string via str().
 |
 |      ** Important ** When this method is used with Cluster clients, all keys
 |              must be in the same hash slot, otherwise a RedisClusterException
 |              will be raised.
 |
 |      For more information, see https://redis.io/commands/mset
 |
 |  msetex(self, mapping: 'Mapping[AnyKeyT, EncodableT]', data_persist_option: 'DataPersistOptions | None' = None, ex: 'ExpiryT | None' = None, px: 'ExpiryT | None' = None, exat: 'AbsExpiryT | None' = None, pxat: 'AbsExpiryT | None' = None, keepttl: 'bool' = False) -> 'int | Awaitable[int]'
 |      Sets key/values based on the provided ``mapping`` items.
 |
 |      ** Important ** When this method is used with Cluster clients, all keys
 |                      must be in the same hash slot, otherwise a RedisClusterException
 |                      will be raised.
 |
 |      ``mapping`` accepts a dict of key/value pairs that will be added to the database.
 |
 |      ``data_persist_option`` can be set to ``NX`` or ``XX`` to control the
 |          behavior of the command.
 |          ``NX`` will set the value for each provided key to each
 |              provided value only if all do not already exist.
 |          ``XX`` will set the value for each provided key to each
 |              provided value only if all already exist.
 |
 |      ``ex`` sets an expire flag on the keys in ``mapping`` for ``ex`` seconds.
 |
 |      ``px`` sets an expire flag on the keys in ``mapping`` for ``px`` milliseconds.
 |
 |      ``exat`` sets an expire flag on the keys in ``mapping`` for ``exat`` seconds,
 |          specified in unix time.
 |
 |      ``pxat`` sets an expire flag on the keys in ``mapping`` for ``pxat`` milliseconds,
 |          specified in unix time.
 |
 |      ``keepttl`` if True, retain the time to live associated with the keys.
 |
 |      Returns the number of fields that were added.
 |
 |      Available since Redis 8.4
 |      For more information, see https://redis.io/commands/msetex
 |
 |  msetnx(self, mapping: 'Mapping[AnyKeyT, EncodableT]') -> 'bool | Awaitable[bool]'
 |      Sets key/values based on a mapping if none of the keys are already set.
 |      Mapping is a dictionary of key/value pairs. Both keys and values
 |      should be strings or types that can be cast to a string via str().
 |      Returns a boolean indicating if the operation was successful.
 |
 |      ** Important ** When this method is used with Cluster clients, all keys
 |                      must be in the same hash slot, otherwise a RedisClusterException
 |                      will be raised.
 |
 |      For more information, see https://redis.io/commands/msetnx
 |
 |  persist(self, name: 'KeyT') -> 'bool | Awaitable[bool]'
 |      Removes an expiration on ``name``
 |
 |      For more information, see https://redis.io/commands/persist
 |
 |  pexpire(self, name: 'KeyT', time: 'ExpiryT', nx: 'bool' = False, xx: 'bool' = False, gt: 'bool' = False, lt: 'bool' = False) -> 'bool | Awaitable[bool]'
 |      Set an expire flag on key ``name`` for ``time`` milliseconds
 |      with given ``option``. ``time`` can be represented by an
 |      integer or a Python timedelta object.
 |
 |      Valid options are:
 |          NX -> Set expiry only when the key has no expiry
 |          XX -> Set expiry only when the key has an existing expiry
 |          GT -> Set expiry only when the new expiry is greater than current one
 |          LT -> Set expiry only when the new expiry is less than current one
 |
 |      For more information, see https://redis.io/commands/pexpire
 |
 |  pexpireat(self, name: 'KeyT', when: 'AbsExpiryT', nx: 'bool' = False, xx: 'bool' = False, gt: 'bool' = False, lt: 'bool' = False) -> 'bool | Awaitable[bool]'
 |      Set an expire flag on key ``name`` with given ``option``. ``when``
 |      can be represented as an integer representing unix time in
 |      milliseconds (unix time * 1000) or a Python datetime object.
 |
 |      Valid options are:
 |          NX -> Set expiry only when the key has no expiry
 |          XX -> Set expiry only when the key has an existing expiry
 |          GT -> Set expiry only when the new expiry is greater than current one
 |          LT -> Set expiry only when the new expiry is less than current one
 |
 |      For more information, see https://redis.io/commands/pexpireat
 |
 |  pexpiretime(self, key: 'str') -> 'int | Awaitable[int]'
 |      Returns the absolute Unix timestamp (since January 1, 1970) in milliseconds
 |      at which the given key will expire.
 |
 |      For more information, see https://redis.io/commands/pexpiretime
 |
 |  psetex(self, name: 'KeyT', time_ms: 'ExpiryT', value: 'EncodableT') -> 'bool | Awaitable[bool]'
 |      Set the value of key ``name`` to ``value`` that expires in ``time_ms``
 |      milliseconds. ``time_ms`` can be represented by an integer or a Python
 |      timedelta object
 |
 |      For more information, see https://redis.io/commands/psetex
 |
 |  pttl(self, name: 'KeyT') -> 'int | Awaitable[int]'
 |      Returns the number of milliseconds until the key ``name`` will expire
 |
 |      For more information, see https://redis.io/commands/pttl
 |
 |  randomkey(self, **kwargs) -> 'bytes | str | None | Awaitable[bytes | str | None]'
 |      Returns the name of a random key
 |
 |      For more information, see https://redis.io/commands/randomkey
 |
 |  rename(self, src: 'KeyT', dst: 'KeyT') -> 'bool | Awaitable[bool]'
 |      Rename key ``src`` to ``dst``
 |
 |      For more information, see https://redis.io/commands/rename
 |
 |  renamenx(self, src: 'KeyT', dst: 'KeyT') -> 'bool | Awaitable[bool]'
 |      Rename key ``src`` to ``dst`` if ``dst`` doesn't already exist
 |
 |      For more information, see https://redis.io/commands/renamenx
 |
 |  restore(self, name: 'KeyT', ttl: 'float', value: 'EncodableT', replace: 'bool' = False, absttl: 'bool' = False, idletime: 'int | None' = None, frequency: 'int | None' = None) -> 'bytes | str | Awaitable[bytes | str]'
 |      Create a key using the provided serialized value, previously obtained
 |      using DUMP.
 |
 |      ``replace`` allows an existing key on ``name`` to be overridden. If
 |      it's not specified an error is raised on collision.
 |
 |      ``absttl`` if True, specified ``ttl`` should represent an absolute Unix
 |      timestamp in milliseconds in which the key will expire. (Redis 5.0 or
 |      greater).
 |
 |      ``idletime`` Used for eviction, this is the number of seconds the
 |      key must be idle, prior to execution.
 |
 |      ``frequency`` Used for eviction, this is the frequency counter of
 |      the object stored at the key, prior to execution.
 |
 |      For more information, see https://redis.io/commands/restore
 |
 |  set(self, name: 'KeyT', value: 'EncodableT', ex: 'ExpiryT | None' = None, px: 'ExpiryT | None' = None, nx: 'bool' = False, xx: 'bool' = False, keepttl: 'bool' = False, get: 'bool' = False, exat: 'AbsExpiryT | None' = None, pxat: 'AbsExpiryT | None' = None, ifeq: 'bytes | str | None' = None, ifne: 'bytes | str | None' = None, ifdeq: 'str | None' = None, ifdne: 'str | None' = None) -> 'bool | str | bytes | None | Awaitable[bool | str | bytes | None]'
 |      Set the value at key ``name`` to ``value``
 |
 |      Warning:
 |      **Experimental** since 7.1.
 |      The usage of the arguments ``ifeq``, ``ifne``, ``ifdeq``, and ``ifdne``
 |      is experimental. The API or returned results when those parameters are used
 |      may change based on feedback.
 |
 |      ``ex`` sets an expire flag on key ``name`` for ``ex`` seconds.
 |
 |      ``px`` sets an expire flag on key ``name`` for ``px`` milliseconds.
 |
 |      ``nx`` if set to True, set the value at key ``name`` to ``value`` only
 |          if it does not exist.
 |
 |      ``xx`` if set to True, set the value at key ``name`` to ``value`` only
 |          if it already exists.
 |
 |      ``keepttl`` if True, retain the time to live associated with the key.
 |          (Available since Redis 6.0)
 |
 |      ``get`` if True, set the value at key ``name`` to ``value`` and return
 |          the old value stored at key, or None if the key did not exist.
 |          (Available since Redis 6.2)
 |
 |      ``exat`` sets an expire flag on key ``name`` for ``ex`` seconds,
 |          specified in unix time.
 |
 |      ``pxat`` sets an expire flag on key ``name`` for ``ex`` milliseconds,
 |          specified in unix time.
 |
 |      ``ifeq`` set the value at key ``name`` to ``value`` only if the current
 |          value exactly matches the argument.
 |          If key doesn’t exist - it won’t be created.
 |          (Requires Redis 8.4 or greater)
 |
 |      ``ifne`` set the value at key ``name`` to ``value`` only if the current
 |          value does not exactly match the argument.
 |          If key doesn’t exist - it will be created.
 |          (Requires Redis 8.4 or greater)
 |
 |      ``ifdeq`` set the value at key ``name`` to ``value`` only if the current
 |          value XXH3 hex digest exactly matches the argument.
 |          If key doesn’t exist - it won’t be created.
 |          (Requires Redis 8.4 or greater)
 |
 |      ``ifdne`` set the value at key ``name`` to ``value`` only if the current
 |          value XXH3 hex digest does not exactly match the argument.
 |          If key doesn’t exist - it will be created.
 |          (Requires Redis 8.4 or greater)
 |
 |      For more information, see https://redis.io/commands/set
 |
 |  setbit(self, name: 'KeyT', offset: 'int', value: 'int') -> 'int | Awaitable[int]'
 |      Flag the ``offset`` in ``name`` as ``value``. Returns an integer
 |      indicating the previous value of ``offset``.
 |
 |      For more information, see https://redis.io/commands/setbit
 |
 |  setex(self, name: 'KeyT', time: 'ExpiryT', value: 'EncodableT') -> 'bool | Awaitable[bool]'
 |      Set the value of key ``name`` to ``value`` that expires in ``time``
 |      seconds. ``time`` can be represented by an integer or a Python
 |      timedelta object.
 |
 |      As per Redis 2.6.12, SETEX is considered deprecated.
 |      Please use SET with EX parameter in new code.
 |
 |      For more information, see https://redis.io/commands/setex
 |
 |  setnx(self, name: 'KeyT', value: 'EncodableT') -> 'bool | Awaitable[bool]'
 |      Set the value of key ``name`` to ``value`` if key doesn't exist
 |
 |      For more information, see https://redis.io/commands/setnx
 |
 |  setrange(self, name: 'KeyT', offset: 'int', value: 'EncodableT') -> 'int | Awaitable[int]'
 |      Overwrite bytes in the value of ``name`` starting at ``offset`` with
 |      ``value``. If ``offset`` plus the length of ``value`` exceeds the
 |      length of the original value, the new value will be larger than before.
 |      If ``offset`` exceeds the length of the original value, null bytes
 |      will be used to pad between the end of the previous value and the start
 |      of what's being injected.
 |
 |      Returns the length of the new string.
 |
 |      For more information, see https://redis.io/commands/setrange
 |
 |  strlen(self, name: 'KeyT') -> 'int | Awaitable[int]'
 |      Return the number of bytes stored in the value of ``name``
 |
 |      For more information, see https://redis.io/commands/strlen
 |
 |  substr(self, name: 'KeyT', start: 'int', end: 'int' = -1) -> 'bytes | str | Awaitable[bytes | str]'
 |      Return a substring of the string at key ``name``. ``start`` and ``end``
 |      are 0-based integers specifying the portion of the string to return.
 |
 |  ttl(self, name: 'KeyT') -> 'int | Awaitable[int]'
 |      Returns the number of seconds until the key ``name`` will expire
 |
 |      For more information, see https://redis.io/commands/ttl
 |
 |  type(self, name: 'KeyT') -> 'bytes | str | Awaitable[bytes | str]'
 |      Returns the type of key ``name``
 |
 |      For more information, see https://redis.io/commands/type
 |
 |  unwatch(self) -> 'None'
 |      Unwatches all previously watched keys for a transaction
 |
 |      For more information, see https://redis.io/commands/unwatch
 |
 |  watch(self, *names: 'KeyT') -> 'None'
 |      Watches the values at keys ``names``, or None if the key doesn't exist
 |
 |      For more information, see https://redis.io/commands/watch
 |
 |  ----------------------------------------------------------------------
 |  Methods inherited from redis.commands.core.HyperlogCommands:
 |
 |  pfadd(self, name: 'KeyT', *values: 'FieldT') -> 'int | Awaitable[int]'
 |      Adds the specified elements to the specified HyperLogLog.
 |
 |      For more information, see https://redis.io/commands/pfadd
 |
 |  pfcount(self, *sources: 'KeyT') -> 'int | Awaitable[int]'
 |      Return the approximated cardinality of
 |      the set observed by the HyperLogLog at key(s).
 |
 |      For more information, see https://redis.io/commands/pfcount
 |
 |  pfmerge(self, dest: 'KeyT', *sources: 'KeyT') -> 'bool | Awaitable[bool]'
 |      Merge N different HyperLogLogs into a single one.
 |
 |      For more information, see https://redis.io/commands/pfmerge
 |
 |  ----------------------------------------------------------------------
 |  Methods inherited from redis.commands.core.HashCommands:
 |
 |  hdel(self, name: 'KeyT', *keys: 'FieldT') -> 'int | Awaitable[int]'
 |      Delete ``keys`` from hash ``name``
 |
 |      For more information, see https://redis.io/commands/hdel
 |
 |  hexists(self, name: 'KeyT', key: 'FieldT') -> 'bool | Awaitable[bool]'
 |      Returns a boolean indicating if ``key`` exists within hash ``name``
 |
 |      For more information, see https://redis.io/commands/hexists
 |
 |  hexpire(self, name: 'KeyT', seconds: 'ExpiryT', *fields: 'FieldT', nx: 'bool' = False, xx: 'bool' = False, gt: 'bool' = False, lt: 'bool' = False) -> 'list[int] | Awaitable[list[int]]'
 |      Sets or updates the expiration time for fields within a hash key, using relative
 |      time in seconds.
 |
 |      If a field already has an expiration time, the behavior of the update can be
 |      controlled using the `nx`, `xx`, `gt`, and `lt` parameters.
 |
 |      The return value provides detailed information about the outcome for each field.
 |
 |      For more information, see https://redis.io/commands/hexpire
 |
 |      Args:
 |          name: The name of the hash key.
 |          seconds: Expiration time in seconds, relative. Can be an integer, or a
 |                   Python `timedelta` object.
 |          fields: List of fields within the hash to apply the expiration time to.
 |          nx: Set expiry only when the field has no expiry.
 |          xx: Set expiry only when the field has an existing expiry.
 |          gt: Set expiry only when the new expiry is greater than the current one.
 |          lt: Set expiry only when the new expiry is less than the current one.
 |
 |      Returns:
 |          Returns a list which contains for each field in the request:
 |              - `-2` if the field does not exist, or if the key does not exist.
 |              - `0` if the specified NX | XX | GT | LT condition was not met.
 |              - `1` if the expiration time was set or updated.
 |              - `2` if the field was deleted because the specified expiration time is
 |                in the past.
 |
 |  hexpireat(self, name: 'KeyT', unix_time_seconds: 'AbsExpiryT', *fields: 'FieldT', nx: 'bool' = False, xx: 'bool' = False, gt: 'bool' = False, lt: 'bool' = False) -> 'list[int] | Awaitable[list[int]]'
 |      Sets or updates the expiration time for fields within a hash key, using an
 |      absolute Unix timestamp in seconds.
 |
 |      If a field already has an expiration time, the behavior of the update can be
 |      controlled using the `nx`, `xx`, `gt`, and `lt` parameters.
 |
 |      The return value provides detailed information about the outcome for each field.
 |
 |      For more information, see https://redis.io/commands/hexpireat
 |
 |      Args:
 |          name: The name of the hash key.
 |          unix_time_seconds: Expiration time as Unix timestamp in seconds. Can be an
 |                             integer or a Python `datetime` object.
 |          fields: List of fields within the hash to apply the expiration time to.
 |          nx: Set expiry only when the field has no expiry.
 |          xx: Set expiry only when the field has an existing expiration time.
 |          gt: Set expiry only when the new expiry is greater than the current one.
 |          lt: Set expiry only when the new expiry is less than the current one.
 |
 |      Returns:
 |          Returns a list which contains for each field in the request:
 |              - `-2` if the field does not exist, or if the key does not exist.
 |              - `0` if the specified NX | XX | GT | LT condition was not met.
 |              - `1` if the expiration time was set or updated.
 |              - `2` if the field was deleted because the specified expiration time is
 |                in the past.
 |
 |  hexpiretime(self, key: 'KeyT', *fields: 'FieldT') -> 'list[int] | Awaitable[list[int]]'
 |      Returns the expiration times of hash fields as Unix timestamps in seconds.
 |
 |      For more information, see https://redis.io/commands/hexpiretime
 |
 |      Args:
 |          key: The hash key.
 |          fields: A list of fields within the hash for which to get the expiration
 |                  time.
 |
 |      Returns:
 |          Returns a list which contains for each field in the request:
 |              - `-2` if the field does not exist, or if the key does not exist.
 |              - `-1` if the field exists but has no associated expire time.
 |              - A positive integer representing the expiration Unix timestamp in
 |                seconds, if the field has an associated expiration time.
 |
 |  hget(self, name: 'KeyT', key: 'FieldT') -> 'bytes | str | None | Awaitable[bytes | str | None]'
 |      Return the value of ``key`` within the hash ``name``
 |
 |      For more information, see https://redis.io/commands/hget
 |
 |  hgetall(self, name: 'KeyT') -> 'dict[bytes | str, bytes | str] | Awaitable[dict[bytes | str, bytes | str]]'
 |      Return a Python dict of the hash's name/value pairs
 |
 |      For more information, see https://redis.io/commands/hgetall
 |
 |  hgetdel(self, name: 'KeyT', *keys: 'FieldT') -> 'list[bytes | str | None] | Awaitable[list[bytes | str | None]]'
 |      Return the value of ``key`` within the hash ``name`` and
 |      delete the field in the hash.
 |      This command is similar to HGET, except for the fact that it also deletes
 |      the key on success from the hash with the provided ```name```.
 |
 |      Available since Redis 8.0
 |      For more information, see https://redis.io/commands/hgetdel
 |
 |  hgetex(self, name: 'KeyT', *keys: 'FieldT', ex: 'ExpiryT | None' = None, px: 'ExpiryT | None' = None, exat: 'AbsExpiryT | None' = None, pxat: 'AbsExpiryT | None' = None, persist: 'bool' = False) -> 'list[bytes | str | None] | Awaitable[list[bytes | str | None]]'
 |      Return the values of ``key`` and ``keys`` within the hash ``name``
 |      and optionally set their expiration.
 |
 |      ``ex`` sets an expire flag on ``kyes`` for ``ex`` seconds.
 |
 |      ``px`` sets an expire flag on ``keys`` for ``px`` milliseconds.
 |
 |      ``exat`` sets an expire flag on ``keys`` for ``ex`` seconds,
 |      specified in unix time.
 |
 |      ``pxat`` sets an expire flag on ``keys`` for ``ex`` milliseconds,
 |      specified in unix time.
 |
 |      ``persist`` remove the time to live associated with the ``keys``.
 |
 |      Available since Redis 8.0
 |      For more information, see https://redis.io/commands/hgetex
 |
 |  himport_discard_all_internal(self) -> 'int | Awaitable[int]'
 |      Send ``HIMPORT DISCARDALL`` (returns the number of fieldsets removed).
 |
 |      .. warning::
 |          Internal wire mapping — not for direct use on a pooled client. It
 |          DISCARDs on a single arbitrary borrowed connection and bypasses the
 |          client's shared fieldset registry, leaving other connections and the
 |          registry out of sync. Use the client's ``himport_discard_all`` instead;
 |          call this only on a pinned single-connection client where you manage
 |          session state yourself.
 |
 |  himport_discard_internal(self, fieldset_name: 'str') -> 'int | Awaitable[int]'
 |      Send ``HIMPORT DISCARD fieldset_name`` (``1`` removed, ``0`` not found).
 |
 |      .. warning::
 |          Internal wire mapping — not for direct use on a pooled client. It
 |          DISCARDs on a single arbitrary borrowed connection and bypasses the
 |          client's shared fieldset registry, leaving other connections and the
 |          registry out of sync. Use the client's ``himport_discard`` instead; call
 |          this only on a pinned single-connection client where you manage session
 |          state yourself.
 |
 |  himport_prepare_internal(self, fieldset_name: 'str', fields: 'Iterable[FieldT]') -> 'bool | Awaitable[bool]'
 |      Send ``HIMPORT PREPARE fieldset_name field [field ...]``.
 |
 |      Registers the ordered field list under ``fieldset_name`` in the executing
 |      connection's session. Fields are sent in the caller's order, unmodified.
 |
 |      .. warning::
 |          Internal wire mapping — not for direct use on a pooled client. It
 |          PREPAREs on a single arbitrary borrowed connection and bypasses the
 |          client's shared fieldset registry, so other connections stay unaware and
 |          reintroduce the nondeterministic "no such fieldset" the HIMPORT design
 |          prevents. Use the client's ``himport_prepare`` instead; call this only
 |          on a pinned single-connection client where you manage session state
 |          yourself.
 |
 |  himport_set(self, key: 'KeyT', fieldset_name: 'str', values: 'Iterable[EncodableT]') -> 'bool | Awaitable[bool]'
 |      Create/replace ``key`` as a hash using ``fieldset_name``'s field list.
 |
 |      Values are sent in the caller's order and map positionally to the prepared
 |      fields. The fieldset is prepared on the serving connection on first use
 |      (PREPARE bundled with SET in one write) and reused on subsequent calls;
 |      runtime discards are reconciled on the next use of the connection. All of
 |      this happens inside the normal command path, so retry, disconnect-on-error
 |      and (for the cluster) routing / MOVED-ASK apply exactly as for any command.
 |
 |      .. note::
 |          Recovery from a mid-connection fieldset loss (the server dropping the
 |          prepared fieldset without dropping the socket, e.g. ``RESET`` or
 |          ``maxmemory-clients`` eviction) applies only to a standalone
 |          ``himport_set`` call: it catches the resulting ``no such fieldset`` and
 |          re-prepares on the same socket, retrying the SET once. A ``himport_set``
 |          buffered in a **pipeline or transaction** has no such per-command
 |          recovery — its fieldset is PREPAREd once as a pre-flight before the
 |          batch, and if the server loses it between that pre-flight and the batch
 |          the SET fails and surfaces as an error in the batch results. Callers who
 |          need the automatic recovery should issue those sets outside a pipeline.
 |
 |  hincrby(self, name: 'KeyT', key: 'FieldT', amount: 'int' = 1) -> 'int | Awaitable[int]'
 |      Increment the value of ``key`` in hash ``name`` by ``amount``
 |
 |      For more information, see https://redis.io/commands/hincrby
 |
 |  hincrbyfloat(self, name: 'KeyT', key: 'FieldT', amount: 'float' = 1.0) -> 'float | Awaitable[float]'
 |      Increment the value of ``key`` in hash ``name`` by floating ``amount``
 |
 |      For more information, see https://redis.io/commands/hincrbyfloat
 |
 |  hkeys(self, name: 'KeyT') -> 'list[bytes | str] | Awaitable[list[bytes | str]]'
 |      Return the list of keys within hash ``name``
 |
 |      For more information, see https://redis.io/commands/hkeys
 |
 |  hlen(self, name: 'KeyT') -> 'int | Awaitable[int]'
 |      Return the number of elements in hash ``name``
 |
 |      For more information, see https://redis.io/commands/hlen
 |
 |  hmget(self, name: 'KeyT', keys: 'FieldT | Iterable[FieldT]', *args: 'FieldT') -> 'list[bytes | str | None] | Awaitable[list[bytes | str | None]]'
 |      Returns a list of values ordered identically to ``keys``
 |
 |      For more information, see https://redis.io/commands/hmget
 |
 |  hmset(self, name: 'KeyT', mapping: 'Mapping[FieldT, EncodableT]') -> 'bool | Awaitable[bool]'
 |      Set key to value within hash ``name`` for each corresponding
 |      key and value from the ``mapping`` dict.
 |
 |      For more information, see https://redis.io/commands/hmset
 |
 |  hpersist(self, name: 'KeyT', *fields: 'FieldT') -> 'list[int] | Awaitable[list[int]]'
 |      Removes the expiration time for each specified field in a hash.
 |
 |      For more information, see https://redis.io/commands/hpersist
 |
 |      Args:
 |          name: The name of the hash key.
 |          fields: A list of fields within the hash from which to remove the
 |                  expiration time.
 |
 |      Returns:
 |          Returns a list which contains for each field in the request:
 |              - `-2` if the field does not exist, or if the key does not exist.
 |              - `-1` if the field exists but has no associated expiration time.
 |              - `1` if the expiration time was successfully removed from the field.
 |
 |  hpexpire(self, name: 'KeyT', milliseconds: 'ExpiryT', *fields: 'FieldT', nx: 'bool' = False, xx: 'bool' = False, gt: 'bool' = False, lt: 'bool' = False) -> 'list[int] | Awaitable[list[int]]'
 |      Sets or updates the expiration time for fields within a hash key, using relative
 |      time in milliseconds.
 |
 |      If a field already has an expiration time, the behavior of the update can be
 |      controlled using the `nx`, `xx`, `gt`, and `lt` parameters.
 |
 |      The return value provides detailed information about the outcome for each field.
 |
 |      For more information, see https://redis.io/commands/hpexpire
 |
 |      Args:
 |          name: The name of the hash key.
 |          milliseconds: Expiration time in milliseconds, relative. Can be an integer,
 |                        or a Python `timedelta` object.
 |          fields: List of fields within the hash to apply the expiration time to.
 |          nx: Set expiry only when the field has no expiry.
 |          xx: Set expiry only when the field has an existing expiry.
 |          gt: Set expiry only when the new expiry is greater than the current one.
 |          lt: Set expiry only when the new expiry is less than the current one.
 |
 |      Returns:
 |          Returns a list which contains for each field in the request:
 |              - `-2` if the field does not exist, or if the key does not exist.
 |              - `0` if the specified NX | XX | GT | LT condition was not met.
 |              - `1` if the expiration time was set or updated.
 |              - `2` if the field was deleted because the specified expiration time is
 |                in the past.
 |
 |  hpexpireat(self, name: 'KeyT', unix_time_milliseconds: 'AbsExpiryT', *fields: 'FieldT', nx: 'bool' = False, xx: 'bool' = False, gt: 'bool' = False, lt: 'bool' = False) -> 'list[int] | Awaitable[list[int]]'
 |      Sets or updates the expiration time for fields within a hash key, using an
 |      absolute Unix timestamp in milliseconds.
 |
 |      If a field already has an expiration time, the behavior of the update can be
 |      controlled using the `nx`, `xx`, `gt`, and `lt` parameters.
 |
 |      The return value provides detailed information about the outcome for each field.
 |
 |      For more information, see https://redis.io/commands/hpexpireat
 |
 |      Args:
 |          name: The name of the hash key.
 |          unix_time_milliseconds: Expiration time as Unix timestamp in milliseconds.
 |                                  Can be an integer or a Python `datetime` object.
 |          fields: List of fields within the hash to apply the expiry.
 |          nx: Set expiry only when the field has no expiry.
 |          xx: Set expiry only when the field has an existing expiry.
 |          gt: Set expiry only when the new expiry is greater than the current one.
 |          lt: Set expiry only when the new expiry is less than the current one.
 |
 |      Returns:
 |          Returns a list which contains for each field in the request:
 |              - `-2` if the field does not exist, or if the key does not exist.
 |              - `0` if the specified NX | XX | GT | LT condition was not met.
 |              - `1` if the expiration time was set or updated.
 |              - `2` if the field was deleted because the specified expiration time is
 |                in the past.
 |
 |  hpexpiretime(self, key: 'KeyT', *fields: 'FieldT') -> 'list[int] | Awaitable[list[int]]'
 |      Returns the expiration times of hash fields as Unix timestamps in milliseconds.
 |
 |      For more information, see https://redis.io/commands/hpexpiretime
 |
 |      Args:
 |          key: The hash key.
 |          fields: A list of fields within the hash for which to get the expiration
 |                  time.
 |
 |      Returns:
 |          Returns a list which contains for each field in the request:
 |              - `-2` if the field does not exist, or if the key does not exist.
 |              - `-1` if the field exists but has no associated expire time.
 |              - A positive integer representing the expiration Unix timestamp in
 |                milliseconds, if the field has an associated expiration time.
 |
 |  hpttl(self, key: 'KeyT', *fields: 'FieldT') -> 'list[int] | Awaitable[list[int]]'
 |      Returns the TTL (Time To Live) in milliseconds for each specified field within a
 |      hash key.
 |
 |      For more information, see https://redis.io/commands/hpttl
 |
 |      Args:
 |          key: The hash key.
 |          fields: A list of fields within the hash for which to get the TTL.
 |
 |      Returns:
 |          Returns a list which contains for each field in the request:
 |              - `-2` if the field does not exist, or if the key does not exist.
 |              - `-1` if the field exists but has no associated expire time.
 |              - A positive integer representing the TTL in milliseconds if the field
 |                has an associated expiration time.
 |
 |  hset(self, name: 'KeyT', key: 'FieldT | None' = None, value: 'EncodableT | None' = None, mapping: 'Mapping[FieldT, EncodableT] | None' = None, items: 'Sequence[EncodableT] | None' = None) -> 'int | Awaitable[int]'
 |      Set ``key`` to ``value`` within hash ``name``,
 |      ``mapping`` accepts a dict of key/value pairs that will be
 |      added to hash ``name``.
 |      ``items`` accepts a list of key/value pairs that will be
 |      added to hash ``name``.
 |      Returns the number of fields that were added.
 |
 |      For more information, see https://redis.io/commands/hset
 |
 |  hsetex(self, name: 'KeyT', key: 'FieldT | None' = None, value: 'EncodableT | None' = None, mapping: 'Mapping[FieldT, EncodableT] | None' = None, items: 'Sequence[EncodableT] | None' = None, ex: 'ExpiryT | None' = None, px: 'ExpiryT | None' = None, exat: 'AbsExpiryT | None' = None, pxat: 'AbsExpiryT | None' = None, data_persist_option: 'HashDataPersistOptions | None' = None, keepttl: 'bool' = False) -> 'int | Awaitable[int]'
 |      Set ``key`` to ``value`` within hash ``name``
 |
 |      ``mapping`` accepts a dict of key/value pairs that will be
 |      added to hash ``name``.
 |
 |      ``items`` accepts a list of key/value pairs that will be
 |      added to hash ``name``.
 |
 |      ``ex`` sets an expire flag on ``keys`` for ``ex`` seconds.
 |
 |      ``px`` sets an expire flag on ``keys`` for ``px`` milliseconds.
 |
 |      ``exat`` sets an expire flag on ``keys`` for ``ex`` seconds,
 |          specified in unix time.
 |
 |      ``pxat`` sets an expire flag on ``keys`` for ``ex`` milliseconds,
 |          specified in unix time.
 |
 |      ``data_persist_option`` can be set to ``FNX`` or ``FXX`` to control the
 |          behavior of the command.
 |          ``FNX`` will set the value for each provided key to each
 |              provided value only if all do not already exist.
 |          ``FXX`` will set the value for each provided key to each
 |              provided value only if all already exist.
 |
 |      ``keepttl`` if True, retain the time to live associated with the keys.
 |
 |      Returns the number of fields that were added.
 |
 |      Available since Redis 8.0
 |      For more information, see https://redis.io/commands/hsetex
 |
 |  hsetnx(self, name: 'KeyT', key: 'FieldT', value: 'EncodableT') -> 'int | Awaitable[int]'
 |      Set ``key`` to ``value`` within hash ``name`` if ``key`` does not
 |      exist.  Returns 1 if HSETNX created a field, otherwise 0.
 |
 |      For more information, see https://redis.io/commands/hsetnx
 |
 |  hstrlen(self, name: 'KeyT', key: 'FieldT') -> 'int | Awaitable[int]'
 |      Return the number of bytes stored in the value of ``key``
 |      within hash ``name``
 |
 |      For more information, see https://redis.io/commands/hstrlen
 |
 |  httl(self, key: 'KeyT', *fields: 'FieldT') -> 'list[int] | Awaitable[list[int]]'
 |      Returns the TTL (Time To Live) in seconds for each specified field within a hash
 |      key.
 |
 |      For more information, see https://redis.io/commands/httl
 |
 |      Args:
 |          key: The hash key.
 |          fields: A list of fields within the hash for which to get the TTL.
 |
 |      Returns:
 |          Returns a list which contains for each field in the request:
 |              - `-2` if the field does not exist, or if the key does not exist.
 |              - `-1` if the field exists but has no associated expire time.
 |              - A positive integer representing the TTL in seconds if the field has
 |                an associated expiration time.
 |
 |  hvals(self, name: 'KeyT') -> 'list[bytes | str] | Awaitable[list[bytes | str]]'
 |      Return the list of values within hash ``name``
 |
 |      For more information, see https://redis.io/commands/hvals
 |
 |  ----------------------------------------------------------------------
 |  Methods inherited from redis.commands.core.GeoCommands:
 |
 |  geoadd(self, name: 'KeyT', values: 'Sequence[EncodableT]', nx: 'bool' = False, xx: 'bool' = False, ch: 'bool' = False) -> 'int | Awaitable[int]'
 |      Add the specified geospatial items to the specified key identified
 |      by the ``name`` argument. The Geospatial items are given as ordered
 |      members of the ``values`` argument, each item or place is formed by
 |      the triad longitude, latitude and name.
 |
 |      Note: You can use ZREM to remove elements.
 |
 |      ``nx`` forces ZADD to only create new elements and not to update
 |      scores for elements that already exist.
 |
 |      ``xx`` forces ZADD to only update scores of elements that already
 |      exist. New elements will not be added.
 |
 |      ``ch`` modifies the return value to be the numbers of elements changed.
 |      Changed elements include new elements that were added and elements
 |      whose scores changed.
 |
 |      For more information, see https://redis.io/commands/geoadd
 |
 |  geodist(self, name: 'KeyT', place1: 'FieldT', place2: 'FieldT', unit: 'str | None' = None) -> 'float | None | Awaitable[float | None]'
 |      Return the distance between ``place1`` and ``place2`` members of the
 |      ``name`` key.
 |      The units must be one of the following : m, km mi, ft. By default
 |      meters are used.
 |
 |      For more information, see https://redis.io/commands/geodist
 |
 |  geohash(self, name: 'KeyT', *values: 'FieldT') -> 'list[bytes | str | None] | Awaitable[list[bytes | str | None]]'
 |      Return the geo hash string for each item of ``values`` members of
 |      the specified key identified by the ``name`` argument.
 |
 |      For more information, see https://redis.io/commands/geohash
 |
 |  geopos(self, name: 'KeyT', *values: 'FieldT') -> 'list[GeoCoordinate | None] | Awaitable[list[GeoCoordinate | None]]'
 |      Return the positions of each item of ``values`` as members of
 |      the specified key identified by the ``name`` argument. Each position
 |      is represented by the pairs lon and lat.
 |
 |      For more information, see https://redis.io/commands/geopos
 |
 |  georadius(self, name: 'KeyT', longitude: 'float', latitude: 'float', radius: 'float', unit: 'str | None' = None, withdist: 'bool' = False, withcoord: 'bool' = False, withhash: 'bool' = False, count: 'int | None' = None, sort: 'str | None' = None, store: 'KeyT | None' = None, store_dist: 'KeyT | None' = None, any: 'bool' = False) -> 'GeoRadiusResponse | Awaitable[GeoRadiusResponse]'
 |      Return the members of the specified key identified by the
 |      ``name`` argument which are within the borders of the area specified
 |      with the ``latitude`` and ``longitude`` location and the maximum
 |      distance from the center specified by the ``radius`` value.
 |
 |      The units must be one of the following : m, km mi, ft. By default
 |
 |      ``withdist`` indicates to return the distances of each place.
 |
 |      ``withcoord`` indicates to return the latitude and longitude of
 |      each place.
 |
 |      ``withhash`` indicates to return the geohash string of each place.
 |
 |      ``count`` indicates to return the number of elements up to N.
 |
 |      ``sort`` indicates to return the places in a sorted way, ASC for
 |      nearest to fairest and DESC for fairest to nearest.
 |
 |      ``store`` indicates to save the places names in a sorted set named
 |      with a specific key, each element of the destination sorted set is
 |      populated with the score got from the original geo sorted set.
 |
 |      ``store_dist`` indicates to save the places names in a sorted set
 |      named with a specific key, instead of ``store`` the sorted set
 |      destination score is set with the distance.
 |
 |      For more information, see https://redis.io/commands/georadius
 |
 |  georadiusbymember(self, name: 'KeyT', member: 'FieldT', radius: 'float', unit: 'str | None' = None, withdist: 'bool' = False, withcoord: 'bool' = False, withhash: 'bool' = False, count: 'int | None' = None, sort: 'str | None' = None, store: 'Union[KeyT, None]' = None, store_dist: 'Union[KeyT, None]' = None, any: 'bool' = False) -> 'GeoRadiusResponse | Awaitable[GeoRadiusResponse]'
 |      This command is exactly like ``georadius`` with the sole difference
 |      that instead of taking, as the center of the area to query, a longitude
 |      and latitude value, it takes the name of a member already existing
 |      inside the geospatial index represented by the sorted set.
 |
 |      For more information, see https://redis.io/commands/georadiusbymember
 |
 |  geosearch(self, name: 'KeyT', member: 'FieldT | None' = None, longitude: 'float | None' = None, latitude: 'float | None' = None, unit: 'str' = 'm', radius: 'float | None' = None, width: 'float | None' = None, height: 'float | None' = None, sort: 'str | None' = None, count: 'int | None' = None, any: 'bool' = False, withcoord: 'bool' = False, withdist: 'bool' = False, withhash: 'bool' = False) -> 'GeoSearchResponse | Awaitable[GeoSearchResponse]'
 |      Return the members of specified key identified by the
 |      ``name`` argument, which are within the borders of the
 |      area specified by a given shape. This command extends the
 |      GEORADIUS command, so in addition to searching within circular
 |      areas, it supports searching within rectangular areas.
 |
 |      This command should be used in place of the deprecated
 |      GEORADIUS and GEORADIUSBYMEMBER commands.
 |
 |      ``member`` Use the position of the given existing
 |       member in the sorted set. Can't be given with ``longitude``
 |       and ``latitude``.
 |
 |      ``longitude`` and ``latitude`` Use the position given by
 |      this coordinates. Can't be given with ``member``
 |      ``radius`` Similar to GEORADIUS, search inside circular
 |      area according the given radius. Can't be given with
 |      ``height`` and ``width``.
 |      ``height`` and ``width`` Search inside an axis-aligned
 |      rectangle, determined by the given height and width.
 |      Can't be given with ``radius``
 |
 |      ``unit`` must be one of the following : m, km, mi, ft.
 |      `m` for meters (the default value), `km` for kilometers,
 |      `mi` for miles and `ft` for feet.
 |
 |      ``sort`` indicates to return the places in a sorted way,
 |      ASC for nearest to furthest and DESC for furthest to nearest.
 |
 |      ``count`` limit the results to the first count matching items.
 |
 |      ``any`` is set to True, the command will return as soon as
 |      enough matches are found. Can't be provided without ``count``
 |
 |      ``withdist`` indicates to return the distances of each place.
 |      ``withcoord`` indicates to return the latitude and longitude of
 |      each place.
 |
 |      ``withhash`` indicates to return the geohash string of each place.
 |
 |      For more information, see https://redis.io/commands/geosearch
 |
 |  geosearchstore(self, dest: 'KeyT', name: 'KeyT', member: 'FieldT | None' = None, longitude: 'float | None' = None, latitude: 'float | None' = None, unit: 'str' = 'm', radius: 'float | None' = None, width: 'float | None' = None, height: 'float | None' = None, sort: 'str | None' = None, count: 'int | None' = None, any: 'bool' = False, storedist: 'bool' = False) -> 'int | Awaitable[int]'
 |      This command is like GEOSEARCH, but stores the result in
 |      ``dest``. By default, it stores the results in the destination
 |      sorted set with their geospatial information.
 |      if ``store_dist`` set to True, the command will stores the
 |      items in a sorted set populated with their distance from the
 |      center of the circle or box, as a floating-point number.
 |
 |      For more information, see https://redis.io/commands/geosearchstore
 |
 |  ----------------------------------------------------------------------
 |  Methods inherited from redis.commands.core.ListCommands:
 |
 |  blmpop(self, timeout: 'float', numkeys: 'int', *args: 'str', direction: 'str', count: 'int | None' = 1) -> 'ListMultiPopResponse | Awaitable[ListMultiPopResponse]'
 |      Pop ``count`` values (default 1) from first non-empty in the list
 |      of provided key names.
 |
 |      When all lists are empty this command blocks the connection until another
 |      client pushes to it or until the timeout, timeout of 0 blocks indefinitely
 |
 |      For more information, see https://redis.io/commands/blmpop
 |
 |  blpop(self, keys: 'KeysT', timeout: 'Number | None' = 0) -> 'BlockingListPopResponse | Awaitable[BlockingListPopResponse]'
 |      LPOP a value off of the first non-empty list
 |      named in ``keys``.
 |
 |      If none of the lists in ``keys`` has a value to LPOP, then block
 |      for ``timeout`` seconds, or until a value gets pushed on to one
 |      of the lists.
 |
 |      If timeout is 0, then block indefinitely.
 |
 |      For more information, see https://redis.io/commands/blpop
 |
 |  brpop(self, keys: 'KeysT', timeout: 'Number | None' = 0) -> 'BlockingListPopResponse | Awaitable[BlockingListPopResponse]'
 |      RPOP a value off of the first non-empty list
 |      named in ``keys``.
 |
 |      If none of the lists in ``keys`` has a value to RPOP, then block
 |      for ``timeout`` seconds, or until a value gets pushed on to one
 |      of the lists.
 |
 |      If timeout is 0, then block indefinitely.
 |
 |      For more information, see https://redis.io/commands/brpop
 |
 |  brpoplpush(self, src: 'KeyT', dst: 'KeyT', timeout: 'Number | None' = 0) -> 'bytes | str | None | Awaitable[bytes | str | None]'
 |      Pop a value off the tail of ``src``, push it on the head of ``dst``
 |      and then return it.
 |
 |      This command blocks until a value is in ``src`` or until ``timeout``
 |      seconds elapse, whichever is first. A ``timeout`` value of 0 blocks
 |      forever.
 |
 |      For more information, see https://redis.io/commands/brpoplpush
 |
 |  lindex(self, name: 'KeyT', index: 'int') -> 'bytes | str | None | Awaitable[bytes | str | None]'
 |      Return the item from list ``name`` at position ``index``
 |
 |      Negative indexes are supported and will return an item at the
 |      end of the list
 |
 |      For more information, see https://redis.io/commands/lindex
 |
 |  linsert(self, name: 'KeyT', where: 'str', refvalue: 'str', value: 'str') -> 'int | Awaitable[int]'
 |      Insert ``value`` in list ``name`` either immediately before or after
 |      [``where``] ``refvalue``
 |
 |      Returns the new length of the list on success or -1 if ``refvalue``
 |      is not in the list.
 |
 |      For more information, see https://redis.io/commands/linsert
 |
 |  llen(self, name: 'KeyT') -> 'int | Awaitable[int]'
 |      Return the length of the list ``name``
 |
 |      For more information, see https://redis.io/commands/llen
 |
 |  lmpop(self, num_keys: 'int', *args: 'str', direction: 'str', count: 'int | None' = 1) -> 'ListMultiPopResponse | Awaitable[ListMultiPopResponse]'
 |      Pop ``count`` values (default 1) first non-empty list key from the list
 |      of args provided key names.
 |
 |      For more information, see https://redis.io/commands/lmpop
 |
 |  lpop(self, name: 'KeyT', count: 'int | None' = None) -> 'bytes | str | list[bytes | str] | None | Awaitable[bytes | str | list[bytes | str] | None]'
 |      Removes and returns the first elements of the list ``name``.
 |
 |      By default, the command pops a single element from the beginning of
 |      the list. When provided with the optional ``count`` argument, the reply
 |      will consist of up to count elements, depending on the list's length.
 |
 |      For more information, see https://redis.io/commands/lpop
 |
 |  lpos(self, name: 'KeyT', value: 'str', rank: 'int | None' = None, count: 'int | None' = None, maxlen: 'int | None' = None) -> 'int | list[int] | None | Awaitable[int | list[int] | None]'
 |      Get position of ``value`` within the list ``name``
 |
 |       If specified, ``rank`` indicates the "rank" of the first element to
 |       return in case there are multiple copies of ``value`` in the list.
 |       By default, LPOS returns the position of the first occurrence of
 |       ``value`` in the list. When ``rank`` 2, LPOS returns the position of
 |       the second ``value`` in the list. If ``rank`` is negative, LPOS
 |       searches the list in reverse. For example, -1 would return the
 |       position of the last occurrence of ``value`` and -2 would return the
 |       position of the next to last occurrence of ``value``.
 |
 |       If specified, ``count`` indicates that LPOS should return a list of
 |       up to ``count`` positions. A ``count`` of 2 would return a list of
 |       up to 2 positions. A ``count`` of 0 returns a list of all positions
 |       matching ``value``. When ``count`` is specified and but ``value``
 |       does not exist in the list, an empty list is returned.
 |
 |       If specified, ``maxlen`` indicates the maximum number of list
 |       elements to scan. A ``maxlen`` of 1000 will only return the
 |       position(s) of items within the first 1000 entries in the list.
 |       A ``maxlen`` of 0 (the default) will scan the entire list.
 |
 |       For more information, see https://redis.io/commands/lpos
 |
 |  lpush(self, name: 'KeyT', *values: 'FieldT') -> 'int | Awaitable[int]'
 |      Push ``values`` onto the head of the list ``name``
 |
 |      For more information, see https://redis.io/commands/lpush
 |
 |  lpushx(self, name: 'KeyT', *values: 'FieldT') -> 'int | Awaitable[int]'
 |      Push ``value`` onto the head of the list ``name`` if ``name`` exists
 |
 |      For more information, see https://redis.io/commands/lpushx
 |
 |  lrange(self, name: 'KeyT', start: 'int', end: 'int') -> 'list[bytes | str] | Awaitable[list[bytes | str]]'
 |      Return a slice of the list ``name`` between
 |      position ``start`` and ``end``
 |
 |      ``start`` and ``end`` can be negative numbers just like
 |      Python slicing notation
 |
 |      For more information, see https://redis.io/commands/lrange
 |
 |  lrem(self, name: 'KeyT', count: 'int', value: 'str') -> 'int | Awaitable[int]'
 |      Remove the first ``count`` occurrences of elements equal to ``value``
 |      from the list stored at ``name``.
 |
 |      The count argument influences the operation in the following ways:
 |          count > 0: Remove elements equal to value moving from head to tail.
 |          count < 0: Remove elements equal to value moving from tail to head.
 |          count = 0: Remove all elements equal to value.
 |
 |          For more information, see https://redis.io/commands/lrem
 |
 |  lset(self, name: 'KeyT', index: 'int', value: 'str') -> 'bool | Awaitable[bool]'
 |      Set element at ``index`` of list ``name`` to ``value``
 |
 |      For more information, see https://redis.io/commands/lset
 |
 |  ltrim(self, name: 'KeyT', start: 'int', end: 'int') -> 'bool | Awaitable[bool]'
 |      Trim the list ``name``, removing all values not within the slice
 |      between ``start`` and ``end``
 |
 |      ``start`` and ``end`` can be negative numbers just like
 |      Python slicing notation
 |
 |      For more information, see https://redis.io/commands/ltrim
 |
 |  rpop(self, name: 'KeyT', count: 'int | None' = None) -> 'bytes | str | list[bytes | str] | None | Awaitable[bytes | str | list[bytes | str] | None]'
 |      Removes and returns the last elements of the list ``name``.
 |
 |      By default, the command pops a single element from the end of the list.
 |      When provided with the optional ``count`` argument, the reply will
 |      consist of up to count elements, depending on the list's length.
 |
 |      For more information, see https://redis.io/commands/rpop
 |
 |  rpoplpush(self, src: 'KeyT', dst: 'KeyT') -> 'bytes | str | None | Awaitable[bytes | str | None]'
 |      RPOP a value off of the ``src`` list and atomically LPUSH it
 |      on to the ``dst`` list.  Returns the value.
 |
 |      For more information, see https://redis.io/commands/rpoplpush
 |
 |  rpush(self, name: 'KeyT', *values: 'FieldT') -> 'int | Awaitable[int]'
 |      Push ``values`` onto the tail of the list ``name``
 |
 |      For more information, see https://redis.io/commands/rpush
 |
 |  rpushx(self, name: 'KeyT', *values: 'str') -> 'int | Awaitable[int]'
 |      Push ``value`` onto the tail of the list ``name`` if ``name`` exists
 |
 |      For more information, see https://redis.io/commands/rpushx
 |
 |  sort(self, name: 'KeyT', start: 'int | None' = None, num: 'int | None' = None, by: 'str | None' = None, get: 'list[str] | None' = None, desc: 'bool' = False, alpha: 'bool' = False, store: 'str | None' = None, groups: 'bool | None' = False) -> 'SortResponse | Awaitable[SortResponse]'
 |      Sort and return the list, set or sorted set at ``name``.
 |
 |      ``start`` and ``num`` allow for paging through the sorted data
 |
 |      ``by`` allows using an external key to weight and sort the items.
 |          Use an "*" to indicate where in the key the item value is located
 |
 |      ``get`` allows for returning items from external keys rather than the
 |          sorted data itself.  Use an "*" to indicate where in the key
 |          the item value is located
 |
 |      ``desc`` allows for reversing the sort
 |
 |      ``alpha`` allows for sorting lexicographically rather than numerically
 |
 |      ``store`` allows for storing the result of the sort into
 |          the key ``store``
 |
 |      ``groups`` if set to True and if ``get`` contains at least two
 |          elements, sort will return a list of tuples, each containing the
 |          values fetched from the arguments to ``get``.
 |
 |      For more information, see https://redis.io/commands/sort
 |
 |  sort_ro(self, key: 'str', start: 'int | None' = None, num: 'int | None' = None, by: 'str | None' = None, get: 'list[str] | None' = None, desc: 'bool' = False, alpha: 'bool' = False) -> 'list[bytes | str] | Awaitable[list[bytes | str]]'
 |      Returns the elements contained in the list, set or sorted set at key.
 |      (read-only variant of the SORT command)
 |
 |      ``start`` and ``num`` allow for paging through the sorted data
 |
 |      ``by`` allows using an external key to weight and sort the items.
 |          Use an "*" to indicate where in the key the item value is located
 |
 |      ``get`` allows for returning items from external keys rather than the
 |          sorted data itself.  Use an "*" to indicate where in the key
 |          the item value is located
 |
 |      ``desc`` allows for reversing the sort
 |
 |      ``alpha`` allows for sorting lexicographically rather than numerically
 |
 |      For more information, see https://redis.io/commands/sort_ro
 |
 |  ----------------------------------------------------------------------
 |  Methods inherited from redis.commands.core.ArrayCommands:
 |
 |  arcount(self, name: 'KeyT') -> 'int | Awaitable[int]'
 |      Return the number of non-empty elements in the array stored at
 |      ``name``. Returns 0 if ``name`` does not exist.
 |
 |      For more information, see https://redis.io/commands/arcount
 |
 |  ardel(self, name: 'KeyT', *indices: 'int') -> 'int | Awaitable[int]'
 |      Delete elements at the specified ``indices`` in the array stored at
 |      ``name``. Deleting an index that does not exist counts as zero
 |      elements deleted and does not modify the array.
 |
 |      Returns the number of elements deleted.
 |
 |      For more information, see https://redis.io/commands/ardel
 |
 |  ardelrange(self, name: 'KeyT', *ranges: 'tuple[int, int]') -> 'int | Awaitable[int]'
 |      Delete elements within one or more inclusive index ranges in the
 |      array stored at ``name``. Each range is a ``(start, end)`` tuple.
 |      If ``start`` is greater than ``end`` for a given pair, the range is
 |      processed in ascending order regardless. Multiple pairs may overlap;
 |      each element is counted at most once.
 |
 |      Returns the number of elements deleted.
 |
 |      For more information, see https://redis.io/commands/ardelrange
 |
 |  arget(self, name: 'KeyT', index: 'int') -> 'bytes | str | None | Awaitable[bytes | str | None]'
 |      Return the value at ``index`` in the array stored at ``name``.
 |
 |      Returns ``None`` if ``name`` does not exist or no value is set at
 |      ``index``.
 |
 |      For more information, see https://redis.io/commands/arget
 |
 |  argetrange(self, name: 'KeyT', start: 'int', end: 'int') -> 'list[bytes | str | None] | Awaitable[list[bytes | str | None]]'
 |      Return the values in the inclusive index range [``start``, ``end``]
 |      in the array stored at ``name``. If ``start`` is greater than ``end``,
 |      elements are returned in reverse index order.
 |
 |      For more information, see https://redis.io/commands/argetrange
 |
 |  argrep(self, name: 'KeyT', start: 'int', end: 'int', predicates: 'list[tuple[ArrayPredicateType, EncodableT]]', combinator: 'ArrayPredicateCombinator | None' = None, limit: 'int | None' = None, withvalues: 'bool' = False, nocase: 'bool' = False) -> 'list[int] | list[list[int | bytes | str]] | Awaitable[list[int] | list[list[int | bytes | str]]]'
 |      Search elements of the array stored at ``name`` within the inclusive
 |      index range [``start``, ``end``] using one or more textual
 |      ``predicates``. Each predicate is a ``(type, value)`` tuple where
 |      ``type`` is a member of ``ArrayPredicateType``
 |      (``EXACT``, ``MATCH``, ``GLOB``, ``RE``).
 |
 |      Multiple predicates are combined via ``combinator``
 |      (``ArrayPredicateCombinator.AND`` or ``OR``); the server defaults to
 |      OR when omitted. ``limit`` caps the number of matches.
 |      ``withvalues=True`` returns a list of ``[index, value]`` pairs
 |      (``[[idx, val], ...]``) instead of a flat list of indices.
 |      ``nocase=True`` makes all comparisons case-insensitive.
 |
 |      Without ``withvalues``, returns a flat list of matching indices in
 |      traversal order. With ``withvalues``, returns a list of
 |      ``[index, value]`` pairs in traversal order. Empty slots are
 |      skipped.
 |
 |      For more information, see https://redis.io/commands/argrep
 |
 |  arinfo(self, name: 'KeyT', full: 'bool' = False) -> 'dict[str, int] | Awaitable[dict[str, int]]'
 |      Return metadata about the array stored at ``name`` as a dictionary.
 |      When ``full`` is ``True``, additionally include per-slice statistics
 |      (dense/sparse slice counts, average sizes, fill rates), which makes
 |      the call O(N) instead of O(1).
 |
 |      Raises ``ResponseError`` when the key does not exist.
 |
 |      For more information, see https://redis.io/commands/arinfo
 |
 |  arinsert(self, name: 'KeyT', *values: 'FieldT') -> 'int | Awaitable[int]'
 |      Insert one or more ``values`` at consecutive indices in the array
 |      stored at ``name``, beginning at the current insert cursor position.
 |      The cursor advances by one for each value inserted. Use ``ARNEXT``
 |      to inspect the current cursor position and ``ARSEEK`` to reposition
 |      it.
 |
 |      Returns the last index where a value was inserted.
 |
 |      For more information, see https://redis.io/commands/arinsert
 |
 |  arlastitems(self, name: 'KeyT', count: 'int', rev: 'bool' = False) -> 'list[bytes | str | None] | Awaitable[list[bytes | str | None]]'
 |      Return up to ``count`` most recently inserted elements from the array
 |      stored at ``name``. If the array contains fewer elements than
 |      ``count``, all elements are returned.
 |
 |      When ``rev`` is ``True``, elements are returned in reverse
 |      chronological order (most recent first) instead of the default
 |      oldest-first order.
 |
 |      For more information, see https://redis.io/commands/arlastitems
 |
 |  arlen(self, name: 'KeyT') -> 'int | Awaitable[int]'
 |      Return the length of the array stored at ``name``, defined as the
 |      maximum set index plus one. Returns 0 if ``name`` does not exist.
 |
 |      For more information, see https://redis.io/commands/arlen
 |
 |  armget(self, name: 'KeyT', *indices: 'int') -> 'list[bytes | str | None] | Awaitable[list[bytes | str | None]]'
 |      Return the values at the specified ``indices`` in the array stored at
 |      ``name``. The reply preserves the order of the requested indices and
 |      returns ``None`` for any index that is not set or when ``name`` does
 |      not exist.
 |
 |      For more information, see https://redis.io/commands/armget
 |
 |  armset(self, name: 'KeyT', mapping: 'Mapping[int, FieldT]') -> 'int | Awaitable[int]'
 |      Set multiple index/value pairs in the array stored at ``name``.
 |      ``mapping`` is a dictionary of zero-based integer indices to values.
 |      Pairs may be non-contiguous and in any order.
 |
 |      Returns the number of new slots that were set (previously empty).
 |
 |      For more information, see https://redis.io/commands/armset
 |
 |  arnext(self, name: 'KeyT') -> 'int | None | Awaitable[int | None]'
 |      Return the next index ``ARINSERT`` would use for the array stored at
 |      ``name``. Returns 0 if ``name`` does not exist or no insert happened
 |      yet, and ``None`` when the insertion cursor is exhausted (next insert
 |      would overflow).
 |
 |      For more information, see https://redis.io/commands/arnext
 |
 |  arop(self, name: 'KeyT', start: 'int', end: 'int', operation: 'ArrayAggregateOperations', value: 'EncodableT | None' = None) -> 'bytes | str | int | None | Awaitable[bytes | str | int | None]'
 |      Perform an aggregate ``operation`` on elements of the array stored at
 |      ``name`` in the inclusive index range [``start``, ``end``]. The range
 |      is always scanned from the lower to the higher index regardless of
 |      argument order.
 |
 |      ``operation`` is one of the members of ``ArrayAggregateOperations``.
 |      ``value`` is required when ``operation`` is
 |      ``ArrayAggregateOperations.MATCH`` and specifies the value to compare
 |      against.
 |
 |      Returns a bulk string for ``SUM``, ``MIN`` and ``MAX``, an integer
 |      for ``AND``, ``OR``, ``XOR``, ``MATCH`` and ``USED``, or ``None``
 |      when no elements match the operation.
 |
 |      For more information, see https://redis.io/commands/arop
 |
 |  arring(self, name: 'KeyT', size: 'int', *values: 'FieldT') -> 'int | Awaitable[int]'
 |      Insert one or more ``values`` into the array stored at ``name`` as a
 |      fixed-size ring buffer of ``size`` slots. Each value is placed at
 |      ``insert_idx % size``, wrapping back to index 0 once the end is
 |      reached and overwriting older values when full. If ``size`` is
 |      smaller than the current window, the array is truncated to fit.
 |
 |      Returns the last index where a value was inserted.
 |
 |      For more information, see https://redis.io/commands/arring
 |
 |  arscan(self, name: 'KeyT', start: 'int', end: 'int', limit: 'int | None' = None) -> 'list[list[int | bytes | str]] | Awaitable[list[list[int | bytes | str]]]'
 |      Iterate populated elements of the array stored at ``name`` in the
 |      inclusive range [``start``, ``end``] and return a list of
 |      ``[index, value]`` pairs in traversal order:
 |      ``[[idx1, val1], [idx2, val2], ...]``. Empty slots are skipped. If
 |      ``start`` is greater than ``end``, the iteration is reversed.
 |
 |      ``limit`` caps the number of populated elements returned. When
 |      omitted, all populated elements in range are returned.
 |
 |      For more information, see https://redis.io/commands/arscan
 |
 |  arseek(self, name: 'KeyT', index: 'int') -> 'int | Awaitable[int]'
 |      Set the insert cursor of the array stored at ``name`` to ``index``.
 |      Subsequent ``ARINSERT`` and ``ARRING`` operations begin inserting at
 |      this position.
 |
 |      Returns 1 if the cursor was set, 0 if ``name`` does not exist.
 |
 |      For more information, see https://redis.io/commands/arseek
 |
 |  arset(self, name: 'KeyT', index: 'int', *values: 'FieldT') -> 'int | Awaitable[int]'
 |      Set one or more contiguous ``values`` in the array stored at ``name``
 |      starting at ``index``. When multiple values are provided, they are
 |      stored at consecutive indices beginning at ``index``.
 |
 |      Returns the number of new slots that were set (previously empty).
 |
 |      For more information, see https://redis.io/commands/arset
 |
 |  ----------------------------------------------------------------------
 |  Methods inherited from redis.commands.core.ScanCommands:
 |
 |  hscan(self, name: 'KeyT', cursor: 'int' = 0, match: 'PatternT | None' = None, count: 'int | None' = None, no_values: 'bool | None' = None) -> 'HScanResponse | Awaitable[HScanResponse]'
 |      Incrementally return key/value slices in a hash. Also return a cursor
 |      indicating the scan position.
 |
 |      ``match`` allows for filtering the keys by pattern
 |
 |      ``count`` allows for hint the minimum number of returns
 |
 |      ``no_values`` indicates to return only the keys, without values.
 |
 |      For more information, see https://redis.io/commands/hscan
 |
 |  hscan_iter(self, name: 'KeyT', match: 'Union[PatternT, None]' = None, count: 'Optional[int]' = None, no_values: 'Union[bool, None]' = None) -> 'Iterator'
 |      Make an iterator using the HSCAN command so that the client doesn't
 |      need to remember the cursor position.
 |
 |      ``match`` allows for filtering the keys by pattern
 |
 |      ``count`` allows for hint the minimum number of returns
 |
 |      ``no_values`` indicates to return only the keys, without values
 |
 |  scan(self, cursor: 'int' = 0, match: 'PatternT | None' = None, count: 'int | None' = None, _type: 'str | None' = None, **kwargs) -> 'ScanResponse | Awaitable[ScanResponse]'
 |      Incrementally return lists of key names. Also return a cursor
 |      indicating the scan position.
 |
 |      ``match`` allows for filtering the keys by pattern
 |
 |      ``count`` provides a hint to Redis about the number of keys to
 |          return per batch.
 |
 |      ``_type`` filters the returned values by a particular Redis type.
 |          Stock Redis instances allow for the following types:
 |          HASH, LIST, SET, STREAM, STRING, ZSET
 |          Additionally, Redis modules can expose other types as well.
 |
 |      For more information, see https://redis.io/commands/scan
 |
 |  sscan(self, name: 'KeyT', cursor: 'int' = 0, match: 'PatternT | None' = None, count: 'int | None' = None) -> 'ScanResponse | Awaitable[ScanResponse]'
 |      Incrementally return lists of elements in a set. Also return a cursor
 |      indicating the scan position.
 |
 |      ``match`` allows for filtering the keys by pattern
 |
 |      ``count`` allows for hint the minimum number of returns
 |
 |      For more information, see https://redis.io/commands/sscan
 |
 |  sscan_iter(self, name: 'KeyT', match: 'Union[PatternT, None]' = None, count: 'Optional[int]' = None) -> 'Iterator'
 |      Make an iterator using the SSCAN command so that the client doesn't
 |      need to remember the cursor position.
 |
 |      ``match`` allows for filtering the keys by pattern
 |
 |      ``count`` allows for hint the minimum number of returns
 |
 |  zscan(self, name: 'KeyT', cursor: 'int' = 0, match: 'PatternT | None' = None, count: 'int | None' = None, score_cast_func: 'type | Callable' = <class 'float'>) -> 'ZScanResponse | Awaitable[ZScanResponse]'
 |      Incrementally return lists of elements in a sorted set. Also return a
 |      cursor indicating the scan position.
 |
 |      ``match`` allows for filtering the keys by pattern
 |
 |      ``count`` allows for hint the minimum number of returns
 |
 |      ``score_cast_func`` a callable used to cast the score return value
 |
 |      For more information, see https://redis.io/commands/zscan
 |
 |  zscan_iter(self, name: 'KeyT', match: 'Union[PatternT, None]' = None, count: 'Optional[int]' = None, score_cast_func: 'Union[type, Callable]' = <class 'float'>) -> 'Iterator'
 |      Make an iterator using the ZSCAN command so that the client doesn't
 |      need to remember the cursor position.
 |
 |      ``match`` allows for filtering the keys by pattern
 |
 |      ``count`` allows for hint the minimum number of returns
 |
 |      ``score_cast_func`` a callable used to cast the score return value
 |
 |  ----------------------------------------------------------------------
 |  Methods inherited from redis.commands.core.SetCommands:
 |
 |  sadd(self, name: 'KeyT', *values: 'FieldT') -> 'int | Awaitable[int]'
 |      Add ``value(s)`` to set ``name``
 |
 |      For more information, see https://redis.io/commands/sadd
 |
 |  scard(self, name: 'KeyT') -> 'int | Awaitable[int]'
 |      Return the number of elements in set ``name``
 |
 |      For more information, see https://redis.io/commands/scard
 |
 |  sdiff(self, keys: 'List', *args: 'List') -> 'set[bytes | str] | Awaitable[set[bytes | str]]'
 |      Return the difference of sets specified by ``keys``
 |
 |      For more information, see https://redis.io/commands/sdiff
 |
 |  sdiffcard(self, numkeys: 'int', keys: 'List[KeyT]', limit: 'int' = 0) -> 'int | Awaitable[int]'
 |      Return the cardinality of the difference between the first set and all
 |      the successive sets specified by ``keys``, without returning the
 |      difference itself.
 |
 |      When LIMIT is provided (defaults to 0 and means unlimited), the returned
 |      cardinality is capped at ``limit`` and the server may stop the
 |      computation once the capped result is known.
 |
 |      For more information, see https://redis.io/commands/sdiffcard
 |
 |  sdiffstore(self, dest: 'str', keys: 'List', *args: 'List') -> 'int | Awaitable[int]'
 |      Store the difference of sets specified by ``keys`` into a new
 |      set named ``dest``.  Returns the number of keys in the new set.
 |
 |      For more information, see https://redis.io/commands/sdiffstore
 |
 |  sinter(self, keys: 'List', *args: 'List') -> 'set[bytes | str] | Awaitable[set[bytes | str]]'
 |      Return the intersection of sets specified by ``keys``
 |
 |      For more information, see https://redis.io/commands/sinter
 |
 |  sintercard(self, numkeys: 'int', keys: 'List[KeyT]', limit: 'int' = 0) -> 'int | Awaitable[int]'
 |      Return the cardinality of the intersect of multiple sets specified by ``keys``.
 |
 |      When LIMIT provided (defaults to 0 and means unlimited), if the intersection
 |      cardinality reaches limit partway through the computation, the algorithm will
 |      exit and yield limit as the cardinality
 |
 |      For more information, see https://redis.io/commands/sintercard
 |
 |  sinterstore(self, dest: 'KeyT', keys: 'List', *args: 'List') -> 'int | Awaitable[int]'
 |      Store the intersection of sets specified by ``keys`` into a new
 |      set named ``dest``.  Returns the number of keys in the new set.
 |
 |      For more information, see https://redis.io/commands/sinterstore
 |
 |  sismember(self, name: 'KeyT', value: 'str') -> 'Literal[0] | Literal[1] | Awaitable[Literal[0] | Literal[1]]'
 |      Return whether ``value`` is a member of set ``name``:
 |      - 1 if the value is a member of the set.
 |      - 0 if the value is not a member of the set or if key does not exist.
 |
 |      For more information, see https://redis.io/commands/sismember
 |
 |  smembers(self, name: 'KeyT') -> 'set[bytes | str] | Awaitable[set[bytes | str]]'
 |      Return all members of the set ``name``
 |
 |      For more information, see https://redis.io/commands/smembers
 |
 |  smismember(self, name: 'KeyT', values: 'List', *args: 'List') -> 'list[Literal[0] | Literal[1]] | Awaitable[list[Literal[0] | Literal[1]]]'
 |      Return whether each value in ``values`` is a member of the set ``name``
 |      as a list of ``int`` in the order of ``values``:
 |      - 1 if the value is a member of the set.
 |      - 0 if the value is not a member of the set or if key does not exist.
 |
 |      For more information, see https://redis.io/commands/smismember
 |
 |  smove(self, src: 'KeyT', dst: 'KeyT', value: 'str') -> 'bool | Awaitable[bool]'
 |      Move ``value`` from set ``src`` to set ``dst`` atomically
 |
 |      For more information, see https://redis.io/commands/smove
 |
 |  spop(self, name: 'KeyT', count: 'int | None' = None) -> 'bytes | str | set[bytes | str] | None | Awaitable[bytes | str | set[bytes | str] | None]'
 |      Remove and return a random member of set ``name``
 |
 |      For more information, see https://redis.io/commands/spop
 |
 |  srandmember(self, name: 'KeyT', number: 'int | None' = None) -> 'bytes | str | list[bytes | str] | None | Awaitable[bytes | str | list[bytes | str] | None]'
 |      If ``number`` is None, returns a random member of set ``name``.
 |
 |      If ``number`` is supplied, returns a list of ``number`` random
 |      members of set ``name``. Note this is only available when running
 |      Redis 2.6+.
 |
 |      For more information, see https://redis.io/commands/srandmember
 |
 |  srem(self, name: 'KeyT', *values: 'FieldT') -> 'int | Awaitable[int]'
 |      Remove ``values`` from set ``name``
 |
 |      For more information, see https://redis.io/commands/srem
 |
 |  sunion(self, keys: 'List', *args: 'List') -> 'set[bytes | str] | Awaitable[set[bytes | str]]'
 |      Return the union of sets specified by ``keys``
 |
 |      For more information, see https://redis.io/commands/sunion
 |
 |  sunioncard(self, numkeys: 'int', keys: 'List[KeyT]', limit: 'int' = 0, approx: 'bool' = False) -> 'int | Awaitable[int]'
 |      Return the cardinality of the union of multiple sets specified by
 |      ``keys``, without returning the union itself.
 |
 |      When ``approx`` is True, the ``APPROX`` option is sent and the server
 |      returns an approximate cardinality computed using HyperLogLog.
 |
 |      When LIMIT is provided (defaults to 0 and means unlimited), the returned
 |      cardinality is capped at ``limit``. In exact mode the result equals
 |      ``limit`` when the real cardinality exceeds ``limit``; in approximate
 |      mode the result will not exceed ``limit``. Options are emitted in the
 |      canonical order ``APPROX`` before ``LIMIT``.
 |
 |      For more information, see https://redis.io/commands/sunioncard
 |
 |  sunionstore(self, dest: 'KeyT', keys: 'List', *args: 'List') -> 'int | Awaitable[int]'
 |      Store the union of sets specified by ``keys`` into a new
 |      set named ``dest``.  Returns the number of keys in the new set.
 |
 |      For more information, see https://redis.io/commands/sunionstore
 |
 |  ----------------------------------------------------------------------
 |  Methods inherited from redis.commands.core.StreamCommands:
 |
 |  xack(self, name: 'KeyT', groupname: 'GroupT', *ids: 'StreamIdT') -> 'int | Awaitable[int]'
 |      Acknowledges the successful processing of one or more messages.
 |
 |      Args:
 |          name: name of the stream.
 |          groupname: name of the consumer group.
 |          *ids: message ids to acknowledge.
 |
 |      For more information, see https://redis.io/commands/xack
 |
 |  xackdel(self, name: 'KeyT', groupname: 'GroupT', *ids: 'StreamIdT', ref_policy: "Literal['KEEPREF', 'DELREF', 'ACKED']" = 'KEEPREF') -> 'int | Awaitable[int]'
 |      Combines the functionality of XACK and XDEL. Acknowledges the specified
 |      message IDs in the given consumer group and simultaneously attempts to
 |      delete the corresponding entries from the stream.
 |
 |  xadd(self, name: 'KeyT', fields: 'Dict[FieldT, EncodableT]', id: 'StreamIdT' = '*', maxlen: 'Optional[int]' = None, approximate: 'bool' = True, nomkstream: 'bool' = False, minid: 'Union[StreamIdT, None]' = None, limit: 'int | None' = None, ref_policy: "Literal['KEEPREF', 'DELREF', 'ACKED'] | None" = None, idmpauto: 'str | None' = None, idmp: 'tuple[str, bytes] | None' = None) -> 'bytes | str | Awaitable[bytes | str]'
 |      Add to a stream.
 |      name: name of the stream
 |      fields: dict of field/value pairs to insert into the stream
 |      id: Location to insert this record. By default it is appended.
 |      maxlen: truncate old stream members beyond this size.
 |      Can't be specified with minid.
 |      approximate: actual stream length may be slightly more than maxlen
 |      nomkstream: When set to true, do not make a stream
 |      minid: the minimum id in the stream to query.
 |      Can't be specified with maxlen.
 |      limit: specifies the maximum number of entries to retrieve
 |      ref_policy: optional reference policy for consumer groups when trimming:
 |          - KEEPREF (default): When trimming, preserves references in consumer groups' PEL
 |          - DELREF: When trimming, removes all references from consumer groups' PEL
 |          - ACKED: When trimming, only removes entries acknowledged by all consumer groups
 |      idmpauto: Producer ID for automatic idempotent ID calculation.
 |          Automatically calculates an idempotent ID based on entry content to prevent
 |          duplicate entries. Can only be used with id='*'. Creates an IDMP map if it
 |          doesn't exist yet. The producer ID must be unique per producer and consistent
 |          across restarts.
 |      idmp: Tuple of (producer_id, idempotent_id) for explicit idempotent ID.
 |          Uses a specific idempotent ID to prevent duplicate entries. Can only be used
 |          with id='*'. The producer ID must be unique per producer and consistent across
 |          restarts. The idempotent ID must be unique per message and per producer.
 |          Shorter idempotent IDs require less memory and allow faster processing.
 |          Creates an IDMP map if it doesn't exist yet.
 |
 |      For more information, see https://redis.io/commands/xadd
 |
 |  xautoclaim(self, name: 'KeyT', groupname: 'GroupT', consumername: 'ConsumerT', min_idle_time: 'int', start_id: 'StreamIdT' = '0-0', count: 'int | None' = None, justid: 'bool' = False) -> 'list[Any] | Awaitable[list[Any]]'
 |      Transfers ownership of pending stream entries that match the specified
 |      criteria. Conceptually, equivalent to calling XPENDING and then XCLAIM,
 |      but provides a more straightforward way to deal with message delivery
 |      failures via SCAN-like semantics.
 |      name: name of the stream.
 |      groupname: name of the consumer group.
 |      consumername: name of a consumer that claims the message.
 |      min_idle_time: filter messages that were idle less than this amount of
 |      milliseconds.
 |      start_id: filter messages with equal or greater ID.
 |      count: optional integer, upper limit of the number of entries that the
 |      command attempts to claim. Set to 100 by default.
 |      justid: optional boolean, false by default. Return just an array of IDs
 |      of messages successfully claimed, without returning the actual message
 |
 |      For more information, see https://redis.io/commands/xautoclaim
 |
 |  xcfgset(self, name: 'KeyT', idmp_duration: 'int | None' = None, idmp_maxsize: 'int | None' = None) -> 'bytes | str | Awaitable[bytes | str]'
 |      Configure the idempotency parameters for a stream's IDMP map.
 |
 |      Sets how long Redis remembers each idempotent ID (iid) and the maximum
 |      number of iids to track. This command clears the existing IDMP map
 |      (Redis forgets all previously stored iids), but only if the configuration
 |      value actually changes.
 |
 |      Args:
 |          name: The name of the stream.
 |          idmp_duration: How long Redis remembers each iid in seconds.
 |              Default: 100 seconds (or value set by stream-idmp-duration config).
 |              Minimum: 1 second, Maximum: 300 seconds.
 |              Redis won't forget an iid for this duration (unless maxsize is reached).
 |              Should accommodate application crash recovery time.
 |          idmp_maxsize: Maximum number of iids Redis remembers per producer ID (pid).
 |              Default: 100 iids (or value set by stream-idmp-maxsize config).
 |              Minimum: 1 iid, Maximum: 1,000,000 (1M) iids.
 |              Should be set to: mark-delay [in msec] × (messages/msec) + margin.
 |              Example: 10K msgs/sec (10 msgs/msec), 80 msec mark-delay
 |              → maxsize = 10 × 80 + margin = 1000 iids.
 |
 |      Returns:
 |          OK on success.
 |
 |      For more information, see https://redis.io/commands/xcfgset
 |
 |  xclaim(self, name: 'KeyT', groupname: 'GroupT', consumername: 'ConsumerT', min_idle_time: 'int', message_ids: 'Union[List[StreamIdT], Tuple[StreamIdT]]', idle: 'int | None' = None, time: 'int | None' = None, retrycount: 'int | None' = None, force: 'bool' = False, justid: 'bool' = False) -> 'XClaimResponse | Awaitable[XClaimResponse]'
 |      Changes the ownership of a pending message.
 |
 |      name: name of the stream.
 |
 |      groupname: name of the consumer group.
 |
 |      consumername: name of a consumer that claims the message.
 |
 |      min_idle_time: filter messages that were idle less than this amount of
 |      milliseconds
 |
 |      message_ids: non-empty list or tuple of message IDs to claim
 |
 |      idle: optional. Set the idle time (last time it was delivered) of the
 |      message in ms
 |
 |      time: optional integer. This is the same as idle but instead of a
 |      relative amount of milliseconds, it sets the idle time to a specific
 |      Unix time (in milliseconds).
 |
 |      retrycount: optional integer. set the retry counter to the specified
 |      value. This counter is incremented every time a message is delivered
 |      again.
 |
 |      force: optional boolean, false by default. Creates the pending message
 |      entry in the PEL even if certain specified IDs are not already in the
 |      PEL assigned to a different client.
 |
 |      justid: optional boolean, false by default. Return just an array of IDs
 |      of messages successfully claimed, without returning the actual message
 |
 |      For more information, see https://redis.io/commands/xclaim
 |
 |  xdel(self, name: 'KeyT', *ids: 'StreamIdT') -> 'int | Awaitable[int]'
 |      Deletes one or more messages from a stream.
 |
 |      Args:
 |          name: name of the stream.
 |          *ids: message ids to delete.
 |
 |      For more information, see https://redis.io/commands/xdel
 |
 |  xdelex(self, name: 'KeyT', *ids: 'StreamIdT', ref_policy: "Literal['KEEPREF', 'DELREF', 'ACKED']" = 'KEEPREF') -> 'int | Awaitable[int]'
 |      Extended version of XDEL that provides more control over how message entries
 |      are deleted concerning consumer groups.
 |
 |  xgroup_create(self, name: 'KeyT', groupname: 'GroupT', id: 'StreamIdT' = '$', mkstream: 'bool' = False, entries_read: 'int | None' = None) -> 'bool | Awaitable[bool]'
 |      Create a new consumer group associated with a stream.
 |      name: name of the stream.
 |      groupname: name of the consumer group.
 |      id: ID of the last item in the stream to consider already delivered.
 |
 |      For more information, see https://redis.io/commands/xgroup-create
 |
 |  xgroup_createconsumer(self, name: 'KeyT', groupname: 'GroupT', consumername: 'ConsumerT') -> 'int | Awaitable[int]'
 |      Consumers in a consumer group are auto-created every time a new
 |      consumer name is mentioned by some command.
 |      They can be explicitly created by using this command.
 |      name: name of the stream.
 |      groupname: name of the consumer group.
 |      consumername: name of consumer to create.
 |
 |      See: https://redis.io/commands/xgroup-createconsumer
 |
 |  xgroup_delconsumer(self, name: 'KeyT', groupname: 'GroupT', consumername: 'ConsumerT') -> 'int | Awaitable[int]'
 |      Remove a specific consumer from a consumer group.
 |      Returns the number of pending messages that the consumer had before it
 |      was deleted.
 |      name: name of the stream.
 |      groupname: name of the consumer group.
 |      consumername: name of consumer to delete
 |
 |      For more information, see https://redis.io/commands/xgroup-delconsumer
 |
 |  xgroup_destroy(self, name: 'KeyT', groupname: 'GroupT') -> 'bool | Awaitable[bool]'
 |      Destroy a consumer group.
 |      name: name of the stream.
 |      groupname: name of the consumer group.
 |
 |      For more information, see https://redis.io/commands/xgroup-destroy
 |
 |  xgroup_setid(self, name: 'KeyT', groupname: 'GroupT', id: 'StreamIdT', entries_read: 'int | None' = None) -> 'bool | Awaitable[bool]'
 |      Set the consumer group last delivered ID to something else.
 |      name: name of the stream.
 |      groupname: name of the consumer group.
 |      id: ID of the last item in the stream to consider already delivered.
 |
 |      For more information, see https://redis.io/commands/xgroup-setid
 |
 |  xinfo_consumers(self, name: 'KeyT', groupname: 'GroupT') -> 'list[dict[str, Any]] | Awaitable[list[dict[str, Any]]]'
 |      Returns general information about the consumers in the group.
 |      name: name of the stream.
 |      groupname: name of the consumer group.
 |
 |      For more information, see https://redis.io/commands/xinfo-consumers
 |
 |  xinfo_groups(self, name: 'KeyT') -> 'list[dict[str, Any]] | Awaitable[list[dict[str, Any]]]'
 |      Returns general information about the consumer groups of the stream.
 |      name: name of the stream.
 |
 |      For more information, see https://redis.io/commands/xinfo-groups
 |
 |  xinfo_stream(self, name: 'KeyT', full: 'bool' = False) -> 'dict[str, Any] | Awaitable[dict[str, Any]]'
 |      Returns general information about the stream.
 |      name: name of the stream.
 |      full: optional boolean, false by default. Return full summary
 |
 |      For more information, see https://redis.io/commands/xinfo-stream
 |
 |  xlen(self, name: 'KeyT') -> 'int | Awaitable[int]'
 |      Returns the number of elements in a given stream.
 |
 |      For more information, see https://redis.io/commands/xlen
 |
 |  xnack(self, name: 'KeyT', groupname: 'GroupT', mode: "Literal['SILENT', 'FAIL', 'FATAL']", *ids: 'StreamIdT', retrycount: 'int | None' = None, force: 'bool' = False) -> 'int | Awaitable[int]'
 |      Negatively acknowledges one or more messages in a consumer group's
 |      Pending Entries List (PEL).
 |
 |      Args:
 |          name: name of the stream.
 |          groupname: name of the consumer group.
 |          mode: the nacking mode. One of SILENT, FAIL, or FATAL.
 |              SILENT: consumer shutting down; decrements delivery counter.
 |              FAIL: consumer unable to process; delivery counter unchanged.
 |              FATAL: invalid/malicious message; delivery counter set to max.
 |          *ids: one or more message IDs to NACK.
 |          retrycount: optional integer >= 0. Overrides the mode's implicit
 |              delivery counter adjustment with an exact value.
 |          force: if True, creates a new unowned PEL entry for any ID not
 |              already in the group's PEL.
 |
 |      Returns:
 |          The number of messages successfully NACKed.
 |
 |      For more information, see https://redis.io/commands/xnack
 |
 |  xpending(self, name: 'KeyT', groupname: 'GroupT') -> 'dict[str, Any] | Awaitable[dict[str, Any]]'
 |      Returns information about pending messages of a group.
 |      name: name of the stream.
 |      groupname: name of the consumer group.
 |
 |      For more information, see https://redis.io/commands/xpending
 |
 |  xpending_range(self, name: 'KeyT', groupname: 'GroupT', min: 'StreamIdT', max: 'StreamIdT', count: 'int', consumername: 'ConsumerT | None' = None, idle: 'int | None' = None) -> 'XPendingRangeResponse | Awaitable[XPendingRangeResponse]'
 |      Returns information about pending messages, in a range.
 |
 |      name: name of the stream.
 |      groupname: name of the consumer group.
 |      idle: available from  version 6.2. filter entries by their
 |      idle-time, given in milliseconds (optional).
 |      min: minimum stream ID.
 |      max: maximum stream ID.
 |      count: number of messages to return
 |      consumername: name of a consumer to filter by (optional).
 |
 |  xrange(self, name: 'KeyT', min: 'StreamIdT' = '-', max: 'StreamIdT' = '+', count: 'int | None' = None) -> 'StreamRangeResponse | None | Awaitable[StreamRangeResponse | None]'
 |      Read stream values within an interval.
 |
 |      name: name of the stream.
 |
 |      start: first stream ID. defaults to '-',
 |             meaning the earliest available.
 |
 |      finish: last stream ID. defaults to '+',
 |              meaning the latest available.
 |
 |      count: if set, only return this many items, beginning with the
 |             earliest available.
 |
 |      For more information, see https://redis.io/commands/xrange
 |
 |  xread(self, streams: 'Dict[KeyT, StreamIdT]', count: 'int | None' = None, block: 'int | None' = None, max_count: 'int | None' = None, max_size: 'int | None' = None) -> 'XReadResponse | Awaitable[XReadResponse]'
 |      Block and monitor multiple streams for new data.
 |
 |      streams: a dict of stream names to stream IDs, where
 |                 IDs indicate the last ID already seen.
 |
 |      count: if set, only return this many items per stream, beginning with
 |             the earliest available.
 |
 |      block: number of milliseconds to wait, if nothing already present.
 |
 |      max_count: if set, cap the total number of entries returned across all
 |                 streams combined. Unlike ``count`` (a per-stream limit),
 |                 this is a cumulative cap over the whole reply. Must be a
 |                 positive integer and, when ``count`` is also set, must be
 |                 greater than or equal to ``count``. Requires Redis >= 8.10.0.
 |
 |      max_size: if set, a soft cap on the total server reply size in bytes
 |                across all streams combined. Measured server-side including
 |                protocol overhead, so it is not an exact application-payload
 |                size guarantee; a single available entry larger than the cap
 |                may still be returned. Must be a positive integer. Requires
 |                Redis >= 8.10.0.
 |
 |      For more information, see https://redis.io/commands/xread
 |
 |  xreadgroup(self, groupname: 'str', consumername: 'str', streams: 'Dict[KeyT, StreamIdT]', count: 'int | None' = None, block: 'int | None' = None, noack: 'bool' = False, claim_min_idle_time: 'int | None' = None, max_count: 'int | None' = None, max_size: 'int | None' = None) -> 'XReadGroupResponse | Awaitable[XReadGroupResponse]'
 |      Read from a stream via a consumer group.
 |
 |      groupname: name of the consumer group.
 |
 |      consumername: name of the requesting consumer.
 |
 |      streams: a dict of stream names to stream IDs, where
 |             IDs indicate the last ID already seen.
 |
 |      count: if set, only return this many items per stream, beginning with
 |             the earliest available.
 |
 |      block: number of milliseconds to wait, if nothing already present.
 |      noack: do not add messages to the PEL
 |
 |      claim_min_idle_time: accepts an integer type and represents a
 |                           time interval in milliseconds
 |
 |      max_count: if set, cap the total number of entries returned across all
 |                 streams combined. Unlike ``count`` (a per-stream limit),
 |                 this is a cumulative cap over the whole reply. Must be a
 |                 positive integer and, when ``count`` is also set, must be
 |                 greater than or equal to ``count``. Requires Redis 8.10.0.
 |
 |      max_size: if set, a soft cap on the total server reply size in bytes
 |                across all streams combined. Measured server-side including
 |                protocol overhead, so it is not an exact application-payload
 |                size guarantee; a single available entry larger than the cap
 |                may still be returned. Must be a positive integer. Requires
 |                Redis 8.10.0.
 |
 |      For more information, see https://redis.io/commands/xreadgroup
 |
 |  xrevrange(self, name: 'KeyT', max: 'StreamIdT' = '+', min: 'StreamIdT' = '-', count: 'int | None' = None) -> 'StreamRangeResponse | None | Awaitable[StreamRangeResponse | None]'
 |      Read stream values within an interval, in reverse order.
 |
 |      name: name of the stream
 |
 |      start: first stream ID. defaults to '+',
 |             meaning the latest available.
 |
 |      finish: last stream ID. defaults to '-',
 |              meaning the earliest available.
 |
 |      count: if set, only return this many items, beginning with the
 |             latest available.
 |
 |      For more information, see https://redis.io/commands/xrevrange
 |
 |  xtrim(self, name: 'KeyT', maxlen: 'int | None' = None, approximate: 'bool' = True, minid: 'StreamIdT | None' = None, limit: 'int | None' = None, ref_policy: "Literal['KEEPREF', 'DELREF', 'ACKED'] | None" = None) -> 'int | Awaitable[int]'
 |      Trims old messages from a stream.
 |      name: name of the stream.
 |      maxlen: truncate old stream messages beyond this size
 |      Can't be specified with minid.
 |      approximate: actual stream length may be slightly more than maxlen
 |      minid: the minimum id in the stream to query
 |      Can't be specified with maxlen.
 |      limit: specifies the maximum number of entries to retrieve
 |      ref_policy: optional reference policy for consumer groups:
 |          - KEEPREF (default): Trims entries but preserves references in consumer groups' PEL
 |          - DELREF: Trims entries and removes all references from consumer groups' PEL
 |          - ACKED: Only trims entries that were read and acknowledged by all consumer groups
 |
 |      For more information, see https://redis.io/commands/xtrim
 |
 |  ----------------------------------------------------------------------
 |  Methods inherited from redis.commands.core.SortedSetCommands:
 |
 |  bzmpop(self, timeout: 'float', numkeys: 'int', keys: 'List[str]', min: 'bool | None' = False, max: 'bool | None' = False, count: 'int | None' = 1) -> 'ZMPopResponse | Awaitable[ZMPopResponse]'
 |      Pop ``count`` values (default 1) off of the first non-empty sorted set
 |      named in the ``keys`` list.
 |
 |      If none of the sorted sets in ``keys`` has a value to pop,
 |      then block for ``timeout`` seconds, or until a member gets added
 |      to one of the sorted sets.
 |
 |      If timeout is 0, then block indefinitely.
 |
 |      For more information, see https://redis.io/commands/bzmpop
 |
 |  bzpopmax(self, keys: 'KeysT', timeout: 'TimeoutSecT' = 0) -> 'BlockingZSetPopResponse | Awaitable[BlockingZSetPopResponse]'
 |      ZPOPMAX a value off of the first non-empty sorted set
 |      named in the ``keys`` list.
 |
 |      If none of the sorted sets in ``keys`` has a value to ZPOPMAX,
 |      then block for ``timeout`` seconds, or until a member gets added
 |      to one of the sorted sets.
 |
 |      If timeout is 0, then block indefinitely.
 |
 |      For more information, see https://redis.io/commands/bzpopmax
 |
 |  bzpopmin(self, keys: 'KeysT', timeout: 'TimeoutSecT' = 0) -> 'BlockingZSetPopResponse | Awaitable[BlockingZSetPopResponse]'
 |      ZPOPMIN a value off of the first non-empty sorted set
 |      named in the ``keys`` list.
 |
 |      If none of the sorted sets in ``keys`` has a value to ZPOPMIN,
 |      then block for ``timeout`` seconds, or until a member gets added
 |      to one of the sorted sets.
 |
 |      If timeout is 0, then block indefinitely.
 |
 |      For more information, see https://redis.io/commands/bzpopmin
 |
 |  zadd(self, name: 'KeyT', mapping: 'Mapping[AnyKeyT, EncodableT]', nx: 'bool' = False, xx: 'bool' = False, ch: 'bool' = False, incr: 'bool' = False, gt: 'bool' = False, lt: 'bool' = False) -> 'int | float | None | Awaitable[int | float | None]'
 |      Set any number of element-name, score pairs to the key ``name``. Pairs
 |      are specified as a dict of element-names keys to score values.
 |
 |      ``nx`` forces ZADD to only create new elements and not to update
 |      scores for elements that already exist.
 |
 |      ``xx`` forces ZADD to only update scores of elements that already
 |      exist. New elements will not be added.
 |
 |      ``ch`` modifies the return value to be the numbers of elements changed.
 |      Changed elements include new elements that were added and elements
 |      whose scores changed.
 |
 |      ``incr`` modifies ZADD to behave like ZINCRBY. In this mode only a
 |      single element/score pair can be specified and the score is the amount
 |      the existing score will be incremented by. When using this mode the
 |      return value of ZADD will be the new score of the element.
 |
 |      ``lt`` only updates existing elements if the new score is less than
 |      the current score. This flag doesn't prevent adding new elements.
 |
 |      ``gt`` only updates existing elements if the new score is greater than
 |      the current score. This flag doesn't prevent adding new elements.
 |
 |      The return value of ZADD varies based on the mode specified. With no
 |      options, ZADD returns the number of new elements added to the sorted
 |      set.
 |
 |      ``nx``, ``lt``, and ``gt`` are mutually exclusive options.
 |
 |      See: https://redis.io/commands/ZADD
 |
 |  zcard(self, name: 'KeyT') -> 'int | Awaitable[int]'
 |      Return the number of elements in the sorted set ``name``
 |
 |      For more information, see https://redis.io/commands/zcard
 |
 |  zcount(self, name: 'KeyT', min: 'ZScoreBoundT', max: 'ZScoreBoundT') -> 'int | Awaitable[int]'
 |      Returns the number of elements in the sorted set at key ``name`` with
 |      a score between ``min`` and ``max``.
 |
 |      For more information, see https://redis.io/commands/zcount
 |
 |  zdiff(self, keys: 'KeysT', withscores: 'bool' = False) -> 'ZSetRangeResponse | Awaitable[ZSetRangeResponse]'
 |      Returns the difference between the first and all successive input
 |      sorted sets provided in ``keys``.
 |
 |      For more information, see https://redis.io/commands/zdiff
 |
 |  zdiffstore(self, dest: 'KeyT', keys: 'KeysT') -> 'int | Awaitable[int]'
 |      Computes the difference between the first and all successive input
 |      sorted sets provided in ``keys`` and stores the result in ``dest``.
 |
 |      For more information, see https://redis.io/commands/zdiffstore
 |
 |  zincrby(self, name: 'KeyT', amount: 'float', value: 'EncodableT') -> 'float | None | Awaitable[float | None]'
 |      Increment the score of ``value`` in sorted set ``name`` by ``amount``
 |
 |      For more information, see https://redis.io/commands/zincrby
 |
 |  zinter(self, keys: 'KeysT', aggregate: 'str | None' = None, withscores: 'bool' = False) -> 'ZSetRangeResponse | Awaitable[ZSetRangeResponse]'
 |      Return the intersect of multiple sorted sets specified by ``keys``.
 |
 |      With the ``aggregate`` option, it is possible to specify how the
 |      results of the intersection are aggregated. Available aggregation
 |      modes:
 |
 |      - ``SUM`` (default): the score of an element is summed across the
 |        inputs where it exists.
 |        Score = SUM(score₁×weight₁, score₂×weight₂, ...)
 |      - ``MIN``: the resulting set will contain the minimum score of an
 |        element across the inputs where it exists.
 |        Score = MIN(score₁×weight₁, score₂×weight₂, ...)
 |      - ``MAX``: the resulting set will contain the maximum score of an
 |        element across the inputs where it exists.
 |        Score = MAX(score₁×weight₁, score₂×weight₂, ...)
 |      - ``COUNT``: ignores the original scores and counts weighted set
 |        membership. Each element's score is the sum of the weights of
 |        the input sets that contain it.
 |        Score = SUM(weight₁, weight₂, ...) for sets containing the element.
 |        When all weights are 1 (default), the score equals the number
 |        of input sets containing the element.
 |
 |      For more information, see https://redis.io/commands/zinter
 |
 |  zintercard(self, numkeys: 'int', keys: 'List[str]', limit: 'int' = 0) -> 'int | Awaitable[int]'
 |      Return the cardinality of the intersect of multiple sorted sets
 |      specified by ``keys``.
 |      When LIMIT provided (defaults to 0 and means unlimited), if the intersection
 |      cardinality reaches limit partway through the computation, the algorithm will
 |      exit and yield limit as the cardinality
 |
 |      For more information, see https://redis.io/commands/zintercard
 |
 |  zinterstore(self, dest: 'KeyT', keys: 'Sequence[KeyT] | Mapping[AnyKeyT, float]', aggregate: 'str | None' = None) -> 'int | Awaitable[int]'
 |      Intersect multiple sorted sets specified by ``keys`` into a new
 |      sorted set, ``dest``. Scores in the destination will be aggregated
 |      based on the ``aggregate``.
 |
 |      Available aggregation modes:
 |
 |      - ``SUM`` (default): the score of an element is summed across the
 |        inputs where it exists.
 |        Score = SUM(score₁×weight₁, score₂×weight₂, ...)
 |      - ``MIN``: the resulting set will contain the minimum score of an
 |        element across the inputs where it exists.
 |        Score = MIN(score₁×weight₁, score₂×weight₂, ...)
 |      - ``MAX``: the resulting set will contain the maximum score of an
 |        element across the inputs where it exists.
 |        Score = MAX(score₁×weight₁, score₂×weight₂, ...)
 |      - ``COUNT``: ignores the original scores and counts weighted set
 |        membership. Each element's score is the sum of the weights of
 |        the input sets that contain it.
 |        Score = SUM(weight₁, weight₂, ...) for sets containing the element.
 |        When all weights are 1 (default), the score equals the number
 |        of input sets containing the element.
 |
 |      For more information, see https://redis.io/commands/zinterstore
 |
 |  zlexcount(self, name: 'KeyT', min: 'EncodableT', max: 'EncodableT') -> 'int | Awaitable[int]'
 |      Return the number of items in the sorted set ``name`` between the
 |      lexicographical range ``min`` and ``max``.
 |
 |      For more information, see https://redis.io/commands/zlexcount
 |
 |  zmpop(self, num_keys: 'int', keys: 'List[str]', min: 'bool | None' = False, max: 'bool | None' = False, count: 'int | None' = 1) -> 'ZMPopResponse | Awaitable[ZMPopResponse]'
 |      Pop ``count`` values (default 1) off of the first non-empty sorted set
 |      named in the ``keys`` list.
 |      For more information, see https://redis.io/commands/zmpop
 |
 |  zmscore(self, key: 'KeyT', members: 'List[str]') -> 'list[float | None] | Awaitable[list[float | None]]'
 |      Returns the scores associated with the specified members
 |      in the sorted set stored at key.
 |      ``members`` should be a list of the member name.
 |      Return type is a list of score.
 |      If the member does not exist, a None will be returned
 |      in corresponding position.
 |
 |      For more information, see https://redis.io/commands/zmscore
 |
 |  zpopmax(self, name: 'KeyT', count: 'int | None' = None) -> 'ZSetRangeResponse | Awaitable[ZSetRangeResponse]'
 |      Remove and return up to ``count`` members with the highest scores
 |      from the sorted set ``name``.
 |
 |      For more information, see https://redis.io/commands/zpopmax
 |
 |  zpopmin(self, name: 'KeyT', count: 'int | None' = None) -> 'ZSetRangeResponse | Awaitable[ZSetRangeResponse]'
 |      Remove and return up to ``count`` members with the lowest scores
 |      from the sorted set ``name``.
 |
 |      For more information, see https://redis.io/commands/zpopmin
 |
 |  zrandmember(self, key: 'KeyT', count: 'int | None' = None, withscores: 'bool' = False) -> 'ZRandMemberResponse | Awaitable[ZRandMemberResponse]'
 |      Return a random element from the sorted set value stored at key.
 |
 |      ``count`` if the argument is positive, return an array of distinct
 |      fields. If called with a negative count, the behavior changes and
 |      the command is allowed to return the same field multiple times.
 |      In this case, the number of returned fields is the absolute value
 |      of the specified count.
 |
 |      ``withscores`` The optional WITHSCORES modifier changes the reply so it
 |      includes the respective scores of the randomly selected elements from
 |      the sorted set.
 |
 |      For more information, see https://redis.io/commands/zrandmember
 |
 |  zrange(self, name: 'KeyT', start: 'EncodableT', end: 'EncodableT', desc: 'bool' = False, withscores: 'bool' = False, score_cast_func: 'type | Callable' = <class 'float'>, byscore: 'bool' = False, bylex: 'bool' = False, offset: 'int | None' = None, num: 'int | None' = None) -> 'ZSetRangeResponse | Awaitable[ZSetRangeResponse]'
 |      Return a range of values from sorted set ``name`` between
 |      ``start`` and ``end`` sorted in ascending order.
 |
 |      ``start`` and ``end`` can be negative, indicating the end of the range.
 |
 |      ``desc`` a boolean indicating whether to sort the results in reversed
 |      order.
 |
 |      ``withscores`` indicates to return the scores along with the values.
 |      The return type is a list of (value, score) pairs.
 |
 |      ``score_cast_func`` a callable used to cast the score return value.
 |
 |      ``byscore`` when set to True, returns the range of elements from the
 |      sorted set having scores equal or between ``start`` and ``end``.
 |
 |      ``bylex`` when set to True, returns the range of elements from the
 |      sorted set between the ``start`` and ``end`` lexicographical closed
 |      range intervals.
 |      Valid ``start`` and ``end`` must start with ( or [, in order to specify
 |      whether the range interval is exclusive or inclusive, respectively.
 |
 |      ``offset`` and ``num`` are specified, then return a slice of the range.
 |      Can't be provided when using ``bylex``.
 |
 |      For more information, see https://redis.io/commands/zrange
 |
 |  zrangebylex(self, name: 'KeyT', min: 'EncodableT', max: 'EncodableT', start: 'int | None' = None, num: 'int | None' = None) -> 'list[bytes | str] | Awaitable[list[bytes | str]]'
 |      Return the lexicographical range of values from sorted set ``name``
 |      between ``min`` and ``max``.
 |
 |      If ``start`` and ``num`` are specified, then return a slice of the
 |      range.
 |
 |      For more information, see https://redis.io/commands/zrangebylex
 |
 |  zrangebyscore(self, name: 'KeyT', min: 'ZScoreBoundT', max: 'ZScoreBoundT', start: 'int | None' = None, num: 'int | None' = None, withscores: 'bool' = False, score_cast_func: 'type | Callable' = <class 'float'>) -> 'ZSetRangeResponse | Awaitable[ZSetRangeResponse]'
 |      Return a range of values from the sorted set ``name`` with scores
 |      between ``min`` and ``max``.
 |
 |      If ``start`` and ``num`` are specified, then return a slice
 |      of the range.
 |
 |      ``withscores`` indicates to return the scores along with the values.
 |      The return type is a list of (value, score) pairs
 |
 |      `score_cast_func`` a callable used to cast the score return value
 |
 |      For more information, see https://redis.io/commands/zrangebyscore
 |
 |  zrangestore(self, dest: 'KeyT', name: 'KeyT', start: 'EncodableT', end: 'EncodableT', byscore: 'bool' = False, bylex: 'bool' = False, desc: 'bool' = False, offset: 'int | None' = None, num: 'int | None' = None) -> 'int | Awaitable[int]'
 |      Stores in ``dest`` the result of a range of values from sorted set
 |      ``name`` between ``start`` and ``end`` sorted in ascending order.
 |
 |      ``start`` and ``end`` can be negative, indicating the end of the range.
 |
 |      ``byscore`` when set to True, returns the range of elements from the
 |      sorted set having scores equal or between ``start`` and ``end``.
 |
 |      ``bylex`` when set to True, returns the range of elements from the
 |      sorted set between the ``start`` and ``end`` lexicographical closed
 |      range intervals.
 |      Valid ``start`` and ``end`` must start with ( or [, in order to specify
 |      whether the range interval is exclusive or inclusive, respectively.
 |
 |      ``desc`` a boolean indicating whether to sort the results in reversed
 |      order.
 |
 |      ``offset`` and ``num`` are specified, then return a slice of the range.
 |      Can't be provided when using ``bylex``.
 |
 |      For more information, see https://redis.io/commands/zrangestore
 |
 |  zrank(self, name: 'KeyT', value: 'EncodableT', withscore: 'bool' = False, score_cast_func: 'type | Callable' = <class 'float'>) -> 'int | list[Any] | None | Awaitable[int | list[Any] | None]'
 |      Returns a 0-based value indicating the rank of ``value`` in sorted set
 |      ``name``.
 |      The optional WITHSCORE argument supplements the command's
 |      reply with the score of the element returned.
 |
 |      ``score_cast_func`` a callable used to cast the score return value
 |
 |      For more information, see https://redis.io/commands/zrank
 |
 |  zrem(self, name: 'KeyT', *values: 'FieldT') -> 'int | Awaitable[int]'
 |      Remove member ``values`` from sorted set ``name``
 |
 |      For more information, see https://redis.io/commands/zrem
 |
 |  zremrangebylex(self, name: 'KeyT', min: 'EncodableT', max: 'EncodableT') -> 'int | Awaitable[int]'
 |      Remove all elements in the sorted set ``name`` between the
 |      lexicographical range specified by ``min`` and ``max``.
 |
 |      Returns the number of elements removed.
 |
 |      For more information, see https://redis.io/commands/zremrangebylex
 |
 |  zremrangebyrank(self, name: 'KeyT', min: 'int', max: 'int') -> 'int | Awaitable[int]'
 |      Remove all elements in the sorted set ``name`` with ranks between
 |      ``min`` and ``max``. Values are 0-based, ordered from smallest score
 |      to largest. Values can be negative indicating the highest scores.
 |      Returns the number of elements removed
 |
 |      For more information, see https://redis.io/commands/zremrangebyrank
 |
 |  zremrangebyscore(self, name: 'KeyT', min: 'ZScoreBoundT', max: 'ZScoreBoundT') -> 'int | Awaitable[int]'
 |      Remove all elements in the sorted set ``name`` with scores
 |      between ``min`` and ``max``. Returns the number of elements removed.
 |
 |      For more information, see https://redis.io/commands/zremrangebyscore
 |
 |  zrevrange(self, name: 'KeyT', start: 'int', end: 'int', withscores: 'bool' = False, score_cast_func: 'type | Callable' = <class 'float'>) -> 'ZSetRangeResponse | Awaitable[ZSetRangeResponse]'
 |      Return a range of values from sorted set ``name`` between
 |      ``start`` and ``end`` sorted in descending order.
 |
 |      ``start`` and ``end`` can be negative, indicating the end of the range.
 |
 |      ``withscores`` indicates to return the scores along with the values
 |      The return type is a list of (value, score) pairs
 |
 |      ``score_cast_func`` a callable used to cast the score return value
 |
 |      For more information, see https://redis.io/commands/zrevrange
 |
 |  zrevrangebylex(self, name: 'KeyT', max: 'EncodableT', min: 'EncodableT', start: 'int | None' = None, num: 'int | None' = None) -> 'list[bytes | str] | Awaitable[list[bytes | str]]'
 |      Return the reversed lexicographical range of values from sorted set
 |      ``name`` between ``max`` and ``min``.
 |
 |      If ``start`` and ``num`` are specified, then return a slice of the
 |      range.
 |
 |      For more information, see https://redis.io/commands/zrevrangebylex
 |
 |  zrevrangebyscore(self, name: 'KeyT', max: 'ZScoreBoundT', min: 'ZScoreBoundT', start: 'int | None' = None, num: 'int | None' = None, withscores: 'bool' = False, score_cast_func: 'type | Callable' = <class 'float'>) -> 'ZSetRangeResponse | Awaitable[ZSetRangeResponse]'
 |      Return a range of values from the sorted set ``name`` with scores
 |      between ``min`` and ``max`` in descending order.
 |
 |      If ``start`` and ``num`` are specified, then return a slice
 |      of the range.
 |
 |      ``withscores`` indicates to return the scores along with the values.
 |      The return type is a list of (value, score) pairs
 |
 |      ``score_cast_func`` a callable used to cast the score return value
 |
 |      For more information, see https://redis.io/commands/zrevrangebyscore
 |
 |  zrevrank(self, name: 'KeyT', value: 'EncodableT', withscore: 'bool' = False, score_cast_func: 'type | Callable' = <class 'float'>) -> 'int | list[Any] | None | Awaitable[int | list[Any] | None]'
 |      Returns a 0-based value indicating the descending rank of
 |      ``value`` in sorted set ``name``.
 |      The optional ``withscore`` argument supplements the command's
 |      reply with the score of the element returned.
 |
 |      ``score_cast_func`` a callable used to cast the score return value
 |
 |      For more information, see https://redis.io/commands/zrevrank
 |
 |  zscore(self, name: 'KeyT', value: 'EncodableT') -> 'float | None | Awaitable[float | None]'
 |      Return the score of element ``value`` in sorted set ``name``
 |
 |      For more information, see https://redis.io/commands/zscore
 |
 |  zunion(self, keys: 'Sequence[KeyT] | Mapping[AnyKeyT, float]', aggregate: 'str | None' = None, withscores: 'bool' = False, score_cast_func: 'type | Callable' = <class 'float'>) -> 'ZSetRangeResponse | Awaitable[ZSetRangeResponse]'
 |      Return the union of multiple sorted sets specified by ``keys``.
 |      ``keys`` can be provided as dictionary of keys and their weights.
 |      Scores will be aggregated based on the ``aggregate``, or SUM if
 |      none is provided.
 |
 |      Available aggregation modes:
 |
 |      - ``SUM`` (default): the score of an element is summed across the
 |        inputs where it exists.
 |        Score = SUM(score₁×weight₁, score₂×weight₂, ...)
 |      - ``MIN``: the resulting set will contain the minimum score of an
 |        element across the inputs where it exists.
 |        Score = MIN(score₁×weight₁, score₂×weight₂, ...)
 |      - ``MAX``: the resulting set will contain the maximum score of an
 |        element across the inputs where it exists.
 |        Score = MAX(score₁×weight₁, score₂×weight₂, ...)
 |      - ``COUNT``: ignores the original scores and counts weighted set
 |        membership. Each element's score is the sum of the weights of
 |        the input sets that contain it.
 |        Score = SUM(weight₁, weight₂, ...) for sets containing the element.
 |        When all weights are 1 (default), the score equals the number
 |        of input sets containing the element.
 |
 |      ``score_cast_func`` a callable used to cast the score return value
 |
 |      For more information, see https://redis.io/commands/zunion
 |
 |  zunionstore(self, dest: 'KeyT', keys: 'Sequence[KeyT] | Mapping[AnyKeyT, float]', aggregate: 'str | None' = None) -> 'int | Awaitable[int]'
 |      Union multiple sorted sets specified by ``keys`` into
 |      a new sorted set, ``dest``. Scores in the destination will be
 |      aggregated based on the ``aggregate``, or SUM if none is provided.
 |
 |      Available aggregation modes:
 |
 |      - ``SUM`` (default): the score of an element is summed across the
 |        inputs where it exists.
 |        Score = SUM(score₁×weight₁, score₂×weight₂, ...)
 |      - ``MIN``: the resulting set will contain the minimum score of an
 |        element across the inputs where it exists.
 |        Score = MIN(score₁×weight₁, score₂×weight₂, ...)
 |      - ``MAX``: the resulting set will contain the maximum score of an
 |        element across the inputs where it exists.
 |        Score = MAX(score₁×weight₁, score₂×weight₂, ...)
 |      - ``COUNT``: ignores the original scores and counts weighted set
 |        membership. Each element's score is the sum of the weights of
 |        the input sets that contain it.
 |        Score = SUM(weight₁, weight₂, ...) for sets containing the element.
 |        When all weights are 1 (default), the score equals the number
 |        of input sets containing the element.
 |
 |      For more information, see https://redis.io/commands/zunionstore
 |
 |  ----------------------------------------------------------------------
 |  Methods inherited from redis.commands.core.ScriptCommands:
 |
 |  eval(self, script: 'str', numkeys: 'int', *keys_and_args: 'KeyT | EncodableT') -> 'Any | Awaitable[Any]'
 |      Execute the Lua ``script``, specifying the ``numkeys`` the script
 |      will touch and the key names and argument values in ``keys_and_args``.
 |      Returns the result of the script.
 |
 |      In practice, use the object returned by ``register_script``. This
 |      function exists purely for Redis API completion.
 |
 |      For more information, see  https://redis.io/commands/eval
 |
 |  eval_ro(self, script: 'str', numkeys: 'int', *keys_and_args: 'KeyT | EncodableT') -> 'Any | Awaitable[Any]'
 |      The read-only variant of the EVAL command
 |
 |      Execute the read-only Lua ``script`` specifying the ``numkeys`` the script
 |      will touch and the key names and argument values in ``keys_and_args``.
 |      Returns the result of the script.
 |
 |      For more information, see  https://redis.io/commands/eval_ro
 |
 |  evalsha(self, sha: 'str', numkeys: 'int', *keys_and_args: 'KeyT | EncodableT') -> 'Any | Awaitable[Any]'
 |      Use the ``sha`` to execute a Lua script already registered via EVAL
 |      or SCRIPT LOAD. Specify the ``numkeys`` the script will touch and the
 |      key names and argument values in ``keys_and_args``. Returns the result
 |      of the script.
 |
 |      In practice, use the object returned by ``register_script``. This
 |      function exists purely for Redis API completion.
 |
 |      For more information, see  https://redis.io/commands/evalsha
 |
 |  evalsha_ro(self, sha: 'str', numkeys: 'int', *keys_and_args: 'KeyT | EncodableT') -> 'Any | Awaitable[Any]'
 |      The read-only variant of the EVALSHA command
 |
 |      Use the ``sha`` to execute a read-only Lua script already registered via EVAL
 |      or SCRIPT LOAD. Specify the ``numkeys`` the script will touch and the
 |      key names and argument values in ``keys_and_args``. Returns the result
 |      of the script.
 |
 |      For more information, see  https://redis.io/commands/evalsha_ro
 |
 |  register_script(self: "Union['redis.client.Redis', 'redis.cluster.RedisCluster']", script: 'ScriptTextT') -> 'Script'
 |      Register a Lua ``script`` specifying the ``keys`` it will touch.
 |      Returns a Script object that is callable and hides the complexity of
 |      deal with scripts, keys, and shas. This is the preferred way to work
 |      with Lua scripts.
 |
 |  script_debug(self, *args) -> 'None'
 |
 |  script_exists(self, *args: 'str') -> 'list[bool] | Awaitable[list[bool]]'
 |      Check if a script exists in the script cache by specifying the SHAs of
 |      each script as ``args``. Returns a list of boolean values indicating if
 |      if each already script exists in the cache_data.
 |
 |      For more information, see  https://redis.io/commands/script-exists
 |
 |  script_flush(self, sync_type: "Literal['SYNC'] | Literal['ASYNC'] | None" = None) -> 'bool | Awaitable[bool]'
 |      Flush all scripts from the script cache_data.
 |
 |      ``sync_type`` is by default SYNC (synchronous) but it can also be
 |                    ASYNC.
 |
 |      For more information, see  https://redis.io/commands/script-flush
 |
 |  script_kill(self) -> 'bool | Awaitable[bool]'
 |      Kill the currently executing Lua script
 |
 |      For more information, see https://redis.io/commands/script-kill
 |
 |  script_load(self, script: 'ScriptTextT') -> 'str | Awaitable[str]'
 |      Load a Lua ``script`` into the script cache_data. Returns the SHA.
 |
 |      For more information, see https://redis.io/commands/script-load
 |
 |  ----------------------------------------------------------------------
 |  Methods inherited from redis.commands.core.FunctionCommands:
 |
 |  fcall(self, function, numkeys: 'int', *keys_and_args: 'Any') -> 'Any | Awaitable[Any]'
 |      Invoke a function.
 |
 |      For more information, see https://redis.io/commands/fcall
 |
 |  fcall_ro(self, function, numkeys: 'int', *keys_and_args: 'Any') -> 'Any | Awaitable[Any]'
 |      This is a read-only variant of the FCALL command that cannot
 |      execute commands that modify data.
 |
 |      For more information, see https://redis.io/commands/fcall_ro
 |
 |  function_delete(self, library: 'str') -> 'bool | Awaitable[bool]'
 |      Delete the library called ``library`` and all its functions.
 |
 |      For more information, see https://redis.io/commands/function-delete
 |
 |  function_dump(self) -> 'bytes | Awaitable[bytes]'
 |      Return the serialized payload of loaded libraries.
 |
 |      For more information, see https://redis.io/commands/function-dump
 |
 |  function_flush(self, mode: 'str' = 'SYNC') -> 'bool | Awaitable[bool]'
 |      Deletes all the libraries.
 |
 |      For more information, see https://redis.io/commands/function-flush
 |
 |  function_kill(self) -> 'bytes | str | Awaitable[bytes | str]'
 |      Kill a function that is currently executing.
 |
 |      For more information, see https://redis.io/commands/function-kill
 |
 |  function_list(self, library: 'str | None' = '*', withcode: 'bool | None' = False) -> 'list[Any] | Awaitable[list[Any]]'
 |      Return information about the functions and libraries.
 |
 |      Args:
 |
 |          library: specify a pattern for matching library names
 |          withcode: cause the server to include the libraries source implementation
 |              in the reply
 |
 |  function_load(self, code: 'str', replace: 'bool | None' = False) -> 'bytes | str | Awaitable[bytes | str]'
 |      Load a library to Redis.
 |      :param code: the source code (must start with
 |      Shebang statement that provides a metadata about the library)
 |      :param replace: changes the behavior to overwrite the existing library
 |      with the new contents.
 |      Return the library name that was loaded.
 |
 |      For more information, see https://redis.io/commands/function-load
 |
 |  function_restore(self, payload: 'str', policy: 'str | None' = 'APPEND') -> 'bool | Awaitable[bool]'
 |      Restore libraries from the serialized ``payload``.
 |      You can use the optional policy argument to provide a policy
 |      for handling existing libraries.
 |
 |      For more information, see https://redis.io/commands/function-restore
 |
 |  function_stats(self) -> 'Any | Awaitable[Any]'
 |      Return information about the function that's currently running
 |      and information about the available execution engines.
 |
 |      For more information, see https://redis.io/commands/function-stats
 |
 |  ----------------------------------------------------------------------
 |  Methods inherited from redis.commands.core.ModuleCommands:
 |
 |  command_getkeys(self, *args) -> 'list[bytes | str] | Awaitable[list[bytes | str]]'
 |
 |  module_list(self) -> 'list[dict[Any, Any]] | Awaitable[list[dict[Any, Any]]]'
 |      Returns a list of dictionaries containing the name and version of
 |      all loaded modules.
 |
 |      For more information, see https://redis.io/commands/module-list
 |
 |  module_load(self, path, *args) -> 'bool | Awaitable[bool]'
 |      Loads the module from ``path``.
 |      Passes all ``*args`` to the module, during loading.
 |      Raises ``ModuleError`` if a module is not found at ``path``.
 |
 |      For more information, see https://redis.io/commands/module-load
 |
 |  module_loadex(self, path: 'str', options: 'List[str] | None' = None, args: 'List[str] | None' = None) -> 'bytes | str | Awaitable[bytes | str]'
 |      Loads a module from a dynamic library at runtime with configuration directives.
 |
 |      For more information, see https://redis.io/commands/module-loadex
 |
 |  module_unload(self, name) -> 'bool | Awaitable[bool]'
 |      Unloads the module ``name``.
 |      Raises ``ModuleError`` if ``name`` is not in loaded modules.
 |
 |      For more information, see https://redis.io/commands/module-unload
 |
 |  ----------------------------------------------------------------------
 |  Data and other attributes inherited from redis.typing.CommandsProtocol:
 |
 |  __protocol_attrs__ = {'_event_dispatcher', 'execute_command'}
 |
 |  ----------------------------------------------------------------------
 |  Class methods inherited from typing.Protocol:
 |
 |  __init_subclass__(*args, **kwargs)
 |      This method is called when a class is subclassed.
 |
 |      The default implementation does nothing. It may be
 |      overridden to extend subclasses.
 |
 |  ----------------------------------------------------------------------
 |  Class methods inherited from typing.Generic:
 |
 |  __class_getitem__(...)
 |      Parameterizes a generic class.
 |
 |      At least, parameterizing a generic class is the *main* thing this
 |      method does. For example, for some generic class `Foo`, this is called
 |      when we do `Foo[int]` - there, with `cls=Foo` and `params=int`.
 |
 |      However, note that this method is also called when defining generic
 |      classes in the first place with `class Foo[T]: ...`.
 |
 |  ----------------------------------------------------------------------
 |  Methods inherited from redis.commands.redismodules.RedisModuleCommands:
 |
 |  bf(self) -> 'BFBloom'
 |      Access the bloom namespace.
 |
 |  cf(self) -> 'CFBloom'
 |      Access the bloom namespace.
 |
 |  cms(self) -> 'CMSBloom'
 |      Access the bloom namespace.
 |
 |  ft(self, index_name='idx') -> 'Search'
 |      Access the search namespace, providing support for redis search.
 |
 |  json(self, encoder=<json.encoder.JSONEncoder object at 0x0000017B9C588F50>, decoder=<json.decoder.JSONDecoder object at 0x0000017B9C588FB0>) -> 'JSON'
 |      Access the json namespace, providing support for redis json.
 |
 |  tdigest(self) -> 'TDigestBloom'
 |      Access the bloom namespace.
 |
 |  topk(self) -> 'TOPKBloom'
 |      Access the bloom namespace.
 |
 |  ts(self) -> 'TimeSeries'
 |      Access the timeseries namespace, providing support for
 |      redis timeseries data.
 |
 |  vset(self) -> 'VectorSet'
 |      Access the VectorSet commands namespace.

Python Library Documentation: class RedisClusterException in module redis.exceptions

class RedisClusterException(builtins.Exception)
 |  RedisClusterException(*args: object) -> None
 |
 |  Base exception for the RedisCluster client
 |
 |  Method resolution order:
 |      RedisClusterException
 |      builtins.Exception
 |      builtins.BaseException
 |      builtins.object
 |
 |  Methods defined here:
 |
 |  __init__(self, *args: object) -> None
 |      Initialize self.  See help(type(self)) for accurate signature.
 |
 |  __repr__(self)
 |      Return repr(self).
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors defined here:
 |
 |  __weakref__
 |      list of weak references to the object
 |
 |  ----------------------------------------------------------------------
 |  Static methods inherited from builtins.Exception:
 |
 |  __new__(*args, **kwargs) class method of builtins.Exception
 |      Create and return a new object.  See help(type) for accurate signature.
 |
 |  ----------------------------------------------------------------------
 |  Methods inherited from builtins.BaseException:
 |
 |  __getattribute__(self, name, /)
 |      Return getattr(self, name).
 |
 |  __reduce__(...)
 |      Helper for pickle.
 |
 |  __setstate__(...)
 |
 |  __str__(self, /)
 |      Return str(self).
 |
 |  add_note(...)
 |      Exception.add_note(note) --
 |      add a note to the exception
 |
 |  with_traceback(...)
 |      Exception.with_traceback(tb) --
 |      set self.__traceback__ to tb and return self.
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from builtins.BaseException:
 |
 |  __cause__
 |      exception cause
 |
 |  __context__
 |      exception context
 |
 |  __dict__
 |
 |  __suppress_context__
 |
 |  __traceback__
 |
 |  args

Python Library Documentation: class RedisError in module redis.exceptions

class RedisError(builtins.Exception)
 |  RedisError(*args, status_code: str | None = None)
 |
 |  Method resolution order:
 |      RedisError
 |      builtins.Exception
 |      builtins.BaseException
 |      builtins.object
 |
 |  Methods defined here:
 |
 |  __init__(self, *args, status_code: str | None = None)
 |      Initialize self.  See help(type(self)) for accurate signature.
 |
 |  __repr__(self)
 |      Return repr(self).
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors defined here:
 |
 |  __weakref__
 |      list of weak references to the object
 |
 |  ----------------------------------------------------------------------
 |  Static methods inherited from builtins.Exception:
 |
 |  __new__(*args, **kwargs) class method of builtins.Exception
 |      Create and return a new object.  See help(type) for accurate signature.
 |
 |  ----------------------------------------------------------------------
 |  Methods inherited from builtins.BaseException:
 |
 |  __getattribute__(self, name, /)
 |      Return getattr(self, name).
 |
 |  __reduce__(...)
 |      Helper for pickle.
 |
 |  __setstate__(...)
 |
 |  __str__(self, /)
 |      Return str(self).
 |
 |  add_note(...)
 |      Exception.add_note(note) --
 |      add a note to the exception
 |
 |  with_traceback(...)
 |      Exception.with_traceback(tb) --
 |      set self.__traceback__ to tb and return self.
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from builtins.BaseException:
 |
 |  __cause__
 |      exception cause
 |
 |  __context__
 |      exception context
 |
 |  __dict__
 |
 |  __suppress_context__
 |
 |  __traceback__
 |
 |  args

Python Library Documentation: class ResponseError in module redis.exceptions

class ResponseError(RedisError)
 |  ResponseError(*args, status_code: str | None = None)
 |
 |  Method resolution order:
 |      ResponseError
 |      RedisError
 |      builtins.Exception
 |      builtins.BaseException
 |      builtins.object
 |
 |  Methods inherited from RedisError:
 |
 |  __init__(self, *args, status_code: str | None = None)
 |      Initialize self.  See help(type(self)) for accurate signature.
 |
 |  __repr__(self)
 |      Return repr(self).
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from RedisError:
 |
 |  __weakref__
 |      list of weak references to the object
 |
 |  ----------------------------------------------------------------------
 |  Static methods inherited from builtins.Exception:
 |
 |  __new__(*args, **kwargs) class method of builtins.Exception
 |      Create and return a new object.  See help(type) for accurate signature.
 |
 |  ----------------------------------------------------------------------
 |  Methods inherited from builtins.BaseException:
 |
 |  __getattribute__(self, name, /)
 |      Return getattr(self, name).
 |
 |  __reduce__(...)
 |      Helper for pickle.
 |
 |  __setstate__(...)
 |
 |  __str__(self, /)
 |      Return str(self).
 |
 |  add_note(...)
 |      Exception.add_note(note) --
 |      add a note to the exception
 |
 |  with_traceback(...)
 |      Exception.with_traceback(tb) --
 |      set self.__traceback__ to tb and return self.
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from builtins.BaseException:
 |
 |  __cause__
 |      exception cause
 |
 |  __context__
 |      exception context
 |
 |  __dict__
 |
 |  __suppress_context__
 |
 |  __traceback__
 |
 |  args

Python Library Documentation: class SSLConnection in module redis.connection

class SSLConnection(Connection)
 |  SSLConnection(ssl_keyfile=None, ssl_certfile=None, ssl_cert_reqs='required', ssl_include_verify_flags: Optional[List[ForwardRef('VerifyFlags')]] = None, ssl_exclude_verify_flags: Optional[List[ForwardRef('VerifyFlags')]] = None, ssl_ca_certs=None, ssl_ca_data=None, ssl_check_hostname=True, ssl_ca_path=None, ssl_password=None, ssl_validate_ocsp=False, ssl_validate_ocsp_stapled=False, ssl_ocsp_context=None, ssl_ocsp_expected_cert=None, ssl_min_version=None, ssl_ciphers=None, **kwargs)
 |
 |  Manages SSL connections to and from the Redis server(s).
 |  This class extends the Connection class, adding SSL functionality, and making
 |  use of ssl.SSLContext (https://docs.python.org/3/library/ssl.html#ssl.SSLContext)
 |
 |  Method resolution order:
 |      SSLConnection
 |      Connection
 |      AbstractConnection
 |      MaintNotificationsAbstractConnection
 |      ConnectionInterface
 |      builtins.object
 |
 |  Methods defined here:
 |
 |  __init__(self, ssl_keyfile=None, ssl_certfile=None, ssl_cert_reqs='required', ssl_include_verify_flags: Optional[List[ForwardRef('VerifyFlags')]] = None, ssl_exclude_verify_flags: Optional[List[ForwardRef('VerifyFlags')]] = None, ssl_ca_certs=None, ssl_ca_data=None, ssl_check_hostname=True, ssl_ca_path=None, ssl_password=None, ssl_validate_ocsp=False, ssl_validate_ocsp_stapled=False, ssl_ocsp_context=None, ssl_ocsp_expected_cert=None, ssl_min_version=None, ssl_ciphers=None, **kwargs)
 |      Constructor
 |
 |      Args:
 |          ssl_keyfile: Path to an ssl private key. Defaults to None.
 |          ssl_certfile: Path to an ssl certificate. Defaults to None.
 |          ssl_cert_reqs: The string value for the SSLContext.verify_mode (none, optional, required),
 |                         or an ssl.VerifyMode. Defaults to "required".
 |          ssl_include_verify_flags: A list of flags to be included in the SSLContext.verify_flags. Defaults to None.
 |          ssl_exclude_verify_flags: A list of flags to be excluded from the SSLContext.verify_flags. Defaults to None.
 |          ssl_ca_certs: The path to a file of concatenated CA certificates in PEM format. Defaults to None.
 |          ssl_ca_data: Either an ASCII string of one or more PEM-encoded certificates or a bytes-like object of DER-encoded certificates.
 |          ssl_check_hostname: If set, match the hostname during the SSL handshake. Defaults to True.
 |          ssl_ca_path: The path to a directory containing several CA certificates in PEM format. Defaults to None.
 |          ssl_password: Password for unlocking an encrypted private key. Defaults to None.
 |
 |          ssl_validate_ocsp: If set, perform a full ocsp validation (i.e not a stapled verification)
 |          ssl_validate_ocsp_stapled: If set, perform a validation on a stapled ocsp response
 |          ssl_ocsp_context: A fully initialized OpenSSL.SSL.Context object to be used in verifying the ssl_ocsp_expected_cert
 |          ssl_ocsp_expected_cert: A PEM armoured string containing the expected certificate to be returned from the ocsp verification service.
 |          ssl_min_version: The lowest supported SSL version. It affects the supported SSL versions of the SSLContext. None leaves the default provided by ssl module.
 |          ssl_ciphers: A string listing the ciphers that are allowed to be used. Defaults to None, which means that the default ciphers are used. See https://docs.python.org/3/library/ssl.html#ssl.SSLContext.set_ciphers for more information.
 |
 |      Raises:
 |          RedisError
 |
 |  ----------------------------------------------------------------------
 |  Methods inherited from Connection:
 |
 |  repr_pieces(self)
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from Connection:
 |
 |  host
 |
 |  ----------------------------------------------------------------------
 |  Methods inherited from AbstractConnection:
 |
 |  __del__(self)
 |
 |  __repr__(self)
 |      Return repr(self).
 |
 |  can_read(self, timeout: float = 0) -> bool
 |      Poll the socket to see if there's data that can be read.
 |
 |  check_health(self)
 |      Check the health of the connection with a PING/PONG
 |
 |  connect(self)
 |      Connects to the Redis server if not already connected
 |
 |  connect_check_health(self, check_health: bool = True, retry_socket_connect: bool = True)
 |
 |  deregister_connect_callback(self, callback)
 |      De-register a previously registered callback.  It will no-longer receive
 |      notifications on connection events.  Calling this is not required when the
 |      listener goes away, since the callbacks are kept as weak methods.
 |
 |  disconnect(self, *args, **kwargs)
 |      Disconnects from the Redis server
 |
 |  extract_connection_details(self) -> str
 |
 |  get_protocol(self) -> Union[int, str]
 |      Returns:
 |          The RESP protocol version, or ``None`` if the protocol is not specified,
 |          in which case the server default will be used.
 |
 |  mark_for_reconnect(self)
 |      Mark the connection to be reconnected on the next command.
 |      This is useful when a connection is moved to a different node.
 |
 |  on_connect(self)
 |
 |  on_connect_check_health(self, check_health: bool = True)
 |      Initialize the connection, authenticate and select a database
 |
 |  pack_command(self, *args)
 |      Pack a series of arguments into the Redis protocol
 |
 |  pack_commands(self, commands)
 |      Pack multiple commands into the Redis protocol
 |
 |  re_auth(self)
 |
 |  read_response(self, disable_decoding=False, *, timeout: Union[float, object] = <object object at 0x0000017B991493E0>, disconnect_on_error=True, push_request=False)
 |      Read the response from a previously sent command
 |
 |  register_connect_callback(self, callback)
 |      Register a callback to be called when the connection is established either
 |      initially or reconnected.  This allows listeners to issue commands that
 |      are ephemeral to the connection, for example pub/sub subscription or
 |      key tracking.  The callback must be a _method_ and will be kept as
 |      a weak reference.
 |
 |  reset_should_reconnect(self)
 |      Reset the internal flag to False.
 |
 |  send_command(self, *args, **kwargs)
 |      Pack and send a command to the Redis server
 |
 |  send_packed_command(self, command, check_health=True)
 |      Send an already packed command to the Redis server
 |
 |  set_parser(self, parser_class)
 |      Creates a new instance of parser_class with socket size:
 |      _socket_read_size and assigns it to the parser for the connection
 |      :param parser_class: The required parser class
 |
 |  set_re_auth_token(self, token: redis.auth.token.TokenInterface)
 |
 |  should_reconnect(self)
 |      Returns True if the connection should be reconnected.
 |
 |  ----------------------------------------------------------------------
 |  Readonly properties inherited from AbstractConnection:
 |
 |  is_connected
 |      Return ``True`` if the connection to the server is active.
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from AbstractConnection:
 |
 |  handshake_metadata
 |
 |  socket_connect_timeout
 |
 |  socket_timeout
 |
 |  ----------------------------------------------------------------------
 |  Methods inherited from MaintNotificationsAbstractConnection:
 |
 |  activate_maint_notifications_handling_if_enabled(self, check_health=True)
 |
 |  add_maint_start_notification(self, id: int)
 |
 |  add_skipped_end_notification(self, id: int)
 |
 |  get_processed_start_notifications(self) -> set
 |
 |  get_resolved_ip(self) -> Optional[str]
 |      Extract the resolved IP address from an
 |      established connection or resolve it from the host.
 |
 |      First tries to get the actual IP from the socket (most accurate),
 |      then falls back to DNS resolution if needed.
 |
 |      Returns:
 |          str: The resolved IP address, or None if it cannot be determined
 |
 |  get_skipped_end_notifications(self) -> set
 |
 |  getpeername(self)
 |      Returns the peer name of the connection.
 |
 |  reset_received_notifications(self)
 |
 |  reset_tmp_settings(self, reset_host_address: bool = False, reset_relaxed_timeout: bool = False)
 |
 |  set_maint_notifications_cluster_handler_for_connection(self, oss_cluster_maint_notifications_handler: redis.maint_notifications.OSSMaintNotificationsHandler)
 |
 |  set_maint_notifications_pool_handler_for_connection(self, maint_notifications_pool_handler: redis.maint_notifications.MaintNotificationsPoolHandler)
 |
 |  set_tmp_settings(self, tmp_host_address: Union[str, object, NoneType] = <object object at 0x0000017B991493E0>, tmp_relaxed_timeout: Optional[float] = -1)
 |      SENTINEL keeps the host unchanged. -1 keeps the relaxed timeout unchanged.
 |
 |  update_current_socket_timeout(self, relaxed_timeout: Optional[float] = None)
 |
 |  update_parser_timeout(self, timeout: Optional[float] = None)
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from MaintNotificationsAbstractConnection:
 |
 |  __dict__
 |      dictionary for instance variables
 |
 |  __weakref__
 |      list of weak references to the object
 |
 |  maintenance_state

Python Library Documentation: class Sentinel in module redis.sentinel

class Sentinel(redis.commands.sentinel.SentinelCommands)
 |  Sentinel(sentinels, min_other_sentinels=0, sentinel_kwargs=None, force_master_ip=None, **connection_kwargs)
 |
 |  Redis Sentinel cluster client
 |
 |  >>> from redis.sentinel import Sentinel
 |  >>> sentinel = Sentinel([('localhost', 26379)], socket_timeout=0.1)
 |  >>> master = sentinel.master_for('mymaster', socket_timeout=0.1)
 |  >>> master.set('foo', 'bar')
 |  >>> slave = sentinel.slave_for('mymaster', socket_timeout=0.1)
 |  >>> slave.get('foo')
 |  b'bar'
 |
 |  ``sentinels`` is a list of sentinel nodes. Each node is represented by
 |  a pair (hostname, port).
 |
 |  ``min_other_sentinels`` defined a minimum number of peers for a sentinel.
 |  When querying a sentinel, if it doesn't meet this threshold, responses
 |  from that sentinel won't be considered valid.
 |
 |  ``sentinel_kwargs`` is a dictionary of connection arguments used when
 |  connecting to sentinel instances. Any argument that can be passed to
 |  a normal Redis connection can be specified here. If ``sentinel_kwargs`` is
 |  not specified, any socket_timeout and socket_keepalive options specified
 |  in ``connection_kwargs`` will be used.
 |
 |  ``connection_kwargs`` are keyword arguments that will be used when
 |  establishing a connection to a Redis server.
 |
 |  Method resolution order:
 |      Sentinel
 |      redis.commands.sentinel.SentinelCommands
 |      builtins.object
 |
 |  Methods defined here:
 |
 |  __enter__(self)
 |
 |  __exit__(self, exc_type, exc_value, traceback)
 |
 |  __init__(self, sentinels, min_other_sentinels=0, sentinel_kwargs=None, force_master_ip=None, **connection_kwargs)
 |      Initialize self.  See help(type(self)) for accurate signature.
 |
 |  __repr__(self)
 |      Return repr(self).
 |
 |  check_master_state(self, state, service_name)
 |
 |  close(self) -> None
 |      Close all sentinel clients created by this Sentinel and their
 |      connection pools.
 |
 |      Each client is closed independently: if one raises, the remaining
 |      clients are still closed and the first error is re-raised afterwards.
 |
 |      Clients returned by ``master_for``/``slave_for`` are owned by the
 |      caller and are not closed here.
 |
 |  discover_master(self, service_name)
 |      Asks sentinel servers for the Redis master's address corresponding
 |      to the service labeled ``service_name``.
 |
 |      Returns a pair (address, port) or raises MasterNotFoundError if no
 |      master is found.
 |
 |  discover_replicas(self, service_name)
 |      Returns a list of alive replicas for service ``service_name``.
 |
 |      This is an alias for :py:meth:`discover_slaves`,
 |      using the preferred Redis 5.0+ terminology.
 |
 |  discover_slaves(self, service_name)
 |      Returns a list of alive slaves for service ``service_name``
 |
 |  execute_command(self, *args, **kwargs)
 |      Execute Sentinel command in sentinel nodes.
 |      once - If set to True, then execute the resulting command on a single
 |      node at random, rather than across the entire sentinel cluster.
 |
 |  filter_replicas(self, replicas)
 |      Remove replicas that are in an ODOWN or SDOWN state.
 |
 |      This is an alias for :py:meth:`filter_slaves`,
 |      using the preferred Redis 5.0+ terminology.
 |
 |  filter_slaves(self, slaves)
 |      Remove slaves that are in an ODOWN or SDOWN state
 |
 |  master_for(self, service_name, redis_class=<class 'redis.client.Redis'>, connection_pool_class=<class 'redis.sentinel.SentinelConnectionPool'>, **kwargs)
 |      Returns a redis client instance for the ``service_name`` master.
 |      Sentinel client will detect failover and reconnect Redis clients
 |      automatically.
 |
 |      A :py:class:`~redis.sentinel.SentinelConnectionPool` class is
 |      used to retrieve the master's address before establishing a new
 |      connection.
 |
 |      NOTE: If the master's address has changed, any cached connections to
 |      the old master are closed.
 |
 |      By default clients will be a :py:class:`~redis.Redis` instance.
 |      Specify a different class to the ``redis_class`` argument if you
 |      desire something different.
 |
 |      The ``connection_pool_class`` specifies the connection pool to
 |      use.  The :py:class:`~redis.sentinel.SentinelConnectionPool`
 |      will be used by default.
 |
 |      All other keyword arguments are merged with any connection_kwargs
 |      passed to this class and passed to the connection pool as keyword
 |      arguments to be used to initialize Redis connections.
 |
 |      HIMPORT note: the returned client exposes the HIMPORT command family
 |      (``himport_prepare``, ``himport_set``, ``himport_discard``,
 |      ``himport_discard_all``). Fieldsets are declared at runtime with
 |      ``himport_prepare`` on the client and live on that client's shared registry,
 |      so they survive Sentinel failover automatically: the pool re-points to the
 |      new master and the fieldset is re-prepared lazily on the next
 |      ``himport_set``. Each call to the current method returns a *new* client with
 |      its *own* empty registry, so call ``himport_prepare`` on the long-lived client
 |      you reuse rather than creating a fresh one per operation; otherwise ``himport_set``
 |      fails with ``no such fieldset``. (``himport_set`` is a write and is served by
 |      the master.)
 |
 |  replica_for(self, service_name, redis_class=<class 'redis.client.Redis'>, connection_pool_class=<class 'redis.sentinel.SentinelConnectionPool'>, **kwargs)
 |      Returns redis client instance for the ``service_name`` replica(s).
 |
 |      This is an alias for :py:meth:`slave_for`,
 |      using the preferred Redis 5.0+ terminology.
 |
 |  slave_for(self, service_name, redis_class=<class 'redis.client.Redis'>, connection_pool_class=<class 'redis.sentinel.SentinelConnectionPool'>, **kwargs)
 |      Returns redis client instance for the ``service_name`` slave(s).
 |
 |      A SentinelConnectionPool class is used to retrieve the slave's
 |      address before establishing a new connection.
 |
 |      By default clients will be a :py:class:`~redis.Redis` instance.
 |      Specify a different class to the ``redis_class`` argument if you
 |      desire something different.
 |
 |      The ``connection_pool_class`` specifies the connection pool to use.
 |      The SentinelConnectionPool will be used by default.
 |
 |      All other keyword arguments are merged with any connection_kwargs
 |      passed to this class and passed to the connection pool as keyword
 |      arguments to be used to initialize Redis connections.
 |
 |      HIMPORT note: the returned client exposes the HIMPORT command family
 |      (``himport_prepare``, ``himport_set``, ``himport_discard``,
 |      ``himport_discard_all``). Fieldsets are declared at runtime with
 |      ``himport_prepare`` on the client and live on that client's shared registry,
 |      so they survive Sentinel failover automatically: the pool re-points to the
 |      new master and the fieldset is re-prepared lazily on the next
 |      ``himport_set``. Each call to current method returns a *new* client with
 |      its *own* empty registry, so call ``himport_prepare`` on the long-lived client
 |      you reuse rather than creating a fresh one per operation; otherwise ``himport_set``
 |      fails with ``no such fieldset``. (``himport_set`` is a write and is served by
 |      the master.)
 |
 |  ----------------------------------------------------------------------
 |  Data and other attributes defined here:
 |
 |  __annotations__ = {}
 |
 |  ----------------------------------------------------------------------
 |  Methods inherited from redis.commands.sentinel.SentinelCommands:
 |
 |  sentinel(self, *args)
 |      Redis Sentinel's SENTINEL command.
 |
 |  sentinel_ckquorum(self, new_master_name) -> Union[bool, Awaitable[bool]]
 |      Check if the current Sentinel configuration is able to reach the
 |      quorum needed to failover a master, and the majority needed to
 |      authorize the failover.
 |
 |      This command should be used in monitoring systems to check if a
 |      Sentinel deployment is ok.
 |
 |  sentinel_failover(self, new_master_name) -> Union[bool, Awaitable[bool]]
 |      Force a failover as if the master was not reachable, and without
 |      asking for agreement to other Sentinels (however a new version of the
 |      configuration will be published so that the other Sentinels will
 |      update their configurations).
 |
 |  sentinel_flushconfig(self) -> Union[bool, Awaitable[bool]]
 |      Force Sentinel to rewrite its configuration on disk, including the
 |      current Sentinel state.
 |
 |      Normally Sentinel rewrites the configuration every time something
 |      changes in its state (in the context of the subset of the state which
 |      is persisted on disk across restart).
 |      However sometimes it is possible that the configuration file is lost
 |      because of operation errors, disk failures, package upgrade scripts or
 |      configuration managers. In those cases a way to to force Sentinel to
 |      rewrite the configuration file is handy.
 |
 |      This command works even if the previous configuration file is
 |      completely missing.
 |
 |  sentinel_get_master_addr_by_name(self, service_name, return_responses: bool = False) -> Union[tuple[bytes | str, int], NoneType, bool, Awaitable[tuple[bytes | str, int] | None | bool]]
 |      Returns a (host, port) pair for the given ``service_name`` when return_responses is True,
 |      otherwise returns a boolean value that indicates if the command was successful.
 |
 |  sentinel_master(self, service_name, return_responses: bool = False) -> Union[dict[str, Any], bool, Awaitable[dict[str, Any] | bool]]
 |      Returns a dictionary containing the specified masters state, when return_responses is True,
 |      otherwise returns a boolean value that indicates if the command was successful.
 |
 |  sentinel_masters(self) -> Union[dict[str, dict[str, Any]], list[dict[str, Any]], Awaitable[dict[str, dict[str, Any]] | list[dict[str, Any]]]]
 |      Returns a list of dictionaries containing each master's state.
 |
 |      Important: This function is called by the Sentinel implementation and is
 |      called directly on the Redis standalone client for sentinels,
 |      so it doesn't support the "once" and "return_responses" options.
 |
 |  sentinel_monitor(self, name, ip, port, quorum) -> Union[bool, Awaitable[bool]]
 |      Add a new master to Sentinel to be monitored
 |
 |  sentinel_remove(self, name) -> Union[bool, Awaitable[bool]]
 |      Remove a master from Sentinel's monitoring
 |
 |  sentinel_reset(self, pattern) -> Union[bool, Awaitable[bool]]
 |      This command will reset all the masters with matching name.
 |      The pattern argument is a glob-style pattern.
 |
 |      The reset process clears any previous state in a master (including a
 |      failover in progress), and removes every slave and sentinel already
 |      discovered and associated with the master.
 |
 |  sentinel_sentinels(self, service_name, return_responses: bool = False) -> Union[list[dict[str, Any]], bool, Awaitable[list[dict[str, Any]] | bool]]
 |      Returns a list of sentinels for ``service_name``, when return_responses is True,
 |      otherwise returns a boolean value that indicates if the command was successful.
 |
 |  sentinel_set(self, name, option, value) -> Union[bool, Awaitable[bool]]
 |      Set Sentinel monitoring parameters for a given master
 |
 |  sentinel_slaves(self, service_name) -> Union[list[dict[str, Any]], Awaitable[list[dict[str, Any]]]]
 |      Returns a list of slaves for ``service_name``
 |
 |      Important: This function is called by the Sentinel implementation and is
 |      called directly on the Redis standalone client for sentinels,
 |      so it doesn't support the "once" and "return_responses" options.
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from redis.commands.sentinel.SentinelCommands:
 |
 |  __dict__
 |      dictionary for instance variables
 |
 |  __weakref__
 |      list of weak references to the object

Python Library Documentation: class SentinelConnectionPool in module redis.sentinel

class SentinelConnectionPool(redis.connection.ConnectionPool)
 |  SentinelConnectionPool(service_name, sentinel_manager, **kwargs)
 |
 |  Sentinel backed connection pool.
 |
 |  If ``check_connection`` flag is set to True, SentinelManagedConnection
 |  sends a PING command right after establishing the connection.
 |
 |  Method resolution order:
 |      SentinelConnectionPool
 |      redis.connection.ConnectionPool
 |      redis.connection.MaintNotificationsAbstractConnectionPool
 |      redis.connection.ConnectionPoolInterface
 |      abc.ABC
 |      builtins.object
 |
 |  Methods defined here:
 |
 |  __init__(self, service_name, sentinel_manager, **kwargs)
 |      Initialize self.  See help(type(self)) for accurate signature.
 |
 |  __repr__(self)
 |      Return repr(self).
 |
 |  get_master_address(self)
 |
 |  owns_connection(self, connection)
 |
 |  reset(self)
 |
 |  rotate_replicas(self)
 |      Round-robin replica balancer.
 |
 |      This is an alias for :py:meth:`rotate_slaves`,
 |      using the preferred Redis 5.0+ terminology.
 |
 |  rotate_slaves(self)
 |      Round-robin slave balancer
 |
 |  ----------------------------------------------------------------------
 |  Readonly properties defined here:
 |
 |  master_address
 |
 |  ----------------------------------------------------------------------
 |  Data and other attributes defined here:
 |
 |  __abstractmethods__ = frozenset()
 |
 |  ----------------------------------------------------------------------
 |  Methods inherited from redis.connection.ConnectionPool:
 |
 |  __del__(self) -> None
 |      Clean up connection pool and record metrics when garbage collected.
 |
 |  __enter__(self: ~_CP) -> ~_CP
 |
 |  __exit__(self, exc_type, exc_value, traceback) -> None
 |
 |  close(self) -> None
 |      Close the pool, disconnecting all connections
 |
 |  disconnect(self, inuse_connections: bool = True) -> None
 |      Disconnects connections in the pool
 |
 |      If ``inuse_connections`` is True, disconnect connections that are
 |      currently in use, potentially by other threads. Otherwise only disconnect
 |      connections that are idle in the pool.
 |
 |  get_connection(self, command_name=None, *keys, **options) -> 'Connection'
 |      Get a connection from the pool
 |
 |  get_connection_count(self) -> List[tuple[int, dict]]
 |      Returns a connection count (both idle and in use).
 |
 |  get_encoder(self) -> redis._parsers.encoders.Encoder
 |      Return an encoder based on encoding settings
 |
 |  get_protocol(self)
 |      Returns:
 |          The RESP protocol version, or ``None`` if the protocol is not specified,
 |          in which case the server default will be used.
 |
 |  make_connection(self) -> 'ConnectionInterface'
 |      Create a new connection
 |
 |  re_auth_callback(self, token: redis.auth.token.TokenInterface)
 |
 |  release(self, connection: 'Connection') -> None
 |      Releases the connection back to the pool
 |
 |  set_retry(self, retry: redis.retry.Retry) -> None
 |
 |  ----------------------------------------------------------------------
 |  Class methods inherited from redis.connection.ConnectionPool:
 |
 |  from_url(url: str, **kwargs) -> ~_CP
 |      Return a connection pool configured from the given URL.
 |
 |      For example::
 |
 |          redis://[[username]:[password]]@localhost:6379/0
 |          rediss://[[username]:[password]]@localhost:6379/0
 |          unix://[username@]/path/to/socket.sock?db=0[&password=password]
 |
 |      Three URL schemes are supported:
 |
 |      - `redis://` creates a TCP socket connection. See more at:
 |        <https://www.iana.org/assignments/uri-schemes/prov/redis>
 |      - `rediss://` creates a SSL wrapped TCP socket connection. See more at:
 |        <https://www.iana.org/assignments/uri-schemes/prov/rediss>
 |      - ``unix://``: creates a Unix Domain Socket connection.
 |
 |      The username, password, hostname, path and all querystring values
 |      are passed through urllib.parse.unquote in order to replace any
 |      percent-encoded values with their corresponding characters.
 |
 |      There are several ways to specify a database number. The first value
 |      found will be used:
 |
 |          1. A ``db`` querystring option, e.g. redis://localhost?db=0
 |          2. If using the redis:// or rediss:// schemes, the path argument
 |             of the url, e.g. redis://localhost/0
 |          3. A ``db`` keyword argument to this function.
 |
 |      If none of these options are specified, the default db=0 is used.
 |
 |      All querystring options are cast to their appropriate Python types.
 |      Boolean arguments can be specified with string values "True"/"False"
 |      or "Yes"/"No". Values that cannot be properly cast cause a
 |      ``ValueError`` to be raised. Once parsed, the querystring arguments
 |      and keyword arguments are passed to the ``ConnectionPool``'s
 |      class initializer. In the case of conflicting arguments, querystring
 |      arguments always win.
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from redis.connection.ConnectionPool:
 |
 |  connection_kwargs
 |
 |  ----------------------------------------------------------------------
 |  Data and other attributes inherited from redis.connection.ConnectionPool:
 |
 |  OMIT_REPR_KEYS = frozenset({'himport_registry'})
 |
 |  SENSITIVE_REPR_KEYS = frozenset({'credential_provider', 'password', 's...
 |
 |  ----------------------------------------------------------------------
 |  Methods inherited from redis.connection.MaintNotificationsAbstractConnectionPool:
 |
 |  disconnect_free_connections(self, moving_address_src: Optional[str] = None)
 |      Disconnect all free/available connections.
 |      This is used when a cluster node is migrated to a different address.
 |
 |      :param moving_address_src: The address of the node that is being moved.
 |
 |  maint_notifications_enabled(self)
 |      Returns:
 |          True if the maintenance notifications are enabled, False otherwise.
 |          The maintenance notifications config is stored in the pool handler.
 |          If the pool handler is not set, the maintenance notifications are not enabled.
 |
 |  update_active_connections_for_reconnect(self, moving_address_src: Optional[str] = None)
 |      Mark all active connections for reconnect.
 |      This is used when a cluster node is migrated to a different address.
 |
 |      :param moving_address_src: The address of the node that is being moved.
 |
 |  update_connection_kwargs(self, **kwargs)
 |      Update the connection kwargs for all future connections.
 |
 |      This method updates the connection kwargs for all future connections created by the pool.
 |      Existing connections are not affected.
 |
 |  update_connection_settings(self, conn: 'MaintNotificationsAbstractConnection', state: Optional[ForwardRef('MaintenanceState')] = None, maintenance_notification_hash: Optional[int] = None, host_address: Optional[str] = None, relaxed_timeout: Optional[float] = None, update_notification_hash: bool = False, reset_host_address: bool = False, reset_relaxed_timeout: bool = False)
 |      Update the settings for a single connection.
 |
 |  update_connections_settings(self, state: Optional[ForwardRef('MaintenanceState')] = None, maintenance_notification_hash: Optional[int] = None, host_address: Optional[str] = None, relaxed_timeout: Optional[float] = None, matching_address: Optional[str] = None, matching_notification_hash: Optional[int] = None, matching_pattern: Literal['connected_address', 'configured_address', 'notification_hash'] = 'connected_address', update_notification_hash: bool = False, reset_host_address: bool = False, reset_relaxed_timeout: bool = False, include_free_connections: bool = True)
 |      Update the settings for all matching connections in the pool.
 |
 |      This method does not create new connections.
 |      This method does not affect the connection kwargs.
 |
 |      :param state: The maintenance state to set for the connection.
 |      :param maintenance_notification_hash: The hash of the maintenance notification
 |                                             to set for the connection.
 |      :param host_address: The host address to set for the connection.
 |      :param relaxed_timeout: The relaxed timeout to set for the connection.
 |      :param matching_address: The address to match for the connection.
 |      :param matching_notification_hash: The notification hash to match for the connection.
 |      :param matching_pattern: The pattern to match for the connection.
 |      :param update_notification_hash: Whether to update the notification hash for the connection.
 |      :param reset_host_address: Whether to reset the host address to the original address.
 |      :param reset_relaxed_timeout: Whether to reset the relaxed timeout to the original timeout.
 |      :param include_free_connections: Whether to include free/available connections.
 |
 |  update_maint_notifications_config(self, maint_notifications_config: redis.maint_notifications.MaintNotificationsConfig, oss_cluster_maint_notifications_handler: Optional[redis.maint_notifications.OSSMaintNotificationsHandler] = None)
 |      Updates the maintenance notifications configuration.
 |      This method should be called only if the pool was created
 |      without enabling the maintenance notifications and
 |      in a later point in time maintenance notifications
 |      are requested to be enabled.
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from redis.connection.MaintNotificationsAbstractConnectionPool:
 |
 |  __dict__
 |      dictionary for instance variables
 |
 |  __weakref__
 |      list of weak references to the object

Python Library Documentation: class SentinelManagedConnection in module redis.sentinel

class SentinelManagedConnection(redis.connection.Connection)
 |  SentinelManagedConnection(**kwargs)
 |
 |  Method resolution order:
 |      SentinelManagedConnection
 |      redis.connection.Connection
 |      redis.connection.AbstractConnection
 |      redis.connection.MaintNotificationsAbstractConnection
 |      redis.connection.ConnectionInterface
 |      builtins.object
 |
 |  Methods defined here:
 |
 |  __init__(self, **kwargs)
 |      Initialize a TCP connection.
 |
 |      Parameters
 |      ----------
 |      socket_keepalive : bool
 |          If `True`, TCP keepalive is enabled for TCP socket connections.
 |      socket_keepalive_options : Mapping[int, int | bytes] | object | None
 |          Mapping of TCP keepalive socket option constants to values, for
 |          example `{socket.TCP_KEEPIDLE: 30}`. If left unspecified, redis-py
 |          uses TCP keepalive defaults when `socket_keepalive` is enabled:
 |          idle 30 seconds, interval 5 seconds, and 3 probes. Platform-specific
 |          options that are not available are skipped. Pass `None` or `{}` to
 |          avoid setting additional TCP keepalive options.
 |
 |  __repr__(self)
 |      Return repr(self).
 |
 |  connect(self)
 |      Connects to the Redis server if not already connected
 |
 |  connect_to(self, address)
 |
 |  read_response(self, disable_decoding=False, *, timeout: Union[float, object] = <object object at 0x0000017B991493E0>, disconnect_on_error: Optional[bool] = False, push_request: Optional[bool] = False)
 |      Read the response from a previously sent command
 |
 |  ----------------------------------------------------------------------
 |  Methods inherited from redis.connection.Connection:
 |
 |  repr_pieces(self)
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from redis.connection.Connection:
 |
 |  host
 |
 |  ----------------------------------------------------------------------
 |  Methods inherited from redis.connection.AbstractConnection:
 |
 |  __del__(self)
 |
 |  can_read(self, timeout: float = 0) -> bool
 |      Poll the socket to see if there's data that can be read.
 |
 |  check_health(self)
 |      Check the health of the connection with a PING/PONG
 |
 |  connect_check_health(self, check_health: bool = True, retry_socket_connect: bool = True)
 |
 |  deregister_connect_callback(self, callback)
 |      De-register a previously registered callback.  It will no-longer receive
 |      notifications on connection events.  Calling this is not required when the
 |      listener goes away, since the callbacks are kept as weak methods.
 |
 |  disconnect(self, *args, **kwargs)
 |      Disconnects from the Redis server
 |
 |  extract_connection_details(self) -> str
 |
 |  get_protocol(self) -> Union[int, str]
 |      Returns:
 |          The RESP protocol version, or ``None`` if the protocol is not specified,
 |          in which case the server default will be used.
 |
 |  mark_for_reconnect(self)
 |      Mark the connection to be reconnected on the next command.
 |      This is useful when a connection is moved to a different node.
 |
 |  on_connect(self)
 |
 |  on_connect_check_health(self, check_health: bool = True)
 |      Initialize the connection, authenticate and select a database
 |
 |  pack_command(self, *args)
 |      Pack a series of arguments into the Redis protocol
 |
 |  pack_commands(self, commands)
 |      Pack multiple commands into the Redis protocol
 |
 |  re_auth(self)
 |
 |  register_connect_callback(self, callback)
 |      Register a callback to be called when the connection is established either
 |      initially or reconnected.  This allows listeners to issue commands that
 |      are ephemeral to the connection, for example pub/sub subscription or
 |      key tracking.  The callback must be a _method_ and will be kept as
 |      a weak reference.
 |
 |  reset_should_reconnect(self)
 |      Reset the internal flag to False.
 |
 |  send_command(self, *args, **kwargs)
 |      Pack and send a command to the Redis server
 |
 |  send_packed_command(self, command, check_health=True)
 |      Send an already packed command to the Redis server
 |
 |  set_parser(self, parser_class)
 |      Creates a new instance of parser_class with socket size:
 |      _socket_read_size and assigns it to the parser for the connection
 |      :param parser_class: The required parser class
 |
 |  set_re_auth_token(self, token: redis.auth.token.TokenInterface)
 |
 |  should_reconnect(self)
 |      Returns True if the connection should be reconnected.
 |
 |  ----------------------------------------------------------------------
 |  Readonly properties inherited from redis.connection.AbstractConnection:
 |
 |  is_connected
 |      Return ``True`` if the connection to the server is active.
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from redis.connection.AbstractConnection:
 |
 |  handshake_metadata
 |
 |  socket_connect_timeout
 |
 |  socket_timeout
 |
 |  ----------------------------------------------------------------------
 |  Methods inherited from redis.connection.MaintNotificationsAbstractConnection:
 |
 |  activate_maint_notifications_handling_if_enabled(self, check_health=True)
 |
 |  add_maint_start_notification(self, id: int)
 |
 |  add_skipped_end_notification(self, id: int)
 |
 |  get_processed_start_notifications(self) -> set
 |
 |  get_resolved_ip(self) -> Optional[str]
 |      Extract the resolved IP address from an
 |      established connection or resolve it from the host.
 |
 |      First tries to get the actual IP from the socket (most accurate),
 |      then falls back to DNS resolution if needed.
 |
 |      Returns:
 |          str: The resolved IP address, or None if it cannot be determined
 |
 |  get_skipped_end_notifications(self) -> set
 |
 |  getpeername(self)
 |      Returns the peer name of the connection.
 |
 |  reset_received_notifications(self)
 |
 |  reset_tmp_settings(self, reset_host_address: bool = False, reset_relaxed_timeout: bool = False)
 |
 |  set_maint_notifications_cluster_handler_for_connection(self, oss_cluster_maint_notifications_handler: redis.maint_notifications.OSSMaintNotificationsHandler)
 |
 |  set_maint_notifications_pool_handler_for_connection(self, maint_notifications_pool_handler: redis.maint_notifications.MaintNotificationsPoolHandler)
 |
 |  set_tmp_settings(self, tmp_host_address: Union[str, object, NoneType] = <object object at 0x0000017B991493E0>, tmp_relaxed_timeout: Optional[float] = -1)
 |      SENTINEL keeps the host unchanged. -1 keeps the relaxed timeout unchanged.
 |
 |  update_current_socket_timeout(self, relaxed_timeout: Optional[float] = None)
 |
 |  update_parser_timeout(self, timeout: Optional[float] = None)
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from redis.connection.MaintNotificationsAbstractConnection:
 |
 |  __dict__
 |      dictionary for instance variables
 |
 |  __weakref__
 |      list of weak references to the object
 |
 |  maintenance_state

Python Library Documentation: class SentinelManagedSSLConnection in module redis.sentinel

class SentinelManagedSSLConnection(SentinelManagedConnection, redis.connection.SSLConnection)
 |  SentinelManagedSSLConnection(**kwargs)
 |
 |  Method resolution order:
 |      SentinelManagedSSLConnection
 |      SentinelManagedConnection
 |      redis.connection.SSLConnection
 |      redis.connection.Connection
 |      redis.connection.AbstractConnection
 |      redis.connection.MaintNotificationsAbstractConnection
 |      redis.connection.ConnectionInterface
 |      builtins.object
 |
 |  Methods inherited from SentinelManagedConnection:
 |
 |  __init__(self, **kwargs)
 |      Initialize a TCP connection.
 |
 |      Parameters
 |      ----------
 |      socket_keepalive : bool
 |          If `True`, TCP keepalive is enabled for TCP socket connections.
 |      socket_keepalive_options : Mapping[int, int | bytes] | object | None
 |          Mapping of TCP keepalive socket option constants to values, for
 |          example `{socket.TCP_KEEPIDLE: 30}`. If left unspecified, redis-py
 |          uses TCP keepalive defaults when `socket_keepalive` is enabled:
 |          idle 30 seconds, interval 5 seconds, and 3 probes. Platform-specific
 |          options that are not available are skipped. Pass `None` or `{}` to
 |          avoid setting additional TCP keepalive options.
 |
 |  __repr__(self)
 |      Return repr(self).
 |
 |  connect(self)
 |      Connects to the Redis server if not already connected
 |
 |  connect_to(self, address)
 |
 |  read_response(self, disable_decoding=False, *, timeout: Union[float, object] = <object object at 0x0000017B991493E0>, disconnect_on_error: Optional[bool] = False, push_request: Optional[bool] = False)
 |      Read the response from a previously sent command
 |
 |  ----------------------------------------------------------------------
 |  Methods inherited from redis.connection.Connection:
 |
 |  repr_pieces(self)
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from redis.connection.Connection:
 |
 |  host
 |
 |  ----------------------------------------------------------------------
 |  Methods inherited from redis.connection.AbstractConnection:
 |
 |  __del__(self)
 |
 |  can_read(self, timeout: float = 0) -> bool
 |      Poll the socket to see if there's data that can be read.
 |
 |  check_health(self)
 |      Check the health of the connection with a PING/PONG
 |
 |  connect_check_health(self, check_health: bool = True, retry_socket_connect: bool = True)
 |
 |  deregister_connect_callback(self, callback)
 |      De-register a previously registered callback.  It will no-longer receive
 |      notifications on connection events.  Calling this is not required when the
 |      listener goes away, since the callbacks are kept as weak methods.
 |
 |  disconnect(self, *args, **kwargs)
 |      Disconnects from the Redis server
 |
 |  extract_connection_details(self) -> str
 |
 |  get_protocol(self) -> Union[int, str]
 |      Returns:
 |          The RESP protocol version, or ``None`` if the protocol is not specified,
 |          in which case the server default will be used.
 |
 |  mark_for_reconnect(self)
 |      Mark the connection to be reconnected on the next command.
 |      This is useful when a connection is moved to a different node.
 |
 |  on_connect(self)
 |
 |  on_connect_check_health(self, check_health: bool = True)
 |      Initialize the connection, authenticate and select a database
 |
 |  pack_command(self, *args)
 |      Pack a series of arguments into the Redis protocol
 |
 |  pack_commands(self, commands)
 |      Pack multiple commands into the Redis protocol
 |
 |  re_auth(self)
 |
 |  register_connect_callback(self, callback)
 |      Register a callback to be called when the connection is established either
 |      initially or reconnected.  This allows listeners to issue commands that
 |      are ephemeral to the connection, for example pub/sub subscription or
 |      key tracking.  The callback must be a _method_ and will be kept as
 |      a weak reference.
 |
 |  reset_should_reconnect(self)
 |      Reset the internal flag to False.
 |
 |  send_command(self, *args, **kwargs)
 |      Pack and send a command to the Redis server
 |
 |  send_packed_command(self, command, check_health=True)
 |      Send an already packed command to the Redis server
 |
 |  set_parser(self, parser_class)
 |      Creates a new instance of parser_class with socket size:
 |      _socket_read_size and assigns it to the parser for the connection
 |      :param parser_class: The required parser class
 |
 |  set_re_auth_token(self, token: redis.auth.token.TokenInterface)
 |
 |  should_reconnect(self)
 |      Returns True if the connection should be reconnected.
 |
 |  ----------------------------------------------------------------------
 |  Readonly properties inherited from redis.connection.AbstractConnection:
 |
 |  is_connected
 |      Return ``True`` if the connection to the server is active.
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from redis.connection.AbstractConnection:
 |
 |  handshake_metadata
 |
 |  socket_connect_timeout
 |
 |  socket_timeout
 |
 |  ----------------------------------------------------------------------
 |  Methods inherited from redis.connection.MaintNotificationsAbstractConnection:
 |
 |  activate_maint_notifications_handling_if_enabled(self, check_health=True)
 |
 |  add_maint_start_notification(self, id: int)
 |
 |  add_skipped_end_notification(self, id: int)
 |
 |  get_processed_start_notifications(self) -> set
 |
 |  get_resolved_ip(self) -> Optional[str]
 |      Extract the resolved IP address from an
 |      established connection or resolve it from the host.
 |
 |      First tries to get the actual IP from the socket (most accurate),
 |      then falls back to DNS resolution if needed.
 |
 |      Returns:
 |          str: The resolved IP address, or None if it cannot be determined
 |
 |  get_skipped_end_notifications(self) -> set
 |
 |  getpeername(self)
 |      Returns the peer name of the connection.
 |
 |  reset_received_notifications(self)
 |
 |  reset_tmp_settings(self, reset_host_address: bool = False, reset_relaxed_timeout: bool = False)
 |
 |  set_maint_notifications_cluster_handler_for_connection(self, oss_cluster_maint_notifications_handler: redis.maint_notifications.OSSMaintNotificationsHandler)
 |
 |  set_maint_notifications_pool_handler_for_connection(self, maint_notifications_pool_handler: redis.maint_notifications.MaintNotificationsPoolHandler)
 |
 |  set_tmp_settings(self, tmp_host_address: Union[str, object, NoneType] = <object object at 0x0000017B991493E0>, tmp_relaxed_timeout: Optional[float] = -1)
 |      SENTINEL keeps the host unchanged. -1 keeps the relaxed timeout unchanged.
 |
 |  update_current_socket_timeout(self, relaxed_timeout: Optional[float] = None)
 |
 |  update_parser_timeout(self, timeout: Optional[float] = None)
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from redis.connection.MaintNotificationsAbstractConnection:
 |
 |  __dict__
 |      dictionary for instance variables
 |
 |  __weakref__
 |      list of weak references to the object
 |
 |  maintenance_state

Python Library Documentation: class Redis in module redis.client

class Redis(redis.commands.redismodules.RedisModuleCommands, redis.commands.core.CoreCommands, redis.commands.sentinel.SentinelCommands)
 |  Redis(host: str = 'localhost', port: int = 6379, db: int = 0, password: str | None = None, socket_timeout: float | None = 5, socket_connect_timeout: float | None = 5, socket_read_size: int = 32768, socket_keepalive: bool | None = True, socket_keepalive_options: Union[Mapping[int, int | bytes], object, NoneType] = <object object at 0x0000017B991493E0>, connection_pool: redis.connection.ConnectionPool | None = None, unix_socket_path: str | None = None, encoding: str = 'utf-8', encoding_errors: str = 'strict', decode_responses: bool = False, retry_on_timeout: bool = False, retry: redis.retry.Retry = <redis.retry.Retry object at 0x0000017B9C6BD640>, retry_on_error: Optional[List[Type[Exception]]] = None, ssl: bool = False, ssl_keyfile: str | None = None, ssl_certfile: str | None = None, ssl_cert_reqs: 'str | ssl.VerifyMode' = 'required', ssl_include_verify_flags: Optional[List[ForwardRef('ssl.VerifyFlags')]] = None, ssl_exclude_verify_flags: Optional[List[ForwardRef('ssl.VerifyFlags')]] = None, ssl_ca_certs: str | None = None, ssl_ca_path: str | None = None, ssl_ca_data: str | None = None, ssl_check_hostname: bool = True, ssl_password: str | None = None, ssl_validate_ocsp: bool = False, ssl_validate_ocsp_stapled: bool = False, ssl_ocsp_context: 'OpenSSL.SSL.Context | None' = None, ssl_ocsp_expected_cert: str | None = None, ssl_min_version: 'ssl.TLSVersion | None' = None, ssl_ciphers: str | None = None, max_connections: int | None = None, single_connection_client: bool = False, health_check_interval: int = 0, client_name: str | None = None, lib_name: str | object | None = <object object at 0x0000017B991493E0>, lib_version: str | object | None = <object object at 0x0000017B991493E0>, driver_info: redis.driver_info.DriverInfo | object | None = <object object at 0x0000017B991493E0>, username: str | None = None, redis_connect_func: Optional[Callable[[], NoneType]] = None, credential_provider: redis.credentials.CredentialProvider | None = None, protocol: int | None = None, legacy_responses: bool = True, cache: redis.cache.CacheInterface | None = None, cache_config: redis.cache.CacheConfig | None = None, event_dispatcher: redis.event.EventDispatcher | None = None, maint_notifications_config: redis.maint_notifications.MaintNotificationsConfig | None = None, oss_cluster_maint_notifications_handler: redis.maint_notifications.OSSMaintNotificationsHandler | None = None) -> None
 |
 |  Implementation of the Redis protocol.
 |
 |  This abstract class provides a Python interface to all Redis commands
 |  and an implementation of the Redis protocol.
 |
 |  Pipelines derive from this, implementing how
 |  the commands are sent and received to the Redis server. Based on
 |  configuration, an instance will either use a ConnectionPool, or
 |  Connection object to talk to redis.
 |
 |  It is not safe to pass PubSub or Pipeline objects between threads.
 |
 |  Method resolution order:
 |      Redis
 |      redis.commands.redismodules.RedisModuleCommands
 |      redis.commands.core.CoreCommands
 |      redis.commands.core.ACLCommands
 |      redis.commands.core.ClusterCommands
 |      redis.commands.core.DataAccessCommands
 |      redis.commands.core.BasicKeyCommands
 |      redis.commands.core.HyperlogCommands
 |      redis.commands.core.HashCommands
 |      redis.commands.core.GeoCommands
 |      redis.commands.core.ListCommands
 |      redis.commands.core.ArrayCommands
 |      redis.commands.core.ScanCommands
 |      redis.commands.core.SetCommands
 |      redis.commands.core.StreamCommands
 |      redis.commands.core.SortedSetCommands
 |      redis.commands.core.ManagementCommands
 |      redis.commands.core.ModuleCommands
 |      redis.commands.core.PubSubCommands
 |      redis.commands.core.ScriptCommands
 |      redis.typing.CommandsProtocol
 |      typing.Protocol
 |      typing.Generic
 |      redis.commands.core.FunctionCommands
 |      redis.commands.sentinel.SentinelCommands
 |      builtins.object
 |
 |  Methods defined here:
 |
 |  __del__(self)
 |
 |  __enter__(self)
 |
 |  __exit__(self, exc_type, exc_value, traceback)
 |
 |  __init__(self, host: str = 'localhost', port: int = 6379, db: int = 0, password: str | None = None, socket_timeout: float | None = 5, socket_connect_timeout: float | None = 5, socket_read_size: int = 32768, socket_keepalive: bool | None = True, socket_keepalive_options: Union[Mapping[int, int | bytes], object, NoneType] = <object object at 0x0000017B991493E0>, connection_pool: redis.connection.ConnectionPool | None = None, unix_socket_path: str | None = None, encoding: str = 'utf-8', encoding_errors: str = 'strict', decode_responses: bool = False, retry_on_timeout: bool = False, retry: redis.retry.Retry = <redis.retry.Retry object at 0x0000017B9C6BD640>, retry_on_error: Optional[List[Type[Exception]]] = None, ssl: bool = False, ssl_keyfile: str | None = None, ssl_certfile: str | None = None, ssl_cert_reqs: 'str | ssl.VerifyMode' = 'required', ssl_include_verify_flags: Optional[List[ForwardRef('ssl.VerifyFlags')]] = None, ssl_exclude_verify_flags: Optional[List[ForwardRef('ssl.VerifyFlags')]] = None, ssl_ca_certs: str | None = None, ssl_ca_path: str | None = None, ssl_ca_data: str | None = None, ssl_check_hostname: bool = True, ssl_password: str | None = None, ssl_validate_ocsp: bool = False, ssl_validate_ocsp_stapled: bool = False, ssl_ocsp_context: 'OpenSSL.SSL.Context | None' = None, ssl_ocsp_expected_cert: str | None = None, ssl_min_version: 'ssl.TLSVersion | None' = None, ssl_ciphers: str | None = None, max_connections: int | None = None, single_connection_client: bool = False, health_check_interval: int = 0, client_name: str | None = None, lib_name: str | object | None = <object object at 0x0000017B991493E0>, lib_version: str | object | None = <object object at 0x0000017B991493E0>, driver_info: redis.driver_info.DriverInfo | object | None = <object object at 0x0000017B991493E0>, username: str | None = None, redis_connect_func: Optional[Callable[[], NoneType]] = None, credential_provider: redis.credentials.CredentialProvider | None = None, protocol: int | None = None, legacy_responses: bool = True, cache: redis.cache.CacheInterface | None = None, cache_config: redis.cache.CacheConfig | None = None, event_dispatcher: redis.event.EventDispatcher | None = None, maint_notifications_config: redis.maint_notifications.MaintNotificationsConfig | None = None, oss_cluster_maint_notifications_handler: redis.maint_notifications.OSSMaintNotificationsHandler | None = None) -> None
 |      Initialize a new Redis client.
 |
 |      To specify a retry policy for specific errors, you have two options:
 |
 |      1. Set the `retry_on_error` to a list of the error/s to retry on, and
 |      you can also set `retry` to a valid `Retry` object(in case the default
 |      one is not appropriate) - with this approach the retries will be triggered
 |      on the default errors specified in the Retry object enriched with the
 |      errors specified in `retry_on_error`.
 |
 |      2. Define a `Retry` object with configured 'supported_errors' and set
 |      it to the `retry` parameter - with this approach you completely redefine
 |      the errors on which retries will happen.
 |
 |      `retry_on_timeout` is deprecated - please include the TimeoutError
 |      either in the Retry object or in the `retry_on_error` list.
 |
 |      When 'connection_pool' is provided - the retry configuration of the
 |      provided pool will be used.
 |
 |      Args:
 |
 |      socket_keepalive:
 |          if `True`, TCP keepalive is enabled for TCP socket connections.
 |          Argument is ignored when connection_pool is provided.
 |      socket_keepalive_options:
 |          mapping of TCP keepalive socket option constants to values, for
 |          example `{socket.TCP_KEEPIDLE: 30}`. If left unspecified, redis-py
 |          uses TCP keepalive defaults when `socket_keepalive` is enabled:
 |          idle 30 seconds, interval 5 seconds, and 3 probes. Platform-specific
 |          options that are not available are skipped. Pass `None` or `{}` to
 |          avoid setting additional TCP keepalive options. Argument is ignored
 |          when connection_pool is provided.
 |      single_connection_client:
 |          if `True`, connection pool is not used. In that case `Redis`
 |          instance use is not thread safe.
 |      decode_responses:
 |          if `True`, the response will be decoded to utf-8.
 |          Argument is ignored when connection_pool is provided.
 |      driver_info:
 |          Optional DriverInfo object to identify upstream libraries.
 |          If provided, lib_name and lib_version are ignored.
 |          If not provided, a DriverInfo will be created from lib_name and lib_version.
 |          Explicit None disables CLIENT SETINFO.
 |          Argument is ignored when connection_pool is provided.
 |      lib_name:
 |          **Deprecated.** Use driver_info instead. Library name for CLIENT SETINFO.
 |      lib_version:
 |          **Deprecated.** Use driver_info instead. Library version for CLIENT SETINFO.
 |      maint_notifications_config:
 |          configures the pool to support maintenance notifications - see
 |          `redis.maint_notifications.MaintNotificationsConfig` for details.
 |          Only supported with RESP3
 |          If not provided and protocol is RESP3, the maintenance notifications
 |          will be enabled by default (logic is included in the connection pool
 |          initialization).
 |          Argument is ignored when connection_pool is provided.
 |      oss_cluster_maint_notifications_handler:
 |          handler for OSS cluster notifications - see
 |          `redis.maint_notifications.OSSMaintNotificationsHandler` for details.
 |          Only supported with RESP3
 |          Argument is ignored when connection_pool is provided.
 |
 |  __repr__(self) -> str
 |      Return repr(self).
 |
 |  client(self)
 |
 |  close(self) -> None
 |
 |  execute_command(self, *args, **options)
 |      # COMMAND EXECUTION AND PROTOCOL PARSING
 |
 |  get_cache(self) -> Optional[redis.cache.CacheInterface]
 |
 |  get_connection_kwargs(self) -> Dict
 |      Get the connection's key-word arguments
 |
 |  get_encoder(self) -> 'Encoder'
 |      Get the connection pool's encoder
 |
 |  get_retry(self) -> Optional[redis.retry.Retry]
 |
 |  himport_discard(self, fieldset_name: str) -> int
 |      Remove a fieldset from the registry.
 |
 |      Returns ``1`` if it was registered, ``0`` otherwise. On a pooled client the
 |      server-side ``DISCARD`` is reconciled lazily when each connection is next
 |      used for ``himport_set``. On a single connection client it runs immediately
 |      on the pinned connection when it is live; while that connection is not
 |      connected there is nothing prepared on the server to discard (its tracking is
 |      reset on connect), so no server call is made.
 |
 |  himport_discard_all(self) -> int
 |      Remove all fieldsets from the registry.
 |
 |      Returns the number removed from the registry. Server-side removal follows the
 |      same live/lazy rule as :meth:`himport_discard`.
 |
 |  himport_prepare(self, fieldset_name: str, fields: Iterable[Union[bytes, bytearray, memoryview, str, int, float]]) -> bool
 |      Declare an HIMPORT fieldset for use by :meth:`himport_set`.
 |
 |      Registers ``fieldset_name`` (ordered ``fields``, verbatim) in the client's
 |      shared registry. On a pooled client the server-side ``PREPARE`` is deferred
 |      and bundled into the next ``himport_set`` per connection. On a single
 |      connection client it is run immediately when the pinned connection is live;
 |      while that connection is not connected there is no session state to prepare,
 |      so the next ``himport_set`` prepares it lazily instead.
 |
 |  keyspace_notifications(self, key_prefix: Union[str, bytes, NoneType] = None, ignore_subscribe_messages: bool = True) -> 'KeyspaceNotifications'
 |      Return a :class:`~redis.keyspace_notifications.KeyspaceNotifications`
 |      object for subscribing to keyspace and keyevent notifications.
 |
 |      Note: Keyspace notifications must be enabled on the Redis server via
 |      the ``notify-keyspace-events`` configuration option.
 |
 |      Args:
 |          key_prefix: Optional prefix to filter and strip from keys in
 |                      notifications.
 |          ignore_subscribe_messages: If True, subscribe/unsubscribe
 |                                    confirmations are not returned by
 |                                    get_message/listen.
 |
 |  load_external_module(self, funcname, func) -> None
 |      This function can be used to add externally defined redis modules,
 |      and their namespaces to the redis client.
 |
 |      funcname - A string containing the name of the function to create
 |      func - The function, being added to this class.
 |
 |      ex: Assume that one has a custom redis module named foomod that
 |      creates command named 'foo.dothing' and 'foo.anotherthing' in redis.
 |      To load function functions into this namespace:
 |
 |      from redis import Redis
 |      from foomodule import F
 |      r = Redis()
 |      r.load_external_module("foo", F)
 |      r.foo().dothing('your', 'arguments')
 |
 |      For a concrete example see the reimport of the redisjson module in
 |      tests/test_connection.py::test_loading_external_modules
 |
 |  lock(self, name: str, timeout: Optional[float] = None, sleep: float = 0.1, blocking: bool = True, blocking_timeout: Optional[float] = None, lock_class: Optional[Any] = None, thread_local: bool = True, raise_on_release_error: bool = True)
 |      Return a new Lock object using key ``name`` that mimics
 |      the behavior of threading.Lock.
 |
 |      If specified, ``timeout`` indicates a maximum life for the lock.
 |      By default, it will remain locked until release() is called.
 |
 |      ``sleep`` indicates the amount of time to sleep per loop iteration
 |      when the lock is in blocking mode and another client is currently
 |      holding the lock.
 |
 |      ``blocking`` indicates whether calling ``acquire`` should block until
 |      the lock has been acquired or to fail immediately, causing ``acquire``
 |      to return False and the lock not being acquired. Defaults to True.
 |      Note this value can be overridden by passing a ``blocking``
 |      argument to ``acquire``.
 |
 |      ``blocking_timeout`` indicates the maximum amount of time in seconds to
 |      spend trying to acquire the lock. A value of ``None`` indicates
 |      continue trying forever. ``blocking_timeout`` can be specified as a
 |      float or integer, both representing the number of seconds to wait.
 |
 |      ``lock_class`` forces the specified lock implementation. Note that as
 |      of redis-py 3.0, the only lock class we implement is ``Lock`` (which is
 |      a Lua-based lock). So, it's unlikely you'll need this parameter, unless
 |      you have created your own custom lock class.
 |
 |      ``thread_local`` indicates whether the lock token is placed in
 |      thread-local storage. By default, the token is placed in thread local
 |      storage so that a thread only sees its token, not a token set by
 |      another thread. Consider the following timeline:
 |
 |          time: 0, thread-1 acquires `my-lock`, with a timeout of 5 seconds.
 |                   thread-1 sets the token to "abc"
 |          time: 1, thread-2 blocks trying to acquire `my-lock` using the
 |                   Lock instance.
 |          time: 5, thread-1 has not yet completed. redis expires the lock
 |                   key.
 |          time: 5, thread-2 acquired `my-lock` now that it's available.
 |                   thread-2 sets the token to "xyz"
 |          time: 6, thread-1 finishes its work and calls release(). if the
 |                   token is *not* stored in thread local storage, then
 |                   thread-1 would see the token value as "xyz" and would be
 |                   able to successfully release the thread-2's lock.
 |
 |      ``raise_on_release_error`` indicates whether to raise an exception when
 |      the lock is no longer owned when exiting the context manager. By default,
 |      this is True, meaning an exception will be raised. If False, the warning
 |      will be logged and the exception will be suppressed.
 |
 |      In some use cases it's necessary to disable thread local storage. For
 |      example, if you have code where one thread acquires a lock and passes
 |      that lock instance to a worker thread to release later. If thread
 |      local storage isn't disabled in this case, the worker thread won't see
 |      the token set by the thread that acquired the lock. Our assumption
 |      is that these cases aren't common and as such default to using
 |      thread local storage.
 |
 |  monitor(self)
 |
 |  parse_response(self, connection, command_name, **options)
 |      Parses a response from the Redis server
 |
 |  pipeline(self, transaction=True, shard_hint=None) -> 'Pipeline'
 |      Return a new pipeline object that can queue multiple commands for
 |      later execution. ``transaction`` indicates whether all commands
 |      should be executed atomically. Apart from making a group of operations
 |      atomic, pipelines are useful for reducing the back-and-forth overhead
 |      between the client and server.
 |
 |  pubsub(self, **kwargs)
 |      Return a Publish/Subscribe object. With this object, you can
 |      subscribe to channels and listen for messages that get published to
 |      them.
 |
 |  set_response_callback(self, command: str, callback: Callable) -> None
 |      Set a custom Response Callback
 |
 |  set_retry(self, retry: redis.retry.Retry) -> None
 |
 |  transaction(self, func: Callable[[ForwardRef('Pipeline')], NoneType], *watches, **kwargs) -> Union[List[Any], Any, NoneType]
 |      Convenience method for executing the callable `func` as a transaction
 |      while watching all keys specified in `watches`. The 'func' callable
 |      should expect a single argument which is a Pipeline object.
 |
 |  ----------------------------------------------------------------------
 |  Class methods defined here:
 |
 |  __subclasshook__ = _proto_hook(other) from typing
 |
 |  from_pool(connection_pool: redis.connection.ConnectionPool) -> 'Redis'
 |      Return a Redis client from the given connection pool.
 |      The Redis client will take ownership of the connection pool and
 |      close it when the Redis client is closed.
 |
 |      Because the client closes (disconnects all connections in) the pool
 |      when it is closed or garbage-collected, the pool must not be shared
 |      with other clients. Constructing multiple clients from the same pool
 |      via ``from_pool`` -- for example one per request across threads -- is
 |      not thread safe: when one client is closed it will disconnect
 |      connections still in use by the others.
 |
 |      To share a single pool across clients, construct the pool explicitly
 |      and manage its lifecycle instead. Unlike ``from_pool``, the plain
 |      ``Redis(connection_pool=pool)`` constructor does not take ownership of
 |      the pool and will not close it, so a pool created this way can be
 |      safely shared across clients. ``ConnectionPool`` supports the context
 |      manager protocol for this::
 |
 |          with ConnectionPool.from_url(url) as pool:
 |              r = Redis(connection_pool=pool)
 |
 |  from_url(url: str, **kwargs) -> 'Redis'
 |      Return a Redis client object configured from the given URL
 |
 |      For example::
 |
 |          redis://[[username]:[password]]@localhost:6379/0
 |          rediss://[[username]:[password]]@localhost:6379/0
 |          unix://[username@]/path/to/socket.sock?db=0[&password=password]
 |
 |      Three URL schemes are supported:
 |
 |      - `redis://` creates a TCP socket connection. See more at:
 |        <https://www.iana.org/assignments/uri-schemes/prov/redis>
 |      - `rediss://` creates a SSL wrapped TCP socket connection. See more at:
 |        <https://www.iana.org/assignments/uri-schemes/prov/rediss>
 |      - ``unix://``: creates a Unix Domain Socket connection.
 |
 |      The username, password, hostname, path and all querystring values
 |      are passed through urllib.parse.unquote in order to replace any
 |      percent-encoded values with their corresponding characters.
 |
 |      There are several ways to specify a database number. The first value
 |      found will be used:
 |
 |          1. A ``db`` querystring option, e.g. redis://localhost?db=0
 |          2. If using the redis:// or rediss:// schemes, the path argument
 |             of the url, e.g. redis://localhost/0
 |          3. A ``db`` keyword argument to this function.
 |
 |      If none of these options are specified, the default db=0 is used.
 |
 |      All querystring options are cast to their appropriate Python types.
 |      Boolean arguments can be specified with string values "True"/"False"
 |      or "Yes"/"No". Values that cannot be properly cast cause a
 |      ``ValueError`` to be raised. Once parsed, the querystring arguments
 |      and keyword arguments are passed to the ``ConnectionPool``'s
 |      class initializer. In the case of conflicting arguments, querystring
 |      arguments always win.
 |
 |  ----------------------------------------------------------------------
 |  Readonly properties defined here:
 |
 |  himport_registry
 |      The client's HIMPORT fieldset registry (contains empty
 |      schema registry if none was declared).
 |
 |      Read-only: the registry is mutated only through the HIMPORT command methods.
 |
 |  ----------------------------------------------------------------------
 |  Data and other attributes defined here:
 |
 |  __abstractmethods__ = frozenset()
 |
 |  __annotations__ = {'_is_async_client': typing.Literal[False]}
 |
 |  __parameters__ = ()
 |
 |  ----------------------------------------------------------------------
 |  Methods inherited from redis.commands.redismodules.RedisModuleCommands:
 |
 |  bf(self) -> 'BFBloom'
 |      Access the bloom namespace.
 |
 |  cf(self) -> 'CFBloom'
 |      Access the bloom namespace.
 |
 |  cms(self) -> 'CMSBloom'
 |      Access the bloom namespace.
 |
 |  ft(self, index_name='idx') -> 'Search'
 |      Access the search namespace, providing support for redis search.
 |
 |  json(self, encoder=<json.encoder.JSONEncoder object at 0x0000017B9C588F50>, decoder=<json.decoder.JSONDecoder object at 0x0000017B9C588FB0>) -> 'JSON'
 |      Access the json namespace, providing support for redis json.
 |
 |  tdigest(self) -> 'TDigestBloom'
 |      Access the bloom namespace.
 |
 |  topk(self) -> 'TOPKBloom'
 |      Access the bloom namespace.
 |
 |  ts(self) -> 'TimeSeries'
 |      Access the timeseries namespace, providing support for
 |      redis timeseries data.
 |
 |  vset(self) -> 'VectorSet'
 |      Access the VectorSet commands namespace.
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from redis.commands.redismodules.RedisModuleCommands:
 |
 |  __dict__
 |      dictionary for instance variables
 |
 |  __weakref__
 |      list of weak references to the object
 |
 |  ----------------------------------------------------------------------
 |  Methods inherited from redis.commands.core.ACLCommands:
 |
 |  acl_cat(self, category: 'str | None' = None, **kwargs) -> 'list[bytes | str] | Awaitable[list[bytes | str]]'
 |      Returns a list of categories or commands within a category.
 |
 |      If ``category`` is not supplied, returns a list of all categories.
 |      If ``category`` is supplied, returns a list of all commands within
 |      that category.
 |
 |      For more information, see https://redis.io/commands/acl-cat
 |
 |  acl_deluser(self, *username: 'str', **kwargs) -> 'int | Awaitable[int]'
 |      Delete the ACL for the specified ``username``\s
 |
 |      For more information, see https://redis.io/commands/acl-deluser
 |
 |  acl_dryrun(self, username: 'str', *args: 'EncodableT', **kwargs) -> 'bytes | str | Awaitable[bytes | str]'
 |      Simulate the execution of a given command by a given ``username``.
 |
 |      For more information, see https://redis.io/commands/acl-dryrun
 |
 |  acl_genpass(self, bits: 'int | None' = None, **kwargs) -> 'bytes | str | Awaitable[bytes | str]'
 |      Generate a random password value.
 |      If ``bits`` is supplied then use this number of bits, rounded to
 |      the next multiple of 4.
 |      See: https://redis.io/commands/acl-genpass
 |
 |  acl_getuser(self, username: 'str', **kwargs) -> 'ACLGetUserData | Awaitable[ACLGetUserData]'
 |      Get the ACL details for the specified ``username``.
 |
 |      If ``username`` does not exist, return None
 |
 |      For more information, see https://redis.io/commands/acl-getuser
 |
 |  acl_help(self, **kwargs) -> 'list[bytes | str] | Awaitable[list[bytes | str]]'
 |      The ACL HELP command returns helpful text describing
 |      the different subcommands.
 |
 |      For more information, see https://redis.io/commands/acl-help
 |
 |  acl_list(self, **kwargs) -> 'list[bytes | str] | Awaitable[list[bytes | str]]'
 |      Return a list of all ACLs on the server
 |
 |      For more information, see https://redis.io/commands/acl-list
 |
 |  acl_load(self, **kwargs) -> 'bool | Awaitable[bool]'
 |      Load ACL rules from the configured ``aclfile``.
 |
 |      Note that the server must be configured with the ``aclfile``
 |      directive to be able to load ACL rules from an aclfile.
 |
 |      For more information, see https://redis.io/commands/acl-load
 |
 |  acl_log(self, count: 'int | None' = None, **kwargs) -> 'ACLLogData | Awaitable[ACLLogData]'
 |      Get ACL logs as a list.
 |      :param int count: Get logs[0:count].
 |      :rtype: List.
 |
 |      For more information, see https://redis.io/commands/acl-log
 |
 |  acl_log_reset(self, **kwargs) -> 'bool | Awaitable[bool]'
 |      Reset ACL logs.
 |      :rtype: Boolean.
 |
 |      For more information, see https://redis.io/commands/acl-log
 |
 |  acl_save(self, **kwargs) -> 'bool | Awaitable[bool]'
 |      Save ACL rules to the configured ``aclfile``.
 |
 |      Note that the server must be configured with the ``aclfile``
 |      directive to be able to save ACL rules to an aclfile.
 |
 |      For more information, see https://redis.io/commands/acl-save
 |
 |  acl_setuser(self, username: 'str', enabled: 'bool' = False, nopass: 'bool' = False, passwords: 'str | Iterable[str] | None' = None, hashed_passwords: 'str | Iterable[str] | None' = None, categories: 'Iterable[str] | None' = None, commands: 'Iterable[str] | None' = None, keys: 'Iterable[KeyT] | None' = None, channels: 'Iterable[ChannelT] | None' = None, selectors: 'Iterable[Tuple[str, KeyT]] | None' = None, reset: 'bool' = False, reset_keys: 'bool' = False, reset_channels: 'bool' = False, reset_passwords: 'bool' = False, **kwargs) -> 'bool | Awaitable[bool]'
 |      Create or update an ACL user.
 |
 |      Create or update the ACL for `username`. If the user already exists,
 |      the existing ACL is completely overwritten and replaced with the
 |      specified values.
 |
 |      For more information, see https://redis.io/commands/acl-setuser
 |
 |      Args:
 |          username: The name of the user whose ACL is to be created or updated.
 |          enabled: Indicates whether the user should be allowed to authenticate.
 |                   Defaults to `False`.
 |          nopass: Indicates whether the user can authenticate without a password.
 |                  This cannot be `True` if `passwords` are also specified.
 |          passwords: A list of plain text passwords to add to or remove from the user.
 |                     Each password must be prefixed with a '+' to add or a '-' to
 |                     remove. For convenience, a single prefixed string can be used
 |                     when adding or removing a single password.
 |          hashed_passwords: A list of SHA-256 hashed passwords to add to or remove
 |                            from the user. Each hashed password must be prefixed with
 |                            a '+' to add or a '-' to remove. For convenience, a single
 |                            prefixed string can be used when adding or removing a
 |                            single password.
 |          categories: A list of strings representing category permissions. Each string
 |                      must be prefixed with either a '+' to add the category
 |                      permission or a '-' to remove the category permission.
 |          commands: A list of strings representing command permissions. Each string
 |                    must be prefixed with either a '+' to add the command permission
 |                    or a '-' to remove the command permission.
 |          keys: A list of key patterns to grant the user access to. Key patterns allow
 |                ``'*'`` to support wildcard matching. For example, ``'*'`` grants
 |                access to all keys while ``'cache:*'`` grants access to all keys that
 |                are prefixed with ``cache:``.
 |                `keys` should not be prefixed with a ``'~'``.
 |          reset: Indicates whether the user should be fully reset prior to applying
 |                 the new ACL. Setting this to `True` will remove all existing
 |                 passwords, flags, and privileges from the user and then apply the
 |                 specified rules. If `False`, the user's existing passwords, flags,
 |                 and privileges will be kept and any new specified rules will be
 |                 applied on top.
 |          reset_keys: Indicates whether the user's key permissions should be reset
 |                      prior to applying any new key permissions specified in `keys`.
 |                      If `False`, the user's existing key permissions will be kept and
 |                      any new specified key permissions will be applied on top.
 |          reset_channels: Indicates whether the user's channel permissions should be
 |                          reset prior to applying any new channel permissions
 |                          specified in `channels`. If `False`, the user's existing
 |                          channel permissions will be kept and any new specified
 |                          channel permissions will be applied on top.
 |          reset_passwords: Indicates whether to remove all existing passwords and the
 |                           `nopass` flag from the user prior to applying any new
 |                           passwords specified in `passwords` or `hashed_passwords`.
 |                           If `False`, the user's existing passwords and `nopass`
 |                           status will be kept and any new specified passwords or
 |                           hashed passwords will be applied on top.
 |
 |  acl_users(self, **kwargs) -> 'list[bytes | str] | Awaitable[list[bytes | str]]'
 |      Returns a list of all registered users on the server.
 |
 |      For more information, see https://redis.io/commands/acl-users
 |
 |  acl_whoami(self, **kwargs) -> 'bytes | str | Awaitable[bytes | str]'
 |      Get the username for the current connection
 |
 |      For more information, see https://redis.io/commands/acl-whoami
 |
 |  ----------------------------------------------------------------------
 |  Methods inherited from redis.commands.core.ClusterCommands:
 |
 |  cluster(self, cluster_arg, *args, **kwargs) -> 'Any | Awaitable[Any]'
 |
 |  readonly(self, **kwargs) -> 'bool | Awaitable[bool]'
 |      Enables read queries for a connection to a Redis Cluster replica node.
 |
 |      For more information, see https://redis.io/commands/readonly
 |
 |  readwrite(self, **kwargs) -> 'bool | Awaitable[bool]'
 |      Disables read queries for a connection to a Redis Cluster slave node.
 |
 |      For more information, see https://redis.io/commands/readwrite
 |
 |  ----------------------------------------------------------------------
 |  Methods inherited from redis.commands.core.BasicKeyCommands:
 |
 |  __contains__ = exists(self, *names: 'KeyT') -> 'int | Awaitable[int]'
 |
 |  __delitem__(self, name: 'KeyT')
 |
 |  __getitem__(self, name: 'KeyT')
 |      Return the value at key ``name``, raises a KeyError if the key
 |      doesn't exist.
 |
 |  __setitem__(self, name: 'KeyT', value: 'EncodableT')
 |
 |  append(self, key: 'KeyT', value: 'EncodableT') -> 'int | Awaitable[int]'
 |      Appends the string ``value`` to the value at ``key``. If ``key``
 |      doesn't already exist, create it with a value of ``value``.
 |      Returns the new length of the value at ``key``.
 |
 |      For more information, see https://redis.io/commands/append
 |
 |  bitcount(self, key: 'KeyT', start: 'int | None' = None, end: 'int | None' = None, mode: 'str | None' = None) -> 'int | Awaitable[int]'
 |      Returns the count of set bits in the value of ``key``.  Optional
 |      ``start`` and ``end`` parameters indicate which bytes to consider
 |
 |      For more information, see https://redis.io/commands/bitcount
 |
 |  bitfield(self: "Union['redis.client.Redis', 'redis.asyncio.client.Redis']", key: 'KeyT', default_overflow: 'str | None' = None) -> 'BitFieldOperation'
 |      Return a BitFieldOperation instance to conveniently construct one or
 |      more bitfield operations on ``key``.
 |
 |      For more information, see https://redis.io/commands/bitfield
 |
 |  bitfield_ro(self: "Union['redis.client.Redis', 'redis.asyncio.client.Redis']", key: 'KeyT', encoding: 'str', offset: 'BitfieldOffsetT', items: 'list[tuple[str, BitfieldOffsetT]] | None' = None) -> 'list[int] | Awaitable[list[int]]'
 |      Return an array of the specified bitfield values
 |      where the first value is found using ``encoding`` and ``offset``
 |      parameters and remaining values are result of corresponding
 |      encoding/offset pairs in optional list ``items``
 |      Read-only variant of the BITFIELD command.
 |
 |      For more information, see https://redis.io/commands/bitfield_ro
 |
 |  bitop(self, operation: 'str', dest: 'KeyT', *keys: 'KeyT') -> 'int | Awaitable[int]'
 |      Perform a bitwise operation using ``operation`` between ``keys`` and
 |      store the result in ``dest``.
 |
 |      For more information, see https://redis.io/commands/bitop
 |
 |  bitpos(self, key: 'KeyT', bit: 'int', start: 'int | None' = None, end: 'int | None' = None, mode: 'str | None' = None) -> 'int | Awaitable[int]'
 |      Return the position of the first bit set to 1 or 0 in a string.
 |      ``start`` and ``end`` defines search range. The range is interpreted
 |      as a range of bytes and not a range of bits, so start=0 and end=2
 |      means to look at the first three bytes.
 |
 |      For more information, see https://redis.io/commands/bitpos
 |
 |  blmove(self, first_list: 'str', second_list: 'str', timeout: 'int', src: 'str' = 'LEFT', dest: 'str' = 'RIGHT') -> 'bytes | str | None | Awaitable[bytes | str | None]'
 |      Blocking version of lmove.
 |
 |      For more information, see https://redis.io/commands/blmove
 |
 |  blmovem(self, first_list: 'str', second_list: 'str', timeout: 'float', src: 'str' = 'LEFT', dest: 'str' = 'RIGHT', count: 'int | None' = None, mode: "Literal['COUNT', 'EXACTLY'] | None" = None, ordering: "Literal['OBO', 'BULK'] | None" = None) -> 'list[bytes | str] | None | Awaitable[list[bytes | str] | None]'
 |      Blocking version of lmovem.
 |
 |      Blocks until elements are available to move or ``timeout`` (in seconds)
 |      is reached; a ``timeout`` of ``0`` blocks indefinitely. With ``COUNT``
 |      the command unblocks once at least one element is available and moves
 |      ``min(count, available)``; with ``EXACTLY`` it blocks until the source
 |      holds at least ``count`` elements, then moves exactly ``count``
 |      atomically. On timeout ``None`` is returned and nothing is moved.
 |
 |      As with ``lmovem``, ``ordering`` (OBO or BULK) is required whenever
 |      ``count`` is given.
 |
 |      For more information, see https://redis.io/commands/blmovem
 |
 |  copy(self, source: 'str', destination: 'str', destination_db: 'str | None' = None, replace: 'bool' = False) -> 'bool | Awaitable[bool]'
 |      Copy the value stored in the ``source`` key to the ``destination`` key.
 |
 |      ``destination_db`` an alternative destination database. By default,
 |      the ``destination`` key is created in the source Redis database.
 |
 |      ``replace`` whether the ``destination`` key should be removed before
 |      copying the value to it. By default, the value is not copied if
 |      the ``destination`` key already exists.
 |
 |      For more information, see https://redis.io/commands/copy
 |
 |  decr = decrby(self, name: 'KeyT', amount: 'int' = 1) -> 'int | Awaitable[int]'
 |
 |  decrby(self, name: 'KeyT', amount: 'int' = 1) -> 'int | Awaitable[int]'
 |      Decrements the value of ``key`` by ``amount``.  If no key exists,
 |      the value will be initialized as 0 - ``amount``
 |
 |      For more information, see https://redis.io/commands/decrby
 |
 |  delete(self, *names: 'KeyT') -> 'int | Awaitable[int]'
 |      Delete one or more keys specified by ``names``
 |
 |  delex(self, name: 'KeyT', ifeq: 'bytes | str | None' = None, ifne: 'bytes | str | None' = None, ifdeq: 'str | None' = None, ifdne: 'str | None' = None) -> 'int | Awaitable[int]'
 |      Conditionally removes the specified key.
 |
 |      Warning:
 |      **Experimental** since 7.1.
 |      This API may change or be removed without notice.
 |      The API may change based on feedback.
 |
 |      Arguments:
 |          name: KeyT - the key to delete
 |          ifeq match-valu: Optional[Union[bytes, str]] - Delete the key only if its value is equal to match-value
 |          ifne match-value: Optional[Union[bytes, str]] - Delete the key only if its value is not equal to match-value
 |          ifdeq match-digest: Optional[str] - Delete the key only if the digest of its value is equal to match-digest
 |          ifdne match-digest: Optional[str] - Delete the key only if the digest of its value is not equal to match-digest
 |
 |      Returns:
 |          int: 1 if the key was deleted, 0 otherwise.
 |      Raises:
 |          redis.exceptions.ResponseError: if key exists but is not a string
 |                                          and a condition is specified.
 |          ValueError: if more than one condition is provided.
 |
 |
 |      Requires Redis 8.4 or greater.
 |      For more information, see https://redis.io/commands/delex
 |
 |  digest(self, name: 'KeyT') -> 'str | bytes | None | Awaitable[str | bytes | None]'
 |      Return the digest of the value stored at the specified key.
 |
 |      Warning:
 |      **Experimental** since 7.1.
 |      This API may change or be removed without notice.
 |      The API may change based on feedback.
 |
 |      Arguments:
 |        - name: KeyT - the key to get the digest of
 |
 |      Returns:
 |        - None if the key does not exist
 |        - (bulk string) the XXH3 digest of the value as a hex string
 |      Raises:
 |        - ResponseError if key exists but is not a string
 |
 |
 |      Requires Redis 8.4 or greater.
 |      For more information, see https://redis.io/commands/digest
 |
 |  digest_local(self, value: 'bytes | str') -> 'bytes | str'
 |      Compute the hexadecimal digest of the value locally, without sending it to the server.
 |
 |      This is useful for conditional operations like IFDEQ/IFDNE where you need to
 |      compute the digest client-side before sending a command.
 |
 |      Warning:
 |      **Experimental** - This API may change or be removed without notice.
 |
 |      Arguments:
 |        - value: Union[bytes, str] - the value to compute the digest of.
 |          If a string is provided, it will be encoded using UTF-8 before hashing,
 |          which matches Redis's default encoding behavior.
 |
 |      Returns:
 |        - (str | bytes) the XXH3 digest of the value as a hex string (16 hex characters).
 |          Returns bytes if decode_responses is False, otherwise returns str.
 |
 |      For more information, see https://redis.io/commands/digest
 |
 |  dump(self, name: 'KeyT') -> 'bytes | None | Awaitable[bytes | None]'
 |      Return a serialized version of the value stored at the specified key.
 |      If key does not exist a nil bulk reply is returned.
 |
 |      For more information, see https://redis.io/commands/dump
 |
 |  exists(self, *names: 'KeyT') -> 'int | Awaitable[int]'
 |      Returns the number of ``names`` that exist
 |
 |      For more information, see https://redis.io/commands/exists
 |
 |  expire(self, name: 'KeyT', time: 'ExpiryT', nx: 'bool' = False, xx: 'bool' = False, gt: 'bool' = False, lt: 'bool' = False) -> 'bool | Awaitable[bool]'
 |      Set an expire flag on key ``name`` for ``time`` seconds with given
 |      ``option``. ``time`` can be represented by an integer or a Python timedelta
 |      object.
 |
 |      Valid options are:
 |          NX -> Set expiry only when the key has no expiry
 |          XX -> Set expiry only when the key has an existing expiry
 |          GT -> Set expiry only when the new expiry is greater than current one
 |          LT -> Set expiry only when the new expiry is less than current one
 |
 |      For more information, see https://redis.io/commands/expire
 |
 |  expireat(self, name: 'KeyT', when: 'AbsExpiryT', nx: 'bool' = False, xx: 'bool' = False, gt: 'bool' = False, lt: 'bool' = False) -> 'bool | Awaitable[bool]'
 |      Set an expire flag on key ``name`` with given ``option``. ``when``
 |      can be represented as an integer indicating unix time or a Python
 |      datetime object.
 |
 |      Valid options are:
 |          -> NX -- Set expiry only when the key has no expiry
 |          -> XX -- Set expiry only when the key has an existing expiry
 |          -> GT -- Set expiry only when the new expiry is greater than current one
 |          -> LT -- Set expiry only when the new expiry is less than current one
 |
 |      For more information, see https://redis.io/commands/expireat
 |
 |  expiretime(self, key: 'str') -> 'int | Awaitable[int]'
 |      Returns the absolute Unix timestamp (since January 1, 1970) in seconds
 |      at which the given key will expire.
 |
 |      For more information, see https://redis.io/commands/expiretime
 |
 |  get(self, name: 'KeyT') -> 'bytes | str | None | Awaitable[bytes | str | None]'
 |      Return the value at key ``name``, or None if the key doesn't exist
 |
 |      For more information, see https://redis.io/commands/get
 |
 |  getbit(self, name: 'KeyT', offset: 'int') -> 'int | Awaitable[int]'
 |      Returns an integer indicating the value of ``offset`` in ``name``
 |
 |      For more information, see https://redis.io/commands/getbit
 |
 |  getdel(self, name: 'KeyT') -> 'bytes | str | None | Awaitable[bytes | str | None]'
 |      Get the value at key ``name`` and delete the key. This command
 |      is similar to GET, except for the fact that it also deletes
 |      the key on success (if and only if the key's value type
 |      is a string).
 |
 |      For more information, see https://redis.io/commands/getdel
 |
 |  getex(self, name: 'KeyT', ex: 'ExpiryT | None' = None, px: 'ExpiryT | None' = None, exat: 'AbsExpiryT | None' = None, pxat: 'AbsExpiryT | None' = None, persist: 'bool' = False) -> 'bytes | str | None | Awaitable[bytes | str | None]'
 |      Get the value of key and optionally set its expiration.
 |      GETEX is similar to GET, but is a write command with
 |      additional options. All time parameters can be given as
 |      datetime.timedelta or integers.
 |
 |      ``ex`` sets an expire flag on key ``name`` for ``ex`` seconds.
 |
 |      ``px`` sets an expire flag on key ``name`` for ``px`` milliseconds.
 |
 |      ``exat`` sets an expire flag on key ``name`` for ``ex`` seconds,
 |      specified in unix time.
 |
 |      ``pxat`` sets an expire flag on key ``name`` for ``ex`` milliseconds,
 |      specified in unix time.
 |
 |      ``persist`` remove the time to live associated with ``name``.
 |
 |      For more information, see https://redis.io/commands/getex
 |
 |  getrange(self, key: 'KeyT', start: 'int', end: 'int') -> 'bytes | str | Awaitable[bytes | str]'
 |      Returns the substring of the string value stored at ``key``,
 |      determined by the offsets ``start`` and ``end`` (both are inclusive)
 |
 |      For more information, see https://redis.io/commands/getrange
 |
 |  getset(self, name: 'KeyT', value: 'EncodableT') -> 'bytes | str | None | Awaitable[bytes | str | None]'
 |      Sets the value at key ``name`` to ``value``
 |      and returns the old value at key ``name`` atomically.
 |
 |      As per Redis 6.2, GETSET is considered deprecated.
 |      Please use SET with GET parameter in new code.
 |
 |      For more information, see https://redis.io/commands/getset
 |
 |  hrandfield(self, key: 'KeyT', count: 'int | None' = None, withvalues: 'bool' = False) -> 'HRandFieldResponse | Awaitable[HRandFieldResponse]'
 |      Return a random field from the hash value stored at key.
 |
 |      count: if the argument is positive, return an array of distinct fields.
 |      If called with a negative count, the behavior changes and the command
 |      is allowed to return the same field multiple times. In this case,
 |      the number of returned fields is the absolute value of the
 |      specified count.
 |      withvalues: The optional WITHVALUES modifier changes the reply so it
 |      includes the respective values of the randomly selected hash fields.
 |
 |      For more information, see https://redis.io/commands/hrandfield
 |
 |  incr = incrby(self, name: 'KeyT', amount: 'int' = 1) -> 'int | Awaitable[int]'
 |
 |  incrby(self, name: 'KeyT', amount: 'int' = 1) -> 'int | Awaitable[int]'
 |      Increments the value of ``key`` by ``amount``.  If no key exists,
 |      the value will be initialized as ``amount``
 |
 |      For more information, see https://redis.io/commands/incrby
 |
 |  incrbyfloat(self, name: 'KeyT', amount: 'float' = 1.0) -> 'float | Awaitable[float]'
 |      Increments the value at key ``name`` by floating ``amount``.
 |      If no key exists, the value will be initialized as ``amount``
 |
 |      For more information, see https://redis.io/commands/incrbyfloat
 |
 |  increx(self, name: 'KeyT', *, byfloat: 'EncodableT | None' = None, byint: 'EncodableT | None' = None, lbound: 'EncodableT | None' = None, ubound: 'EncodableT | None' = None, saturate: 'bool' = False, ex: 'ExpiryT | None' = None, px: 'ExpiryT | None' = None, exat: 'AbsExpiryT | None' = None, pxat: 'AbsExpiryT | None' = None, persist: 'bool' = False, enx: 'bool' = False) -> 'list[Number | bytes | str] | Awaitable[list[Number | bytes | str]]'
 |      Increment the numeric value at key ``name`` and return the new value
 |      and the actual increment.
 |
 |      ``byfloat`` increments a floating point value by the provided amount.
 |
 |      ``byint`` increments an integer value by the provided amount.
 |
 |      If neither ``byfloat`` nor ``byint`` is specified, the value is
 |      incremented by one.
 |
 |      ``lbound`` and ``ubound`` constrain the valid range of the result.
 |
 |      If ``saturate`` is True, out-of-bounds results are saturated to the
 |      specified bound, or to the type limit when no bound is specified.
 |      Otherwise, out-of-bounds results are rejected, leaving the value and
 |      TTL unchanged and returning the current value and zero as the actual
 |      increment.
 |
 |      ``enx`` applies the expiration only when the key does not already
 |      have an expiration, and requires ``ex``, ``px``, ``exat``, or ``pxat``.
 |
 |  keys(self, pattern: 'PatternT' = '*', **kwargs) -> 'list[bytes | str] | Awaitable[list[bytes | str]]'
 |      Returns a list of keys matching ``pattern``
 |
 |      For more information, see https://redis.io/commands/keys
 |
 |  lcs(self, key1: 'str', key2: 'str', len: 'bool | None' = False, idx: 'bool | None' = False, minmatchlen: 'int | None' = 0, withmatchlen: 'bool | None' = False) -> 'LCSCommandResponse | Awaitable[LCSCommandResponse]'
 |      Find the longest common subsequence between ``key1`` and ``key2``.
 |      If ``len`` is true the length of the match will be returned.
 |      If ``idx`` is true the match position in each strings will be returned.
 |      ``minmatchlen`` restrict the list of matches to the ones of
 |      the given ``minmatchlen``.
 |      If ``withmatchlen`` the length of the match also will be returned.
 |      For more information, see https://redis.io/commands/lcs
 |
 |  lmove(self, first_list: 'str', second_list: 'str', src: 'str' = 'LEFT', dest: 'str' = 'RIGHT') -> 'bytes | str | None | Awaitable[bytes | str | None]'
 |      Atomically returns and removes the first/last element of a list,
 |      pushing it as the first/last element on the destination list.
 |      Returns the element being popped and pushed.
 |
 |      For more information, see https://redis.io/commands/lmove
 |
 |  lmovem(self, first_list: 'str', second_list: 'str', src: 'str' = 'LEFT', dest: 'str' = 'RIGHT', count: 'int | None' = None, mode: "Literal['COUNT', 'EXACTLY'] | None" = None, ordering: "Literal['OBO', 'BULK'] | None" = None) -> 'list[bytes | str] | None | Awaitable[list[bytes | str] | None]'
 |      Atomically moves multiple elements from one end of the ``first_list``
 |      to one end of the ``second_list``, returning the moved elements in
 |      destination order.
 |
 |      ``src`` and ``dest`` are the ends to pop from / push to, either
 |      ``LEFT`` (head) or ``RIGHT`` (tail).
 |
 |      When ``count`` is given, ``mode`` selects how many elements to move:
 |      ``COUNT`` (the default) moves up to ``count`` elements, while
 |      ``EXACTLY`` moves exactly ``count`` elements or nothing at all. When
 |      ``count`` is not given a single element is moved.
 |
 |      ``ordering`` controls the order at the destination: ``OBO`` pushes each
 |      element as it is popped (reversing block order, stack semantics) while
 |      ``BULK`` preserves the original relative order (queue semantics). It is
 |      required whenever ``count`` is given.
 |
 |      Returns the array of moved elements, or ``None`` if nothing was moved.
 |
 |      For more information, see https://redis.io/commands/lmovem
 |
 |  mget(self, keys: 'KeysT', *args: 'EncodableT') -> 'list[bytes | str | None] | Awaitable[list[bytes | str | None]]'
 |      Returns a list of values ordered identically to ``keys``
 |
 |      ** Important ** When this method is used with Cluster clients, all keys
 |              must be in the same hash slot, otherwise a RedisClusterException
 |              will be raised.
 |
 |      For more information, see https://redis.io/commands/mget
 |
 |  move(self, name: 'KeyT', db: 'int') -> 'bool | Awaitable[bool]'
 |      Moves the key ``name`` to a different Redis database ``db``
 |
 |      For more information, see https://redis.io/commands/move
 |
 |  mset(self, mapping: 'Mapping[AnyKeyT, EncodableT]') -> 'bool | Awaitable[bool]'
 |      Sets key/values based on a mapping. Mapping is a dictionary of
 |      key/value pairs. Both keys and values should be strings or types that
 |      can be cast to a string via str().
 |
 |      ** Important ** When this method is used with Cluster clients, all keys
 |              must be in the same hash slot, otherwise a RedisClusterException
 |              will be raised.
 |
 |      For more information, see https://redis.io/commands/mset
 |
 |  msetex(self, mapping: 'Mapping[AnyKeyT, EncodableT]', data_persist_option: 'DataPersistOptions | None' = None, ex: 'ExpiryT | None' = None, px: 'ExpiryT | None' = None, exat: 'AbsExpiryT | None' = None, pxat: 'AbsExpiryT | None' = None, keepttl: 'bool' = False) -> 'int | Awaitable[int]'
 |      Sets key/values based on the provided ``mapping`` items.
 |
 |      ** Important ** When this method is used with Cluster clients, all keys
 |                      must be in the same hash slot, otherwise a RedisClusterException
 |                      will be raised.
 |
 |      ``mapping`` accepts a dict of key/value pairs that will be added to the database.
 |
 |      ``data_persist_option`` can be set to ``NX`` or ``XX`` to control the
 |          behavior of the command.
 |          ``NX`` will set the value for each provided key to each
 |              provided value only if all do not already exist.
 |          ``XX`` will set the value for each provided key to each
 |              provided value only if all already exist.
 |
 |      ``ex`` sets an expire flag on the keys in ``mapping`` for ``ex`` seconds.
 |
 |      ``px`` sets an expire flag on the keys in ``mapping`` for ``px`` milliseconds.
 |
 |      ``exat`` sets an expire flag on the keys in ``mapping`` for ``exat`` seconds,
 |          specified in unix time.
 |
 |      ``pxat`` sets an expire flag on the keys in ``mapping`` for ``pxat`` milliseconds,
 |          specified in unix time.
 |
 |      ``keepttl`` if True, retain the time to live associated with the keys.
 |
 |      Returns the number of fields that were added.
 |
 |      Available since Redis 8.4
 |      For more information, see https://redis.io/commands/msetex
 |
 |  msetnx(self, mapping: 'Mapping[AnyKeyT, EncodableT]') -> 'bool | Awaitable[bool]'
 |      Sets key/values based on a mapping if none of the keys are already set.
 |      Mapping is a dictionary of key/value pairs. Both keys and values
 |      should be strings or types that can be cast to a string via str().
 |      Returns a boolean indicating if the operation was successful.
 |
 |      ** Important ** When this method is used with Cluster clients, all keys
 |                      must be in the same hash slot, otherwise a RedisClusterException
 |                      will be raised.
 |
 |      For more information, see https://redis.io/commands/msetnx
 |
 |  persist(self, name: 'KeyT') -> 'bool | Awaitable[bool]'
 |      Removes an expiration on ``name``
 |
 |      For more information, see https://redis.io/commands/persist
 |
 |  pexpire(self, name: 'KeyT', time: 'ExpiryT', nx: 'bool' = False, xx: 'bool' = False, gt: 'bool' = False, lt: 'bool' = False) -> 'bool | Awaitable[bool]'
 |      Set an expire flag on key ``name`` for ``time`` milliseconds
 |      with given ``option``. ``time`` can be represented by an
 |      integer or a Python timedelta object.
 |
 |      Valid options are:
 |          NX -> Set expiry only when the key has no expiry
 |          XX -> Set expiry only when the key has an existing expiry
 |          GT -> Set expiry only when the new expiry is greater than current one
 |          LT -> Set expiry only when the new expiry is less than current one
 |
 |      For more information, see https://redis.io/commands/pexpire
 |
 |  pexpireat(self, name: 'KeyT', when: 'AbsExpiryT', nx: 'bool' = False, xx: 'bool' = False, gt: 'bool' = False, lt: 'bool' = False) -> 'bool | Awaitable[bool]'
 |      Set an expire flag on key ``name`` with given ``option``. ``when``
 |      can be represented as an integer representing unix time in
 |      milliseconds (unix time * 1000) or a Python datetime object.
 |
 |      Valid options are:
 |          NX -> Set expiry only when the key has no expiry
 |          XX -> Set expiry only when the key has an existing expiry
 |          GT -> Set expiry only when the new expiry is greater than current one
 |          LT -> Set expiry only when the new expiry is less than current one
 |
 |      For more information, see https://redis.io/commands/pexpireat
 |
 |  pexpiretime(self, key: 'str') -> 'int | Awaitable[int]'
 |      Returns the absolute Unix timestamp (since January 1, 1970) in milliseconds
 |      at which the given key will expire.
 |
 |      For more information, see https://redis.io/commands/pexpiretime
 |
 |  psetex(self, name: 'KeyT', time_ms: 'ExpiryT', value: 'EncodableT') -> 'bool | Awaitable[bool]'
 |      Set the value of key ``name`` to ``value`` that expires in ``time_ms``
 |      milliseconds. ``time_ms`` can be represented by an integer or a Python
 |      timedelta object
 |
 |      For more information, see https://redis.io/commands/psetex
 |
 |  pttl(self, name: 'KeyT') -> 'int | Awaitable[int]'
 |      Returns the number of milliseconds until the key ``name`` will expire
 |
 |      For more information, see https://redis.io/commands/pttl
 |
 |  randomkey(self, **kwargs) -> 'bytes | str | None | Awaitable[bytes | str | None]'
 |      Returns the name of a random key
 |
 |      For more information, see https://redis.io/commands/randomkey
 |
 |  rename(self, src: 'KeyT', dst: 'KeyT') -> 'bool | Awaitable[bool]'
 |      Rename key ``src`` to ``dst``
 |
 |      For more information, see https://redis.io/commands/rename
 |
 |  renamenx(self, src: 'KeyT', dst: 'KeyT') -> 'bool | Awaitable[bool]'
 |      Rename key ``src`` to ``dst`` if ``dst`` doesn't already exist
 |
 |      For more information, see https://redis.io/commands/renamenx
 |
 |  restore(self, name: 'KeyT', ttl: 'float', value: 'EncodableT', replace: 'bool' = False, absttl: 'bool' = False, idletime: 'int | None' = None, frequency: 'int | None' = None) -> 'bytes | str | Awaitable[bytes | str]'
 |      Create a key using the provided serialized value, previously obtained
 |      using DUMP.
 |
 |      ``replace`` allows an existing key on ``name`` to be overridden. If
 |      it's not specified an error is raised on collision.
 |
 |      ``absttl`` if True, specified ``ttl`` should represent an absolute Unix
 |      timestamp in milliseconds in which the key will expire. (Redis 5.0 or
 |      greater).
 |
 |      ``idletime`` Used for eviction, this is the number of seconds the
 |      key must be idle, prior to execution.
 |
 |      ``frequency`` Used for eviction, this is the frequency counter of
 |      the object stored at the key, prior to execution.
 |
 |      For more information, see https://redis.io/commands/restore
 |
 |  set(self, name: 'KeyT', value: 'EncodableT', ex: 'ExpiryT | None' = None, px: 'ExpiryT | None' = None, nx: 'bool' = False, xx: 'bool' = False, keepttl: 'bool' = False, get: 'bool' = False, exat: 'AbsExpiryT | None' = None, pxat: 'AbsExpiryT | None' = None, ifeq: 'bytes | str | None' = None, ifne: 'bytes | str | None' = None, ifdeq: 'str | None' = None, ifdne: 'str | None' = None) -> 'bool | str | bytes | None | Awaitable[bool | str | bytes | None]'
 |      Set the value at key ``name`` to ``value``
 |
 |      Warning:
 |      **Experimental** since 7.1.
 |      The usage of the arguments ``ifeq``, ``ifne``, ``ifdeq``, and ``ifdne``
 |      is experimental. The API or returned results when those parameters are used
 |      may change based on feedback.
 |
 |      ``ex`` sets an expire flag on key ``name`` for ``ex`` seconds.
 |
 |      ``px`` sets an expire flag on key ``name`` for ``px`` milliseconds.
 |
 |      ``nx`` if set to True, set the value at key ``name`` to ``value`` only
 |          if it does not exist.
 |
 |      ``xx`` if set to True, set the value at key ``name`` to ``value`` only
 |          if it already exists.
 |
 |      ``keepttl`` if True, retain the time to live associated with the key.
 |          (Available since Redis 6.0)
 |
 |      ``get`` if True, set the value at key ``name`` to ``value`` and return
 |          the old value stored at key, or None if the key did not exist.
 |          (Available since Redis 6.2)
 |
 |      ``exat`` sets an expire flag on key ``name`` for ``ex`` seconds,
 |          specified in unix time.
 |
 |      ``pxat`` sets an expire flag on key ``name`` for ``ex`` milliseconds,
 |          specified in unix time.
 |
 |      ``ifeq`` set the value at key ``name`` to ``value`` only if the current
 |          value exactly matches the argument.
 |          If key doesn’t exist - it won’t be created.
 |          (Requires Redis 8.4 or greater)
 |
 |      ``ifne`` set the value at key ``name`` to ``value`` only if the current
 |          value does not exactly match the argument.
 |          If key doesn’t exist - it will be created.
 |          (Requires Redis 8.4 or greater)
 |
 |      ``ifdeq`` set the value at key ``name`` to ``value`` only if the current
 |          value XXH3 hex digest exactly matches the argument.
 |          If key doesn’t exist - it won’t be created.
 |          (Requires Redis 8.4 or greater)
 |
 |      ``ifdne`` set the value at key ``name`` to ``value`` only if the current
 |          value XXH3 hex digest does not exactly match the argument.
 |          If key doesn’t exist - it will be created.
 |          (Requires Redis 8.4 or greater)
 |
 |      For more information, see https://redis.io/commands/set
 |
 |  setbit(self, name: 'KeyT', offset: 'int', value: 'int') -> 'int | Awaitable[int]'
 |      Flag the ``offset`` in ``name`` as ``value``. Returns an integer
 |      indicating the previous value of ``offset``.
 |
 |      For more information, see https://redis.io/commands/setbit
 |
 |  setex(self, name: 'KeyT', time: 'ExpiryT', value: 'EncodableT') -> 'bool | Awaitable[bool]'
 |      Set the value of key ``name`` to ``value`` that expires in ``time``
 |      seconds. ``time`` can be represented by an integer or a Python
 |      timedelta object.
 |
 |      As per Redis 2.6.12, SETEX is considered deprecated.
 |      Please use SET with EX parameter in new code.
 |
 |      For more information, see https://redis.io/commands/setex
 |
 |  setnx(self, name: 'KeyT', value: 'EncodableT') -> 'bool | Awaitable[bool]'
 |      Set the value of key ``name`` to ``value`` if key doesn't exist
 |
 |      For more information, see https://redis.io/commands/setnx
 |
 |  setrange(self, name: 'KeyT', offset: 'int', value: 'EncodableT') -> 'int | Awaitable[int]'
 |      Overwrite bytes in the value of ``name`` starting at ``offset`` with
 |      ``value``. If ``offset`` plus the length of ``value`` exceeds the
 |      length of the original value, the new value will be larger than before.
 |      If ``offset`` exceeds the length of the original value, null bytes
 |      will be used to pad between the end of the previous value and the start
 |      of what's being injected.
 |
 |      Returns the length of the new string.
 |
 |      For more information, see https://redis.io/commands/setrange
 |
 |  stralgo(self, algo: "Literal['LCS']", value1: 'KeyT', value2: 'KeyT', specific_argument: "Literal['strings'] | Literal['keys']" = 'strings', len: 'bool' = False, idx: 'bool' = False, minmatchlen: 'int | None' = None, withmatchlen: 'bool' = False, **kwargs) -> 'StralgoResponse | Awaitable[StralgoResponse]'
 |      Implements complex algorithms that operate on strings.
 |      Right now the only algorithm implemented is the LCS algorithm
 |      (longest common substring). However new algorithms could be
 |      implemented in the future.
 |
 |      ``algo`` Right now must be LCS
 |      ``value1`` and ``value2`` Can be two strings or two keys
 |      ``specific_argument`` Specifying if the arguments to the algorithm
 |      will be keys or strings. strings is the default.
 |      ``len`` Returns just the len of the match.
 |      ``idx`` Returns the match positions in each string.
 |      ``minmatchlen`` Restrict the list of matches to the ones of a given
 |      minimal length. Can be provided only when ``idx`` set to True.
 |      ``withmatchlen`` Returns the matches with the len of the match.
 |      Can be provided only when ``idx`` set to True.
 |
 |      For more information, see https://redis.io/commands/stralgo
 |
 |  strlen(self, name: 'KeyT') -> 'int | Awaitable[int]'
 |      Return the number of bytes stored in the value of ``name``
 |
 |      For more information, see https://redis.io/commands/strlen
 |
 |  substr(self, name: 'KeyT', start: 'int', end: 'int' = -1) -> 'bytes | str | Awaitable[bytes | str]'
 |      Return a substring of the string at key ``name``. ``start`` and ``end``
 |      are 0-based integers specifying the portion of the string to return.
 |
 |  touch(self, *args: 'KeyT') -> 'int | Awaitable[int]'
 |      Alters the last access time of a key(s) ``*args``. A key is ignored
 |      if it does not exist.
 |
 |      For more information, see https://redis.io/commands/touch
 |
 |  ttl(self, name: 'KeyT') -> 'int | Awaitable[int]'
 |      Returns the number of seconds until the key ``name`` will expire
 |
 |      For more information, see https://redis.io/commands/ttl
 |
 |  type(self, name: 'KeyT') -> 'bytes | str | Awaitable[bytes | str]'
 |      Returns the type of key ``name``
 |
 |      For more information, see https://redis.io/commands/type
 |
 |  unlink(self, *names: 'KeyT') -> 'int | Awaitable[int]'
 |      Unlink one or more keys specified by ``names``
 |
 |      For more information, see https://redis.io/commands/unlink
 |
 |  unwatch(self) -> 'None'
 |      Unwatches all previously watched keys for a transaction
 |
 |      For more information, see https://redis.io/commands/unwatch
 |
 |  watch(self, *names: 'KeyT') -> 'None'
 |      Watches the values at keys ``names``, or None if the key doesn't exist
 |
 |      For more information, see https://redis.io/commands/watch
 |
 |  ----------------------------------------------------------------------
 |  Methods inherited from redis.commands.core.HyperlogCommands:
 |
 |  pfadd(self, name: 'KeyT', *values: 'FieldT') -> 'int | Awaitable[int]'
 |      Adds the specified elements to the specified HyperLogLog.
 |
 |      For more information, see https://redis.io/commands/pfadd
 |
 |  pfcount(self, *sources: 'KeyT') -> 'int | Awaitable[int]'
 |      Return the approximated cardinality of
 |      the set observed by the HyperLogLog at key(s).
 |
 |      For more information, see https://redis.io/commands/pfcount
 |
 |  pfmerge(self, dest: 'KeyT', *sources: 'KeyT') -> 'bool | Awaitable[bool]'
 |      Merge N different HyperLogLogs into a single one.
 |
 |      For more information, see https://redis.io/commands/pfmerge
 |
 |  ----------------------------------------------------------------------
 |  Methods inherited from redis.commands.core.HashCommands:
 |
 |  hdel(self, name: 'KeyT', *keys: 'FieldT') -> 'int | Awaitable[int]'
 |      Delete ``keys`` from hash ``name``
 |
 |      For more information, see https://redis.io/commands/hdel
 |
 |  hexists(self, name: 'KeyT', key: 'FieldT') -> 'bool | Awaitable[bool]'
 |      Returns a boolean indicating if ``key`` exists within hash ``name``
 |
 |      For more information, see https://redis.io/commands/hexists
 |
 |  hexpire(self, name: 'KeyT', seconds: 'ExpiryT', *fields: 'FieldT', nx: 'bool' = False, xx: 'bool' = False, gt: 'bool' = False, lt: 'bool' = False) -> 'list[int] | Awaitable[list[int]]'
 |      Sets or updates the expiration time for fields within a hash key, using relative
 |      time in seconds.
 |
 |      If a field already has an expiration time, the behavior of the update can be
 |      controlled using the `nx`, `xx`, `gt`, and `lt` parameters.
 |
 |      The return value provides detailed information about the outcome for each field.
 |
 |      For more information, see https://redis.io/commands/hexpire
 |
 |      Args:
 |          name: The name of the hash key.
 |          seconds: Expiration time in seconds, relative. Can be an integer, or a
 |                   Python `timedelta` object.
 |          fields: List of fields within the hash to apply the expiration time to.
 |          nx: Set expiry only when the field has no expiry.
 |          xx: Set expiry only when the field has an existing expiry.
 |          gt: Set expiry only when the new expiry is greater than the current one.
 |          lt: Set expiry only when the new expiry is less than the current one.
 |
 |      Returns:
 |          Returns a list which contains for each field in the request:
 |              - `-2` if the field does not exist, or if the key does not exist.
 |              - `0` if the specified NX | XX | GT | LT condition was not met.
 |              - `1` if the expiration time was set or updated.
 |              - `2` if the field was deleted because the specified expiration time is
 |                in the past.
 |
 |  hexpireat(self, name: 'KeyT', unix_time_seconds: 'AbsExpiryT', *fields: 'FieldT', nx: 'bool' = False, xx: 'bool' = False, gt: 'bool' = False, lt: 'bool' = False) -> 'list[int] | Awaitable[list[int]]'
 |      Sets or updates the expiration time for fields within a hash key, using an
 |      absolute Unix timestamp in seconds.
 |
 |      If a field already has an expiration time, the behavior of the update can be
 |      controlled using the `nx`, `xx`, `gt`, and `lt` parameters.
 |
 |      The return value provides detailed information about the outcome for each field.
 |
 |      For more information, see https://redis.io/commands/hexpireat
 |
 |      Args:
 |          name: The name of the hash key.
 |          unix_time_seconds: Expiration time as Unix timestamp in seconds. Can be an
 |                             integer or a Python `datetime` object.
 |          fields: List of fields within the hash to apply the expiration time to.
 |          nx: Set expiry only when the field has no expiry.
 |          xx: Set expiry only when the field has an existing expiration time.
 |          gt: Set expiry only when the new expiry is greater than the current one.
 |          lt: Set expiry only when the new expiry is less than the current one.
 |
 |      Returns:
 |          Returns a list which contains for each field in the request:
 |              - `-2` if the field does not exist, or if the key does not exist.
 |              - `0` if the specified NX | XX | GT | LT condition was not met.
 |              - `1` if the expiration time was set or updated.
 |              - `2` if the field was deleted because the specified expiration time is
 |                in the past.
 |
 |  hexpiretime(self, key: 'KeyT', *fields: 'FieldT') -> 'list[int] | Awaitable[list[int]]'
 |      Returns the expiration times of hash fields as Unix timestamps in seconds.
 |
 |      For more information, see https://redis.io/commands/hexpiretime
 |
 |      Args:
 |          key: The hash key.
 |          fields: A list of fields within the hash for which to get the expiration
 |                  time.
 |
 |      Returns:
 |          Returns a list which contains for each field in the request:
 |              - `-2` if the field does not exist, or if the key does not exist.
 |              - `-1` if the field exists but has no associated expire time.
 |              - A positive integer representing the expiration Unix timestamp in
 |                seconds, if the field has an associated expiration time.
 |
 |  hget(self, name: 'KeyT', key: 'FieldT') -> 'bytes | str | None | Awaitable[bytes | str | None]'
 |      Return the value of ``key`` within the hash ``name``
 |
 |      For more information, see https://redis.io/commands/hget
 |
 |  hgetall(self, name: 'KeyT') -> 'dict[bytes | str, bytes | str] | Awaitable[dict[bytes | str, bytes | str]]'
 |      Return a Python dict of the hash's name/value pairs
 |
 |      For more information, see https://redis.io/commands/hgetall
 |
 |  hgetdel(self, name: 'KeyT', *keys: 'FieldT') -> 'list[bytes | str | None] | Awaitable[list[bytes | str | None]]'
 |      Return the value of ``key`` within the hash ``name`` and
 |      delete the field in the hash.
 |      This command is similar to HGET, except for the fact that it also deletes
 |      the key on success from the hash with the provided ```name```.
 |
 |      Available since Redis 8.0
 |      For more information, see https://redis.io/commands/hgetdel
 |
 |  hgetex(self, name: 'KeyT', *keys: 'FieldT', ex: 'ExpiryT | None' = None, px: 'ExpiryT | None' = None, exat: 'AbsExpiryT | None' = None, pxat: 'AbsExpiryT | None' = None, persist: 'bool' = False) -> 'list[bytes | str | None] | Awaitable[list[bytes | str | None]]'
 |      Return the values of ``key`` and ``keys`` within the hash ``name``
 |      and optionally set their expiration.
 |
 |      ``ex`` sets an expire flag on ``kyes`` for ``ex`` seconds.
 |
 |      ``px`` sets an expire flag on ``keys`` for ``px`` milliseconds.
 |
 |      ``exat`` sets an expire flag on ``keys`` for ``ex`` seconds,
 |      specified in unix time.
 |
 |      ``pxat`` sets an expire flag on ``keys`` for ``ex`` milliseconds,
 |      specified in unix time.
 |
 |      ``persist`` remove the time to live associated with the ``keys``.
 |
 |      Available since Redis 8.0
 |      For more information, see https://redis.io/commands/hgetex
 |
 |  himport_discard_all_internal(self) -> 'int | Awaitable[int]'
 |      Send ``HIMPORT DISCARDALL`` (returns the number of fieldsets removed).
 |
 |      .. warning::
 |          Internal wire mapping — not for direct use on a pooled client. It
 |          DISCARDs on a single arbitrary borrowed connection and bypasses the
 |          client's shared fieldset registry, leaving other connections and the
 |          registry out of sync. Use the client's ``himport_discard_all`` instead;
 |          call this only on a pinned single-connection client where you manage
 |          session state yourself.
 |
 |  himport_discard_internal(self, fieldset_name: 'str') -> 'int | Awaitable[int]'
 |      Send ``HIMPORT DISCARD fieldset_name`` (``1`` removed, ``0`` not found).
 |
 |      .. warning::
 |          Internal wire mapping — not for direct use on a pooled client. It
 |          DISCARDs on a single arbitrary borrowed connection and bypasses the
 |          client's shared fieldset registry, leaving other connections and the
 |          registry out of sync. Use the client's ``himport_discard`` instead; call
 |          this only on a pinned single-connection client where you manage session
 |          state yourself.
 |
 |  himport_prepare_internal(self, fieldset_name: 'str', fields: 'Iterable[FieldT]') -> 'bool | Awaitable[bool]'
 |      Send ``HIMPORT PREPARE fieldset_name field [field ...]``.
 |
 |      Registers the ordered field list under ``fieldset_name`` in the executing
 |      connection's session. Fields are sent in the caller's order, unmodified.
 |
 |      .. warning::
 |          Internal wire mapping — not for direct use on a pooled client. It
 |          PREPAREs on a single arbitrary borrowed connection and bypasses the
 |          client's shared fieldset registry, so other connections stay unaware and
 |          reintroduce the nondeterministic "no such fieldset" the HIMPORT design
 |          prevents. Use the client's ``himport_prepare`` instead; call this only
 |          on a pinned single-connection client where you manage session state
 |          yourself.
 |
 |  himport_set(self, key: 'KeyT', fieldset_name: 'str', values: 'Iterable[EncodableT]') -> 'bool | Awaitable[bool]'
 |      Create/replace ``key`` as a hash using ``fieldset_name``'s field list.
 |
 |      Values are sent in the caller's order and map positionally to the prepared
 |      fields. The fieldset is prepared on the serving connection on first use
 |      (PREPARE bundled with SET in one write) and reused on subsequent calls;
 |      runtime discards are reconciled on the next use of the connection. All of
 |      this happens inside the normal command path, so retry, disconnect-on-error
 |      and (for the cluster) routing / MOVED-ASK apply exactly as for any command.
 |
 |      .. note::
 |          Recovery from a mid-connection fieldset loss (the server dropping the
 |          prepared fieldset without dropping the socket, e.g. ``RESET`` or
 |          ``maxmemory-clients`` eviction) applies only to a standalone
 |          ``himport_set`` call: it catches the resulting ``no such fieldset`` and
 |          re-prepares on the same socket, retrying the SET once. A ``himport_set``
 |          buffered in a **pipeline or transaction** has no such per-command
 |          recovery — its fieldset is PREPAREd once as a pre-flight before the
 |          batch, and if the server loses it between that pre-flight and the batch
 |          the SET fails and surfaces as an error in the batch results. Callers who
 |          need the automatic recovery should issue those sets outside a pipeline.
 |
 |  hincrby(self, name: 'KeyT', key: 'FieldT', amount: 'int' = 1) -> 'int | Awaitable[int]'
 |      Increment the value of ``key`` in hash ``name`` by ``amount``
 |
 |      For more information, see https://redis.io/commands/hincrby
 |
 |  hincrbyfloat(self, name: 'KeyT', key: 'FieldT', amount: 'float' = 1.0) -> 'float | Awaitable[float]'
 |      Increment the value of ``key`` in hash ``name`` by floating ``amount``
 |
 |      For more information, see https://redis.io/commands/hincrbyfloat
 |
 |  hkeys(self, name: 'KeyT') -> 'list[bytes | str] | Awaitable[list[bytes | str]]'
 |      Return the list of keys within hash ``name``
 |
 |      For more information, see https://redis.io/commands/hkeys
 |
 |  hlen(self, name: 'KeyT') -> 'int | Awaitable[int]'
 |      Return the number of elements in hash ``name``
 |
 |      For more information, see https://redis.io/commands/hlen
 |
 |  hmget(self, name: 'KeyT', keys: 'FieldT | Iterable[FieldT]', *args: 'FieldT') -> 'list[bytes | str | None] | Awaitable[list[bytes | str | None]]'
 |      Returns a list of values ordered identically to ``keys``
 |
 |      For more information, see https://redis.io/commands/hmget
 |
 |  hmset(self, name: 'KeyT', mapping: 'Mapping[FieldT, EncodableT]') -> 'bool | Awaitable[bool]'
 |      Set key to value within hash ``name`` for each corresponding
 |      key and value from the ``mapping`` dict.
 |
 |      For more information, see https://redis.io/commands/hmset
 |
 |  hpersist(self, name: 'KeyT', *fields: 'FieldT') -> 'list[int] | Awaitable[list[int]]'
 |      Removes the expiration time for each specified field in a hash.
 |
 |      For more information, see https://redis.io/commands/hpersist
 |
 |      Args:
 |          name: The name of the hash key.
 |          fields: A list of fields within the hash from which to remove the
 |                  expiration time.
 |
 |      Returns:
 |          Returns a list which contains for each field in the request:
 |              - `-2` if the field does not exist, or if the key does not exist.
 |              - `-1` if the field exists but has no associated expiration time.
 |              - `1` if the expiration time was successfully removed from the field.
 |
 |  hpexpire(self, name: 'KeyT', milliseconds: 'ExpiryT', *fields: 'FieldT', nx: 'bool' = False, xx: 'bool' = False, gt: 'bool' = False, lt: 'bool' = False) -> 'list[int] | Awaitable[list[int]]'
 |      Sets or updates the expiration time for fields within a hash key, using relative
 |      time in milliseconds.
 |
 |      If a field already has an expiration time, the behavior of the update can be
 |      controlled using the `nx`, `xx`, `gt`, and `lt` parameters.
 |
 |      The return value provides detailed information about the outcome for each field.
 |
 |      For more information, see https://redis.io/commands/hpexpire
 |
 |      Args:
 |          name: The name of the hash key.
 |          milliseconds: Expiration time in milliseconds, relative. Can be an integer,
 |                        or a Python `timedelta` object.
 |          fields: List of fields within the hash to apply the expiration time to.
 |          nx: Set expiry only when the field has no expiry.
 |          xx: Set expiry only when the field has an existing expiry.
 |          gt: Set expiry only when the new expiry is greater than the current one.
 |          lt: Set expiry only when the new expiry is less than the current one.
 |
 |      Returns:
 |          Returns a list which contains for each field in the request:
 |              - `-2` if the field does not exist, or if the key does not exist.
 |              - `0` if the specified NX | XX | GT | LT condition was not met.
 |              - `1` if the expiration time was set or updated.
 |              - `2` if the field was deleted because the specified expiration time is
 |                in the past.
 |
 |  hpexpireat(self, name: 'KeyT', unix_time_milliseconds: 'AbsExpiryT', *fields: 'FieldT', nx: 'bool' = False, xx: 'bool' = False, gt: 'bool' = False, lt: 'bool' = False) -> 'list[int] | Awaitable[list[int]]'
 |      Sets or updates the expiration time for fields within a hash key, using an
 |      absolute Unix timestamp in milliseconds.
 |
 |      If a field already has an expiration time, the behavior of the update can be
 |      controlled using the `nx`, `xx`, `gt`, and `lt` parameters.
 |
 |      The return value provides detailed information about the outcome for each field.
 |
 |      For more information, see https://redis.io/commands/hpexpireat
 |
 |      Args:
 |          name: The name of the hash key.
 |          unix_time_milliseconds: Expiration time as Unix timestamp in milliseconds.
 |                                  Can be an integer or a Python `datetime` object.
 |          fields: List of fields within the hash to apply the expiry.
 |          nx: Set expiry only when the field has no expiry.
 |          xx: Set expiry only when the field has an existing expiry.
 |          gt: Set expiry only when the new expiry is greater than the current one.
 |          lt: Set expiry only when the new expiry is less than the current one.
 |
 |      Returns:
 |          Returns a list which contains for each field in the request:
 |              - `-2` if the field does not exist, or if the key does not exist.
 |              - `0` if the specified NX | XX | GT | LT condition was not met.
 |              - `1` if the expiration time was set or updated.
 |              - `2` if the field was deleted because the specified expiration time is
 |                in the past.
 |
 |  hpexpiretime(self, key: 'KeyT', *fields: 'FieldT') -> 'list[int] | Awaitable[list[int]]'
 |      Returns the expiration times of hash fields as Unix timestamps in milliseconds.
 |
 |      For more information, see https://redis.io/commands/hpexpiretime
 |
 |      Args:
 |          key: The hash key.
 |          fields: A list of fields within the hash for which to get the expiration
 |                  time.
 |
 |      Returns:
 |          Returns a list which contains for each field in the request:
 |              - `-2` if the field does not exist, or if the key does not exist.
 |              - `-1` if the field exists but has no associated expire time.
 |              - A positive integer representing the expiration Unix timestamp in
 |                milliseconds, if the field has an associated expiration time.
 |
 |  hpttl(self, key: 'KeyT', *fields: 'FieldT') -> 'list[int] | Awaitable[list[int]]'
 |      Returns the TTL (Time To Live) in milliseconds for each specified field within a
 |      hash key.
 |
 |      For more information, see https://redis.io/commands/hpttl
 |
 |      Args:
 |          key: The hash key.
 |          fields: A list of fields within the hash for which to get the TTL.
 |
 |      Returns:
 |          Returns a list which contains for each field in the request:
 |              - `-2` if the field does not exist, or if the key does not exist.
 |              - `-1` if the field exists but has no associated expire time.
 |              - A positive integer representing the TTL in milliseconds if the field
 |                has an associated expiration time.
 |
 |  hset(self, name: 'KeyT', key: 'FieldT | None' = None, value: 'EncodableT | None' = None, mapping: 'Mapping[FieldT, EncodableT] | None' = None, items: 'Sequence[EncodableT] | None' = None) -> 'int | Awaitable[int]'
 |      Set ``key`` to ``value`` within hash ``name``,
 |      ``mapping`` accepts a dict of key/value pairs that will be
 |      added to hash ``name``.
 |      ``items`` accepts a list of key/value pairs that will be
 |      added to hash ``name``.
 |      Returns the number of fields that were added.
 |
 |      For more information, see https://redis.io/commands/hset
 |
 |  hsetex(self, name: 'KeyT', key: 'FieldT | None' = None, value: 'EncodableT | None' = None, mapping: 'Mapping[FieldT, EncodableT] | None' = None, items: 'Sequence[EncodableT] | None' = None, ex: 'ExpiryT | None' = None, px: 'ExpiryT | None' = None, exat: 'AbsExpiryT | None' = None, pxat: 'AbsExpiryT | None' = None, data_persist_option: 'HashDataPersistOptions | None' = None, keepttl: 'bool' = False) -> 'int | Awaitable[int]'
 |      Set ``key`` to ``value`` within hash ``name``
 |
 |      ``mapping`` accepts a dict of key/value pairs that will be
 |      added to hash ``name``.
 |
 |      ``items`` accepts a list of key/value pairs that will be
 |      added to hash ``name``.
 |
 |      ``ex`` sets an expire flag on ``keys`` for ``ex`` seconds.
 |
 |      ``px`` sets an expire flag on ``keys`` for ``px`` milliseconds.
 |
 |      ``exat`` sets an expire flag on ``keys`` for ``ex`` seconds,
 |          specified in unix time.
 |
 |      ``pxat`` sets an expire flag on ``keys`` for ``ex`` milliseconds,
 |          specified in unix time.
 |
 |      ``data_persist_option`` can be set to ``FNX`` or ``FXX`` to control the
 |          behavior of the command.
 |          ``FNX`` will set the value for each provided key to each
 |              provided value only if all do not already exist.
 |          ``FXX`` will set the value for each provided key to each
 |              provided value only if all already exist.
 |
 |      ``keepttl`` if True, retain the time to live associated with the keys.
 |
 |      Returns the number of fields that were added.
 |
 |      Available since Redis 8.0
 |      For more information, see https://redis.io/commands/hsetex
 |
 |  hsetnx(self, name: 'KeyT', key: 'FieldT', value: 'EncodableT') -> 'int | Awaitable[int]'
 |      Set ``key`` to ``value`` within hash ``name`` if ``key`` does not
 |      exist.  Returns 1 if HSETNX created a field, otherwise 0.
 |
 |      For more information, see https://redis.io/commands/hsetnx
 |
 |  hstrlen(self, name: 'KeyT', key: 'FieldT') -> 'int | Awaitable[int]'
 |      Return the number of bytes stored in the value of ``key``
 |      within hash ``name``
 |
 |      For more information, see https://redis.io/commands/hstrlen
 |
 |  httl(self, key: 'KeyT', *fields: 'FieldT') -> 'list[int] | Awaitable[list[int]]'
 |      Returns the TTL (Time To Live) in seconds for each specified field within a hash
 |      key.
 |
 |      For more information, see https://redis.io/commands/httl
 |
 |      Args:
 |          key: The hash key.
 |          fields: A list of fields within the hash for which to get the TTL.
 |
 |      Returns:
 |          Returns a list which contains for each field in the request:
 |              - `-2` if the field does not exist, or if the key does not exist.
 |              - `-1` if the field exists but has no associated expire time.
 |              - A positive integer representing the TTL in seconds if the field has
 |                an associated expiration time.
 |
 |  hvals(self, name: 'KeyT') -> 'list[bytes | str] | Awaitable[list[bytes | str]]'
 |      Return the list of values within hash ``name``
 |
 |      For more information, see https://redis.io/commands/hvals
 |
 |  ----------------------------------------------------------------------
 |  Methods inherited from redis.commands.core.GeoCommands:
 |
 |  geoadd(self, name: 'KeyT', values: 'Sequence[EncodableT]', nx: 'bool' = False, xx: 'bool' = False, ch: 'bool' = False) -> 'int | Awaitable[int]'
 |      Add the specified geospatial items to the specified key identified
 |      by the ``name`` argument. The Geospatial items are given as ordered
 |      members of the ``values`` argument, each item or place is formed by
 |      the triad longitude, latitude and name.
 |
 |      Note: You can use ZREM to remove elements.
 |
 |      ``nx`` forces ZADD to only create new elements and not to update
 |      scores for elements that already exist.
 |
 |      ``xx`` forces ZADD to only update scores of elements that already
 |      exist. New elements will not be added.
 |
 |      ``ch`` modifies the return value to be the numbers of elements changed.
 |      Changed elements include new elements that were added and elements
 |      whose scores changed.
 |
 |      For more information, see https://redis.io/commands/geoadd
 |
 |  geodist(self, name: 'KeyT', place1: 'FieldT', place2: 'FieldT', unit: 'str | None' = None) -> 'float | None | Awaitable[float | None]'
 |      Return the distance between ``place1`` and ``place2`` members of the
 |      ``name`` key.
 |      The units must be one of the following : m, km mi, ft. By default
 |      meters are used.
 |
 |      For more information, see https://redis.io/commands/geodist
 |
 |  geohash(self, name: 'KeyT', *values: 'FieldT') -> 'list[bytes | str | None] | Awaitable[list[bytes | str | None]]'
 |      Return the geo hash string for each item of ``values`` members of
 |      the specified key identified by the ``name`` argument.
 |
 |      For more information, see https://redis.io/commands/geohash
 |
 |  geopos(self, name: 'KeyT', *values: 'FieldT') -> 'list[GeoCoordinate | None] | Awaitable[list[GeoCoordinate | None]]'
 |      Return the positions of each item of ``values`` as members of
 |      the specified key identified by the ``name`` argument. Each position
 |      is represented by the pairs lon and lat.
 |
 |      For more information, see https://redis.io/commands/geopos
 |
 |  georadius(self, name: 'KeyT', longitude: 'float', latitude: 'float', radius: 'float', unit: 'str | None' = None, withdist: 'bool' = False, withcoord: 'bool' = False, withhash: 'bool' = False, count: 'int | None' = None, sort: 'str | None' = None, store: 'KeyT | None' = None, store_dist: 'KeyT | None' = None, any: 'bool' = False) -> 'GeoRadiusResponse | Awaitable[GeoRadiusResponse]'
 |      Return the members of the specified key identified by the
 |      ``name`` argument which are within the borders of the area specified
 |      with the ``latitude`` and ``longitude`` location and the maximum
 |      distance from the center specified by the ``radius`` value.
 |
 |      The units must be one of the following : m, km mi, ft. By default
 |
 |      ``withdist`` indicates to return the distances of each place.
 |
 |      ``withcoord`` indicates to return the latitude and longitude of
 |      each place.
 |
 |      ``withhash`` indicates to return the geohash string of each place.
 |
 |      ``count`` indicates to return the number of elements up to N.
 |
 |      ``sort`` indicates to return the places in a sorted way, ASC for
 |      nearest to fairest and DESC for fairest to nearest.
 |
 |      ``store`` indicates to save the places names in a sorted set named
 |      with a specific key, each element of the destination sorted set is
 |      populated with the score got from the original geo sorted set.
 |
 |      ``store_dist`` indicates to save the places names in a sorted set
 |      named with a specific key, instead of ``store`` the sorted set
 |      destination score is set with the distance.
 |
 |      For more information, see https://redis.io/commands/georadius
 |
 |  georadiusbymember(self, name: 'KeyT', member: 'FieldT', radius: 'float', unit: 'str | None' = None, withdist: 'bool' = False, withcoord: 'bool' = False, withhash: 'bool' = False, count: 'int | None' = None, sort: 'str | None' = None, store: 'Union[KeyT, None]' = None, store_dist: 'Union[KeyT, None]' = None, any: 'bool' = False) -> 'GeoRadiusResponse | Awaitable[GeoRadiusResponse]'
 |      This command is exactly like ``georadius`` with the sole difference
 |      that instead of taking, as the center of the area to query, a longitude
 |      and latitude value, it takes the name of a member already existing
 |      inside the geospatial index represented by the sorted set.
 |
 |      For more information, see https://redis.io/commands/georadiusbymember
 |
 |  geosearch(self, name: 'KeyT', member: 'FieldT | None' = None, longitude: 'float | None' = None, latitude: 'float | None' = None, unit: 'str' = 'm', radius: 'float | None' = None, width: 'float | None' = None, height: 'float | None' = None, sort: 'str | None' = None, count: 'int | None' = None, any: 'bool' = False, withcoord: 'bool' = False, withdist: 'bool' = False, withhash: 'bool' = False) -> 'GeoSearchResponse | Awaitable[GeoSearchResponse]'
 |      Return the members of specified key identified by the
 |      ``name`` argument, which are within the borders of the
 |      area specified by a given shape. This command extends the
 |      GEORADIUS command, so in addition to searching within circular
 |      areas, it supports searching within rectangular areas.
 |
 |      This command should be used in place of the deprecated
 |      GEORADIUS and GEORADIUSBYMEMBER commands.
 |
 |      ``member`` Use the position of the given existing
 |       member in the sorted set. Can't be given with ``longitude``
 |       and ``latitude``.
 |
 |      ``longitude`` and ``latitude`` Use the position given by
 |      this coordinates. Can't be given with ``member``
 |      ``radius`` Similar to GEORADIUS, search inside circular
 |      area according the given radius. Can't be given with
 |      ``height`` and ``width``.
 |      ``height`` and ``width`` Search inside an axis-aligned
 |      rectangle, determined by the given height and width.
 |      Can't be given with ``radius``
 |
 |      ``unit`` must be one of the following : m, km, mi, ft.
 |      `m` for meters (the default value), `km` for kilometers,
 |      `mi` for miles and `ft` for feet.
 |
 |      ``sort`` indicates to return the places in a sorted way,
 |      ASC for nearest to furthest and DESC for furthest to nearest.
 |
 |      ``count`` limit the results to the first count matching items.
 |
 |      ``any`` is set to True, the command will return as soon as
 |      enough matches are found. Can't be provided without ``count``
 |
 |      ``withdist`` indicates to return the distances of each place.
 |      ``withcoord`` indicates to return the latitude and longitude of
 |      each place.
 |
 |      ``withhash`` indicates to return the geohash string of each place.
 |
 |      For more information, see https://redis.io/commands/geosearch
 |
 |  geosearchstore(self, dest: 'KeyT', name: 'KeyT', member: 'FieldT | None' = None, longitude: 'float | None' = None, latitude: 'float | None' = None, unit: 'str' = 'm', radius: 'float | None' = None, width: 'float | None' = None, height: 'float | None' = None, sort: 'str | None' = None, count: 'int | None' = None, any: 'bool' = False, storedist: 'bool' = False) -> 'int | Awaitable[int]'
 |      This command is like GEOSEARCH, but stores the result in
 |      ``dest``. By default, it stores the results in the destination
 |      sorted set with their geospatial information.
 |      if ``store_dist`` set to True, the command will stores the
 |      items in a sorted set populated with their distance from the
 |      center of the circle or box, as a floating-point number.
 |
 |      For more information, see https://redis.io/commands/geosearchstore
 |
 |  ----------------------------------------------------------------------
 |  Methods inherited from redis.commands.core.ListCommands:
 |
 |  blmpop(self, timeout: 'float', numkeys: 'int', *args: 'str', direction: 'str', count: 'int | None' = 1) -> 'ListMultiPopResponse | Awaitable[ListMultiPopResponse]'
 |      Pop ``count`` values (default 1) from first non-empty in the list
 |      of provided key names.
 |
 |      When all lists are empty this command blocks the connection until another
 |      client pushes to it or until the timeout, timeout of 0 blocks indefinitely
 |
 |      For more information, see https://redis.io/commands/blmpop
 |
 |  blpop(self, keys: 'KeysT', timeout: 'Number | None' = 0) -> 'BlockingListPopResponse | Awaitable[BlockingListPopResponse]'
 |      LPOP a value off of the first non-empty list
 |      named in ``keys``.
 |
 |      If none of the lists in ``keys`` has a value to LPOP, then block
 |      for ``timeout`` seconds, or until a value gets pushed on to one
 |      of the lists.
 |
 |      If timeout is 0, then block indefinitely.
 |
 |      For more information, see https://redis.io/commands/blpop
 |
 |  brpop(self, keys: 'KeysT', timeout: 'Number | None' = 0) -> 'BlockingListPopResponse | Awaitable[BlockingListPopResponse]'
 |      RPOP a value off of the first non-empty list
 |      named in ``keys``.
 |
 |      If none of the lists in ``keys`` has a value to RPOP, then block
 |      for ``timeout`` seconds, or until a value gets pushed on to one
 |      of the lists.
 |
 |      If timeout is 0, then block indefinitely.
 |
 |      For more information, see https://redis.io/commands/brpop
 |
 |  brpoplpush(self, src: 'KeyT', dst: 'KeyT', timeout: 'Number | None' = 0) -> 'bytes | str | None | Awaitable[bytes | str | None]'
 |      Pop a value off the tail of ``src``, push it on the head of ``dst``
 |      and then return it.
 |
 |      This command blocks until a value is in ``src`` or until ``timeout``
 |      seconds elapse, whichever is first. A ``timeout`` value of 0 blocks
 |      forever.
 |
 |      For more information, see https://redis.io/commands/brpoplpush
 |
 |  lindex(self, name: 'KeyT', index: 'int') -> 'bytes | str | None | Awaitable[bytes | str | None]'
 |      Return the item from list ``name`` at position ``index``
 |
 |      Negative indexes are supported and will return an item at the
 |      end of the list
 |
 |      For more information, see https://redis.io/commands/lindex
 |
 |  linsert(self, name: 'KeyT', where: 'str', refvalue: 'str', value: 'str') -> 'int | Awaitable[int]'
 |      Insert ``value`` in list ``name`` either immediately before or after
 |      [``where``] ``refvalue``
 |
 |      Returns the new length of the list on success or -1 if ``refvalue``
 |      is not in the list.
 |
 |      For more information, see https://redis.io/commands/linsert
 |
 |  llen(self, name: 'KeyT') -> 'int | Awaitable[int]'
 |      Return the length of the list ``name``
 |
 |      For more information, see https://redis.io/commands/llen
 |
 |  lmpop(self, num_keys: 'int', *args: 'str', direction: 'str', count: 'int | None' = 1) -> 'ListMultiPopResponse | Awaitable[ListMultiPopResponse]'
 |      Pop ``count`` values (default 1) first non-empty list key from the list
 |      of args provided key names.
 |
 |      For more information, see https://redis.io/commands/lmpop
 |
 |  lpop(self, name: 'KeyT', count: 'int | None' = None) -> 'bytes | str | list[bytes | str] | None | Awaitable[bytes | str | list[bytes | str] | None]'
 |      Removes and returns the first elements of the list ``name``.
 |
 |      By default, the command pops a single element from the beginning of
 |      the list. When provided with the optional ``count`` argument, the reply
 |      will consist of up to count elements, depending on the list's length.
 |
 |      For more information, see https://redis.io/commands/lpop
 |
 |  lpos(self, name: 'KeyT', value: 'str', rank: 'int | None' = None, count: 'int | None' = None, maxlen: 'int | None' = None) -> 'int | list[int] | None | Awaitable[int | list[int] | None]'
 |      Get position of ``value`` within the list ``name``
 |
 |       If specified, ``rank`` indicates the "rank" of the first element to
 |       return in case there are multiple copies of ``value`` in the list.
 |       By default, LPOS returns the position of the first occurrence of
 |       ``value`` in the list. When ``rank`` 2, LPOS returns the position of
 |       the second ``value`` in the list. If ``rank`` is negative, LPOS
 |       searches the list in reverse. For example, -1 would return the
 |       position of the last occurrence of ``value`` and -2 would return the
 |       position of the next to last occurrence of ``value``.
 |
 |       If specified, ``count`` indicates that LPOS should return a list of
 |       up to ``count`` positions. A ``count`` of 2 would return a list of
 |       up to 2 positions. A ``count`` of 0 returns a list of all positions
 |       matching ``value``. When ``count`` is specified and but ``value``
 |       does not exist in the list, an empty list is returned.
 |
 |       If specified, ``maxlen`` indicates the maximum number of list
 |       elements to scan. A ``maxlen`` of 1000 will only return the
 |       position(s) of items within the first 1000 entries in the list.
 |       A ``maxlen`` of 0 (the default) will scan the entire list.
 |
 |       For more information, see https://redis.io/commands/lpos
 |
 |  lpush(self, name: 'KeyT', *values: 'FieldT') -> 'int | Awaitable[int]'
 |      Push ``values`` onto the head of the list ``name``
 |
 |      For more information, see https://redis.io/commands/lpush
 |
 |  lpushx(self, name: 'KeyT', *values: 'FieldT') -> 'int | Awaitable[int]'
 |      Push ``value`` onto the head of the list ``name`` if ``name`` exists
 |
 |      For more information, see https://redis.io/commands/lpushx
 |
 |  lrange(self, name: 'KeyT', start: 'int', end: 'int') -> 'list[bytes | str] | Awaitable[list[bytes | str]]'
 |      Return a slice of the list ``name`` between
 |      position ``start`` and ``end``
 |
 |      ``start`` and ``end`` can be negative numbers just like
 |      Python slicing notation
 |
 |      For more information, see https://redis.io/commands/lrange
 |
 |  lrem(self, name: 'KeyT', count: 'int', value: 'str') -> 'int | Awaitable[int]'
 |      Remove the first ``count`` occurrences of elements equal to ``value``
 |      from the list stored at ``name``.
 |
 |      The count argument influences the operation in the following ways:
 |          count > 0: Remove elements equal to value moving from head to tail.
 |          count < 0: Remove elements equal to value moving from tail to head.
 |          count = 0: Remove all elements equal to value.
 |
 |          For more information, see https://redis.io/commands/lrem
 |
 |  lset(self, name: 'KeyT', index: 'int', value: 'str') -> 'bool | Awaitable[bool]'
 |      Set element at ``index`` of list ``name`` to ``value``
 |
 |      For more information, see https://redis.io/commands/lset
 |
 |  ltrim(self, name: 'KeyT', start: 'int', end: 'int') -> 'bool | Awaitable[bool]'
 |      Trim the list ``name``, removing all values not within the slice
 |      between ``start`` and ``end``
 |
 |      ``start`` and ``end`` can be negative numbers just like
 |      Python slicing notation
 |
 |      For more information, see https://redis.io/commands/ltrim
 |
 |  rpop(self, name: 'KeyT', count: 'int | None' = None) -> 'bytes | str | list[bytes | str] | None | Awaitable[bytes | str | list[bytes | str] | None]'
 |      Removes and returns the last elements of the list ``name``.
 |
 |      By default, the command pops a single element from the end of the list.
 |      When provided with the optional ``count`` argument, the reply will
 |      consist of up to count elements, depending on the list's length.
 |
 |      For more information, see https://redis.io/commands/rpop
 |
 |  rpoplpush(self, src: 'KeyT', dst: 'KeyT') -> 'bytes | str | None | Awaitable[bytes | str | None]'
 |      RPOP a value off of the ``src`` list and atomically LPUSH it
 |      on to the ``dst`` list.  Returns the value.
 |
 |      For more information, see https://redis.io/commands/rpoplpush
 |
 |  rpush(self, name: 'KeyT', *values: 'FieldT') -> 'int | Awaitable[int]'
 |      Push ``values`` onto the tail of the list ``name``
 |
 |      For more information, see https://redis.io/commands/rpush
 |
 |  rpushx(self, name: 'KeyT', *values: 'str') -> 'int | Awaitable[int]'
 |      Push ``value`` onto the tail of the list ``name`` if ``name`` exists
 |
 |      For more information, see https://redis.io/commands/rpushx
 |
 |  sort(self, name: 'KeyT', start: 'int | None' = None, num: 'int | None' = None, by: 'str | None' = None, get: 'list[str] | None' = None, desc: 'bool' = False, alpha: 'bool' = False, store: 'str | None' = None, groups: 'bool | None' = False) -> 'SortResponse | Awaitable[SortResponse]'
 |      Sort and return the list, set or sorted set at ``name``.
 |
 |      ``start`` and ``num`` allow for paging through the sorted data
 |
 |      ``by`` allows using an external key to weight and sort the items.
 |          Use an "*" to indicate where in the key the item value is located
 |
 |      ``get`` allows for returning items from external keys rather than the
 |          sorted data itself.  Use an "*" to indicate where in the key
 |          the item value is located
 |
 |      ``desc`` allows for reversing the sort
 |
 |      ``alpha`` allows for sorting lexicographically rather than numerically
 |
 |      ``store`` allows for storing the result of the sort into
 |          the key ``store``
 |
 |      ``groups`` if set to True and if ``get`` contains at least two
 |          elements, sort will return a list of tuples, each containing the
 |          values fetched from the arguments to ``get``.
 |
 |      For more information, see https://redis.io/commands/sort
 |
 |  sort_ro(self, key: 'str', start: 'int | None' = None, num: 'int | None' = None, by: 'str | None' = None, get: 'list[str] | None' = None, desc: 'bool' = False, alpha: 'bool' = False) -> 'list[bytes | str] | Awaitable[list[bytes | str]]'
 |      Returns the elements contained in the list, set or sorted set at key.
 |      (read-only variant of the SORT command)
 |
 |      ``start`` and ``num`` allow for paging through the sorted data
 |
 |      ``by`` allows using an external key to weight and sort the items.
 |          Use an "*" to indicate where in the key the item value is located
 |
 |      ``get`` allows for returning items from external keys rather than the
 |          sorted data itself.  Use an "*" to indicate where in the key
 |          the item value is located
 |
 |      ``desc`` allows for reversing the sort
 |
 |      ``alpha`` allows for sorting lexicographically rather than numerically
 |
 |      For more information, see https://redis.io/commands/sort_ro
 |
 |  ----------------------------------------------------------------------
 |  Methods inherited from redis.commands.core.ArrayCommands:
 |
 |  arcount(self, name: 'KeyT') -> 'int | Awaitable[int]'
 |      Return the number of non-empty elements in the array stored at
 |      ``name``. Returns 0 if ``name`` does not exist.
 |
 |      For more information, see https://redis.io/commands/arcount
 |
 |  ardel(self, name: 'KeyT', *indices: 'int') -> 'int | Awaitable[int]'
 |      Delete elements at the specified ``indices`` in the array stored at
 |      ``name``. Deleting an index that does not exist counts as zero
 |      elements deleted and does not modify the array.
 |
 |      Returns the number of elements deleted.
 |
 |      For more information, see https://redis.io/commands/ardel
 |
 |  ardelrange(self, name: 'KeyT', *ranges: 'tuple[int, int]') -> 'int | Awaitable[int]'
 |      Delete elements within one or more inclusive index ranges in the
 |      array stored at ``name``. Each range is a ``(start, end)`` tuple.
 |      If ``start`` is greater than ``end`` for a given pair, the range is
 |      processed in ascending order regardless. Multiple pairs may overlap;
 |      each element is counted at most once.
 |
 |      Returns the number of elements deleted.
 |
 |      For more information, see https://redis.io/commands/ardelrange
 |
 |  arget(self, name: 'KeyT', index: 'int') -> 'bytes | str | None | Awaitable[bytes | str | None]'
 |      Return the value at ``index`` in the array stored at ``name``.
 |
 |      Returns ``None`` if ``name`` does not exist or no value is set at
 |      ``index``.
 |
 |      For more information, see https://redis.io/commands/arget
 |
 |  argetrange(self, name: 'KeyT', start: 'int', end: 'int') -> 'list[bytes | str | None] | Awaitable[list[bytes | str | None]]'
 |      Return the values in the inclusive index range [``start``, ``end``]
 |      in the array stored at ``name``. If ``start`` is greater than ``end``,
 |      elements are returned in reverse index order.
 |
 |      For more information, see https://redis.io/commands/argetrange
 |
 |  argrep(self, name: 'KeyT', start: 'int', end: 'int', predicates: 'list[tuple[ArrayPredicateType, EncodableT]]', combinator: 'ArrayPredicateCombinator | None' = None, limit: 'int | None' = None, withvalues: 'bool' = False, nocase: 'bool' = False) -> 'list[int] | list[list[int | bytes | str]] | Awaitable[list[int] | list[list[int | bytes | str]]]'
 |      Search elements of the array stored at ``name`` within the inclusive
 |      index range [``start``, ``end``] using one or more textual
 |      ``predicates``. Each predicate is a ``(type, value)`` tuple where
 |      ``type`` is a member of ``ArrayPredicateType``
 |      (``EXACT``, ``MATCH``, ``GLOB``, ``RE``).
 |
 |      Multiple predicates are combined via ``combinator``
 |      (``ArrayPredicateCombinator.AND`` or ``OR``); the server defaults to
 |      OR when omitted. ``limit`` caps the number of matches.
 |      ``withvalues=True`` returns a list of ``[index, value]`` pairs
 |      (``[[idx, val], ...]``) instead of a flat list of indices.
 |      ``nocase=True`` makes all comparisons case-insensitive.
 |
 |      Without ``withvalues``, returns a flat list of matching indices in
 |      traversal order. With ``withvalues``, returns a list of
 |      ``[index, value]`` pairs in traversal order. Empty slots are
 |      skipped.
 |
 |      For more information, see https://redis.io/commands/argrep
 |
 |  arinfo(self, name: 'KeyT', full: 'bool' = False) -> 'dict[str, int] | Awaitable[dict[str, int]]'
 |      Return metadata about the array stored at ``name`` as a dictionary.
 |      When ``full`` is ``True``, additionally include per-slice statistics
 |      (dense/sparse slice counts, average sizes, fill rates), which makes
 |      the call O(N) instead of O(1).
 |
 |      Raises ``ResponseError`` when the key does not exist.
 |
 |      For more information, see https://redis.io/commands/arinfo
 |
 |  arinsert(self, name: 'KeyT', *values: 'FieldT') -> 'int | Awaitable[int]'
 |      Insert one or more ``values`` at consecutive indices in the array
 |      stored at ``name``, beginning at the current insert cursor position.
 |      The cursor advances by one for each value inserted. Use ``ARNEXT``
 |      to inspect the current cursor position and ``ARSEEK`` to reposition
 |      it.
 |
 |      Returns the last index where a value was inserted.
 |
 |      For more information, see https://redis.io/commands/arinsert
 |
 |  arlastitems(self, name: 'KeyT', count: 'int', rev: 'bool' = False) -> 'list[bytes | str | None] | Awaitable[list[bytes | str | None]]'
 |      Return up to ``count`` most recently inserted elements from the array
 |      stored at ``name``. If the array contains fewer elements than
 |      ``count``, all elements are returned.
 |
 |      When ``rev`` is ``True``, elements are returned in reverse
 |      chronological order (most recent first) instead of the default
 |      oldest-first order.
 |
 |      For more information, see https://redis.io/commands/arlastitems
 |
 |  arlen(self, name: 'KeyT') -> 'int | Awaitable[int]'
 |      Return the length of the array stored at ``name``, defined as the
 |      maximum set index plus one. Returns 0 if ``name`` does not exist.
 |
 |      For more information, see https://redis.io/commands/arlen
 |
 |  armget(self, name: 'KeyT', *indices: 'int') -> 'list[bytes | str | None] | Awaitable[list[bytes | str | None]]'
 |      Return the values at the specified ``indices`` in the array stored at
 |      ``name``. The reply preserves the order of the requested indices and
 |      returns ``None`` for any index that is not set or when ``name`` does
 |      not exist.
 |
 |      For more information, see https://redis.io/commands/armget
 |
 |  armset(self, name: 'KeyT', mapping: 'Mapping[int, FieldT]') -> 'int | Awaitable[int]'
 |      Set multiple index/value pairs in the array stored at ``name``.
 |      ``mapping`` is a dictionary of zero-based integer indices to values.
 |      Pairs may be non-contiguous and in any order.
 |
 |      Returns the number of new slots that were set (previously empty).
 |
 |      For more information, see https://redis.io/commands/armset
 |
 |  arnext(self, name: 'KeyT') -> 'int | None | Awaitable[int | None]'
 |      Return the next index ``ARINSERT`` would use for the array stored at
 |      ``name``. Returns 0 if ``name`` does not exist or no insert happened
 |      yet, and ``None`` when the insertion cursor is exhausted (next insert
 |      would overflow).
 |
 |      For more information, see https://redis.io/commands/arnext
 |
 |  arop(self, name: 'KeyT', start: 'int', end: 'int', operation: 'ArrayAggregateOperations', value: 'EncodableT | None' = None) -> 'bytes | str | int | None | Awaitable[bytes | str | int | None]'
 |      Perform an aggregate ``operation`` on elements of the array stored at
 |      ``name`` in the inclusive index range [``start``, ``end``]. The range
 |      is always scanned from the lower to the higher index regardless of
 |      argument order.
 |
 |      ``operation`` is one of the members of ``ArrayAggregateOperations``.
 |      ``value`` is required when ``operation`` is
 |      ``ArrayAggregateOperations.MATCH`` and specifies the value to compare
 |      against.
 |
 |      Returns a bulk string for ``SUM``, ``MIN`` and ``MAX``, an integer
 |      for ``AND``, ``OR``, ``XOR``, ``MATCH`` and ``USED``, or ``None``
 |      when no elements match the operation.
 |
 |      For more information, see https://redis.io/commands/arop
 |
 |  arring(self, name: 'KeyT', size: 'int', *values: 'FieldT') -> 'int | Awaitable[int]'
 |      Insert one or more ``values`` into the array stored at ``name`` as a
 |      fixed-size ring buffer of ``size`` slots. Each value is placed at
 |      ``insert_idx % size``, wrapping back to index 0 once the end is
 |      reached and overwriting older values when full. If ``size`` is
 |      smaller than the current window, the array is truncated to fit.
 |
 |      Returns the last index where a value was inserted.
 |
 |      For more information, see https://redis.io/commands/arring
 |
 |  arscan(self, name: 'KeyT', start: 'int', end: 'int', limit: 'int | None' = None) -> 'list[list[int | bytes | str]] | Awaitable[list[list[int | bytes | str]]]'
 |      Iterate populated elements of the array stored at ``name`` in the
 |      inclusive range [``start``, ``end``] and return a list of
 |      ``[index, value]`` pairs in traversal order:
 |      ``[[idx1, val1], [idx2, val2], ...]``. Empty slots are skipped. If
 |      ``start`` is greater than ``end``, the iteration is reversed.
 |
 |      ``limit`` caps the number of populated elements returned. When
 |      omitted, all populated elements in range are returned.
 |
 |      For more information, see https://redis.io/commands/arscan
 |
 |  arseek(self, name: 'KeyT', index: 'int') -> 'int | Awaitable[int]'
 |      Set the insert cursor of the array stored at ``name`` to ``index``.
 |      Subsequent ``ARINSERT`` and ``ARRING`` operations begin inserting at
 |      this position.
 |
 |      Returns 1 if the cursor was set, 0 if ``name`` does not exist.
 |
 |      For more information, see https://redis.io/commands/arseek
 |
 |  arset(self, name: 'KeyT', index: 'int', *values: 'FieldT') -> 'int | Awaitable[int]'
 |      Set one or more contiguous ``values`` in the array stored at ``name``
 |      starting at ``index``. When multiple values are provided, they are
 |      stored at consecutive indices beginning at ``index``.
 |
 |      Returns the number of new slots that were set (previously empty).
 |
 |      For more information, see https://redis.io/commands/arset
 |
 |  ----------------------------------------------------------------------
 |  Methods inherited from redis.commands.core.ScanCommands:
 |
 |  hscan(self, name: 'KeyT', cursor: 'int' = 0, match: 'PatternT | None' = None, count: 'int | None' = None, no_values: 'bool | None' = None) -> 'HScanResponse | Awaitable[HScanResponse]'
 |      Incrementally return key/value slices in a hash. Also return a cursor
 |      indicating the scan position.
 |
 |      ``match`` allows for filtering the keys by pattern
 |
 |      ``count`` allows for hint the minimum number of returns
 |
 |      ``no_values`` indicates to return only the keys, without values.
 |
 |      For more information, see https://redis.io/commands/hscan
 |
 |  hscan_iter(self, name: 'KeyT', match: 'Union[PatternT, None]' = None, count: 'Optional[int]' = None, no_values: 'Union[bool, None]' = None) -> 'Iterator'
 |      Make an iterator using the HSCAN command so that the client doesn't
 |      need to remember the cursor position.
 |
 |      ``match`` allows for filtering the keys by pattern
 |
 |      ``count`` allows for hint the minimum number of returns
 |
 |      ``no_values`` indicates to return only the keys, without values
 |
 |  scan(self, cursor: 'int' = 0, match: 'PatternT | None' = None, count: 'int | None' = None, _type: 'str | None' = None, **kwargs) -> 'ScanResponse | Awaitable[ScanResponse]'
 |      Incrementally return lists of key names. Also return a cursor
 |      indicating the scan position.
 |
 |      ``match`` allows for filtering the keys by pattern
 |
 |      ``count`` provides a hint to Redis about the number of keys to
 |          return per batch.
 |
 |      ``_type`` filters the returned values by a particular Redis type.
 |          Stock Redis instances allow for the following types:
 |          HASH, LIST, SET, STREAM, STRING, ZSET
 |          Additionally, Redis modules can expose other types as well.
 |
 |      For more information, see https://redis.io/commands/scan
 |
 |  scan_iter(self, match: 'Union[PatternT, None]' = None, count: 'Optional[int]' = None, _type: 'Optional[str]' = None, **kwargs) -> 'Iterator'
 |      Make an iterator using the SCAN command so that the client doesn't
 |      need to remember the cursor position.
 |
 |      ``match`` allows for filtering the keys by pattern
 |
 |      ``count`` provides a hint to Redis about the number of keys to
 |          return per batch.
 |
 |      ``_type`` filters the returned values by a particular Redis type.
 |          Stock Redis instances allow for the following types:
 |          HASH, LIST, SET, STREAM, STRING, ZSET
 |          Additionally, Redis modules can expose other types as well.
 |
 |  sscan(self, name: 'KeyT', cursor: 'int' = 0, match: 'PatternT | None' = None, count: 'int | None' = None) -> 'ScanResponse | Awaitable[ScanResponse]'
 |      Incrementally return lists of elements in a set. Also return a cursor
 |      indicating the scan position.
 |
 |      ``match`` allows for filtering the keys by pattern
 |
 |      ``count`` allows for hint the minimum number of returns
 |
 |      For more information, see https://redis.io/commands/sscan
 |
 |  sscan_iter(self, name: 'KeyT', match: 'Union[PatternT, None]' = None, count: 'Optional[int]' = None) -> 'Iterator'
 |      Make an iterator using the SSCAN command so that the client doesn't
 |      need to remember the cursor position.
 |
 |      ``match`` allows for filtering the keys by pattern
 |
 |      ``count`` allows for hint the minimum number of returns
 |
 |  zscan(self, name: 'KeyT', cursor: 'int' = 0, match: 'PatternT | None' = None, count: 'int | None' = None, score_cast_func: 'type | Callable' = <class 'float'>) -> 'ZScanResponse | Awaitable[ZScanResponse]'
 |      Incrementally return lists of elements in a sorted set. Also return a
 |      cursor indicating the scan position.
 |
 |      ``match`` allows for filtering the keys by pattern
 |
 |      ``count`` allows for hint the minimum number of returns
 |
 |      ``score_cast_func`` a callable used to cast the score return value
 |
 |      For more information, see https://redis.io/commands/zscan
 |
 |  zscan_iter(self, name: 'KeyT', match: 'Union[PatternT, None]' = None, count: 'Optional[int]' = None, score_cast_func: 'Union[type, Callable]' = <class 'float'>) -> 'Iterator'
 |      Make an iterator using the ZSCAN command so that the client doesn't
 |      need to remember the cursor position.
 |
 |      ``match`` allows for filtering the keys by pattern
 |
 |      ``count`` allows for hint the minimum number of returns
 |
 |      ``score_cast_func`` a callable used to cast the score return value
 |
 |  ----------------------------------------------------------------------
 |  Methods inherited from redis.commands.core.SetCommands:
 |
 |  sadd(self, name: 'KeyT', *values: 'FieldT') -> 'int | Awaitable[int]'
 |      Add ``value(s)`` to set ``name``
 |
 |      For more information, see https://redis.io/commands/sadd
 |
 |  scard(self, name: 'KeyT') -> 'int | Awaitable[int]'
 |      Return the number of elements in set ``name``
 |
 |      For more information, see https://redis.io/commands/scard
 |
 |  sdiff(self, keys: 'List', *args: 'List') -> 'set[bytes | str] | Awaitable[set[bytes | str]]'
 |      Return the difference of sets specified by ``keys``
 |
 |      For more information, see https://redis.io/commands/sdiff
 |
 |  sdiffcard(self, numkeys: 'int', keys: 'List[KeyT]', limit: 'int' = 0) -> 'int | Awaitable[int]'
 |      Return the cardinality of the difference between the first set and all
 |      the successive sets specified by ``keys``, without returning the
 |      difference itself.
 |
 |      When LIMIT is provided (defaults to 0 and means unlimited), the returned
 |      cardinality is capped at ``limit`` and the server may stop the
 |      computation once the capped result is known.
 |
 |      For more information, see https://redis.io/commands/sdiffcard
 |
 |  sdiffstore(self, dest: 'str', keys: 'List', *args: 'List') -> 'int | Awaitable[int]'
 |      Store the difference of sets specified by ``keys`` into a new
 |      set named ``dest``.  Returns the number of keys in the new set.
 |
 |      For more information, see https://redis.io/commands/sdiffstore
 |
 |  sinter(self, keys: 'List', *args: 'List') -> 'set[bytes | str] | Awaitable[set[bytes | str]]'
 |      Return the intersection of sets specified by ``keys``
 |
 |      For more information, see https://redis.io/commands/sinter
 |
 |  sintercard(self, numkeys: 'int', keys: 'List[KeyT]', limit: 'int' = 0) -> 'int | Awaitable[int]'
 |      Return the cardinality of the intersect of multiple sets specified by ``keys``.
 |
 |      When LIMIT provided (defaults to 0 and means unlimited), if the intersection
 |      cardinality reaches limit partway through the computation, the algorithm will
 |      exit and yield limit as the cardinality
 |
 |      For more information, see https://redis.io/commands/sintercard
 |
 |  sinterstore(self, dest: 'KeyT', keys: 'List', *args: 'List') -> 'int | Awaitable[int]'
 |      Store the intersection of sets specified by ``keys`` into a new
 |      set named ``dest``.  Returns the number of keys in the new set.
 |
 |      For more information, see https://redis.io/commands/sinterstore
 |
 |  sismember(self, name: 'KeyT', value: 'str') -> 'Literal[0] | Literal[1] | Awaitable[Literal[0] | Literal[1]]'
 |      Return whether ``value`` is a member of set ``name``:
 |      - 1 if the value is a member of the set.
 |      - 0 if the value is not a member of the set or if key does not exist.
 |
 |      For more information, see https://redis.io/commands/sismember
 |
 |  smembers(self, name: 'KeyT') -> 'set[bytes | str] | Awaitable[set[bytes | str]]'
 |      Return all members of the set ``name``
 |
 |      For more information, see https://redis.io/commands/smembers
 |
 |  smismember(self, name: 'KeyT', values: 'List', *args: 'List') -> 'list[Literal[0] | Literal[1]] | Awaitable[list[Literal[0] | Literal[1]]]'
 |      Return whether each value in ``values`` is a member of the set ``name``
 |      as a list of ``int`` in the order of ``values``:
 |      - 1 if the value is a member of the set.
 |      - 0 if the value is not a member of the set or if key does not exist.
 |
 |      For more information, see https://redis.io/commands/smismember
 |
 |  smove(self, src: 'KeyT', dst: 'KeyT', value: 'str') -> 'bool | Awaitable[bool]'
 |      Move ``value`` from set ``src`` to set ``dst`` atomically
 |
 |      For more information, see https://redis.io/commands/smove
 |
 |  spop(self, name: 'KeyT', count: 'int | None' = None) -> 'bytes | str | set[bytes | str] | None | Awaitable[bytes | str | set[bytes | str] | None]'
 |      Remove and return a random member of set ``name``
 |
 |      For more information, see https://redis.io/commands/spop
 |
 |  srandmember(self, name: 'KeyT', number: 'int | None' = None) -> 'bytes | str | list[bytes | str] | None | Awaitable[bytes | str | list[bytes | str] | None]'
 |      If ``number`` is None, returns a random member of set ``name``.
 |
 |      If ``number`` is supplied, returns a list of ``number`` random
 |      members of set ``name``. Note this is only available when running
 |      Redis 2.6+.
 |
 |      For more information, see https://redis.io/commands/srandmember
 |
 |  srem(self, name: 'KeyT', *values: 'FieldT') -> 'int | Awaitable[int]'
 |      Remove ``values`` from set ``name``
 |
 |      For more information, see https://redis.io/commands/srem
 |
 |  sunion(self, keys: 'List', *args: 'List') -> 'set[bytes | str] | Awaitable[set[bytes | str]]'
 |      Return the union of sets specified by ``keys``
 |
 |      For more information, see https://redis.io/commands/sunion
 |
 |  sunioncard(self, numkeys: 'int', keys: 'List[KeyT]', limit: 'int' = 0, approx: 'bool' = False) -> 'int | Awaitable[int]'
 |      Return the cardinality of the union of multiple sets specified by
 |      ``keys``, without returning the union itself.
 |
 |      When ``approx`` is True, the ``APPROX`` option is sent and the server
 |      returns an approximate cardinality computed using HyperLogLog.
 |
 |      When LIMIT is provided (defaults to 0 and means unlimited), the returned
 |      cardinality is capped at ``limit``. In exact mode the result equals
 |      ``limit`` when the real cardinality exceeds ``limit``; in approximate
 |      mode the result will not exceed ``limit``. Options are emitted in the
 |      canonical order ``APPROX`` before ``LIMIT``.
 |
 |      For more information, see https://redis.io/commands/sunioncard
 |
 |  sunionstore(self, dest: 'KeyT', keys: 'List', *args: 'List') -> 'int | Awaitable[int]'
 |      Store the union of sets specified by ``keys`` into a new
 |      set named ``dest``.  Returns the number of keys in the new set.
 |
 |      For more information, see https://redis.io/commands/sunionstore
 |
 |  ----------------------------------------------------------------------
 |  Methods inherited from redis.commands.core.StreamCommands:
 |
 |  xack(self, name: 'KeyT', groupname: 'GroupT', *ids: 'StreamIdT') -> 'int | Awaitable[int]'
 |      Acknowledges the successful processing of one or more messages.
 |
 |      Args:
 |          name: name of the stream.
 |          groupname: name of the consumer group.
 |          *ids: message ids to acknowledge.
 |
 |      For more information, see https://redis.io/commands/xack
 |
 |  xackdel(self, name: 'KeyT', groupname: 'GroupT', *ids: 'StreamIdT', ref_policy: "Literal['KEEPREF', 'DELREF', 'ACKED']" = 'KEEPREF') -> 'int | Awaitable[int]'
 |      Combines the functionality of XACK and XDEL. Acknowledges the specified
 |      message IDs in the given consumer group and simultaneously attempts to
 |      delete the corresponding entries from the stream.
 |
 |  xadd(self, name: 'KeyT', fields: 'Dict[FieldT, EncodableT]', id: 'StreamIdT' = '*', maxlen: 'Optional[int]' = None, approximate: 'bool' = True, nomkstream: 'bool' = False, minid: 'Union[StreamIdT, None]' = None, limit: 'int | None' = None, ref_policy: "Literal['KEEPREF', 'DELREF', 'ACKED'] | None" = None, idmpauto: 'str | None' = None, idmp: 'tuple[str, bytes] | None' = None) -> 'bytes | str | Awaitable[bytes | str]'
 |      Add to a stream.
 |      name: name of the stream
 |      fields: dict of field/value pairs to insert into the stream
 |      id: Location to insert this record. By default it is appended.
 |      maxlen: truncate old stream members beyond this size.
 |      Can't be specified with minid.
 |      approximate: actual stream length may be slightly more than maxlen
 |      nomkstream: When set to true, do not make a stream
 |      minid: the minimum id in the stream to query.
 |      Can't be specified with maxlen.
 |      limit: specifies the maximum number of entries to retrieve
 |      ref_policy: optional reference policy for consumer groups when trimming:
 |          - KEEPREF (default): When trimming, preserves references in consumer groups' PEL
 |          - DELREF: When trimming, removes all references from consumer groups' PEL
 |          - ACKED: When trimming, only removes entries acknowledged by all consumer groups
 |      idmpauto: Producer ID for automatic idempotent ID calculation.
 |          Automatically calculates an idempotent ID based on entry content to prevent
 |          duplicate entries. Can only be used with id='*'. Creates an IDMP map if it
 |          doesn't exist yet. The producer ID must be unique per producer and consistent
 |          across restarts.
 |      idmp: Tuple of (producer_id, idempotent_id) for explicit idempotent ID.
 |          Uses a specific idempotent ID to prevent duplicate entries. Can only be used
 |          with id='*'. The producer ID must be unique per producer and consistent across
 |          restarts. The idempotent ID must be unique per message and per producer.
 |          Shorter idempotent IDs require less memory and allow faster processing.
 |          Creates an IDMP map if it doesn't exist yet.
 |
 |      For more information, see https://redis.io/commands/xadd
 |
 |  xautoclaim(self, name: 'KeyT', groupname: 'GroupT', consumername: 'ConsumerT', min_idle_time: 'int', start_id: 'StreamIdT' = '0-0', count: 'int | None' = None, justid: 'bool' = False) -> 'list[Any] | Awaitable[list[Any]]'
 |      Transfers ownership of pending stream entries that match the specified
 |      criteria. Conceptually, equivalent to calling XPENDING and then XCLAIM,
 |      but provides a more straightforward way to deal with message delivery
 |      failures via SCAN-like semantics.
 |      name: name of the stream.
 |      groupname: name of the consumer group.
 |      consumername: name of a consumer that claims the message.
 |      min_idle_time: filter messages that were idle less than this amount of
 |      milliseconds.
 |      start_id: filter messages with equal or greater ID.
 |      count: optional integer, upper limit of the number of entries that the
 |      command attempts to claim. Set to 100 by default.
 |      justid: optional boolean, false by default. Return just an array of IDs
 |      of messages successfully claimed, without returning the actual message
 |
 |      For more information, see https://redis.io/commands/xautoclaim
 |
 |  xcfgset(self, name: 'KeyT', idmp_duration: 'int | None' = None, idmp_maxsize: 'int | None' = None) -> 'bytes | str | Awaitable[bytes | str]'
 |      Configure the idempotency parameters for a stream's IDMP map.
 |
 |      Sets how long Redis remembers each idempotent ID (iid) and the maximum
 |      number of iids to track. This command clears the existing IDMP map
 |      (Redis forgets all previously stored iids), but only if the configuration
 |      value actually changes.
 |
 |      Args:
 |          name: The name of the stream.
 |          idmp_duration: How long Redis remembers each iid in seconds.
 |              Default: 100 seconds (or value set by stream-idmp-duration config).
 |              Minimum: 1 second, Maximum: 300 seconds.
 |              Redis won't forget an iid for this duration (unless maxsize is reached).
 |              Should accommodate application crash recovery time.
 |          idmp_maxsize: Maximum number of iids Redis remembers per producer ID (pid).
 |              Default: 100 iids (or value set by stream-idmp-maxsize config).
 |              Minimum: 1 iid, Maximum: 1,000,000 (1M) iids.
 |              Should be set to: mark-delay [in msec] × (messages/msec) + margin.
 |              Example: 10K msgs/sec (10 msgs/msec), 80 msec mark-delay
 |              → maxsize = 10 × 80 + margin = 1000 iids.
 |
 |      Returns:
 |          OK on success.
 |
 |      For more information, see https://redis.io/commands/xcfgset
 |
 |  xclaim(self, name: 'KeyT', groupname: 'GroupT', consumername: 'ConsumerT', min_idle_time: 'int', message_ids: 'Union[List[StreamIdT], Tuple[StreamIdT]]', idle: 'int | None' = None, time: 'int | None' = None, retrycount: 'int | None' = None, force: 'bool' = False, justid: 'bool' = False) -> 'XClaimResponse | Awaitable[XClaimResponse]'
 |      Changes the ownership of a pending message.
 |
 |      name: name of the stream.
 |
 |      groupname: name of the consumer group.
 |
 |      consumername: name of a consumer that claims the message.
 |
 |      min_idle_time: filter messages that were idle less than this amount of
 |      milliseconds
 |
 |      message_ids: non-empty list or tuple of message IDs to claim
 |
 |      idle: optional. Set the idle time (last time it was delivered) of the
 |      message in ms
 |
 |      time: optional integer. This is the same as idle but instead of a
 |      relative amount of milliseconds, it sets the idle time to a specific
 |      Unix time (in milliseconds).
 |
 |      retrycount: optional integer. set the retry counter to the specified
 |      value. This counter is incremented every time a message is delivered
 |      again.
 |
 |      force: optional boolean, false by default. Creates the pending message
 |      entry in the PEL even if certain specified IDs are not already in the
 |      PEL assigned to a different client.
 |
 |      justid: optional boolean, false by default. Return just an array of IDs
 |      of messages successfully claimed, without returning the actual message
 |
 |      For more information, see https://redis.io/commands/xclaim
 |
 |  xdel(self, name: 'KeyT', *ids: 'StreamIdT') -> 'int | Awaitable[int]'
 |      Deletes one or more messages from a stream.
 |
 |      Args:
 |          name: name of the stream.
 |          *ids: message ids to delete.
 |
 |      For more information, see https://redis.io/commands/xdel
 |
 |  xdelex(self, name: 'KeyT', *ids: 'StreamIdT', ref_policy: "Literal['KEEPREF', 'DELREF', 'ACKED']" = 'KEEPREF') -> 'int | Awaitable[int]'
 |      Extended version of XDEL that provides more control over how message entries
 |      are deleted concerning consumer groups.
 |
 |  xgroup_create(self, name: 'KeyT', groupname: 'GroupT', id: 'StreamIdT' = '$', mkstream: 'bool' = False, entries_read: 'int | None' = None) -> 'bool | Awaitable[bool]'
 |      Create a new consumer group associated with a stream.
 |      name: name of the stream.
 |      groupname: name of the consumer group.
 |      id: ID of the last item in the stream to consider already delivered.
 |
 |      For more information, see https://redis.io/commands/xgroup-create
 |
 |  xgroup_createconsumer(self, name: 'KeyT', groupname: 'GroupT', consumername: 'ConsumerT') -> 'int | Awaitable[int]'
 |      Consumers in a consumer group are auto-created every time a new
 |      consumer name is mentioned by some command.
 |      They can be explicitly created by using this command.
 |      name: name of the stream.
 |      groupname: name of the consumer group.
 |      consumername: name of consumer to create.
 |
 |      See: https://redis.io/commands/xgroup-createconsumer
 |
 |  xgroup_delconsumer(self, name: 'KeyT', groupname: 'GroupT', consumername: 'ConsumerT') -> 'int | Awaitable[int]'
 |      Remove a specific consumer from a consumer group.
 |      Returns the number of pending messages that the consumer had before it
 |      was deleted.
 |      name: name of the stream.
 |      groupname: name of the consumer group.
 |      consumername: name of consumer to delete
 |
 |      For more information, see https://redis.io/commands/xgroup-delconsumer
 |
 |  xgroup_destroy(self, name: 'KeyT', groupname: 'GroupT') -> 'bool | Awaitable[bool]'
 |      Destroy a consumer group.
 |      name: name of the stream.
 |      groupname: name of the consumer group.
 |
 |      For more information, see https://redis.io/commands/xgroup-destroy
 |
 |  xgroup_setid(self, name: 'KeyT', groupname: 'GroupT', id: 'StreamIdT', entries_read: 'int | None' = None) -> 'bool | Awaitable[bool]'
 |      Set the consumer group last delivered ID to something else.
 |      name: name of the stream.
 |      groupname: name of the consumer group.
 |      id: ID of the last item in the stream to consider already delivered.
 |
 |      For more information, see https://redis.io/commands/xgroup-setid
 |
 |  xinfo_consumers(self, name: 'KeyT', groupname: 'GroupT') -> 'list[dict[str, Any]] | Awaitable[list[dict[str, Any]]]'
 |      Returns general information about the consumers in the group.
 |      name: name of the stream.
 |      groupname: name of the consumer group.
 |
 |      For more information, see https://redis.io/commands/xinfo-consumers
 |
 |  xinfo_groups(self, name: 'KeyT') -> 'list[dict[str, Any]] | Awaitable[list[dict[str, Any]]]'
 |      Returns general information about the consumer groups of the stream.
 |      name: name of the stream.
 |
 |      For more information, see https://redis.io/commands/xinfo-groups
 |
 |  xinfo_stream(self, name: 'KeyT', full: 'bool' = False) -> 'dict[str, Any] | Awaitable[dict[str, Any]]'
 |      Returns general information about the stream.
 |      name: name of the stream.
 |      full: optional boolean, false by default. Return full summary
 |
 |      For more information, see https://redis.io/commands/xinfo-stream
 |
 |  xlen(self, name: 'KeyT') -> 'int | Awaitable[int]'
 |      Returns the number of elements in a given stream.
 |
 |      For more information, see https://redis.io/commands/xlen
 |
 |  xnack(self, name: 'KeyT', groupname: 'GroupT', mode: "Literal['SILENT', 'FAIL', 'FATAL']", *ids: 'StreamIdT', retrycount: 'int | None' = None, force: 'bool' = False) -> 'int | Awaitable[int]'
 |      Negatively acknowledges one or more messages in a consumer group's
 |      Pending Entries List (PEL).
 |
 |      Args:
 |          name: name of the stream.
 |          groupname: name of the consumer group.
 |          mode: the nacking mode. One of SILENT, FAIL, or FATAL.
 |              SILENT: consumer shutting down; decrements delivery counter.
 |              FAIL: consumer unable to process; delivery counter unchanged.
 |              FATAL: invalid/malicious message; delivery counter set to max.
 |          *ids: one or more message IDs to NACK.
 |          retrycount: optional integer >= 0. Overrides the mode's implicit
 |              delivery counter adjustment with an exact value.
 |          force: if True, creates a new unowned PEL entry for any ID not
 |              already in the group's PEL.
 |
 |      Returns:
 |          The number of messages successfully NACKed.
 |
 |      For more information, see https://redis.io/commands/xnack
 |
 |  xpending(self, name: 'KeyT', groupname: 'GroupT') -> 'dict[str, Any] | Awaitable[dict[str, Any]]'
 |      Returns information about pending messages of a group.
 |      name: name of the stream.
 |      groupname: name of the consumer group.
 |
 |      For more information, see https://redis.io/commands/xpending
 |
 |  xpending_range(self, name: 'KeyT', groupname: 'GroupT', min: 'StreamIdT', max: 'StreamIdT', count: 'int', consumername: 'ConsumerT | None' = None, idle: 'int | None' = None) -> 'XPendingRangeResponse | Awaitable[XPendingRangeResponse]'
 |      Returns information about pending messages, in a range.
 |
 |      name: name of the stream.
 |      groupname: name of the consumer group.
 |      idle: available from  version 6.2. filter entries by their
 |      idle-time, given in milliseconds (optional).
 |      min: minimum stream ID.
 |      max: maximum stream ID.
 |      count: number of messages to return
 |      consumername: name of a consumer to filter by (optional).
 |
 |  xrange(self, name: 'KeyT', min: 'StreamIdT' = '-', max: 'StreamIdT' = '+', count: 'int | None' = None) -> 'StreamRangeResponse | None | Awaitable[StreamRangeResponse | None]'
 |      Read stream values within an interval.
 |
 |      name: name of the stream.
 |
 |      start: first stream ID. defaults to '-',
 |             meaning the earliest available.
 |
 |      finish: last stream ID. defaults to '+',
 |              meaning the latest available.
 |
 |      count: if set, only return this many items, beginning with the
 |             earliest available.
 |
 |      For more information, see https://redis.io/commands/xrange
 |
 |  xread(self, streams: 'Dict[KeyT, StreamIdT]', count: 'int | None' = None, block: 'int | None' = None, max_count: 'int | None' = None, max_size: 'int | None' = None) -> 'XReadResponse | Awaitable[XReadResponse]'
 |      Block and monitor multiple streams for new data.
 |
 |      streams: a dict of stream names to stream IDs, where
 |                 IDs indicate the last ID already seen.
 |
 |      count: if set, only return this many items per stream, beginning with
 |             the earliest available.
 |
 |      block: number of milliseconds to wait, if nothing already present.
 |
 |      max_count: if set, cap the total number of entries returned across all
 |                 streams combined. Unlike ``count`` (a per-stream limit),
 |                 this is a cumulative cap over the whole reply. Must be a
 |                 positive integer and, when ``count`` is also set, must be
 |                 greater than or equal to ``count``. Requires Redis >= 8.10.0.
 |
 |      max_size: if set, a soft cap on the total server reply size in bytes
 |                across all streams combined. Measured server-side including
 |                protocol overhead, so it is not an exact application-payload
 |                size guarantee; a single available entry larger than the cap
 |                may still be returned. Must be a positive integer. Requires
 |                Redis >= 8.10.0.
 |
 |      For more information, see https://redis.io/commands/xread
 |
 |  xreadgroup(self, groupname: 'str', consumername: 'str', streams: 'Dict[KeyT, StreamIdT]', count: 'int | None' = None, block: 'int | None' = None, noack: 'bool' = False, claim_min_idle_time: 'int | None' = None, max_count: 'int | None' = None, max_size: 'int | None' = None) -> 'XReadGroupResponse | Awaitable[XReadGroupResponse]'
 |      Read from a stream via a consumer group.
 |
 |      groupname: name of the consumer group.
 |
 |      consumername: name of the requesting consumer.
 |
 |      streams: a dict of stream names to stream IDs, where
 |             IDs indicate the last ID already seen.
 |
 |      count: if set, only return this many items per stream, beginning with
 |             the earliest available.
 |
 |      block: number of milliseconds to wait, if nothing already present.
 |      noack: do not add messages to the PEL
 |
 |      claim_min_idle_time: accepts an integer type and represents a
 |                           time interval in milliseconds
 |
 |      max_count: if set, cap the total number of entries returned across all
 |                 streams combined. Unlike ``count`` (a per-stream limit),
 |                 this is a cumulative cap over the whole reply. Must be a
 |                 positive integer and, when ``count`` is also set, must be
 |                 greater than or equal to ``count``. Requires Redis 8.10.0.
 |
 |      max_size: if set, a soft cap on the total server reply size in bytes
 |                across all streams combined. Measured server-side including
 |                protocol overhead, so it is not an exact application-payload
 |                size guarantee; a single available entry larger than the cap
 |                may still be returned. Must be a positive integer. Requires
 |                Redis 8.10.0.
 |
 |      For more information, see https://redis.io/commands/xreadgroup
 |
 |  xrevrange(self, name: 'KeyT', max: 'StreamIdT' = '+', min: 'StreamIdT' = '-', count: 'int | None' = None) -> 'StreamRangeResponse | None | Awaitable[StreamRangeResponse | None]'
 |      Read stream values within an interval, in reverse order.
 |
 |      name: name of the stream
 |
 |      start: first stream ID. defaults to '+',
 |             meaning the latest available.
 |
 |      finish: last stream ID. defaults to '-',
 |              meaning the earliest available.
 |
 |      count: if set, only return this many items, beginning with the
 |             latest available.
 |
 |      For more information, see https://redis.io/commands/xrevrange
 |
 |  xtrim(self, name: 'KeyT', maxlen: 'int | None' = None, approximate: 'bool' = True, minid: 'StreamIdT | None' = None, limit: 'int | None' = None, ref_policy: "Literal['KEEPREF', 'DELREF', 'ACKED'] | None" = None) -> 'int | Awaitable[int]'
 |      Trims old messages from a stream.
 |      name: name of the stream.
 |      maxlen: truncate old stream messages beyond this size
 |      Can't be specified with minid.
 |      approximate: actual stream length may be slightly more than maxlen
 |      minid: the minimum id in the stream to query
 |      Can't be specified with maxlen.
 |      limit: specifies the maximum number of entries to retrieve
 |      ref_policy: optional reference policy for consumer groups:
 |          - KEEPREF (default): Trims entries but preserves references in consumer groups' PEL
 |          - DELREF: Trims entries and removes all references from consumer groups' PEL
 |          - ACKED: Only trims entries that were read and acknowledged by all consumer groups
 |
 |      For more information, see https://redis.io/commands/xtrim
 |
 |  ----------------------------------------------------------------------
 |  Methods inherited from redis.commands.core.SortedSetCommands:
 |
 |  bzmpop(self, timeout: 'float', numkeys: 'int', keys: 'List[str]', min: 'bool | None' = False, max: 'bool | None' = False, count: 'int | None' = 1) -> 'ZMPopResponse | Awaitable[ZMPopResponse]'
 |      Pop ``count`` values (default 1) off of the first non-empty sorted set
 |      named in the ``keys`` list.
 |
 |      If none of the sorted sets in ``keys`` has a value to pop,
 |      then block for ``timeout`` seconds, or until a member gets added
 |      to one of the sorted sets.
 |
 |      If timeout is 0, then block indefinitely.
 |
 |      For more information, see https://redis.io/commands/bzmpop
 |
 |  bzpopmax(self, keys: 'KeysT', timeout: 'TimeoutSecT' = 0) -> 'BlockingZSetPopResponse | Awaitable[BlockingZSetPopResponse]'
 |      ZPOPMAX a value off of the first non-empty sorted set
 |      named in the ``keys`` list.
 |
 |      If none of the sorted sets in ``keys`` has a value to ZPOPMAX,
 |      then block for ``timeout`` seconds, or until a member gets added
 |      to one of the sorted sets.
 |
 |      If timeout is 0, then block indefinitely.
 |
 |      For more information, see https://redis.io/commands/bzpopmax
 |
 |  bzpopmin(self, keys: 'KeysT', timeout: 'TimeoutSecT' = 0) -> 'BlockingZSetPopResponse | Awaitable[BlockingZSetPopResponse]'
 |      ZPOPMIN a value off of the first non-empty sorted set
 |      named in the ``keys`` list.
 |
 |      If none of the sorted sets in ``keys`` has a value to ZPOPMIN,
 |      then block for ``timeout`` seconds, or until a member gets added
 |      to one of the sorted sets.
 |
 |      If timeout is 0, then block indefinitely.
 |
 |      For more information, see https://redis.io/commands/bzpopmin
 |
 |  zadd(self, name: 'KeyT', mapping: 'Mapping[AnyKeyT, EncodableT]', nx: 'bool' = False, xx: 'bool' = False, ch: 'bool' = False, incr: 'bool' = False, gt: 'bool' = False, lt: 'bool' = False) -> 'int | float | None | Awaitable[int | float | None]'
 |      Set any number of element-name, score pairs to the key ``name``. Pairs
 |      are specified as a dict of element-names keys to score values.
 |
 |      ``nx`` forces ZADD to only create new elements and not to update
 |      scores for elements that already exist.
 |
 |      ``xx`` forces ZADD to only update scores of elements that already
 |      exist. New elements will not be added.
 |
 |      ``ch`` modifies the return value to be the numbers of elements changed.
 |      Changed elements include new elements that were added and elements
 |      whose scores changed.
 |
 |      ``incr`` modifies ZADD to behave like ZINCRBY. In this mode only a
 |      single element/score pair can be specified and the score is the amount
 |      the existing score will be incremented by. When using this mode the
 |      return value of ZADD will be the new score of the element.
 |
 |      ``lt`` only updates existing elements if the new score is less than
 |      the current score. This flag doesn't prevent adding new elements.
 |
 |      ``gt`` only updates existing elements if the new score is greater than
 |      the current score. This flag doesn't prevent adding new elements.
 |
 |      The return value of ZADD varies based on the mode specified. With no
 |      options, ZADD returns the number of new elements added to the sorted
 |      set.
 |
 |      ``nx``, ``lt``, and ``gt`` are mutually exclusive options.
 |
 |      See: https://redis.io/commands/ZADD
 |
 |  zcard(self, name: 'KeyT') -> 'int | Awaitable[int]'
 |      Return the number of elements in the sorted set ``name``
 |
 |      For more information, see https://redis.io/commands/zcard
 |
 |  zcount(self, name: 'KeyT', min: 'ZScoreBoundT', max: 'ZScoreBoundT') -> 'int | Awaitable[int]'
 |      Returns the number of elements in the sorted set at key ``name`` with
 |      a score between ``min`` and ``max``.
 |
 |      For more information, see https://redis.io/commands/zcount
 |
 |  zdiff(self, keys: 'KeysT', withscores: 'bool' = False) -> 'ZSetRangeResponse | Awaitable[ZSetRangeResponse]'
 |      Returns the difference between the first and all successive input
 |      sorted sets provided in ``keys``.
 |
 |      For more information, see https://redis.io/commands/zdiff
 |
 |  zdiffstore(self, dest: 'KeyT', keys: 'KeysT') -> 'int | Awaitable[int]'
 |      Computes the difference between the first and all successive input
 |      sorted sets provided in ``keys`` and stores the result in ``dest``.
 |
 |      For more information, see https://redis.io/commands/zdiffstore
 |
 |  zincrby(self, name: 'KeyT', amount: 'float', value: 'EncodableT') -> 'float | None | Awaitable[float | None]'
 |      Increment the score of ``value`` in sorted set ``name`` by ``amount``
 |
 |      For more information, see https://redis.io/commands/zincrby
 |
 |  zinter(self, keys: 'KeysT', aggregate: 'str | None' = None, withscores: 'bool' = False) -> 'ZSetRangeResponse | Awaitable[ZSetRangeResponse]'
 |      Return the intersect of multiple sorted sets specified by ``keys``.
 |
 |      With the ``aggregate`` option, it is possible to specify how the
 |      results of the intersection are aggregated. Available aggregation
 |      modes:
 |
 |      - ``SUM`` (default): the score of an element is summed across the
 |        inputs where it exists.
 |        Score = SUM(score₁×weight₁, score₂×weight₂, ...)
 |      - ``MIN``: the resulting set will contain the minimum score of an
 |        element across the inputs where it exists.
 |        Score = MIN(score₁×weight₁, score₂×weight₂, ...)
 |      - ``MAX``: the resulting set will contain the maximum score of an
 |        element across the inputs where it exists.
 |        Score = MAX(score₁×weight₁, score₂×weight₂, ...)
 |      - ``COUNT``: ignores the original scores and counts weighted set
 |        membership. Each element's score is the sum of the weights of
 |        the input sets that contain it.
 |        Score = SUM(weight₁, weight₂, ...) for sets containing the element.
 |        When all weights are 1 (default), the score equals the number
 |        of input sets containing the element.
 |
 |      For more information, see https://redis.io/commands/zinter
 |
 |  zintercard(self, numkeys: 'int', keys: 'List[str]', limit: 'int' = 0) -> 'int | Awaitable[int]'
 |      Return the cardinality of the intersect of multiple sorted sets
 |      specified by ``keys``.
 |      When LIMIT provided (defaults to 0 and means unlimited), if the intersection
 |      cardinality reaches limit partway through the computation, the algorithm will
 |      exit and yield limit as the cardinality
 |
 |      For more information, see https://redis.io/commands/zintercard
 |
 |  zinterstore(self, dest: 'KeyT', keys: 'Sequence[KeyT] | Mapping[AnyKeyT, float]', aggregate: 'str | None' = None) -> 'int | Awaitable[int]'
 |      Intersect multiple sorted sets specified by ``keys`` into a new
 |      sorted set, ``dest``. Scores in the destination will be aggregated
 |      based on the ``aggregate``.
 |
 |      Available aggregation modes:
 |
 |      - ``SUM`` (default): the score of an element is summed across the
 |        inputs where it exists.
 |        Score = SUM(score₁×weight₁, score₂×weight₂, ...)
 |      - ``MIN``: the resulting set will contain the minimum score of an
 |        element across the inputs where it exists.
 |        Score = MIN(score₁×weight₁, score₂×weight₂, ...)
 |      - ``MAX``: the resulting set will contain the maximum score of an
 |        element across the inputs where it exists.
 |        Score = MAX(score₁×weight₁, score₂×weight₂, ...)
 |      - ``COUNT``: ignores the original scores and counts weighted set
 |        membership. Each element's score is the sum of the weights of
 |        the input sets that contain it.
 |        Score = SUM(weight₁, weight₂, ...) for sets containing the element.
 |        When all weights are 1 (default), the score equals the number
 |        of input sets containing the element.
 |
 |      For more information, see https://redis.io/commands/zinterstore
 |
 |  zlexcount(self, name: 'KeyT', min: 'EncodableT', max: 'EncodableT') -> 'int | Awaitable[int]'
 |      Return the number of items in the sorted set ``name`` between the
 |      lexicographical range ``min`` and ``max``.
 |
 |      For more information, see https://redis.io/commands/zlexcount
 |
 |  zmpop(self, num_keys: 'int', keys: 'List[str]', min: 'bool | None' = False, max: 'bool | None' = False, count: 'int | None' = 1) -> 'ZMPopResponse | Awaitable[ZMPopResponse]'
 |      Pop ``count`` values (default 1) off of the first non-empty sorted set
 |      named in the ``keys`` list.
 |      For more information, see https://redis.io/commands/zmpop
 |
 |  zmscore(self, key: 'KeyT', members: 'List[str]') -> 'list[float | None] | Awaitable[list[float | None]]'
 |      Returns the scores associated with the specified members
 |      in the sorted set stored at key.
 |      ``members`` should be a list of the member name.
 |      Return type is a list of score.
 |      If the member does not exist, a None will be returned
 |      in corresponding position.
 |
 |      For more information, see https://redis.io/commands/zmscore
 |
 |  zpopmax(self, name: 'KeyT', count: 'int | None' = None) -> 'ZSetRangeResponse | Awaitable[ZSetRangeResponse]'
 |      Remove and return up to ``count`` members with the highest scores
 |      from the sorted set ``name``.
 |
 |      For more information, see https://redis.io/commands/zpopmax
 |
 |  zpopmin(self, name: 'KeyT', count: 'int | None' = None) -> 'ZSetRangeResponse | Awaitable[ZSetRangeResponse]'
 |      Remove and return up to ``count`` members with the lowest scores
 |      from the sorted set ``name``.
 |
 |      For more information, see https://redis.io/commands/zpopmin
 |
 |  zrandmember(self, key: 'KeyT', count: 'int | None' = None, withscores: 'bool' = False) -> 'ZRandMemberResponse | Awaitable[ZRandMemberResponse]'
 |      Return a random element from the sorted set value stored at key.
 |
 |      ``count`` if the argument is positive, return an array of distinct
 |      fields. If called with a negative count, the behavior changes and
 |      the command is allowed to return the same field multiple times.
 |      In this case, the number of returned fields is the absolute value
 |      of the specified count.
 |
 |      ``withscores`` The optional WITHSCORES modifier changes the reply so it
 |      includes the respective scores of the randomly selected elements from
 |      the sorted set.
 |
 |      For more information, see https://redis.io/commands/zrandmember
 |
 |  zrange(self, name: 'KeyT', start: 'EncodableT', end: 'EncodableT', desc: 'bool' = False, withscores: 'bool' = False, score_cast_func: 'type | Callable' = <class 'float'>, byscore: 'bool' = False, bylex: 'bool' = False, offset: 'int | None' = None, num: 'int | None' = None) -> 'ZSetRangeResponse | Awaitable[ZSetRangeResponse]'
 |      Return a range of values from sorted set ``name`` between
 |      ``start`` and ``end`` sorted in ascending order.
 |
 |      ``start`` and ``end`` can be negative, indicating the end of the range.
 |
 |      ``desc`` a boolean indicating whether to sort the results in reversed
 |      order.
 |
 |      ``withscores`` indicates to return the scores along with the values.
 |      The return type is a list of (value, score) pairs.
 |
 |      ``score_cast_func`` a callable used to cast the score return value.
 |
 |      ``byscore`` when set to True, returns the range of elements from the
 |      sorted set having scores equal or between ``start`` and ``end``.
 |
 |      ``bylex`` when set to True, returns the range of elements from the
 |      sorted set between the ``start`` and ``end`` lexicographical closed
 |      range intervals.
 |      Valid ``start`` and ``end`` must start with ( or [, in order to specify
 |      whether the range interval is exclusive or inclusive, respectively.
 |
 |      ``offset`` and ``num`` are specified, then return a slice of the range.
 |      Can't be provided when using ``bylex``.
 |
 |      For more information, see https://redis.io/commands/zrange
 |
 |  zrangebylex(self, name: 'KeyT', min: 'EncodableT', max: 'EncodableT', start: 'int | None' = None, num: 'int | None' = None) -> 'list[bytes | str] | Awaitable[list[bytes | str]]'
 |      Return the lexicographical range of values from sorted set ``name``
 |      between ``min`` and ``max``.
 |
 |      If ``start`` and ``num`` are specified, then return a slice of the
 |      range.
 |
 |      For more information, see https://redis.io/commands/zrangebylex
 |
 |  zrangebyscore(self, name: 'KeyT', min: 'ZScoreBoundT', max: 'ZScoreBoundT', start: 'int | None' = None, num: 'int | None' = None, withscores: 'bool' = False, score_cast_func: 'type | Callable' = <class 'float'>) -> 'ZSetRangeResponse | Awaitable[ZSetRangeResponse]'
 |      Return a range of values from the sorted set ``name`` with scores
 |      between ``min`` and ``max``.
 |
 |      If ``start`` and ``num`` are specified, then return a slice
 |      of the range.
 |
 |      ``withscores`` indicates to return the scores along with the values.
 |      The return type is a list of (value, score) pairs
 |
 |      `score_cast_func`` a callable used to cast the score return value
 |
 |      For more information, see https://redis.io/commands/zrangebyscore
 |
 |  zrangestore(self, dest: 'KeyT', name: 'KeyT', start: 'EncodableT', end: 'EncodableT', byscore: 'bool' = False, bylex: 'bool' = False, desc: 'bool' = False, offset: 'int | None' = None, num: 'int | None' = None) -> 'int | Awaitable[int]'
 |      Stores in ``dest`` the result of a range of values from sorted set
 |      ``name`` between ``start`` and ``end`` sorted in ascending order.
 |
 |      ``start`` and ``end`` can be negative, indicating the end of the range.
 |
 |      ``byscore`` when set to True, returns the range of elements from the
 |      sorted set having scores equal or between ``start`` and ``end``.
 |
 |      ``bylex`` when set to True, returns the range of elements from the
 |      sorted set between the ``start`` and ``end`` lexicographical closed
 |      range intervals.
 |      Valid ``start`` and ``end`` must start with ( or [, in order to specify
 |      whether the range interval is exclusive or inclusive, respectively.
 |
 |      ``desc`` a boolean indicating whether to sort the results in reversed
 |      order.
 |
 |      ``offset`` and ``num`` are specified, then return a slice of the range.
 |      Can't be provided when using ``bylex``.
 |
 |      For more information, see https://redis.io/commands/zrangestore
 |
 |  zrank(self, name: 'KeyT', value: 'EncodableT', withscore: 'bool' = False, score_cast_func: 'type | Callable' = <class 'float'>) -> 'int | list[Any] | None | Awaitable[int | list[Any] | None]'
 |      Returns a 0-based value indicating the rank of ``value`` in sorted set
 |      ``name``.
 |      The optional WITHSCORE argument supplements the command's
 |      reply with the score of the element returned.
 |
 |      ``score_cast_func`` a callable used to cast the score return value
 |
 |      For more information, see https://redis.io/commands/zrank
 |
 |  zrem(self, name: 'KeyT', *values: 'FieldT') -> 'int | Awaitable[int]'
 |      Remove member ``values`` from sorted set ``name``
 |
 |      For more information, see https://redis.io/commands/zrem
 |
 |  zremrangebylex(self, name: 'KeyT', min: 'EncodableT', max: 'EncodableT') -> 'int | Awaitable[int]'
 |      Remove all elements in the sorted set ``name`` between the
 |      lexicographical range specified by ``min`` and ``max``.
 |
 |      Returns the number of elements removed.
 |
 |      For more information, see https://redis.io/commands/zremrangebylex
 |
 |  zremrangebyrank(self, name: 'KeyT', min: 'int', max: 'int') -> 'int | Awaitable[int]'
 |      Remove all elements in the sorted set ``name`` with ranks between
 |      ``min`` and ``max``. Values are 0-based, ordered from smallest score
 |      to largest. Values can be negative indicating the highest scores.
 |      Returns the number of elements removed
 |
 |      For more information, see https://redis.io/commands/zremrangebyrank
 |
 |  zremrangebyscore(self, name: 'KeyT', min: 'ZScoreBoundT', max: 'ZScoreBoundT') -> 'int | Awaitable[int]'
 |      Remove all elements in the sorted set ``name`` with scores
 |      between ``min`` and ``max``. Returns the number of elements removed.
 |
 |      For more information, see https://redis.io/commands/zremrangebyscore
 |
 |  zrevrange(self, name: 'KeyT', start: 'int', end: 'int', withscores: 'bool' = False, score_cast_func: 'type | Callable' = <class 'float'>) -> 'ZSetRangeResponse | Awaitable[ZSetRangeResponse]'
 |      Return a range of values from sorted set ``name`` between
 |      ``start`` and ``end`` sorted in descending order.
 |
 |      ``start`` and ``end`` can be negative, indicating the end of the range.
 |
 |      ``withscores`` indicates to return the scores along with the values
 |      The return type is a list of (value, score) pairs
 |
 |      ``score_cast_func`` a callable used to cast the score return value
 |
 |      For more information, see https://redis.io/commands/zrevrange
 |
 |  zrevrangebylex(self, name: 'KeyT', max: 'EncodableT', min: 'EncodableT', start: 'int | None' = None, num: 'int | None' = None) -> 'list[bytes | str] | Awaitable[list[bytes | str]]'
 |      Return the reversed lexicographical range of values from sorted set
 |      ``name`` between ``max`` and ``min``.
 |
 |      If ``start`` and ``num`` are specified, then return a slice of the
 |      range.
 |
 |      For more information, see https://redis.io/commands/zrevrangebylex
 |
 |  zrevrangebyscore(self, name: 'KeyT', max: 'ZScoreBoundT', min: 'ZScoreBoundT', start: 'int | None' = None, num: 'int | None' = None, withscores: 'bool' = False, score_cast_func: 'type | Callable' = <class 'float'>) -> 'ZSetRangeResponse | Awaitable[ZSetRangeResponse]'
 |      Return a range of values from the sorted set ``name`` with scores
 |      between ``min`` and ``max`` in descending order.
 |
 |      If ``start`` and ``num`` are specified, then return a slice
 |      of the range.
 |
 |      ``withscores`` indicates to return the scores along with the values.
 |      The return type is a list of (value, score) pairs
 |
 |      ``score_cast_func`` a callable used to cast the score return value
 |
 |      For more information, see https://redis.io/commands/zrevrangebyscore
 |
 |  zrevrank(self, name: 'KeyT', value: 'EncodableT', withscore: 'bool' = False, score_cast_func: 'type | Callable' = <class 'float'>) -> 'int | list[Any] | None | Awaitable[int | list[Any] | None]'
 |      Returns a 0-based value indicating the descending rank of
 |      ``value`` in sorted set ``name``.
 |      The optional ``withscore`` argument supplements the command's
 |      reply with the score of the element returned.
 |
 |      ``score_cast_func`` a callable used to cast the score return value
 |
 |      For more information, see https://redis.io/commands/zrevrank
 |
 |  zscore(self, name: 'KeyT', value: 'EncodableT') -> 'float | None | Awaitable[float | None]'
 |      Return the score of element ``value`` in sorted set ``name``
 |
 |      For more information, see https://redis.io/commands/zscore
 |
 |  zunion(self, keys: 'Sequence[KeyT] | Mapping[AnyKeyT, float]', aggregate: 'str | None' = None, withscores: 'bool' = False, score_cast_func: 'type | Callable' = <class 'float'>) -> 'ZSetRangeResponse | Awaitable[ZSetRangeResponse]'
 |      Return the union of multiple sorted sets specified by ``keys``.
 |      ``keys`` can be provided as dictionary of keys and their weights.
 |      Scores will be aggregated based on the ``aggregate``, or SUM if
 |      none is provided.
 |
 |      Available aggregation modes:
 |
 |      - ``SUM`` (default): the score of an element is summed across the
 |        inputs where it exists.
 |        Score = SUM(score₁×weight₁, score₂×weight₂, ...)
 |      - ``MIN``: the resulting set will contain the minimum score of an
 |        element across the inputs where it exists.
 |        Score = MIN(score₁×weight₁, score₂×weight₂, ...)
 |      - ``MAX``: the resulting set will contain the maximum score of an
 |        element across the inputs where it exists.
 |        Score = MAX(score₁×weight₁, score₂×weight₂, ...)
 |      - ``COUNT``: ignores the original scores and counts weighted set
 |        membership. Each element's score is the sum of the weights of
 |        the input sets that contain it.
 |        Score = SUM(weight₁, weight₂, ...) for sets containing the element.
 |        When all weights are 1 (default), the score equals the number
 |        of input sets containing the element.
 |
 |      ``score_cast_func`` a callable used to cast the score return value
 |
 |      For more information, see https://redis.io/commands/zunion
 |
 |  zunionstore(self, dest: 'KeyT', keys: 'Sequence[KeyT] | Mapping[AnyKeyT, float]', aggregate: 'str | None' = None) -> 'int | Awaitable[int]'
 |      Union multiple sorted sets specified by ``keys`` into
 |      a new sorted set, ``dest``. Scores in the destination will be
 |      aggregated based on the ``aggregate``, or SUM if none is provided.
 |
 |      Available aggregation modes:
 |
 |      - ``SUM`` (default): the score of an element is summed across the
 |        inputs where it exists.
 |        Score = SUM(score₁×weight₁, score₂×weight₂, ...)
 |      - ``MIN``: the resulting set will contain the minimum score of an
 |        element across the inputs where it exists.
 |        Score = MIN(score₁×weight₁, score₂×weight₂, ...)
 |      - ``MAX``: the resulting set will contain the maximum score of an
 |        element across the inputs where it exists.
 |        Score = MAX(score₁×weight₁, score₂×weight₂, ...)
 |      - ``COUNT``: ignores the original scores and counts weighted set
 |        membership. Each element's score is the sum of the weights of
 |        the input sets that contain it.
 |        Score = SUM(weight₁, weight₂, ...) for sets containing the element.
 |        When all weights are 1 (default), the score equals the number
 |        of input sets containing the element.
 |
 |      For more information, see https://redis.io/commands/zunionstore
 |
 |  ----------------------------------------------------------------------
 |  Methods inherited from redis.commands.core.ManagementCommands:
 |
 |  auth(self, password: 'str', username: 'str | None' = None, **kwargs) -> 'bool | Awaitable[bool]'
 |      Authenticates the user. If you do not pass username, Redis will try to
 |      authenticate for the "default" user. If you do pass username, it will
 |      authenticate for the given user.
 |      For more information, see https://redis.io/commands/auth
 |
 |  bgrewriteaof(self, **kwargs) -> 'bool | bytes | str | Awaitable[bool | bytes | str]'
 |      Tell the Redis server to rewrite the AOF file from data in memory.
 |
 |      For more information, see https://redis.io/commands/bgrewriteaof
 |
 |  bgsave(self, schedule: 'bool' = True, **kwargs) -> 'bool | bytes | str | Awaitable[bool | bytes | str]'
 |      Tell the Redis server to save its data to disk.  Unlike save(),
 |      this method is asynchronous and returns immediately.
 |
 |      For more information, see https://redis.io/commands/bgsave
 |
 |  client_getname(self, **kwargs) -> 'bytes | str | None | Awaitable[bytes | str | None]'
 |      Returns the current connection name
 |
 |      For more information, see https://redis.io/commands/client-getname
 |
 |  client_getredir(self, **kwargs) -> 'int | Awaitable[int]'
 |      Returns the ID (an integer) of the client to whom we are
 |      redirecting tracking notifications.
 |
 |      see: https://redis.io/commands/client-getredir
 |
 |  client_id(self, **kwargs) -> 'int | Awaitable[int]'
 |      Returns the current connection id
 |
 |      For more information, see https://redis.io/commands/client-id
 |
 |  client_info(self, **kwargs) -> 'dict[str, str | int] | Awaitable[dict[str, str | int]]'
 |      Returns information and statistics about the current
 |      client connection.
 |
 |      For more information, see https://redis.io/commands/client-info
 |
 |  client_kill(self, address: 'str', **kwargs) -> 'bool | int | Awaitable[bool | int]'
 |      Disconnects the client at ``address`` (ip:port)
 |
 |      For more information, see https://redis.io/commands/client-kill
 |
 |  client_kill_filter(self, _id: 'str | None' = None, _type: 'str | None' = None, addr: 'str | None' = None, skipme: 'bool | None' = None, laddr: 'bool | None' = None, user: 'str | None' = None, maxage: 'int | None' = None, **kwargs) -> 'int | Awaitable[int]'
 |      Disconnects client(s) using a variety of filter options
 |      :param _id: Kills a client by its unique ID field
 |      :param _type: Kills a client by type where type is one of 'normal',
 |      'master', 'slave', 'replica' or 'pubsub'
 |      :param addr: Kills a client by its 'address:port'
 |      :param skipme: If True, then the client calling the command
 |      will not get killed even if it is identified by one of the filter
 |      options. If skipme is not provided, the server defaults to skipme=True
 |      :param laddr: Kills a client by its 'local (bind) address:port'
 |      :param user: Kills a client for a specific user name
 |      :param maxage: Kills clients that are older than the specified age in seconds
 |
 |  client_list(self, _type: 'str | None' = None, client_id: 'List[EncodableT]' = [], **kwargs) -> 'list[dict[str, str]] | Awaitable[list[dict[str, str]]]'
 |      Returns a list of currently connected clients.
 |      If type of client specified, only that type will be returned.
 |
 |      :param _type: optional. one of the client types (normal, master,
 |       replica, pubsub)
 |      :param client_id: optional. a list of client ids
 |
 |      For more information, see https://redis.io/commands/client-list
 |
 |  client_no_evict(self, mode: 'str') -> 'bytes | str | Awaitable[bytes | str]'
 |      Sets the client eviction mode for the current connection.
 |
 |      For more information, see https://redis.io/commands/client-no-evict
 |
 |  client_no_touch(self, mode: 'str') -> 'bytes | str | Awaitable[bytes | str]'
 |      # The command controls whether commands sent by the client will alter
 |      # the LRU/LFU of the keys they access.
 |      # When turned on, the current client will not change LFU/LRU stats,
 |      # unless it sends the TOUCH command.
 |
 |      For more information, see https://redis.io/commands/client-no-touch
 |
 |  client_pause(self, timeout: 'int', all: 'bool' = True, **kwargs) -> 'bool | Awaitable[bool]'
 |      Suspend all the Redis clients for the specified amount of time.
 |
 |
 |      For more information, see https://redis.io/commands/client-pause
 |
 |      Args:
 |          timeout: milliseconds to pause clients
 |          all: If true (default) all client commands are blocked.
 |               otherwise, clients are only blocked if they attempt to execute
 |               a write command.
 |
 |      For the WRITE mode, some commands have special behavior:
 |
 |      * EVAL/EVALSHA: Will block client for all scripts.
 |      * PUBLISH: Will block client.
 |      * PFCOUNT: Will block client.
 |      * WAIT: Acknowledgments will be delayed, so this command will
 |          appear blocked.
 |
 |  client_reply(self, reply: "Literal['ON', 'OFF', 'SKIP']", **kwargs) -> 'bytes | str | Awaitable[bytes | str]'
 |      Enable and disable redis server replies.
 |
 |      ``reply`` Must be ON OFF or SKIP,
 |      ON - The default most with server replies to commands
 |      OFF - Disable server responses to commands
 |      SKIP - Skip the response of the immediately following command.
 |
 |      Note: When setting OFF or SKIP replies, you will need a client object
 |      with a timeout specified in seconds, and will need to catch the
 |      TimeoutError.
 |      The test_client_reply unit test illustrates this, and
 |      conftest.py has a client with a timeout.
 |
 |      See https://redis.io/commands/client-reply
 |
 |  client_setinfo(self, attr: 'str', value: 'str', **kwargs) -> 'bool | Awaitable[bool]'
 |      Sets the current connection library name or version
 |      For more information see https://redis.io/commands/client-setinfo
 |
 |  client_setname(self, name: 'str', **kwargs) -> 'bool | Awaitable[bool]'
 |      Sets the current connection name
 |
 |      For more information, see https://redis.io/commands/client-setname
 |
 |      .. note::
 |         This method sets client name only for **current** connection.
 |
 |         If you want to set a common name for all connections managed
 |         by this client, use ``client_name`` constructor argument.
 |
 |  client_tracking(self, on: 'bool' = True, clientid: 'int | None' = None, prefix: 'Sequence[KeyT]' = [], bcast: 'bool' = False, optin: 'bool' = False, optout: 'bool' = False, noloop: 'bool' = False, **kwargs) -> 'bytes | str | Awaitable[bytes | str]'
 |      Enables the tracking feature of the Redis server, that is used
 |      for server assisted client side caching.
 |
 |      ``on`` indicate for tracking on or tracking off. The default is on.
 |
 |      ``clientid`` send invalidation messages to the connection with
 |      the specified ID.
 |
 |      ``bcast`` enable tracking in broadcasting mode. In this mode
 |      invalidation messages are reported for all the prefixes
 |      specified, regardless of the keys requested by the connection.
 |
 |      ``optin``  when broadcasting is NOT active, normally don't track
 |      keys in read only commands, unless they are called immediately
 |      after a CLIENT CACHING yes command.
 |
 |      ``optout`` when broadcasting is NOT active, normally track keys in
 |      read only commands, unless they are called immediately after a
 |      CLIENT CACHING no command.
 |
 |      ``noloop`` don't send notifications about keys modified by this
 |      connection itself.
 |
 |      ``prefix``  for broadcasting, register a given key prefix, so that
 |      notifications will be provided only for keys starting with this string.
 |
 |      See https://redis.io/commands/client-tracking
 |
 |  client_tracking_off(self, clientid: 'int | None' = None, prefix: 'Sequence[KeyT]' = [], bcast: 'bool' = False, optin: 'bool' = False, optout: 'bool' = False, noloop: 'bool' = False) -> 'bytes | str | Awaitable[bytes | str]'
 |      Turn off the tracking mode.
 |      For more information, about the options look at client_tracking func.
 |
 |      See https://redis.io/commands/client-tracking
 |
 |  client_tracking_on(self, clientid: 'int | None' = None, prefix: 'Sequence[KeyT]' = [], bcast: 'bool' = False, optin: 'bool' = False, optout: 'bool' = False, noloop: 'bool' = False) -> 'bytes | str | Awaitable[bytes | str]'
 |      Turn on the tracking mode.
 |      For more information, about the options look at client_tracking func.
 |
 |      See https://redis.io/commands/client-tracking
 |
 |  client_trackinginfo(self, **kwargs) -> 'ClientTrackingInfoResponse | Awaitable[ClientTrackingInfoResponse]'
 |      Returns the information about the current client connection's
 |      use of the server assisted client side cache.
 |
 |      See https://redis.io/commands/client-trackinginfo
 |
 |  client_unblock(self, client_id: 'int', error: 'bool' = False, **kwargs) -> 'bool | Awaitable[bool]'
 |      Unblocks a connection by its client id.
 |      If ``error`` is True, unblocks the client with a special error message.
 |      If ``error`` is False (default), the client is unblocked using the
 |      regular timeout mechanism.
 |
 |      For more information, see https://redis.io/commands/client-unblock
 |
 |  client_unpause(self, **kwargs) -> 'bytes | str | Awaitable[bytes | str]'
 |      Unpause all redis clients
 |
 |      For more information, see https://redis.io/commands/client-unpause
 |
 |  command(self, **kwargs) -> 'dict[str, dict[str, Any]] | Awaitable[dict[str, dict[str, Any]]]'
 |      Returns dict reply of details about all Redis commands.
 |
 |      For more information, see https://redis.io/commands/command
 |
 |  command_count(self, **kwargs) -> 'int | Awaitable[int]'
 |
 |  command_docs(self, *args)
 |      This function throws a NotImplementedError since it is intentionally
 |      not supported.
 |
 |  command_getkeysandflags(self, *args: 'str') -> 'CommandGetKeysAndFlagsResponse | Awaitable[CommandGetKeysAndFlagsResponse]'
 |      Returns array of keys from a full Redis command and their usage flags.
 |
 |      For more information, see https://redis.io/commands/command-getkeysandflags
 |
 |  command_info(self, **kwargs) -> 'None'
 |
 |  command_list(self, module: 'str | None' = None, category: 'str | None' = None, pattern: 'str | None' = None) -> 'list[bytes | str] | Awaitable[list[bytes | str]]'
 |      Return an array of the server's command names.
 |      You can use one of the following filters:
 |      ``module``: get the commands that belong to the module
 |      ``category``: get the commands in the ACL category
 |      ``pattern``: get the commands that match the given pattern
 |
 |      For more information, see https://redis.io/commands/command-list/
 |
 |  config_get(self, pattern: 'PatternT' = '*', *args: 'PatternT', **kwargs) -> 'dict[str | None, str | None] | Awaitable[dict[str | None, str | None]]'
 |      Return a dictionary of configuration based on the ``pattern``
 |
 |      For more information, see https://redis.io/commands/config-get
 |
 |  config_resetstat(self, **kwargs) -> 'bool | Awaitable[bool]'
 |      Reset runtime statistics
 |
 |      For more information, see https://redis.io/commands/config-resetstat
 |
 |  config_rewrite(self, **kwargs) -> 'bytes | str | Awaitable[bytes | str]'
 |      Rewrite config file with the minimal change to reflect running config.
 |
 |      For more information, see https://redis.io/commands/config-rewrite
 |
 |  config_set(self, name: 'KeyT', value: 'EncodableT', *args: 'Union[KeyT, EncodableT]', **kwargs) -> 'bool | Awaitable[bool]'
 |      Set config item ``name`` with ``value``
 |
 |      For more information, see https://redis.io/commands/config-set
 |
 |  dbsize(self, **kwargs) -> 'int | Awaitable[int]'
 |      Returns the number of keys in the current database
 |
 |      For more information, see https://redis.io/commands/dbsize
 |
 |  debug_object(self, key: 'KeyT', **kwargs) -> 'dict[str, str | int] | bytes | str | Awaitable[dict[str, str | int] | bytes | str]'
 |      Returns version specific meta information about a given key
 |
 |      For more information, see https://redis.io/commands/debug-object
 |
 |  debug_segfault(self, **kwargs) -> 'None'
 |
 |  echo(self, value: 'EncodableT', **kwargs) -> 'bytes | str | Awaitable[bytes | str]'
 |      Echo the string back from the server
 |
 |      For more information, see https://redis.io/commands/echo
 |
 |  failover(self)
 |      This function throws a NotImplementedError since it is intentionally
 |      not supported.
 |
 |  flushall(self, asynchronous: 'bool' = False, **kwargs) -> 'bool | Awaitable[bool]'
 |      Delete all keys in all databases on the current host.
 |
 |      ``asynchronous`` indicates whether the operation is
 |      executed asynchronously by the server.
 |
 |      For more information, see https://redis.io/commands/flushall
 |
 |  flushdb(self, asynchronous: 'bool' = False, **kwargs) -> 'bool | Awaitable[bool]'
 |      Delete all keys in the current database.
 |
 |      ``asynchronous`` indicates whether the operation is
 |      executed asynchronously by the server.
 |
 |      For more information, see https://redis.io/commands/flushdb
 |
 |  hello(self)
 |      This function throws a NotImplementedError since it is intentionally
 |      not supported.
 |
 |  hotkeys_get(self, **kwargs) -> 'Union[Awaitable[list[dict[str | bytes, Any]]], list[dict[str | bytes, Any]]]'
 |      Retrieve the result of the ongoing collection session (if any),
 |      or the last collection session (if any).
 |
 |      HOTKEYS GET response is wrapped in an array for aggregation support.
 |      Each node returns a single-element array, allowing multiple node
 |      responses to be concatenated by DMC or other aggregators.
 |
 |      For more information, see https://redis.io/commands/hotkeys-get
 |
 |  hotkeys_reset(self, **kwargs) -> 'bytes | str | Awaitable[bytes | str]'
 |      Discard the last hotkeys collection session results (in order to save memory).
 |      Error if there is an ongoing collection session.
 |
 |      For more information, see https://redis.io/commands/hotkeys-reset
 |
 |  hotkeys_start(self, metrics: 'List[HotkeysMetricsTypes]', count: 'int | None' = None, duration: 'int | None' = None, sample_ratio: 'int | None' = None, slots: 'List[int] | None' = None, **kwargs) -> 'bytes | str | Awaitable[bytes | str]'
 |      Start collecting hotkeys data.
 |      Returns an error if there is an ongoing collection session.
 |
 |      Args:
 |          count: The number of keys to collect in each criteria (CPU and network consumption)
 |          metrics: List of metrics to track. Supported values: [HotkeysMetricsTypes.CPU, HotkeysMetricsTypes.NET]
 |          duration: Automatically stop the collection after `duration` seconds
 |          sample_ratio: Commands are sampled with probability 1/ratio (1 means no sampling)
 |          slots: Only track keys on the specified hash slots
 |
 |      For more information, see https://redis.io/commands/hotkeys-start
 |
 |  hotkeys_stop(self, **kwargs) -> 'bytes | str | Awaitable[bytes | str]'
 |      Stop the ongoing hotkeys collection session (if any).
 |      The results of the last collection session are kept for consumption with HOTKEYS GET.
 |
 |      For more information, see https://redis.io/commands/hotkeys-stop
 |
 |  info(self, section: 'Optional[str]' = None, *args: 'str', **kwargs) -> 'dict[str, Any] | Awaitable[dict[str, Any]]'
 |      Returns a dictionary containing information about the Redis server
 |
 |      The ``section`` option can be used to select a specific section
 |      of information
 |
 |      The section option is not supported by older versions of Redis Server,
 |      and will generate ResponseError
 |
 |      For more information, see https://redis.io/commands/info
 |
 |  lastsave(self, **kwargs) -> 'datetime.datetime | Awaitable[datetime.datetime]'
 |      Return a Python datetime object representing the last time the
 |      Redis database was saved to disk
 |
 |      For more information, see https://redis.io/commands/lastsave
 |
 |  latency_doctor(self)
 |      Raise a NotImplementedError, as the client will not support LATENCY DOCTOR.
 |      This function is best used within the redis-cli.
 |
 |      For more information, see https://redis.io/commands/latency-doctor
 |
 |  latency_graph(self)
 |      Raise a NotImplementedError, as the client will not support LATENCY GRAPH.
 |      This function is best used within the redis-cli.
 |
 |      For more information, see https://redis.io/commands/latency-graph.
 |
 |  latency_histogram(self, *args)
 |      This function throws a NotImplementedError since it is intentionally
 |      not supported.
 |
 |  latency_history(self, event: 'str') -> 'list[list[int]] | Awaitable[list[list[int]]]'
 |      Returns the raw data of the ``event``'s latency spikes time series.
 |
 |      For more information, see https://redis.io/commands/latency-history
 |
 |  latency_latest(self) -> 'list[list[bytes | str | int]] | Awaitable[list[list[bytes | str | int]]]'
 |      Reports the latest latency events logged.
 |
 |      For more information, see https://redis.io/commands/latency-latest
 |
 |  latency_reset(self, *events: 'str') -> 'int | Awaitable[int]'
 |      Resets the latency spikes time series of all, or only some, events.
 |
 |      For more information, see https://redis.io/commands/latency-reset
 |
 |  lolwut(self, *version_numbers: 'Union[str, float]', **kwargs) -> 'bytes | str | Awaitable[bytes | str]'
 |      Get the Redis version and a piece of generative computer art
 |
 |      See: https://redis.io/commands/lolwut
 |
 |  memory_doctor(self, **kwargs) -> 'None'
 |
 |  memory_help(self, **kwargs) -> 'None'
 |
 |  memory_malloc_stats(self, **kwargs) -> 'bytes | str | Awaitable[bytes | str]'
 |      Return an internal statistics report from the memory allocator.
 |
 |      See: https://redis.io/commands/memory-malloc-stats
 |
 |  memory_purge(self, **kwargs) -> 'bool | Awaitable[bool]'
 |      Attempts to purge dirty pages for reclamation by allocator
 |
 |      For more information, see https://redis.io/commands/memory-purge
 |
 |  memory_stats(self, **kwargs) -> 'dict[str, Any] | Awaitable[dict[str, Any]]'
 |      Return a dictionary of memory stats
 |
 |      For more information, see https://redis.io/commands/memory-stats
 |
 |  memory_usage(self, key: 'KeyT', samples: 'int | None' = None, **kwargs) -> 'int | None | Awaitable[int | None]'
 |      Return the total memory usage for key, its value and associated
 |      administrative overheads.
 |
 |      For nested data structures, ``samples`` is the number of elements to
 |      sample. If left unspecified, the server's default is 5. Use 0 to sample
 |      all elements.
 |
 |      For more information, see https://redis.io/commands/memory-usage
 |
 |  migrate(self, host: 'str', port: 'int', keys: 'KeysT', destination_db: 'int', timeout: 'int', copy: 'bool' = False, replace: 'bool' = False, auth: 'str | None' = None, **kwargs) -> 'bytes | str | Awaitable[bytes | str]'
 |      Migrate 1 or more keys from the current Redis server to a different
 |      server specified by the ``host``, ``port`` and ``destination_db``.
 |
 |      The ``timeout``, specified in milliseconds, indicates the maximum
 |      time the connection between the two servers can be idle before the
 |      command is interrupted.
 |
 |      If ``copy`` is True, the specified ``keys`` are NOT deleted from
 |      the source server.
 |
 |      If ``replace`` is True, this operation will overwrite the keys
 |      on the destination server if they exist.
 |
 |      If ``auth`` is specified, authenticate to the destination server with
 |      the password provided.
 |
 |      For more information, see https://redis.io/commands/migrate
 |
 |  object(self, infotype: 'str', key: 'KeyT', **kwargs) -> 'Any | Awaitable[Any]'
 |      Return the encoding, idletime, or refcount about the key
 |
 |  ping(self, **kwargs) -> 'Union[Awaitable[bool], bool]'
 |      Ping the Redis server to test connectivity.
 |
 |      Sends a PING command to the Redis server and returns True if the server
 |      responds with "PONG".
 |
 |      This command is useful for:
 |      - Testing whether a connection is still alive
 |      - Verifying the server's ability to serve data
 |
 |      For more information on the underlying ping command see https://redis.io/commands/ping
 |
 |  psync(self, replicationid: 'str', offset: 'int') -> 'bytes | Awaitable[bytes]'
 |      Initiates a replication stream from the master.
 |      Newer version for `sync`.
 |
 |      For more information, see https://redis.io/commands/sync
 |
 |  quit(self, **kwargs) -> 'bool | Awaitable[bool]'
 |      Ask the server to close the connection.
 |
 |      For more information, see https://redis.io/commands/quit
 |
 |  replicaof(self, *args, **kwargs) -> 'bytes | str | Awaitable[bytes | str]'
 |      Update the replication settings of a redis replica, on the fly.
 |
 |      Examples of valid arguments include:
 |
 |      NO ONE (set no replication)
 |      host port (set to the host and port of a redis server)
 |
 |      For more information, see  https://redis.io/commands/replicaof
 |
 |  reset(self) -> 'bytes | str | Awaitable[bytes | str]'
 |      Perform a full reset on the connection's server-side context.
 |
 |      See: https://redis.io/commands/reset
 |
 |  role(self) -> 'list[Any] | Awaitable[list[Any]]'
 |      Provide information on the role of a Redis instance in
 |      the context of replication, by returning if the instance
 |      is currently a master, slave, or sentinel.
 |
 |      For more information, see https://redis.io/commands/role
 |
 |  save(self, **kwargs) -> 'bool | Awaitable[bool]'
 |      Tell the Redis server to save its data to disk,
 |      blocking until the save is complete
 |
 |      For more information, see https://redis.io/commands/save
 |
 |  select(self, index: 'int', **kwargs) -> 'bool | Awaitable[bool]'
 |      Select the Redis logical database at index.
 |
 |      See: https://redis.io/commands/select
 |
 |  shutdown(self, save: 'bool' = False, nosave: 'bool' = False, now: 'bool' = False, force: 'bool' = False, abort: 'bool' = False, **kwargs) -> 'None'
 |      Shutdown the Redis server.  If Redis has persistence configured,
 |      data will be flushed before shutdown.
 |      It is possible to specify modifiers to alter the behavior of the command:
 |      ``save`` will force a DB saving operation even if no save points are configured.
 |      ``nosave`` will prevent a DB saving operation even if one or more save points
 |      are configured.
 |      ``now`` skips waiting for lagging replicas, i.e. it bypasses the first step in
 |      the shutdown sequence.
 |      ``force`` ignores any errors that would normally prevent the server from exiting
 |      ``abort`` cancels an ongoing shutdown and cannot be combined with other flags.
 |
 |      For more information, see https://redis.io/commands/shutdown
 |
 |  slaveof(self, host: 'str | None' = None, port: 'int | None' = None, **kwargs) -> 'bool | Awaitable[bool]'
 |      Set the server to be a replicated slave of the instance identified
 |      by the ``host`` and ``port``. If called without arguments, the
 |      instance is promoted to a master instead.
 |
 |      For more information, see https://redis.io/commands/slaveof
 |
 |  slowlog_get(self, num: 'int | None' = None, **kwargs) -> 'list[dict[str, Any]] | Awaitable[list[dict[str, Any]]]'
 |      Get the entries from the slowlog. If ``num`` is specified, get the
 |      most recent ``num`` items.
 |
 |      For more information, see https://redis.io/commands/slowlog-get
 |
 |  slowlog_len(self, **kwargs) -> 'int | Awaitable[int]'
 |      Get the number of items in the slowlog
 |
 |      For more information, see https://redis.io/commands/slowlog-len
 |
 |  slowlog_reset(self, **kwargs) -> 'bool | Awaitable[bool]'
 |      Remove all items in the slowlog
 |
 |      For more information, see https://redis.io/commands/slowlog-reset
 |
 |  swapdb(self, first: 'int', second: 'int', **kwargs) -> 'bool | Awaitable[bool]'
 |      Swap two databases
 |
 |      For more information, see https://redis.io/commands/swapdb
 |
 |  sync(self) -> 'bytes | Awaitable[bytes]'
 |      Initiates a replication stream from the master.
 |
 |      For more information, see https://redis.io/commands/sync
 |
 |  time(self, **kwargs) -> 'tuple[int, int] | Awaitable[tuple[int, int]]'
 |      Returns the server time as a 2-item tuple of ints:
 |      (seconds since epoch, microseconds into this second).
 |
 |      For more information, see https://redis.io/commands/time
 |
 |  wait(self, num_replicas: 'int', timeout: 'int', **kwargs) -> 'int | Awaitable[int]'
 |      Redis synchronous replication
 |      That returns the number of replicas that processed the query when
 |      we finally have at least ``num_replicas``, or when the ``timeout`` was
 |      reached.
 |
 |      For more information, see https://redis.io/commands/wait
 |
 |  waitaof(self, num_local: 'int', num_replicas: 'int', timeout: 'int', **kwargs) -> 'list[int] | Awaitable[list[int]]'
 |      This command blocks the current client until all previous write
 |      commands by that client are acknowledged as having been fsynced
 |      to the AOF of the local Redis and/or at least the specified number
 |      of replicas.
 |
 |      For more information, see https://redis.io/commands/waitaof
 |
 |  ----------------------------------------------------------------------
 |  Methods inherited from redis.commands.core.ModuleCommands:
 |
 |  command_getkeys(self, *args) -> 'list[bytes | str] | Awaitable[list[bytes | str]]'
 |
 |  module_list(self) -> 'list[dict[Any, Any]] | Awaitable[list[dict[Any, Any]]]'
 |      Returns a list of dictionaries containing the name and version of
 |      all loaded modules.
 |
 |      For more information, see https://redis.io/commands/module-list
 |
 |  module_load(self, path, *args) -> 'bool | Awaitable[bool]'
 |      Loads the module from ``path``.
 |      Passes all ``*args`` to the module, during loading.
 |      Raises ``ModuleError`` if a module is not found at ``path``.
 |
 |      For more information, see https://redis.io/commands/module-load
 |
 |  module_loadex(self, path: 'str', options: 'List[str] | None' = None, args: 'List[str] | None' = None) -> 'bytes | str | Awaitable[bytes | str]'
 |      Loads a module from a dynamic library at runtime with configuration directives.
 |
 |      For more information, see https://redis.io/commands/module-loadex
 |
 |  module_unload(self, name) -> 'bool | Awaitable[bool]'
 |      Unloads the module ``name``.
 |      Raises ``ModuleError`` if ``name`` is not in loaded modules.
 |
 |      For more information, see https://redis.io/commands/module-unload
 |
 |  ----------------------------------------------------------------------
 |  Methods inherited from redis.commands.core.PubSubCommands:
 |
 |  publish(self, channel: 'ChannelT', message: 'EncodableT', **kwargs) -> 'int | Awaitable[int]'
 |      Publish ``message`` on ``channel``.
 |      Returns the number of subscribers the message was delivered to.
 |
 |      For more information, see https://redis.io/commands/publish
 |
 |  pubsub_channels(self, pattern: 'PatternT' = '*', **kwargs) -> 'list[bytes | str] | Awaitable[list[bytes | str]]'
 |      Return a list of channels that have at least one subscriber
 |
 |      For more information, see https://redis.io/commands/pubsub-channels
 |
 |  pubsub_numpat(self, **kwargs) -> 'int | Awaitable[int]'
 |      Returns the number of subscriptions to patterns
 |
 |      For more information, see https://redis.io/commands/pubsub-numpat
 |
 |  pubsub_numsub(self, *args: 'ChannelT', **kwargs) -> 'list[tuple[bytes | str, int]] | Awaitable[list[tuple[bytes | str, int]]]'
 |      Return a list of (channel, number of subscribers) tuples
 |      for each channel given in ``*args``
 |
 |      For more information, see https://redis.io/commands/pubsub-numsub
 |
 |  pubsub_shardchannels(self, pattern: 'PatternT' = '*', **kwargs) -> 'list[bytes | str] | Awaitable[list[bytes | str]]'
 |      Return a list of shard_channels that have at least one subscriber
 |
 |      For more information, see https://redis.io/commands/pubsub-shardchannels
 |
 |  pubsub_shardnumsub(self, *args: 'ChannelT', **kwargs) -> 'list[tuple[bytes | str, int]] | Awaitable[list[tuple[bytes | str, int]]]'
 |      Return a list of (shard_channel, number of subscribers) tuples
 |      for each channel given in ``*args``
 |
 |      For more information, see https://redis.io/commands/pubsub-shardnumsub
 |
 |  spublish(self, shard_channel: 'ChannelT', message: 'EncodableT') -> 'int | Awaitable[int]'
 |      Posts a message to the given shard channel.
 |      Returns the number of clients that received the message
 |
 |      For more information, see https://redis.io/commands/spublish
 |
 |  ----------------------------------------------------------------------
 |  Methods inherited from redis.commands.core.ScriptCommands:
 |
 |  eval(self, script: 'str', numkeys: 'int', *keys_and_args: 'KeyT | EncodableT') -> 'Any | Awaitable[Any]'
 |      Execute the Lua ``script``, specifying the ``numkeys`` the script
 |      will touch and the key names and argument values in ``keys_and_args``.
 |      Returns the result of the script.
 |
 |      In practice, use the object returned by ``register_script``. This
 |      function exists purely for Redis API completion.
 |
 |      For more information, see  https://redis.io/commands/eval
 |
 |  eval_ro(self, script: 'str', numkeys: 'int', *keys_and_args: 'KeyT | EncodableT') -> 'Any | Awaitable[Any]'
 |      The read-only variant of the EVAL command
 |
 |      Execute the read-only Lua ``script`` specifying the ``numkeys`` the script
 |      will touch and the key names and argument values in ``keys_and_args``.
 |      Returns the result of the script.
 |
 |      For more information, see  https://redis.io/commands/eval_ro
 |
 |  evalsha(self, sha: 'str', numkeys: 'int', *keys_and_args: 'KeyT | EncodableT') -> 'Any | Awaitable[Any]'
 |      Use the ``sha`` to execute a Lua script already registered via EVAL
 |      or SCRIPT LOAD. Specify the ``numkeys`` the script will touch and the
 |      key names and argument values in ``keys_and_args``. Returns the result
 |      of the script.
 |
 |      In practice, use the object returned by ``register_script``. This
 |      function exists purely for Redis API completion.
 |
 |      For more information, see  https://redis.io/commands/evalsha
 |
 |  evalsha_ro(self, sha: 'str', numkeys: 'int', *keys_and_args: 'KeyT | EncodableT') -> 'Any | Awaitable[Any]'
 |      The read-only variant of the EVALSHA command
 |
 |      Use the ``sha`` to execute a read-only Lua script already registered via EVAL
 |      or SCRIPT LOAD. Specify the ``numkeys`` the script will touch and the
 |      key names and argument values in ``keys_and_args``. Returns the result
 |      of the script.
 |
 |      For more information, see  https://redis.io/commands/evalsha_ro
 |
 |  register_script(self: "Union['redis.client.Redis', 'redis.cluster.RedisCluster']", script: 'ScriptTextT') -> 'Script'
 |      Register a Lua ``script`` specifying the ``keys`` it will touch.
 |      Returns a Script object that is callable and hides the complexity of
 |      deal with scripts, keys, and shas. This is the preferred way to work
 |      with Lua scripts.
 |
 |  script_debug(self, *args) -> 'None'
 |
 |  script_exists(self, *args: 'str') -> 'list[bool] | Awaitable[list[bool]]'
 |      Check if a script exists in the script cache by specifying the SHAs of
 |      each script as ``args``. Returns a list of boolean values indicating if
 |      if each already script exists in the cache_data.
 |
 |      For more information, see  https://redis.io/commands/script-exists
 |
 |  script_flush(self, sync_type: "Literal['SYNC'] | Literal['ASYNC'] | None" = None) -> 'bool | Awaitable[bool]'
 |      Flush all scripts from the script cache_data.
 |
 |      ``sync_type`` is by default SYNC (synchronous) but it can also be
 |                    ASYNC.
 |
 |      For more information, see  https://redis.io/commands/script-flush
 |
 |  script_kill(self) -> 'bool | Awaitable[bool]'
 |      Kill the currently executing Lua script
 |
 |      For more information, see https://redis.io/commands/script-kill
 |
 |  script_load(self, script: 'ScriptTextT') -> 'str | Awaitable[str]'
 |      Load a Lua ``script`` into the script cache_data. Returns the SHA.
 |
 |      For more information, see https://redis.io/commands/script-load
 |
 |  ----------------------------------------------------------------------
 |  Data and other attributes inherited from redis.typing.CommandsProtocol:
 |
 |  __protocol_attrs__ = {'_event_dispatcher', 'execute_command'}
 |
 |  ----------------------------------------------------------------------
 |  Class methods inherited from typing.Protocol:
 |
 |  __init_subclass__(*args, **kwargs)
 |      This method is called when a class is subclassed.
 |
 |      The default implementation does nothing. It may be
 |      overridden to extend subclasses.
 |
 |  ----------------------------------------------------------------------
 |  Class methods inherited from typing.Generic:
 |
 |  __class_getitem__(...)
 |      Parameterizes a generic class.
 |
 |      At least, parameterizing a generic class is the *main* thing this
 |      method does. For example, for some generic class `Foo`, this is called
 |      when we do `Foo[int]` - there, with `cls=Foo` and `params=int`.
 |
 |      However, note that this method is also called when defining generic
 |      classes in the first place with `class Foo[T]: ...`.
 |
 |  ----------------------------------------------------------------------
 |  Methods inherited from redis.commands.core.FunctionCommands:
 |
 |  fcall(self, function, numkeys: 'int', *keys_and_args: 'Any') -> 'Any | Awaitable[Any]'
 |      Invoke a function.
 |
 |      For more information, see https://redis.io/commands/fcall
 |
 |  fcall_ro(self, function, numkeys: 'int', *keys_and_args: 'Any') -> 'Any | Awaitable[Any]'
 |      This is a read-only variant of the FCALL command that cannot
 |      execute commands that modify data.
 |
 |      For more information, see https://redis.io/commands/fcall_ro
 |
 |  function_delete(self, library: 'str') -> 'bool | Awaitable[bool]'
 |      Delete the library called ``library`` and all its functions.
 |
 |      For more information, see https://redis.io/commands/function-delete
 |
 |  function_dump(self) -> 'bytes | Awaitable[bytes]'
 |      Return the serialized payload of loaded libraries.
 |
 |      For more information, see https://redis.io/commands/function-dump
 |
 |  function_flush(self, mode: 'str' = 'SYNC') -> 'bool | Awaitable[bool]'
 |      Deletes all the libraries.
 |
 |      For more information, see https://redis.io/commands/function-flush
 |
 |  function_kill(self) -> 'bytes | str | Awaitable[bytes | str]'
 |      Kill a function that is currently executing.
 |
 |      For more information, see https://redis.io/commands/function-kill
 |
 |  function_list(self, library: 'str | None' = '*', withcode: 'bool | None' = False) -> 'list[Any] | Awaitable[list[Any]]'
 |      Return information about the functions and libraries.
 |
 |      Args:
 |
 |          library: specify a pattern for matching library names
 |          withcode: cause the server to include the libraries source implementation
 |              in the reply
 |
 |  function_load(self, code: 'str', replace: 'bool | None' = False) -> 'bytes | str | Awaitable[bytes | str]'
 |      Load a library to Redis.
 |      :param code: the source code (must start with
 |      Shebang statement that provides a metadata about the library)
 |      :param replace: changes the behavior to overwrite the existing library
 |      with the new contents.
 |      Return the library name that was loaded.
 |
 |      For more information, see https://redis.io/commands/function-load
 |
 |  function_restore(self, payload: 'str', policy: 'str | None' = 'APPEND') -> 'bool | Awaitable[bool]'
 |      Restore libraries from the serialized ``payload``.
 |      You can use the optional policy argument to provide a policy
 |      for handling existing libraries.
 |
 |      For more information, see https://redis.io/commands/function-restore
 |
 |  function_stats(self) -> 'Any | Awaitable[Any]'
 |      Return information about the function that's currently running
 |      and information about the available execution engines.
 |
 |      For more information, see https://redis.io/commands/function-stats
 |
 |  ----------------------------------------------------------------------
 |  Methods inherited from redis.commands.sentinel.SentinelCommands:
 |
 |  sentinel(self, *args)
 |      Redis Sentinel's SENTINEL command.
 |
 |  sentinel_ckquorum(self, new_master_name) -> Union[bool, Awaitable[bool]]
 |      Check if the current Sentinel configuration is able to reach the
 |      quorum needed to failover a master, and the majority needed to
 |      authorize the failover.
 |
 |      This command should be used in monitoring systems to check if a
 |      Sentinel deployment is ok.
 |
 |  sentinel_failover(self, new_master_name) -> Union[bool, Awaitable[bool]]
 |      Force a failover as if the master was not reachable, and without
 |      asking for agreement to other Sentinels (however a new version of the
 |      configuration will be published so that the other Sentinels will
 |      update their configurations).
 |
 |  sentinel_flushconfig(self) -> Union[bool, Awaitable[bool]]
 |      Force Sentinel to rewrite its configuration on disk, including the
 |      current Sentinel state.
 |
 |      Normally Sentinel rewrites the configuration every time something
 |      changes in its state (in the context of the subset of the state which
 |      is persisted on disk across restart).
 |      However sometimes it is possible that the configuration file is lost
 |      because of operation errors, disk failures, package upgrade scripts or
 |      configuration managers. In those cases a way to to force Sentinel to
 |      rewrite the configuration file is handy.
 |
 |      This command works even if the previous configuration file is
 |      completely missing.
 |
 |  sentinel_get_master_addr_by_name(self, service_name, return_responses: bool = False) -> Union[tuple[bytes | str, int], NoneType, bool, Awaitable[tuple[bytes | str, int] | None | bool]]
 |      Returns a (host, port) pair for the given ``service_name`` when return_responses is True,
 |      otherwise returns a boolean value that indicates if the command was successful.
 |
 |  sentinel_master(self, service_name, return_responses: bool = False) -> Union[dict[str, Any], bool, Awaitable[dict[str, Any] | bool]]
 |      Returns a dictionary containing the specified masters state, when return_responses is True,
 |      otherwise returns a boolean value that indicates if the command was successful.
 |
 |  sentinel_masters(self) -> Union[dict[str, dict[str, Any]], list[dict[str, Any]], Awaitable[dict[str, dict[str, Any]] | list[dict[str, Any]]]]
 |      Returns a list of dictionaries containing each master's state.
 |
 |      Important: This function is called by the Sentinel implementation and is
 |      called directly on the Redis standalone client for sentinels,
 |      so it doesn't support the "once" and "return_responses" options.
 |
 |  sentinel_monitor(self, name, ip, port, quorum) -> Union[bool, Awaitable[bool]]
 |      Add a new master to Sentinel to be monitored
 |
 |  sentinel_remove(self, name) -> Union[bool, Awaitable[bool]]
 |      Remove a master from Sentinel's monitoring
 |
 |  sentinel_reset(self, pattern) -> Union[bool, Awaitable[bool]]
 |      This command will reset all the masters with matching name.
 |      The pattern argument is a glob-style pattern.
 |
 |      The reset process clears any previous state in a master (including a
 |      failover in progress), and removes every slave and sentinel already
 |      discovered and associated with the master.
 |
 |  sentinel_sentinels(self, service_name, return_responses: bool = False) -> Union[list[dict[str, Any]], bool, Awaitable[list[dict[str, Any]] | bool]]
 |      Returns a list of sentinels for ``service_name``, when return_responses is True,
 |      otherwise returns a boolean value that indicates if the command was successful.
 |
 |  sentinel_set(self, name, option, value) -> Union[bool, Awaitable[bool]]
 |      Set Sentinel monitoring parameters for a given master
 |
 |  sentinel_slaves(self, service_name) -> Union[list[dict[str, Any]], Awaitable[list[dict[str, Any]]]]
 |      Returns a list of slaves for ``service_name``
 |
 |      Important: This function is called by the Sentinel implementation and is
 |      called directly on the Redis standalone client for sentinels,
 |      so it doesn't support the "once" and "return_responses" options.

Python Library Documentation: class SubkeyeventChannel in module redis.keyspace_notifications

class SubkeyeventChannel(builtins.object)
 |  SubkeyeventChannel(event: 'str', db: 'int' = 0)
 |
 |  Represents a subkeyevent notification channel for subscribing to
 |  specific event types with subkey-level detail.
 |
 |  The channel format is ``__subkeyevent@<db>__:<event>``.
 |  The message payload is ``<key_len>:<key>|<subkey_len>:<subkey>[,...]``.
 |
 |  Examples:
 |      >>> channel = SubkeyeventChannel("hdel", db=0)
 |      >>> str(channel)
 |      '__subkeyevent@0__:hdel'
 |
 |  Methods defined here:
 |
 |  __eq__(self, other: 'object') -> 'bool'
 |      Return self==value.
 |
 |  __hash__(self) -> 'int'
 |      Return hash(self).
 |
 |  __init__(self, event: 'str', db: 'int' = 0)
 |      Initialize self.  See help(type(self)) for accurate signature.
 |
 |  __repr__(self) -> 'str'
 |      Return repr(self).
 |
 |  __str__(self) -> 'str'
 |      Return str(self).
 |
 |  ----------------------------------------------------------------------
 |  Class methods defined here:
 |
 |  all_events(db: 'int' = 0) -> 'SubkeyeventChannel'
 |      Create a channel for all subkeyevent types.
 |
 |  ----------------------------------------------------------------------
 |  Readonly properties defined here:
 |
 |  is_pattern
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors defined here:
 |
 |  __dict__
 |      dictionary for instance variables
 |
 |  __weakref__
 |      list of weak references to the object
 |
 |  ----------------------------------------------------------------------
 |  Data and other attributes defined here:
 |
 |  PREFIX = '__subkeyevent@'
 |
 |  __annotations__ = {'PREFIX': 'ClassVar[str]'}

Python Library Documentation: class SubkeyspaceChannel in module redis.keyspace_notifications

class SubkeyspaceChannel(builtins.object)
 |  SubkeyspaceChannel(key_or_pattern: 'str', db: 'int' = 0)
 |
 |  Represents a subkeyspace notification channel for subscribing to
 |  subkey-level events on keys (e.g., hash field changes).
 |
 |  The channel format is ``__subkeyspace@<db>__:<key>``.
 |  The message payload is ``<event>|<subkey_len>:<subkey>[,...]``.
 |
 |  Examples:
 |      >>> channel = SubkeyspaceChannel("myhash", db=0)
 |      >>> str(channel)
 |      '__subkeyspace@0__:myhash'
 |
 |  Methods defined here:
 |
 |  __eq__(self, other: 'object') -> 'bool'
 |      Return self==value.
 |
 |  __hash__(self) -> 'int'
 |      Return hash(self).
 |
 |  __init__(self, key_or_pattern: 'str', db: 'int' = 0)
 |      Initialize self.  See help(type(self)) for accurate signature.
 |
 |  __repr__(self) -> 'str'
 |      Return repr(self).
 |
 |  __str__(self) -> 'str'
 |      Return str(self).
 |
 |  ----------------------------------------------------------------------
 |  Readonly properties defined here:
 |
 |  is_pattern
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors defined here:
 |
 |  __dict__
 |      dictionary for instance variables
 |
 |  __weakref__
 |      list of weak references to the object
 |
 |  ----------------------------------------------------------------------
 |  Data and other attributes defined here:
 |
 |  PREFIX = '__subkeyspace@'
 |
 |  __annotations__ = {'PREFIX': 'ClassVar[str]'}

Python Library Documentation: class SubkeyspaceeventChannel in module redis.keyspace_notifications

class SubkeyspaceeventChannel(builtins.object)
 |  SubkeyspaceeventChannel(event: 'str', key_or_pattern: 'str', db: 'int' = 0)
 |
 |  Represents a subkeyspaceevent notification channel for subscribing to
 |  a specific event on a specific key, receiving affected subkeys.
 |
 |  The channel format is ``__subkeyspaceevent@<db>__:<event>|<key>``.
 |  The message payload is a length-prefixed subkey list.
 |
 |  Examples:
 |      >>> channel = SubkeyspaceeventChannel("hset", "myhash", db=0)
 |      >>> str(channel)
 |      '__subkeyspaceevent@0__:hset|myhash'
 |
 |  Methods defined here:
 |
 |  __eq__(self, other: 'object') -> 'bool'
 |      Return self==value.
 |
 |  __hash__(self) -> 'int'
 |      Return hash(self).
 |
 |  __init__(self, event: 'str', key_or_pattern: 'str', db: 'int' = 0)
 |      Initialize self.  See help(type(self)) for accurate signature.
 |
 |  __repr__(self) -> 'str'
 |      Return repr(self).
 |
 |  __str__(self) -> 'str'
 |      Return str(self).
 |
 |  ----------------------------------------------------------------------
 |  Readonly properties defined here:
 |
 |  is_pattern
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors defined here:
 |
 |  __dict__
 |      dictionary for instance variables
 |
 |  __weakref__
 |      list of weak references to the object
 |
 |  ----------------------------------------------------------------------
 |  Data and other attributes defined here:
 |
 |  PREFIX = '__subkeyspaceevent@'
 |
 |  __annotations__ = {'PREFIX': 'ClassVar[str]'}

Python Library Documentation: class SubkeyspaceitemChannel in module redis.keyspace_notifications

class SubkeyspaceitemChannel(builtins.object)
 |  SubkeyspaceitemChannel(key_or_pattern: 'str', subkey_or_pattern: 'str', db: 'int' = 0)
 |
 |  Represents a subkeyspaceitem notification channel for subscribing to
 |  events on a specific subkey (field) of a specific key.
 |
 |  The channel format is ``__subkeyspaceitem@<db>__:<key>\n<subkey>``.
 |  The message payload is the event type (e.g., ``"hset"``).
 |
 |  Note:
 |      The server only emits this notification when the key does not
 |      contain a newline character.
 |
 |  Examples:
 |      >>> channel = SubkeyspaceitemChannel("myhash", "myfield", db=0)
 |      >>> str(channel)
 |      '__subkeyspaceitem@0__:myhash\nmyfield'
 |
 |  Methods defined here:
 |
 |  __eq__(self, other: 'object') -> 'bool'
 |      Return self==value.
 |
 |  __hash__(self) -> 'int'
 |      Return hash(self).
 |
 |  __init__(self, key_or_pattern: 'str', subkey_or_pattern: 'str', db: 'int' = 0)
 |      Initialize self.  See help(type(self)) for accurate signature.
 |
 |  __repr__(self) -> 'str'
 |      Return repr(self).
 |
 |  __str__(self) -> 'str'
 |      Return str(self).
 |
 |  ----------------------------------------------------------------------
 |  Readonly properties defined here:
 |
 |  is_pattern
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors defined here:
 |
 |  __dict__
 |      dictionary for instance variables
 |
 |  __weakref__
 |      list of weak references to the object
 |
 |  ----------------------------------------------------------------------
 |  Data and other attributes defined here:
 |
 |  PREFIX = '__subkeyspaceitem@'
 |
 |  __annotations__ = {'PREFIX': 'ClassVar[str]'}

Python Library Documentation: class Subscription in module redis.typing

class Subscription(builtins.object)
 |  Subscription(name: Union[bytes, str, memoryview], handler: Optional[Callable[[dict[str, Any]], Any]] = None) -> None
 |
 |  PubSub channel or pattern subscription with an optional handler.
 |
 |  Methods defined here:
 |
 |  __delattr__(self, name)
 |      Implement delattr(self, name).
 |
 |  __eq__(self, other)
 |      Return self==value.
 |
 |  __hash__(self)
 |      Return hash(self).
 |
 |  __init__(self, name: Union[bytes, str, memoryview], handler: Optional[Callable[[dict[str, Any]], Any]] = None) -> None
 |      Initialize self.  See help(type(self)) for accurate signature.
 |
 |  __repr__(self)
 |      Return repr(self).
 |
 |  __setattr__(self, name, value)
 |      Implement setattr(self, name, value).
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors defined here:
 |
 |  __dict__
 |      dictionary for instance variables
 |
 |  __weakref__
 |      list of weak references to the object
 |
 |  ----------------------------------------------------------------------
 |  Data and other attributes defined here:
 |
 |  __annotations__ = {'handler': typing.Optional[typing.Callable[[dict[st...
 |
 |  __dataclass_fields__ = {'handler': Field(name='handler',type=typing.Op...
 |
 |  __dataclass_params__ = _DataclassParams(init=True,repr=True,eq=True,or...
 |
 |  __match_args__ = ('name', 'handler')
 |
 |  handler = None

Python Library Documentation: class TimeoutError in module redis.exceptions

class TimeoutError(RedisError)
 |  TimeoutError(*args, status_code: str | None = None)
 |
 |  Method resolution order:
 |      TimeoutError
 |      RedisError
 |      builtins.Exception
 |      builtins.BaseException
 |      builtins.object
 |
 |  Methods defined here:
 |
 |  __init__(self, *args, status_code: str | None = None)
 |      Initialize self.  See help(type(self)) for accurate signature.
 |
 |  ----------------------------------------------------------------------
 |  Methods inherited from RedisError:
 |
 |  __repr__(self)
 |      Return repr(self).
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from RedisError:
 |
 |  __weakref__
 |      list of weak references to the object
 |
 |  ----------------------------------------------------------------------
 |  Static methods inherited from builtins.Exception:
 |
 |  __new__(*args, **kwargs) class method of builtins.Exception
 |      Create and return a new object.  See help(type) for accurate signature.
 |
 |  ----------------------------------------------------------------------
 |  Methods inherited from builtins.BaseException:
 |
 |  __getattribute__(self, name, /)
 |      Return getattr(self, name).
 |
 |  __reduce__(...)
 |      Helper for pickle.
 |
 |  __setstate__(...)
 |
 |  __str__(self, /)
 |      Return str(self).
 |
 |  add_note(...)
 |      Exception.add_note(note) --
 |      add a note to the exception
 |
 |  with_traceback(...)
 |      Exception.with_traceback(tb) --
 |      set self.__traceback__ to tb and return self.
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from builtins.BaseException:
 |
 |  __cause__
 |      exception cause
 |
 |  __context__
 |      exception context
 |
 |  __dict__
 |
 |  __suppress_context__
 |
 |  __traceback__
 |
 |  args

Python Library Documentation: class UnixDomainSocketConnection in module redis.connection

class UnixDomainSocketConnection(AbstractConnection)
 |  UnixDomainSocketConnection(path='', socket_timeout=5, **kwargs)
 |
 |  Manages UDS communication to and from a Redis server
 |
 |  Method resolution order:
 |      UnixDomainSocketConnection
 |      AbstractConnection
 |      MaintNotificationsAbstractConnection
 |      ConnectionInterface
 |      builtins.object
 |
 |  Methods defined here:
 |
 |  __init__(self, path='', socket_timeout=5, **kwargs)
 |      Initialize a new Connection.
 |
 |      To specify a retry policy for specific errors, first set
 |      `retry_on_error` to a list of the error/s to retry on, then set
 |      `retry` to a valid `Retry` object.
 |      To retry on TimeoutError, `retry_on_timeout` can also be set to `True`.
 |
 |      Parameters
 |      ----------
 |      driver_info : DriverInfo, optional
 |          Driver metadata for CLIENT SETINFO. If provided, lib_name and lib_version
 |          are ignored. If not provided, a DriverInfo will be created from lib_name
 |          and lib_version. Explicit None disables CLIENT SETINFO.
 |      lib_name : str, optional
 |          **Deprecated.** Use driver_info instead. Library name for CLIENT SETINFO.
 |      lib_version : str, optional
 |          **Deprecated.** Use driver_info instead. Library version for CLIENT SETINFO.
 |
 |  repr_pieces(self)
 |
 |  ----------------------------------------------------------------------
 |  Methods inherited from AbstractConnection:
 |
 |  __del__(self)
 |
 |  __repr__(self)
 |      Return repr(self).
 |
 |  can_read(self, timeout: float = 0) -> bool
 |      Poll the socket to see if there's data that can be read.
 |
 |  check_health(self)
 |      Check the health of the connection with a PING/PONG
 |
 |  connect(self)
 |      Connects to the Redis server if not already connected
 |
 |  connect_check_health(self, check_health: bool = True, retry_socket_connect: bool = True)
 |
 |  deregister_connect_callback(self, callback)
 |      De-register a previously registered callback.  It will no-longer receive
 |      notifications on connection events.  Calling this is not required when the
 |      listener goes away, since the callbacks are kept as weak methods.
 |
 |  disconnect(self, *args, **kwargs)
 |      Disconnects from the Redis server
 |
 |  extract_connection_details(self) -> str
 |
 |  get_protocol(self) -> Union[int, str]
 |      Returns:
 |          The RESP protocol version, or ``None`` if the protocol is not specified,
 |          in which case the server default will be used.
 |
 |  mark_for_reconnect(self)
 |      Mark the connection to be reconnected on the next command.
 |      This is useful when a connection is moved to a different node.
 |
 |  on_connect(self)
 |
 |  on_connect_check_health(self, check_health: bool = True)
 |      Initialize the connection, authenticate and select a database
 |
 |  pack_command(self, *args)
 |      Pack a series of arguments into the Redis protocol
 |
 |  pack_commands(self, commands)
 |      Pack multiple commands into the Redis protocol
 |
 |  re_auth(self)
 |
 |  read_response(self, disable_decoding=False, *, timeout: Union[float, object] = <object object at 0x0000017B991493E0>, disconnect_on_error=True, push_request=False)
 |      Read the response from a previously sent command
 |
 |  register_connect_callback(self, callback)
 |      Register a callback to be called when the connection is established either
 |      initially or reconnected.  This allows listeners to issue commands that
 |      are ephemeral to the connection, for example pub/sub subscription or
 |      key tracking.  The callback must be a _method_ and will be kept as
 |      a weak reference.
 |
 |  reset_should_reconnect(self)
 |      Reset the internal flag to False.
 |
 |  send_command(self, *args, **kwargs)
 |      Pack and send a command to the Redis server
 |
 |  send_packed_command(self, command, check_health=True)
 |      Send an already packed command to the Redis server
 |
 |  set_parser(self, parser_class)
 |      Creates a new instance of parser_class with socket size:
 |      _socket_read_size and assigns it to the parser for the connection
 |      :param parser_class: The required parser class
 |
 |  set_re_auth_token(self, token: redis.auth.token.TokenInterface)
 |
 |  should_reconnect(self)
 |      Returns True if the connection should be reconnected.
 |
 |  ----------------------------------------------------------------------
 |  Readonly properties inherited from AbstractConnection:
 |
 |  is_connected
 |      Return ``True`` if the connection to the server is active.
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from AbstractConnection:
 |
 |  handshake_metadata
 |
 |  socket_connect_timeout
 |
 |  socket_timeout
 |
 |  ----------------------------------------------------------------------
 |  Methods inherited from MaintNotificationsAbstractConnection:
 |
 |  activate_maint_notifications_handling_if_enabled(self, check_health=True)
 |
 |  add_maint_start_notification(self, id: int)
 |
 |  add_skipped_end_notification(self, id: int)
 |
 |  get_processed_start_notifications(self) -> set
 |
 |  get_resolved_ip(self) -> Optional[str]
 |      Extract the resolved IP address from an
 |      established connection or resolve it from the host.
 |
 |      First tries to get the actual IP from the socket (most accurate),
 |      then falls back to DNS resolution if needed.
 |
 |      Returns:
 |          str: The resolved IP address, or None if it cannot be determined
 |
 |  get_skipped_end_notifications(self) -> set
 |
 |  getpeername(self)
 |      Returns the peer name of the connection.
 |
 |  reset_received_notifications(self)
 |
 |  reset_tmp_settings(self, reset_host_address: bool = False, reset_relaxed_timeout: bool = False)
 |
 |  set_maint_notifications_cluster_handler_for_connection(self, oss_cluster_maint_notifications_handler: redis.maint_notifications.OSSMaintNotificationsHandler)
 |
 |  set_maint_notifications_pool_handler_for_connection(self, maint_notifications_pool_handler: redis.maint_notifications.MaintNotificationsPoolHandler)
 |
 |  set_tmp_settings(self, tmp_host_address: Union[str, object, NoneType] = <object object at 0x0000017B991493E0>, tmp_relaxed_timeout: Optional[float] = -1)
 |      SENTINEL keeps the host unchanged. -1 keeps the relaxed timeout unchanged.
 |
 |  update_current_socket_timeout(self, relaxed_timeout: Optional[float] = None)
 |
 |  update_parser_timeout(self, timeout: Optional[float] = None)
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from MaintNotificationsAbstractConnection:
 |
 |  __dict__
 |      dictionary for instance variables
 |
 |  __weakref__
 |      list of weak references to the object
 |
 |  host
 |
 |  maintenance_state

Python Library Documentation: class UsernamePasswordCredentialProvider in module redis.credentials

class UsernamePasswordCredentialProvider(CredentialProvider)
 |  UsernamePasswordCredentialProvider(username: Optional[str] = None, password: Optional[str] = None)
 |
 |  Simple implementation of CredentialProvider that just wraps static
 |  username and password.
 |
 |  Method resolution order:
 |      UsernamePasswordCredentialProvider
 |      CredentialProvider
 |      builtins.object
 |
 |  Methods defined here:
 |
 |  __init__(self, username: Optional[str] = None, password: Optional[str] = None)
 |      Initialize self.  See help(type(self)) for accurate signature.
 |
 |  get_credentials(self)
 |
 |  async get_credentials_async(self) -> Union[Tuple[str], Tuple[str, str]]
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from CredentialProvider:
 |
 |  __dict__
 |      dictionary for instance variables
 |
 |  __weakref__
 |      list of weak references to the object

Python Library Documentation: tuple object

class tuple(object)
 |  tuple(iterable=(), /)
 |
 |  Built-in immutable sequence.
 |
 |  If no argument is given, the constructor returns an empty tuple.
 |  If iterable is specified the tuple is initialized from iterable's items.
 |
 |  If the argument is a tuple, the return value is the same object.
 |
 |  Built-in subclasses:
 |      asyncgen_hooks
 |      UnraisableHookArgs
 |
 |  Methods defined here:
 |
 |  __add__(self, value, /)
 |      Return self+value.
 |
 |  __contains__(self, key, /)
 |      Return bool(key in self).
 |
 |  __eq__(self, value, /)
 |      Return self==value.
 |
 |  __ge__(self, value, /)
 |      Return self>=value.
 |
 |  __getattribute__(self, name, /)
 |      Return getattr(self, name).
 |
 |  __getitem__(self, key, /)
 |      Return self[key].
 |
 |  __getnewargs__(self, /)
 |
 |  __gt__(self, value, /)
 |      Return self>value.
 |
 |  __hash__(self, /)
 |      Return hash(self).
 |
 |  __iter__(self, /)
 |      Implement iter(self).
 |
 |  __le__(self, value, /)
 |      Return self<=value.
 |
 |  __len__(self, /)
 |      Return len(self).
 |
 |  __lt__(self, value, /)
 |      Return self<value.
 |
 |  __mul__(self, value, /)
 |      Return self*value.
 |
 |  __ne__(self, value, /)
 |      Return self!=value.
 |
 |  __repr__(self, /)
 |      Return repr(self).
 |
 |  __rmul__(self, value, /)
 |      Return value*self.
 |
 |  count(self, value, /)
 |      Return number of occurrences of value.
 |
 |  index(self, value, start=0, stop=9223372036854775807, /)
 |      Return first index of value.
 |
 |      Raises ValueError if the value is not present.
 |
 |  ----------------------------------------------------------------------
 |  Class methods defined here:
 |
 |  __class_getitem__(...)
 |      See PEP 585
 |
 |  ----------------------------------------------------------------------
 |  Static methods defined here:
 |
 |  __new__(*args, **kwargs)
 |      Create and return a new object.  See help(type) for accurate signature.

Python Library Documentation: class WatchError in module redis.exceptions

class WatchError(RedisError)
 |  WatchError(*args, status_code: str | None = None)
 |
 |  Method resolution order:
 |      WatchError
 |      RedisError
 |      builtins.Exception
 |      builtins.BaseException
 |      builtins.object
 |
 |  Methods inherited from RedisError:
 |
 |  __init__(self, *args, status_code: str | None = None)
 |      Initialize self.  See help(type(self)) for accurate signature.
 |
 |  __repr__(self)
 |      Return repr(self).
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from RedisError:
 |
 |  __weakref__
 |      list of weak references to the object
 |
 |  ----------------------------------------------------------------------
 |  Static methods inherited from builtins.Exception:
 |
 |  __new__(*args, **kwargs) class method of builtins.Exception
 |      Create and return a new object.  See help(type) for accurate signature.
 |
 |  ----------------------------------------------------------------------
 |  Methods inherited from builtins.BaseException:
 |
 |  __getattribute__(self, name, /)
 |      Return getattr(self, name).
 |
 |  __reduce__(...)
 |      Helper for pickle.
 |
 |  __setstate__(...)
 |
 |  __str__(self, /)
 |      Return str(self).
 |
 |  add_note(...)
 |      Exception.add_note(note) --
 |      add a note to the exception
 |
 |  with_traceback(...)
 |      Exception.with_traceback(tb) --
 |      set self.__traceback__ to tb and return self.
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from builtins.BaseException:
 |
 |  __cause__
 |      exception cause
 |
 |  __context__
 |      exception context
 |
 |  __dict__
 |
 |  __suppress_context__
 |
 |  __traceback__
 |
 |  args

Python Library Documentation: package redis.asyncio in redis

NAME
    redis.asyncio

PACKAGE CONTENTS
    _himport_exec
    client
    cluster
    connection
    http (package)
    keyspace_notifications
    lock
    maint_notifications
    multidb (package)
    observability (package)
    retry
    sentinel
    utils

CLASSES
    abc.ABC(builtins.object)
        redis.asyncio.keyspace_notifications.AsyncKeyspaceNotificationsInterface
    builtins.Exception(builtins.BaseException)
        redis.exceptions.ChildDeadlockedError
        redis.exceptions.RedisError
            redis.exceptions.ConnectionError
                redis.exceptions.AuthenticationError
                redis.exceptions.BusyLoadingError
            redis.exceptions.DataError
            redis.exceptions.InvalidResponse
            redis.exceptions.PubSubError
            redis.exceptions.ResponseError
                redis.exceptions.AuthenticationWrongNumberOfArgsError
                redis.exceptions.OutOfMemoryError
                redis.exceptions.ReadOnlyError
            redis.exceptions.TimeoutError
            redis.exceptions.WatchError
    builtins.object
        redis.typing.Subscription
    redis.asyncio.cluster.AsyncMaintNotificationsAbstractRedisCluster(builtins.object)
        redis.asyncio.cluster.RedisCluster(redis.client.AbstractRedis, redis.cluster.AbstractRedisCluster, redis.asyncio.cluster.AsyncMaintNotificationsAbstractRedisCluster, redis.commands.cluster.AsyncRedisClusterCommands)
    redis.asyncio.connection.AbstractConnection(redis.asyncio.connection.AsyncMaintNotificationsAbstractConnection)
        redis.asyncio.connection.Connection
            redis.asyncio.connection.SSLConnection
            redis.asyncio.sentinel.SentinelManagedConnection
                redis.asyncio.sentinel.SentinelManagedSSLConnection(redis.asyncio.sentinel.SentinelManagedConnection, redis.asyncio.connection.SSLConnection)
        redis.asyncio.connection.UnixDomainSocketConnection
    redis.asyncio.connection.AsyncMaintNotificationsAbstractConnectionPool(builtins.object)
        redis.asyncio.connection.ConnectionPool(redis.asyncio.connection.AsyncMaintNotificationsAbstractConnectionPool, redis.asyncio.connection.ConnectionPoolInterface)
            redis.asyncio.connection.BlockingConnectionPool
            redis.asyncio.sentinel.SentinelConnectionPool
    redis.asyncio.connection.ConnectionPoolInterface(abc.ABC)
        redis.asyncio.connection.ConnectionPool(redis.asyncio.connection.AsyncMaintNotificationsAbstractConnectionPool, redis.asyncio.connection.ConnectionPoolInterface)
            redis.asyncio.connection.BlockingConnectionPool
            redis.asyncio.sentinel.SentinelConnectionPool
    redis.asyncio.keyspace_notifications.AbstractAsyncKeyspaceNotifications(redis.asyncio.keyspace_notifications.AsyncKeyspaceNotificationsInterface)
        redis.asyncio.keyspace_notifications.AsyncClusterKeyspaceNotifications
        redis.asyncio.keyspace_notifications.AsyncKeyspaceNotifications
    redis.client.AbstractRedis(builtins.object)
        redis.asyncio.client.Redis(redis.client.AbstractRedis, redis.commands.redismodules.AsyncRedisModuleCommands, redis.commands.core.AsyncCoreCommands, redis.commands.sentinel.AsyncSentinelCommands)
        redis.asyncio.cluster.RedisCluster(redis.client.AbstractRedis, redis.cluster.AbstractRedisCluster, redis.asyncio.cluster.AsyncMaintNotificationsAbstractRedisCluster, redis.commands.cluster.AsyncRedisClusterCommands)
    redis.cluster.AbstractRedisCluster(builtins.object)
        redis.asyncio.cluster.RedisCluster(redis.client.AbstractRedis, redis.cluster.AbstractRedisCluster, redis.asyncio.cluster.AsyncMaintNotificationsAbstractRedisCluster, redis.commands.cluster.AsyncRedisClusterCommands)
    redis.commands.cluster.AsyncRedisClusterCommands(redis.commands.cluster.AsyncClusterMultiKeyCommands, redis.commands.cluster.AsyncClusterManagementCommands, redis.commands.core.ACLCommands, redis.commands.core.PubSubCommands, redis.commands.cluster.AsyncClusterDataAccessCommands, redis.commands.core.AsyncScriptCommands, redis.commands.core.FunctionCommands, redis.commands.core.AsyncModuleCommands, redis.commands.redismodules.AsyncRedisModuleCommands)
        redis.asyncio.cluster.RedisCluster(redis.client.AbstractRedis, redis.cluster.AbstractRedisCluster, redis.asyncio.cluster.AsyncMaintNotificationsAbstractRedisCluster, redis.commands.cluster.AsyncRedisClusterCommands)
    redis.commands.core.AsyncCoreCommands(redis.commands.core.ACLCommands, redis.commands.core.ClusterCommands, redis.commands.core.AsyncDataAccessCommands, redis.commands.core.AsyncManagementCommands, redis.commands.core.AsyncModuleCommands, redis.commands.core.PubSubCommands, redis.commands.core.AsyncScriptCommands, redis.commands.core.FunctionCommands)
        redis.asyncio.client.Redis(redis.client.AbstractRedis, redis.commands.redismodules.AsyncRedisModuleCommands, redis.commands.core.AsyncCoreCommands, redis.commands.sentinel.AsyncSentinelCommands)
    redis.commands.redismodules.AsyncRedisModuleCommands(redis.commands.redismodules.RedisModuleCommands)
        redis.asyncio.client.Redis(redis.client.AbstractRedis, redis.commands.redismodules.AsyncRedisModuleCommands, redis.commands.core.AsyncCoreCommands, redis.commands.sentinel.AsyncSentinelCommands)
    redis.commands.sentinel.AsyncSentinelCommands(redis.commands.sentinel.SentinelCommands)
        redis.asyncio.client.Redis(redis.client.AbstractRedis, redis.commands.redismodules.AsyncRedisModuleCommands, redis.commands.core.AsyncCoreCommands, redis.commands.sentinel.AsyncSentinelCommands)
        redis.asyncio.sentinel.Sentinel

    class AsyncClusterKeyspaceNotifications(AbstractAsyncKeyspaceNotifications)
     |  AsyncClusterKeyspaceNotifications(redis_cluster: 'RedisCluster', key_prefix: 'str | bytes | None' = None, ignore_subscribe_messages: 'bool' = True)
     |
     |  Manages keyspace notification subscriptions across all nodes in an async Redis Cluster.
     |
     |  In Redis Cluster, keyspace notifications are NOT broadcast between nodes.
     |  Each node only emits notifications for keys it owns. This class automatically
     |  subscribes to all primary nodes in the cluster and handles topology changes.
     |
     |  Method resolution order:
     |      AsyncClusterKeyspaceNotifications
     |      AbstractAsyncKeyspaceNotifications
     |      AsyncKeyspaceNotificationsInterface
     |      abc.ABC
     |      builtins.object
     |
     |  Methods defined here:
     |
     |  __init__(self, redis_cluster: 'RedisCluster', key_prefix: 'str | bytes | None' = None, ignore_subscribe_messages: 'bool' = True)
     |      Initialize the async cluster keyspace notification manager.
     |
     |      Note: Keyspace notifications must be enabled on all Redis cluster nodes via
     |      the ``notify-keyspace-events`` configuration option.
     |
     |      Args:
     |          redis_cluster: An async RedisCluster instance
     |          key_prefix: Optional prefix to filter and strip from keys in notifications
     |          ignore_subscribe_messages: If True, subscribe/unsubscribe confirmations
     |                                    are not returned by get_message/listen
     |
     |  async aclose(self)
     |      Close all pubsub connections and clean up resources.
     |
     |  async get_message(self, ignore_subscribe_messages: 'bool | None' = None, timeout: 'float' = 0.0) -> 'KeyNotification | None'
     |      Get the next keyspace notification if one is available.
     |
     |      This method polls all node pubsubs in round-robin fashion until
     |      a message is received or the timeout expires.
     |      If a connection error occurs, subscriptions are automatically refreshed.
     |
     |      Args:
     |          ignore_subscribe_messages: If True, skip subscribe/unsubscribe messages.
     |                                    Defaults to the value set in __init__ (True).
     |          timeout: Total time to wait for a message (distributed across all nodes)
     |
     |      Returns:
     |          A KeyNotification if a notification is available, None otherwise.
     |
     |  async listen(self) -> 'AsyncIterator[KeyNotification]'
     |      Listen for keyspace notifications from all cluster nodes.
     |
     |      This is an async generator that yields KeyNotification objects as they arrive.
     |
     |      Yields:
     |          KeyNotification objects for each keyspace/keyevent notification.
     |
     |      Example:
     |          >>> async for notification in ksn.listen():
     |          ...     print(f"{notification.key}: {notification.event_type}")
     |
     |  async refresh_subscriptions(self)
     |      Refresh subscriptions after a topology change.
     |
     |      This method is called automatically when topology changes are detected
     |      or when connection errors occur. You can also call it manually if needed.
     |
     |      This method:
     |      1. Discovers any new primary nodes and subscribes them
     |      2. Removes pubsubs for nodes that are no longer primaries
     |      3. Re-creates broken pubsub connections for existing nodes
     |
     |  ----------------------------------------------------------------------
     |  Readonly properties defined here:
     |
     |  subscribed
     |      Check if there are any active subscriptions and not closed.
     |
     |  ----------------------------------------------------------------------
     |  Data and other attributes defined here:
     |
     |  __abstractmethods__ = frozenset()
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from AbstractAsyncKeyspaceNotifications:
     |
     |  async __aenter__(self)
     |
     |  async __aexit__(self, _exc_type, _exc_val, _exc_tb)
     |
     |  async run(self, poll_timeout: 'float' = 1.0, exception_handler: 'Callable[[BaseException, AsyncKeyspaceNotificationsInterface], None | Awaitable[None]] | None' = None) -> 'None'
     |      Run the notification loop as a coroutine.
     |
     |      This continuously polls for notifications and triggers handlers.
     |      Use asyncio.create_task() to run in the background.
     |
     |      Args:
     |          poll_timeout: Timeout in seconds for each get_message call.
     |          exception_handler: Optional callback for handling exceptions.
     |                            Can be sync or async.
     |
     |  async subscribe(self, *channels: 'ChannelT', handler: 'AsyncHandlerT | None' = None)
     |      Subscribe to keyspace notification channels.
     |
     |      Automatically detects whether each channel is a pattern (contains
     |      wildcards like *, ?, [) or an exact channel name and uses the
     |      appropriate Redis subscribe command internally.
     |
     |      The handler can be either a sync or async function.  Note that a
     |      **sync** handler will be called directly on the event loop thread,
     |      so it must not perform blocking I/O or long-running computation —
     |      prefer an ``async`` handler whenever possible.
     |
     |  async subscribe_keyevent(self, event: 'str', db: 'int' = 0, handler: 'AsyncHandlerT | None' = None)
     |      Subscribe to keyevent notifications for specific event types.
     |
     |  async subscribe_keyspace(self, key_or_pattern: 'str', db: 'int' = 0, handler: 'AsyncHandlerT | None' = None)
     |      Subscribe to keyspace notifications for specific keys.
     |
     |  async subscribe_subkeyevent(self, event: 'str', db: 'int' = 0, handler: 'AsyncHandlerT | None' = None)
     |      Subscribe to subkeyevent notifications for specific event types.
     |
     |  async subscribe_subkeyspace(self, key_or_pattern: 'str', db: 'int' = 0, handler: 'AsyncHandlerT | None' = None)
     |      Subscribe to subkeyspace notifications for specific keys.
     |
     |  async subscribe_subkeyspaceevent(self, event: 'str', key_or_pattern: 'str', db: 'int' = 0, handler: 'AsyncHandlerT | None' = None)
     |      Subscribe to subkeyspaceevent notifications for an event on a key.
     |
     |  async subscribe_subkeyspaceitem(self, key_or_pattern: 'str', subkey_or_pattern: 'str', db: 'int' = 0, handler: 'AsyncHandlerT | None' = None)
     |      Subscribe to subkeyspaceitem notifications for a specific subkey.
     |
     |  async unsubscribe(self, *channels: 'ChannelT')
     |      Unsubscribe from keyspace notification channels.
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors inherited from AsyncKeyspaceNotificationsInterface:
     |
     |  __dict__
     |      dictionary for instance variables
     |
     |  __weakref__
     |      list of weak references to the object

    class AsyncKeyspaceNotifications(AbstractAsyncKeyspaceNotifications)
     |  AsyncKeyspaceNotifications(redis_client: 'Redis', key_prefix: 'str | bytes | None' = None, ignore_subscribe_messages: 'bool' = True)
     |
     |  Manages keyspace notification subscriptions for standalone async Redis.
     |
     |  For standalone Redis, keyspace notifications work with a single PubSub
     |  connection. This class wraps that connection and provides:
     |  - Automatic pattern vs exact channel detection
     |  - KeyNotification parsing with optional key_prefix filtering
     |  - Convenience methods for keyspace and keyevent subscriptions
     |  - Context manager and run() coroutine support
     |
     |  Method resolution order:
     |      AsyncKeyspaceNotifications
     |      AbstractAsyncKeyspaceNotifications
     |      AsyncKeyspaceNotificationsInterface
     |      abc.ABC
     |      builtins.object
     |
     |  Methods defined here:
     |
     |  __init__(self, redis_client: 'Redis', key_prefix: 'str | bytes | None' = None, ignore_subscribe_messages: 'bool' = True)
     |      Initialize the standalone async keyspace notification manager.
     |
     |      Note: Keyspace notifications must be enabled on the Redis server via
     |      the ``notify-keyspace-events`` configuration option.
     |
     |      Args:
     |          redis_client: An async Redis client instance
     |          key_prefix: Optional prefix to filter and strip from keys in notifications
     |          ignore_subscribe_messages: If True, subscribe/unsubscribe confirmations
     |                                    are not returned by get_message/listen
     |
     |  async aclose(self)
     |      Close the pubsub connection and clean up resources.
     |
     |  async get_message(self, ignore_subscribe_messages: 'bool | None' = None, timeout: 'float' = 0.0) -> 'KeyNotification | None'
     |      Get the next keyspace notification if one is available.
     |
     |      Args:
     |          ignore_subscribe_messages: If True, skip subscribe/unsubscribe messages.
     |                                    Defaults to the value set in __init__ (True).
     |          timeout: Time to wait for a message.
     |
     |      Returns:
     |          A KeyNotification if a notification is available and no handler
     |          was registered for the channel, None otherwise.
     |
     |  async listen(self) -> 'AsyncIterator[KeyNotification]'
     |      Listen for keyspace notifications.
     |
     |      This is an async generator that yields KeyNotification objects as they arrive.
     |
     |      Yields:
     |          KeyNotification objects for each keyspace/keyevent notification.
     |
     |      Example:
     |          >>> async for notification in ksn.listen():
     |          ...     print(f"{notification.key}: {notification.event_type}")
     |
     |  ----------------------------------------------------------------------
     |  Readonly properties defined here:
     |
     |  subscribed
     |      Check if there are any active subscriptions and not closed.
     |
     |  ----------------------------------------------------------------------
     |  Data and other attributes defined here:
     |
     |  __abstractmethods__ = frozenset()
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from AbstractAsyncKeyspaceNotifications:
     |
     |  async __aenter__(self)
     |
     |  async __aexit__(self, _exc_type, _exc_val, _exc_tb)
     |
     |  async run(self, poll_timeout: 'float' = 1.0, exception_handler: 'Callable[[BaseException, AsyncKeyspaceNotificationsInterface], None | Awaitable[None]] | None' = None) -> 'None'
     |      Run the notification loop as a coroutine.
     |
     |      This continuously polls for notifications and triggers handlers.
     |      Use asyncio.create_task() to run in the background.
     |
     |      Args:
     |          poll_timeout: Timeout in seconds for each get_message call.
     |          exception_handler: Optional callback for handling exceptions.
     |                            Can be sync or async.
     |
     |  async subscribe(self, *channels: 'ChannelT', handler: 'AsyncHandlerT | None' = None)
     |      Subscribe to keyspace notification channels.
     |
     |      Automatically detects whether each channel is a pattern (contains
     |      wildcards like *, ?, [) or an exact channel name and uses the
     |      appropriate Redis subscribe command internally.
     |
     |      The handler can be either a sync or async function.  Note that a
     |      **sync** handler will be called directly on the event loop thread,
     |      so it must not perform blocking I/O or long-running computation —
     |      prefer an ``async`` handler whenever possible.
     |
     |  async subscribe_keyevent(self, event: 'str', db: 'int' = 0, handler: 'AsyncHandlerT | None' = None)
     |      Subscribe to keyevent notifications for specific event types.
     |
     |  async subscribe_keyspace(self, key_or_pattern: 'str', db: 'int' = 0, handler: 'AsyncHandlerT | None' = None)
     |      Subscribe to keyspace notifications for specific keys.
     |
     |  async subscribe_subkeyevent(self, event: 'str', db: 'int' = 0, handler: 'AsyncHandlerT | None' = None)
     |      Subscribe to subkeyevent notifications for specific event types.
     |
     |  async subscribe_subkeyspace(self, key_or_pattern: 'str', db: 'int' = 0, handler: 'AsyncHandlerT | None' = None)
     |      Subscribe to subkeyspace notifications for specific keys.
     |
     |  async subscribe_subkeyspaceevent(self, event: 'str', key_or_pattern: 'str', db: 'int' = 0, handler: 'AsyncHandlerT | None' = None)
     |      Subscribe to subkeyspaceevent notifications for an event on a key.
     |
     |  async subscribe_subkeyspaceitem(self, key_or_pattern: 'str', subkey_or_pattern: 'str', db: 'int' = 0, handler: 'AsyncHandlerT | None' = None)
     |      Subscribe to subkeyspaceitem notifications for a specific subkey.
     |
     |  async unsubscribe(self, *channels: 'ChannelT')
     |      Unsubscribe from keyspace notification channels.
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors inherited from AsyncKeyspaceNotificationsInterface:
     |
     |  __dict__
     |      dictionary for instance variables
     |
     |  __weakref__
     |      list of weak references to the object

    class AsyncKeyspaceNotificationsInterface(abc.ABC)
     |  Async interface for keyspace notification managers.
     |
     |  This interface provides a consistent async API for both standalone
     |  (AsyncKeyspaceNotifications) and cluster (AsyncClusterKeyspaceNotifications)
     |  implementations.
     |
     |  Method resolution order:
     |      AsyncKeyspaceNotificationsInterface
     |      abc.ABC
     |      builtins.object
     |
     |  Methods defined here:
     |
     |  async __aenter__(self)
     |
     |  async __aexit__(self, _exc_type, _exc_val, _exc_tb)
     |
     |  async aclose(self)
     |      Close the notification manager and clean up resources.
     |
     |  async get_message(self, ignore_subscribe_messages: 'bool | None' = None, timeout: 'float' = 0.0) -> 'KeyNotification | None'
     |      Get the next keyspace notification if one is available.
     |
     |  listen(self) -> 'AsyncIterator[KeyNotification]'
     |      Listen for keyspace notifications.
     |
     |  async run(self, poll_timeout: 'float' = 1.0, exception_handler: 'Callable[[BaseException, AsyncKeyspaceNotificationsInterface], None | Awaitable[None]] | None' = None) -> 'None'
     |      Run the notification loop as a coroutine.
     |
     |      This is the async equivalent of run_in_thread() for sync notifications.
     |      Use asyncio.create_task() to run in the background.
     |
     |      The exception_handler can be either a sync or async function.
     |
     |  async subscribe(self, *channels: 'ChannelT', handler: 'AsyncHandlerT | None' = None)
     |      Subscribe to keyspace notification channels.
     |
     |  async subscribe_keyevent(self, event: 'str', db: 'int' = 0, handler: 'AsyncHandlerT | None' = None)
     |      Subscribe to keyevent notifications for specific event types.
     |
     |  async subscribe_keyspace(self, key_or_pattern: 'str', db: 'int' = 0, handler: 'AsyncHandlerT | None' = None)
     |      Subscribe to keyspace notifications for specific keys.
     |
     |  async subscribe_subkeyevent(self, event: 'str', db: 'int' = 0, handler: 'AsyncHandlerT | None' = None)
     |      Subscribe to subkeyevent notifications for specific event types.
     |
     |  async subscribe_subkeyspace(self, key_or_pattern: 'str', db: 'int' = 0, handler: 'AsyncHandlerT | None' = None)
     |      Subscribe to subkeyspace notifications for specific keys.
     |
     |  async subscribe_subkeyspaceevent(self, event: 'str', key_or_pattern: 'str', db: 'int' = 0, handler: 'AsyncHandlerT | None' = None)
     |      Subscribe to subkeyspaceevent notifications for an event on a key.
     |
     |  async subscribe_subkeyspaceitem(self, key_or_pattern: 'str', subkey_or_pattern: 'str', db: 'int' = 0, handler: 'AsyncHandlerT | None' = None)
     |      Subscribe to subkeyspaceitem notifications for a specific subkey.
     |
     |  async unsubscribe(self, *channels: 'ChannelT')
     |      Unsubscribe from keyspace notification channels.
     |
     |  ----------------------------------------------------------------------
     |  Readonly properties defined here:
     |
     |  subscribed
     |      Check if there are any active subscriptions and not closed.
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors defined here:
     |
     |  __dict__
     |      dictionary for instance variables
     |
     |  __weakref__
     |      list of weak references to the object
     |
     |  ----------------------------------------------------------------------
     |  Data and other attributes defined here:
     |
     |  __abstractmethods__ = frozenset({'__aenter__', '__aexit__', 'aclose', ...

    class AuthenticationError(ConnectionError)
     |  AuthenticationError(*args, status_code: str | None = None)
     |
     |  Method resolution order:
     |      AuthenticationError
     |      ConnectionError
     |      RedisError
     |      builtins.Exception
     |      builtins.BaseException
     |      builtins.object
     |
     |  Methods defined here:
     |
     |  __init__(self, *args, status_code: str | None = None)
     |      Initialize self.  See help(type(self)) for accurate signature.
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from RedisError:
     |
     |  __repr__(self)
     |      Return repr(self).
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors inherited from RedisError:
     |
     |  __weakref__
     |      list of weak references to the object
     |
     |  ----------------------------------------------------------------------
     |  Static methods inherited from builtins.Exception:
     |
     |  __new__(*args, **kwargs) class method of builtins.Exception
     |      Create and return a new object.  See help(type) for accurate signature.
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from builtins.BaseException:
     |
     |  __getattribute__(self, name, /)
     |      Return getattr(self, name).
     |
     |  __reduce__(...)
     |      Helper for pickle.
     |
     |  __setstate__(...)
     |
     |  __str__(self, /)
     |      Return str(self).
     |
     |  add_note(...)
     |      Exception.add_note(note) --
     |      add a note to the exception
     |
     |  with_traceback(...)
     |      Exception.with_traceback(tb) --
     |      set self.__traceback__ to tb and return self.
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors inherited from builtins.BaseException:
     |
     |  __cause__
     |      exception cause
     |
     |  __context__
     |      exception context
     |
     |  __dict__
     |
     |  __suppress_context__
     |
     |  __traceback__
     |
     |  args

    class AuthenticationWrongNumberOfArgsError(ResponseError)
     |  AuthenticationWrongNumberOfArgsError(*args, status_code: str | None = None)
     |
     |  An error to indicate that the wrong number of args
     |  were sent to the AUTH command
     |
     |  Method resolution order:
     |      AuthenticationWrongNumberOfArgsError
     |      ResponseError
     |      RedisError
     |      builtins.Exception
     |      builtins.BaseException
     |      builtins.object
     |
     |  Methods defined here:
     |
     |  __init__(self, *args, status_code: str | None = None)
     |      Initialize self.  See help(type(self)) for accurate signature.
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from RedisError:
     |
     |  __repr__(self)
     |      Return repr(self).
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors inherited from RedisError:
     |
     |  __weakref__
     |      list of weak references to the object
     |
     |  ----------------------------------------------------------------------
     |  Static methods inherited from builtins.Exception:
     |
     |  __new__(*args, **kwargs) class method of builtins.Exception
     |      Create and return a new object.  See help(type) for accurate signature.
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from builtins.BaseException:
     |
     |  __getattribute__(self, name, /)
     |      Return getattr(self, name).
     |
     |  __reduce__(...)
     |      Helper for pickle.
     |
     |  __setstate__(...)
     |
     |  __str__(self, /)
     |      Return str(self).
     |
     |  add_note(...)
     |      Exception.add_note(note) --
     |      add a note to the exception
     |
     |  with_traceback(...)
     |      Exception.with_traceback(tb) --
     |      set self.__traceback__ to tb and return self.
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors inherited from builtins.BaseException:
     |
     |  __cause__
     |      exception cause
     |
     |  __context__
     |      exception context
     |
     |  __dict__
     |
     |  __suppress_context__
     |
     |  __traceback__
     |
     |  args

    class BlockingConnectionPool(ConnectionPool)
     |  BlockingConnectionPool(max_connections: int = 50, timeout: Optional[float] = 20, connection_class: Type[redis.asyncio.connection.AbstractConnection] = <class 'redis.asyncio.connection.Connection'>, queue_class: Type[asyncio.queues.Queue] = <class 'asyncio.queues.LifoQueue'>, **connection_kwargs)
     |
     |  A blocking connection pool::
     |
     |      >>> from redis.asyncio import Redis, BlockingConnectionPool
     |      >>> client = Redis.from_pool(BlockingConnectionPool())
     |
     |  It performs the same function as the default
     |  :py:class:`~redis.asyncio.ConnectionPool` implementation, in that,
     |  it maintains a pool of reusable connections that can be shared by
     |  multiple async redis clients.
     |
     |  The difference is that, in the event that a client tries to get a
     |  connection from the pool when all of connections are in use, rather than
     |  raising a :py:class:`~redis.ConnectionError` (as the default
     |  :py:class:`~redis.asyncio.ConnectionPool` implementation does), it
     |  blocks the current `Task` for a specified number of seconds until
     |  a connection becomes available.
     |
     |  Use ``max_connections`` to increase / decrease the pool size::
     |
     |      >>> pool = BlockingConnectionPool(max_connections=10)
     |
     |  Use ``timeout`` to tell it either how many seconds to wait for a connection
     |  to become available, or to block forever:
     |
     |      >>> # Block forever.
     |      >>> pool = BlockingConnectionPool(timeout=None)
     |
     |      >>> # Raise a ``ConnectionError`` after five seconds if a connection is
     |      >>> # not available.
     |      >>> pool = BlockingConnectionPool(timeout=5)
     |
     |  Method resolution order:
     |      BlockingConnectionPool
     |      ConnectionPool
     |      AsyncMaintNotificationsAbstractConnectionPool
     |      ConnectionPoolInterface
     |      abc.ABC
     |      builtins.object
     |
     |  Methods defined here:
     |
     |  __init__(self, max_connections: int = 50, timeout: Optional[float] = 20, connection_class: Type[redis.asyncio.connection.AbstractConnection] = <class 'redis.asyncio.connection.Connection'>, queue_class: Type[asyncio.queues.Queue] = <class 'asyncio.queues.LifoQueue'>, **connection_kwargs)
     |      Initialize self.  See help(type(self)) for accurate signature.
     |
     |  async get_connection(self, command_name=None, *keys, **options)
     |      Gets a connection from the pool, blocking until one is available
     |
     |  async release(self, connection: redis.asyncio.connection.AbstractConnection)
     |      Releases the connection back to the pool.
     |
     |  set_in_maintenance(self, in_maintenance: bool) -> None
     |      Toggle the pool's maintenance mode.
     |
     |      While maintenance mode is on, ``get_connection`` and ``release``
     |      serialize their pool mutations through ``self._lock`` so they cannot
     |      interleave with a MOVING notification handler that is currently
     |      rewriting pool state under the same lock. Outside of maintenance the
     |      mutations skip the lock, since their critical sections are pure-Python
     |      and already atomic under asyncio's single-threaded scheduling.
     |
     |  ----------------------------------------------------------------------
     |  Data and other attributes defined here:
     |
     |  __abstractmethods__ = frozenset()
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from ConnectionPool:
     |
     |  async __aenter__(self: ~_CP) -> ~_CP
     |
     |  async __aexit__(self, exc_type, exc_value, traceback) -> None
     |
     |  __del__(self) -> None
     |      Clean up connection pool and record metrics when garbage collected.
     |
     |  __repr__(self)
     |      Return repr(self).
     |
     |  async aclose(self) -> None
     |      Close the pool, disconnecting all connections
     |
     |  can_get_connection(self) -> bool
     |      Return True if a connection can be retrieved from the pool.
     |
     |  async disconnect(self, inuse_connections: bool = True)
     |      Disconnects connections in the pool
     |
     |      If ``inuse_connections`` is True, disconnect connections that are
     |      current in use, potentially by other tasks. Otherwise only disconnect
     |      connections that are idle in the pool.
     |
     |  async ensure_connection(self, connection: redis.asyncio.connection.AbstractConnection)
     |      Ensure that the connection object is connected and valid
     |
     |  get_available_connection(self)
     |      Get a connection from the pool, without making sure it is connected
     |
     |  get_connection_count(self) -> List[tuple[int, dict]]
     |      Returns a connection count (both idle and in use).
     |
     |  get_encoder(self)
     |      Return an encoder based on encoding settings
     |
     |  get_protocol(self)
     |      Returns:
     |          The RESP protocol version, or ``None`` if the protocol is not specified,
     |          in which case the server default will be used.
     |
     |  make_connection(self)
     |      Create a new connection.  Can be overridden by child classes.
     |
     |  async re_auth_callback(self, token: redis.auth.token.TokenInterface)
     |
     |  reset(self)
     |
     |  set_retry(self, retry: 'Retry') -> None
     |
     |  async update_active_connections_for_reconnect(self)
     |      Mark all active connections for reconnect.
     |
     |  ----------------------------------------------------------------------
     |  Class methods inherited from ConnectionPool:
     |
     |  from_url(url: str, **kwargs) -> ~_CP
     |      Return a connection pool configured from the given URL.
     |
     |      For example::
     |
     |          redis://[[username]:[password]]@localhost:6379/0
     |          rediss://[[username]:[password]]@localhost:6379/0
     |          unix://[username@]/path/to/socket.sock?db=0[&password=password]
     |
     |      Three URL schemes are supported:
     |
     |      - `redis://` creates a TCP socket connection. See more at:
     |        <https://www.iana.org/assignments/uri-schemes/prov/redis>
     |      - `rediss://` creates a SSL wrapped TCP socket connection. See more at:
     |        <https://www.iana.org/assignments/uri-schemes/prov/rediss>
     |      - ``unix://``: creates a Unix Domain Socket connection.
     |
     |      The username, password, hostname, path and all querystring values
     |      are passed through urllib.parse.unquote in order to replace any
     |      percent-encoded values with their corresponding characters.
     |
     |      There are several ways to specify a database number. The first value
     |      found will be used:
     |
     |      1. A ``db`` querystring option, e.g. redis://localhost?db=0
     |
     |      2. If using the redis:// or rediss:// schemes, the path argument
     |             of the url, e.g. redis://localhost/0
     |
     |      3. A ``db`` keyword argument to this function.
     |
     |      If none of these options are specified, the default db=0 is used.
     |
     |      All querystring options are cast to their appropriate Python types.
     |      Boolean arguments can be specified with string values "True"/"False"
     |      or "Yes"/"No". Values that cannot be properly cast cause a
     |      ``ValueError`` to be raised. Once parsed, the querystring arguments
     |      and keyword arguments are passed to the ``ConnectionPool``'s
     |      class initializer. In the case of conflicting arguments, querystring
     |      arguments always win.
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors inherited from ConnectionPool:
     |
     |  connection_kwargs
     |
     |  ----------------------------------------------------------------------
     |  Data and other attributes inherited from ConnectionPool:
     |
     |  OMIT_REPR_KEYS = frozenset({'himport_registry'})
     |
     |  SENSITIVE_REPR_KEYS = frozenset({'credential_provider', 'password', 's...
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from AsyncMaintNotificationsAbstractConnectionPool:
     |
     |  async apply_moving_notification(self, notification: redis.maint_notifications.NodeMovingNotification, config: redis.maint_notifications.MaintNotificationsConfig, moving_address_src: str | None, run_proactive_reconnect: bool = False) -> None
     |      Apply the pool state transition for a MOVING notification atomically.
     |
     |      Async pools use a non-reentrant `asyncio.Lock`, so the handler cannot
     |      safely compose several separately locked calls. Existing connection
     |      updates, optional proactive reconnect, and future `connection_kwargs`
     |      changes must happen under one pool-owned lock; otherwise a connection
     |      can move between active/free lists and escape handling.
     |
     |  async cleanup_moving_notification(self, notification_hash: int, reset_relaxed_timeout: bool, reset_host_address: bool) -> None
     |      Revert MOVING pool state atomically after the notification TTL.
     |
     |      Future connection kwargs and existing connection state must be cleaned
     |      up in the same critical section. Splitting the cleanup lets an
     |      acquire/release interleave, which can leave stale MOVING state or undo a
     |      newer overlapping MOVING notification.
     |
     |  maint_notifications_enabled(self)
     |      Returns:
     |          True if the maintenance notifications are enabled, False otherwise.
     |          The maintenance notifications config is stored in the pool handler.
     |          If the pool handler is not set, the maintenance notifications are not enabled.
     |
     |  async run_proactive_reconnect(self, moving_address_src: str | None = None) -> None
     |      Mark active connections and disconnect free connections atomically.
     |
     |      This operation is pool-owned because the active/free lists can change
     |      while tasks acquire or release connections. Keeping the mark/disconnect
     |      pass under one lock avoids a connection moving between lists between
     |      separately locked calls.
     |
     |  update_connection_kwargs(self, **kwargs: Any) -> None
     |      Update the connection kwargs for all future connections.
     |
     |      This method updates the connection kwargs for all future connections created by the pool.
     |      Existing connections are not affected.
     |
     |  update_connection_settings(self, conn: 'AsyncMaintNotificationsAbstractConnection', state: redis.maint_notifications.MaintenanceState | None = None, maintenance_notification_hash: int | None = None, host_address: str | None = None, relaxed_timeout: float | None = None, update_notification_hash: bool = False, reset_host_address: bool = False, reset_relaxed_timeout: bool = False) -> None
     |      Update the settings for a single connection.
     |
     |  async update_connections_settings(self, state: redis.maint_notifications.MaintenanceState | None = None, maintenance_notification_hash: int | None = None, host_address: str | None = None, relaxed_timeout: float | None = None, matching_address: str | None = None, matching_notification_hash: int | None = None, matching_pattern: Literal['connected_address', 'configured_address', 'notification_hash'] = 'connected_address', update_notification_hash: bool = False, reset_host_address: bool = False, reset_relaxed_timeout: bool = False, include_free_connections: bool = True) -> None
     |      Update the settings for all matching connections in the pool.
     |
     |      This method does not create new connections.
     |      This method does not affect the connection kwargs.
     |
     |      :param state: The maintenance state to set for the connection.
     |      :param maintenance_notification_hash: The hash of the maintenance notification
     |                                             to set for the connection.
     |      :param host_address: The host address to set for the connection.
     |      :param relaxed_timeout: The relaxed timeout to set for the connection.
     |      :param matching_address: The address to match for the connection.
     |      :param matching_notification_hash: The notification hash to match for the connection.
     |      :param matching_pattern: The pattern to match for the connection.
     |      :param update_notification_hash: Whether to update the notification hash for the connection.
     |      :param reset_host_address: Whether to reset the host address to the original address.
     |      :param reset_relaxed_timeout: Whether to reset the relaxed timeout to the original timeout.
     |      :param include_free_connections: Whether to include free/available connections.
     |
     |  async update_maint_notifications_config(self, maint_notifications_config: redis.maint_notifications.MaintNotificationsConfig, oss_cluster_maint_notifications_handler: redis.asyncio.maint_notifications.AsyncOSSMaintNotificationsHandler | None = None) -> None
     |      Updates the maintenance notifications configuration.
     |      This method should be called only if the pool was created
     |      without enabling the maintenance notifications and
     |      in a later point in time maintenance notifications
     |      are requested to be enabled.
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors inherited from AsyncMaintNotificationsAbstractConnectionPool:
     |
     |  __dict__
     |      dictionary for instance variables
     |
     |  __weakref__
     |      list of weak references to the object

    class BusyLoadingError(ConnectionError)
     |  BusyLoadingError(*args, status_code: str | None = None)
     |
     |  Method resolution order:
     |      BusyLoadingError
     |      ConnectionError
     |      RedisError
     |      builtins.Exception
     |      builtins.BaseException
     |      builtins.object
     |
     |  Methods defined here:
     |
     |  __init__(self, *args, status_code: str | None = None)
     |      Initialize self.  See help(type(self)) for accurate signature.
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from RedisError:
     |
     |  __repr__(self)
     |      Return repr(self).
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors inherited from RedisError:
     |
     |  __weakref__
     |      list of weak references to the object
     |
     |  ----------------------------------------------------------------------
     |  Static methods inherited from builtins.Exception:
     |
     |  __new__(*args, **kwargs) class method of builtins.Exception
     |      Create and return a new object.  See help(type) for accurate signature.
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from builtins.BaseException:
     |
     |  __getattribute__(self, name, /)
     |      Return getattr(self, name).
     |
     |  __reduce__(...)
     |      Helper for pickle.
     |
     |  __setstate__(...)
     |
     |  __str__(self, /)
     |      Return str(self).
     |
     |  add_note(...)
     |      Exception.add_note(note) --
     |      add a note to the exception
     |
     |  with_traceback(...)
     |      Exception.with_traceback(tb) --
     |      set self.__traceback__ to tb and return self.
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors inherited from builtins.BaseException:
     |
     |  __cause__
     |      exception cause
     |
     |  __context__
     |      exception context
     |
     |  __dict__
     |
     |  __suppress_context__
     |
     |  __traceback__
     |
     |  args

    class ChildDeadlockedError(builtins.Exception)
     |  Error indicating that a child process is deadlocked after a fork()
     |
     |  Method resolution order:
     |      ChildDeadlockedError
     |      builtins.Exception
     |      builtins.BaseException
     |      builtins.object
     |
     |  Data descriptors defined here:
     |
     |  __weakref__
     |      list of weak references to the object
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from builtins.Exception:
     |
     |  __init__(self, /, *args, **kwargs)
     |      Initialize self.  See help(type(self)) for accurate signature.
     |
     |  ----------------------------------------------------------------------
     |  Static methods inherited from builtins.Exception:
     |
     |  __new__(*args, **kwargs) class method of builtins.Exception
     |      Create and return a new object.  See help(type) for accurate signature.
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from builtins.BaseException:
     |
     |  __getattribute__(self, name, /)
     |      Return getattr(self, name).
     |
     |  __reduce__(...)
     |      Helper for pickle.
     |
     |  __repr__(self, /)
     |      Return repr(self).
     |
     |  __setstate__(...)
     |
     |  __str__(self, /)
     |      Return str(self).
     |
     |  add_note(...)
     |      Exception.add_note(note) --
     |      add a note to the exception
     |
     |  with_traceback(...)
     |      Exception.with_traceback(tb) --
     |      set self.__traceback__ to tb and return self.
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors inherited from builtins.BaseException:
     |
     |  __cause__
     |      exception cause
     |
     |  __context__
     |      exception context
     |
     |  __dict__
     |
     |  __suppress_context__
     |
     |  __traceback__
     |
     |  args

    class Connection(AbstractConnection)
     |  Connection(*, host: str = 'localhost', port: str | int = 6379, socket_keepalive: bool = True, socket_keepalive_options: Union[Mapping[int, int | bytes], object, NoneType] = <object object at 0x0000017B991493E0>, socket_type: int = 0, **kwargs)
     |
     |  Manages TCP communication to and from a Redis server
     |
     |  Method resolution order:
     |      Connection
     |      AbstractConnection
     |      AsyncMaintNotificationsAbstractConnection
     |      builtins.object
     |
     |  Methods defined here:
     |
     |  __init__(self, *, host: str = 'localhost', port: str | int = 6379, socket_keepalive: bool = True, socket_keepalive_options: Union[Mapping[int, int | bytes], object, NoneType] = <object object at 0x0000017B991493E0>, socket_type: int = 0, **kwargs)
     |      Initialize a TCP connection.
     |
     |      Parameters
     |      ----------
     |      socket_keepalive : bool
     |          If `True`, TCP keepalive is enabled for TCP socket connections.
     |      socket_keepalive_options : Mapping[int, int | bytes] | object | None
     |          Mapping of TCP keepalive socket option constants to values, for
     |          example `{socket.TCP_KEEPIDLE: 30}`. If left unspecified, redis-py
     |          uses TCP keepalive defaults when `socket_keepalive` is enabled:
     |          idle 30 seconds, interval 5 seconds, and 3 probes. Platform-specific
     |          options that are not available are skipped. Pass `None` or `{}` to
     |          avoid setting additional TCP keepalive options.
     |
     |  repr_pieces(self)
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors defined here:
     |
     |  __weakref__
     |      list of weak references to the object
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from AbstractConnection:
     |
     |  __del__(self, _warnings: Any = <module 'warnings' from 'C:\\Users\\Youse\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\warnings.py'>)
     |
     |  __repr__(self)
     |      Return repr(self).
     |
     |  async can_read(self) -> bool
     |      Check the socket to see if there's data loaded in the buffer.
     |
     |  async can_read_destructive(self) -> bool
     |      Check the socket to see if there's data loaded in the buffer.
     |
     |  async check_health(self)
     |      Check the health of the connection with a PING/PONG
     |
     |  async connect(self)
     |      Connects to the Redis server if not already connected
     |
     |  async connect_check_health(self, check_health: bool = True, retry_socket_connect: bool = True)
     |
     |  deregister_connect_callback(self, callback)
     |      De-register a previously registered callback.  It will no-longer receive
     |      notifications on connection events.  Calling this is not required when the
     |      listener goes away, since the callbacks are kept as weak methods.
     |
     |  async disconnect(self, nowait: bool = False, error: Optional[Exception] = None, failure_count: Optional[int] = None, health_check_failed: bool = False) -> None
     |      Disconnects from the Redis server
     |
     |  get_protocol(self)
     |
     |  getpeername(self) -> str | None
     |      Returns the peer name of the connection.
     |
     |  mark_for_reconnect(self)
     |
     |  async on_connect(self) -> None
     |      Initialize the connection, authenticate and select a database
     |
     |  async on_connect_check_health(self, check_health: bool = True) -> None
     |
     |  pack_command(self, *args: Union[bytes, bytearray, memoryview, str, int, float]) -> List[bytes]
     |      Pack a series of arguments into the Redis protocol
     |
     |  pack_commands(self, commands: Iterable[Iterable[Union[bytes, bytearray, memoryview, str, int, float]]]) -> List[bytes]
     |      Pack multiple commands into the Redis protocol
     |
     |  async process_invalidation_messages(self)
     |
     |  async re_auth(self)
     |
     |  async read_response(self, disable_decoding: bool = False, timeout: float | None = None, *, disconnect_on_error: bool = True, push_request: bool | None = False)
     |      Read the response from a previously sent command.
     |
     |      ``timeout`` semantics:
     |      - ``None`` (default): fall back to ``self.socket_timeout``.
     |      - ``math.inf``: block indefinitely with no timeout. Used by PubSub
     |        blocking reads (``listen()`` / ``get_message(timeout=None)`` /
     |        ``parse_response(block=True)``) where the configured
     |        ``socket_timeout`` must not abort the read.
     |      - ``float``: apply that timeout in seconds for this single read.
     |
     |      TODO(next-major): replace the ``math.inf`` opt-in with a SENTINEL
     |      default for ``timeout``. After that change, ``timeout=None`` will
     |      mean "no timeout, block until a response arrives" (matching the
     |      long-standing PubSub docstring contract) and the SENTINEL default
     |      will be the value that falls back to ``self.socket_timeout``.
     |      That swap is a breaking change, so it must wait for a major
     |      release. Until then, callers that need an indefinitely blocking
     |      read pass ``math.inf`` explicitly.
     |
     |  register_connect_callback(self, callback)
     |      Register a callback to be called when the connection is established either
     |      initially or reconnected.  This allows listeners to issue commands that
     |      are ephemeral to the connection, for example pub/sub subscription or
     |      key tracking.  The callback must be a _method_ and will be kept as
     |      a weak reference.
     |
     |  reset_should_reconnect(self)
     |
     |  async send_command(self, *args: Any, **kwargs: Any) -> None
     |      Pack and send a command to the Redis server
     |
     |  async send_packed_command(self, command: Union[bytes, str, Iterable[bytes]], check_health: bool = True) -> None
     |
     |  set_parser(self, parser_class: Type[redis._parsers.base.BaseParser]) -> None
     |      Creates a new instance of parser_class with socket size:
     |      _socket_read_size and assigns it to the parser for the connection
     |      :param parser_class: The required parser class
     |
     |  set_re_auth_token(self, token: redis.auth.token.TokenInterface)
     |
     |  should_reconnect(self)
     |
     |  ----------------------------------------------------------------------
     |  Readonly properties inherited from AbstractConnection:
     |
     |  is_connected
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors inherited from AbstractConnection:
     |
     |  __dict__
     |      dictionary for instance variables
     |
     |  client_name
     |
     |  credential_provider
     |
     |  db
     |
     |  encoder
     |
     |  health_check_interval
     |
     |  last_active_at
     |
     |  lib_name
     |
     |  lib_version
     |
     |  next_health_check
     |
     |  password
     |
     |  protocol
     |
     |  redis_connect_func
     |
     |  retry_on_error
     |
     |  retry_on_timeout
     |
     |  socket_connect_timeout
     |
     |  socket_timeout
     |
     |  ssl_context
     |
     |  username
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from AsyncMaintNotificationsAbstractConnection:
     |
     |  async activate_maint_notifications_handling_if_enabled(self, check_health: bool = True) -> None
     |
     |  add_maint_start_notification(self, id: int) -> None
     |
     |  add_skipped_end_notification(self, id: int) -> None
     |
     |  get_processed_start_notifications(self) -> set[int]
     |
     |  get_resolved_ip(self) -> str | None
     |      Extract the resolved IP address from an established connection or host.
     |
     |      First tries to get the actual peer IP from the async stream writer, then
     |      falls back to DNS resolution if needed.
     |
     |      Returns:
     |          The resolved IP address, or None if it cannot be determined.
     |
     |  get_skipped_end_notifications(self) -> set[int]
     |
     |  reset_received_notifications(self) -> None
     |
     |  reset_tmp_settings(self, reset_host_address: bool = False, reset_relaxed_timeout: bool = False) -> None
     |
     |  set_maint_notifications_cluster_handler_for_connection(self, oss_cluster_maint_notifications_handler: redis.asyncio.maint_notifications.AsyncOSSMaintNotificationsHandler) -> None
     |
     |  set_maint_notifications_pool_handler_for_connection(self, maint_notifications_pool_handler: redis.asyncio.maint_notifications.AsyncMaintNotificationsPoolHandler) -> None
     |
     |  set_tmp_settings(self, tmp_host_address: str | object | None = <object object at 0x0000017B991493E0>, tmp_relaxed_timeout: float | None = -1) -> None
     |      SENTINEL keeps the host unchanged. -1 keeps the relaxed timeout unchanged.
     |
     |  update_current_socket_timeout(self, relaxed_timeout: float | None = None) -> None
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors inherited from AsyncMaintNotificationsAbstractConnection:
     |
     |  maintenance_state

    class ConnectionError(RedisError)
     |  ConnectionError(*args, status_code: str | None = None)
     |
     |  Method resolution order:
     |      ConnectionError
     |      RedisError
     |      builtins.Exception
     |      builtins.BaseException
     |      builtins.object
     |
     |  Methods defined here:
     |
     |  __init__(self, *args, status_code: str | None = None)
     |      Initialize self.  See help(type(self)) for accurate signature.
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from RedisError:
     |
     |  __repr__(self)
     |      Return repr(self).
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors inherited from RedisError:
     |
     |  __weakref__
     |      list of weak references to the object
     |
     |  ----------------------------------------------------------------------
     |  Static methods inherited from builtins.Exception:
     |
     |  __new__(*args, **kwargs) class method of builtins.Exception
     |      Create and return a new object.  See help(type) for accurate signature.
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from builtins.BaseException:
     |
     |  __getattribute__(self, name, /)
     |      Return getattr(self, name).
     |
     |  __reduce__(...)
     |      Helper for pickle.
     |
     |  __setstate__(...)
     |
     |  __str__(self, /)
     |      Return str(self).
     |
     |  add_note(...)
     |      Exception.add_note(note) --
     |      add a note to the exception
     |
     |  with_traceback(...)
     |      Exception.with_traceback(tb) --
     |      set self.__traceback__ to tb and return self.
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors inherited from builtins.BaseException:
     |
     |  __cause__
     |      exception cause
     |
     |  __context__
     |      exception context
     |
     |  __dict__
     |
     |  __suppress_context__
     |
     |  __traceback__
     |
     |  args

    class ConnectionPool(AsyncMaintNotificationsAbstractConnectionPool, ConnectionPoolInterface)
     |  ConnectionPool(connection_class: Type[redis.asyncio.connection.AbstractConnection] = <class 'redis.asyncio.connection.Connection'>, max_connections: Optional[int] = None, maint_notifications_config: redis.maint_notifications.MaintNotificationsConfig | None = None, **connection_kwargs)
     |
     |  Create a connection pool. ``If max_connections`` is set, then this
     |  object raises :py:class:`~redis.ConnectionError` when the pool's
     |  limit is reached.
     |
     |  By default, TCP connections are created unless ``connection_class``
     |  is specified. Use :py:class:`~redis.UnixDomainSocketConnection` for
     |  unix sockets.
     |  :py:class:`~redis.SSLConnection` can be used for SSL enabled connections.
     |
     |  Any additional keyword arguments are passed to the constructor of
     |  ``connection_class``.
     |
     |  Method resolution order:
     |      ConnectionPool
     |      AsyncMaintNotificationsAbstractConnectionPool
     |      ConnectionPoolInterface
     |      abc.ABC
     |      builtins.object
     |
     |  Methods defined here:
     |
     |  async __aenter__(self: ~_CP) -> ~_CP
     |
     |  async __aexit__(self, exc_type, exc_value, traceback) -> None
     |
     |  __del__(self) -> None
     |      Clean up connection pool and record metrics when garbage collected.
     |
     |  __init__(self, connection_class: Type[redis.asyncio.connection.AbstractConnection] = <class 'redis.asyncio.connection.Connection'>, max_connections: Optional[int] = None, maint_notifications_config: redis.maint_notifications.MaintNotificationsConfig | None = None, **connection_kwargs)
     |      Initialize self.  See help(type(self)) for accurate signature.
     |
     |  __repr__(self)
     |      Return repr(self).
     |
     |  async aclose(self) -> None
     |      Close the pool, disconnecting all connections
     |
     |  can_get_connection(self) -> bool
     |      Return True if a connection can be retrieved from the pool.
     |
     |  async disconnect(self, inuse_connections: bool = True)
     |      Disconnects connections in the pool
     |
     |      If ``inuse_connections`` is True, disconnect connections that are
     |      current in use, potentially by other tasks. Otherwise only disconnect
     |      connections that are idle in the pool.
     |
     |  async ensure_connection(self, connection: redis.asyncio.connection.AbstractConnection)
     |      Ensure that the connection object is connected and valid
     |
     |  get_available_connection(self)
     |      Get a connection from the pool, without making sure it is connected
     |
     |  async get_connection(self, command_name=None, *keys, **options)
     |      Get a connected connection from the pool
     |
     |  get_connection_count(self) -> List[tuple[int, dict]]
     |      Returns a connection count (both idle and in use).
     |
     |  get_encoder(self)
     |      Return an encoder based on encoding settings
     |
     |  get_protocol(self)
     |      Returns:
     |          The RESP protocol version, or ``None`` if the protocol is not specified,
     |          in which case the server default will be used.
     |
     |  make_connection(self)
     |      Create a new connection.  Can be overridden by child classes.
     |
     |  async re_auth_callback(self, token: redis.auth.token.TokenInterface)
     |
     |  async release(self, connection: redis.asyncio.connection.AbstractConnection)
     |      Releases the connection back to the pool
     |
     |  reset(self)
     |
     |  set_retry(self, retry: 'Retry') -> None
     |
     |  async update_active_connections_for_reconnect(self)
     |      Mark all active connections for reconnect.
     |
     |  ----------------------------------------------------------------------
     |  Class methods defined here:
     |
     |  from_url(url: str, **kwargs) -> ~_CP
     |      Return a connection pool configured from the given URL.
     |
     |      For example::
     |
     |          redis://[[username]:[password]]@localhost:6379/0
     |          rediss://[[username]:[password]]@localhost:6379/0
     |          unix://[username@]/path/to/socket.sock?db=0[&password=password]
     |
     |      Three URL schemes are supported:
     |
     |      - `redis://` creates a TCP socket connection. See more at:
     |        <https://www.iana.org/assignments/uri-schemes/prov/redis>
     |      - `rediss://` creates a SSL wrapped TCP socket connection. See more at:
     |        <https://www.iana.org/assignments/uri-schemes/prov/rediss>
     |      - ``unix://``: creates a Unix Domain Socket connection.
     |
     |      The username, password, hostname, path and all querystring values
     |      are passed through urllib.parse.unquote in order to replace any
     |      percent-encoded values with their corresponding characters.
     |
     |      There are several ways to specify a database number. The first value
     |      found will be used:
     |
     |      1. A ``db`` querystring option, e.g. redis://localhost?db=0
     |
     |      2. If using the redis:// or rediss:// schemes, the path argument
     |             of the url, e.g. redis://localhost/0
     |
     |      3. A ``db`` keyword argument to this function.
     |
     |      If none of these options are specified, the default db=0 is used.
     |
     |      All querystring options are cast to their appropriate Python types.
     |      Boolean arguments can be specified with string values "True"/"False"
     |      or "Yes"/"No". Values that cannot be properly cast cause a
     |      ``ValueError`` to be raised. Once parsed, the querystring arguments
     |      and keyword arguments are passed to the ``ConnectionPool``'s
     |      class initializer. In the case of conflicting arguments, querystring
     |      arguments always win.
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors defined here:
     |
     |  connection_kwargs
     |
     |  ----------------------------------------------------------------------
     |  Data and other attributes defined here:
     |
     |  OMIT_REPR_KEYS = frozenset({'himport_registry'})
     |
     |  SENSITIVE_REPR_KEYS = frozenset({'credential_provider', 'password', 's...
     |
     |  __abstractmethods__ = frozenset()
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from AsyncMaintNotificationsAbstractConnectionPool:
     |
     |  async apply_moving_notification(self, notification: redis.maint_notifications.NodeMovingNotification, config: redis.maint_notifications.MaintNotificationsConfig, moving_address_src: str | None, run_proactive_reconnect: bool = False) -> None
     |      Apply the pool state transition for a MOVING notification atomically.
     |
     |      Async pools use a non-reentrant `asyncio.Lock`, so the handler cannot
     |      safely compose several separately locked calls. Existing connection
     |      updates, optional proactive reconnect, and future `connection_kwargs`
     |      changes must happen under one pool-owned lock; otherwise a connection
     |      can move between active/free lists and escape handling.
     |
     |  async cleanup_moving_notification(self, notification_hash: int, reset_relaxed_timeout: bool, reset_host_address: bool) -> None
     |      Revert MOVING pool state atomically after the notification TTL.
     |
     |      Future connection kwargs and existing connection state must be cleaned
     |      up in the same critical section. Splitting the cleanup lets an
     |      acquire/release interleave, which can leave stale MOVING state or undo a
     |      newer overlapping MOVING notification.
     |
     |  maint_notifications_enabled(self)
     |      Returns:
     |          True if the maintenance notifications are enabled, False otherwise.
     |          The maintenance notifications config is stored in the pool handler.
     |          If the pool handler is not set, the maintenance notifications are not enabled.
     |
     |  async run_proactive_reconnect(self, moving_address_src: str | None = None) -> None
     |      Mark active connections and disconnect free connections atomically.
     |
     |      This operation is pool-owned because the active/free lists can change
     |      while tasks acquire or release connections. Keeping the mark/disconnect
     |      pass under one lock avoids a connection moving between lists between
     |      separately locked calls.
     |
     |  update_connection_kwargs(self, **kwargs: Any) -> None
     |      Update the connection kwargs for all future connections.
     |
     |      This method updates the connection kwargs for all future connections created by the pool.
     |      Existing connections are not affected.
     |
     |  update_connection_settings(self, conn: 'AsyncMaintNotificationsAbstractConnection', state: redis.maint_notifications.MaintenanceState | None = None, maintenance_notification_hash: int | None = None, host_address: str | None = None, relaxed_timeout: float | None = None, update_notification_hash: bool = False, reset_host_address: bool = False, reset_relaxed_timeout: bool = False) -> None
     |      Update the settings for a single connection.
     |
     |  async update_connections_settings(self, state: redis.maint_notifications.MaintenanceState | None = None, maintenance_notification_hash: int | None = None, host_address: str | None = None, relaxed_timeout: float | None = None, matching_address: str | None = None, matching_notification_hash: int | None = None, matching_pattern: Literal['connected_address', 'configured_address', 'notification_hash'] = 'connected_address', update_notification_hash: bool = False, reset_host_address: bool = False, reset_relaxed_timeout: bool = False, include_free_connections: bool = True) -> None
     |      Update the settings for all matching connections in the pool.
     |
     |      This method does not create new connections.
     |      This method does not affect the connection kwargs.
     |
     |      :param state: The maintenance state to set for the connection.
     |      :param maintenance_notification_hash: The hash of the maintenance notification
     |                                             to set for the connection.
     |      :param host_address: The host address to set for the connection.
     |      :param relaxed_timeout: The relaxed timeout to set for the connection.
     |      :param matching_address: The address to match for the connection.
     |      :param matching_notification_hash: The notification hash to match for the connection.
     |      :param matching_pattern: The pattern to match for the connection.
     |      :param update_notification_hash: Whether to update the notification hash for the connection.
     |      :param reset_host_address: Whether to reset the host address to the original address.
     |      :param reset_relaxed_timeout: Whether to reset the relaxed timeout to the original timeout.
     |      :param include_free_connections: Whether to include free/available connections.
     |
     |  async update_maint_notifications_config(self, maint_notifications_config: redis.maint_notifications.MaintNotificationsConfig, oss_cluster_maint_notifications_handler: redis.asyncio.maint_notifications.AsyncOSSMaintNotificationsHandler | None = None) -> None
     |      Updates the maintenance notifications configuration.
     |      This method should be called only if the pool was created
     |      without enabling the maintenance notifications and
     |      in a later point in time maintenance notifications
     |      are requested to be enabled.
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors inherited from AsyncMaintNotificationsAbstractConnectionPool:
     |
     |  __dict__
     |      dictionary for instance variables
     |
     |  __weakref__
     |      list of weak references to the object

    class DataError(RedisError)
     |  DataError(*args, status_code: str | None = None)
     |
     |  Method resolution order:
     |      DataError
     |      RedisError
     |      builtins.Exception
     |      builtins.BaseException
     |      builtins.object
     |
     |  Methods inherited from RedisError:
     |
     |  __init__(self, *args, status_code: str | None = None)
     |      Initialize self.  See help(type(self)) for accurate signature.
     |
     |  __repr__(self)
     |      Return repr(self).
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors inherited from RedisError:
     |
     |  __weakref__
     |      list of weak references to the object
     |
     |  ----------------------------------------------------------------------
     |  Static methods inherited from builtins.Exception:
     |
     |  __new__(*args, **kwargs) class method of builtins.Exception
     |      Create and return a new object.  See help(type) for accurate signature.
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from builtins.BaseException:
     |
     |  __getattribute__(self, name, /)
     |      Return getattr(self, name).
     |
     |  __reduce__(...)
     |      Helper for pickle.
     |
     |  __setstate__(...)
     |
     |  __str__(self, /)
     |      Return str(self).
     |
     |  add_note(...)
     |      Exception.add_note(note) --
     |      add a note to the exception
     |
     |  with_traceback(...)
     |      Exception.with_traceback(tb) --
     |      set self.__traceback__ to tb and return self.
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors inherited from builtins.BaseException:
     |
     |  __cause__
     |      exception cause
     |
     |  __context__
     |      exception context
     |
     |  __dict__
     |
     |  __suppress_context__
     |
     |  __traceback__
     |
     |  args

    class InvalidResponse(RedisError)
     |  InvalidResponse(*args, status_code: str | None = None)
     |
     |  Method resolution order:
     |      InvalidResponse
     |      RedisError
     |      builtins.Exception
     |      builtins.BaseException
     |      builtins.object
     |
     |  Methods inherited from RedisError:
     |
     |  __init__(self, *args, status_code: str | None = None)
     |      Initialize self.  See help(type(self)) for accurate signature.
     |
     |  __repr__(self)
     |      Return repr(self).
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors inherited from RedisError:
     |
     |  __weakref__
     |      list of weak references to the object
     |
     |  ----------------------------------------------------------------------
     |  Static methods inherited from builtins.Exception:
     |
     |  __new__(*args, **kwargs) class method of builtins.Exception
     |      Create and return a new object.  See help(type) for accurate signature.
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from builtins.BaseException:
     |
     |  __getattribute__(self, name, /)
     |      Return getattr(self, name).
     |
     |  __reduce__(...)
     |      Helper for pickle.
     |
     |  __setstate__(...)
     |
     |  __str__(self, /)
     |      Return str(self).
     |
     |  add_note(...)
     |      Exception.add_note(note) --
     |      add a note to the exception
     |
     |  with_traceback(...)
     |      Exception.with_traceback(tb) --
     |      set self.__traceback__ to tb and return self.
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors inherited from builtins.BaseException:
     |
     |  __cause__
     |      exception cause
     |
     |  __context__
     |      exception context
     |
     |  __dict__
     |
     |  __suppress_context__
     |
     |  __traceback__
     |
     |  args

    class OutOfMemoryError(ResponseError)
     |  OutOfMemoryError(*args, status_code: str | None = None)
     |
     |  Indicates the database is full. Can only occur when either:
     |    * Redis maxmemory-policy=noeviction
     |    * Redis maxmemory-policy=volatile* and there are no evictable keys
     |
     |  For more information see `Memory optimization in Redis <https://redis.io/docs/management/optimization/memory-optimization/#memory-allocation>`_. # noqa
     |
     |  Method resolution order:
     |      OutOfMemoryError
     |      ResponseError
     |      RedisError
     |      builtins.Exception
     |      builtins.BaseException
     |      builtins.object
     |
     |  Methods inherited from RedisError:
     |
     |  __init__(self, *args, status_code: str | None = None)
     |      Initialize self.  See help(type(self)) for accurate signature.
     |
     |  __repr__(self)
     |      Return repr(self).
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors inherited from RedisError:
     |
     |  __weakref__
     |      list of weak references to the object
     |
     |  ----------------------------------------------------------------------
     |  Static methods inherited from builtins.Exception:
     |
     |  __new__(*args, **kwargs) class method of builtins.Exception
     |      Create and return a new object.  See help(type) for accurate signature.
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from builtins.BaseException:
     |
     |  __getattribute__(self, name, /)
     |      Return getattr(self, name).
     |
     |  __reduce__(...)
     |      Helper for pickle.
     |
     |  __setstate__(...)
     |
     |  __str__(self, /)
     |      Return str(self).
     |
     |  add_note(...)
     |      Exception.add_note(note) --
     |      add a note to the exception
     |
     |  with_traceback(...)
     |      Exception.with_traceback(tb) --
     |      set self.__traceback__ to tb and return self.
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors inherited from builtins.BaseException:
     |
     |  __cause__
     |      exception cause
     |
     |  __context__
     |      exception context
     |
     |  __dict__
     |
     |  __suppress_context__
     |
     |  __traceback__
     |
     |  args

    class PubSubError(RedisError)
     |  PubSubError(*args, status_code: str | None = None)
     |
     |  Method resolution order:
     |      PubSubError
     |      RedisError
     |      builtins.Exception
     |      builtins.BaseException
     |      builtins.object
     |
     |  Methods inherited from RedisError:
     |
     |  __init__(self, *args, status_code: str | None = None)
     |      Initialize self.  See help(type(self)) for accurate signature.
     |
     |  __repr__(self)
     |      Return repr(self).
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors inherited from RedisError:
     |
     |  __weakref__
     |      list of weak references to the object
     |
     |  ----------------------------------------------------------------------
     |  Static methods inherited from builtins.Exception:
     |
     |  __new__(*args, **kwargs) class method of builtins.Exception
     |      Create and return a new object.  See help(type) for accurate signature.
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from builtins.BaseException:
     |
     |  __getattribute__(self, name, /)
     |      Return getattr(self, name).
     |
     |  __reduce__(...)
     |      Helper for pickle.
     |
     |  __setstate__(...)
     |
     |  __str__(self, /)
     |      Return str(self).
     |
     |  add_note(...)
     |      Exception.add_note(note) --
     |      add a note to the exception
     |
     |  with_traceback(...)
     |      Exception.with_traceback(tb) --
     |      set self.__traceback__ to tb and return self.
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors inherited from builtins.BaseException:
     |
     |  __cause__
     |      exception cause
     |
     |  __context__
     |      exception context
     |
     |  __dict__
     |
     |  __suppress_context__
     |
     |  __traceback__
     |
     |  args

    class ReadOnlyError(ResponseError)
     |  ReadOnlyError(*args, status_code: str | None = None)
     |
     |  Method resolution order:
     |      ReadOnlyError
     |      ResponseError
     |      RedisError
     |      builtins.Exception
     |      builtins.BaseException
     |      builtins.object
     |
     |  Methods inherited from RedisError:
     |
     |  __init__(self, *args, status_code: str | None = None)
     |      Initialize self.  See help(type(self)) for accurate signature.
     |
     |  __repr__(self)
     |      Return repr(self).
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors inherited from RedisError:
     |
     |  __weakref__
     |      list of weak references to the object
     |
     |  ----------------------------------------------------------------------
     |  Static methods inherited from builtins.Exception:
     |
     |  __new__(*args, **kwargs) class method of builtins.Exception
     |      Create and return a new object.  See help(type) for accurate signature.
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from builtins.BaseException:
     |
     |  __getattribute__(self, name, /)
     |      Return getattr(self, name).
     |
     |  __reduce__(...)
     |      Helper for pickle.
     |
     |  __setstate__(...)
     |
     |  __str__(self, /)
     |      Return str(self).
     |
     |  add_note(...)
     |      Exception.add_note(note) --
     |      add a note to the exception
     |
     |  with_traceback(...)
     |      Exception.with_traceback(tb) --
     |      set self.__traceback__ to tb and return self.
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors inherited from builtins.BaseException:
     |
     |  __cause__
     |      exception cause
     |
     |  __context__
     |      exception context
     |
     |  __dict__
     |
     |  __suppress_context__
     |
     |  __traceback__
     |
     |  args

    class Redis(redis.client.AbstractRedis, redis.commands.redismodules.AsyncRedisModuleCommands, redis.commands.core.AsyncCoreCommands, redis.commands.sentinel.AsyncSentinelCommands)
     |  Redis(*, host: str = 'localhost', port: int = 6379, db: str | int = 0, password: str | None = None, socket_timeout: float | None = 5, socket_connect_timeout: float | None = 5, socket_read_size: int = 32768, socket_keepalive: bool | None = True, socket_keepalive_options: Union[Mapping[int, int | bytes], object, NoneType] = <object object at 0x0000017B991493E0>, connection_pool: redis.asyncio.connection.ConnectionPool | None = None, unix_socket_path: str | None = None, encoding: str = 'utf-8', encoding_errors: str = 'strict', decode_responses: bool = False, retry_on_timeout: bool = False, retry: redis.asyncio.retry.Retry = <redis.asyncio.retry.Retry object at 0x0000017B9C6BE4B0>, retry_on_error: list | None = None, ssl: bool = False, ssl_keyfile: str | None = None, ssl_certfile: str | None = None, ssl_cert_reqs: 'str | VerifyMode' = 'required', ssl_include_verify_flags: Optional[List[ForwardRef('VerifyFlags')]] = None, ssl_exclude_verify_flags: Optional[List[ForwardRef('VerifyFlags')]] = None, ssl_ca_certs: str | None = None, ssl_ca_data: str | None = None, ssl_ca_path: str | None = None, ssl_check_hostname: bool = True, ssl_min_version: 'TLSVersion | None' = None, ssl_ciphers: str | None = None, ssl_password: str | None = None, max_connections: int | None = None, single_connection_client: bool = False, health_check_interval: int = 0, client_name: str | None = None, lib_name: str | object | None = <object object at 0x0000017B991493E0>, lib_version: str | object | None = <object object at 0x0000017B991493E0>, driver_info: redis.driver_info.DriverInfo | object | None = <object object at 0x0000017B991493E0>, username: str | None = None, auto_close_connection_pool: bool | None = None, redis_connect_func=None, credential_provider: redis.credentials.CredentialProvider | None = None, protocol: int | None = None, legacy_responses: bool = True, event_dispatcher: redis.event.EventDispatcher | None = None, maint_notifications_config: redis.maint_notifications.MaintNotificationsConfig | None = None)
     |
     |  Implementation of the Redis protocol.
     |
     |  This abstract class provides a Python interface to all Redis commands
     |  and an implementation of the Redis protocol.
     |
     |  Pipelines derive from this, implementing how
     |  the commands are sent and received to the Redis server. Based on
     |  configuration, an instance will either use a ConnectionPool, or
     |  Connection object to talk to redis.
     |
     |  Method resolution order:
     |      Redis
     |      redis.client.AbstractRedis
     |      redis.commands.redismodules.AsyncRedisModuleCommands
     |      redis.commands.redismodules.RedisModuleCommands
     |      redis.commands.core.AsyncCoreCommands
     |      redis.commands.core.ACLCommands
     |      redis.commands.core.ClusterCommands
     |      redis.commands.core.AsyncDataAccessCommands
     |      redis.commands.core.AsyncBasicKeyCommands
     |      redis.commands.core.BasicKeyCommands
     |      redis.commands.core.HyperlogCommands
     |      redis.commands.core.HashCommands
     |      redis.commands.core.GeoCommands
     |      redis.commands.core.ListCommands
     |      redis.commands.core.ArrayCommands
     |      redis.commands.core.AsyncScanCommands
     |      redis.commands.core.ScanCommands
     |      redis.commands.core.SetCommands
     |      redis.commands.core.StreamCommands
     |      redis.commands.core.SortedSetCommands
     |      redis.commands.core.AsyncManagementCommands
     |      redis.commands.core.ManagementCommands
     |      redis.commands.core.AsyncModuleCommands
     |      redis.commands.core.ModuleCommands
     |      redis.commands.core.PubSubCommands
     |      redis.commands.core.AsyncScriptCommands
     |      redis.commands.core.ScriptCommands
     |      redis.typing.CommandsProtocol
     |      typing.Protocol
     |      typing.Generic
     |      redis.commands.core.FunctionCommands
     |      redis.commands.sentinel.AsyncSentinelCommands
     |      redis.commands.sentinel.SentinelCommands
     |      builtins.object
     |
     |  Methods defined here:
     |
     |  async __aenter__(self: ~_RedisT) -> ~_RedisT
     |      Async context manager entry. Increments a usage counter so that the
     |      connection pool is only closed (via aclose()) when no context is using
     |      the client.
     |
     |  async __aexit__(self, exc_type, exc_value, traceback)
     |      Async context manager exit. Decrements a usage counter. If this is the
     |      last exit (counter becomes zero), the client closes its connection pool.
     |
     |  __await__(self)
     |
     |  __del__(self, _warn: Any = <built-in function warn>, _grl: Any = <built-in function get_running_loop>) -> None
     |      # passing _warnings and _grl as argument default since they may be gone
     |      # by the time __del__ is called at shutdown
     |
     |  __init__(self, *, host: str = 'localhost', port: int = 6379, db: str | int = 0, password: str | None = None, socket_timeout: float | None = 5, socket_connect_timeout: float | None = 5, socket_read_size: int = 32768, socket_keepalive: bool | None = True, socket_keepalive_options: Union[Mapping[int, int | bytes], object, NoneType] = <object object at 0x0000017B991493E0>, connection_pool: redis.asyncio.connection.ConnectionPool | None = None, unix_socket_path: str | None = None, encoding: str = 'utf-8', encoding_errors: str = 'strict', decode_responses: bool = False, retry_on_timeout: bool = False, retry: redis.asyncio.retry.Retry = <redis.asyncio.retry.Retry object at 0x0000017B9C6BE4B0>, retry_on_error: list | None = None, ssl: bool = False, ssl_keyfile: str | None = None, ssl_certfile: str | None = None, ssl_cert_reqs: 'str | VerifyMode' = 'required', ssl_include_verify_flags: Optional[List[ForwardRef('VerifyFlags')]] = None, ssl_exclude_verify_flags: Optional[List[ForwardRef('VerifyFlags')]] = None, ssl_ca_certs: str | None = None, ssl_ca_data: str | None = None, ssl_ca_path: str | None = None, ssl_check_hostname: bool = True, ssl_min_version: 'TLSVersion | None' = None, ssl_ciphers: str | None = None, ssl_password: str | None = None, max_connections: int | None = None, single_connection_client: bool = False, health_check_interval: int = 0, client_name: str | None = None, lib_name: str | object | None = <object object at 0x0000017B991493E0>, lib_version: str | object | None = <object object at 0x0000017B991493E0>, driver_info: redis.driver_info.DriverInfo | object | None = <object object at 0x0000017B991493E0>, username: str | None = None, auto_close_connection_pool: bool | None = None, redis_connect_func=None, credential_provider: redis.credentials.CredentialProvider | None = None, protocol: int | None = None, legacy_responses: bool = True, event_dispatcher: redis.event.EventDispatcher | None = None, maint_notifications_config: redis.maint_notifications.MaintNotificationsConfig | None = None)
     |      Initialize a new Redis client.
     |
     |      To specify a retry policy for specific errors, you have two options:
     |
     |      1. Set the `retry_on_error` to a list of the error/s to retry on, and
     |      you can also set `retry` to a valid `Retry` object(in case the default
     |      one is not appropriate) - with this approach the retries will be triggered
     |      on the default errors specified in the Retry object enriched with the
     |      errors specified in `retry_on_error`.
     |
     |      2. Define a `Retry` object with configured 'supported_errors' and set
     |      it to the `retry` parameter - with this approach you completely redefine
     |      the errors on which retries will happen.
     |
     |      `retry_on_timeout` is deprecated - please include the TimeoutError
     |      either in the Retry object or in the `retry_on_error` list.
     |
     |      When 'connection_pool' is provided - the retry configuration of the
     |      provided pool will be used.
     |
     |      Args:
     |
     |      socket_keepalive:
     |          if `True`, TCP keepalive is enabled for TCP socket connections.
     |          Argument is ignored when connection_pool is provided.
     |      socket_keepalive_options:
     |          mapping of TCP keepalive socket option constants to values, for
     |          example `{socket.TCP_KEEPIDLE: 30}`. If left unspecified, redis-py
     |          uses TCP keepalive defaults when `socket_keepalive` is enabled:
     |          idle 30 seconds, interval 5 seconds, and 3 probes. Platform-specific
     |          options that are not available are skipped. Pass `None` or `{}` to
     |          avoid setting additional TCP keepalive options. Argument is ignored
     |          when connection_pool is provided.
     |      maint_notifications_config:
     |          configures the pool to support maintenance notifications - see
     |          `redis.maint_notifications.MaintNotificationsConfig` for details.
     |          Only supported with RESP3
     |          If not provided and protocol is RESP3, the maintenance notifications
     |          will be enabled by default (logic is included in the connection pool
     |          initialization).
     |          Argument is ignored when connection_pool is provided.
     |
     |  __repr__(self)
     |      Return repr(self).
     |
     |  async aclose(self, close_connection_pool: Optional[bool] = None) -> None
     |      Closes Redis client connection
     |
     |      Args:
     |          close_connection_pool:
     |              decides whether to close the connection pool used by this Redis client,
     |              overriding Redis.auto_close_connection_pool.
     |              By default, let Redis.auto_close_connection_pool decide
     |              whether to close the connection pool.
     |
     |  client(self) -> 'Redis'
     |
     |  async close(self, close_connection_pool: Optional[bool] = None) -> None
     |      Alias for aclose(), for backwards compatibility
     |
     |  async execute_command(self, *args, **options)
     |      Execute a command and return a parsed response
     |
     |  get_connection_kwargs(self)
     |      Get the connection's key-word arguments
     |
     |  get_encoder(self)
     |      Get the connection pool's encoder
     |
     |  get_retry(self) -> Optional[redis.asyncio.retry.Retry]
     |
     |  async himport_discard(self, fieldset_name: str) -> int
     |      Remove a fieldset from the registry.
     |
     |  async himport_discard_all(self) -> int
     |      Remove all fieldsets from the registry.
     |
     |  async himport_prepare(self, fieldset_name: str, fields: Iterable[Union[bytes, bytearray, memoryview, str, int, float]]) -> bool
     |      Declare an HIMPORT fieldset for use by :meth:`himport_set`.
     |
     |  async initialize(self: ~_RedisT) -> ~_RedisT
     |
     |  keyspace_notifications(self, key_prefix: Union[str, bytes, NoneType] = None, ignore_subscribe_messages: bool = True) -> 'AsyncKeyspaceNotifications'
     |      Return an :class:`~redis.asyncio.keyspace_notifications.AsyncKeyspaceNotifications`
     |      object for subscribing to keyspace and keyevent notifications.
     |
     |      Note: Keyspace notifications must be enabled on the Redis server via
     |      the ``notify-keyspace-events`` configuration option.
     |
     |      Args:
     |          key_prefix: Optional prefix to filter and strip from keys in
     |                      notifications.
     |          ignore_subscribe_messages: If True, subscribe/unsubscribe
     |                                    confirmations are not returned by
     |                                    get_message/listen.
     |
     |  load_external_module(self, funcname, func)
     |      This function can be used to add externally defined redis modules,
     |      and their namespaces to the redis client.
     |
     |      funcname - A string containing the name of the function to create
     |      func - The function, being added to this class.
     |
     |      ex: Assume that one has a custom redis module named foomod that
     |      creates command named 'foo.dothing' and 'foo.anotherthing' in redis.
     |      To load function functions into this namespace:
     |
     |      from redis import Redis
     |      from foomodule import F
     |      r = Redis()
     |      r.load_external_module("foo", F)
     |      r.foo().dothing('your', 'arguments')
     |
     |      For a concrete example see the reimport of the redisjson module in
     |      tests/test_connection.py::test_loading_external_modules
     |
     |  lock(self, name: Union[bytes, str, memoryview], timeout: Optional[float] = None, sleep: float = 0.1, blocking: bool = True, blocking_timeout: Optional[float] = None, lock_class: Optional[Type[redis.asyncio.lock.Lock]] = None, thread_local: bool = True, raise_on_release_error: bool = True) -> redis.asyncio.lock.Lock
     |      Return a new Lock object using key ``name`` that mimics
     |      the behavior of threading.Lock.
     |
     |      If specified, ``timeout`` indicates a maximum life for the lock.
     |      By default, it will remain locked until release() is called.
     |
     |      ``sleep`` indicates the amount of time to sleep per loop iteration
     |      when the lock is in blocking mode and another client is currently
     |      holding the lock.
     |
     |      ``blocking`` indicates whether calling ``acquire`` should block until
     |      the lock has been acquired or to fail immediately, causing ``acquire``
     |      to return False and the lock not being acquired. Defaults to True.
     |      Note this value can be overridden by passing a ``blocking``
     |      argument to ``acquire``.
     |
     |      ``blocking_timeout`` indicates the maximum amount of time in seconds to
     |      spend trying to acquire the lock. A value of ``None`` indicates
     |      continue trying forever. ``blocking_timeout`` can be specified as a
     |      float or integer, both representing the number of seconds to wait.
     |
     |      ``lock_class`` forces the specified lock implementation. Note that as
     |      of redis-py 3.0, the only lock class we implement is ``Lock`` (which is
     |      a Lua-based lock). So, it's unlikely you'll need this parameter, unless
     |      you have created your own custom lock class.
     |
     |      ``thread_local`` indicates whether the lock token is placed in
     |      thread-local storage. By default, the token is placed in thread local
     |      storage so that a thread only sees its token, not a token set by
     |      another thread. Consider the following timeline:
     |
     |          time: 0, thread-1 acquires `my-lock`, with a timeout of 5 seconds.
     |                   thread-1 sets the token to "abc"
     |          time: 1, thread-2 blocks trying to acquire `my-lock` using the
     |                   Lock instance.
     |          time: 5, thread-1 has not yet completed. redis expires the lock
     |                   key.
     |          time: 5, thread-2 acquired `my-lock` now that it's available.
     |                   thread-2 sets the token to "xyz"
     |          time: 6, thread-1 finishes its work and calls release(). if the
     |                   token is *not* stored in thread local storage, then
     |                   thread-1 would see the token value as "xyz" and would be
     |                   able to successfully release the thread-2's lock.
     |
     |      ``raise_on_release_error`` indicates whether to raise an exception when
     |      the lock is no longer owned when exiting the context manager. By default,
     |      this is True, meaning an exception will be raised. If False, the warning
     |      will be logged and the exception will be suppressed.
     |
     |      In some use cases it's necessary to disable thread local storage. For
     |      example, if you have code where one thread acquires a lock and passes
     |      that lock instance to a worker thread to release later. If thread
     |      local storage isn't disabled in this case, the worker thread won't see
     |      the token set by the thread that acquired the lock. Our assumption
     |      is that these cases aren't common and as such default to using
     |      thread local storage.
     |
     |  monitor(self) -> 'Monitor'
     |
     |  async parse_response(self, connection: redis.asyncio.connection.Connection, command_name: Union[str, bytes], **options)
     |      Parses a response from the Redis server
     |
     |  pipeline(self, transaction: bool = True, shard_hint: Optional[str] = None) -> 'Pipeline'
     |      Return a new pipeline object that can queue multiple commands for
     |      later execution. ``transaction`` indicates whether all commands
     |      should be executed atomically. Apart from making a group of operations
     |      atomic, pipelines are useful for reducing the back-and-forth overhead
     |      between the client and server.
     |
     |  pubsub(self, **kwargs) -> 'PubSub'
     |      Return a Publish/Subscribe object. With this object, you can
     |      subscribe to channels and listen for messages that get published to
     |      them.
     |
     |  set_response_callback(self, command: str, callback: Union[redis.asyncio.client.ResponseCallbackProtocol, redis.asyncio.client.AsyncResponseCallbackProtocol])
     |      Set a custom Response Callback
     |
     |  set_retry(self, retry: redis.asyncio.retry.Retry) -> None
     |
     |  async transaction(self, func: Callable[[ForwardRef('Pipeline')], Union[Any, Awaitable[Any]]], *watches: Union[bytes, str, memoryview], shard_hint: Optional[str] = None, value_from_callable: bool = False, watch_delay: Optional[float] = None)
     |      Convenience method for executing the callable `func` as a transaction
     |      while watching all keys specified in `watches`. The 'func' callable
     |      should expect a single argument which is a Pipeline object.
     |
     |  ----------------------------------------------------------------------
     |  Class methods defined here:
     |
     |  __subclasshook__ = _proto_hook(other) from typing
     |
     |  from_pool(connection_pool: redis.asyncio.connection.ConnectionPool) -> 'Redis'
     |      Return a Redis client from the given connection pool.
     |      The Redis client will take ownership of the connection pool and
     |      close it when the Redis client is closed.
     |
     |      Because the client closes (disconnects all connections in) the pool
     |      when it is closed or garbage-collected, the pool must not be shared
     |      with other clients. Constructing multiple clients from the same pool
     |      via ``from_pool`` -- for example one per request across tasks -- is
     |      not safe: when one client is closed it will disconnect connections
     |      still in use by the others.
     |
     |      To share a single pool across clients, construct the pool explicitly
     |      and manage its lifecycle instead. Unlike ``from_pool``, the plain
     |      ``Redis(connection_pool=pool)`` constructor does not take ownership of
     |      the pool and will not close it, so a pool created this way can be
     |      safely shared across clients. ``ConnectionPool`` supports the async
     |      context manager protocol for this::
     |
     |          async with ConnectionPool.from_url(url) as pool:
     |              r = Redis(connection_pool=pool)
     |
     |  from_url(url: str, single_connection_client: bool = False, auto_close_connection_pool: Optional[bool] = None, **kwargs) -> 'Redis'
     |      Return a Redis client object configured from the given URL
     |
     |      For example::
     |
     |          redis://[[username]:[password]]@localhost:6379/0
     |          rediss://[[username]:[password]]@localhost:6379/0
     |          unix://[username@]/path/to/socket.sock?db=0[&password=password]
     |
     |      Three URL schemes are supported:
     |
     |      - `redis://` creates a TCP socket connection. See more at:
     |        <https://www.iana.org/assignments/uri-schemes/prov/redis>
     |      - `rediss://` creates a SSL wrapped TCP socket connection. See more at:
     |        <https://www.iana.org/assignments/uri-schemes/prov/rediss>
     |      - ``unix://``: creates a Unix Domain Socket connection.
     |
     |      The username, password, hostname, path and all querystring values
     |      are passed through urllib.parse.unquote in order to replace any
     |      percent-encoded values with their corresponding characters.
     |
     |      There are several ways to specify a database number. The first value
     |      found will be used:
     |
     |      1. A ``db`` querystring option, e.g. redis://localhost?db=0
     |
     |      2. If using the redis:// or rediss:// schemes, the path argument
     |             of the url, e.g. redis://localhost/0
     |
     |      3. A ``db`` keyword argument to this function.
     |
     |      If none of these options are specified, the default db=0 is used.
     |
     |      All querystring options are cast to their appropriate Python types.
     |      Boolean arguments can be specified with string values "True"/"False"
     |      or "Yes"/"No". Values that cannot be properly cast cause a
     |      ``ValueError`` to be raised. Once parsed, the querystring arguments
     |      and keyword arguments are passed to the ``ConnectionPool``'s
     |      class initializer. In the case of conflicting arguments, querystring
     |      arguments always win.
     |
     |  ----------------------------------------------------------------------
     |  Readonly properties defined here:
     |
     |  himport_registry
     |      The client's HIMPORT fieldset registry (empty if none was declared).
     |
     |      Read-only: the registry is mutated only through the HIMPORT command methods.
     |
     |  ----------------------------------------------------------------------
     |  Data and other attributes defined here:
     |
     |  __abstractmethods__ = frozenset()
     |
     |  __annotations__ = {'_is_async_client': typing.Literal[True], 'response...
     |
     |  __parameters__ = ()
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors inherited from redis.client.AbstractRedis:
     |
     |  __dict__
     |      dictionary for instance variables
     |
     |  __weakref__
     |      list of weak references to the object
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from redis.commands.redismodules.AsyncRedisModuleCommands:
     |
     |  bf(self) -> 'AsyncBFBloom'
     |      Access the bloom namespace.
     |
     |  cf(self) -> 'AsyncCFBloom'
     |      Access the bloom namespace.
     |
     |  cms(self) -> 'AsyncCMSBloom'
     |      Access the bloom namespace.
     |
     |  ft(self, index_name='idx') -> 'AsyncSearch'
     |      Access the search namespace, providing support for redis search.
     |
     |  json(self, encoder=<json.encoder.JSONEncoder object at 0x0000017B9C589190>, decoder=<json.decoder.JSONDecoder object at 0x0000017B9C589220>) -> 'AsyncJSON'
     |      Access the json namespace, providing support for redis json.
     |
     |  tdigest(self) -> 'AsyncTDigestBloom'
     |      Access the bloom namespace.
     |
     |  topk(self) -> 'AsyncTOPKBloom'
     |      Access the bloom namespace.
     |
     |  ts(self) -> 'AsyncTimeSeries'
     |      Access the timeseries namespace, providing support for
     |      redis timeseries data.
     |
     |  vset(self) -> 'AsyncVectorSet'
     |      Access the VectorSet commands namespace.
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from redis.commands.core.ACLCommands:
     |
     |  acl_cat(self, category: 'str | None' = None, **kwargs) -> 'list[bytes | str] | Awaitable[list[bytes | str]]'
     |      Returns a list of categories or commands within a category.
     |
     |      If ``category`` is not supplied, returns a list of all categories.
     |      If ``category`` is supplied, returns a list of all commands within
     |      that category.
     |
     |      For more information, see https://redis.io/commands/acl-cat
     |
     |  acl_deluser(self, *username: 'str', **kwargs) -> 'int | Awaitable[int]'
     |      Delete the ACL for the specified ``username``\s
     |
     |      For more information, see https://redis.io/commands/acl-deluser
     |
     |  acl_dryrun(self, username: 'str', *args: 'EncodableT', **kwargs) -> 'bytes | str | Awaitable[bytes | str]'
     |      Simulate the execution of a given command by a given ``username``.
     |
     |      For more information, see https://redis.io/commands/acl-dryrun
     |
     |  acl_genpass(self, bits: 'int | None' = None, **kwargs) -> 'bytes | str | Awaitable[bytes | str]'
     |      Generate a random password value.
     |      If ``bits`` is supplied then use this number of bits, rounded to
     |      the next multiple of 4.
     |      See: https://redis.io/commands/acl-genpass
     |
     |  acl_getuser(self, username: 'str', **kwargs) -> 'ACLGetUserData | Awaitable[ACLGetUserData]'
     |      Get the ACL details for the specified ``username``.
     |
     |      If ``username`` does not exist, return None
     |
     |      For more information, see https://redis.io/commands/acl-getuser
     |
     |  acl_help(self, **kwargs) -> 'list[bytes | str] | Awaitable[list[bytes | str]]'
     |      The ACL HELP command returns helpful text describing
     |      the different subcommands.
     |
     |      For more information, see https://redis.io/commands/acl-help
     |
     |  acl_list(self, **kwargs) -> 'list[bytes | str] | Awaitable[list[bytes | str]]'
     |      Return a list of all ACLs on the server
     |
     |      For more information, see https://redis.io/commands/acl-list
     |
     |  acl_load(self, **kwargs) -> 'bool | Awaitable[bool]'
     |      Load ACL rules from the configured ``aclfile``.
     |
     |      Note that the server must be configured with the ``aclfile``
     |      directive to be able to load ACL rules from an aclfile.
     |
     |      For more information, see https://redis.io/commands/acl-load
     |
     |  acl_log(self, count: 'int | None' = None, **kwargs) -> 'ACLLogData | Awaitable[ACLLogData]'
     |      Get ACL logs as a list.
     |      :param int count: Get logs[0:count].
     |      :rtype: List.
     |
     |      For more information, see https://redis.io/commands/acl-log
     |
     |  acl_log_reset(self, **kwargs) -> 'bool | Awaitable[bool]'
     |      Reset ACL logs.
     |      :rtype: Boolean.
     |
     |      For more information, see https://redis.io/commands/acl-log
     |
     |  acl_save(self, **kwargs) -> 'bool | Awaitable[bool]'
     |      Save ACL rules to the configured ``aclfile``.
     |
     |      Note that the server must be configured with the ``aclfile``
     |      directive to be able to save ACL rules to an aclfile.
     |
     |      For more information, see https://redis.io/commands/acl-save
     |
     |  acl_setuser(self, username: 'str', enabled: 'bool' = False, nopass: 'bool' = False, passwords: 'str | Iterable[str] | None' = None, hashed_passwords: 'str | Iterable[str] | None' = None, categories: 'Iterable[str] | None' = None, commands: 'Iterable[str] | None' = None, keys: 'Iterable[KeyT] | None' = None, channels: 'Iterable[ChannelT] | None' = None, selectors: 'Iterable[Tuple[str, KeyT]] | None' = None, reset: 'bool' = False, reset_keys: 'bool' = False, reset_channels: 'bool' = False, reset_passwords: 'bool' = False, **kwargs) -> 'bool | Awaitable[bool]'
     |      Create or update an ACL user.
     |
     |      Create or update the ACL for `username`. If the user already exists,
     |      the existing ACL is completely overwritten and replaced with the
     |      specified values.
     |
     |      For more information, see https://redis.io/commands/acl-setuser
     |
     |      Args:
     |          username: The name of the user whose ACL is to be created or updated.
     |          enabled: Indicates whether the user should be allowed to authenticate.
     |                   Defaults to `False`.
     |          nopass: Indicates whether the user can authenticate without a password.
     |                  This cannot be `True` if `passwords` are also specified.
     |          passwords: A list of plain text passwords to add to or remove from the user.
     |                     Each password must be prefixed with a '+' to add or a '-' to
     |                     remove. For convenience, a single prefixed string can be used
     |                     when adding or removing a single password.
     |          hashed_passwords: A list of SHA-256 hashed passwords to add to or remove
     |                            from the user. Each hashed password must be prefixed with
     |                            a '+' to add or a '-' to remove. For convenience, a single
     |                            prefixed string can be used when adding or removing a
     |                            single password.
     |          categories: A list of strings representing category permissions. Each string
     |                      must be prefixed with either a '+' to add the category
     |                      permission or a '-' to remove the category permission.
     |          commands: A list of strings representing command permissions. Each string
     |                    must be prefixed with either a '+' to add the command permission
     |                    or a '-' to remove the command permission.
     |          keys: A list of key patterns to grant the user access to. Key patterns allow
     |                ``'*'`` to support wildcard matching. For example, ``'*'`` grants
     |                access to all keys while ``'cache:*'`` grants access to all keys that
     |                are prefixed with ``cache:``.
     |                `keys` should not be prefixed with a ``'~'``.
     |          reset: Indicates whether the user should be fully reset prior to applying
     |                 the new ACL. Setting this to `True` will remove all existing
     |                 passwords, flags, and privileges from the user and then apply the
     |                 specified rules. If `False`, the user's existing passwords, flags,
     |                 and privileges will be kept and any new specified rules will be
     |                 applied on top.
     |          reset_keys: Indicates whether the user's key permissions should be reset
     |                      prior to applying any new key permissions specified in `keys`.
     |                      If `False`, the user's existing key permissions will be kept and
     |                      any new specified key permissions will be applied on top.
     |          reset_channels: Indicates whether the user's channel permissions should be
     |                          reset prior to applying any new channel permissions
     |                          specified in `channels`. If `False`, the user's existing
     |                          channel permissions will be kept and any new specified
     |                          channel permissions will be applied on top.
     |          reset_passwords: Indicates whether to remove all existing passwords and the
     |                           `nopass` flag from the user prior to applying any new
     |                           passwords specified in `passwords` or `hashed_passwords`.
     |                           If `False`, the user's existing passwords and `nopass`
     |                           status will be kept and any new specified passwords or
     |                           hashed passwords will be applied on top.
     |
     |  acl_users(self, **kwargs) -> 'list[bytes | str] | Awaitable[list[bytes | str]]'
     |      Returns a list of all registered users on the server.
     |
     |      For more information, see https://redis.io/commands/acl-users
     |
     |  acl_whoami(self, **kwargs) -> 'bytes | str | Awaitable[bytes | str]'
     |      Get the username for the current connection
     |
     |      For more information, see https://redis.io/commands/acl-whoami
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from redis.commands.core.ClusterCommands:
     |
     |  cluster(self, cluster_arg, *args, **kwargs) -> 'Any | Awaitable[Any]'
     |
     |  readonly(self, **kwargs) -> 'bool | Awaitable[bool]'
     |      Enables read queries for a connection to a Redis Cluster replica node.
     |
     |      For more information, see https://redis.io/commands/readonly
     |
     |  readwrite(self, **kwargs) -> 'bool | Awaitable[bool]'
     |      Disables read queries for a connection to a Redis Cluster slave node.
     |
     |      For more information, see https://redis.io/commands/readwrite
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from redis.commands.core.AsyncBasicKeyCommands:
     |
     |  __contains__(self, name: 'KeyT')
     |      Returns the number of ``names`` that exist
     |
     |      For more information, see https://redis.io/commands/exists
     |
     |  __delitem__(self, name: 'KeyT')
     |
     |  __getitem__(self, name: 'KeyT')
     |      Return the value at key ``name``, raises a KeyError if the key
     |      doesn't exist.
     |
     |  __setitem__(self, name: 'KeyT', value: 'EncodableT')
     |
     |  async unwatch(self) -> 'None'
     |      Unwatches all previously watched keys for a transaction
     |
     |      For more information, see https://redis.io/commands/unwatch
     |
     |  async watch(self, *names: 'KeyT') -> 'None'
     |      Watches the values at keys ``names``, or None if the key doesn't exist
     |
     |      For more information, see https://redis.io/commands/watch
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from redis.commands.core.BasicKeyCommands:
     |
     |  append(self, key: 'KeyT', value: 'EncodableT') -> 'int | Awaitable[int]'
     |      Appends the string ``value`` to the value at ``key``. If ``key``
     |      doesn't already exist, create it with a value of ``value``.
     |      Returns the new length of the value at ``key``.
     |
     |      For more information, see https://redis.io/commands/append
     |
     |  bitcount(self, key: 'KeyT', start: 'int | None' = None, end: 'int | None' = None, mode: 'str | None' = None) -> 'int | Awaitable[int]'
     |      Returns the count of set bits in the value of ``key``.  Optional
     |      ``start`` and ``end`` parameters indicate which bytes to consider
     |
     |      For more information, see https://redis.io/commands/bitcount
     |
     |  bitfield(self: "Union['redis.client.Redis', 'redis.asyncio.client.Redis']", key: 'KeyT', default_overflow: 'str | None' = None) -> 'BitFieldOperation'
     |      Return a BitFieldOperation instance to conveniently construct one or
     |      more bitfield operations on ``key``.
     |
     |      For more information, see https://redis.io/commands/bitfield
     |
     |  bitfield_ro(self: "Union['redis.client.Redis', 'redis.asyncio.client.Redis']", key: 'KeyT', encoding: 'str', offset: 'BitfieldOffsetT', items: 'list[tuple[str, BitfieldOffsetT]] | None' = None) -> 'list[int] | Awaitable[list[int]]'
     |      Return an array of the specified bitfield values
     |      where the first value is found using ``encoding`` and ``offset``
     |      parameters and remaining values are result of corresponding
     |      encoding/offset pairs in optional list ``items``
     |      Read-only variant of the BITFIELD command.
     |
     |      For more information, see https://redis.io/commands/bitfield_ro
     |
     |  bitop(self, operation: 'str', dest: 'KeyT', *keys: 'KeyT') -> 'int | Awaitable[int]'
     |      Perform a bitwise operation using ``operation`` between ``keys`` and
     |      store the result in ``dest``.
     |
     |      For more information, see https://redis.io/commands/bitop
     |
     |  bitpos(self, key: 'KeyT', bit: 'int', start: 'int | None' = None, end: 'int | None' = None, mode: 'str | None' = None) -> 'int | Awaitable[int]'
     |      Return the position of the first bit set to 1 or 0 in a string.
     |      ``start`` and ``end`` defines search range. The range is interpreted
     |      as a range of bytes and not a range of bits, so start=0 and end=2
     |      means to look at the first three bytes.
     |
     |      For more information, see https://redis.io/commands/bitpos
     |
     |  blmove(self, first_list: 'str', second_list: 'str', timeout: 'int', src: 'str' = 'LEFT', dest: 'str' = 'RIGHT') -> 'bytes | str | None | Awaitable[bytes | str | None]'
     |      Blocking version of lmove.
     |
     |      For more information, see https://redis.io/commands/blmove
     |
     |  blmovem(self, first_list: 'str', second_list: 'str', timeout: 'float', src: 'str' = 'LEFT', dest: 'str' = 'RIGHT', count: 'int | None' = None, mode: "Literal['COUNT', 'EXACTLY'] | None" = None, ordering: "Literal['OBO', 'BULK'] | None" = None) -> 'list[bytes | str] | None | Awaitable[list[bytes | str] | None]'
     |      Blocking version of lmovem.
     |
     |      Blocks until elements are available to move or ``timeout`` (in seconds)
     |      is reached; a ``timeout`` of ``0`` blocks indefinitely. With ``COUNT``
     |      the command unblocks once at least one element is available and moves
     |      ``min(count, available)``; with ``EXACTLY`` it blocks until the source
     |      holds at least ``count`` elements, then moves exactly ``count``
     |      atomically. On timeout ``None`` is returned and nothing is moved.
     |
     |      As with ``lmovem``, ``ordering`` (OBO or BULK) is required whenever
     |      ``count`` is given.
     |
     |      For more information, see https://redis.io/commands/blmovem
     |
     |  copy(self, source: 'str', destination: 'str', destination_db: 'str | None' = None, replace: 'bool' = False) -> 'bool | Awaitable[bool]'
     |      Copy the value stored in the ``source`` key to the ``destination`` key.
     |
     |      ``destination_db`` an alternative destination database. By default,
     |      the ``destination`` key is created in the source Redis database.
     |
     |      ``replace`` whether the ``destination`` key should be removed before
     |      copying the value to it. By default, the value is not copied if
     |      the ``destination`` key already exists.
     |
     |      For more information, see https://redis.io/commands/copy
     |
     |  decr = decrby(self, name: 'KeyT', amount: 'int' = 1) -> 'int | Awaitable[int]'
     |
     |  decrby(self, name: 'KeyT', amount: 'int' = 1) -> 'int | Awaitable[int]'
     |      Decrements the value of ``key`` by ``amount``.  If no key exists,
     |      the value will be initialized as 0 - ``amount``
     |
     |      For more information, see https://redis.io/commands/decrby
     |
     |  delete(self, *names: 'KeyT') -> 'int | Awaitable[int]'
     |      Delete one or more keys specified by ``names``
     |
     |  delex(self, name: 'KeyT', ifeq: 'bytes | str | None' = None, ifne: 'bytes | str | None' = None, ifdeq: 'str | None' = None, ifdne: 'str | None' = None) -> 'int | Awaitable[int]'
     |      Conditionally removes the specified key.
     |
     |      Warning:
     |      **Experimental** since 7.1.
     |      This API may change or be removed without notice.
     |      The API may change based on feedback.
     |
     |      Arguments:
     |          name: KeyT - the key to delete
     |          ifeq match-valu: Optional[Union[bytes, str]] - Delete the key only if its value is equal to match-value
     |          ifne match-value: Optional[Union[bytes, str]] - Delete the key only if its value is not equal to match-value
     |          ifdeq match-digest: Optional[str] - Delete the key only if the digest of its value is equal to match-digest
     |          ifdne match-digest: Optional[str] - Delete the key only if the digest of its value is not equal to match-digest
     |
     |      Returns:
     |          int: 1 if the key was deleted, 0 otherwise.
     |      Raises:
     |          redis.exceptions.ResponseError: if key exists but is not a string
     |                                          and a condition is specified.
     |          ValueError: if more than one condition is provided.
     |
     |
     |      Requires Redis 8.4 or greater.
     |      For more information, see https://redis.io/commands/delex
     |
     |  digest(self, name: 'KeyT') -> 'str | bytes | None | Awaitable[str | bytes | None]'
     |      Return the digest of the value stored at the specified key.
     |
     |      Warning:
     |      **Experimental** since 7.1.
     |      This API may change or be removed without notice.
     |      The API may change based on feedback.
     |
     |      Arguments:
     |        - name: KeyT - the key to get the digest of
     |
     |      Returns:
     |        - None if the key does not exist
     |        - (bulk string) the XXH3 digest of the value as a hex string
     |      Raises:
     |        - ResponseError if key exists but is not a string
     |
     |
     |      Requires Redis 8.4 or greater.
     |      For more information, see https://redis.io/commands/digest
     |
     |  digest_local(self, value: 'bytes | str') -> 'bytes | str'
     |      Compute the hexadecimal digest of the value locally, without sending it to the server.
     |
     |      This is useful for conditional operations like IFDEQ/IFDNE where you need to
     |      compute the digest client-side before sending a command.
     |
     |      Warning:
     |      **Experimental** - This API may change or be removed without notice.
     |
     |      Arguments:
     |        - value: Union[bytes, str] - the value to compute the digest of.
     |          If a string is provided, it will be encoded using UTF-8 before hashing,
     |          which matches Redis's default encoding behavior.
     |
     |      Returns:
     |        - (str | bytes) the XXH3 digest of the value as a hex string (16 hex characters).
     |          Returns bytes if decode_responses is False, otherwise returns str.
     |
     |      For more information, see https://redis.io/commands/digest
     |
     |  dump(self, name: 'KeyT') -> 'bytes | None | Awaitable[bytes | None]'
     |      Return a serialized version of the value stored at the specified key.
     |      If key does not exist a nil bulk reply is returned.
     |
     |      For more information, see https://redis.io/commands/dump
     |
     |  exists(self, *names: 'KeyT') -> 'int | Awaitable[int]'
     |      Returns the number of ``names`` that exist
     |
     |      For more information, see https://redis.io/commands/exists
     |
     |  expire(self, name: 'KeyT', time: 'ExpiryT', nx: 'bool' = False, xx: 'bool' = False, gt: 'bool' = False, lt: 'bool' = False) -> 'bool | Awaitable[bool]'
     |      Set an expire flag on key ``name`` for ``time`` seconds with given
     |      ``option``. ``time`` can be represented by an integer or a Python timedelta
     |      object.
     |
     |      Valid options are:
     |          NX -> Set expiry only when the key has no expiry
     |          XX -> Set expiry only when the key has an existing expiry
     |          GT -> Set expiry only when the new expiry is greater than current one
     |          LT -> Set expiry only when the new expiry is less than current one
     |
     |      For more information, see https://redis.io/commands/expire
     |
     |  expireat(self, name: 'KeyT', when: 'AbsExpiryT', nx: 'bool' = False, xx: 'bool' = False, gt: 'bool' = False, lt: 'bool' = False) -> 'bool | Awaitable[bool]'
     |      Set an expire flag on key ``name`` with given ``option``. ``when``
     |      can be represented as an integer indicating unix time or a Python
     |      datetime object.
     |
     |      Valid options are:
     |          -> NX -- Set expiry only when the key has no expiry
     |          -> XX -- Set expiry only when the key has an existing expiry
     |          -> GT -- Set expiry only when the new expiry is greater than current one
     |          -> LT -- Set expiry only when the new expiry is less than current one
     |
     |      For more information, see https://redis.io/commands/expireat
     |
     |  expiretime(self, key: 'str') -> 'int | Awaitable[int]'
     |      Returns the absolute Unix timestamp (since January 1, 1970) in seconds
     |      at which the given key will expire.
     |
     |      For more information, see https://redis.io/commands/expiretime
     |
     |  get(self, name: 'KeyT') -> 'bytes | str | None | Awaitable[bytes | str | None]'
     |      Return the value at key ``name``, or None if the key doesn't exist
     |
     |      For more information, see https://redis.io/commands/get
     |
     |  getbit(self, name: 'KeyT', offset: 'int') -> 'int | Awaitable[int]'
     |      Returns an integer indicating the value of ``offset`` in ``name``
     |
     |      For more information, see https://redis.io/commands/getbit
     |
     |  getdel(self, name: 'KeyT') -> 'bytes | str | None | Awaitable[bytes | str | None]'
     |      Get the value at key ``name`` and delete the key. This command
     |      is similar to GET, except for the fact that it also deletes
     |      the key on success (if and only if the key's value type
     |      is a string).
     |
     |      For more information, see https://redis.io/commands/getdel
     |
     |  getex(self, name: 'KeyT', ex: 'ExpiryT | None' = None, px: 'ExpiryT | None' = None, exat: 'AbsExpiryT | None' = None, pxat: 'AbsExpiryT | None' = None, persist: 'bool' = False) -> 'bytes | str | None | Awaitable[bytes | str | None]'
     |      Get the value of key and optionally set its expiration.
     |      GETEX is similar to GET, but is a write command with
     |      additional options. All time parameters can be given as
     |      datetime.timedelta or integers.
     |
     |      ``ex`` sets an expire flag on key ``name`` for ``ex`` seconds.
     |
     |      ``px`` sets an expire flag on key ``name`` for ``px`` milliseconds.
     |
     |      ``exat`` sets an expire flag on key ``name`` for ``ex`` seconds,
     |      specified in unix time.
     |
     |      ``pxat`` sets an expire flag on key ``name`` for ``ex`` milliseconds,
     |      specified in unix time.
     |
     |      ``persist`` remove the time to live associated with ``name``.
     |
     |      For more information, see https://redis.io/commands/getex
     |
     |  getrange(self, key: 'KeyT', start: 'int', end: 'int') -> 'bytes | str | Awaitable[bytes | str]'
     |      Returns the substring of the string value stored at ``key``,
     |      determined by the offsets ``start`` and ``end`` (both are inclusive)
     |
     |      For more information, see https://redis.io/commands/getrange
     |
     |  getset(self, name: 'KeyT', value: 'EncodableT') -> 'bytes | str | None | Awaitable[bytes | str | None]'
     |      Sets the value at key ``name`` to ``value``
     |      and returns the old value at key ``name`` atomically.
     |
     |      As per Redis 6.2, GETSET is considered deprecated.
     |      Please use SET with GET parameter in new code.
     |
     |      For more information, see https://redis.io/commands/getset
     |
     |  hrandfield(self, key: 'KeyT', count: 'int | None' = None, withvalues: 'bool' = False) -> 'HRandFieldResponse | Awaitable[HRandFieldResponse]'
     |      Return a random field from the hash value stored at key.
     |
     |      count: if the argument is positive, return an array of distinct fields.
     |      If called with a negative count, the behavior changes and the command
     |      is allowed to return the same field multiple times. In this case,
     |      the number of returned fields is the absolute value of the
     |      specified count.
     |      withvalues: The optional WITHVALUES modifier changes the reply so it
     |      includes the respective values of the randomly selected hash fields.
     |
     |      For more information, see https://redis.io/commands/hrandfield
     |
     |  incr = incrby(self, name: 'KeyT', amount: 'int' = 1) -> 'int | Awaitable[int]'
     |
     |  incrby(self, name: 'KeyT', amount: 'int' = 1) -> 'int | Awaitable[int]'
     |      Increments the value of ``key`` by ``amount``.  If no key exists,
     |      the value will be initialized as ``amount``
     |
     |      For more information, see https://redis.io/commands/incrby
     |
     |  incrbyfloat(self, name: 'KeyT', amount: 'float' = 1.0) -> 'float | Awaitable[float]'
     |      Increments the value at key ``name`` by floating ``amount``.
     |      If no key exists, the value will be initialized as ``amount``
     |
     |      For more information, see https://redis.io/commands/incrbyfloat
     |
     |  increx(self, name: 'KeyT', *, byfloat: 'EncodableT | None' = None, byint: 'EncodableT | None' = None, lbound: 'EncodableT | None' = None, ubound: 'EncodableT | None' = None, saturate: 'bool' = False, ex: 'ExpiryT | None' = None, px: 'ExpiryT | None' = None, exat: 'AbsExpiryT | None' = None, pxat: 'AbsExpiryT | None' = None, persist: 'bool' = False, enx: 'bool' = False) -> 'list[Number | bytes | str] | Awaitable[list[Number | bytes | str]]'
     |      Increment the numeric value at key ``name`` and return the new value
     |      and the actual increment.
     |
     |      ``byfloat`` increments a floating point value by the provided amount.
     |
     |      ``byint`` increments an integer value by the provided amount.
     |
     |      If neither ``byfloat`` nor ``byint`` is specified, the value is
     |      incremented by one.
     |
     |      ``lbound`` and ``ubound`` constrain the valid range of the result.
     |
     |      If ``saturate`` is True, out-of-bounds results are saturated to the
     |      specified bound, or to the type limit when no bound is specified.
     |      Otherwise, out-of-bounds results are rejected, leaving the value and
     |      TTL unchanged and returning the current value and zero as the actual
     |      increment.
     |
     |      ``enx`` applies the expiration only when the key does not already
     |      have an expiration, and requires ``ex``, ``px``, ``exat``, or ``pxat``.
     |
     |  keys(self, pattern: 'PatternT' = '*', **kwargs) -> 'list[bytes | str] | Awaitable[list[bytes | str]]'
     |      Returns a list of keys matching ``pattern``
     |
     |      For more information, see https://redis.io/commands/keys
     |
     |  lcs(self, key1: 'str', key2: 'str', len: 'bool | None' = False, idx: 'bool | None' = False, minmatchlen: 'int | None' = 0, withmatchlen: 'bool | None' = False) -> 'LCSCommandResponse | Awaitable[LCSCommandResponse]'
     |      Find the longest common subsequence between ``key1`` and ``key2``.
     |      If ``len`` is true the length of the match will be returned.
     |      If ``idx`` is true the match position in each strings will be returned.
     |      ``minmatchlen`` restrict the list of matches to the ones of
     |      the given ``minmatchlen``.
     |      If ``withmatchlen`` the length of the match also will be returned.
     |      For more information, see https://redis.io/commands/lcs
     |
     |  lmove(self, first_list: 'str', second_list: 'str', src: 'str' = 'LEFT', dest: 'str' = 'RIGHT') -> 'bytes | str | None | Awaitable[bytes | str | None]'
     |      Atomically returns and removes the first/last element of a list,
     |      pushing it as the first/last element on the destination list.
     |      Returns the element being popped and pushed.
     |
     |      For more information, see https://redis.io/commands/lmove
     |
     |  lmovem(self, first_list: 'str', second_list: 'str', src: 'str' = 'LEFT', dest: 'str' = 'RIGHT', count: 'int | None' = None, mode: "Literal['COUNT', 'EXACTLY'] | None" = None, ordering: "Literal['OBO', 'BULK'] | None" = None) -> 'list[bytes | str] | None | Awaitable[list[bytes | str] | None]'
     |      Atomically moves multiple elements from one end of the ``first_list``
     |      to one end of the ``second_list``, returning the moved elements in
     |      destination order.
     |
     |      ``src`` and ``dest`` are the ends to pop from / push to, either
     |      ``LEFT`` (head) or ``RIGHT`` (tail).
     |
     |      When ``count`` is given, ``mode`` selects how many elements to move:
     |      ``COUNT`` (the default) moves up to ``count`` elements, while
     |      ``EXACTLY`` moves exactly ``count`` elements or nothing at all. When
     |      ``count`` is not given a single element is moved.
     |
     |      ``ordering`` controls the order at the destination: ``OBO`` pushes each
     |      element as it is popped (reversing block order, stack semantics) while
     |      ``BULK`` preserves the original relative order (queue semantics). It is
     |      required whenever ``count`` is given.
     |
     |      Returns the array of moved elements, or ``None`` if nothing was moved.
     |
     |      For more information, see https://redis.io/commands/lmovem
     |
     |  mget(self, keys: 'KeysT', *args: 'EncodableT') -> 'list[bytes | str | None] | Awaitable[list[bytes | str | None]]'
     |      Returns a list of values ordered identically to ``keys``
     |
     |      ** Important ** When this method is used with Cluster clients, all keys
     |              must be in the same hash slot, otherwise a RedisClusterException
     |              will be raised.
     |
     |      For more information, see https://redis.io/commands/mget
     |
     |  move(self, name: 'KeyT', db: 'int') -> 'bool | Awaitable[bool]'
     |      Moves the key ``name`` to a different Redis database ``db``
     |
     |      For more information, see https://redis.io/commands/move
     |
     |  mset(self, mapping: 'Mapping[AnyKeyT, EncodableT]') -> 'bool | Awaitable[bool]'
     |      Sets key/values based on a mapping. Mapping is a dictionary of
     |      key/value pairs. Both keys and values should be strings or types that
     |      can be cast to a string via str().
     |
     |      ** Important ** When this method is used with Cluster clients, all keys
     |              must be in the same hash slot, otherwise a RedisClusterException
     |              will be raised.
     |
     |      For more information, see https://redis.io/commands/mset
     |
     |  msetex(self, mapping: 'Mapping[AnyKeyT, EncodableT]', data_persist_option: 'DataPersistOptions | None' = None, ex: 'ExpiryT | None' = None, px: 'ExpiryT | None' = None, exat: 'AbsExpiryT | None' = None, pxat: 'AbsExpiryT | None' = None, keepttl: 'bool' = False) -> 'int | Awaitable[int]'
     |      Sets key/values based on the provided ``mapping`` items.
     |
     |      ** Important ** When this method is used with Cluster clients, all keys
     |                      must be in the same hash slot, otherwise a RedisClusterException
     |                      will be raised.
     |
     |      ``mapping`` accepts a dict of key/value pairs that will be added to the database.
     |
     |      ``data_persist_option`` can be set to ``NX`` or ``XX`` to control the
     |          behavior of the command.
     |          ``NX`` will set the value for each provided key to each
     |              provided value only if all do not already exist.
     |          ``XX`` will set the value for each provided key to each
     |              provided value only if all already exist.
     |
     |      ``ex`` sets an expire flag on the keys in ``mapping`` for ``ex`` seconds.
     |
     |      ``px`` sets an expire flag on the keys in ``mapping`` for ``px`` milliseconds.
     |
     |      ``exat`` sets an expire flag on the keys in ``mapping`` for ``exat`` seconds,
     |          specified in unix time.
     |
     |      ``pxat`` sets an expire flag on the keys in ``mapping`` for ``pxat`` milliseconds,
     |          specified in unix time.
     |
     |      ``keepttl`` if True, retain the time to live associated with the keys.
     |
     |      Returns the number of fields that were added.
     |
     |      Available since Redis 8.4
     |      For more information, see https://redis.io/commands/msetex
     |
     |  msetnx(self, mapping: 'Mapping[AnyKeyT, EncodableT]') -> 'bool | Awaitable[bool]'
     |      Sets key/values based on a mapping if none of the keys are already set.
     |      Mapping is a dictionary of key/value pairs. Both keys and values
     |      should be strings or types that can be cast to a string via str().
     |      Returns a boolean indicating if the operation was successful.
     |
     |      ** Important ** When this method is used with Cluster clients, all keys
     |                      must be in the same hash slot, otherwise a RedisClusterException
     |                      will be raised.
     |
     |      For more information, see https://redis.io/commands/msetnx
     |
     |  persist(self, name: 'KeyT') -> 'bool | Awaitable[bool]'
     |      Removes an expiration on ``name``
     |
     |      For more information, see https://redis.io/commands/persist
     |
     |  pexpire(self, name: 'KeyT', time: 'ExpiryT', nx: 'bool' = False, xx: 'bool' = False, gt: 'bool' = False, lt: 'bool' = False) -> 'bool | Awaitable[bool]'
     |      Set an expire flag on key ``name`` for ``time`` milliseconds
     |      with given ``option``. ``time`` can be represented by an
     |      integer or a Python timedelta object.
     |
     |      Valid options are:
     |          NX -> Set expiry only when the key has no expiry
     |          XX -> Set expiry only when the key has an existing expiry
     |          GT -> Set expiry only when the new expiry is greater than current one
     |          LT -> Set expiry only when the new expiry is less than current one
     |
     |      For more information, see https://redis.io/commands/pexpire
     |
     |  pexpireat(self, name: 'KeyT', when: 'AbsExpiryT', nx: 'bool' = False, xx: 'bool' = False, gt: 'bool' = False, lt: 'bool' = False) -> 'bool | Awaitable[bool]'
     |      Set an expire flag on key ``name`` with given ``option``. ``when``
     |      can be represented as an integer representing unix time in
     |      milliseconds (unix time * 1000) or a Python datetime object.
     |
     |      Valid options are:
     |          NX -> Set expiry only when the key has no expiry
     |          XX -> Set expiry only when the key has an existing expiry
     |          GT -> Set expiry only when the new expiry is greater than current one
     |          LT -> Set expiry only when the new expiry is less than current one
     |
     |      For more information, see https://redis.io/commands/pexpireat
     |
     |  pexpiretime(self, key: 'str') -> 'int | Awaitable[int]'
     |      Returns the absolute Unix timestamp (since January 1, 1970) in milliseconds
     |      at which the given key will expire.
     |
     |      For more information, see https://redis.io/commands/pexpiretime
     |
     |  psetex(self, name: 'KeyT', time_ms: 'ExpiryT', value: 'EncodableT') -> 'bool | Awaitable[bool]'
     |      Set the value of key ``name`` to ``value`` that expires in ``time_ms``
     |      milliseconds. ``time_ms`` can be represented by an integer or a Python
     |      timedelta object
     |
     |      For more information, see https://redis.io/commands/psetex
     |
     |  pttl(self, name: 'KeyT') -> 'int | Awaitable[int]'
     |      Returns the number of milliseconds until the key ``name`` will expire
     |
     |      For more information, see https://redis.io/commands/pttl
     |
     |  randomkey(self, **kwargs) -> 'bytes | str | None | Awaitable[bytes | str | None]'
     |      Returns the name of a random key
     |
     |      For more information, see https://redis.io/commands/randomkey
     |
     |  rename(self, src: 'KeyT', dst: 'KeyT') -> 'bool | Awaitable[bool]'
     |      Rename key ``src`` to ``dst``
     |
     |      For more information, see https://redis.io/commands/rename
     |
     |  renamenx(self, src: 'KeyT', dst: 'KeyT') -> 'bool | Awaitable[bool]'
     |      Rename key ``src`` to ``dst`` if ``dst`` doesn't already exist
     |
     |      For more information, see https://redis.io/commands/renamenx
     |
     |  restore(self, name: 'KeyT', ttl: 'float', value: 'EncodableT', replace: 'bool' = False, absttl: 'bool' = False, idletime: 'int | None' = None, frequency: 'int | None' = None) -> 'bytes | str | Awaitable[bytes | str]'
     |      Create a key using the provided serialized value, previously obtained
     |      using DUMP.
     |
     |      ``replace`` allows an existing key on ``name`` to be overridden. If
     |      it's not specified an error is raised on collision.
     |
     |      ``absttl`` if True, specified ``ttl`` should represent an absolute Unix
     |      timestamp in milliseconds in which the key will expire. (Redis 5.0 or
     |      greater).
     |
     |      ``idletime`` Used for eviction, this is the number of seconds the
     |      key must be idle, prior to execution.
     |
     |      ``frequency`` Used for eviction, this is the frequency counter of
     |      the object stored at the key, prior to execution.
     |
     |      For more information, see https://redis.io/commands/restore
     |
     |  set(self, name: 'KeyT', value: 'EncodableT', ex: 'ExpiryT | None' = None, px: 'ExpiryT | None' = None, nx: 'bool' = False, xx: 'bool' = False, keepttl: 'bool' = False, get: 'bool' = False, exat: 'AbsExpiryT | None' = None, pxat: 'AbsExpiryT | None' = None, ifeq: 'bytes | str | None' = None, ifne: 'bytes | str | None' = None, ifdeq: 'str | None' = None, ifdne: 'str | None' = None) -> 'bool | str | bytes | None | Awaitable[bool | str | bytes | None]'
     |      Set the value at key ``name`` to ``value``
     |
     |      Warning:
     |      **Experimental** since 7.1.
     |      The usage of the arguments ``ifeq``, ``ifne``, ``ifdeq``, and ``ifdne``
     |      is experimental. The API or returned results when those parameters are used
     |      may change based on feedback.
     |
     |      ``ex`` sets an expire flag on key ``name`` for ``ex`` seconds.
     |
     |      ``px`` sets an expire flag on key ``name`` for ``px`` milliseconds.
     |
     |      ``nx`` if set to True, set the value at key ``name`` to ``value`` only
     |          if it does not exist.
     |
     |      ``xx`` if set to True, set the value at key ``name`` to ``value`` only
     |          if it already exists.
     |
     |      ``keepttl`` if True, retain the time to live associated with the key.
     |          (Available since Redis 6.0)
     |
     |      ``get`` if True, set the value at key ``name`` to ``value`` and return
     |          the old value stored at key, or None if the key did not exist.
     |          (Available since Redis 6.2)
     |
     |      ``exat`` sets an expire flag on key ``name`` for ``ex`` seconds,
     |          specified in unix time.
     |
     |      ``pxat`` sets an expire flag on key ``name`` for ``ex`` milliseconds,
     |          specified in unix time.
     |
     |      ``ifeq`` set the value at key ``name`` to ``value`` only if the current
     |          value exactly matches the argument.
     |          If key doesn’t exist - it won’t be created.
     |          (Requires Redis 8.4 or greater)
     |
     |      ``ifne`` set the value at key ``name`` to ``value`` only if the current
     |          value does not exactly match the argument.
     |          If key doesn’t exist - it will be created.
     |          (Requires Redis 8.4 or greater)
     |
     |      ``ifdeq`` set the value at key ``name`` to ``value`` only if the current
     |          value XXH3 hex digest exactly matches the argument.
     |          If key doesn’t exist - it won’t be created.
     |          (Requires Redis 8.4 or greater)
     |
     |      ``ifdne`` set the value at key ``name`` to ``value`` only if the current
     |          value XXH3 hex digest does not exactly match the argument.
     |          If key doesn’t exist - it will be created.
     |          (Requires Redis 8.4 or greater)
     |
     |      For more information, see https://redis.io/commands/set
     |
     |  setbit(self, name: 'KeyT', offset: 'int', value: 'int') -> 'int | Awaitable[int]'
     |      Flag the ``offset`` in ``name`` as ``value``. Returns an integer
     |      indicating the previous value of ``offset``.
     |
     |      For more information, see https://redis.io/commands/setbit
     |
     |  setex(self, name: 'KeyT', time: 'ExpiryT', value: 'EncodableT') -> 'bool | Awaitable[bool]'
     |      Set the value of key ``name`` to ``value`` that expires in ``time``
     |      seconds. ``time`` can be represented by an integer or a Python
     |      timedelta object.
     |
     |      As per Redis 2.6.12, SETEX is considered deprecated.
     |      Please use SET with EX parameter in new code.
     |
     |      For more information, see https://redis.io/commands/setex
     |
     |  setnx(self, name: 'KeyT', value: 'EncodableT') -> 'bool | Awaitable[bool]'
     |      Set the value of key ``name`` to ``value`` if key doesn't exist
     |
     |      For more information, see https://redis.io/commands/setnx
     |
     |  setrange(self, name: 'KeyT', offset: 'int', value: 'EncodableT') -> 'int | Awaitable[int]'
     |      Overwrite bytes in the value of ``name`` starting at ``offset`` with
     |      ``value``. If ``offset`` plus the length of ``value`` exceeds the
     |      length of the original value, the new value will be larger than before.
     |      If ``offset`` exceeds the length of the original value, null bytes
     |      will be used to pad between the end of the previous value and the start
     |      of what's being injected.
     |
     |      Returns the length of the new string.
     |
     |      For more information, see https://redis.io/commands/setrange
     |
     |  stralgo(self, algo: "Literal['LCS']", value1: 'KeyT', value2: 'KeyT', specific_argument: "Literal['strings'] | Literal['keys']" = 'strings', len: 'bool' = False, idx: 'bool' = False, minmatchlen: 'int | None' = None, withmatchlen: 'bool' = False, **kwargs) -> 'StralgoResponse | Awaitable[StralgoResponse]'
     |      Implements complex algorithms that operate on strings.
     |      Right now the only algorithm implemented is the LCS algorithm
     |      (longest common substring). However new algorithms could be
     |      implemented in the future.
     |
     |      ``algo`` Right now must be LCS
     |      ``value1`` and ``value2`` Can be two strings or two keys
     |      ``specific_argument`` Specifying if the arguments to the algorithm
     |      will be keys or strings. strings is the default.
     |      ``len`` Returns just the len of the match.
     |      ``idx`` Returns the match positions in each string.
     |      ``minmatchlen`` Restrict the list of matches to the ones of a given
     |      minimal length. Can be provided only when ``idx`` set to True.
     |      ``withmatchlen`` Returns the matches with the len of the match.
     |      Can be provided only when ``idx`` set to True.
     |
     |      For more information, see https://redis.io/commands/stralgo
     |
     |  strlen(self, name: 'KeyT') -> 'int | Awaitable[int]'
     |      Return the number of bytes stored in the value of ``name``
     |
     |      For more information, see https://redis.io/commands/strlen
     |
     |  substr(self, name: 'KeyT', start: 'int', end: 'int' = -1) -> 'bytes | str | Awaitable[bytes | str]'
     |      Return a substring of the string at key ``name``. ``start`` and ``end``
     |      are 0-based integers specifying the portion of the string to return.
     |
     |  touch(self, *args: 'KeyT') -> 'int | Awaitable[int]'
     |      Alters the last access time of a key(s) ``*args``. A key is ignored
     |      if it does not exist.
     |
     |      For more information, see https://redis.io/commands/touch
     |
     |  ttl(self, name: 'KeyT') -> 'int | Awaitable[int]'
     |      Returns the number of seconds until the key ``name`` will expire
     |
     |      For more information, see https://redis.io/commands/ttl
     |
     |  type(self, name: 'KeyT') -> 'bytes | str | Awaitable[bytes | str]'
     |      Returns the type of key ``name``
     |
     |      For more information, see https://redis.io/commands/type
     |
     |  unlink(self, *names: 'KeyT') -> 'int | Awaitable[int]'
     |      Unlink one or more keys specified by ``names``
     |
     |      For more information, see https://redis.io/commands/unlink
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from redis.commands.core.HyperlogCommands:
     |
     |  pfadd(self, name: 'KeyT', *values: 'FieldT') -> 'int | Awaitable[int]'
     |      Adds the specified elements to the specified HyperLogLog.
     |
     |      For more information, see https://redis.io/commands/pfadd
     |
     |  pfcount(self, *sources: 'KeyT') -> 'int | Awaitable[int]'
     |      Return the approximated cardinality of
     |      the set observed by the HyperLogLog at key(s).
     |
     |      For more information, see https://redis.io/commands/pfcount
     |
     |  pfmerge(self, dest: 'KeyT', *sources: 'KeyT') -> 'bool | Awaitable[bool]'
     |      Merge N different HyperLogLogs into a single one.
     |
     |      For more information, see https://redis.io/commands/pfmerge
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from redis.commands.core.HashCommands:
     |
     |  hdel(self, name: 'KeyT', *keys: 'FieldT') -> 'int | Awaitable[int]'
     |      Delete ``keys`` from hash ``name``
     |
     |      For more information, see https://redis.io/commands/hdel
     |
     |  hexists(self, name: 'KeyT', key: 'FieldT') -> 'bool | Awaitable[bool]'
     |      Returns a boolean indicating if ``key`` exists within hash ``name``
     |
     |      For more information, see https://redis.io/commands/hexists
     |
     |  hexpire(self, name: 'KeyT', seconds: 'ExpiryT', *fields: 'FieldT', nx: 'bool' = False, xx: 'bool' = False, gt: 'bool' = False, lt: 'bool' = False) -> 'list[int] | Awaitable[list[int]]'
     |      Sets or updates the expiration time for fields within a hash key, using relative
     |      time in seconds.
     |
     |      If a field already has an expiration time, the behavior of the update can be
     |      controlled using the `nx`, `xx`, `gt`, and `lt` parameters.
     |
     |      The return value provides detailed information about the outcome for each field.
     |
     |      For more information, see https://redis.io/commands/hexpire
     |
     |      Args:
     |          name: The name of the hash key.
     |          seconds: Expiration time in seconds, relative. Can be an integer, or a
     |                   Python `timedelta` object.
     |          fields: List of fields within the hash to apply the expiration time to.
     |          nx: Set expiry only when the field has no expiry.
     |          xx: Set expiry only when the field has an existing expiry.
     |          gt: Set expiry only when the new expiry is greater than the current one.
     |          lt: Set expiry only when the new expiry is less than the current one.
     |
     |      Returns:
     |          Returns a list which contains for each field in the request:
     |              - `-2` if the field does not exist, or if the key does not exist.
     |              - `0` if the specified NX | XX | GT | LT condition was not met.
     |              - `1` if the expiration time was set or updated.
     |              - `2` if the field was deleted because the specified expiration time is
     |                in the past.
     |
     |  hexpireat(self, name: 'KeyT', unix_time_seconds: 'AbsExpiryT', *fields: 'FieldT', nx: 'bool' = False, xx: 'bool' = False, gt: 'bool' = False, lt: 'bool' = False) -> 'list[int] | Awaitable[list[int]]'
     |      Sets or updates the expiration time for fields within a hash key, using an
     |      absolute Unix timestamp in seconds.
     |
     |      If a field already has an expiration time, the behavior of the update can be
     |      controlled using the `nx`, `xx`, `gt`, and `lt` parameters.
     |
     |      The return value provides detailed information about the outcome for each field.
     |
     |      For more information, see https://redis.io/commands/hexpireat
     |
     |      Args:
     |          name: The name of the hash key.
     |          unix_time_seconds: Expiration time as Unix timestamp in seconds. Can be an
     |                             integer or a Python `datetime` object.
     |          fields: List of fields within the hash to apply the expiration time to.
     |          nx: Set expiry only when the field has no expiry.
     |          xx: Set expiry only when the field has an existing expiration time.
     |          gt: Set expiry only when the new expiry is greater than the current one.
     |          lt: Set expiry only when the new expiry is less than the current one.
     |
     |      Returns:
     |          Returns a list which contains for each field in the request:
     |              - `-2` if the field does not exist, or if the key does not exist.
     |              - `0` if the specified NX | XX | GT | LT condition was not met.
     |              - `1` if the expiration time was set or updated.
     |              - `2` if the field was deleted because the specified expiration time is
     |                in the past.
     |
     |  hexpiretime(self, key: 'KeyT', *fields: 'FieldT') -> 'list[int] | Awaitable[list[int]]'
     |      Returns the expiration times of hash fields as Unix timestamps in seconds.
     |
     |      For more information, see https://redis.io/commands/hexpiretime
     |
     |      Args:
     |          key: The hash key.
     |          fields: A list of fields within the hash for which to get the expiration
     |                  time.
     |
     |      Returns:
     |          Returns a list which contains for each field in the request:
     |              - `-2` if the field does not exist, or if the key does not exist.
     |              - `-1` if the field exists but has no associated expire time.
     |              - A positive integer representing the expiration Unix timestamp in
     |                seconds, if the field has an associated expiration time.
     |
     |  hget(self, name: 'KeyT', key: 'FieldT') -> 'bytes | str | None | Awaitable[bytes | str | None]'
     |      Return the value of ``key`` within the hash ``name``
     |
     |      For more information, see https://redis.io/commands/hget
     |
     |  hgetall(self, name: 'KeyT') -> 'dict[bytes | str, bytes | str] | Awaitable[dict[bytes | str, bytes | str]]'
     |      Return a Python dict of the hash's name/value pairs
     |
     |      For more information, see https://redis.io/commands/hgetall
     |
     |  hgetdel(self, name: 'KeyT', *keys: 'FieldT') -> 'list[bytes | str | None] | Awaitable[list[bytes | str | None]]'
     |      Return the value of ``key`` within the hash ``name`` and
     |      delete the field in the hash.
     |      This command is similar to HGET, except for the fact that it also deletes
     |      the key on success from the hash with the provided ```name```.
     |
     |      Available since Redis 8.0
     |      For more information, see https://redis.io/commands/hgetdel
     |
     |  hgetex(self, name: 'KeyT', *keys: 'FieldT', ex: 'ExpiryT | None' = None, px: 'ExpiryT | None' = None, exat: 'AbsExpiryT | None' = None, pxat: 'AbsExpiryT | None' = None, persist: 'bool' = False) -> 'list[bytes | str | None] | Awaitable[list[bytes | str | None]]'
     |      Return the values of ``key`` and ``keys`` within the hash ``name``
     |      and optionally set their expiration.
     |
     |      ``ex`` sets an expire flag on ``kyes`` for ``ex`` seconds.
     |
     |      ``px`` sets an expire flag on ``keys`` for ``px`` milliseconds.
     |
     |      ``exat`` sets an expire flag on ``keys`` for ``ex`` seconds,
     |      specified in unix time.
     |
     |      ``pxat`` sets an expire flag on ``keys`` for ``ex`` milliseconds,
     |      specified in unix time.
     |
     |      ``persist`` remove the time to live associated with the ``keys``.
     |
     |      Available since Redis 8.0
     |      For more information, see https://redis.io/commands/hgetex
     |
     |  himport_discard_all_internal(self) -> 'int | Awaitable[int]'
     |      Send ``HIMPORT DISCARDALL`` (returns the number of fieldsets removed).
     |
     |      .. warning::
     |          Internal wire mapping — not for direct use on a pooled client. It
     |          DISCARDs on a single arbitrary borrowed connection and bypasses the
     |          client's shared fieldset registry, leaving other connections and the
     |          registry out of sync. Use the client's ``himport_discard_all`` instead;
     |          call this only on a pinned single-connection client where you manage
     |          session state yourself.
     |
     |  himport_discard_internal(self, fieldset_name: 'str') -> 'int | Awaitable[int]'
     |      Send ``HIMPORT DISCARD fieldset_name`` (``1`` removed, ``0`` not found).
     |
     |      .. warning::
     |          Internal wire mapping — not for direct use on a pooled client. It
     |          DISCARDs on a single arbitrary borrowed connection and bypasses the
     |          client's shared fieldset registry, leaving other connections and the
     |          registry out of sync. Use the client's ``himport_discard`` instead; call
     |          this only on a pinned single-connection client where you manage session
     |          state yourself.
     |
     |  himport_prepare_internal(self, fieldset_name: 'str', fields: 'Iterable[FieldT]') -> 'bool | Awaitable[bool]'
     |      Send ``HIMPORT PREPARE fieldset_name field [field ...]``.
     |
     |      Registers the ordered field list under ``fieldset_name`` in the executing
     |      connection's session. Fields are sent in the caller's order, unmodified.
     |
     |      .. warning::
     |          Internal wire mapping — not for direct use on a pooled client. It
     |          PREPAREs on a single arbitrary borrowed connection and bypasses the
     |          client's shared fieldset registry, so other connections stay unaware and
     |          reintroduce the nondeterministic "no such fieldset" the HIMPORT design
     |          prevents. Use the client's ``himport_prepare`` instead; call this only
     |          on a pinned single-connection client where you manage session state
     |          yourself.
     |
     |  himport_set(self, key: 'KeyT', fieldset_name: 'str', values: 'Iterable[EncodableT]') -> 'bool | Awaitable[bool]'
     |      Create/replace ``key`` as a hash using ``fieldset_name``'s field list.
     |
     |      Values are sent in the caller's order and map positionally to the prepared
     |      fields. The fieldset is prepared on the serving connection on first use
     |      (PREPARE bundled with SET in one write) and reused on subsequent calls;
     |      runtime discards are reconciled on the next use of the connection. All of
     |      this happens inside the normal command path, so retry, disconnect-on-error
     |      and (for the cluster) routing / MOVED-ASK apply exactly as for any command.
     |
     |      .. note::
     |          Recovery from a mid-connection fieldset loss (the server dropping the
     |          prepared fieldset without dropping the socket, e.g. ``RESET`` or
     |          ``maxmemory-clients`` eviction) applies only to a standalone
     |          ``himport_set`` call: it catches the resulting ``no such fieldset`` and
     |          re-prepares on the same socket, retrying the SET once. A ``himport_set``
     |          buffered in a **pipeline or transaction** has no such per-command
     |          recovery — its fieldset is PREPAREd once as a pre-flight before the
     |          batch, and if the server loses it between that pre-flight and the batch
     |          the SET fails and surfaces as an error in the batch results. Callers who
     |          need the automatic recovery should issue those sets outside a pipeline.
     |
     |  hincrby(self, name: 'KeyT', key: 'FieldT', amount: 'int' = 1) -> 'int | Awaitable[int]'
     |      Increment the value of ``key`` in hash ``name`` by ``amount``
     |
     |      For more information, see https://redis.io/commands/hincrby
     |
     |  hincrbyfloat(self, name: 'KeyT', key: 'FieldT', amount: 'float' = 1.0) -> 'float | Awaitable[float]'
     |      Increment the value of ``key`` in hash ``name`` by floating ``amount``
     |
     |      For more information, see https://redis.io/commands/hincrbyfloat
     |
     |  hkeys(self, name: 'KeyT') -> 'list[bytes | str] | Awaitable[list[bytes | str]]'
     |      Return the list of keys within hash ``name``
     |
     |      For more information, see https://redis.io/commands/hkeys
     |
     |  hlen(self, name: 'KeyT') -> 'int | Awaitable[int]'
     |      Return the number of elements in hash ``name``
     |
     |      For more information, see https://redis.io/commands/hlen
     |
     |  hmget(self, name: 'KeyT', keys: 'FieldT | Iterable[FieldT]', *args: 'FieldT') -> 'list[bytes | str | None] | Awaitable[list[bytes | str | None]]'
     |      Returns a list of values ordered identically to ``keys``
     |
     |      For more information, see https://redis.io/commands/hmget
     |
     |  hmset(self, name: 'KeyT', mapping: 'Mapping[FieldT, EncodableT]') -> 'bool | Awaitable[bool]'
     |      Set key to value within hash ``name`` for each corresponding
     |      key and value from the ``mapping`` dict.
     |
     |      For more information, see https://redis.io/commands/hmset
     |
     |  hpersist(self, name: 'KeyT', *fields: 'FieldT') -> 'list[int] | Awaitable[list[int]]'
     |      Removes the expiration time for each specified field in a hash.
     |
     |      For more information, see https://redis.io/commands/hpersist
     |
     |      Args:
     |          name: The name of the hash key.
     |          fields: A list of fields within the hash from which to remove the
     |                  expiration time.
     |
     |      Returns:
     |          Returns a list which contains for each field in the request:
     |              - `-2` if the field does not exist, or if the key does not exist.
     |              - `-1` if the field exists but has no associated expiration time.
     |              - `1` if the expiration time was successfully removed from the field.
     |
     |  hpexpire(self, name: 'KeyT', milliseconds: 'ExpiryT', *fields: 'FieldT', nx: 'bool' = False, xx: 'bool' = False, gt: 'bool' = False, lt: 'bool' = False) -> 'list[int] | Awaitable[list[int]]'
     |      Sets or updates the expiration time for fields within a hash key, using relative
     |      time in milliseconds.
     |
     |      If a field already has an expiration time, the behavior of the update can be
     |      controlled using the `nx`, `xx`, `gt`, and `lt` parameters.
     |
     |      The return value provides detailed information about the outcome for each field.
     |
     |      For more information, see https://redis.io/commands/hpexpire
     |
     |      Args:
     |          name: The name of the hash key.
     |          milliseconds: Expiration time in milliseconds, relative. Can be an integer,
     |                        or a Python `timedelta` object.
     |          fields: List of fields within the hash to apply the expiration time to.
     |          nx: Set expiry only when the field has no expiry.
     |          xx: Set expiry only when the field has an existing expiry.
     |          gt: Set expiry only when the new expiry is greater than the current one.
     |          lt: Set expiry only when the new expiry is less than the current one.
     |
     |      Returns:
     |          Returns a list which contains for each field in the request:
     |              - `-2` if the field does not exist, or if the key does not exist.
     |              - `0` if the specified NX | XX | GT | LT condition was not met.
     |              - `1` if the expiration time was set or updated.
     |              - `2` if the field was deleted because the specified expiration time is
     |                in the past.
     |
     |  hpexpireat(self, name: 'KeyT', unix_time_milliseconds: 'AbsExpiryT', *fields: 'FieldT', nx: 'bool' = False, xx: 'bool' = False, gt: 'bool' = False, lt: 'bool' = False) -> 'list[int] | Awaitable[list[int]]'
     |      Sets or updates the expiration time for fields within a hash key, using an
     |      absolute Unix timestamp in milliseconds.
     |
     |      If a field already has an expiration time, the behavior of the update can be
     |      controlled using the `nx`, `xx`, `gt`, and `lt` parameters.
     |
     |      The return value provides detailed information about the outcome for each field.
     |
     |      For more information, see https://redis.io/commands/hpexpireat
     |
     |      Args:
     |          name: The name of the hash key.
     |          unix_time_milliseconds: Expiration time as Unix timestamp in milliseconds.
     |                                  Can be an integer or a Python `datetime` object.
     |          fields: List of fields within the hash to apply the expiry.
     |          nx: Set expiry only when the field has no expiry.
     |          xx: Set expiry only when the field has an existing expiry.
     |          gt: Set expiry only when the new expiry is greater than the current one.
     |          lt: Set expiry only when the new expiry is less than the current one.
     |
     |      Returns:
     |          Returns a list which contains for each field in the request:
     |              - `-2` if the field does not exist, or if the key does not exist.
     |              - `0` if the specified NX | XX | GT | LT condition was not met.
     |              - `1` if the expiration time was set or updated.
     |              - `2` if the field was deleted because the specified expiration time is
     |                in the past.
     |
     |  hpexpiretime(self, key: 'KeyT', *fields: 'FieldT') -> 'list[int] | Awaitable[list[int]]'
     |      Returns the expiration times of hash fields as Unix timestamps in milliseconds.
     |
     |      For more information, see https://redis.io/commands/hpexpiretime
     |
     |      Args:
     |          key: The hash key.
     |          fields: A list of fields within the hash for which to get the expiration
     |                  time.
     |
     |      Returns:
     |          Returns a list which contains for each field in the request:
     |              - `-2` if the field does not exist, or if the key does not exist.
     |              - `-1` if the field exists but has no associated expire time.
     |              - A positive integer representing the expiration Unix timestamp in
     |                milliseconds, if the field has an associated expiration time.
     |
     |  hpttl(self, key: 'KeyT', *fields: 'FieldT') -> 'list[int] | Awaitable[list[int]]'
     |      Returns the TTL (Time To Live) in milliseconds for each specified field within a
     |      hash key.
     |
     |      For more information, see https://redis.io/commands/hpttl
     |
     |      Args:
     |          key: The hash key.
     |          fields: A list of fields within the hash for which to get the TTL.
     |
     |      Returns:
     |          Returns a list which contains for each field in the request:
     |              - `-2` if the field does not exist, or if the key does not exist.
     |              - `-1` if the field exists but has no associated expire time.
     |              - A positive integer representing the TTL in milliseconds if the field
     |                has an associated expiration time.
     |
     |  hset(self, name: 'KeyT', key: 'FieldT | None' = None, value: 'EncodableT | None' = None, mapping: 'Mapping[FieldT, EncodableT] | None' = None, items: 'Sequence[EncodableT] | None' = None) -> 'int | Awaitable[int]'
     |      Set ``key`` to ``value`` within hash ``name``,
     |      ``mapping`` accepts a dict of key/value pairs that will be
     |      added to hash ``name``.
     |      ``items`` accepts a list of key/value pairs that will be
     |      added to hash ``name``.
     |      Returns the number of fields that were added.
     |
     |      For more information, see https://redis.io/commands/hset
     |
     |  hsetex(self, name: 'KeyT', key: 'FieldT | None' = None, value: 'EncodableT | None' = None, mapping: 'Mapping[FieldT, EncodableT] | None' = None, items: 'Sequence[EncodableT] | None' = None, ex: 'ExpiryT | None' = None, px: 'ExpiryT | None' = None, exat: 'AbsExpiryT | None' = None, pxat: 'AbsExpiryT | None' = None, data_persist_option: 'HashDataPersistOptions | None' = None, keepttl: 'bool' = False) -> 'int | Awaitable[int]'
     |      Set ``key`` to ``value`` within hash ``name``
     |
     |      ``mapping`` accepts a dict of key/value pairs that will be
     |      added to hash ``name``.
     |
     |      ``items`` accepts a list of key/value pairs that will be
     |      added to hash ``name``.
     |
     |      ``ex`` sets an expire flag on ``keys`` for ``ex`` seconds.
     |
     |      ``px`` sets an expire flag on ``keys`` for ``px`` milliseconds.
     |
     |      ``exat`` sets an expire flag on ``keys`` for ``ex`` seconds,
     |          specified in unix time.
     |
     |      ``pxat`` sets an expire flag on ``keys`` for ``ex`` milliseconds,
     |          specified in unix time.
     |
     |      ``data_persist_option`` can be set to ``FNX`` or ``FXX`` to control the
     |          behavior of the command.
     |          ``FNX`` will set the value for each provided key to each
     |              provided value only if all do not already exist.
     |          ``FXX`` will set the value for each provided key to each
     |              provided value only if all already exist.
     |
     |      ``keepttl`` if True, retain the time to live associated with the keys.
     |
     |      Returns the number of fields that were added.
     |
     |      Available since Redis 8.0
     |      For more information, see https://redis.io/commands/hsetex
     |
     |  hsetnx(self, name: 'KeyT', key: 'FieldT', value: 'EncodableT') -> 'int | Awaitable[int]'
     |      Set ``key`` to ``value`` within hash ``name`` if ``key`` does not
     |      exist.  Returns 1 if HSETNX created a field, otherwise 0.
     |
     |      For more information, see https://redis.io/commands/hsetnx
     |
     |  hstrlen(self, name: 'KeyT', key: 'FieldT') -> 'int | Awaitable[int]'
     |      Return the number of bytes stored in the value of ``key``
     |      within hash ``name``
     |
     |      For more information, see https://redis.io/commands/hstrlen
     |
     |  httl(self, key: 'KeyT', *fields: 'FieldT') -> 'list[int] | Awaitable[list[int]]'
     |      Returns the TTL (Time To Live) in seconds for each specified field within a hash
     |      key.
     |
     |      For more information, see https://redis.io/commands/httl
     |
     |      Args:
     |          key: The hash key.
     |          fields: A list of fields within the hash for which to get the TTL.
     |
     |      Returns:
     |          Returns a list which contains for each field in the request:
     |              - `-2` if the field does not exist, or if the key does not exist.
     |              - `-1` if the field exists but has no associated expire time.
     |              - A positive integer representing the TTL in seconds if the field has
     |                an associated expiration time.
     |
     |  hvals(self, name: 'KeyT') -> 'list[bytes | str] | Awaitable[list[bytes | str]]'
     |      Return the list of values within hash ``name``
     |
     |      For more information, see https://redis.io/commands/hvals
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from redis.commands.core.GeoCommands:
     |
     |  geoadd(self, name: 'KeyT', values: 'Sequence[EncodableT]', nx: 'bool' = False, xx: 'bool' = False, ch: 'bool' = False) -> 'int | Awaitable[int]'
     |      Add the specified geospatial items to the specified key identified
     |      by the ``name`` argument. The Geospatial items are given as ordered
     |      members of the ``values`` argument, each item or place is formed by
     |      the triad longitude, latitude and name.
     |
     |      Note: You can use ZREM to remove elements.
     |
     |      ``nx`` forces ZADD to only create new elements and not to update
     |      scores for elements that already exist.
     |
     |      ``xx`` forces ZADD to only update scores of elements that already
     |      exist. New elements will not be added.
     |
     |      ``ch`` modifies the return value to be the numbers of elements changed.
     |      Changed elements include new elements that were added and elements
     |      whose scores changed.
     |
     |      For more information, see https://redis.io/commands/geoadd
     |
     |  geodist(self, name: 'KeyT', place1: 'FieldT', place2: 'FieldT', unit: 'str | None' = None) -> 'float | None | Awaitable[float | None]'
     |      Return the distance between ``place1`` and ``place2`` members of the
     |      ``name`` key.
     |      The units must be one of the following : m, km mi, ft. By default
     |      meters are used.
     |
     |      For more information, see https://redis.io/commands/geodist
     |
     |  geohash(self, name: 'KeyT', *values: 'FieldT') -> 'list[bytes | str | None] | Awaitable[list[bytes | str | None]]'
     |      Return the geo hash string for each item of ``values`` members of
     |      the specified key identified by the ``name`` argument.
     |
     |      For more information, see https://redis.io/commands/geohash
     |
     |  geopos(self, name: 'KeyT', *values: 'FieldT') -> 'list[GeoCoordinate | None] | Awaitable[list[GeoCoordinate | None]]'
     |      Return the positions of each item of ``values`` as members of
     |      the specified key identified by the ``name`` argument. Each position
     |      is represented by the pairs lon and lat.
     |
     |      For more information, see https://redis.io/commands/geopos
     |
     |  georadius(self, name: 'KeyT', longitude: 'float', latitude: 'float', radius: 'float', unit: 'str | None' = None, withdist: 'bool' = False, withcoord: 'bool' = False, withhash: 'bool' = False, count: 'int | None' = None, sort: 'str | None' = None, store: 'KeyT | None' = None, store_dist: 'KeyT | None' = None, any: 'bool' = False) -> 'GeoRadiusResponse | Awaitable[GeoRadiusResponse]'
     |      Return the members of the specified key identified by the
     |      ``name`` argument which are within the borders of the area specified
     |      with the ``latitude`` and ``longitude`` location and the maximum
     |      distance from the center specified by the ``radius`` value.
     |
     |      The units must be one of the following : m, km mi, ft. By default
     |
     |      ``withdist`` indicates to return the distances of each place.
     |
     |      ``withcoord`` indicates to return the latitude and longitude of
     |      each place.
     |
     |      ``withhash`` indicates to return the geohash string of each place.
     |
     |      ``count`` indicates to return the number of elements up to N.
     |
     |      ``sort`` indicates to return the places in a sorted way, ASC for
     |      nearest to fairest and DESC for fairest to nearest.
     |
     |      ``store`` indicates to save the places names in a sorted set named
     |      with a specific key, each element of the destination sorted set is
     |      populated with the score got from the original geo sorted set.
     |
     |      ``store_dist`` indicates to save the places names in a sorted set
     |      named with a specific key, instead of ``store`` the sorted set
     |      destination score is set with the distance.
     |
     |      For more information, see https://redis.io/commands/georadius
     |
     |  georadiusbymember(self, name: 'KeyT', member: 'FieldT', radius: 'float', unit: 'str | None' = None, withdist: 'bool' = False, withcoord: 'bool' = False, withhash: 'bool' = False, count: 'int | None' = None, sort: 'str | None' = None, store: 'Union[KeyT, None]' = None, store_dist: 'Union[KeyT, None]' = None, any: 'bool' = False) -> 'GeoRadiusResponse | Awaitable[GeoRadiusResponse]'
     |      This command is exactly like ``georadius`` with the sole difference
     |      that instead of taking, as the center of the area to query, a longitude
     |      and latitude value, it takes the name of a member already existing
     |      inside the geospatial index represented by the sorted set.
     |
     |      For more information, see https://redis.io/commands/georadiusbymember
     |
     |  geosearch(self, name: 'KeyT', member: 'FieldT | None' = None, longitude: 'float | None' = None, latitude: 'float | None' = None, unit: 'str' = 'm', radius: 'float | None' = None, width: 'float | None' = None, height: 'float | None' = None, sort: 'str | None' = None, count: 'int | None' = None, any: 'bool' = False, withcoord: 'bool' = False, withdist: 'bool' = False, withhash: 'bool' = False) -> 'GeoSearchResponse | Awaitable[GeoSearchResponse]'
     |      Return the members of specified key identified by the
     |      ``name`` argument, which are within the borders of the
     |      area specified by a given shape. This command extends the
     |      GEORADIUS command, so in addition to searching within circular
     |      areas, it supports searching within rectangular areas.
     |
     |      This command should be used in place of the deprecated
     |      GEORADIUS and GEORADIUSBYMEMBER commands.
     |
     |      ``member`` Use the position of the given existing
     |       member in the sorted set. Can't be given with ``longitude``
     |       and ``latitude``.
     |
     |      ``longitude`` and ``latitude`` Use the position given by
     |      this coordinates. Can't be given with ``member``
     |      ``radius`` Similar to GEORADIUS, search inside circular
     |      area according the given radius. Can't be given with
     |      ``height`` and ``width``.
     |      ``height`` and ``width`` Search inside an axis-aligned
     |      rectangle, determined by the given height and width.
     |      Can't be given with ``radius``
     |
     |      ``unit`` must be one of the following : m, km, mi, ft.
     |      `m` for meters (the default value), `km` for kilometers,
     |      `mi` for miles and `ft` for feet.
     |
     |      ``sort`` indicates to return the places in a sorted way,
     |      ASC for nearest to furthest and DESC for furthest to nearest.
     |
     |      ``count`` limit the results to the first count matching items.
     |
     |      ``any`` is set to True, the command will return as soon as
     |      enough matches are found. Can't be provided without ``count``
     |
     |      ``withdist`` indicates to return the distances of each place.
     |      ``withcoord`` indicates to return the latitude and longitude of
     |      each place.
     |
     |      ``withhash`` indicates to return the geohash string of each place.
     |
     |      For more information, see https://redis.io/commands/geosearch
     |
     |  geosearchstore(self, dest: 'KeyT', name: 'KeyT', member: 'FieldT | None' = None, longitude: 'float | None' = None, latitude: 'float | None' = None, unit: 'str' = 'm', radius: 'float | None' = None, width: 'float | None' = None, height: 'float | None' = None, sort: 'str | None' = None, count: 'int | None' = None, any: 'bool' = False, storedist: 'bool' = False) -> 'int | Awaitable[int]'
     |      This command is like GEOSEARCH, but stores the result in
     |      ``dest``. By default, it stores the results in the destination
     |      sorted set with their geospatial information.
     |      if ``store_dist`` set to True, the command will stores the
     |      items in a sorted set populated with their distance from the
     |      center of the circle or box, as a floating-point number.
     |
     |      For more information, see https://redis.io/commands/geosearchstore
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from redis.commands.core.ListCommands:
     |
     |  blmpop(self, timeout: 'float', numkeys: 'int', *args: 'str', direction: 'str', count: 'int | None' = 1) -> 'ListMultiPopResponse | Awaitable[ListMultiPopResponse]'
     |      Pop ``count`` values (default 1) from first non-empty in the list
     |      of provided key names.
     |
     |      When all lists are empty this command blocks the connection until another
     |      client pushes to it or until the timeout, timeout of 0 blocks indefinitely
     |
     |      For more information, see https://redis.io/commands/blmpop
     |
     |  blpop(self, keys: 'KeysT', timeout: 'Number | None' = 0) -> 'BlockingListPopResponse | Awaitable[BlockingListPopResponse]'
     |      LPOP a value off of the first non-empty list
     |      named in ``keys``.
     |
     |      If none of the lists in ``keys`` has a value to LPOP, then block
     |      for ``timeout`` seconds, or until a value gets pushed on to one
     |      of the lists.
     |
     |      If timeout is 0, then block indefinitely.
     |
     |      For more information, see https://redis.io/commands/blpop
     |
     |  brpop(self, keys: 'KeysT', timeout: 'Number | None' = 0) -> 'BlockingListPopResponse | Awaitable[BlockingListPopResponse]'
     |      RPOP a value off of the first non-empty list
     |      named in ``keys``.
     |
     |      If none of the lists in ``keys`` has a value to RPOP, then block
     |      for ``timeout`` seconds, or until a value gets pushed on to one
     |      of the lists.
     |
     |      If timeout is 0, then block indefinitely.
     |
     |      For more information, see https://redis.io/commands/brpop
     |
     |  brpoplpush(self, src: 'KeyT', dst: 'KeyT', timeout: 'Number | None' = 0) -> 'bytes | str | None | Awaitable[bytes | str | None]'
     |      Pop a value off the tail of ``src``, push it on the head of ``dst``
     |      and then return it.
     |
     |      This command blocks until a value is in ``src`` or until ``timeout``
     |      seconds elapse, whichever is first. A ``timeout`` value of 0 blocks
     |      forever.
     |
     |      For more information, see https://redis.io/commands/brpoplpush
     |
     |  lindex(self, name: 'KeyT', index: 'int') -> 'bytes | str | None | Awaitable[bytes | str | None]'
     |      Return the item from list ``name`` at position ``index``
     |
     |      Negative indexes are supported and will return an item at the
     |      end of the list
     |
     |      For more information, see https://redis.io/commands/lindex
     |
     |  linsert(self, name: 'KeyT', where: 'str', refvalue: 'str', value: 'str') -> 'int | Awaitable[int]'
     |      Insert ``value`` in list ``name`` either immediately before or after
     |      [``where``] ``refvalue``
     |
     |      Returns the new length of the list on success or -1 if ``refvalue``
     |      is not in the list.
     |
     |      For more information, see https://redis.io/commands/linsert
     |
     |  llen(self, name: 'KeyT') -> 'int | Awaitable[int]'
     |      Return the length of the list ``name``
     |
     |      For more information, see https://redis.io/commands/llen
     |
     |  lmpop(self, num_keys: 'int', *args: 'str', direction: 'str', count: 'int | None' = 1) -> 'ListMultiPopResponse | Awaitable[ListMultiPopResponse]'
     |      Pop ``count`` values (default 1) first non-empty list key from the list
     |      of args provided key names.
     |
     |      For more information, see https://redis.io/commands/lmpop
     |
     |  lpop(self, name: 'KeyT', count: 'int | None' = None) -> 'bytes | str | list[bytes | str] | None | Awaitable[bytes | str | list[bytes | str] | None]'
     |      Removes and returns the first elements of the list ``name``.
     |
     |      By default, the command pops a single element from the beginning of
     |      the list. When provided with the optional ``count`` argument, the reply
     |      will consist of up to count elements, depending on the list's length.
     |
     |      For more information, see https://redis.io/commands/lpop
     |
     |  lpos(self, name: 'KeyT', value: 'str', rank: 'int | None' = None, count: 'int | None' = None, maxlen: 'int | None' = None) -> 'int | list[int] | None | Awaitable[int | list[int] | None]'
     |      Get position of ``value`` within the list ``name``
     |
     |       If specified, ``rank`` indicates the "rank" of the first element to
     |       return in case there are multiple copies of ``value`` in the list.
     |       By default, LPOS returns the position of the first occurrence of
     |       ``value`` in the list. When ``rank`` 2, LPOS returns the position of
     |       the second ``value`` in the list. If ``rank`` is negative, LPOS
     |       searches the list in reverse. For example, -1 would return the
     |       position of the last occurrence of ``value`` and -2 would return the
     |       position of the next to last occurrence of ``value``.
     |
     |       If specified, ``count`` indicates that LPOS should return a list of
     |       up to ``count`` positions. A ``count`` of 2 would return a list of
     |       up to 2 positions. A ``count`` of 0 returns a list of all positions
     |       matching ``value``. When ``count`` is specified and but ``value``
     |       does not exist in the list, an empty list is returned.
     |
     |       If specified, ``maxlen`` indicates the maximum number of list
     |       elements to scan. A ``maxlen`` of 1000 will only return the
     |       position(s) of items within the first 1000 entries in the list.
     |       A ``maxlen`` of 0 (the default) will scan the entire list.
     |
     |       For more information, see https://redis.io/commands/lpos
     |
     |  lpush(self, name: 'KeyT', *values: 'FieldT') -> 'int | Awaitable[int]'
     |      Push ``values`` onto the head of the list ``name``
     |
     |      For more information, see https://redis.io/commands/lpush
     |
     |  lpushx(self, name: 'KeyT', *values: 'FieldT') -> 'int | Awaitable[int]'
     |      Push ``value`` onto the head of the list ``name`` if ``name`` exists
     |
     |      For more information, see https://redis.io/commands/lpushx
     |
     |  lrange(self, name: 'KeyT', start: 'int', end: 'int') -> 'list[bytes | str] | Awaitable[list[bytes | str]]'
     |      Return a slice of the list ``name`` between
     |      position ``start`` and ``end``
     |
     |      ``start`` and ``end`` can be negative numbers just like
     |      Python slicing notation
     |
     |      For more information, see https://redis.io/commands/lrange
     |
     |  lrem(self, name: 'KeyT', count: 'int', value: 'str') -> 'int | Awaitable[int]'
     |      Remove the first ``count`` occurrences of elements equal to ``value``
     |      from the list stored at ``name``.
     |
     |      The count argument influences the operation in the following ways:
     |          count > 0: Remove elements equal to value moving from head to tail.
     |          count < 0: Remove elements equal to value moving from tail to head.
     |          count = 0: Remove all elements equal to value.
     |
     |          For more information, see https://redis.io/commands/lrem
     |
     |  lset(self, name: 'KeyT', index: 'int', value: 'str') -> 'bool | Awaitable[bool]'
     |      Set element at ``index`` of list ``name`` to ``value``
     |
     |      For more information, see https://redis.io/commands/lset
     |
     |  ltrim(self, name: 'KeyT', start: 'int', end: 'int') -> 'bool | Awaitable[bool]'
     |      Trim the list ``name``, removing all values not within the slice
     |      between ``start`` and ``end``
     |
     |      ``start`` and ``end`` can be negative numbers just like
     |      Python slicing notation
     |
     |      For more information, see https://redis.io/commands/ltrim
     |
     |  rpop(self, name: 'KeyT', count: 'int | None' = None) -> 'bytes | str | list[bytes | str] | None | Awaitable[bytes | str | list[bytes | str] | None]'
     |      Removes and returns the last elements of the list ``name``.
     |
     |      By default, the command pops a single element from the end of the list.
     |      When provided with the optional ``count`` argument, the reply will
     |      consist of up to count elements, depending on the list's length.
     |
     |      For more information, see https://redis.io/commands/rpop
     |
     |  rpoplpush(self, src: 'KeyT', dst: 'KeyT') -> 'bytes | str | None | Awaitable[bytes | str | None]'
     |      RPOP a value off of the ``src`` list and atomically LPUSH it
     |      on to the ``dst`` list.  Returns the value.
     |
     |      For more information, see https://redis.io/commands/rpoplpush
     |
     |  rpush(self, name: 'KeyT', *values: 'FieldT') -> 'int | Awaitable[int]'
     |      Push ``values`` onto the tail of the list ``name``
     |
     |      For more information, see https://redis.io/commands/rpush
     |
     |  rpushx(self, name: 'KeyT', *values: 'str') -> 'int | Awaitable[int]'
     |      Push ``value`` onto the tail of the list ``name`` if ``name`` exists
     |
     |      For more information, see https://redis.io/commands/rpushx
     |
     |  sort(self, name: 'KeyT', start: 'int | None' = None, num: 'int | None' = None, by: 'str | None' = None, get: 'list[str] | None' = None, desc: 'bool' = False, alpha: 'bool' = False, store: 'str | None' = None, groups: 'bool | None' = False) -> 'SortResponse | Awaitable[SortResponse]'
     |      Sort and return the list, set or sorted set at ``name``.
     |
     |      ``start`` and ``num`` allow for paging through the sorted data
     |
     |      ``by`` allows using an external key to weight and sort the items.
     |          Use an "*" to indicate where in the key the item value is located
     |
     |      ``get`` allows for returning items from external keys rather than the
     |          sorted data itself.  Use an "*" to indicate where in the key
     |          the item value is located
     |
     |      ``desc`` allows for reversing the sort
     |
     |      ``alpha`` allows for sorting lexicographically rather than numerically
     |
     |      ``store`` allows for storing the result of the sort into
     |          the key ``store``
     |
     |      ``groups`` if set to True and if ``get`` contains at least two
     |          elements, sort will return a list of tuples, each containing the
     |          values fetched from the arguments to ``get``.
     |
     |      For more information, see https://redis.io/commands/sort
     |
     |  sort_ro(self, key: 'str', start: 'int | None' = None, num: 'int | None' = None, by: 'str | None' = None, get: 'list[str] | None' = None, desc: 'bool' = False, alpha: 'bool' = False) -> 'list[bytes | str] | Awaitable[list[bytes | str]]'
     |      Returns the elements contained in the list, set or sorted set at key.
     |      (read-only variant of the SORT command)
     |
     |      ``start`` and ``num`` allow for paging through the sorted data
     |
     |      ``by`` allows using an external key to weight and sort the items.
     |          Use an "*" to indicate where in the key the item value is located
     |
     |      ``get`` allows for returning items from external keys rather than the
     |          sorted data itself.  Use an "*" to indicate where in the key
     |          the item value is located
     |
     |      ``desc`` allows for reversing the sort
     |
     |      ``alpha`` allows for sorting lexicographically rather than numerically
     |
     |      For more information, see https://redis.io/commands/sort_ro
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from redis.commands.core.ArrayCommands:
     |
     |  arcount(self, name: 'KeyT') -> 'int | Awaitable[int]'
     |      Return the number of non-empty elements in the array stored at
     |      ``name``. Returns 0 if ``name`` does not exist.
     |
     |      For more information, see https://redis.io/commands/arcount
     |
     |  ardel(self, name: 'KeyT', *indices: 'int') -> 'int | Awaitable[int]'
     |      Delete elements at the specified ``indices`` in the array stored at
     |      ``name``. Deleting an index that does not exist counts as zero
     |      elements deleted and does not modify the array.
     |
     |      Returns the number of elements deleted.
     |
     |      For more information, see https://redis.io/commands/ardel
     |
     |  ardelrange(self, name: 'KeyT', *ranges: 'tuple[int, int]') -> 'int | Awaitable[int]'
     |      Delete elements within one or more inclusive index ranges in the
     |      array stored at ``name``. Each range is a ``(start, end)`` tuple.
     |      If ``start`` is greater than ``end`` for a given pair, the range is
     |      processed in ascending order regardless. Multiple pairs may overlap;
     |      each element is counted at most once.
     |
     |      Returns the number of elements deleted.
     |
     |      For more information, see https://redis.io/commands/ardelrange
     |
     |  arget(self, name: 'KeyT', index: 'int') -> 'bytes | str | None | Awaitable[bytes | str | None]'
     |      Return the value at ``index`` in the array stored at ``name``.
     |
     |      Returns ``None`` if ``name`` does not exist or no value is set at
     |      ``index``.
     |
     |      For more information, see https://redis.io/commands/arget
     |
     |  argetrange(self, name: 'KeyT', start: 'int', end: 'int') -> 'list[bytes | str | None] | Awaitable[list[bytes | str | None]]'
     |      Return the values in the inclusive index range [``start``, ``end``]
     |      in the array stored at ``name``. If ``start`` is greater than ``end``,
     |      elements are returned in reverse index order.
     |
     |      For more information, see https://redis.io/commands/argetrange
     |
     |  argrep(self, name: 'KeyT', start: 'int', end: 'int', predicates: 'list[tuple[ArrayPredicateType, EncodableT]]', combinator: 'ArrayPredicateCombinator | None' = None, limit: 'int | None' = None, withvalues: 'bool' = False, nocase: 'bool' = False) -> 'list[int] | list[list[int | bytes | str]] | Awaitable[list[int] | list[list[int | bytes | str]]]'
     |      Search elements of the array stored at ``name`` within the inclusive
     |      index range [``start``, ``end``] using one or more textual
     |      ``predicates``. Each predicate is a ``(type, value)`` tuple where
     |      ``type`` is a member of ``ArrayPredicateType``
     |      (``EXACT``, ``MATCH``, ``GLOB``, ``RE``).
     |
     |      Multiple predicates are combined via ``combinator``
     |      (``ArrayPredicateCombinator.AND`` or ``OR``); the server defaults to
     |      OR when omitted. ``limit`` caps the number of matches.
     |      ``withvalues=True`` returns a list of ``[index, value]`` pairs
     |      (``[[idx, val], ...]``) instead of a flat list of indices.
     |      ``nocase=True`` makes all comparisons case-insensitive.
     |
     |      Without ``withvalues``, returns a flat list of matching indices in
     |      traversal order. With ``withvalues``, returns a list of
     |      ``[index, value]`` pairs in traversal order. Empty slots are
     |      skipped.
     |
     |      For more information, see https://redis.io/commands/argrep
     |
     |  arinfo(self, name: 'KeyT', full: 'bool' = False) -> 'dict[str, int] | Awaitable[dict[str, int]]'
     |      Return metadata about the array stored at ``name`` as a dictionary.
     |      When ``full`` is ``True``, additionally include per-slice statistics
     |      (dense/sparse slice counts, average sizes, fill rates), which makes
     |      the call O(N) instead of O(1).
     |
     |      Raises ``ResponseError`` when the key does not exist.
     |
     |      For more information, see https://redis.io/commands/arinfo
     |
     |  arinsert(self, name: 'KeyT', *values: 'FieldT') -> 'int | Awaitable[int]'
     |      Insert one or more ``values`` at consecutive indices in the array
     |      stored at ``name``, beginning at the current insert cursor position.
     |      The cursor advances by one for each value inserted. Use ``ARNEXT``
     |      to inspect the current cursor position and ``ARSEEK`` to reposition
     |      it.
     |
     |      Returns the last index where a value was inserted.
     |
     |      For more information, see https://redis.io/commands/arinsert
     |
     |  arlastitems(self, name: 'KeyT', count: 'int', rev: 'bool' = False) -> 'list[bytes | str | None] | Awaitable[list[bytes | str | None]]'
     |      Return up to ``count`` most recently inserted elements from the array
     |      stored at ``name``. If the array contains fewer elements than
     |      ``count``, all elements are returned.
     |
     |      When ``rev`` is ``True``, elements are returned in reverse
     |      chronological order (most recent first) instead of the default
     |      oldest-first order.
     |
     |      For more information, see https://redis.io/commands/arlastitems
     |
     |  arlen(self, name: 'KeyT') -> 'int | Awaitable[int]'
     |      Return the length of the array stored at ``name``, defined as the
     |      maximum set index plus one. Returns 0 if ``name`` does not exist.
     |
     |      For more information, see https://redis.io/commands/arlen
     |
     |  armget(self, name: 'KeyT', *indices: 'int') -> 'list[bytes | str | None] | Awaitable[list[bytes | str | None]]'
     |      Return the values at the specified ``indices`` in the array stored at
     |      ``name``. The reply preserves the order of the requested indices and
     |      returns ``None`` for any index that is not set or when ``name`` does
     |      not exist.
     |
     |      For more information, see https://redis.io/commands/armget
     |
     |  armset(self, name: 'KeyT', mapping: 'Mapping[int, FieldT]') -> 'int | Awaitable[int]'
     |      Set multiple index/value pairs in the array stored at ``name``.
     |      ``mapping`` is a dictionary of zero-based integer indices to values.
     |      Pairs may be non-contiguous and in any order.
     |
     |      Returns the number of new slots that were set (previously empty).
     |
     |      For more information, see https://redis.io/commands/armset
     |
     |  arnext(self, name: 'KeyT') -> 'int | None | Awaitable[int | None]'
     |      Return the next index ``ARINSERT`` would use for the array stored at
     |      ``name``. Returns 0 if ``name`` does not exist or no insert happened
     |      yet, and ``None`` when the insertion cursor is exhausted (next insert
     |      would overflow).
     |
     |      For more information, see https://redis.io/commands/arnext
     |
     |  arop(self, name: 'KeyT', start: 'int', end: 'int', operation: 'ArrayAggregateOperations', value: 'EncodableT | None' = None) -> 'bytes | str | int | None | Awaitable[bytes | str | int | None]'
     |      Perform an aggregate ``operation`` on elements of the array stored at
     |      ``name`` in the inclusive index range [``start``, ``end``]. The range
     |      is always scanned from the lower to the higher index regardless of
     |      argument order.
     |
     |      ``operation`` is one of the members of ``ArrayAggregateOperations``.
     |      ``value`` is required when ``operation`` is
     |      ``ArrayAggregateOperations.MATCH`` and specifies the value to compare
     |      against.
     |
     |      Returns a bulk string for ``SUM``, ``MIN`` and ``MAX``, an integer
     |      for ``AND``, ``OR``, ``XOR``, ``MATCH`` and ``USED``, or ``None``
     |      when no elements match the operation.
     |
     |      For more information, see https://redis.io/commands/arop
     |
     |  arring(self, name: 'KeyT', size: 'int', *values: 'FieldT') -> 'int | Awaitable[int]'
     |      Insert one or more ``values`` into the array stored at ``name`` as a
     |      fixed-size ring buffer of ``size`` slots. Each value is placed at
     |      ``insert_idx % size``, wrapping back to index 0 once the end is
     |      reached and overwriting older values when full. If ``size`` is
     |      smaller than the current window, the array is truncated to fit.
     |
     |      Returns the last index where a value was inserted.
     |
     |      For more information, see https://redis.io/commands/arring
     |
     |  arscan(self, name: 'KeyT', start: 'int', end: 'int', limit: 'int | None' = None) -> 'list[list[int | bytes | str]] | Awaitable[list[list[int | bytes | str]]]'
     |      Iterate populated elements of the array stored at ``name`` in the
     |      inclusive range [``start``, ``end``] and return a list of
     |      ``[index, value]`` pairs in traversal order:
     |      ``[[idx1, val1], [idx2, val2], ...]``. Empty slots are skipped. If
     |      ``start`` is greater than ``end``, the iteration is reversed.
     |
     |      ``limit`` caps the number of populated elements returned. When
     |      omitted, all populated elements in range are returned.
     |
     |      For more information, see https://redis.io/commands/arscan
     |
     |  arseek(self, name: 'KeyT', index: 'int') -> 'int | Awaitable[int]'
     |      Set the insert cursor of the array stored at ``name`` to ``index``.
     |      Subsequent ``ARINSERT`` and ``ARRING`` operations begin inserting at
     |      this position.
     |
     |      Returns 1 if the cursor was set, 0 if ``name`` does not exist.
     |
     |      For more information, see https://redis.io/commands/arseek
     |
     |  arset(self, name: 'KeyT', index: 'int', *values: 'FieldT') -> 'int | Awaitable[int]'
     |      Set one or more contiguous ``values`` in the array stored at ``name``
     |      starting at ``index``. When multiple values are provided, they are
     |      stored at consecutive indices beginning at ``index``.
     |
     |      Returns the number of new slots that were set (previously empty).
     |
     |      For more information, see https://redis.io/commands/arset
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from redis.commands.core.AsyncScanCommands:
     |
     |  async hscan_iter(self, name: 'KeyT', match: 'Union[PatternT, None]' = None, count: 'Optional[int]' = None, no_values: 'Union[bool, None]' = None) -> 'AsyncIterator'
     |      Make an iterator using the HSCAN command so that the client doesn't
     |      need to remember the cursor position.
     |
     |      ``match`` allows for filtering the keys by pattern
     |
     |      ``count`` allows for hint the minimum number of returns
     |
     |      ``no_values`` indicates to return only the keys, without values
     |
     |  async scan_iter(self, match: 'Union[PatternT, None]' = None, count: 'Optional[int]' = None, _type: 'Optional[str]' = None, **kwargs) -> 'AsyncIterator'
     |      Make an iterator using the SCAN command so that the client doesn't
     |      need to remember the cursor position.
     |
     |      ``match`` allows for filtering the keys by pattern
     |
     |      ``count`` provides a hint to Redis about the number of keys to
     |          return per batch.
     |
     |      ``_type`` filters the returned values by a particular Redis type.
     |          Stock Redis instances allow for the following types:
     |          HASH, LIST, SET, STREAM, STRING, ZSET
     |          Additionally, Redis modules can expose other types as well.
     |
     |  async sscan_iter(self, name: 'KeyT', match: 'Union[PatternT, None]' = None, count: 'Optional[int]' = None) -> 'AsyncIterator'
     |      Make an iterator using the SSCAN command so that the client doesn't
     |      need to remember the cursor position.
     |
     |      ``match`` allows for filtering the keys by pattern
     |
     |      ``count`` allows for hint the minimum number of returns
     |
     |  async zscan_iter(self, name: 'KeyT', match: 'Union[PatternT, None]' = None, count: 'Optional[int]' = None, score_cast_func: 'Union[type, Callable]' = <class 'float'>) -> 'AsyncIterator'
     |      Make an iterator using the ZSCAN command so that the client doesn't
     |      need to remember the cursor position.
     |
     |      ``match`` allows for filtering the keys by pattern
     |
     |      ``count`` allows for hint the minimum number of returns
     |
     |      ``score_cast_func`` a callable used to cast the score return value
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from redis.commands.core.ScanCommands:
     |
     |  hscan(self, name: 'KeyT', cursor: 'int' = 0, match: 'PatternT | None' = None, count: 'int | None' = None, no_values: 'bool | None' = None) -> 'HScanResponse | Awaitable[HScanResponse]'
     |      Incrementally return key/value slices in a hash. Also return a cursor
     |      indicating the scan position.
     |
     |      ``match`` allows for filtering the keys by pattern
     |
     |      ``count`` allows for hint the minimum number of returns
     |
     |      ``no_values`` indicates to return only the keys, without values.
     |
     |      For more information, see https://redis.io/commands/hscan
     |
     |  scan(self, cursor: 'int' = 0, match: 'PatternT | None' = None, count: 'int | None' = None, _type: 'str | None' = None, **kwargs) -> 'ScanResponse | Awaitable[ScanResponse]'
     |      Incrementally return lists of key names. Also return a cursor
     |      indicating the scan position.
     |
     |      ``match`` allows for filtering the keys by pattern
     |
     |      ``count`` provides a hint to Redis about the number of keys to
     |          return per batch.
     |
     |      ``_type`` filters the returned values by a particular Redis type.
     |          Stock Redis instances allow for the following types:
     |          HASH, LIST, SET, STREAM, STRING, ZSET
     |          Additionally, Redis modules can expose other types as well.
     |
     |      For more information, see https://redis.io/commands/scan
     |
     |  sscan(self, name: 'KeyT', cursor: 'int' = 0, match: 'PatternT | None' = None, count: 'int | None' = None) -> 'ScanResponse | Awaitable[ScanResponse]'
     |      Incrementally return lists of elements in a set. Also return a cursor
     |      indicating the scan position.
     |
     |      ``match`` allows for filtering the keys by pattern
     |
     |      ``count`` allows for hint the minimum number of returns
     |
     |      For more information, see https://redis.io/commands/sscan
     |
     |  zscan(self, name: 'KeyT', cursor: 'int' = 0, match: 'PatternT | None' = None, count: 'int | None' = None, score_cast_func: 'type | Callable' = <class 'float'>) -> 'ZScanResponse | Awaitable[ZScanResponse]'
     |      Incrementally return lists of elements in a sorted set. Also return a
     |      cursor indicating the scan position.
     |
     |      ``match`` allows for filtering the keys by pattern
     |
     |      ``count`` allows for hint the minimum number of returns
     |
     |      ``score_cast_func`` a callable used to cast the score return value
     |
     |      For more information, see https://redis.io/commands/zscan
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from redis.commands.core.SetCommands:
     |
     |  sadd(self, name: 'KeyT', *values: 'FieldT') -> 'int | Awaitable[int]'
     |      Add ``value(s)`` to set ``name``
     |
     |      For more information, see https://redis.io/commands/sadd
     |
     |  scard(self, name: 'KeyT') -> 'int | Awaitable[int]'
     |      Return the number of elements in set ``name``
     |
     |      For more information, see https://redis.io/commands/scard
     |
     |  sdiff(self, keys: 'List', *args: 'List') -> 'set[bytes | str] | Awaitable[set[bytes | str]]'
     |      Return the difference of sets specified by ``keys``
     |
     |      For more information, see https://redis.io/commands/sdiff
     |
     |  sdiffcard(self, numkeys: 'int', keys: 'List[KeyT]', limit: 'int' = 0) -> 'int | Awaitable[int]'
     |      Return the cardinality of the difference between the first set and all
     |      the successive sets specified by ``keys``, without returning the
     |      difference itself.
     |
     |      When LIMIT is provided (defaults to 0 and means unlimited), the returned
     |      cardinality is capped at ``limit`` and the server may stop the
     |      computation once the capped result is known.
     |
     |      For more information, see https://redis.io/commands/sdiffcard
     |
     |  sdiffstore(self, dest: 'str', keys: 'List', *args: 'List') -> 'int | Awaitable[int]'
     |      Store the difference of sets specified by ``keys`` into a new
     |      set named ``dest``.  Returns the number of keys in the new set.
     |
     |      For more information, see https://redis.io/commands/sdiffstore
     |
     |  sinter(self, keys: 'List', *args: 'List') -> 'set[bytes | str] | Awaitable[set[bytes | str]]'
     |      Return the intersection of sets specified by ``keys``
     |
     |      For more information, see https://redis.io/commands/sinter
     |
     |  sintercard(self, numkeys: 'int', keys: 'List[KeyT]', limit: 'int' = 0) -> 'int | Awaitable[int]'
     |      Return the cardinality of the intersect of multiple sets specified by ``keys``.
     |
     |      When LIMIT provided (defaults to 0 and means unlimited), if the intersection
     |      cardinality reaches limit partway through the computation, the algorithm will
     |      exit and yield limit as the cardinality
     |
     |      For more information, see https://redis.io/commands/sintercard
     |
     |  sinterstore(self, dest: 'KeyT', keys: 'List', *args: 'List') -> 'int | Awaitable[int]'
     |      Store the intersection of sets specified by ``keys`` into a new
     |      set named ``dest``.  Returns the number of keys in the new set.
     |
     |      For more information, see https://redis.io/commands/sinterstore
     |
     |  sismember(self, name: 'KeyT', value: 'str') -> 'Literal[0] | Literal[1] | Awaitable[Literal[0] | Literal[1]]'
     |      Return whether ``value`` is a member of set ``name``:
     |      - 1 if the value is a member of the set.
     |      - 0 if the value is not a member of the set or if key does not exist.
     |
     |      For more information, see https://redis.io/commands/sismember
     |
     |  smembers(self, name: 'KeyT') -> 'set[bytes | str] | Awaitable[set[bytes | str]]'
     |      Return all members of the set ``name``
     |
     |      For more information, see https://redis.io/commands/smembers
     |
     |  smismember(self, name: 'KeyT', values: 'List', *args: 'List') -> 'list[Literal[0] | Literal[1]] | Awaitable[list[Literal[0] | Literal[1]]]'
     |      Return whether each value in ``values`` is a member of the set ``name``
     |      as a list of ``int`` in the order of ``values``:
     |      - 1 if the value is a member of the set.
     |      - 0 if the value is not a member of the set or if key does not exist.
     |
     |      For more information, see https://redis.io/commands/smismember
     |
     |  smove(self, src: 'KeyT', dst: 'KeyT', value: 'str') -> 'bool | Awaitable[bool]'
     |      Move ``value`` from set ``src`` to set ``dst`` atomically
     |
     |      For more information, see https://redis.io/commands/smove
     |
     |  spop(self, name: 'KeyT', count: 'int | None' = None) -> 'bytes | str | set[bytes | str] | None | Awaitable[bytes | str | set[bytes | str] | None]'
     |      Remove and return a random member of set ``name``
     |
     |      For more information, see https://redis.io/commands/spop
     |
     |  srandmember(self, name: 'KeyT', number: 'int | None' = None) -> 'bytes | str | list[bytes | str] | None | Awaitable[bytes | str | list[bytes | str] | None]'
     |      If ``number`` is None, returns a random member of set ``name``.
     |
     |      If ``number`` is supplied, returns a list of ``number`` random
     |      members of set ``name``. Note this is only available when running
     |      Redis 2.6+.
     |
     |      For more information, see https://redis.io/commands/srandmember
     |
     |  srem(self, name: 'KeyT', *values: 'FieldT') -> 'int | Awaitable[int]'
     |      Remove ``values`` from set ``name``
     |
     |      For more information, see https://redis.io/commands/srem
     |
     |  sunion(self, keys: 'List', *args: 'List') -> 'set[bytes | str] | Awaitable[set[bytes | str]]'
     |      Return the union of sets specified by ``keys``
     |
     |      For more information, see https://redis.io/commands/sunion
     |
     |  sunioncard(self, numkeys: 'int', keys: 'List[KeyT]', limit: 'int' = 0, approx: 'bool' = False) -> 'int | Awaitable[int]'
     |      Return the cardinality of the union of multiple sets specified by
     |      ``keys``, without returning the union itself.
     |
     |      When ``approx`` is True, the ``APPROX`` option is sent and the server
     |      returns an approximate cardinality computed using HyperLogLog.
     |
     |      When LIMIT is provided (defaults to 0 and means unlimited), the returned
     |      cardinality is capped at ``limit``. In exact mode the result equals
     |      ``limit`` when the real cardinality exceeds ``limit``; in approximate
     |      mode the result will not exceed ``limit``. Options are emitted in the
     |      canonical order ``APPROX`` before ``LIMIT``.
     |
     |      For more information, see https://redis.io/commands/sunioncard
     |
     |  sunionstore(self, dest: 'KeyT', keys: 'List', *args: 'List') -> 'int | Awaitable[int]'
     |      Store the union of sets specified by ``keys`` into a new
     |      set named ``dest``.  Returns the number of keys in the new set.
     |
     |      For more information, see https://redis.io/commands/sunionstore
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from redis.commands.core.StreamCommands:
     |
     |  xack(self, name: 'KeyT', groupname: 'GroupT', *ids: 'StreamIdT') -> 'int | Awaitable[int]'
     |      Acknowledges the successful processing of one or more messages.
     |
     |      Args:
     |          name: name of the stream.
     |          groupname: name of the consumer group.
     |          *ids: message ids to acknowledge.
     |
     |      For more information, see https://redis.io/commands/xack
     |
     |  xackdel(self, name: 'KeyT', groupname: 'GroupT', *ids: 'StreamIdT', ref_policy: "Literal['KEEPREF', 'DELREF', 'ACKED']" = 'KEEPREF') -> 'int | Awaitable[int]'
     |      Combines the functionality of XACK and XDEL. Acknowledges the specified
     |      message IDs in the given consumer group and simultaneously attempts to
     |      delete the corresponding entries from the stream.
     |
     |  xadd(self, name: 'KeyT', fields: 'Dict[FieldT, EncodableT]', id: 'StreamIdT' = '*', maxlen: 'Optional[int]' = None, approximate: 'bool' = True, nomkstream: 'bool' = False, minid: 'Union[StreamIdT, None]' = None, limit: 'int | None' = None, ref_policy: "Literal['KEEPREF', 'DELREF', 'ACKED'] | None" = None, idmpauto: 'str | None' = None, idmp: 'tuple[str, bytes] | None' = None) -> 'bytes | str | Awaitable[bytes | str]'
     |      Add to a stream.
     |      name: name of the stream
     |      fields: dict of field/value pairs to insert into the stream
     |      id: Location to insert this record. By default it is appended.
     |      maxlen: truncate old stream members beyond this size.
     |      Can't be specified with minid.
     |      approximate: actual stream length may be slightly more than maxlen
     |      nomkstream: When set to true, do not make a stream
     |      minid: the minimum id in the stream to query.
     |      Can't be specified with maxlen.
     |      limit: specifies the maximum number of entries to retrieve
     |      ref_policy: optional reference policy for consumer groups when trimming:
     |          - KEEPREF (default): When trimming, preserves references in consumer groups' PEL
     |          - DELREF: When trimming, removes all references from consumer groups' PEL
     |          - ACKED: When trimming, only removes entries acknowledged by all consumer groups
     |      idmpauto: Producer ID for automatic idempotent ID calculation.
     |          Automatically calculates an idempotent ID based on entry content to prevent
     |          duplicate entries. Can only be used with id='*'. Creates an IDMP map if it
     |          doesn't exist yet. The producer ID must be unique per producer and consistent
     |          across restarts.
     |      idmp: Tuple of (producer_id, idempotent_id) for explicit idempotent ID.
     |          Uses a specific idempotent ID to prevent duplicate entries. Can only be used
     |          with id='*'. The producer ID must be unique per producer and consistent across
     |          restarts. The idempotent ID must be unique per message and per producer.
     |          Shorter idempotent IDs require less memory and allow faster processing.
     |          Creates an IDMP map if it doesn't exist yet.
     |
     |      For more information, see https://redis.io/commands/xadd
     |
     |  xautoclaim(self, name: 'KeyT', groupname: 'GroupT', consumername: 'ConsumerT', min_idle_time: 'int', start_id: 'StreamIdT' = '0-0', count: 'int | None' = None, justid: 'bool' = False) -> 'list[Any] | Awaitable[list[Any]]'
     |      Transfers ownership of pending stream entries that match the specified
     |      criteria. Conceptually, equivalent to calling XPENDING and then XCLAIM,
     |      but provides a more straightforward way to deal with message delivery
     |      failures via SCAN-like semantics.
     |      name: name of the stream.
     |      groupname: name of the consumer group.
     |      consumername: name of a consumer that claims the message.
     |      min_idle_time: filter messages that were idle less than this amount of
     |      milliseconds.
     |      start_id: filter messages with equal or greater ID.
     |      count: optional integer, upper limit of the number of entries that the
     |      command attempts to claim. Set to 100 by default.
     |      justid: optional boolean, false by default. Return just an array of IDs
     |      of messages successfully claimed, without returning the actual message
     |
     |      For more information, see https://redis.io/commands/xautoclaim
     |
     |  xcfgset(self, name: 'KeyT', idmp_duration: 'int | None' = None, idmp_maxsize: 'int | None' = None) -> 'bytes | str | Awaitable[bytes | str]'
     |      Configure the idempotency parameters for a stream's IDMP map.
     |
     |      Sets how long Redis remembers each idempotent ID (iid) and the maximum
     |      number of iids to track. This command clears the existing IDMP map
     |      (Redis forgets all previously stored iids), but only if the configuration
     |      value actually changes.
     |
     |      Args:
     |          name: The name of the stream.
     |          idmp_duration: How long Redis remembers each iid in seconds.
     |              Default: 100 seconds (or value set by stream-idmp-duration config).
     |              Minimum: 1 second, Maximum: 300 seconds.
     |              Redis won't forget an iid for this duration (unless maxsize is reached).
     |              Should accommodate application crash recovery time.
     |          idmp_maxsize: Maximum number of iids Redis remembers per producer ID (pid).
     |              Default: 100 iids (or value set by stream-idmp-maxsize config).
     |              Minimum: 1 iid, Maximum: 1,000,000 (1M) iids.
     |              Should be set to: mark-delay [in msec] × (messages/msec) + margin.
     |              Example: 10K msgs/sec (10 msgs/msec), 80 msec mark-delay
     |              → maxsize = 10 × 80 + margin = 1000 iids.
     |
     |      Returns:
     |          OK on success.
     |
     |      For more information, see https://redis.io/commands/xcfgset
     |
     |  xclaim(self, name: 'KeyT', groupname: 'GroupT', consumername: 'ConsumerT', min_idle_time: 'int', message_ids: 'Union[List[StreamIdT], Tuple[StreamIdT]]', idle: 'int | None' = None, time: 'int | None' = None, retrycount: 'int | None' = None, force: 'bool' = False, justid: 'bool' = False) -> 'XClaimResponse | Awaitable[XClaimResponse]'
     |      Changes the ownership of a pending message.
     |
     |      name: name of the stream.
     |
     |      groupname: name of the consumer group.
     |
     |      consumername: name of a consumer that claims the message.
     |
     |      min_idle_time: filter messages that were idle less than this amount of
     |      milliseconds
     |
     |      message_ids: non-empty list or tuple of message IDs to claim
     |
     |      idle: optional. Set the idle time (last time it was delivered) of the
     |      message in ms
     |
     |      time: optional integer. This is the same as idle but instead of a
     |      relative amount of milliseconds, it sets the idle time to a specific
     |      Unix time (in milliseconds).
     |
     |      retrycount: optional integer. set the retry counter to the specified
     |      value. This counter is incremented every time a message is delivered
     |      again.
     |
     |      force: optional boolean, false by default. Creates the pending message
     |      entry in the PEL even if certain specified IDs are not already in the
     |      PEL assigned to a different client.
     |
     |      justid: optional boolean, false by default. Return just an array of IDs
     |      of messages successfully claimed, without returning the actual message
     |
     |      For more information, see https://redis.io/commands/xclaim
     |
     |  xdel(self, name: 'KeyT', *ids: 'StreamIdT') -> 'int | Awaitable[int]'
     |      Deletes one or more messages from a stream.
     |
     |      Args:
     |          name: name of the stream.
     |          *ids: message ids to delete.
     |
     |      For more information, see https://redis.io/commands/xdel
     |
     |  xdelex(self, name: 'KeyT', *ids: 'StreamIdT', ref_policy: "Literal['KEEPREF', 'DELREF', 'ACKED']" = 'KEEPREF') -> 'int | Awaitable[int]'
     |      Extended version of XDEL that provides more control over how message entries
     |      are deleted concerning consumer groups.
     |
     |  xgroup_create(self, name: 'KeyT', groupname: 'GroupT', id: 'StreamIdT' = '$', mkstream: 'bool' = False, entries_read: 'int | None' = None) -> 'bool | Awaitable[bool]'
     |      Create a new consumer group associated with a stream.
     |      name: name of the stream.
     |      groupname: name of the consumer group.
     |      id: ID of the last item in the stream to consider already delivered.
     |
     |      For more information, see https://redis.io/commands/xgroup-create
     |
     |  xgroup_createconsumer(self, name: 'KeyT', groupname: 'GroupT', consumername: 'ConsumerT') -> 'int | Awaitable[int]'
     |      Consumers in a consumer group are auto-created every time a new
     |      consumer name is mentioned by some command.
     |      They can be explicitly created by using this command.
     |      name: name of the stream.
     |      groupname: name of the consumer group.
     |      consumername: name of consumer to create.
     |
     |      See: https://redis.io/commands/xgroup-createconsumer
     |
     |  xgroup_delconsumer(self, name: 'KeyT', groupname: 'GroupT', consumername: 'ConsumerT') -> 'int | Awaitable[int]'
     |      Remove a specific consumer from a consumer group.
     |      Returns the number of pending messages that the consumer had before it
     |      was deleted.
     |      name: name of the stream.
     |      groupname: name of the consumer group.
     |      consumername: name of consumer to delete
     |
     |      For more information, see https://redis.io/commands/xgroup-delconsumer
     |
     |  xgroup_destroy(self, name: 'KeyT', groupname: 'GroupT') -> 'bool | Awaitable[bool]'
     |      Destroy a consumer group.
     |      name: name of the stream.
     |      groupname: name of the consumer group.
     |
     |      For more information, see https://redis.io/commands/xgroup-destroy
     |
     |  xgroup_setid(self, name: 'KeyT', groupname: 'GroupT', id: 'StreamIdT', entries_read: 'int | None' = None) -> 'bool | Awaitable[bool]'
     |      Set the consumer group last delivered ID to something else.
     |      name: name of the stream.
     |      groupname: name of the consumer group.
     |      id: ID of the last item in the stream to consider already delivered.
     |
     |      For more information, see https://redis.io/commands/xgroup-setid
     |
     |  xinfo_consumers(self, name: 'KeyT', groupname: 'GroupT') -> 'list[dict[str, Any]] | Awaitable[list[dict[str, Any]]]'
     |      Returns general information about the consumers in the group.
     |      name: name of the stream.
     |      groupname: name of the consumer group.
     |
     |      For more information, see https://redis.io/commands/xinfo-consumers
     |
     |  xinfo_groups(self, name: 'KeyT') -> 'list[dict[str, Any]] | Awaitable[list[dict[str, Any]]]'
     |      Returns general information about the consumer groups of the stream.
     |      name: name of the stream.
     |
     |      For more information, see https://redis.io/commands/xinfo-groups
     |
     |  xinfo_stream(self, name: 'KeyT', full: 'bool' = False) -> 'dict[str, Any] | Awaitable[dict[str, Any]]'
     |      Returns general information about the stream.
     |      name: name of the stream.
     |      full: optional boolean, false by default. Return full summary
     |
     |      For more information, see https://redis.io/commands/xinfo-stream
     |
     |  xlen(self, name: 'KeyT') -> 'int | Awaitable[int]'
     |      Returns the number of elements in a given stream.
     |
     |      For more information, see https://redis.io/commands/xlen
     |
     |  xnack(self, name: 'KeyT', groupname: 'GroupT', mode: "Literal['SILENT', 'FAIL', 'FATAL']", *ids: 'StreamIdT', retrycount: 'int | None' = None, force: 'bool' = False) -> 'int | Awaitable[int]'
     |      Negatively acknowledges one or more messages in a consumer group's
     |      Pending Entries List (PEL).
     |
     |      Args:
     |          name: name of the stream.
     |          groupname: name of the consumer group.
     |          mode: the nacking mode. One of SILENT, FAIL, or FATAL.
     |              SILENT: consumer shutting down; decrements delivery counter.
     |              FAIL: consumer unable to process; delivery counter unchanged.
     |              FATAL: invalid/malicious message; delivery counter set to max.
     |          *ids: one or more message IDs to NACK.
     |          retrycount: optional integer >= 0. Overrides the mode's implicit
     |              delivery counter adjustment with an exact value.
     |          force: if True, creates a new unowned PEL entry for any ID not
     |              already in the group's PEL.
     |
     |      Returns:
     |          The number of messages successfully NACKed.
     |
     |      For more information, see https://redis.io/commands/xnack
     |
     |  xpending(self, name: 'KeyT', groupname: 'GroupT') -> 'dict[str, Any] | Awaitable[dict[str, Any]]'
     |      Returns information about pending messages of a group.
     |      name: name of the stream.
     |      groupname: name of the consumer group.
     |
     |      For more information, see https://redis.io/commands/xpending
     |
     |  xpending_range(self, name: 'KeyT', groupname: 'GroupT', min: 'StreamIdT', max: 'StreamIdT', count: 'int', consumername: 'ConsumerT | None' = None, idle: 'int | None' = None) -> 'XPendingRangeResponse | Awaitable[XPendingRangeResponse]'
     |      Returns information about pending messages, in a range.
     |
     |      name: name of the stream.
     |      groupname: name of the consumer group.
     |      idle: available from  version 6.2. filter entries by their
     |      idle-time, given in milliseconds (optional).
     |      min: minimum stream ID.
     |      max: maximum stream ID.
     |      count: number of messages to return
     |      consumername: name of a consumer to filter by (optional).
     |
     |  xrange(self, name: 'KeyT', min: 'StreamIdT' = '-', max: 'StreamIdT' = '+', count: 'int | None' = None) -> 'StreamRangeResponse | None | Awaitable[StreamRangeResponse | None]'
     |      Read stream values within an interval.
     |
     |      name: name of the stream.
     |
     |      start: first stream ID. defaults to '-',
     |             meaning the earliest available.
     |
     |      finish: last stream ID. defaults to '+',
     |              meaning the latest available.
     |
     |      count: if set, only return this many items, beginning with the
     |             earliest available.
     |
     |      For more information, see https://redis.io/commands/xrange
     |
     |  xread(self, streams: 'Dict[KeyT, StreamIdT]', count: 'int | None' = None, block: 'int | None' = None, max_count: 'int | None' = None, max_size: 'int | None' = None) -> 'XReadResponse | Awaitable[XReadResponse]'
     |      Block and monitor multiple streams for new data.
     |
     |      streams: a dict of stream names to stream IDs, where
     |                 IDs indicate the last ID already seen.
     |
     |      count: if set, only return this many items per stream, beginning with
     |             the earliest available.
     |
     |      block: number of milliseconds to wait, if nothing already present.
     |
     |      max_count: if set, cap the total number of entries returned across all
     |                 streams combined. Unlike ``count`` (a per-stream limit),
     |                 this is a cumulative cap over the whole reply. Must be a
     |                 positive integer and, when ``count`` is also set, must be
     |                 greater than or equal to ``count``. Requires Redis >= 8.10.0.
     |
     |      max_size: if set, a soft cap on the total server reply size in bytes
     |                across all streams combined. Measured server-side including
     |                protocol overhead, so it is not an exact application-payload
     |                size guarantee; a single available entry larger than the cap
     |                may still be returned. Must be a positive integer. Requires
     |                Redis >= 8.10.0.
     |
     |      For more information, see https://redis.io/commands/xread
     |
     |  xreadgroup(self, groupname: 'str', consumername: 'str', streams: 'Dict[KeyT, StreamIdT]', count: 'int | None' = None, block: 'int | None' = None, noack: 'bool' = False, claim_min_idle_time: 'int | None' = None, max_count: 'int | None' = None, max_size: 'int | None' = None) -> 'XReadGroupResponse | Awaitable[XReadGroupResponse]'
     |      Read from a stream via a consumer group.
     |
     |      groupname: name of the consumer group.
     |
     |      consumername: name of the requesting consumer.
     |
     |      streams: a dict of stream names to stream IDs, where
     |             IDs indicate the last ID already seen.
     |
     |      count: if set, only return this many items per stream, beginning with
     |             the earliest available.
     |
     |      block: number of milliseconds to wait, if nothing already present.
     |      noack: do not add messages to the PEL
     |
     |      claim_min_idle_time: accepts an integer type and represents a
     |                           time interval in milliseconds
     |
     |      max_count: if set, cap the total number of entries returned across all
     |                 streams combined. Unlike ``count`` (a per-stream limit),
     |                 this is a cumulative cap over the whole reply. Must be a
     |                 positive integer and, when ``count`` is also set, must be
     |                 greater than or equal to ``count``. Requires Redis 8.10.0.
     |
     |      max_size: if set, a soft cap on the total server reply size in bytes
     |                across all streams combined. Measured server-side including
     |                protocol overhead, so it is not an exact application-payload
     |                size guarantee; a single available entry larger than the cap
     |                may still be returned. Must be a positive integer. Requires
     |                Redis 8.10.0.
     |
     |      For more information, see https://redis.io/commands/xreadgroup
     |
     |  xrevrange(self, name: 'KeyT', max: 'StreamIdT' = '+', min: 'StreamIdT' = '-', count: 'int | None' = None) -> 'StreamRangeResponse | None | Awaitable[StreamRangeResponse | None]'
     |      Read stream values within an interval, in reverse order.
     |
     |      name: name of the stream
     |
     |      start: first stream ID. defaults to '+',
     |             meaning the latest available.
     |
     |      finish: last stream ID. defaults to '-',
     |              meaning the earliest available.
     |
     |      count: if set, only return this many items, beginning with the
     |             latest available.
     |
     |      For more information, see https://redis.io/commands/xrevrange
     |
     |  xtrim(self, name: 'KeyT', maxlen: 'int | None' = None, approximate: 'bool' = True, minid: 'StreamIdT | None' = None, limit: 'int | None' = None, ref_policy: "Literal['KEEPREF', 'DELREF', 'ACKED'] | None" = None) -> 'int | Awaitable[int]'
     |      Trims old messages from a stream.
     |      name: name of the stream.
     |      maxlen: truncate old stream messages beyond this size
     |      Can't be specified with minid.
     |      approximate: actual stream length may be slightly more than maxlen
     |      minid: the minimum id in the stream to query
     |      Can't be specified with maxlen.
     |      limit: specifies the maximum number of entries to retrieve
     |      ref_policy: optional reference policy for consumer groups:
     |          - KEEPREF (default): Trims entries but preserves references in consumer groups' PEL
     |          - DELREF: Trims entries and removes all references from consumer groups' PEL
     |          - ACKED: Only trims entries that were read and acknowledged by all consumer groups
     |
     |      For more information, see https://redis.io/commands/xtrim
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from redis.commands.core.SortedSetCommands:
     |
     |  bzmpop(self, timeout: 'float', numkeys: 'int', keys: 'List[str]', min: 'bool | None' = False, max: 'bool | None' = False, count: 'int | None' = 1) -> 'ZMPopResponse | Awaitable[ZMPopResponse]'
     |      Pop ``count`` values (default 1) off of the first non-empty sorted set
     |      named in the ``keys`` list.
     |
     |      If none of the sorted sets in ``keys`` has a value to pop,
     |      then block for ``timeout`` seconds, or until a member gets added
     |      to one of the sorted sets.
     |
     |      If timeout is 0, then block indefinitely.
     |
     |      For more information, see https://redis.io/commands/bzmpop
     |
     |  bzpopmax(self, keys: 'KeysT', timeout: 'TimeoutSecT' = 0) -> 'BlockingZSetPopResponse | Awaitable[BlockingZSetPopResponse]'
     |      ZPOPMAX a value off of the first non-empty sorted set
     |      named in the ``keys`` list.
     |
     |      If none of the sorted sets in ``keys`` has a value to ZPOPMAX,
     |      then block for ``timeout`` seconds, or until a member gets added
     |      to one of the sorted sets.
     |
     |      If timeout is 0, then block indefinitely.
     |
     |      For more information, see https://redis.io/commands/bzpopmax
     |
     |  bzpopmin(self, keys: 'KeysT', timeout: 'TimeoutSecT' = 0) -> 'BlockingZSetPopResponse | Awaitable[BlockingZSetPopResponse]'
     |      ZPOPMIN a value off of the first non-empty sorted set
     |      named in the ``keys`` list.
     |
     |      If none of the sorted sets in ``keys`` has a value to ZPOPMIN,
     |      then block for ``timeout`` seconds, or until a member gets added
     |      to one of the sorted sets.
     |
     |      If timeout is 0, then block indefinitely.
     |
     |      For more information, see https://redis.io/commands/bzpopmin
     |
     |  zadd(self, name: 'KeyT', mapping: 'Mapping[AnyKeyT, EncodableT]', nx: 'bool' = False, xx: 'bool' = False, ch: 'bool' = False, incr: 'bool' = False, gt: 'bool' = False, lt: 'bool' = False) -> 'int | float | None | Awaitable[int | float | None]'
     |      Set any number of element-name, score pairs to the key ``name``. Pairs
     |      are specified as a dict of element-names keys to score values.
     |
     |      ``nx`` forces ZADD to only create new elements and not to update
     |      scores for elements that already exist.
     |
     |      ``xx`` forces ZADD to only update scores of elements that already
     |      exist. New elements will not be added.
     |
     |      ``ch`` modifies the return value to be the numbers of elements changed.
     |      Changed elements include new elements that were added and elements
     |      whose scores changed.
     |
     |      ``incr`` modifies ZADD to behave like ZINCRBY. In this mode only a
     |      single element/score pair can be specified and the score is the amount
     |      the existing score will be incremented by. When using this mode the
     |      return value of ZADD will be the new score of the element.
     |
     |      ``lt`` only updates existing elements if the new score is less than
     |      the current score. This flag doesn't prevent adding new elements.
     |
     |      ``gt`` only updates existing elements if the new score is greater than
     |      the current score. This flag doesn't prevent adding new elements.
     |
     |      The return value of ZADD varies based on the mode specified. With no
     |      options, ZADD returns the number of new elements added to the sorted
     |      set.
     |
     |      ``nx``, ``lt``, and ``gt`` are mutually exclusive options.
     |
     |      See: https://redis.io/commands/ZADD
     |
     |  zcard(self, name: 'KeyT') -> 'int | Awaitable[int]'
     |      Return the number of elements in the sorted set ``name``
     |
     |      For more information, see https://redis.io/commands/zcard
     |
     |  zcount(self, name: 'KeyT', min: 'ZScoreBoundT', max: 'ZScoreBoundT') -> 'int | Awaitable[int]'
     |      Returns the number of elements in the sorted set at key ``name`` with
     |      a score between ``min`` and ``max``.
     |
     |      For more information, see https://redis.io/commands/zcount
     |
     |  zdiff(self, keys: 'KeysT', withscores: 'bool' = False) -> 'ZSetRangeResponse | Awaitable[ZSetRangeResponse]'
     |      Returns the difference between the first and all successive input
     |      sorted sets provided in ``keys``.
     |
     |      For more information, see https://redis.io/commands/zdiff
     |
     |  zdiffstore(self, dest: 'KeyT', keys: 'KeysT') -> 'int | Awaitable[int]'
     |      Computes the difference between the first and all successive input
     |      sorted sets provided in ``keys`` and stores the result in ``dest``.
     |
     |      For more information, see https://redis.io/commands/zdiffstore
     |
     |  zincrby(self, name: 'KeyT', amount: 'float', value: 'EncodableT') -> 'float | None | Awaitable[float | None]'
     |      Increment the score of ``value`` in sorted set ``name`` by ``amount``
     |
     |      For more information, see https://redis.io/commands/zincrby
     |
     |  zinter(self, keys: 'KeysT', aggregate: 'str | None' = None, withscores: 'bool' = False) -> 'ZSetRangeResponse | Awaitable[ZSetRangeResponse]'
     |      Return the intersect of multiple sorted sets specified by ``keys``.
     |
     |      With the ``aggregate`` option, it is possible to specify how the
     |      results of the intersection are aggregated. Available aggregation
     |      modes:
     |
     |      - ``SUM`` (default): the score of an element is summed across the
     |        inputs where it exists.
     |        Score = SUM(score₁×weight₁, score₂×weight₂, ...)
     |      - ``MIN``: the resulting set will contain the minimum score of an
     |        element across the inputs where it exists.
     |        Score = MIN(score₁×weight₁, score₂×weight₂, ...)
     |      - ``MAX``: the resulting set will contain the maximum score of an
     |        element across the inputs where it exists.
     |        Score = MAX(score₁×weight₁, score₂×weight₂, ...)
     |      - ``COUNT``: ignores the original scores and counts weighted set
     |        membership. Each element's score is the sum of the weights of
     |        the input sets that contain it.
     |        Score = SUM(weight₁, weight₂, ...) for sets containing the element.
     |        When all weights are 1 (default), the score equals the number
     |        of input sets containing the element.
     |
     |      For more information, see https://redis.io/commands/zinter
     |
     |  zintercard(self, numkeys: 'int', keys: 'List[str]', limit: 'int' = 0) -> 'int | Awaitable[int]'
     |      Return the cardinality of the intersect of multiple sorted sets
     |      specified by ``keys``.
     |      When LIMIT provided (defaults to 0 and means unlimited), if the intersection
     |      cardinality reaches limit partway through the computation, the algorithm will
     |      exit and yield limit as the cardinality
     |
     |      For more information, see https://redis.io/commands/zintercard
     |
     |  zinterstore(self, dest: 'KeyT', keys: 'Sequence[KeyT] | Mapping[AnyKeyT, float]', aggregate: 'str | None' = None) -> 'int | Awaitable[int]'
     |      Intersect multiple sorted sets specified by ``keys`` into a new
     |      sorted set, ``dest``. Scores in the destination will be aggregated
     |      based on the ``aggregate``.
     |
     |      Available aggregation modes:
     |
     |      - ``SUM`` (default): the score of an element is summed across the
     |        inputs where it exists.
     |        Score = SUM(score₁×weight₁, score₂×weight₂, ...)
     |      - ``MIN``: the resulting set will contain the minimum score of an
     |        element across the inputs where it exists.
     |        Score = MIN(score₁×weight₁, score₂×weight₂, ...)
     |      - ``MAX``: the resulting set will contain the maximum score of an
     |        element across the inputs where it exists.
     |        Score = MAX(score₁×weight₁, score₂×weight₂, ...)
     |      - ``COUNT``: ignores the original scores and counts weighted set
     |        membership. Each element's score is the sum of the weights of
     |        the input sets that contain it.
     |        Score = SUM(weight₁, weight₂, ...) for sets containing the element.
     |        When all weights are 1 (default), the score equals the number
     |        of input sets containing the element.
     |
     |      For more information, see https://redis.io/commands/zinterstore
     |
     |  zlexcount(self, name: 'KeyT', min: 'EncodableT', max: 'EncodableT') -> 'int | Awaitable[int]'
     |      Return the number of items in the sorted set ``name`` between the
     |      lexicographical range ``min`` and ``max``.
     |
     |      For more information, see https://redis.io/commands/zlexcount
     |
     |  zmpop(self, num_keys: 'int', keys: 'List[str]', min: 'bool | None' = False, max: 'bool | None' = False, count: 'int | None' = 1) -> 'ZMPopResponse | Awaitable[ZMPopResponse]'
     |      Pop ``count`` values (default 1) off of the first non-empty sorted set
     |      named in the ``keys`` list.
     |      For more information, see https://redis.io/commands/zmpop
     |
     |  zmscore(self, key: 'KeyT', members: 'List[str]') -> 'list[float | None] | Awaitable[list[float | None]]'
     |      Returns the scores associated with the specified members
     |      in the sorted set stored at key.
     |      ``members`` should be a list of the member name.
     |      Return type is a list of score.
     |      If the member does not exist, a None will be returned
     |      in corresponding position.
     |
     |      For more information, see https://redis.io/commands/zmscore
     |
     |  zpopmax(self, name: 'KeyT', count: 'int | None' = None) -> 'ZSetRangeResponse | Awaitable[ZSetRangeResponse]'
     |      Remove and return up to ``count`` members with the highest scores
     |      from the sorted set ``name``.
     |
     |      For more information, see https://redis.io/commands/zpopmax
     |
     |  zpopmin(self, name: 'KeyT', count: 'int | None' = None) -> 'ZSetRangeResponse | Awaitable[ZSetRangeResponse]'
     |      Remove and return up to ``count`` members with the lowest scores
     |      from the sorted set ``name``.
     |
     |      For more information, see https://redis.io/commands/zpopmin
     |
     |  zrandmember(self, key: 'KeyT', count: 'int | None' = None, withscores: 'bool' = False) -> 'ZRandMemberResponse | Awaitable[ZRandMemberResponse]'
     |      Return a random element from the sorted set value stored at key.
     |
     |      ``count`` if the argument is positive, return an array of distinct
     |      fields. If called with a negative count, the behavior changes and
     |      the command is allowed to return the same field multiple times.
     |      In this case, the number of returned fields is the absolute value
     |      of the specified count.
     |
     |      ``withscores`` The optional WITHSCORES modifier changes the reply so it
     |      includes the respective scores of the randomly selected elements from
     |      the sorted set.
     |
     |      For more information, see https://redis.io/commands/zrandmember
     |
     |  zrange(self, name: 'KeyT', start: 'EncodableT', end: 'EncodableT', desc: 'bool' = False, withscores: 'bool' = False, score_cast_func: 'type | Callable' = <class 'float'>, byscore: 'bool' = False, bylex: 'bool' = False, offset: 'int | None' = None, num: 'int | None' = None) -> 'ZSetRangeResponse | Awaitable[ZSetRangeResponse]'
     |      Return a range of values from sorted set ``name`` between
     |      ``start`` and ``end`` sorted in ascending order.
     |
     |      ``start`` and ``end`` can be negative, indicating the end of the range.
     |
     |      ``desc`` a boolean indicating whether to sort the results in reversed
     |      order.
     |
     |      ``withscores`` indicates to return the scores along with the values.
     |      The return type is a list of (value, score) pairs.
     |
     |      ``score_cast_func`` a callable used to cast the score return value.
     |
     |      ``byscore`` when set to True, returns the range of elements from the
     |      sorted set having scores equal or between ``start`` and ``end``.
     |
     |      ``bylex`` when set to True, returns the range of elements from the
     |      sorted set between the ``start`` and ``end`` lexicographical closed
     |      range intervals.
     |      Valid ``start`` and ``end`` must start with ( or [, in order to specify
     |      whether the range interval is exclusive or inclusive, respectively.
     |
     |      ``offset`` and ``num`` are specified, then return a slice of the range.
     |      Can't be provided when using ``bylex``.
     |
     |      For more information, see https://redis.io/commands/zrange
     |
     |  zrangebylex(self, name: 'KeyT', min: 'EncodableT', max: 'EncodableT', start: 'int | None' = None, num: 'int | None' = None) -> 'list[bytes | str] | Awaitable[list[bytes | str]]'
     |      Return the lexicographical range of values from sorted set ``name``
     |      between ``min`` and ``max``.
     |
     |      If ``start`` and ``num`` are specified, then return a slice of the
     |      range.
     |
     |      For more information, see https://redis.io/commands/zrangebylex
     |
     |  zrangebyscore(self, name: 'KeyT', min: 'ZScoreBoundT', max: 'ZScoreBoundT', start: 'int | None' = None, num: 'int | None' = None, withscores: 'bool' = False, score_cast_func: 'type | Callable' = <class 'float'>) -> 'ZSetRangeResponse | Awaitable[ZSetRangeResponse]'
     |      Return a range of values from the sorted set ``name`` with scores
     |      between ``min`` and ``max``.
     |
     |      If ``start`` and ``num`` are specified, then return a slice
     |      of the range.
     |
     |      ``withscores`` indicates to return the scores along with the values.
     |      The return type is a list of (value, score) pairs
     |
     |      `score_cast_func`` a callable used to cast the score return value
     |
     |      For more information, see https://redis.io/commands/zrangebyscore
     |
     |  zrangestore(self, dest: 'KeyT', name: 'KeyT', start: 'EncodableT', end: 'EncodableT', byscore: 'bool' = False, bylex: 'bool' = False, desc: 'bool' = False, offset: 'int | None' = None, num: 'int | None' = None) -> 'int | Awaitable[int]'
     |      Stores in ``dest`` the result of a range of values from sorted set
     |      ``name`` between ``start`` and ``end`` sorted in ascending order.
     |
     |      ``start`` and ``end`` can be negative, indicating the end of the range.
     |
     |      ``byscore`` when set to True, returns the range of elements from the
     |      sorted set having scores equal or between ``start`` and ``end``.
     |
     |      ``bylex`` when set to True, returns the range of elements from the
     |      sorted set between the ``start`` and ``end`` lexicographical closed
     |      range intervals.
     |      Valid ``start`` and ``end`` must start with ( or [, in order to specify
     |      whether the range interval is exclusive or inclusive, respectively.
     |
     |      ``desc`` a boolean indicating whether to sort the results in reversed
     |      order.
     |
     |      ``offset`` and ``num`` are specified, then return a slice of the range.
     |      Can't be provided when using ``bylex``.
     |
     |      For more information, see https://redis.io/commands/zrangestore
     |
     |  zrank(self, name: 'KeyT', value: 'EncodableT', withscore: 'bool' = False, score_cast_func: 'type | Callable' = <class 'float'>) -> 'int | list[Any] | None | Awaitable[int | list[Any] | None]'
     |      Returns a 0-based value indicating the rank of ``value`` in sorted set
     |      ``name``.
     |      The optional WITHSCORE argument supplements the command's
     |      reply with the score of the element returned.
     |
     |      ``score_cast_func`` a callable used to cast the score return value
     |
     |      For more information, see https://redis.io/commands/zrank
     |
     |  zrem(self, name: 'KeyT', *values: 'FieldT') -> 'int | Awaitable[int]'
     |      Remove member ``values`` from sorted set ``name``
     |
     |      For more information, see https://redis.io/commands/zrem
     |
     |  zremrangebylex(self, name: 'KeyT', min: 'EncodableT', max: 'EncodableT') -> 'int | Awaitable[int]'
     |      Remove all elements in the sorted set ``name`` between the
     |      lexicographical range specified by ``min`` and ``max``.
     |
     |      Returns the number of elements removed.
     |
     |      For more information, see https://redis.io/commands/zremrangebylex
     |
     |  zremrangebyrank(self, name: 'KeyT', min: 'int', max: 'int') -> 'int | Awaitable[int]'
     |      Remove all elements in the sorted set ``name`` with ranks between
     |      ``min`` and ``max``. Values are 0-based, ordered from smallest score
     |      to largest. Values can be negative indicating the highest scores.
     |      Returns the number of elements removed
     |
     |      For more information, see https://redis.io/commands/zremrangebyrank
     |
     |  zremrangebyscore(self, name: 'KeyT', min: 'ZScoreBoundT', max: 'ZScoreBoundT') -> 'int | Awaitable[int]'
     |      Remove all elements in the sorted set ``name`` with scores
     |      between ``min`` and ``max``. Returns the number of elements removed.
     |
     |      For more information, see https://redis.io/commands/zremrangebyscore
     |
     |  zrevrange(self, name: 'KeyT', start: 'int', end: 'int', withscores: 'bool' = False, score_cast_func: 'type | Callable' = <class 'float'>) -> 'ZSetRangeResponse | Awaitable[ZSetRangeResponse]'
     |      Return a range of values from sorted set ``name`` between
     |      ``start`` and ``end`` sorted in descending order.
     |
     |      ``start`` and ``end`` can be negative, indicating the end of the range.
     |
     |      ``withscores`` indicates to return the scores along with the values
     |      The return type is a list of (value, score) pairs
     |
     |      ``score_cast_func`` a callable used to cast the score return value
     |
     |      For more information, see https://redis.io/commands/zrevrange
     |
     |  zrevrangebylex(self, name: 'KeyT', max: 'EncodableT', min: 'EncodableT', start: 'int | None' = None, num: 'int | None' = None) -> 'list[bytes | str] | Awaitable[list[bytes | str]]'
     |      Return the reversed lexicographical range of values from sorted set
     |      ``name`` between ``max`` and ``min``.
     |
     |      If ``start`` and ``num`` are specified, then return a slice of the
     |      range.
     |
     |      For more information, see https://redis.io/commands/zrevrangebylex
     |
     |  zrevrangebyscore(self, name: 'KeyT', max: 'ZScoreBoundT', min: 'ZScoreBoundT', start: 'int | None' = None, num: 'int | None' = None, withscores: 'bool' = False, score_cast_func: 'type | Callable' = <class 'float'>) -> 'ZSetRangeResponse | Awaitable[ZSetRangeResponse]'
     |      Return a range of values from the sorted set ``name`` with scores
     |      between ``min`` and ``max`` in descending order.
     |
     |      If ``start`` and ``num`` are specified, then return a slice
     |      of the range.
     |
     |      ``withscores`` indicates to return the scores along with the values.
     |      The return type is a list of (value, score) pairs
     |
     |      ``score_cast_func`` a callable used to cast the score return value
     |
     |      For more information, see https://redis.io/commands/zrevrangebyscore
     |
     |  zrevrank(self, name: 'KeyT', value: 'EncodableT', withscore: 'bool' = False, score_cast_func: 'type | Callable' = <class 'float'>) -> 'int | list[Any] | None | Awaitable[int | list[Any] | None]'
     |      Returns a 0-based value indicating the descending rank of
     |      ``value`` in sorted set ``name``.
     |      The optional ``withscore`` argument supplements the command's
     |      reply with the score of the element returned.
     |
     |      ``score_cast_func`` a callable used to cast the score return value
     |
     |      For more information, see https://redis.io/commands/zrevrank
     |
     |  zscore(self, name: 'KeyT', value: 'EncodableT') -> 'float | None | Awaitable[float | None]'
     |      Return the score of element ``value`` in sorted set ``name``
     |
     |      For more information, see https://redis.io/commands/zscore
     |
     |  zunion(self, keys: 'Sequence[KeyT] | Mapping[AnyKeyT, float]', aggregate: 'str | None' = None, withscores: 'bool' = False, score_cast_func: 'type | Callable' = <class 'float'>) -> 'ZSetRangeResponse | Awaitable[ZSetRangeResponse]'
     |      Return the union of multiple sorted sets specified by ``keys``.
     |      ``keys`` can be provided as dictionary of keys and their weights.
     |      Scores will be aggregated based on the ``aggregate``, or SUM if
     |      none is provided.
     |
     |      Available aggregation modes:
     |
     |      - ``SUM`` (default): the score of an element is summed across the
     |        inputs where it exists.
     |        Score = SUM(score₁×weight₁, score₂×weight₂, ...)
     |      - ``MIN``: the resulting set will contain the minimum score of an
     |        element across the inputs where it exists.
     |        Score = MIN(score₁×weight₁, score₂×weight₂, ...)
     |      - ``MAX``: the resulting set will contain the maximum score of an
     |        element across the inputs where it exists.
     |        Score = MAX(score₁×weight₁, score₂×weight₂, ...)
     |      - ``COUNT``: ignores the original scores and counts weighted set
     |        membership. Each element's score is the sum of the weights of
     |        the input sets that contain it.
     |        Score = SUM(weight₁, weight₂, ...) for sets containing the element.
     |        When all weights are 1 (default), the score equals the number
     |        of input sets containing the element.
     |
     |      ``score_cast_func`` a callable used to cast the score return value
     |
     |      For more information, see https://redis.io/commands/zunion
     |
     |  zunionstore(self, dest: 'KeyT', keys: 'Sequence[KeyT] | Mapping[AnyKeyT, float]', aggregate: 'str | None' = None) -> 'int | Awaitable[int]'
     |      Union multiple sorted sets specified by ``keys`` into
     |      a new sorted set, ``dest``. Scores in the destination will be
     |      aggregated based on the ``aggregate``, or SUM if none is provided.
     |
     |      Available aggregation modes:
     |
     |      - ``SUM`` (default): the score of an element is summed across the
     |        inputs where it exists.
     |        Score = SUM(score₁×weight₁, score₂×weight₂, ...)
     |      - ``MIN``: the resulting set will contain the minimum score of an
     |        element across the inputs where it exists.
     |        Score = MIN(score₁×weight₁, score₂×weight₂, ...)
     |      - ``MAX``: the resulting set will contain the maximum score of an
     |        element across the inputs where it exists.
     |        Score = MAX(score₁×weight₁, score₂×weight₂, ...)
     |      - ``COUNT``: ignores the original scores and counts weighted set
     |        membership. Each element's score is the sum of the weights of
     |        the input sets that contain it.
     |        Score = SUM(weight₁, weight₂, ...) for sets containing the element.
     |        When all weights are 1 (default), the score equals the number
     |        of input sets containing the element.
     |
     |      For more information, see https://redis.io/commands/zunionstore
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from redis.commands.core.AsyncManagementCommands:
     |
     |  async command_info(self, **kwargs) -> 'None'
     |
     |  async debug_segfault(self, **kwargs) -> 'None'
     |
     |  async memory_doctor(self, **kwargs) -> 'None'
     |
     |  async memory_help(self, **kwargs) -> 'None'
     |
     |  async shutdown(self, save: 'bool' = False, nosave: 'bool' = False, now: 'bool' = False, force: 'bool' = False, abort: 'bool' = False, **kwargs) -> 'None'
     |      Shutdown the Redis server.  If Redis has persistence configured,
     |      data will be flushed before shutdown.  If the "save" option is set,
     |      a data flush will be attempted even if there is no persistence
     |      configured.  If the "nosave" option is set, no data flush will be
     |      attempted.  The "save" and "nosave" options cannot both be set.
     |
     |      For more information, see https://redis.io/commands/shutdown
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from redis.commands.core.ManagementCommands:
     |
     |  auth(self, password: 'str', username: 'str | None' = None, **kwargs) -> 'bool | Awaitable[bool]'
     |      Authenticates the user. If you do not pass username, Redis will try to
     |      authenticate for the "default" user. If you do pass username, it will
     |      authenticate for the given user.
     |      For more information, see https://redis.io/commands/auth
     |
     |  bgrewriteaof(self, **kwargs) -> 'bool | bytes | str | Awaitable[bool | bytes | str]'
     |      Tell the Redis server to rewrite the AOF file from data in memory.
     |
     |      For more information, see https://redis.io/commands/bgrewriteaof
     |
     |  bgsave(self, schedule: 'bool' = True, **kwargs) -> 'bool | bytes | str | Awaitable[bool | bytes | str]'
     |      Tell the Redis server to save its data to disk.  Unlike save(),
     |      this method is asynchronous and returns immediately.
     |
     |      For more information, see https://redis.io/commands/bgsave
     |
     |  client_getname(self, **kwargs) -> 'bytes | str | None | Awaitable[bytes | str | None]'
     |      Returns the current connection name
     |
     |      For more information, see https://redis.io/commands/client-getname
     |
     |  client_getredir(self, **kwargs) -> 'int | Awaitable[int]'
     |      Returns the ID (an integer) of the client to whom we are
     |      redirecting tracking notifications.
     |
     |      see: https://redis.io/commands/client-getredir
     |
     |  client_id(self, **kwargs) -> 'int | Awaitable[int]'
     |      Returns the current connection id
     |
     |      For more information, see https://redis.io/commands/client-id
     |
     |  client_info(self, **kwargs) -> 'dict[str, str | int] | Awaitable[dict[str, str | int]]'
     |      Returns information and statistics about the current
     |      client connection.
     |
     |      For more information, see https://redis.io/commands/client-info
     |
     |  client_kill(self, address: 'str', **kwargs) -> 'bool | int | Awaitable[bool | int]'
     |      Disconnects the client at ``address`` (ip:port)
     |
     |      For more information, see https://redis.io/commands/client-kill
     |
     |  client_kill_filter(self, _id: 'str | None' = None, _type: 'str | None' = None, addr: 'str | None' = None, skipme: 'bool | None' = None, laddr: 'bool | None' = None, user: 'str | None' = None, maxage: 'int | None' = None, **kwargs) -> 'int | Awaitable[int]'
     |      Disconnects client(s) using a variety of filter options
     |      :param _id: Kills a client by its unique ID field
     |      :param _type: Kills a client by type where type is one of 'normal',
     |      'master', 'slave', 'replica' or 'pubsub'
     |      :param addr: Kills a client by its 'address:port'
     |      :param skipme: If True, then the client calling the command
     |      will not get killed even if it is identified by one of the filter
     |      options. If skipme is not provided, the server defaults to skipme=True
     |      :param laddr: Kills a client by its 'local (bind) address:port'
     |      :param user: Kills a client for a specific user name
     |      :param maxage: Kills clients that are older than the specified age in seconds
     |
     |  client_list(self, _type: 'str | None' = None, client_id: 'List[EncodableT]' = [], **kwargs) -> 'list[dict[str, str]] | Awaitable[list[dict[str, str]]]'
     |      Returns a list of currently connected clients.
     |      If type of client specified, only that type will be returned.
     |
     |      :param _type: optional. one of the client types (normal, master,
     |       replica, pubsub)
     |      :param client_id: optional. a list of client ids
     |
     |      For more information, see https://redis.io/commands/client-list
     |
     |  client_no_evict(self, mode: 'str') -> 'bytes | str | Awaitable[bytes | str]'
     |      Sets the client eviction mode for the current connection.
     |
     |      For more information, see https://redis.io/commands/client-no-evict
     |
     |  client_no_touch(self, mode: 'str') -> 'bytes | str | Awaitable[bytes | str]'
     |      # The command controls whether commands sent by the client will alter
     |      # the LRU/LFU of the keys they access.
     |      # When turned on, the current client will not change LFU/LRU stats,
     |      # unless it sends the TOUCH command.
     |
     |      For more information, see https://redis.io/commands/client-no-touch
     |
     |  client_pause(self, timeout: 'int', all: 'bool' = True, **kwargs) -> 'bool | Awaitable[bool]'
     |      Suspend all the Redis clients for the specified amount of time.
     |
     |
     |      For more information, see https://redis.io/commands/client-pause
     |
     |      Args:
     |          timeout: milliseconds to pause clients
     |          all: If true (default) all client commands are blocked.
     |               otherwise, clients are only blocked if they attempt to execute
     |               a write command.
     |
     |      For the WRITE mode, some commands have special behavior:
     |
     |      * EVAL/EVALSHA: Will block client for all scripts.
     |      * PUBLISH: Will block client.
     |      * PFCOUNT: Will block client.
     |      * WAIT: Acknowledgments will be delayed, so this command will
     |          appear blocked.
     |
     |  client_reply(self, reply: "Literal['ON', 'OFF', 'SKIP']", **kwargs) -> 'bytes | str | Awaitable[bytes | str]'
     |      Enable and disable redis server replies.
     |
     |      ``reply`` Must be ON OFF or SKIP,
     |      ON - The default most with server replies to commands
     |      OFF - Disable server responses to commands
     |      SKIP - Skip the response of the immediately following command.
     |
     |      Note: When setting OFF or SKIP replies, you will need a client object
     |      with a timeout specified in seconds, and will need to catch the
     |      TimeoutError.
     |      The test_client_reply unit test illustrates this, and
     |      conftest.py has a client with a timeout.
     |
     |      See https://redis.io/commands/client-reply
     |
     |  client_setinfo(self, attr: 'str', value: 'str', **kwargs) -> 'bool | Awaitable[bool]'
     |      Sets the current connection library name or version
     |      For more information see https://redis.io/commands/client-setinfo
     |
     |  client_setname(self, name: 'str', **kwargs) -> 'bool | Awaitable[bool]'
     |      Sets the current connection name
     |
     |      For more information, see https://redis.io/commands/client-setname
     |
     |      .. note::
     |         This method sets client name only for **current** connection.
     |
     |         If you want to set a common name for all connections managed
     |         by this client, use ``client_name`` constructor argument.
     |
     |  client_tracking(self, on: 'bool' = True, clientid: 'int | None' = None, prefix: 'Sequence[KeyT]' = [], bcast: 'bool' = False, optin: 'bool' = False, optout: 'bool' = False, noloop: 'bool' = False, **kwargs) -> 'bytes | str | Awaitable[bytes | str]'
     |      Enables the tracking feature of the Redis server, that is used
     |      for server assisted client side caching.
     |
     |      ``on`` indicate for tracking on or tracking off. The default is on.
     |
     |      ``clientid`` send invalidation messages to the connection with
     |      the specified ID.
     |
     |      ``bcast`` enable tracking in broadcasting mode. In this mode
     |      invalidation messages are reported for all the prefixes
     |      specified, regardless of the keys requested by the connection.
     |
     |      ``optin``  when broadcasting is NOT active, normally don't track
     |      keys in read only commands, unless they are called immediately
     |      after a CLIENT CACHING yes command.
     |
     |      ``optout`` when broadcasting is NOT active, normally track keys in
     |      read only commands, unless they are called immediately after a
     |      CLIENT CACHING no command.
     |
     |      ``noloop`` don't send notifications about keys modified by this
     |      connection itself.
     |
     |      ``prefix``  for broadcasting, register a given key prefix, so that
     |      notifications will be provided only for keys starting with this string.
     |
     |      See https://redis.io/commands/client-tracking
     |
     |  client_tracking_off(self, clientid: 'int | None' = None, prefix: 'Sequence[KeyT]' = [], bcast: 'bool' = False, optin: 'bool' = False, optout: 'bool' = False, noloop: 'bool' = False) -> 'bytes | str | Awaitable[bytes | str]'
     |      Turn off the tracking mode.
     |      For more information, about the options look at client_tracking func.
     |
     |      See https://redis.io/commands/client-tracking
     |
     |  client_tracking_on(self, clientid: 'int | None' = None, prefix: 'Sequence[KeyT]' = [], bcast: 'bool' = False, optin: 'bool' = False, optout: 'bool' = False, noloop: 'bool' = False) -> 'bytes | str | Awaitable[bytes | str]'
     |      Turn on the tracking mode.
     |      For more information, about the options look at client_tracking func.
     |
     |      See https://redis.io/commands/client-tracking
     |
     |  client_trackinginfo(self, **kwargs) -> 'ClientTrackingInfoResponse | Awaitable[ClientTrackingInfoResponse]'
     |      Returns the information about the current client connection's
     |      use of the server assisted client side cache.
     |
     |      See https://redis.io/commands/client-trackinginfo
     |
     |  client_unblock(self, client_id: 'int', error: 'bool' = False, **kwargs) -> 'bool | Awaitable[bool]'
     |      Unblocks a connection by its client id.
     |      If ``error`` is True, unblocks the client with a special error message.
     |      If ``error`` is False (default), the client is unblocked using the
     |      regular timeout mechanism.
     |
     |      For more information, see https://redis.io/commands/client-unblock
     |
     |  client_unpause(self, **kwargs) -> 'bytes | str | Awaitable[bytes | str]'
     |      Unpause all redis clients
     |
     |      For more information, see https://redis.io/commands/client-unpause
     |
     |  command(self, **kwargs) -> 'dict[str, dict[str, Any]] | Awaitable[dict[str, dict[str, Any]]]'
     |      Returns dict reply of details about all Redis commands.
     |
     |      For more information, see https://redis.io/commands/command
     |
     |  command_count(self, **kwargs) -> 'int | Awaitable[int]'
     |
     |  command_docs(self, *args)
     |      This function throws a NotImplementedError since it is intentionally
     |      not supported.
     |
     |  command_getkeysandflags(self, *args: 'str') -> 'CommandGetKeysAndFlagsResponse | Awaitable[CommandGetKeysAndFlagsResponse]'
     |      Returns array of keys from a full Redis command and their usage flags.
     |
     |      For more information, see https://redis.io/commands/command-getkeysandflags
     |
     |  command_list(self, module: 'str | None' = None, category: 'str | None' = None, pattern: 'str | None' = None) -> 'list[bytes | str] | Awaitable[list[bytes | str]]'
     |      Return an array of the server's command names.
     |      You can use one of the following filters:
     |      ``module``: get the commands that belong to the module
     |      ``category``: get the commands in the ACL category
     |      ``pattern``: get the commands that match the given pattern
     |
     |      For more information, see https://redis.io/commands/command-list/
     |
     |  config_get(self, pattern: 'PatternT' = '*', *args: 'PatternT', **kwargs) -> 'dict[str | None, str | None] | Awaitable[dict[str | None, str | None]]'
     |      Return a dictionary of configuration based on the ``pattern``
     |
     |      For more information, see https://redis.io/commands/config-get
     |
     |  config_resetstat(self, **kwargs) -> 'bool | Awaitable[bool]'
     |      Reset runtime statistics
     |
     |      For more information, see https://redis.io/commands/config-resetstat
     |
     |  config_rewrite(self, **kwargs) -> 'bytes | str | Awaitable[bytes | str]'
     |      Rewrite config file with the minimal change to reflect running config.
     |
     |      For more information, see https://redis.io/commands/config-rewrite
     |
     |  config_set(self, name: 'KeyT', value: 'EncodableT', *args: 'Union[KeyT, EncodableT]', **kwargs) -> 'bool | Awaitable[bool]'
     |      Set config item ``name`` with ``value``
     |
     |      For more information, see https://redis.io/commands/config-set
     |
     |  dbsize(self, **kwargs) -> 'int | Awaitable[int]'
     |      Returns the number of keys in the current database
     |
     |      For more information, see https://redis.io/commands/dbsize
     |
     |  debug_object(self, key: 'KeyT', **kwargs) -> 'dict[str, str | int] | bytes | str | Awaitable[dict[str, str | int] | bytes | str]'
     |      Returns version specific meta information about a given key
     |
     |      For more information, see https://redis.io/commands/debug-object
     |
     |  echo(self, value: 'EncodableT', **kwargs) -> 'bytes | str | Awaitable[bytes | str]'
     |      Echo the string back from the server
     |
     |      For more information, see https://redis.io/commands/echo
     |
     |  failover(self)
     |      This function throws a NotImplementedError since it is intentionally
     |      not supported.
     |
     |  flushall(self, asynchronous: 'bool' = False, **kwargs) -> 'bool | Awaitable[bool]'
     |      Delete all keys in all databases on the current host.
     |
     |      ``asynchronous`` indicates whether the operation is
     |      executed asynchronously by the server.
     |
     |      For more information, see https://redis.io/commands/flushall
     |
     |  flushdb(self, asynchronous: 'bool' = False, **kwargs) -> 'bool | Awaitable[bool]'
     |      Delete all keys in the current database.
     |
     |      ``asynchronous`` indicates whether the operation is
     |      executed asynchronously by the server.
     |
     |      For more information, see https://redis.io/commands/flushdb
     |
     |  hello(self)
     |      This function throws a NotImplementedError since it is intentionally
     |      not supported.
     |
     |  hotkeys_get(self, **kwargs) -> 'Union[Awaitable[list[dict[str | bytes, Any]]], list[dict[str | bytes, Any]]]'
     |      Retrieve the result of the ongoing collection session (if any),
     |      or the last collection session (if any).
     |
     |      HOTKEYS GET response is wrapped in an array for aggregation support.
     |      Each node returns a single-element array, allowing multiple node
     |      responses to be concatenated by DMC or other aggregators.
     |
     |      For more information, see https://redis.io/commands/hotkeys-get
     |
     |  hotkeys_reset(self, **kwargs) -> 'bytes | str | Awaitable[bytes | str]'
     |      Discard the last hotkeys collection session results (in order to save memory).
     |      Error if there is an ongoing collection session.
     |
     |      For more information, see https://redis.io/commands/hotkeys-reset
     |
     |  hotkeys_start(self, metrics: 'List[HotkeysMetricsTypes]', count: 'int | None' = None, duration: 'int | None' = None, sample_ratio: 'int | None' = None, slots: 'List[int] | None' = None, **kwargs) -> 'bytes | str | Awaitable[bytes | str]'
     |      Start collecting hotkeys data.
     |      Returns an error if there is an ongoing collection session.
     |
     |      Args:
     |          count: The number of keys to collect in each criteria (CPU and network consumption)
     |          metrics: List of metrics to track. Supported values: [HotkeysMetricsTypes.CPU, HotkeysMetricsTypes.NET]
     |          duration: Automatically stop the collection after `duration` seconds
     |          sample_ratio: Commands are sampled with probability 1/ratio (1 means no sampling)
     |          slots: Only track keys on the specified hash slots
     |
     |      For more information, see https://redis.io/commands/hotkeys-start
     |
     |  hotkeys_stop(self, **kwargs) -> 'bytes | str | Awaitable[bytes | str]'
     |      Stop the ongoing hotkeys collection session (if any).
     |      The results of the last collection session are kept for consumption with HOTKEYS GET.
     |
     |      For more information, see https://redis.io/commands/hotkeys-stop
     |
     |  info(self, section: 'Optional[str]' = None, *args: 'str', **kwargs) -> 'dict[str, Any] | Awaitable[dict[str, Any]]'
     |      Returns a dictionary containing information about the Redis server
     |
     |      The ``section`` option can be used to select a specific section
     |      of information
     |
     |      The section option is not supported by older versions of Redis Server,
     |      and will generate ResponseError
     |
     |      For more information, see https://redis.io/commands/info
     |
     |  lastsave(self, **kwargs) -> 'datetime.datetime | Awaitable[datetime.datetime]'
     |      Return a Python datetime object representing the last time the
     |      Redis database was saved to disk
     |
     |      For more information, see https://redis.io/commands/lastsave
     |
     |  latency_doctor(self)
     |      Raise a NotImplementedError, as the client will not support LATENCY DOCTOR.
     |      This function is best used within the redis-cli.
     |
     |      For more information, see https://redis.io/commands/latency-doctor
     |
     |  latency_graph(self)
     |      Raise a NotImplementedError, as the client will not support LATENCY GRAPH.
     |      This function is best used within the redis-cli.
     |
     |      For more information, see https://redis.io/commands/latency-graph.
     |
     |  latency_histogram(self, *args)
     |      This function throws a NotImplementedError since it is intentionally
     |      not supported.
     |
     |  latency_history(self, event: 'str') -> 'list[list[int]] | Awaitable[list[list[int]]]'
     |      Returns the raw data of the ``event``'s latency spikes time series.
     |
     |      For more information, see https://redis.io/commands/latency-history
     |
     |  latency_latest(self) -> 'list[list[bytes | str | int]] | Awaitable[list[list[bytes | str | int]]]'
     |      Reports the latest latency events logged.
     |
     |      For more information, see https://redis.io/commands/latency-latest
     |
     |  latency_reset(self, *events: 'str') -> 'int | Awaitable[int]'
     |      Resets the latency spikes time series of all, or only some, events.
     |
     |      For more information, see https://redis.io/commands/latency-reset
     |
     |  lolwut(self, *version_numbers: 'Union[str, float]', **kwargs) -> 'bytes | str | Awaitable[bytes | str]'
     |      Get the Redis version and a piece of generative computer art
     |
     |      See: https://redis.io/commands/lolwut
     |
     |  memory_malloc_stats(self, **kwargs) -> 'bytes | str | Awaitable[bytes | str]'
     |      Return an internal statistics report from the memory allocator.
     |
     |      See: https://redis.io/commands/memory-malloc-stats
     |
     |  memory_purge(self, **kwargs) -> 'bool | Awaitable[bool]'
     |      Attempts to purge dirty pages for reclamation by allocator
     |
     |      For more information, see https://redis.io/commands/memory-purge
     |
     |  memory_stats(self, **kwargs) -> 'dict[str, Any] | Awaitable[dict[str, Any]]'
     |      Return a dictionary of memory stats
     |
     |      For more information, see https://redis.io/commands/memory-stats
     |
     |  memory_usage(self, key: 'KeyT', samples: 'int | None' = None, **kwargs) -> 'int | None | Awaitable[int | None]'
     |      Return the total memory usage for key, its value and associated
     |      administrative overheads.
     |
     |      For nested data structures, ``samples`` is the number of elements to
     |      sample. If left unspecified, the server's default is 5. Use 0 to sample
     |      all elements.
     |
     |      For more information, see https://redis.io/commands/memory-usage
     |
     |  migrate(self, host: 'str', port: 'int', keys: 'KeysT', destination_db: 'int', timeout: 'int', copy: 'bool' = False, replace: 'bool' = False, auth: 'str | None' = None, **kwargs) -> 'bytes | str | Awaitable[bytes | str]'
     |      Migrate 1 or more keys from the current Redis server to a different
     |      server specified by the ``host``, ``port`` and ``destination_db``.
     |
     |      The ``timeout``, specified in milliseconds, indicates the maximum
     |      time the connection between the two servers can be idle before the
     |      command is interrupted.
     |
     |      If ``copy`` is True, the specified ``keys`` are NOT deleted from
     |      the source server.
     |
     |      If ``replace`` is True, this operation will overwrite the keys
     |      on the destination server if they exist.
     |
     |      If ``auth`` is specified, authenticate to the destination server with
     |      the password provided.
     |
     |      For more information, see https://redis.io/commands/migrate
     |
     |  object(self, infotype: 'str', key: 'KeyT', **kwargs) -> 'Any | Awaitable[Any]'
     |      Return the encoding, idletime, or refcount about the key
     |
     |  ping(self, **kwargs) -> 'Union[Awaitable[bool], bool]'
     |      Ping the Redis server to test connectivity.
     |
     |      Sends a PING command to the Redis server and returns True if the server
     |      responds with "PONG".
     |
     |      This command is useful for:
     |      - Testing whether a connection is still alive
     |      - Verifying the server's ability to serve data
     |
     |      For more information on the underlying ping command see https://redis.io/commands/ping
     |
     |  psync(self, replicationid: 'str', offset: 'int') -> 'bytes | Awaitable[bytes]'
     |      Initiates a replication stream from the master.
     |      Newer version for `sync`.
     |
     |      For more information, see https://redis.io/commands/sync
     |
     |  quit(self, **kwargs) -> 'bool | Awaitable[bool]'
     |      Ask the server to close the connection.
     |
     |      For more information, see https://redis.io/commands/quit
     |
     |  replicaof(self, *args, **kwargs) -> 'bytes | str | Awaitable[bytes | str]'
     |      Update the replication settings of a redis replica, on the fly.
     |
     |      Examples of valid arguments include:
     |
     |      NO ONE (set no replication)
     |      host port (set to the host and port of a redis server)
     |
     |      For more information, see  https://redis.io/commands/replicaof
     |
     |  reset(self) -> 'bytes | str | Awaitable[bytes | str]'
     |      Perform a full reset on the connection's server-side context.
     |
     |      See: https://redis.io/commands/reset
     |
     |  role(self) -> 'list[Any] | Awaitable[list[Any]]'
     |      Provide information on the role of a Redis instance in
     |      the context of replication, by returning if the instance
     |      is currently a master, slave, or sentinel.
     |
     |      For more information, see https://redis.io/commands/role
     |
     |  save(self, **kwargs) -> 'bool | Awaitable[bool]'
     |      Tell the Redis server to save its data to disk,
     |      blocking until the save is complete
     |
     |      For more information, see https://redis.io/commands/save
     |
     |  select(self, index: 'int', **kwargs) -> 'bool | Awaitable[bool]'
     |      Select the Redis logical database at index.
     |
     |      See: https://redis.io/commands/select
     |
     |  slaveof(self, host: 'str | None' = None, port: 'int | None' = None, **kwargs) -> 'bool | Awaitable[bool]'
     |      Set the server to be a replicated slave of the instance identified
     |      by the ``host`` and ``port``. If called without arguments, the
     |      instance is promoted to a master instead.
     |
     |      For more information, see https://redis.io/commands/slaveof
     |
     |  slowlog_get(self, num: 'int | None' = None, **kwargs) -> 'list[dict[str, Any]] | Awaitable[list[dict[str, Any]]]'
     |      Get the entries from the slowlog. If ``num`` is specified, get the
     |      most recent ``num`` items.
     |
     |      For more information, see https://redis.io/commands/slowlog-get
     |
     |  slowlog_len(self, **kwargs) -> 'int | Awaitable[int]'
     |      Get the number of items in the slowlog
     |
     |      For more information, see https://redis.io/commands/slowlog-len
     |
     |  slowlog_reset(self, **kwargs) -> 'bool | Awaitable[bool]'
     |      Remove all items in the slowlog
     |
     |      For more information, see https://redis.io/commands/slowlog-reset
     |
     |  swapdb(self, first: 'int', second: 'int', **kwargs) -> 'bool | Awaitable[bool]'
     |      Swap two databases
     |
     |      For more information, see https://redis.io/commands/swapdb
     |
     |  sync(self) -> 'bytes | Awaitable[bytes]'
     |      Initiates a replication stream from the master.
     |
     |      For more information, see https://redis.io/commands/sync
     |
     |  time(self, **kwargs) -> 'tuple[int, int] | Awaitable[tuple[int, int]]'
     |      Returns the server time as a 2-item tuple of ints:
     |      (seconds since epoch, microseconds into this second).
     |
     |      For more information, see https://redis.io/commands/time
     |
     |  wait(self, num_replicas: 'int', timeout: 'int', **kwargs) -> 'int | Awaitable[int]'
     |      Redis synchronous replication
     |      That returns the number of replicas that processed the query when
     |      we finally have at least ``num_replicas``, or when the ``timeout`` was
     |      reached.
     |
     |      For more information, see https://redis.io/commands/wait
     |
     |  waitaof(self, num_local: 'int', num_replicas: 'int', timeout: 'int', **kwargs) -> 'list[int] | Awaitable[list[int]]'
     |      This command blocks the current client until all previous write
     |      commands by that client are acknowledged as having been fsynced
     |      to the AOF of the local Redis and/or at least the specified number
     |      of replicas.
     |
     |      For more information, see https://redis.io/commands/waitaof
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from redis.commands.core.ModuleCommands:
     |
     |  command_getkeys(self, *args) -> 'list[bytes | str] | Awaitable[list[bytes | str]]'
     |
     |  module_list(self) -> 'list[dict[Any, Any]] | Awaitable[list[dict[Any, Any]]]'
     |      Returns a list of dictionaries containing the name and version of
     |      all loaded modules.
     |
     |      For more information, see https://redis.io/commands/module-list
     |
     |  module_load(self, path, *args) -> 'bool | Awaitable[bool]'
     |      Loads the module from ``path``.
     |      Passes all ``*args`` to the module, during loading.
     |      Raises ``ModuleError`` if a module is not found at ``path``.
     |
     |      For more information, see https://redis.io/commands/module-load
     |
     |  module_loadex(self, path: 'str', options: 'List[str] | None' = None, args: 'List[str] | None' = None) -> 'bytes | str | Awaitable[bytes | str]'
     |      Loads a module from a dynamic library at runtime with configuration directives.
     |
     |      For more information, see https://redis.io/commands/module-loadex
     |
     |  module_unload(self, name) -> 'bool | Awaitable[bool]'
     |      Unloads the module ``name``.
     |      Raises ``ModuleError`` if ``name`` is not in loaded modules.
     |
     |      For more information, see https://redis.io/commands/module-unload
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from redis.commands.core.PubSubCommands:
     |
     |  publish(self, channel: 'ChannelT', message: 'EncodableT', **kwargs) -> 'int | Awaitable[int]'
     |      Publish ``message`` on ``channel``.
     |      Returns the number of subscribers the message was delivered to.
     |
     |      For more information, see https://redis.io/commands/publish
     |
     |  pubsub_channels(self, pattern: 'PatternT' = '*', **kwargs) -> 'list[bytes | str] | Awaitable[list[bytes | str]]'
     |      Return a list of channels that have at least one subscriber
     |
     |      For more information, see https://redis.io/commands/pubsub-channels
     |
     |  pubsub_numpat(self, **kwargs) -> 'int | Awaitable[int]'
     |      Returns the number of subscriptions to patterns
     |
     |      For more information, see https://redis.io/commands/pubsub-numpat
     |
     |  pubsub_numsub(self, *args: 'ChannelT', **kwargs) -> 'list[tuple[bytes | str, int]] | Awaitable[list[tuple[bytes | str, int]]]'
     |      Return a list of (channel, number of subscribers) tuples
     |      for each channel given in ``*args``
     |
     |      For more information, see https://redis.io/commands/pubsub-numsub
     |
     |  pubsub_shardchannels(self, pattern: 'PatternT' = '*', **kwargs) -> 'list[bytes | str] | Awaitable[list[bytes | str]]'
     |      Return a list of shard_channels that have at least one subscriber
     |
     |      For more information, see https://redis.io/commands/pubsub-shardchannels
     |
     |  pubsub_shardnumsub(self, *args: 'ChannelT', **kwargs) -> 'list[tuple[bytes | str, int]] | Awaitable[list[tuple[bytes | str, int]]]'
     |      Return a list of (shard_channel, number of subscribers) tuples
     |      for each channel given in ``*args``
     |
     |      For more information, see https://redis.io/commands/pubsub-shardnumsub
     |
     |  spublish(self, shard_channel: 'ChannelT', message: 'EncodableT') -> 'int | Awaitable[int]'
     |      Posts a message to the given shard channel.
     |      Returns the number of clients that received the message
     |
     |      For more information, see https://redis.io/commands/spublish
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from redis.commands.core.AsyncScriptCommands:
     |
     |  register_script(self: "Union['redis.asyncio.client.Redis', 'redis.asyncio.cluster.RedisCluster']", script: 'ScriptTextT') -> 'AsyncScript'
     |      Register a Lua ``script`` specifying the ``keys`` it will touch.
     |      Returns a Script object that is callable and hides the complexity of
     |      deal with scripts, keys, and shas. This is the preferred way to work
     |      with Lua scripts.
     |
     |  async script_debug(self, *args) -> 'None'
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from redis.commands.core.ScriptCommands:
     |
     |  eval(self, script: 'str', numkeys: 'int', *keys_and_args: 'KeyT | EncodableT') -> 'Any | Awaitable[Any]'
     |      Execute the Lua ``script``, specifying the ``numkeys`` the script
     |      will touch and the key names and argument values in ``keys_and_args``.
     |      Returns the result of the script.
     |
     |      In practice, use the object returned by ``register_script``. This
     |      function exists purely for Redis API completion.
     |
     |      For more information, see  https://redis.io/commands/eval
     |
     |  eval_ro(self, script: 'str', numkeys: 'int', *keys_and_args: 'KeyT | EncodableT') -> 'Any | Awaitable[Any]'
     |      The read-only variant of the EVAL command
     |
     |      Execute the read-only Lua ``script`` specifying the ``numkeys`` the script
     |      will touch and the key names and argument values in ``keys_and_args``.
     |      Returns the result of the script.
     |
     |      For more information, see  https://redis.io/commands/eval_ro
     |
     |  evalsha(self, sha: 'str', numkeys: 'int', *keys_and_args: 'KeyT | EncodableT') -> 'Any | Awaitable[Any]'
     |      Use the ``sha`` to execute a Lua script already registered via EVAL
     |      or SCRIPT LOAD. Specify the ``numkeys`` the script will touch and the
     |      key names and argument values in ``keys_and_args``. Returns the result
     |      of the script.
     |
     |      In practice, use the object returned by ``register_script``. This
     |      function exists purely for Redis API completion.
     |
     |      For more information, see  https://redis.io/commands/evalsha
     |
     |  evalsha_ro(self, sha: 'str', numkeys: 'int', *keys_and_args: 'KeyT | EncodableT') -> 'Any | Awaitable[Any]'
     |      The read-only variant of the EVALSHA command
     |
     |      Use the ``sha`` to execute a read-only Lua script already registered via EVAL
     |      or SCRIPT LOAD. Specify the ``numkeys`` the script will touch and the
     |      key names and argument values in ``keys_and_args``. Returns the result
     |      of the script.
     |
     |      For more information, see  https://redis.io/commands/evalsha_ro
     |
     |  script_exists(self, *args: 'str') -> 'list[bool] | Awaitable[list[bool]]'
     |      Check if a script exists in the script cache by specifying the SHAs of
     |      each script as ``args``. Returns a list of boolean values indicating if
     |      if each already script exists in the cache_data.
     |
     |      For more information, see  https://redis.io/commands/script-exists
     |
     |  script_flush(self, sync_type: "Literal['SYNC'] | Literal['ASYNC'] | None" = None) -> 'bool | Awaitable[bool]'
     |      Flush all scripts from the script cache_data.
     |
     |      ``sync_type`` is by default SYNC (synchronous) but it can also be
     |                    ASYNC.
     |
     |      For more information, see  https://redis.io/commands/script-flush
     |
     |  script_kill(self) -> 'bool | Awaitable[bool]'
     |      Kill the currently executing Lua script
     |
     |      For more information, see https://redis.io/commands/script-kill
     |
     |  script_load(self, script: 'ScriptTextT') -> 'str | Awaitable[str]'
     |      Load a Lua ``script`` into the script cache_data. Returns the SHA.
     |
     |      For more information, see https://redis.io/commands/script-load
     |
     |  ----------------------------------------------------------------------
     |  Data and other attributes inherited from redis.typing.CommandsProtocol:
     |
     |  __protocol_attrs__ = {'_event_dispatcher', 'execute_command'}
     |
     |  ----------------------------------------------------------------------
     |  Class methods inherited from typing.Protocol:
     |
     |  __init_subclass__(*args, **kwargs)
     |      This method is called when a class is subclassed.
     |
     |      The default implementation does nothing. It may be
     |      overridden to extend subclasses.
     |
     |  ----------------------------------------------------------------------
     |  Class methods inherited from typing.Generic:
     |
     |  __class_getitem__(...)
     |      Parameterizes a generic class.
     |
     |      At least, parameterizing a generic class is the *main* thing this
     |      method does. For example, for some generic class `Foo`, this is called
     |      when we do `Foo[int]` - there, with `cls=Foo` and `params=int`.
     |
     |      However, note that this method is also called when defining generic
     |      classes in the first place with `class Foo[T]: ...`.
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from redis.commands.core.FunctionCommands:
     |
     |  fcall(self, function, numkeys: 'int', *keys_and_args: 'Any') -> 'Any | Awaitable[Any]'
     |      Invoke a function.
     |
     |      For more information, see https://redis.io/commands/fcall
     |
     |  fcall_ro(self, function, numkeys: 'int', *keys_and_args: 'Any') -> 'Any | Awaitable[Any]'
     |      This is a read-only variant of the FCALL command that cannot
     |      execute commands that modify data.
     |
     |      For more information, see https://redis.io/commands/fcall_ro
     |
     |  function_delete(self, library: 'str') -> 'bool | Awaitable[bool]'
     |      Delete the library called ``library`` and all its functions.
     |
     |      For more information, see https://redis.io/commands/function-delete
     |
     |  function_dump(self) -> 'bytes | Awaitable[bytes]'
     |      Return the serialized payload of loaded libraries.
     |
     |      For more information, see https://redis.io/commands/function-dump
     |
     |  function_flush(self, mode: 'str' = 'SYNC') -> 'bool | Awaitable[bool]'
     |      Deletes all the libraries.
     |
     |      For more information, see https://redis.io/commands/function-flush
     |
     |  function_kill(self) -> 'bytes | str | Awaitable[bytes | str]'
     |      Kill a function that is currently executing.
     |
     |      For more information, see https://redis.io/commands/function-kill
     |
     |  function_list(self, library: 'str | None' = '*', withcode: 'bool | None' = False) -> 'list[Any] | Awaitable[list[Any]]'
     |      Return information about the functions and libraries.
     |
     |      Args:
     |
     |          library: specify a pattern for matching library names
     |          withcode: cause the server to include the libraries source implementation
     |              in the reply
     |
     |  function_load(self, code: 'str', replace: 'bool | None' = False) -> 'bytes | str | Awaitable[bytes | str]'
     |      Load a library to Redis.
     |      :param code: the source code (must start with
     |      Shebang statement that provides a metadata about the library)
     |      :param replace: changes the behavior to overwrite the existing library
     |      with the new contents.
     |      Return the library name that was loaded.
     |
     |      For more information, see https://redis.io/commands/function-load
     |
     |  function_restore(self, payload: 'str', policy: 'str | None' = 'APPEND') -> 'bool | Awaitable[bool]'
     |      Restore libraries from the serialized ``payload``.
     |      You can use the optional policy argument to provide a policy
     |      for handling existing libraries.
     |
     |      For more information, see https://redis.io/commands/function-restore
     |
     |  function_stats(self) -> 'Any | Awaitable[Any]'
     |      Return information about the function that's currently running
     |      and information about the available execution engines.
     |
     |      For more information, see https://redis.io/commands/function-stats
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from redis.commands.sentinel.AsyncSentinelCommands:
     |
     |  async sentinel(self, *args) -> None
     |      Redis Sentinel's SENTINEL command.
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from redis.commands.sentinel.SentinelCommands:
     |
     |  sentinel_ckquorum(self, new_master_name) -> Union[bool, Awaitable[bool]]
     |      Check if the current Sentinel configuration is able to reach the
     |      quorum needed to failover a master, and the majority needed to
     |      authorize the failover.
     |
     |      This command should be used in monitoring systems to check if a
     |      Sentinel deployment is ok.
     |
     |  sentinel_failover(self, new_master_name) -> Union[bool, Awaitable[bool]]
     |      Force a failover as if the master was not reachable, and without
     |      asking for agreement to other Sentinels (however a new version of the
     |      configuration will be published so that the other Sentinels will
     |      update their configurations).
     |
     |  sentinel_flushconfig(self) -> Union[bool, Awaitable[bool]]
     |      Force Sentinel to rewrite its configuration on disk, including the
     |      current Sentinel state.
     |
     |      Normally Sentinel rewrites the configuration every time something
     |      changes in its state (in the context of the subset of the state which
     |      is persisted on disk across restart).
     |      However sometimes it is possible that the configuration file is lost
     |      because of operation errors, disk failures, package upgrade scripts or
     |      configuration managers. In those cases a way to to force Sentinel to
     |      rewrite the configuration file is handy.
     |
     |      This command works even if the previous configuration file is
     |      completely missing.
     |
     |  sentinel_get_master_addr_by_name(self, service_name, return_responses: bool = False) -> Union[tuple[bytes | str, int], NoneType, bool, Awaitable[tuple[bytes | str, int] | None | bool]]
     |      Returns a (host, port) pair for the given ``service_name`` when return_responses is True,
     |      otherwise returns a boolean value that indicates if the command was successful.
     |
     |  sentinel_master(self, service_name, return_responses: bool = False) -> Union[dict[str, Any], bool, Awaitable[dict[str, Any] | bool]]
     |      Returns a dictionary containing the specified masters state, when return_responses is True,
     |      otherwise returns a boolean value that indicates if the command was successful.
     |
     |  sentinel_masters(self) -> Union[dict[str, dict[str, Any]], list[dict[str, Any]], Awaitable[dict[str, dict[str, Any]] | list[dict[str, Any]]]]
     |      Returns a list of dictionaries containing each master's state.
     |
     |      Important: This function is called by the Sentinel implementation and is
     |      called directly on the Redis standalone client for sentinels,
     |      so it doesn't support the "once" and "return_responses" options.
     |
     |  sentinel_monitor(self, name, ip, port, quorum) -> Union[bool, Awaitable[bool]]
     |      Add a new master to Sentinel to be monitored
     |
     |  sentinel_remove(self, name) -> Union[bool, Awaitable[bool]]
     |      Remove a master from Sentinel's monitoring
     |
     |  sentinel_reset(self, pattern) -> Union[bool, Awaitable[bool]]
     |      This command will reset all the masters with matching name.
     |      The pattern argument is a glob-style pattern.
     |
     |      The reset process clears any previous state in a master (including a
     |      failover in progress), and removes every slave and sentinel already
     |      discovered and associated with the master.
     |
     |  sentinel_sentinels(self, service_name, return_responses: bool = False) -> Union[list[dict[str, Any]], bool, Awaitable[list[dict[str, Any]] | bool]]
     |      Returns a list of sentinels for ``service_name``, when return_responses is True,
     |      otherwise returns a boolean value that indicates if the command was successful.
     |
     |  sentinel_set(self, name, option, value) -> Union[bool, Awaitable[bool]]
     |      Set Sentinel monitoring parameters for a given master
     |
     |  sentinel_slaves(self, service_name) -> Union[list[dict[str, Any]], Awaitable[list[dict[str, Any]]]]
     |      Returns a list of slaves for ``service_name``
     |
     |      Important: This function is called by the Sentinel implementation and is
     |      called directly on the Redis standalone client for sentinels,
     |      so it doesn't support the "once" and "return_responses" options.

    class RedisCluster(redis.client.AbstractRedis, redis.cluster.AbstractRedisCluster, AsyncMaintNotificationsAbstractRedisCluster, redis.commands.cluster.AsyncRedisClusterCommands)
     |  RedisCluster(host: str | None = None, port: str | int = 6379, startup_nodes: Optional[List[ForwardRef('ClusterNode')]] = None, require_full_coverage: bool = True, read_from_replicas: bool = False, load_balancing_strategy: redis.cluster.LoadBalancingStrategy | None = None, dynamic_startup_nodes: bool = True, reinitialize_steps: int = 5, cluster_error_retry_attempts: int = 10, max_connections: int = 100, retry: redis.asyncio.retry.Retry | None = None, retry_on_error: Optional[List[Type[Exception]]] = None, db: str | int = 0, path: str | None = None, credential_provider: redis.credentials.CredentialProvider | None = None, username: str | None = None, password: str | None = None, client_name: str | None = None, lib_name: str | object | None = <object object at 0x0000017B991493E0>, lib_version: str | object | None = <object object at 0x0000017B991493E0>, driver_info: redis.driver_info.DriverInfo | object | None = <object object at 0x0000017B991493E0>, encoding: str = 'utf-8', encoding_errors: str = 'strict', decode_responses: bool = False, health_check_interval: float = 0, socket_timeout: float | None = 5, socket_connect_timeout: float | None = 5, socket_read_size: int = 32768, socket_keepalive: bool = True, socket_keepalive_options: Union[Mapping[int, int | bytes], object, NoneType] = <object object at 0x0000017B991493E0>, ssl: bool = False, ssl_ca_certs: str | None = None, ssl_ca_data: str | None = None, ssl_cert_reqs: 'str | VerifyMode' = 'required', ssl_include_verify_flags: Optional[List[ForwardRef('VerifyFlags')]] = None, ssl_exclude_verify_flags: Optional[List[ForwardRef('VerifyFlags')]] = None, ssl_certfile: str | None = None, ssl_check_hostname: bool = True, ssl_keyfile: str | None = None, ssl_min_version: 'TLSVersion | None' = None, ssl_ciphers: str | None = None, protocol: int | None = None, legacy_responses: bool = True, address_remap: Optional[Callable[[Tuple[str, int]], Tuple[str, int]]] = None, event_dispatcher: redis.event.EventDispatcher | None = None, policy_resolver: redis.commands.policies.AsyncPolicyResolver = <redis.commands.policies.AsyncStaticPolicyResolver object at 0x0000017B9C771130>, maint_notifications_config: redis.maint_notifications.MaintNotificationsConfig | None = None) -> None
     |
     |  Create a new RedisCluster client.
     |
     |  Pass one of parameters:
     |
     |    - `host` & `port`
     |    - `startup_nodes`
     |
     |  | Use ``await`` :meth:`initialize` to find cluster nodes & create connections.
     |  | Use ``await`` :meth:`close` to disconnect connections & close client.
     |
     |  Many commands support the target_nodes kwarg. It can be one of the
     |  :attr:`NODE_FLAGS`:
     |
     |    - :attr:`PRIMARIES`
     |    - :attr:`REPLICAS`
     |    - :attr:`ALL_NODES`
     |    - :attr:`RANDOM`
     |    - :attr:`DEFAULT_NODE`
     |
     |  Note: This client is not thread/process/fork safe.
     |
     |  :param host:
     |      | Can be used to point to a startup node
     |  :param port:
     |      | Port used if **host** is provided
     |  :param startup_nodes:
     |      | :class:`~.ClusterNode` to used as a startup node
     |  :param require_full_coverage:
     |      | When set to ``False``: the client will not require a full coverage of
     |        the slots. However, if not all slots are covered, and at least one node
     |        has ``cluster-require-full-coverage`` set to ``yes``, the server will throw
     |        a :class:`~.ClusterDownError` for some key-based commands.
     |      | When set to ``True``: all slots must be covered to construct the cluster
     |        client. If not all slots are covered, :class:`~.RedisClusterException` will be
     |        thrown.
     |      | See:
     |        https://redis.io/docs/manual/scaling/#redis-cluster-configuration-parameters
     |  :param read_from_replicas:
     |      | @deprecated - please use load_balancing_strategy instead
     |      | Enable read from replicas in READONLY mode.
     |        When set to true, read commands will be assigned between the primary and
     |        its replications in a Round-Robin manner.
     |        The data read from replicas is eventually consistent with the data in primary nodes.
     |  :param load_balancing_strategy:
     |      | Enable read from replicas in READONLY mode and defines the load balancing
     |        strategy that will be used for cluster node selection.
     |        The data read from replicas is eventually consistent with the data in primary nodes.
     |  :param dynamic_startup_nodes:
     |      | Set the RedisCluster's startup nodes to all the discovered nodes.
     |        If true (default value), the cluster's discovered nodes will be used to
     |        determine the cluster nodes-slots mapping in the next topology refresh.
     |        It will remove the initial passed startup nodes if their endpoints aren't
     |        listed in the CLUSTER SLOTS output.
     |        If you use dynamic DNS endpoints for startup nodes but CLUSTER SLOTS lists
     |        specific IP addresses, it is best to set it to false.
     |  :param reinitialize_steps:
     |      | Specifies the number of MOVED errors that need to occur before reinitializing
     |        the whole cluster topology. If a MOVED error occurs and the cluster does not
     |        need to be reinitialized on this current error handling, only the MOVED slot
     |        will be patched with the redirected node.
     |        To reinitialize the cluster on every MOVED error, set reinitialize_steps to 1.
     |        To avoid reinitializing the cluster on moved errors, set reinitialize_steps to
     |        0.
     |  :param cluster_error_retry_attempts:
     |      | @deprecated - Please configure the 'retry' object instead
     |        In case 'retry' object is set - this argument is ignored!
     |
     |        Number of times to retry before raising an error when :class:`~.TimeoutError`,
     |        :class:`~.ConnectionError`, :class:`~.SlotNotCoveredError`
     |        or :class:`~.ClusterDownError` are encountered
     |  :param retry:
     |      | A retry object that defines the retry strategy and the number of
     |        retries for the cluster client.
     |        In current implementation for the cluster client (starting form redis-py version 6.0.0)
     |        the retry object is not yet fully utilized, instead it is used just to determine
     |        the number of retries for the cluster client.
     |        In the future releases the retry object will be used to handle the cluster client retries!
     |  :param max_connections:
     |      | Maximum number of connections per node. If there are no free connections & the
     |        maximum number of connections are already created, a
     |        :class:`~.MaxConnectionsError` is raised.
     |  :param socket_keepalive:
     |      | If ``True``, TCP keepalive is enabled for TCP socket connections.
     |  :param socket_keepalive_options:
     |      | Mapping of TCP keepalive socket option constants to values, for
     |        example ``{socket.TCP_KEEPIDLE: 30}``. If left unspecified, redis-py
     |        uses TCP keepalive defaults when ``socket_keepalive`` is enabled:
     |        idle 30 seconds, interval 5 seconds, and 3 probes.
     |        Platform-specific options that are not available are skipped.
     |        Pass ``None`` or ``{}`` to avoid setting additional TCP keepalive
     |        options.
     |  :param address_remap:
     |      | An optional callable which, when provided with an internal network
     |        address of a node, e.g. a `(host, port)` tuple, will return the address
     |        where the node is reachable.  This can be used to map the addresses at
     |        which the nodes _think_ they are, to addresses at which a client may
     |        reach them, such as when they sit behind a proxy.
     |
     |  | Rest of the arguments will be passed to the
     |    :class:`~redis.asyncio.connection.Connection` instances when created
     |
     |  :raises RedisClusterException:
     |      if any arguments are invalid or unknown. Eg:
     |
     |      - `db` != 0 or None
     |      - `path` argument for unix socket connection
     |      - none of the `host`/`port` & `startup_nodes` were provided
     |
     |  Method resolution order:
     |      RedisCluster
     |      redis.client.AbstractRedis
     |      redis.cluster.AbstractRedisCluster
     |      AsyncMaintNotificationsAbstractRedisCluster
     |      redis.commands.cluster.AsyncRedisClusterCommands
     |      redis.commands.cluster.AsyncClusterMultiKeyCommands
     |      redis.commands.cluster.ClusterMultiKeyCommands
     |      redis.typing.ClusterCommandsProtocol
     |      redis.commands.cluster.AsyncClusterManagementCommands
     |      redis.commands.cluster.ClusterManagementCommands
     |      redis.commands.core.AsyncManagementCommands
     |      redis.commands.core.ManagementCommands
     |      redis.commands.core.ACLCommands
     |      redis.commands.core.PubSubCommands
     |      redis.commands.cluster.AsyncClusterDataAccessCommands
     |      redis.commands.cluster.ClusterDataAccessCommands
     |      redis.commands.core.DataAccessCommands
     |      redis.commands.core.AsyncDataAccessCommands
     |      redis.commands.core.AsyncBasicKeyCommands
     |      redis.commands.core.BasicKeyCommands
     |      redis.commands.core.HyperlogCommands
     |      redis.commands.core.HashCommands
     |      redis.commands.core.GeoCommands
     |      redis.commands.core.ListCommands
     |      redis.commands.core.ArrayCommands
     |      redis.commands.core.AsyncScanCommands
     |      redis.commands.core.ScanCommands
     |      redis.commands.core.SetCommands
     |      redis.commands.core.StreamCommands
     |      redis.commands.core.SortedSetCommands
     |      redis.commands.core.AsyncScriptCommands
     |      redis.commands.core.ScriptCommands
     |      redis.commands.core.FunctionCommands
     |      redis.commands.core.AsyncModuleCommands
     |      redis.commands.core.ModuleCommands
     |      redis.typing.CommandsProtocol
     |      typing.Protocol
     |      typing.Generic
     |      redis.commands.redismodules.AsyncRedisModuleCommands
     |      redis.commands.redismodules.RedisModuleCommands
     |      builtins.object
     |
     |  Methods defined here:
     |
     |  async __aenter__(self) -> 'RedisCluster'
     |      Async context manager entry. Increments a usage counter so that the
     |      connection pool is only closed (via aclose()) when no context is using
     |      the client.
     |
     |  async __aexit__(self, exc_type, exc_value, traceback)
     |      Async context manager exit. Decrements a usage counter. If this is the
     |      last exit (counter becomes zero), the client closes its connection pool.
     |
     |  __await__(self) -> Generator[Any, NoneType, ForwardRef('RedisCluster')]
     |
     |  __del__(self, _warn: Any = <built-in function warn>, _grl: Any = <built-in function get_running_loop>) -> None
     |
     |  __init__(self, host: str | None = None, port: str | int = 6379, startup_nodes: Optional[List[ForwardRef('ClusterNode')]] = None, require_full_coverage: bool = True, read_from_replicas: bool = False, load_balancing_strategy: redis.cluster.LoadBalancingStrategy | None = None, dynamic_startup_nodes: bool = True, reinitialize_steps: int = 5, cluster_error_retry_attempts: int = 10, max_connections: int = 100, retry: redis.asyncio.retry.Retry | None = None, retry_on_error: Optional[List[Type[Exception]]] = None, db: str | int = 0, path: str | None = None, credential_provider: redis.credentials.CredentialProvider | None = None, username: str | None = None, password: str | None = None, client_name: str | None = None, lib_name: str | object | None = <object object at 0x0000017B991493E0>, lib_version: str | object | None = <object object at 0x0000017B991493E0>, driver_info: redis.driver_info.DriverInfo | object | None = <object object at 0x0000017B991493E0>, encoding: str = 'utf-8', encoding_errors: str = 'strict', decode_responses: bool = False, health_check_interval: float = 0, socket_timeout: float | None = 5, socket_connect_timeout: float | None = 5, socket_read_size: int = 32768, socket_keepalive: bool = True, socket_keepalive_options: Union[Mapping[int, int | bytes], object, NoneType] = <object object at 0x0000017B991493E0>, ssl: bool = False, ssl_ca_certs: str | None = None, ssl_ca_data: str | None = None, ssl_cert_reqs: 'str | VerifyMode' = 'required', ssl_include_verify_flags: Optional[List[ForwardRef('VerifyFlags')]] = None, ssl_exclude_verify_flags: Optional[List[ForwardRef('VerifyFlags')]] = None, ssl_certfile: str | None = None, ssl_check_hostname: bool = True, ssl_keyfile: str | None = None, ssl_min_version: 'TLSVersion | None' = None, ssl_ciphers: str | None = None, protocol: int | None = None, legacy_responses: bool = True, address_remap: Optional[Callable[[Tuple[str, int]], Tuple[str, int]]] = None, event_dispatcher: redis.event.EventDispatcher | None = None, policy_resolver: redis.commands.policies.AsyncPolicyResolver = <redis.commands.policies.AsyncStaticPolicyResolver object at 0x0000017B9C771130>, maint_notifications_config: redis.maint_notifications.MaintNotificationsConfig | None = None) -> None
     |      Initialize self.  See help(type(self)) for accurate signature.
     |
     |  async aclose(self) -> None
     |      Close all connections & client if initialized.
     |
     |  async close(self) -> None
     |      alias for aclose() for backwards compatibility
     |
     |  async execute_command(self, *args: Union[bytes, bytearray, memoryview, str, int, float], **kwargs: Any) -> Any
     |      Execute a raw command on the appropriate cluster node or target_nodes.
     |
     |      It will retry the command as specified by the retries property of
     |      the :attr:`retry` & then raise an exception.
     |
     |      :param args:
     |          | Raw command args
     |      :param kwargs:
     |
     |          - target_nodes: :attr:`NODE_FLAGS` or :class:`~.ClusterNode`
     |            or List[:class:`~.ClusterNode`] or Dict[Any, :class:`~.ClusterNode`]
     |          - Rest of the kwargs are passed to the Redis connection
     |
     |      :raises RedisClusterException: if target_nodes is not provided & the command
     |          can't be mapped to a slot
     |
     |  get_connection_kwargs(self) -> Dict[str, Optional[Any]]
     |      Get the kwargs passed to :class:`~redis.asyncio.connection.Connection`.
     |
     |  get_default_node(self) -> 'ClusterNode'
     |      Get the default node of the client.
     |
     |  get_encoder(self) -> redis._parsers.encoders.Encoder
     |      Get the encoder object of the client.
     |
     |  get_node(self, host: Optional[str] = None, port: Optional[int] = None, node_name: Optional[str] = None) -> Optional[ForwardRef('ClusterNode')]
     |      Get node by (host, port) or node_name.
     |
     |  get_node_from_key(self, key: str, replica: bool = False) -> Optional[ForwardRef('ClusterNode')]
     |      Get the cluster node corresponding to the provided key.
     |
     |      :param key:
     |      :param replica:
     |          | Indicates if a replica should be returned
     |          |
     |            None will returned if no replica holds this key
     |
     |      :raises SlotNotCoveredError: if the key is not covered by any slot.
     |
     |  get_nodes(self) -> List[ForwardRef('ClusterNode')]
     |      Get all nodes of the cluster.
     |
     |  async get_nodes_from_slot(self, command: str, *args)
     |      Returns a list of nodes that hold the specified keys' slots.
     |
     |  get_primaries(self) -> List[ForwardRef('ClusterNode')]
     |      Get the primary nodes of the cluster.
     |
     |  get_random_node(self) -> 'ClusterNode'
     |      Get a random node of the cluster.
     |
     |  get_random_primary_node(self) -> 'ClusterNode'
     |      Returns a random primary node
     |
     |  get_random_primary_or_all_nodes(self, command_name)
     |      Returns random primary or all nodes depends on READONLY mode.
     |
     |  get_replicas(self) -> List[ForwardRef('ClusterNode')]
     |      Get the replica nodes of the cluster.
     |
     |  get_special_nodes(self) -> Optional[list['ClusterNode']]
     |      Returns a list of nodes for commands with a special policy.
     |
     |  async himport_discard(self, fieldset_name: str) -> int
     |      Remove an HIMPORT fieldset cluster-wide (shared registry, applied lazily).
     |
     |  async himport_discard_all(self) -> int
     |      Remove all HIMPORT fieldsets cluster-wide (shared registry, applied lazily).
     |
     |  async himport_prepare(self, fieldset_name: str, fields: Iterable[Union[bytes, bytearray, memoryview, str, int, float]]) -> bool
     |      Declare an HIMPORT fieldset cluster-wide (shared registry, applied lazily).
     |
     |  async initialize(self, additional_startup_nodes_info: Optional[List[Tuple[str, int]]] = None, last_failed_node_name: Optional[str] = None) -> 'RedisCluster'
     |      Get all nodes from startup nodes & creates connections if not initialized.
     |
     |  keyslot(self, key: Union[bytes, bytearray, memoryview, str, int, float]) -> int
     |      Find the keyslot for a given key.
     |
     |      See: https://redis.io/docs/manual/scaling/#redis-cluster-data-sharding
     |
     |  keyspace_notifications(self, key_prefix: Union[str, bytes, NoneType] = None, ignore_subscribe_messages: bool = True) -> 'AsyncClusterKeyspaceNotifications'
     |      Return an
     |      :class:`~redis.asyncio.keyspace_notifications.AsyncClusterKeyspaceNotifications`
     |      object for subscribing to keyspace and keyevent notifications across
     |      all primary nodes in the cluster.
     |
     |      Note: Keyspace notifications must be enabled on all Redis cluster nodes
     |      via the ``notify-keyspace-events`` configuration option.
     |
     |      Args:
     |          key_prefix: Optional prefix to filter and strip from keys in
     |                      notifications.
     |          ignore_subscribe_messages: If True, subscribe/unsubscribe
     |                                    confirmations are not returned by
     |                                    get_message/listen.
     |
     |  lock(self, name: Union[bytes, str, memoryview], timeout: Optional[float] = None, sleep: float = 0.1, blocking: bool = True, blocking_timeout: Optional[float] = None, lock_class: Optional[Type[redis.asyncio.lock.Lock]] = None, thread_local: bool = True, raise_on_release_error: bool = True) -> redis.asyncio.lock.Lock
     |      Return a new Lock object using key ``name`` that mimics
     |      the behavior of threading.Lock.
     |
     |      If specified, ``timeout`` indicates a maximum life for the lock.
     |      By default, it will remain locked until release() is called.
     |
     |      ``sleep`` indicates the amount of time to sleep per loop iteration
     |      when the lock is in blocking mode and another client is currently
     |      holding the lock.
     |
     |      ``blocking`` indicates whether calling ``acquire`` should block until
     |      the lock has been acquired or to fail immediately, causing ``acquire``
     |      to return False and the lock not being acquired. Defaults to True.
     |      Note this value can be overridden by passing a ``blocking``
     |      argument to ``acquire``.
     |
     |      ``blocking_timeout`` indicates the maximum amount of time in seconds to
     |      spend trying to acquire the lock. A value of ``None`` indicates
     |      continue trying forever. ``blocking_timeout`` can be specified as a
     |      float or integer, both representing the number of seconds to wait.
     |
     |      ``lock_class`` forces the specified lock implementation. Note that as
     |      of redis-py 3.0, the only lock class we implement is ``Lock`` (which is
     |      a Lua-based lock). So, it's unlikely you'll need this parameter, unless
     |      you have created your own custom lock class.
     |
     |      ``thread_local`` indicates whether the lock token is placed in
     |      thread-local storage. By default, the token is placed in thread local
     |      storage so that a thread only sees its token, not a token set by
     |      another thread. Consider the following timeline:
     |
     |          time: 0, thread-1 acquires `my-lock`, with a timeout of 5 seconds.
     |                   thread-1 sets the token to "abc"
     |          time: 1, thread-2 blocks trying to acquire `my-lock` using the
     |                   Lock instance.
     |          time: 5, thread-1 has not yet completed. redis expires the lock
     |                   key.
     |          time: 5, thread-2 acquired `my-lock` now that it's available.
     |                   thread-2 sets the token to "xyz"
     |          time: 6, thread-1 finishes its work and calls release(). if the
     |                   token is *not* stored in thread local storage, then
     |                   thread-1 would see the token value as "xyz" and would be
     |                   able to successfully release the thread-2's lock.
     |
     |      ``raise_on_release_error`` indicates whether to raise an exception when
     |      the lock is no longer owned when exiting the context manager. By default,
     |      this is True, meaning an exception will be raised. If False, the warning
     |      will be logged and the exception will be suppressed.
     |
     |      In some use cases it's necessary to disable thread local storage. For
     |      example, if you have code where one thread acquires a lock and passes
     |      that lock instance to a worker thread to release later. If thread
     |      local storage isn't disabled in this case, the worker thread won't see
     |      the token set by the thread that acquired the lock. Our assumption
     |      is that these cases aren't common and as such default to using
     |      thread local storage.
     |
     |  async on_connect(self, connection: redis.asyncio.connection.Connection) -> None
     |
     |  pipeline(self, transaction: Optional[Any] = None, shard_hint: Optional[Any] = None) -> 'ClusterPipeline'
     |      Create & return a new :class:`~.ClusterPipeline` object.
     |
     |      Cluster implementation of pipeline does not support transaction or shard_hint.
     |
     |      :raises RedisClusterException: if transaction or shard_hint are truthy values
     |
     |  pubsub(self, node: Optional[ForwardRef('ClusterNode')] = None, host: Optional[str] = None, port: Optional[int] = None, **kwargs: Any) -> 'ClusterPubSub'
     |      Create and return a ClusterPubSub instance.
     |
     |      Allows passing a ClusterNode, or host&port, to get a pubsub instance
     |      connected to the specified node
     |
     |      :param node: ClusterNode to connect to
     |      :param host: Host of the node to connect to
     |      :param port: Port of the node to connect to
     |      :param kwargs: Additional keyword arguments
     |      :return: ClusterPubSub instance
     |
     |  set_default_node(self, node: 'ClusterNode') -> None
     |      Set the default node of the client.
     |
     |      :raises DataError: if None is passed or node does not exist in cluster.
     |
     |  set_response_callback(self, command: str, callback: Union[redis.asyncio.client.ResponseCallbackProtocol, redis.asyncio.client.AsyncResponseCallbackProtocol]) -> None
     |      Set a custom response callback.
     |
     |  set_retry(self, retry: redis.asyncio.retry.Retry) -> None
     |
     |  async transaction(self, func: Coroutine[NoneType, ForwardRef('ClusterPipeline'), Any], *watches, **kwargs)
     |      Convenience method for executing the callable `func` as a transaction
     |      while watching all keys specified in `watches`. The 'func' callable
     |      should expect a single argument which is a Pipeline object.
     |
     |  ----------------------------------------------------------------------
     |  Class methods defined here:
     |
     |  __subclasshook__ = _proto_hook(other) from typing
     |
     |  from_url(url: str, **kwargs: Any) -> 'RedisCluster'
     |      Return a Redis client object configured from the given URL.
     |
     |      For example::
     |
     |          redis://[[username]:[password]]@localhost:6379/0
     |          rediss://[[username]:[password]]@localhost:6379/0
     |
     |      Three URL schemes are supported:
     |
     |      - `redis://` creates a TCP socket connection. See more at:
     |        <https://www.iana.org/assignments/uri-schemes/prov/redis>
     |      - `rediss://` creates a SSL wrapped TCP socket connection. See more at:
     |        <https://www.iana.org/assignments/uri-schemes/prov/rediss>
     |
     |      The username, password, hostname, path and all querystring values are passed
     |      through ``urllib.parse.unquote`` in order to replace any percent-encoded values
     |      with their corresponding characters.
     |
     |      All querystring options are cast to their appropriate Python types. Boolean
     |      arguments can be specified with string values "True"/"False" or "Yes"/"No".
     |      Values that cannot be properly cast cause a ``ValueError`` to be raised. Once
     |      parsed, the querystring arguments and keyword arguments are passed to
     |      :class:`~redis.asyncio.connection.Connection` when created.
     |      In the case of conflicting arguments, querystring arguments are used.
     |
     |  ----------------------------------------------------------------------
     |  Readonly properties defined here:
     |
     |  himport_registry
     |      The cluster-wide HIMPORT fieldset registry (empty if none was declared).
     |
     |      Read-only: the registry is mutated only through the HIMPORT command methods.
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors defined here:
     |
     |  command_flags
     |
     |  commands_parser
     |
     |  connection_kwargs
     |
     |  encoder
     |
     |  maint_notifications_config
     |
     |  node_flags
     |
     |  nodes_manager
     |
     |  read_from_replicas
     |
     |  reinitialize_counter
     |
     |  reinitialize_steps
     |
     |  response_callbacks
     |
     |  result_callbacks
     |
     |  retry
     |
     |  ----------------------------------------------------------------------
     |  Data and other attributes defined here:
     |
     |  __abstractmethods__ = frozenset()
     |
     |  __annotations__ = {'_is_async_client': typing.Literal[True]}
     |
     |  __parameters__ = ()
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors inherited from redis.client.AbstractRedis:
     |
     |  __dict__
     |      dictionary for instance variables
     |
     |  __weakref__
     |      list of weak references to the object
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from redis.cluster.AbstractRedisCluster:
     |
     |  replace_default_node(self, target_node: 'ClusterNode' = None) -> None
     |      Replace the default cluster node.
     |      A random cluster node will be chosen if target_node isn't passed, and primaries
     |      will be prioritized. The default node will not be changed if there are no other
     |      nodes in the cluster.
     |
     |      Args:
     |          target_node (ClusterNode, optional): Target node to replace the default
     |          node. Defaults to None.
     |
     |  ----------------------------------------------------------------------
     |  Data and other attributes inherited from redis.cluster.AbstractRedisCluster:
     |
     |  ALL_NODES = 'all'
     |
     |  CLUSTER_COMMANDS_RESPONSE_CALLBACKS = {'CLUSTER MYSHARDID': <function ...
     |
     |  COMMAND_FLAGS = {'ACL CAT': 'default-node', 'ACL DELUSER': 'default-no...
     |
     |  DEFAULT_NODE = 'default-node'
     |
     |  ERRORS_ALLOW_RETRY = (<class 'redis.exceptions.ConnectionError'>, <cla...
     |
     |  NODE_FLAGS = {'all', 'default-node', 'primaries', 'random', 'replicas'...
     |
     |  PRIMARIES = 'primaries'
     |
     |  RANDOM = 'random'
     |
     |  REPLICAS = 'replicas'
     |
     |  RESULT_CALLBACKS = {'BGSAVE': <function AbstractRedisCluster.<lambda>>...
     |
     |  RedisClusterRequestTTL = 16
     |
     |  SEARCH_COMMANDS = (['FT.CREATE', 'FT.SEARCH', 'FT.AGGREGATE', 'FT.EXPL...
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from redis.commands.cluster.AsyncClusterMultiKeyCommands:
     |
     |  async mget_nonatomic(self, keys: 'KeysT', *args: 'KeyT') -> 'List[Any | None]'
     |      Splits the keys into different slots and then calls MGET
     |      for the keys of every slot. This operation will not be atomic
     |      if keys belong to more than one slot.
     |
     |      Returns a list of values ordered identically to ``keys``
     |
     |      For more information see https://redis.io/commands/mget
     |
     |  async mset_nonatomic(self, mapping: 'Mapping[AnyKeyT, EncodableT]') -> 'List[bool]'
     |      Sets key/values based on a mapping. Mapping is a dictionary of
     |      key/value pairs. Both keys and values should be strings or types that
     |      can be cast to a string via str().
     |
     |      Splits the keys into different slots and then calls MSET
     |      for the keys of every slot. This operation will not be atomic
     |      if keys belong to more than one slot.
     |
     |      For more information see https://redis.io/commands/mset
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from redis.commands.cluster.ClusterMultiKeyCommands:
     |
     |  delete(self, *keys: 'KeyT') -> 'int | Awaitable[int]'
     |      Deletes the given keys in the cluster.
     |      The keys are first split up into slots
     |      and then an DEL command is sent for every slot
     |
     |      Non-existent keys are ignored.
     |      Returns the number of keys that were deleted.
     |
     |      For more information see https://redis.io/commands/del
     |
     |  exists(self, *keys: 'KeyT') -> 'int | Awaitable[int]'
     |      Returns the number of ``names`` that exist in the
     |      whole cluster. The keys are first split up into slots
     |      and then an EXISTS command is sent for every slot
     |
     |      For more information see https://redis.io/commands/exists
     |
     |  touch(self, *keys: 'KeyT') -> 'int | Awaitable[int]'
     |      Updates the last access time of given keys across the
     |      cluster.
     |
     |      The keys are first split up into slots
     |      and then an TOUCH command is sent for every slot
     |
     |      Non-existent keys are ignored.
     |      Returns the number of keys that were touched.
     |
     |      For more information see https://redis.io/commands/touch
     |
     |  unlink(self, *keys: 'KeyT') -> 'int | Awaitable[int]'
     |      Remove the specified keys in a different thread.
     |
     |      The keys are first split up into slots
     |      and then an TOUCH command is sent for every slot
     |
     |      Non-existent keys are ignored.
     |      Returns the number of keys that were unlinked.
     |
     |      For more information see https://redis.io/commands/unlink
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from redis.commands.cluster.AsyncClusterManagementCommands:
     |
     |  async client_tracking_off(self, clientid: 'int | None' = None, prefix: 'Sequence[KeyT]' = [], bcast: 'bool' = False, optin: 'bool' = False, optout: 'bool' = False, noloop: 'bool' = False, target_nodes: "'TargetNodesT' | None" = 'all') -> 'ResponseT'
     |      Disables the tracking feature of the Redis server, that is used
     |      for server assisted client side caching.
     |
     |      When clientid is provided - in target_nodes only the node that owns the
     |      connection with this id should be provided.
     |      When clientid is not provided - target_nodes can be any node.
     |
     |      For more information see https://redis.io/commands/client-tracking
     |
     |  async client_tracking_on(self, clientid: 'int | None' = None, prefix: 'Sequence[KeyT]' = [], bcast: 'bool' = False, optin: 'bool' = False, optout: 'bool' = False, noloop: 'bool' = False, target_nodes: "'TargetNodesT' | None" = 'all') -> 'ResponseT'
     |      Enables the tracking feature of the Redis server, that is used
     |      for server assisted client side caching.
     |
     |      When clientid is provided - in target_nodes only the node that owns the
     |      connection with this id should be provided.
     |      When clientid is not provided - target_nodes can be any node.
     |
     |      For more information see https://redis.io/commands/client-tracking
     |
     |  async cluster_delslots(self, *slots: 'EncodableT') -> 'List[bool]'
     |      Set hash slots as unbound in the cluster.
     |      It determines by it self what node the slot is in and sends it there
     |
     |      Returns a list of the results for each processed slot.
     |
     |      For more information see https://redis.io/commands/cluster-delslots
     |
     |  async hotkeys_get(self, **kwargs) -> 'Awaitable[list[dict[str | bytes, Any]]]'
     |      Cluster client does not support hotkeys command. Please use the non-cluster client.
     |
     |      For more information see https://redis.io/commands/hotkeys-get
     |
     |  async hotkeys_reset(self, **kwargs) -> 'Awaitable[str | bytes]'
     |      Cluster client does not support hotkeys command. Please use the non-cluster client.
     |
     |      For more information see https://redis.io/commands/hotkeys-reset
     |
     |  async hotkeys_start(self, metrics: 'List[HotkeysMetricsTypes]', count: 'int | None' = None, duration: 'int | None' = None, sample_ratio: 'int | None' = None, slots: 'List[int] | None' = None, **kwargs) -> 'Awaitable[str | bytes]'
     |      Cluster client does not support hotkeys command. Please use the non-cluster client.
     |
     |      For more information see https://redis.io/commands/hotkeys-start
     |
     |  async hotkeys_stop(self, **kwargs) -> 'Awaitable[str | bytes]'
     |      Cluster client does not support hotkeys command. Please use the non-cluster client.
     |
     |      For more information see https://redis.io/commands/hotkeys-stop
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from redis.commands.cluster.ClusterManagementCommands:
     |
     |  cluster_addslots(self, target_node: "'TargetNodesT'", *slots: 'EncodableT') -> 'bool | Awaitable[bool]'
     |      Assign new hash slots to receiving node. Sends to specified node.
     |
     |      :target_node: 'ClusterNode'
     |          The node to execute the command on
     |
     |      For more information see https://redis.io/commands/cluster-addslots
     |
     |  cluster_addslotsrange(self, target_node: "'TargetNodesT'", *slots: 'EncodableT') -> 'bool | Awaitable[bool]'
     |      Similar to the CLUSTER ADDSLOTS command.
     |      The difference between the two commands is that ADDSLOTS takes a list of slots
     |      to assign to the node, while ADDSLOTSRANGE takes a list of slot ranges
     |      (specified by start and end slots) to assign to the node.
     |
     |      :target_node: 'ClusterNode'
     |          The node to execute the command on
     |
     |      For more information see https://redis.io/commands/cluster-addslotsrange
     |
     |  cluster_bumpepoch(self, target_nodes: "'TargetNodesT' | None" = None) -> 'None'
     |
     |  cluster_count_failure_report(self, node_id: 'str') -> 'int | Awaitable[int]'
     |      Return the number of failure reports active for a given node
     |      Sends to a random node
     |
     |      For more information see https://redis.io/commands/cluster-count-failure-reports
     |
     |  cluster_countkeysinslot(self, slot_id: 'int') -> 'int | Awaitable[int]'
     |      Return the number of local keys in the specified hash slot
     |      Send to node based on specified slot_id
     |
     |      For more information see https://redis.io/commands/cluster-countkeysinslot
     |
     |  cluster_delslotsrange(self, *slots: 'EncodableT') -> 'bool | Awaitable[bool]'
     |      Similar to the CLUSTER DELSLOTS command.
     |      The difference is that CLUSTER DELSLOTS takes a list of hash slots to remove
     |      from the node, while CLUSTER DELSLOTSRANGE takes a list of slot ranges to remove
     |      from the node.
     |
     |      For more information see https://redis.io/commands/cluster-delslotsrange
     |
     |  cluster_failover(self, target_node: "'TargetNodesT'", option: 'str | None' = None) -> 'bool | Awaitable[bool]'
     |      Forces a slave to perform a manual failover of its master
     |      Sends to specified node
     |
     |      :target_node: 'ClusterNode'
     |          The node to execute the command on
     |
     |      For more information see https://redis.io/commands/cluster-failover
     |
     |  cluster_flushslots(self, target_nodes: "'TargetNodesT' | None" = None) -> 'None'
     |
     |  cluster_get_keys_in_slot(self, slot: 'int', num_keys: 'int') -> 'list[bytes | str] | Awaitable[list[bytes | str]]'
     |      Returns the number of keys in the specified cluster slot
     |
     |      For more information see https://redis.io/commands/cluster-getkeysinslot
     |
     |  cluster_info(self, target_nodes: "'TargetNodesT' | None" = None) -> 'dict[str, str] | Awaitable[dict[str, str]]'
     |      Provides info about Redis Cluster node state.
     |      The command will be sent to a random node in the cluster if no target
     |      node is specified.
     |
     |      For more information see https://redis.io/commands/cluster-info
     |
     |  cluster_keyslot(self, key: 'str') -> 'int | Awaitable[int]'
     |      Returns the hash slot of the specified key
     |      Sends to random node in the cluster
     |
     |      For more information see https://redis.io/commands/cluster-keyslot
     |
     |  cluster_links(self, target_node: "'TargetNodesT'") -> 'ClusterLinksResponse | Awaitable[ClusterLinksResponse]'
     |      Each node in a Redis Cluster maintains a pair of long-lived TCP link with each
     |      peer in the cluster: One for sending outbound messages towards the peer and one
     |      for receiving inbound messages from the peer.
     |
     |      This command outputs information of all such peer links as an array.
     |
     |      For more information see https://redis.io/commands/cluster-links
     |
     |  cluster_meet(self, host: 'str', port: 'int', target_nodes: "'TargetNodesT' | None" = None) -> 'bool | Awaitable[bool]'
     |      Force a node cluster to handshake with another node.
     |      Sends to specified node.
     |
     |      For more information see https://redis.io/commands/cluster-meet
     |
     |  cluster_myid(self, target_node: "'TargetNodesT'") -> 'bytes | str | Awaitable[bytes | str]'
     |      Returns the node's id.
     |
     |      :target_node: 'ClusterNode'
     |          The node to execute the command on
     |
     |      For more information check https://redis.io/commands/cluster-myid/
     |
     |  cluster_myshardid(self, target_nodes: "'TargetNodesT' | None" = None) -> 'bytes | str | Awaitable[bytes | str]'
     |      Returns the shard ID of the node.
     |
     |      For more information see https://redis.io/commands/cluster-myshardid/
     |
     |  cluster_nodes(self) -> 'dict[str, ClusterNodeDetail] | Awaitable[dict[str, ClusterNodeDetail]]'
     |      Get Cluster config for the node.
     |      Sends to random node in the cluster
     |
     |      For more information see https://redis.io/commands/cluster-nodes
     |
     |  cluster_replicas(self, node_id: 'str', target_nodes: "'TargetNodesT' | None" = None) -> 'dict[str, ClusterNodeDetail] | Awaitable[dict[str, ClusterNodeDetail]]'
     |      Provides a list of replica nodes replicating from the specified primary
     |      target node.
     |
     |      For more information see https://redis.io/commands/cluster-replicas
     |
     |  cluster_replicate(self, target_nodes: "'TargetNodesT'", node_id: 'str') -> 'bool | Awaitable[bool]'
     |      Reconfigure a node as a slave of the specified master node
     |
     |      For more information see https://redis.io/commands/cluster-replicate
     |
     |  cluster_reset(self, soft: 'bool' = True, target_nodes: "'TargetNodesT' | None" = None) -> 'bool | Awaitable[bool]'
     |      Reset a Redis Cluster node
     |
     |      If 'soft' is True then it will send 'SOFT' argument
     |      If 'soft' is False then it will send 'HARD' argument
     |
     |      For more information see https://redis.io/commands/cluster-reset
     |
     |  cluster_save_config(self, target_nodes: "'TargetNodesT' | None" = None) -> 'bool | Awaitable[bool]'
     |      Forces the node to save cluster state on disk
     |
     |      For more information see https://redis.io/commands/cluster-saveconfig
     |
     |  cluster_set_config_epoch(self, epoch: 'int', target_nodes: "'TargetNodesT' | None" = None) -> 'bool | Awaitable[bool]'
     |      Set the configuration epoch in a new node
     |
     |      For more information see https://redis.io/commands/cluster-set-config-epoch
     |
     |  cluster_setslot(self, target_node: "'TargetNodesT'", node_id: 'str', slot_id: 'int', state: 'str') -> 'bool | Awaitable[bool]'
     |      Bind an hash slot to a specific node
     |
     |      :target_node: 'ClusterNode'
     |          The node to execute the command on
     |
     |      For more information see https://redis.io/commands/cluster-setslot
     |
     |  cluster_setslot_stable(self, slot_id: 'int') -> 'bool | Awaitable[bool]'
     |      Clears migrating / importing state from the slot.
     |      It determines by it self what node the slot is in and sends it there.
     |
     |      For more information see https://redis.io/commands/cluster-setslot
     |
     |  cluster_shards(self, target_nodes: "'TargetNodesT' | None" = None) -> 'ClusterShardsResponse | Awaitable[ClusterShardsResponse]'
     |      Returns details about the shards of the cluster.
     |
     |      For more information see https://redis.io/commands/cluster-shards
     |
     |  cluster_slots(self, target_nodes: "'TargetNodesT' | None" = None) -> 'list[Any] | Awaitable[list[Any]]'
     |      Get array of Cluster slot to node mappings
     |
     |      For more information see https://redis.io/commands/cluster-slots
     |
     |  readonly(self, target_nodes: "'TargetNodesT' | None" = None) -> 'ResponseT'
     |      Enables read queries.
     |      The command will be sent to the default cluster node if target_nodes is
     |      not specified.
     |
     |      For more information see https://redis.io/commands/readonly
     |
     |  readwrite(self, target_nodes: "'TargetNodesT' | None" = None) -> 'ResponseT'
     |      Disables read queries.
     |      The command will be sent to the default cluster node if target_nodes is
     |      not specified.
     |
     |      For more information see https://redis.io/commands/readwrite
     |
     |  replicaof(self, *args, **kwargs) -> 'NoReturn'
     |      Make the server a replica of another instance, or promote it as master.
     |
     |      For more information see https://redis.io/commands/replicaof
     |
     |  slaveof(self, *args, **kwargs) -> 'NoReturn'
     |      Make the server a replica of another instance, or promote it as master.
     |
     |      For more information see https://redis.io/commands/slaveof
     |
     |  swapdb(self, *args, **kwargs) -> 'NoReturn'
     |      Swaps two Redis databases.
     |
     |      For more information see https://redis.io/commands/swapdb
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from redis.commands.core.AsyncManagementCommands:
     |
     |  async command_info(self, **kwargs) -> 'None'
     |
     |  async debug_segfault(self, **kwargs) -> 'None'
     |
     |  async memory_doctor(self, **kwargs) -> 'None'
     |
     |  async memory_help(self, **kwargs) -> 'None'
     |
     |  async shutdown(self, save: 'bool' = False, nosave: 'bool' = False, now: 'bool' = False, force: 'bool' = False, abort: 'bool' = False, **kwargs) -> 'None'
     |      Shutdown the Redis server.  If Redis has persistence configured,
     |      data will be flushed before shutdown.  If the "save" option is set,
     |      a data flush will be attempted even if there is no persistence
     |      configured.  If the "nosave" option is set, no data flush will be
     |      attempted.  The "save" and "nosave" options cannot both be set.
     |
     |      For more information, see https://redis.io/commands/shutdown
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from redis.commands.core.ManagementCommands:
     |
     |  auth(self, password: 'str', username: 'str | None' = None, **kwargs) -> 'bool | Awaitable[bool]'
     |      Authenticates the user. If you do not pass username, Redis will try to
     |      authenticate for the "default" user. If you do pass username, it will
     |      authenticate for the given user.
     |      For more information, see https://redis.io/commands/auth
     |
     |  bgrewriteaof(self, **kwargs) -> 'bool | bytes | str | Awaitable[bool | bytes | str]'
     |      Tell the Redis server to rewrite the AOF file from data in memory.
     |
     |      For more information, see https://redis.io/commands/bgrewriteaof
     |
     |  bgsave(self, schedule: 'bool' = True, **kwargs) -> 'bool | bytes | str | Awaitable[bool | bytes | str]'
     |      Tell the Redis server to save its data to disk.  Unlike save(),
     |      this method is asynchronous and returns immediately.
     |
     |      For more information, see https://redis.io/commands/bgsave
     |
     |  client_getname(self, **kwargs) -> 'bytes | str | None | Awaitable[bytes | str | None]'
     |      Returns the current connection name
     |
     |      For more information, see https://redis.io/commands/client-getname
     |
     |  client_getredir(self, **kwargs) -> 'int | Awaitable[int]'
     |      Returns the ID (an integer) of the client to whom we are
     |      redirecting tracking notifications.
     |
     |      see: https://redis.io/commands/client-getredir
     |
     |  client_id(self, **kwargs) -> 'int | Awaitable[int]'
     |      Returns the current connection id
     |
     |      For more information, see https://redis.io/commands/client-id
     |
     |  client_info(self, **kwargs) -> 'dict[str, str | int] | Awaitable[dict[str, str | int]]'
     |      Returns information and statistics about the current
     |      client connection.
     |
     |      For more information, see https://redis.io/commands/client-info
     |
     |  client_kill(self, address: 'str', **kwargs) -> 'bool | int | Awaitable[bool | int]'
     |      Disconnects the client at ``address`` (ip:port)
     |
     |      For more information, see https://redis.io/commands/client-kill
     |
     |  client_kill_filter(self, _id: 'str | None' = None, _type: 'str | None' = None, addr: 'str | None' = None, skipme: 'bool | None' = None, laddr: 'bool | None' = None, user: 'str | None' = None, maxage: 'int | None' = None, **kwargs) -> 'int | Awaitable[int]'
     |      Disconnects client(s) using a variety of filter options
     |      :param _id: Kills a client by its unique ID field
     |      :param _type: Kills a client by type where type is one of 'normal',
     |      'master', 'slave', 'replica' or 'pubsub'
     |      :param addr: Kills a client by its 'address:port'
     |      :param skipme: If True, then the client calling the command
     |      will not get killed even if it is identified by one of the filter
     |      options. If skipme is not provided, the server defaults to skipme=True
     |      :param laddr: Kills a client by its 'local (bind) address:port'
     |      :param user: Kills a client for a specific user name
     |      :param maxage: Kills clients that are older than the specified age in seconds
     |
     |  client_list(self, _type: 'str | None' = None, client_id: 'List[EncodableT]' = [], **kwargs) -> 'list[dict[str, str]] | Awaitable[list[dict[str, str]]]'
     |      Returns a list of currently connected clients.
     |      If type of client specified, only that type will be returned.
     |
     |      :param _type: optional. one of the client types (normal, master,
     |       replica, pubsub)
     |      :param client_id: optional. a list of client ids
     |
     |      For more information, see https://redis.io/commands/client-list
     |
     |  client_no_evict(self, mode: 'str') -> 'bytes | str | Awaitable[bytes | str]'
     |      Sets the client eviction mode for the current connection.
     |
     |      For more information, see https://redis.io/commands/client-no-evict
     |
     |  client_no_touch(self, mode: 'str') -> 'bytes | str | Awaitable[bytes | str]'
     |      # The command controls whether commands sent by the client will alter
     |      # the LRU/LFU of the keys they access.
     |      # When turned on, the current client will not change LFU/LRU stats,
     |      # unless it sends the TOUCH command.
     |
     |      For more information, see https://redis.io/commands/client-no-touch
     |
     |  client_pause(self, timeout: 'int', all: 'bool' = True, **kwargs) -> 'bool | Awaitable[bool]'
     |      Suspend all the Redis clients for the specified amount of time.
     |
     |
     |      For more information, see https://redis.io/commands/client-pause
     |
     |      Args:
     |          timeout: milliseconds to pause clients
     |          all: If true (default) all client commands are blocked.
     |               otherwise, clients are only blocked if they attempt to execute
     |               a write command.
     |
     |      For the WRITE mode, some commands have special behavior:
     |
     |      * EVAL/EVALSHA: Will block client for all scripts.
     |      * PUBLISH: Will block client.
     |      * PFCOUNT: Will block client.
     |      * WAIT: Acknowledgments will be delayed, so this command will
     |          appear blocked.
     |
     |  client_reply(self, reply: "Literal['ON', 'OFF', 'SKIP']", **kwargs) -> 'bytes | str | Awaitable[bytes | str]'
     |      Enable and disable redis server replies.
     |
     |      ``reply`` Must be ON OFF or SKIP,
     |      ON - The default most with server replies to commands
     |      OFF - Disable server responses to commands
     |      SKIP - Skip the response of the immediately following command.
     |
     |      Note: When setting OFF or SKIP replies, you will need a client object
     |      with a timeout specified in seconds, and will need to catch the
     |      TimeoutError.
     |      The test_client_reply unit test illustrates this, and
     |      conftest.py has a client with a timeout.
     |
     |      See https://redis.io/commands/client-reply
     |
     |  client_setinfo(self, attr: 'str', value: 'str', **kwargs) -> 'bool | Awaitable[bool]'
     |      Sets the current connection library name or version
     |      For more information see https://redis.io/commands/client-setinfo
     |
     |  client_setname(self, name: 'str', **kwargs) -> 'bool | Awaitable[bool]'
     |      Sets the current connection name
     |
     |      For more information, see https://redis.io/commands/client-setname
     |
     |      .. note::
     |         This method sets client name only for **current** connection.
     |
     |         If you want to set a common name for all connections managed
     |         by this client, use ``client_name`` constructor argument.
     |
     |  client_tracking(self, on: 'bool' = True, clientid: 'int | None' = None, prefix: 'Sequence[KeyT]' = [], bcast: 'bool' = False, optin: 'bool' = False, optout: 'bool' = False, noloop: 'bool' = False, **kwargs) -> 'bytes | str | Awaitable[bytes | str]'
     |      Enables the tracking feature of the Redis server, that is used
     |      for server assisted client side caching.
     |
     |      ``on`` indicate for tracking on or tracking off. The default is on.
     |
     |      ``clientid`` send invalidation messages to the connection with
     |      the specified ID.
     |
     |      ``bcast`` enable tracking in broadcasting mode. In this mode
     |      invalidation messages are reported for all the prefixes
     |      specified, regardless of the keys requested by the connection.
     |
     |      ``optin``  when broadcasting is NOT active, normally don't track
     |      keys in read only commands, unless they are called immediately
     |      after a CLIENT CACHING yes command.
     |
     |      ``optout`` when broadcasting is NOT active, normally track keys in
     |      read only commands, unless they are called immediately after a
     |      CLIENT CACHING no command.
     |
     |      ``noloop`` don't send notifications about keys modified by this
     |      connection itself.
     |
     |      ``prefix``  for broadcasting, register a given key prefix, so that
     |      notifications will be provided only for keys starting with this string.
     |
     |      See https://redis.io/commands/client-tracking
     |
     |  client_trackinginfo(self, **kwargs) -> 'ClientTrackingInfoResponse | Awaitable[ClientTrackingInfoResponse]'
     |      Returns the information about the current client connection's
     |      use of the server assisted client side cache.
     |
     |      See https://redis.io/commands/client-trackinginfo
     |
     |  client_unblock(self, client_id: 'int', error: 'bool' = False, **kwargs) -> 'bool | Awaitable[bool]'
     |      Unblocks a connection by its client id.
     |      If ``error`` is True, unblocks the client with a special error message.
     |      If ``error`` is False (default), the client is unblocked using the
     |      regular timeout mechanism.
     |
     |      For more information, see https://redis.io/commands/client-unblock
     |
     |  client_unpause(self, **kwargs) -> 'bytes | str | Awaitable[bytes | str]'
     |      Unpause all redis clients
     |
     |      For more information, see https://redis.io/commands/client-unpause
     |
     |  command(self, **kwargs) -> 'dict[str, dict[str, Any]] | Awaitable[dict[str, dict[str, Any]]]'
     |      Returns dict reply of details about all Redis commands.
     |
     |      For more information, see https://redis.io/commands/command
     |
     |  command_count(self, **kwargs) -> 'int | Awaitable[int]'
     |
     |  command_docs(self, *args)
     |      This function throws a NotImplementedError since it is intentionally
     |      not supported.
     |
     |  command_getkeysandflags(self, *args: 'str') -> 'CommandGetKeysAndFlagsResponse | Awaitable[CommandGetKeysAndFlagsResponse]'
     |      Returns array of keys from a full Redis command and their usage flags.
     |
     |      For more information, see https://redis.io/commands/command-getkeysandflags
     |
     |  command_list(self, module: 'str | None' = None, category: 'str | None' = None, pattern: 'str | None' = None) -> 'list[bytes | str] | Awaitable[list[bytes | str]]'
     |      Return an array of the server's command names.
     |      You can use one of the following filters:
     |      ``module``: get the commands that belong to the module
     |      ``category``: get the commands in the ACL category
     |      ``pattern``: get the commands that match the given pattern
     |
     |      For more information, see https://redis.io/commands/command-list/
     |
     |  config_get(self, pattern: 'PatternT' = '*', *args: 'PatternT', **kwargs) -> 'dict[str | None, str | None] | Awaitable[dict[str | None, str | None]]'
     |      Return a dictionary of configuration based on the ``pattern``
     |
     |      For more information, see https://redis.io/commands/config-get
     |
     |  config_resetstat(self, **kwargs) -> 'bool | Awaitable[bool]'
     |      Reset runtime statistics
     |
     |      For more information, see https://redis.io/commands/config-resetstat
     |
     |  config_rewrite(self, **kwargs) -> 'bytes | str | Awaitable[bytes | str]'
     |      Rewrite config file with the minimal change to reflect running config.
     |
     |      For more information, see https://redis.io/commands/config-rewrite
     |
     |  config_set(self, name: 'KeyT', value: 'EncodableT', *args: 'Union[KeyT, EncodableT]', **kwargs) -> 'bool | Awaitable[bool]'
     |      Set config item ``name`` with ``value``
     |
     |      For more information, see https://redis.io/commands/config-set
     |
     |  dbsize(self, **kwargs) -> 'int | Awaitable[int]'
     |      Returns the number of keys in the current database
     |
     |      For more information, see https://redis.io/commands/dbsize
     |
     |  debug_object(self, key: 'KeyT', **kwargs) -> 'dict[str, str | int] | bytes | str | Awaitable[dict[str, str | int] | bytes | str]'
     |      Returns version specific meta information about a given key
     |
     |      For more information, see https://redis.io/commands/debug-object
     |
     |  echo(self, value: 'EncodableT', **kwargs) -> 'bytes | str | Awaitable[bytes | str]'
     |      Echo the string back from the server
     |
     |      For more information, see https://redis.io/commands/echo
     |
     |  failover(self)
     |      This function throws a NotImplementedError since it is intentionally
     |      not supported.
     |
     |  flushall(self, asynchronous: 'bool' = False, **kwargs) -> 'bool | Awaitable[bool]'
     |      Delete all keys in all databases on the current host.
     |
     |      ``asynchronous`` indicates whether the operation is
     |      executed asynchronously by the server.
     |
     |      For more information, see https://redis.io/commands/flushall
     |
     |  flushdb(self, asynchronous: 'bool' = False, **kwargs) -> 'bool | Awaitable[bool]'
     |      Delete all keys in the current database.
     |
     |      ``asynchronous`` indicates whether the operation is
     |      executed asynchronously by the server.
     |
     |      For more information, see https://redis.io/commands/flushdb
     |
     |  hello(self)
     |      This function throws a NotImplementedError since it is intentionally
     |      not supported.
     |
     |  info(self, section: 'Optional[str]' = None, *args: 'str', **kwargs) -> 'dict[str, Any] | Awaitable[dict[str, Any]]'
     |      Returns a dictionary containing information about the Redis server
     |
     |      The ``section`` option can be used to select a specific section
     |      of information
     |
     |      The section option is not supported by older versions of Redis Server,
     |      and will generate ResponseError
     |
     |      For more information, see https://redis.io/commands/info
     |
     |  lastsave(self, **kwargs) -> 'datetime.datetime | Awaitable[datetime.datetime]'
     |      Return a Python datetime object representing the last time the
     |      Redis database was saved to disk
     |
     |      For more information, see https://redis.io/commands/lastsave
     |
     |  latency_doctor(self)
     |      Raise a NotImplementedError, as the client will not support LATENCY DOCTOR.
     |      This function is best used within the redis-cli.
     |
     |      For more information, see https://redis.io/commands/latency-doctor
     |
     |  latency_graph(self)
     |      Raise a NotImplementedError, as the client will not support LATENCY GRAPH.
     |      This function is best used within the redis-cli.
     |
     |      For more information, see https://redis.io/commands/latency-graph.
     |
     |  latency_histogram(self, *args)
     |      This function throws a NotImplementedError since it is intentionally
     |      not supported.
     |
     |  latency_history(self, event: 'str') -> 'list[list[int]] | Awaitable[list[list[int]]]'
     |      Returns the raw data of the ``event``'s latency spikes time series.
     |
     |      For more information, see https://redis.io/commands/latency-history
     |
     |  latency_latest(self) -> 'list[list[bytes | str | int]] | Awaitable[list[list[bytes | str | int]]]'
     |      Reports the latest latency events logged.
     |
     |      For more information, see https://redis.io/commands/latency-latest
     |
     |  latency_reset(self, *events: 'str') -> 'int | Awaitable[int]'
     |      Resets the latency spikes time series of all, or only some, events.
     |
     |      For more information, see https://redis.io/commands/latency-reset
     |
     |  lolwut(self, *version_numbers: 'Union[str, float]', **kwargs) -> 'bytes | str | Awaitable[bytes | str]'
     |      Get the Redis version and a piece of generative computer art
     |
     |      See: https://redis.io/commands/lolwut
     |
     |  memory_malloc_stats(self, **kwargs) -> 'bytes | str | Awaitable[bytes | str]'
     |      Return an internal statistics report from the memory allocator.
     |
     |      See: https://redis.io/commands/memory-malloc-stats
     |
     |  memory_purge(self, **kwargs) -> 'bool | Awaitable[bool]'
     |      Attempts to purge dirty pages for reclamation by allocator
     |
     |      For more information, see https://redis.io/commands/memory-purge
     |
     |  memory_stats(self, **kwargs) -> 'dict[str, Any] | Awaitable[dict[str, Any]]'
     |      Return a dictionary of memory stats
     |
     |      For more information, see https://redis.io/commands/memory-stats
     |
     |  memory_usage(self, key: 'KeyT', samples: 'int | None' = None, **kwargs) -> 'int | None | Awaitable[int | None]'
     |      Return the total memory usage for key, its value and associated
     |      administrative overheads.
     |
     |      For nested data structures, ``samples`` is the number of elements to
     |      sample. If left unspecified, the server's default is 5. Use 0 to sample
     |      all elements.
     |
     |      For more information, see https://redis.io/commands/memory-usage
     |
     |  migrate(self, host: 'str', port: 'int', keys: 'KeysT', destination_db: 'int', timeout: 'int', copy: 'bool' = False, replace: 'bool' = False, auth: 'str | None' = None, **kwargs) -> 'bytes | str | Awaitable[bytes | str]'
     |      Migrate 1 or more keys from the current Redis server to a different
     |      server specified by the ``host``, ``port`` and ``destination_db``.
     |
     |      The ``timeout``, specified in milliseconds, indicates the maximum
     |      time the connection between the two servers can be idle before the
     |      command is interrupted.
     |
     |      If ``copy`` is True, the specified ``keys`` are NOT deleted from
     |      the source server.
     |
     |      If ``replace`` is True, this operation will overwrite the keys
     |      on the destination server if they exist.
     |
     |      If ``auth`` is specified, authenticate to the destination server with
     |      the password provided.
     |
     |      For more information, see https://redis.io/commands/migrate
     |
     |  object(self, infotype: 'str', key: 'KeyT', **kwargs) -> 'Any | Awaitable[Any]'
     |      Return the encoding, idletime, or refcount about the key
     |
     |  ping(self, **kwargs) -> 'Union[Awaitable[bool], bool]'
     |      Ping the Redis server to test connectivity.
     |
     |      Sends a PING command to the Redis server and returns True if the server
     |      responds with "PONG".
     |
     |      This command is useful for:
     |      - Testing whether a connection is still alive
     |      - Verifying the server's ability to serve data
     |
     |      For more information on the underlying ping command see https://redis.io/commands/ping
     |
     |  psync(self, replicationid: 'str', offset: 'int') -> 'bytes | Awaitable[bytes]'
     |      Initiates a replication stream from the master.
     |      Newer version for `sync`.
     |
     |      For more information, see https://redis.io/commands/sync
     |
     |  quit(self, **kwargs) -> 'bool | Awaitable[bool]'
     |      Ask the server to close the connection.
     |
     |      For more information, see https://redis.io/commands/quit
     |
     |  reset(self) -> 'bytes | str | Awaitable[bytes | str]'
     |      Perform a full reset on the connection's server-side context.
     |
     |      See: https://redis.io/commands/reset
     |
     |  role(self) -> 'list[Any] | Awaitable[list[Any]]'
     |      Provide information on the role of a Redis instance in
     |      the context of replication, by returning if the instance
     |      is currently a master, slave, or sentinel.
     |
     |      For more information, see https://redis.io/commands/role
     |
     |  save(self, **kwargs) -> 'bool | Awaitable[bool]'
     |      Tell the Redis server to save its data to disk,
     |      blocking until the save is complete
     |
     |      For more information, see https://redis.io/commands/save
     |
     |  select(self, index: 'int', **kwargs) -> 'bool | Awaitable[bool]'
     |      Select the Redis logical database at index.
     |
     |      See: https://redis.io/commands/select
     |
     |  slowlog_get(self, num: 'int | None' = None, **kwargs) -> 'list[dict[str, Any]] | Awaitable[list[dict[str, Any]]]'
     |      Get the entries from the slowlog. If ``num`` is specified, get the
     |      most recent ``num`` items.
     |
     |      For more information, see https://redis.io/commands/slowlog-get
     |
     |  slowlog_len(self, **kwargs) -> 'int | Awaitable[int]'
     |      Get the number of items in the slowlog
     |
     |      For more information, see https://redis.io/commands/slowlog-len
     |
     |  slowlog_reset(self, **kwargs) -> 'bool | Awaitable[bool]'
     |      Remove all items in the slowlog
     |
     |      For more information, see https://redis.io/commands/slowlog-reset
     |
     |  sync(self) -> 'bytes | Awaitable[bytes]'
     |      Initiates a replication stream from the master.
     |
     |      For more information, see https://redis.io/commands/sync
     |
     |  time(self, **kwargs) -> 'tuple[int, int] | Awaitable[tuple[int, int]]'
     |      Returns the server time as a 2-item tuple of ints:
     |      (seconds since epoch, microseconds into this second).
     |
     |      For more information, see https://redis.io/commands/time
     |
     |  wait(self, num_replicas: 'int', timeout: 'int', **kwargs) -> 'int | Awaitable[int]'
     |      Redis synchronous replication
     |      That returns the number of replicas that processed the query when
     |      we finally have at least ``num_replicas``, or when the ``timeout`` was
     |      reached.
     |
     |      For more information, see https://redis.io/commands/wait
     |
     |  waitaof(self, num_local: 'int', num_replicas: 'int', timeout: 'int', **kwargs) -> 'list[int] | Awaitable[list[int]]'
     |      This command blocks the current client until all previous write
     |      commands by that client are acknowledged as having been fsynced
     |      to the AOF of the local Redis and/or at least the specified number
     |      of replicas.
     |
     |      For more information, see https://redis.io/commands/waitaof
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from redis.commands.core.ACLCommands:
     |
     |  acl_cat(self, category: 'str | None' = None, **kwargs) -> 'list[bytes | str] | Awaitable[list[bytes | str]]'
     |      Returns a list of categories or commands within a category.
     |
     |      If ``category`` is not supplied, returns a list of all categories.
     |      If ``category`` is supplied, returns a list of all commands within
     |      that category.
     |
     |      For more information, see https://redis.io/commands/acl-cat
     |
     |  acl_deluser(self, *username: 'str', **kwargs) -> 'int | Awaitable[int]'
     |      Delete the ACL for the specified ``username``\s
     |
     |      For more information, see https://redis.io/commands/acl-deluser
     |
     |  acl_dryrun(self, username: 'str', *args: 'EncodableT', **kwargs) -> 'bytes | str | Awaitable[bytes | str]'
     |      Simulate the execution of a given command by a given ``username``.
     |
     |      For more information, see https://redis.io/commands/acl-dryrun
     |
     |  acl_genpass(self, bits: 'int | None' = None, **kwargs) -> 'bytes | str | Awaitable[bytes | str]'
     |      Generate a random password value.
     |      If ``bits`` is supplied then use this number of bits, rounded to
     |      the next multiple of 4.
     |      See: https://redis.io/commands/acl-genpass
     |
     |  acl_getuser(self, username: 'str', **kwargs) -> 'ACLGetUserData | Awaitable[ACLGetUserData]'
     |      Get the ACL details for the specified ``username``.
     |
     |      If ``username`` does not exist, return None
     |
     |      For more information, see https://redis.io/commands/acl-getuser
     |
     |  acl_help(self, **kwargs) -> 'list[bytes | str] | Awaitable[list[bytes | str]]'
     |      The ACL HELP command returns helpful text describing
     |      the different subcommands.
     |
     |      For more information, see https://redis.io/commands/acl-help
     |
     |  acl_list(self, **kwargs) -> 'list[bytes | str] | Awaitable[list[bytes | str]]'
     |      Return a list of all ACLs on the server
     |
     |      For more information, see https://redis.io/commands/acl-list
     |
     |  acl_load(self, **kwargs) -> 'bool | Awaitable[bool]'
     |      Load ACL rules from the configured ``aclfile``.
     |
     |      Note that the server must be configured with the ``aclfile``
     |      directive to be able to load ACL rules from an aclfile.
     |
     |      For more information, see https://redis.io/commands/acl-load
     |
     |  acl_log(self, count: 'int | None' = None, **kwargs) -> 'ACLLogData | Awaitable[ACLLogData]'
     |      Get ACL logs as a list.
     |      :param int count: Get logs[0:count].
     |      :rtype: List.
     |
     |      For more information, see https://redis.io/commands/acl-log
     |
     |  acl_log_reset(self, **kwargs) -> 'bool | Awaitable[bool]'
     |      Reset ACL logs.
     |      :rtype: Boolean.
     |
     |      For more information, see https://redis.io/commands/acl-log
     |
     |  acl_save(self, **kwargs) -> 'bool | Awaitable[bool]'
     |      Save ACL rules to the configured ``aclfile``.
     |
     |      Note that the server must be configured with the ``aclfile``
     |      directive to be able to save ACL rules to an aclfile.
     |
     |      For more information, see https://redis.io/commands/acl-save
     |
     |  acl_setuser(self, username: 'str', enabled: 'bool' = False, nopass: 'bool' = False, passwords: 'str | Iterable[str] | None' = None, hashed_passwords: 'str | Iterable[str] | None' = None, categories: 'Iterable[str] | None' = None, commands: 'Iterable[str] | None' = None, keys: 'Iterable[KeyT] | None' = None, channels: 'Iterable[ChannelT] | None' = None, selectors: 'Iterable[Tuple[str, KeyT]] | None' = None, reset: 'bool' = False, reset_keys: 'bool' = False, reset_channels: 'bool' = False, reset_passwords: 'bool' = False, **kwargs) -> 'bool | Awaitable[bool]'
     |      Create or update an ACL user.
     |
     |      Create or update the ACL for `username`. If the user already exists,
     |      the existing ACL is completely overwritten and replaced with the
     |      specified values.
     |
     |      For more information, see https://redis.io/commands/acl-setuser
     |
     |      Args:
     |          username: The name of the user whose ACL is to be created or updated.
     |          enabled: Indicates whether the user should be allowed to authenticate.
     |                   Defaults to `False`.
     |          nopass: Indicates whether the user can authenticate without a password.
     |                  This cannot be `True` if `passwords` are also specified.
     |          passwords: A list of plain text passwords to add to or remove from the user.
     |                     Each password must be prefixed with a '+' to add or a '-' to
     |                     remove. For convenience, a single prefixed string can be used
     |                     when adding or removing a single password.
     |          hashed_passwords: A list of SHA-256 hashed passwords to add to or remove
     |                            from the user. Each hashed password must be prefixed with
     |                            a '+' to add or a '-' to remove. For convenience, a single
     |                            prefixed string can be used when adding or removing a
     |                            single password.
     |          categories: A list of strings representing category permissions. Each string
     |                      must be prefixed with either a '+' to add the category
     |                      permission or a '-' to remove the category permission.
     |          commands: A list of strings representing command permissions. Each string
     |                    must be prefixed with either a '+' to add the command permission
     |                    or a '-' to remove the command permission.
     |          keys: A list of key patterns to grant the user access to. Key patterns allow
     |                ``'*'`` to support wildcard matching. For example, ``'*'`` grants
     |                access to all keys while ``'cache:*'`` grants access to all keys that
     |                are prefixed with ``cache:``.
     |                `keys` should not be prefixed with a ``'~'``.
     |          reset: Indicates whether the user should be fully reset prior to applying
     |                 the new ACL. Setting this to `True` will remove all existing
     |                 passwords, flags, and privileges from the user and then apply the
     |                 specified rules. If `False`, the user's existing passwords, flags,
     |                 and privileges will be kept and any new specified rules will be
     |                 applied on top.
     |          reset_keys: Indicates whether the user's key permissions should be reset
     |                      prior to applying any new key permissions specified in `keys`.
     |                      If `False`, the user's existing key permissions will be kept and
     |                      any new specified key permissions will be applied on top.
     |          reset_channels: Indicates whether the user's channel permissions should be
     |                          reset prior to applying any new channel permissions
     |                          specified in `channels`. If `False`, the user's existing
     |                          channel permissions will be kept and any new specified
     |                          channel permissions will be applied on top.
     |          reset_passwords: Indicates whether to remove all existing passwords and the
     |                           `nopass` flag from the user prior to applying any new
     |                           passwords specified in `passwords` or `hashed_passwords`.
     |                           If `False`, the user's existing passwords and `nopass`
     |                           status will be kept and any new specified passwords or
     |                           hashed passwords will be applied on top.
     |
     |  acl_users(self, **kwargs) -> 'list[bytes | str] | Awaitable[list[bytes | str]]'
     |      Returns a list of all registered users on the server.
     |
     |      For more information, see https://redis.io/commands/acl-users
     |
     |  acl_whoami(self, **kwargs) -> 'bytes | str | Awaitable[bytes | str]'
     |      Get the username for the current connection
     |
     |      For more information, see https://redis.io/commands/acl-whoami
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from redis.commands.core.PubSubCommands:
     |
     |  publish(self, channel: 'ChannelT', message: 'EncodableT', **kwargs) -> 'int | Awaitable[int]'
     |      Publish ``message`` on ``channel``.
     |      Returns the number of subscribers the message was delivered to.
     |
     |      For more information, see https://redis.io/commands/publish
     |
     |  pubsub_channels(self, pattern: 'PatternT' = '*', **kwargs) -> 'list[bytes | str] | Awaitable[list[bytes | str]]'
     |      Return a list of channels that have at least one subscriber
     |
     |      For more information, see https://redis.io/commands/pubsub-channels
     |
     |  pubsub_numpat(self, **kwargs) -> 'int | Awaitable[int]'
     |      Returns the number of subscriptions to patterns
     |
     |      For more information, see https://redis.io/commands/pubsub-numpat
     |
     |  pubsub_numsub(self, *args: 'ChannelT', **kwargs) -> 'list[tuple[bytes | str, int]] | Awaitable[list[tuple[bytes | str, int]]]'
     |      Return a list of (channel, number of subscribers) tuples
     |      for each channel given in ``*args``
     |
     |      For more information, see https://redis.io/commands/pubsub-numsub
     |
     |  pubsub_shardchannels(self, pattern: 'PatternT' = '*', **kwargs) -> 'list[bytes | str] | Awaitable[list[bytes | str]]'
     |      Return a list of shard_channels that have at least one subscriber
     |
     |      For more information, see https://redis.io/commands/pubsub-shardchannels
     |
     |  pubsub_shardnumsub(self, *args: 'ChannelT', **kwargs) -> 'list[tuple[bytes | str, int]] | Awaitable[list[tuple[bytes | str, int]]]'
     |      Return a list of (shard_channel, number of subscribers) tuples
     |      for each channel given in ``*args``
     |
     |      For more information, see https://redis.io/commands/pubsub-shardnumsub
     |
     |  spublish(self, shard_channel: 'ChannelT', message: 'EncodableT') -> 'int | Awaitable[int]'
     |      Posts a message to the given shard channel.
     |      Returns the number of clients that received the message
     |
     |      For more information, see https://redis.io/commands/spublish
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from redis.commands.cluster.AsyncClusterDataAccessCommands:
     |
     |  async scan_iter(self, match: 'PatternT | None' = None, count: 'int | None' = None, _type: 'str | None' = None, **kwargs) -> 'AsyncIterator'
     |      Make an iterator using the SCAN command so that the client doesn't
     |      need to remember the cursor position.
     |
     |      ``match`` allows for filtering the keys by pattern
     |
     |      ``count`` provides a hint to Redis about the number of keys to
     |          return per batch.
     |
     |      ``_type`` filters the returned values by a particular Redis type.
     |          Stock Redis instances allow for the following types:
     |          HASH, LIST, SET, STREAM, STRING, ZSET
     |          Additionally, Redis modules can expose other types as well.
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from redis.commands.cluster.ClusterDataAccessCommands:
     |
     |  stralgo(self, algo: "Literal['LCS']", value1: 'KeyT', value2: 'KeyT', specific_argument: "Literal['strings'] | Literal['keys']" = 'strings', len: 'bool' = False, idx: 'bool' = False, minmatchlen: 'int | None' = None, withmatchlen: 'bool' = False, **kwargs) -> 'StralgoResponse | Awaitable[StralgoResponse]'
     |      Implements complex algorithms that operate on strings.
     |      Right now the only algorithm implemented is the LCS algorithm
     |      (longest common substring). However new algorithms could be
     |      implemented in the future.
     |
     |      ``algo`` Right now must be LCS
     |      ``value1`` and ``value2`` Can be two strings or two keys
     |      ``specific_argument`` Specifying if the arguments to the algorithm
     |      will be keys or strings. strings is the default.
     |      ``len`` Returns just the len of the match.
     |      ``idx`` Returns the match positions in each string.
     |      ``minmatchlen`` Restrict the list of matches to the ones of a given
     |      minimal length. Can be provided only when ``idx`` set to True.
     |      ``withmatchlen`` Returns the matches with the len of the match.
     |      Can be provided only when ``idx`` set to True.
     |
     |      For more information see https://redis.io/commands/stralgo
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from redis.commands.core.AsyncBasicKeyCommands:
     |
     |  __contains__(self, name: 'KeyT')
     |      Returns the number of ``names`` that exist
     |
     |      For more information, see https://redis.io/commands/exists
     |
     |  __delitem__(self, name: 'KeyT')
     |
     |  __getitem__(self, name: 'KeyT')
     |      Return the value at key ``name``, raises a KeyError if the key
     |      doesn't exist.
     |
     |  __setitem__(self, name: 'KeyT', value: 'EncodableT')
     |
     |  async unwatch(self) -> 'None'
     |      Unwatches all previously watched keys for a transaction
     |
     |      For more information, see https://redis.io/commands/unwatch
     |
     |  async watch(self, *names: 'KeyT') -> 'None'
     |      Watches the values at keys ``names``, or None if the key doesn't exist
     |
     |      For more information, see https://redis.io/commands/watch
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from redis.commands.core.BasicKeyCommands:
     |
     |  append(self, key: 'KeyT', value: 'EncodableT') -> 'int | Awaitable[int]'
     |      Appends the string ``value`` to the value at ``key``. If ``key``
     |      doesn't already exist, create it with a value of ``value``.
     |      Returns the new length of the value at ``key``.
     |
     |      For more information, see https://redis.io/commands/append
     |
     |  bitcount(self, key: 'KeyT', start: 'int | None' = None, end: 'int | None' = None, mode: 'str | None' = None) -> 'int | Awaitable[int]'
     |      Returns the count of set bits in the value of ``key``.  Optional
     |      ``start`` and ``end`` parameters indicate which bytes to consider
     |
     |      For more information, see https://redis.io/commands/bitcount
     |
     |  bitfield(self: "Union['redis.client.Redis', 'redis.asyncio.client.Redis']", key: 'KeyT', default_overflow: 'str | None' = None) -> 'BitFieldOperation'
     |      Return a BitFieldOperation instance to conveniently construct one or
     |      more bitfield operations on ``key``.
     |
     |      For more information, see https://redis.io/commands/bitfield
     |
     |  bitfield_ro(self: "Union['redis.client.Redis', 'redis.asyncio.client.Redis']", key: 'KeyT', encoding: 'str', offset: 'BitfieldOffsetT', items: 'list[tuple[str, BitfieldOffsetT]] | None' = None) -> 'list[int] | Awaitable[list[int]]'
     |      Return an array of the specified bitfield values
     |      where the first value is found using ``encoding`` and ``offset``
     |      parameters and remaining values are result of corresponding
     |      encoding/offset pairs in optional list ``items``
     |      Read-only variant of the BITFIELD command.
     |
     |      For more information, see https://redis.io/commands/bitfield_ro
     |
     |  bitop(self, operation: 'str', dest: 'KeyT', *keys: 'KeyT') -> 'int | Awaitable[int]'
     |      Perform a bitwise operation using ``operation`` between ``keys`` and
     |      store the result in ``dest``.
     |
     |      For more information, see https://redis.io/commands/bitop
     |
     |  bitpos(self, key: 'KeyT', bit: 'int', start: 'int | None' = None, end: 'int | None' = None, mode: 'str | None' = None) -> 'int | Awaitable[int]'
     |      Return the position of the first bit set to 1 or 0 in a string.
     |      ``start`` and ``end`` defines search range. The range is interpreted
     |      as a range of bytes and not a range of bits, so start=0 and end=2
     |      means to look at the first three bytes.
     |
     |      For more information, see https://redis.io/commands/bitpos
     |
     |  blmove(self, first_list: 'str', second_list: 'str', timeout: 'int', src: 'str' = 'LEFT', dest: 'str' = 'RIGHT') -> 'bytes | str | None | Awaitable[bytes | str | None]'
     |      Blocking version of lmove.
     |
     |      For more information, see https://redis.io/commands/blmove
     |
     |  blmovem(self, first_list: 'str', second_list: 'str', timeout: 'float', src: 'str' = 'LEFT', dest: 'str' = 'RIGHT', count: 'int | None' = None, mode: "Literal['COUNT', 'EXACTLY'] | None" = None, ordering: "Literal['OBO', 'BULK'] | None" = None) -> 'list[bytes | str] | None | Awaitable[list[bytes | str] | None]'
     |      Blocking version of lmovem.
     |
     |      Blocks until elements are available to move or ``timeout`` (in seconds)
     |      is reached; a ``timeout`` of ``0`` blocks indefinitely. With ``COUNT``
     |      the command unblocks once at least one element is available and moves
     |      ``min(count, available)``; with ``EXACTLY`` it blocks until the source
     |      holds at least ``count`` elements, then moves exactly ``count``
     |      atomically. On timeout ``None`` is returned and nothing is moved.
     |
     |      As with ``lmovem``, ``ordering`` (OBO or BULK) is required whenever
     |      ``count`` is given.
     |
     |      For more information, see https://redis.io/commands/blmovem
     |
     |  copy(self, source: 'str', destination: 'str', destination_db: 'str | None' = None, replace: 'bool' = False) -> 'bool | Awaitable[bool]'
     |      Copy the value stored in the ``source`` key to the ``destination`` key.
     |
     |      ``destination_db`` an alternative destination database. By default,
     |      the ``destination`` key is created in the source Redis database.
     |
     |      ``replace`` whether the ``destination`` key should be removed before
     |      copying the value to it. By default, the value is not copied if
     |      the ``destination`` key already exists.
     |
     |      For more information, see https://redis.io/commands/copy
     |
     |  decr = decrby(self, name: 'KeyT', amount: 'int' = 1) -> 'int | Awaitable[int]'
     |
     |  decrby(self, name: 'KeyT', amount: 'int' = 1) -> 'int | Awaitable[int]'
     |      Decrements the value of ``key`` by ``amount``.  If no key exists,
     |      the value will be initialized as 0 - ``amount``
     |
     |      For more information, see https://redis.io/commands/decrby
     |
     |  delex(self, name: 'KeyT', ifeq: 'bytes | str | None' = None, ifne: 'bytes | str | None' = None, ifdeq: 'str | None' = None, ifdne: 'str | None' = None) -> 'int | Awaitable[int]'
     |      Conditionally removes the specified key.
     |
     |      Warning:
     |      **Experimental** since 7.1.
     |      This API may change or be removed without notice.
     |      The API may change based on feedback.
     |
     |      Arguments:
     |          name: KeyT - the key to delete
     |          ifeq match-valu: Optional[Union[bytes, str]] - Delete the key only if its value is equal to match-value
     |          ifne match-value: Optional[Union[bytes, str]] - Delete the key only if its value is not equal to match-value
     |          ifdeq match-digest: Optional[str] - Delete the key only if the digest of its value is equal to match-digest
     |          ifdne match-digest: Optional[str] - Delete the key only if the digest of its value is not equal to match-digest
     |
     |      Returns:
     |          int: 1 if the key was deleted, 0 otherwise.
     |      Raises:
     |          redis.exceptions.ResponseError: if key exists but is not a string
     |                                          and a condition is specified.
     |          ValueError: if more than one condition is provided.
     |
     |
     |      Requires Redis 8.4 or greater.
     |      For more information, see https://redis.io/commands/delex
     |
     |  digest(self, name: 'KeyT') -> 'str | bytes | None | Awaitable[str | bytes | None]'
     |      Return the digest of the value stored at the specified key.
     |
     |      Warning:
     |      **Experimental** since 7.1.
     |      This API may change or be removed without notice.
     |      The API may change based on feedback.
     |
     |      Arguments:
     |        - name: KeyT - the key to get the digest of
     |
     |      Returns:
     |        - None if the key does not exist
     |        - (bulk string) the XXH3 digest of the value as a hex string
     |      Raises:
     |        - ResponseError if key exists but is not a string
     |
     |
     |      Requires Redis 8.4 or greater.
     |      For more information, see https://redis.io/commands/digest
     |
     |  digest_local(self, value: 'bytes | str') -> 'bytes | str'
     |      Compute the hexadecimal digest of the value locally, without sending it to the server.
     |
     |      This is useful for conditional operations like IFDEQ/IFDNE where you need to
     |      compute the digest client-side before sending a command.
     |
     |      Warning:
     |      **Experimental** - This API may change or be removed without notice.
     |
     |      Arguments:
     |        - value: Union[bytes, str] - the value to compute the digest of.
     |          If a string is provided, it will be encoded using UTF-8 before hashing,
     |          which matches Redis's default encoding behavior.
     |
     |      Returns:
     |        - (str | bytes) the XXH3 digest of the value as a hex string (16 hex characters).
     |          Returns bytes if decode_responses is False, otherwise returns str.
     |
     |      For more information, see https://redis.io/commands/digest
     |
     |  dump(self, name: 'KeyT') -> 'bytes | None | Awaitable[bytes | None]'
     |      Return a serialized version of the value stored at the specified key.
     |      If key does not exist a nil bulk reply is returned.
     |
     |      For more information, see https://redis.io/commands/dump
     |
     |  expire(self, name: 'KeyT', time: 'ExpiryT', nx: 'bool' = False, xx: 'bool' = False, gt: 'bool' = False, lt: 'bool' = False) -> 'bool | Awaitable[bool]'
     |      Set an expire flag on key ``name`` for ``time`` seconds with given
     |      ``option``. ``time`` can be represented by an integer or a Python timedelta
     |      object.
     |
     |      Valid options are:
     |          NX -> Set expiry only when the key has no expiry
     |          XX -> Set expiry only when the key has an existing expiry
     |          GT -> Set expiry only when the new expiry is greater than current one
     |          LT -> Set expiry only when the new expiry is less than current one
     |
     |      For more information, see https://redis.io/commands/expire
     |
     |  expireat(self, name: 'KeyT', when: 'AbsExpiryT', nx: 'bool' = False, xx: 'bool' = False, gt: 'bool' = False, lt: 'bool' = False) -> 'bool | Awaitable[bool]'
     |      Set an expire flag on key ``name`` with given ``option``. ``when``
     |      can be represented as an integer indicating unix time or a Python
     |      datetime object.
     |
     |      Valid options are:
     |          -> NX -- Set expiry only when the key has no expiry
     |          -> XX -- Set expiry only when the key has an existing expiry
     |          -> GT -- Set expiry only when the new expiry is greater than current one
     |          -> LT -- Set expiry only when the new expiry is less than current one
     |
     |      For more information, see https://redis.io/commands/expireat
     |
     |  expiretime(self, key: 'str') -> 'int | Awaitable[int]'
     |      Returns the absolute Unix timestamp (since January 1, 1970) in seconds
     |      at which the given key will expire.
     |
     |      For more information, see https://redis.io/commands/expiretime
     |
     |  get(self, name: 'KeyT') -> 'bytes | str | None | Awaitable[bytes | str | None]'
     |      Return the value at key ``name``, or None if the key doesn't exist
     |
     |      For more information, see https://redis.io/commands/get
     |
     |  getbit(self, name: 'KeyT', offset: 'int') -> 'int | Awaitable[int]'
     |      Returns an integer indicating the value of ``offset`` in ``name``
     |
     |      For more information, see https://redis.io/commands/getbit
     |
     |  getdel(self, name: 'KeyT') -> 'bytes | str | None | Awaitable[bytes | str | None]'
     |      Get the value at key ``name`` and delete the key. This command
     |      is similar to GET, except for the fact that it also deletes
     |      the key on success (if and only if the key's value type
     |      is a string).
     |
     |      For more information, see https://redis.io/commands/getdel
     |
     |  getex(self, name: 'KeyT', ex: 'ExpiryT | None' = None, px: 'ExpiryT | None' = None, exat: 'AbsExpiryT | None' = None, pxat: 'AbsExpiryT | None' = None, persist: 'bool' = False) -> 'bytes | str | None | Awaitable[bytes | str | None]'
     |      Get the value of key and optionally set its expiration.
     |      GETEX is similar to GET, but is a write command with
     |      additional options. All time parameters can be given as
     |      datetime.timedelta or integers.
     |
     |      ``ex`` sets an expire flag on key ``name`` for ``ex`` seconds.
     |
     |      ``px`` sets an expire flag on key ``name`` for ``px`` milliseconds.
     |
     |      ``exat`` sets an expire flag on key ``name`` for ``ex`` seconds,
     |      specified in unix time.
     |
     |      ``pxat`` sets an expire flag on key ``name`` for ``ex`` milliseconds,
     |      specified in unix time.
     |
     |      ``persist`` remove the time to live associated with ``name``.
     |
     |      For more information, see https://redis.io/commands/getex
     |
     |  getrange(self, key: 'KeyT', start: 'int', end: 'int') -> 'bytes | str | Awaitable[bytes | str]'
     |      Returns the substring of the string value stored at ``key``,
     |      determined by the offsets ``start`` and ``end`` (both are inclusive)
     |
     |      For more information, see https://redis.io/commands/getrange
     |
     |  getset(self, name: 'KeyT', value: 'EncodableT') -> 'bytes | str | None | Awaitable[bytes | str | None]'
     |      Sets the value at key ``name`` to ``value``
     |      and returns the old value at key ``name`` atomically.
     |
     |      As per Redis 6.2, GETSET is considered deprecated.
     |      Please use SET with GET parameter in new code.
     |
     |      For more information, see https://redis.io/commands/getset
     |
     |  hrandfield(self, key: 'KeyT', count: 'int | None' = None, withvalues: 'bool' = False) -> 'HRandFieldResponse | Awaitable[HRandFieldResponse]'
     |      Return a random field from the hash value stored at key.
     |
     |      count: if the argument is positive, return an array of distinct fields.
     |      If called with a negative count, the behavior changes and the command
     |      is allowed to return the same field multiple times. In this case,
     |      the number of returned fields is the absolute value of the
     |      specified count.
     |      withvalues: The optional WITHVALUES modifier changes the reply so it
     |      includes the respective values of the randomly selected hash fields.
     |
     |      For more information, see https://redis.io/commands/hrandfield
     |
     |  incr = incrby(self, name: 'KeyT', amount: 'int' = 1) -> 'int | Awaitable[int]'
     |
     |  incrby(self, name: 'KeyT', amount: 'int' = 1) -> 'int | Awaitable[int]'
     |      Increments the value of ``key`` by ``amount``.  If no key exists,
     |      the value will be initialized as ``amount``
     |
     |      For more information, see https://redis.io/commands/incrby
     |
     |  incrbyfloat(self, name: 'KeyT', amount: 'float' = 1.0) -> 'float | Awaitable[float]'
     |      Increments the value at key ``name`` by floating ``amount``.
     |      If no key exists, the value will be initialized as ``amount``
     |
     |      For more information, see https://redis.io/commands/incrbyfloat
     |
     |  increx(self, name: 'KeyT', *, byfloat: 'EncodableT | None' = None, byint: 'EncodableT | None' = None, lbound: 'EncodableT | None' = None, ubound: 'EncodableT | None' = None, saturate: 'bool' = False, ex: 'ExpiryT | None' = None, px: 'ExpiryT | None' = None, exat: 'AbsExpiryT | None' = None, pxat: 'AbsExpiryT | None' = None, persist: 'bool' = False, enx: 'bool' = False) -> 'list[Number | bytes | str] | Awaitable[list[Number | bytes | str]]'
     |      Increment the numeric value at key ``name`` and return the new value
     |      and the actual increment.
     |
     |      ``byfloat`` increments a floating point value by the provided amount.
     |
     |      ``byint`` increments an integer value by the provided amount.
     |
     |      If neither ``byfloat`` nor ``byint`` is specified, the value is
     |      incremented by one.
     |
     |      ``lbound`` and ``ubound`` constrain the valid range of the result.
     |
     |      If ``saturate`` is True, out-of-bounds results are saturated to the
     |      specified bound, or to the type limit when no bound is specified.
     |      Otherwise, out-of-bounds results are rejected, leaving the value and
     |      TTL unchanged and returning the current value and zero as the actual
     |      increment.
     |
     |      ``enx`` applies the expiration only when the key does not already
     |      have an expiration, and requires ``ex``, ``px``, ``exat``, or ``pxat``.
     |
     |  keys(self, pattern: 'PatternT' = '*', **kwargs) -> 'list[bytes | str] | Awaitable[list[bytes | str]]'
     |      Returns a list of keys matching ``pattern``
     |
     |      For more information, see https://redis.io/commands/keys
     |
     |  lcs(self, key1: 'str', key2: 'str', len: 'bool | None' = False, idx: 'bool | None' = False, minmatchlen: 'int | None' = 0, withmatchlen: 'bool | None' = False) -> 'LCSCommandResponse | Awaitable[LCSCommandResponse]'
     |      Find the longest common subsequence between ``key1`` and ``key2``.
     |      If ``len`` is true the length of the match will be returned.
     |      If ``idx`` is true the match position in each strings will be returned.
     |      ``minmatchlen`` restrict the list of matches to the ones of
     |      the given ``minmatchlen``.
     |      If ``withmatchlen`` the length of the match also will be returned.
     |      For more information, see https://redis.io/commands/lcs
     |
     |  lmove(self, first_list: 'str', second_list: 'str', src: 'str' = 'LEFT', dest: 'str' = 'RIGHT') -> 'bytes | str | None | Awaitable[bytes | str | None]'
     |      Atomically returns and removes the first/last element of a list,
     |      pushing it as the first/last element on the destination list.
     |      Returns the element being popped and pushed.
     |
     |      For more information, see https://redis.io/commands/lmove
     |
     |  lmovem(self, first_list: 'str', second_list: 'str', src: 'str' = 'LEFT', dest: 'str' = 'RIGHT', count: 'int | None' = None, mode: "Literal['COUNT', 'EXACTLY'] | None" = None, ordering: "Literal['OBO', 'BULK'] | None" = None) -> 'list[bytes | str] | None | Awaitable[list[bytes | str] | None]'
     |      Atomically moves multiple elements from one end of the ``first_list``
     |      to one end of the ``second_list``, returning the moved elements in
     |      destination order.
     |
     |      ``src`` and ``dest`` are the ends to pop from / push to, either
     |      ``LEFT`` (head) or ``RIGHT`` (tail).
     |
     |      When ``count`` is given, ``mode`` selects how many elements to move:
     |      ``COUNT`` (the default) moves up to ``count`` elements, while
     |      ``EXACTLY`` moves exactly ``count`` elements or nothing at all. When
     |      ``count`` is not given a single element is moved.
     |
     |      ``ordering`` controls the order at the destination: ``OBO`` pushes each
     |      element as it is popped (reversing block order, stack semantics) while
     |      ``BULK`` preserves the original relative order (queue semantics). It is
     |      required whenever ``count`` is given.
     |
     |      Returns the array of moved elements, or ``None`` if nothing was moved.
     |
     |      For more information, see https://redis.io/commands/lmovem
     |
     |  mget(self, keys: 'KeysT', *args: 'EncodableT') -> 'list[bytes | str | None] | Awaitable[list[bytes | str | None]]'
     |      Returns a list of values ordered identically to ``keys``
     |
     |      ** Important ** When this method is used with Cluster clients, all keys
     |              must be in the same hash slot, otherwise a RedisClusterException
     |              will be raised.
     |
     |      For more information, see https://redis.io/commands/mget
     |
     |  move(self, name: 'KeyT', db: 'int') -> 'bool | Awaitable[bool]'
     |      Moves the key ``name`` to a different Redis database ``db``
     |
     |      For more information, see https://redis.io/commands/move
     |
     |  mset(self, mapping: 'Mapping[AnyKeyT, EncodableT]') -> 'bool | Awaitable[bool]'
     |      Sets key/values based on a mapping. Mapping is a dictionary of
     |      key/value pairs. Both keys and values should be strings or types that
     |      can be cast to a string via str().
     |
     |      ** Important ** When this method is used with Cluster clients, all keys
     |              must be in the same hash slot, otherwise a RedisClusterException
     |              will be raised.
     |
     |      For more information, see https://redis.io/commands/mset
     |
     |  msetex(self, mapping: 'Mapping[AnyKeyT, EncodableT]', data_persist_option: 'DataPersistOptions | None' = None, ex: 'ExpiryT | None' = None, px: 'ExpiryT | None' = None, exat: 'AbsExpiryT | None' = None, pxat: 'AbsExpiryT | None' = None, keepttl: 'bool' = False) -> 'int | Awaitable[int]'
     |      Sets key/values based on the provided ``mapping`` items.
     |
     |      ** Important ** When this method is used with Cluster clients, all keys
     |                      must be in the same hash slot, otherwise a RedisClusterException
     |                      will be raised.
     |
     |      ``mapping`` accepts a dict of key/value pairs that will be added to the database.
     |
     |      ``data_persist_option`` can be set to ``NX`` or ``XX`` to control the
     |          behavior of the command.
     |          ``NX`` will set the value for each provided key to each
     |              provided value only if all do not already exist.
     |          ``XX`` will set the value for each provided key to each
     |              provided value only if all already exist.
     |
     |      ``ex`` sets an expire flag on the keys in ``mapping`` for ``ex`` seconds.
     |
     |      ``px`` sets an expire flag on the keys in ``mapping`` for ``px`` milliseconds.
     |
     |      ``exat`` sets an expire flag on the keys in ``mapping`` for ``exat`` seconds,
     |          specified in unix time.
     |
     |      ``pxat`` sets an expire flag on the keys in ``mapping`` for ``pxat`` milliseconds,
     |          specified in unix time.
     |
     |      ``keepttl`` if True, retain the time to live associated with the keys.
     |
     |      Returns the number of fields that were added.
     |
     |      Available since Redis 8.4
     |      For more information, see https://redis.io/commands/msetex
     |
     |  msetnx(self, mapping: 'Mapping[AnyKeyT, EncodableT]') -> 'bool | Awaitable[bool]'
     |      Sets key/values based on a mapping if none of the keys are already set.
     |      Mapping is a dictionary of key/value pairs. Both keys and values
     |      should be strings or types that can be cast to a string via str().
     |      Returns a boolean indicating if the operation was successful.
     |
     |      ** Important ** When this method is used with Cluster clients, all keys
     |                      must be in the same hash slot, otherwise a RedisClusterException
     |                      will be raised.
     |
     |      For more information, see https://redis.io/commands/msetnx
     |
     |  persist(self, name: 'KeyT') -> 'bool | Awaitable[bool]'
     |      Removes an expiration on ``name``
     |
     |      For more information, see https://redis.io/commands/persist
     |
     |  pexpire(self, name: 'KeyT', time: 'ExpiryT', nx: 'bool' = False, xx: 'bool' = False, gt: 'bool' = False, lt: 'bool' = False) -> 'bool | Awaitable[bool]'
     |      Set an expire flag on key ``name`` for ``time`` milliseconds
     |      with given ``option``. ``time`` can be represented by an
     |      integer or a Python timedelta object.
     |
     |      Valid options are:
     |          NX -> Set expiry only when the key has no expiry
     |          XX -> Set expiry only when the key has an existing expiry
     |          GT -> Set expiry only when the new expiry is greater than current one
     |          LT -> Set expiry only when the new expiry is less than current one
     |
     |      For more information, see https://redis.io/commands/pexpire
     |
     |  pexpireat(self, name: 'KeyT', when: 'AbsExpiryT', nx: 'bool' = False, xx: 'bool' = False, gt: 'bool' = False, lt: 'bool' = False) -> 'bool | Awaitable[bool]'
     |      Set an expire flag on key ``name`` with given ``option``. ``when``
     |      can be represented as an integer representing unix time in
     |      milliseconds (unix time * 1000) or a Python datetime object.
     |
     |      Valid options are:
     |          NX -> Set expiry only when the key has no expiry
     |          XX -> Set expiry only when the key has an existing expiry
     |          GT -> Set expiry only when the new expiry is greater than current one
     |          LT -> Set expiry only when the new expiry is less than current one
     |
     |      For more information, see https://redis.io/commands/pexpireat
     |
     |  pexpiretime(self, key: 'str') -> 'int | Awaitable[int]'
     |      Returns the absolute Unix timestamp (since January 1, 1970) in milliseconds
     |      at which the given key will expire.
     |
     |      For more information, see https://redis.io/commands/pexpiretime
     |
     |  psetex(self, name: 'KeyT', time_ms: 'ExpiryT', value: 'EncodableT') -> 'bool | Awaitable[bool]'
     |      Set the value of key ``name`` to ``value`` that expires in ``time_ms``
     |      milliseconds. ``time_ms`` can be represented by an integer or a Python
     |      timedelta object
     |
     |      For more information, see https://redis.io/commands/psetex
     |
     |  pttl(self, name: 'KeyT') -> 'int | Awaitable[int]'
     |      Returns the number of milliseconds until the key ``name`` will expire
     |
     |      For more information, see https://redis.io/commands/pttl
     |
     |  randomkey(self, **kwargs) -> 'bytes | str | None | Awaitable[bytes | str | None]'
     |      Returns the name of a random key
     |
     |      For more information, see https://redis.io/commands/randomkey
     |
     |  rename(self, src: 'KeyT', dst: 'KeyT') -> 'bool | Awaitable[bool]'
     |      Rename key ``src`` to ``dst``
     |
     |      For more information, see https://redis.io/commands/rename
     |
     |  renamenx(self, src: 'KeyT', dst: 'KeyT') -> 'bool | Awaitable[bool]'
     |      Rename key ``src`` to ``dst`` if ``dst`` doesn't already exist
     |
     |      For more information, see https://redis.io/commands/renamenx
     |
     |  restore(self, name: 'KeyT', ttl: 'float', value: 'EncodableT', replace: 'bool' = False, absttl: 'bool' = False, idletime: 'int | None' = None, frequency: 'int | None' = None) -> 'bytes | str | Awaitable[bytes | str]'
     |      Create a key using the provided serialized value, previously obtained
     |      using DUMP.
     |
     |      ``replace`` allows an existing key on ``name`` to be overridden. If
     |      it's not specified an error is raised on collision.
     |
     |      ``absttl`` if True, specified ``ttl`` should represent an absolute Unix
     |      timestamp in milliseconds in which the key will expire. (Redis 5.0 or
     |      greater).
     |
     |      ``idletime`` Used for eviction, this is the number of seconds the
     |      key must be idle, prior to execution.
     |
     |      ``frequency`` Used for eviction, this is the frequency counter of
     |      the object stored at the key, prior to execution.
     |
     |      For more information, see https://redis.io/commands/restore
     |
     |  set(self, name: 'KeyT', value: 'EncodableT', ex: 'ExpiryT | None' = None, px: 'ExpiryT | None' = None, nx: 'bool' = False, xx: 'bool' = False, keepttl: 'bool' = False, get: 'bool' = False, exat: 'AbsExpiryT | None' = None, pxat: 'AbsExpiryT | None' = None, ifeq: 'bytes | str | None' = None, ifne: 'bytes | str | None' = None, ifdeq: 'str | None' = None, ifdne: 'str | None' = None) -> 'bool | str | bytes | None | Awaitable[bool | str | bytes | None]'
     |      Set the value at key ``name`` to ``value``
     |
     |      Warning:
     |      **Experimental** since 7.1.
     |      The usage of the arguments ``ifeq``, ``ifne``, ``ifdeq``, and ``ifdne``
     |      is experimental. The API or returned results when those parameters are used
     |      may change based on feedback.
     |
     |      ``ex`` sets an expire flag on key ``name`` for ``ex`` seconds.
     |
     |      ``px`` sets an expire flag on key ``name`` for ``px`` milliseconds.
     |
     |      ``nx`` if set to True, set the value at key ``name`` to ``value`` only
     |          if it does not exist.
     |
     |      ``xx`` if set to True, set the value at key ``name`` to ``value`` only
     |          if it already exists.
     |
     |      ``keepttl`` if True, retain the time to live associated with the key.
     |          (Available since Redis 6.0)
     |
     |      ``get`` if True, set the value at key ``name`` to ``value`` and return
     |          the old value stored at key, or None if the key did not exist.
     |          (Available since Redis 6.2)
     |
     |      ``exat`` sets an expire flag on key ``name`` for ``ex`` seconds,
     |          specified in unix time.
     |
     |      ``pxat`` sets an expire flag on key ``name`` for ``ex`` milliseconds,
     |          specified in unix time.
     |
     |      ``ifeq`` set the value at key ``name`` to ``value`` only if the current
     |          value exactly matches the argument.
     |          If key doesn’t exist - it won’t be created.
     |          (Requires Redis 8.4 or greater)
     |
     |      ``ifne`` set the value at key ``name`` to ``value`` only if the current
     |          value does not exactly match the argument.
     |          If key doesn’t exist - it will be created.
     |          (Requires Redis 8.4 or greater)
     |
     |      ``ifdeq`` set the value at key ``name`` to ``value`` only if the current
     |          value XXH3 hex digest exactly matches the argument.
     |          If key doesn’t exist - it won’t be created.
     |          (Requires Redis 8.4 or greater)
     |
     |      ``ifdne`` set the value at key ``name`` to ``value`` only if the current
     |          value XXH3 hex digest does not exactly match the argument.
     |          If key doesn’t exist - it will be created.
     |          (Requires Redis 8.4 or greater)
     |
     |      For more information, see https://redis.io/commands/set
     |
     |  setbit(self, name: 'KeyT', offset: 'int', value: 'int') -> 'int | Awaitable[int]'
     |      Flag the ``offset`` in ``name`` as ``value``. Returns an integer
     |      indicating the previous value of ``offset``.
     |
     |      For more information, see https://redis.io/commands/setbit
     |
     |  setex(self, name: 'KeyT', time: 'ExpiryT', value: 'EncodableT') -> 'bool | Awaitable[bool]'
     |      Set the value of key ``name`` to ``value`` that expires in ``time``
     |      seconds. ``time`` can be represented by an integer or a Python
     |      timedelta object.
     |
     |      As per Redis 2.6.12, SETEX is considered deprecated.
     |      Please use SET with EX parameter in new code.
     |
     |      For more information, see https://redis.io/commands/setex
     |
     |  setnx(self, name: 'KeyT', value: 'EncodableT') -> 'bool | Awaitable[bool]'
     |      Set the value of key ``name`` to ``value`` if key doesn't exist
     |
     |      For more information, see https://redis.io/commands/setnx
     |
     |  setrange(self, name: 'KeyT', offset: 'int', value: 'EncodableT') -> 'int | Awaitable[int]'
     |      Overwrite bytes in the value of ``name`` starting at ``offset`` with
     |      ``value``. If ``offset`` plus the length of ``value`` exceeds the
     |      length of the original value, the new value will be larger than before.
     |      If ``offset`` exceeds the length of the original value, null bytes
     |      will be used to pad between the end of the previous value and the start
     |      of what's being injected.
     |
     |      Returns the length of the new string.
     |
     |      For more information, see https://redis.io/commands/setrange
     |
     |  strlen(self, name: 'KeyT') -> 'int | Awaitable[int]'
     |      Return the number of bytes stored in the value of ``name``
     |
     |      For more information, see https://redis.io/commands/strlen
     |
     |  substr(self, name: 'KeyT', start: 'int', end: 'int' = -1) -> 'bytes | str | Awaitable[bytes | str]'
     |      Return a substring of the string at key ``name``. ``start`` and ``end``
     |      are 0-based integers specifying the portion of the string to return.
     |
     |  ttl(self, name: 'KeyT') -> 'int | Awaitable[int]'
     |      Returns the number of seconds until the key ``name`` will expire
     |
     |      For more information, see https://redis.io/commands/ttl
     |
     |  type(self, name: 'KeyT') -> 'bytes | str | Awaitable[bytes | str]'
     |      Returns the type of key ``name``
     |
     |      For more information, see https://redis.io/commands/type
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from redis.commands.core.HyperlogCommands:
     |
     |  pfadd(self, name: 'KeyT', *values: 'FieldT') -> 'int | Awaitable[int]'
     |      Adds the specified elements to the specified HyperLogLog.
     |
     |      For more information, see https://redis.io/commands/pfadd
     |
     |  pfcount(self, *sources: 'KeyT') -> 'int | Awaitable[int]'
     |      Return the approximated cardinality of
     |      the set observed by the HyperLogLog at key(s).
     |
     |      For more information, see https://redis.io/commands/pfcount
     |
     |  pfmerge(self, dest: 'KeyT', *sources: 'KeyT') -> 'bool | Awaitable[bool]'
     |      Merge N different HyperLogLogs into a single one.
     |
     |      For more information, see https://redis.io/commands/pfmerge
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from redis.commands.core.HashCommands:
     |
     |  hdel(self, name: 'KeyT', *keys: 'FieldT') -> 'int | Awaitable[int]'
     |      Delete ``keys`` from hash ``name``
     |
     |      For more information, see https://redis.io/commands/hdel
     |
     |  hexists(self, name: 'KeyT', key: 'FieldT') -> 'bool | Awaitable[bool]'
     |      Returns a boolean indicating if ``key`` exists within hash ``name``
     |
     |      For more information, see https://redis.io/commands/hexists
     |
     |  hexpire(self, name: 'KeyT', seconds: 'ExpiryT', *fields: 'FieldT', nx: 'bool' = False, xx: 'bool' = False, gt: 'bool' = False, lt: 'bool' = False) -> 'list[int] | Awaitable[list[int]]'
     |      Sets or updates the expiration time for fields within a hash key, using relative
     |      time in seconds.
     |
     |      If a field already has an expiration time, the behavior of the update can be
     |      controlled using the `nx`, `xx`, `gt`, and `lt` parameters.
     |
     |      The return value provides detailed information about the outcome for each field.
     |
     |      For more information, see https://redis.io/commands/hexpire
     |
     |      Args:
     |          name: The name of the hash key.
     |          seconds: Expiration time in seconds, relative. Can be an integer, or a
     |                   Python `timedelta` object.
     |          fields: List of fields within the hash to apply the expiration time to.
     |          nx: Set expiry only when the field has no expiry.
     |          xx: Set expiry only when the field has an existing expiry.
     |          gt: Set expiry only when the new expiry is greater than the current one.
     |          lt: Set expiry only when the new expiry is less than the current one.
     |
     |      Returns:
     |          Returns a list which contains for each field in the request:
     |              - `-2` if the field does not exist, or if the key does not exist.
     |              - `0` if the specified NX | XX | GT | LT condition was not met.
     |              - `1` if the expiration time was set or updated.
     |              - `2` if the field was deleted because the specified expiration time is
     |                in the past.
     |
     |  hexpireat(self, name: 'KeyT', unix_time_seconds: 'AbsExpiryT', *fields: 'FieldT', nx: 'bool' = False, xx: 'bool' = False, gt: 'bool' = False, lt: 'bool' = False) -> 'list[int] | Awaitable[list[int]]'
     |      Sets or updates the expiration time for fields within a hash key, using an
     |      absolute Unix timestamp in seconds.
     |
     |      If a field already has an expiration time, the behavior of the update can be
     |      controlled using the `nx`, `xx`, `gt`, and `lt` parameters.
     |
     |      The return value provides detailed information about the outcome for each field.
     |
     |      For more information, see https://redis.io/commands/hexpireat
     |
     |      Args:
     |          name: The name of the hash key.
     |          unix_time_seconds: Expiration time as Unix timestamp in seconds. Can be an
     |                             integer or a Python `datetime` object.
     |          fields: List of fields within the hash to apply the expiration time to.
     |          nx: Set expiry only when the field has no expiry.
     |          xx: Set expiry only when the field has an existing expiration time.
     |          gt: Set expiry only when the new expiry is greater than the current one.
     |          lt: Set expiry only when the new expiry is less than the current one.
     |
     |      Returns:
     |          Returns a list which contains for each field in the request:
     |              - `-2` if the field does not exist, or if the key does not exist.
     |              - `0` if the specified NX | XX | GT | LT condition was not met.
     |              - `1` if the expiration time was set or updated.
     |              - `2` if the field was deleted because the specified expiration time is
     |                in the past.
     |
     |  hexpiretime(self, key: 'KeyT', *fields: 'FieldT') -> 'list[int] | Awaitable[list[int]]'
     |      Returns the expiration times of hash fields as Unix timestamps in seconds.
     |
     |      For more information, see https://redis.io/commands/hexpiretime
     |
     |      Args:
     |          key: The hash key.
     |          fields: A list of fields within the hash for which to get the expiration
     |                  time.
     |
     |      Returns:
     |          Returns a list which contains for each field in the request:
     |              - `-2` if the field does not exist, or if the key does not exist.
     |              - `-1` if the field exists but has no associated expire time.
     |              - A positive integer representing the expiration Unix timestamp in
     |                seconds, if the field has an associated expiration time.
     |
     |  hget(self, name: 'KeyT', key: 'FieldT') -> 'bytes | str | None | Awaitable[bytes | str | None]'
     |      Return the value of ``key`` within the hash ``name``
     |
     |      For more information, see https://redis.io/commands/hget
     |
     |  hgetall(self, name: 'KeyT') -> 'dict[bytes | str, bytes | str] | Awaitable[dict[bytes | str, bytes | str]]'
     |      Return a Python dict of the hash's name/value pairs
     |
     |      For more information, see https://redis.io/commands/hgetall
     |
     |  hgetdel(self, name: 'KeyT', *keys: 'FieldT') -> 'list[bytes | str | None] | Awaitable[list[bytes | str | None]]'
     |      Return the value of ``key`` within the hash ``name`` and
     |      delete the field in the hash.
     |      This command is similar to HGET, except for the fact that it also deletes
     |      the key on success from the hash with the provided ```name```.
     |
     |      Available since Redis 8.0
     |      For more information, see https://redis.io/commands/hgetdel
     |
     |  hgetex(self, name: 'KeyT', *keys: 'FieldT', ex: 'ExpiryT | None' = None, px: 'ExpiryT | None' = None, exat: 'AbsExpiryT | None' = None, pxat: 'AbsExpiryT | None' = None, persist: 'bool' = False) -> 'list[bytes | str | None] | Awaitable[list[bytes | str | None]]'
     |      Return the values of ``key`` and ``keys`` within the hash ``name``
     |      and optionally set their expiration.
     |
     |      ``ex`` sets an expire flag on ``kyes`` for ``ex`` seconds.
     |
     |      ``px`` sets an expire flag on ``keys`` for ``px`` milliseconds.
     |
     |      ``exat`` sets an expire flag on ``keys`` for ``ex`` seconds,
     |      specified in unix time.
     |
     |      ``pxat`` sets an expire flag on ``keys`` for ``ex`` milliseconds,
     |      specified in unix time.
     |
     |      ``persist`` remove the time to live associated with the ``keys``.
     |
     |      Available since Redis 8.0
     |      For more information, see https://redis.io/commands/hgetex
     |
     |  himport_discard_all_internal(self) -> 'int | Awaitable[int]'
     |      Send ``HIMPORT DISCARDALL`` (returns the number of fieldsets removed).
     |
     |      .. warning::
     |          Internal wire mapping — not for direct use on a pooled client. It
     |          DISCARDs on a single arbitrary borrowed connection and bypasses the
     |          client's shared fieldset registry, leaving other connections and the
     |          registry out of sync. Use the client's ``himport_discard_all`` instead;
     |          call this only on a pinned single-connection client where you manage
     |          session state yourself.
     |
     |  himport_discard_internal(self, fieldset_name: 'str') -> 'int | Awaitable[int]'
     |      Send ``HIMPORT DISCARD fieldset_name`` (``1`` removed, ``0`` not found).
     |
     |      .. warning::
     |          Internal wire mapping — not for direct use on a pooled client. It
     |          DISCARDs on a single arbitrary borrowed connection and bypasses the
     |          client's shared fieldset registry, leaving other connections and the
     |          registry out of sync. Use the client's ``himport_discard`` instead; call
     |          this only on a pinned single-connection client where you manage session
     |          state yourself.
     |
     |  himport_prepare_internal(self, fieldset_name: 'str', fields: 'Iterable[FieldT]') -> 'bool | Awaitable[bool]'
     |      Send ``HIMPORT PREPARE fieldset_name field [field ...]``.
     |
     |      Registers the ordered field list under ``fieldset_name`` in the executing
     |      connection's session. Fields are sent in the caller's order, unmodified.
     |
     |      .. warning::
     |          Internal wire mapping — not for direct use on a pooled client. It
     |          PREPAREs on a single arbitrary borrowed connection and bypasses the
     |          client's shared fieldset registry, so other connections stay unaware and
     |          reintroduce the nondeterministic "no such fieldset" the HIMPORT design
     |          prevents. Use the client's ``himport_prepare`` instead; call this only
     |          on a pinned single-connection client where you manage session state
     |          yourself.
     |
     |  himport_set(self, key: 'KeyT', fieldset_name: 'str', values: 'Iterable[EncodableT]') -> 'bool | Awaitable[bool]'
     |      Create/replace ``key`` as a hash using ``fieldset_name``'s field list.
     |
     |      Values are sent in the caller's order and map positionally to the prepared
     |      fields. The fieldset is prepared on the serving connection on first use
     |      (PREPARE bundled with SET in one write) and reused on subsequent calls;
     |      runtime discards are reconciled on the next use of the connection. All of
     |      this happens inside the normal command path, so retry, disconnect-on-error
     |      and (for the cluster) routing / MOVED-ASK apply exactly as for any command.
     |
     |      .. note::
     |          Recovery from a mid-connection fieldset loss (the server dropping the
     |          prepared fieldset without dropping the socket, e.g. ``RESET`` or
     |          ``maxmemory-clients`` eviction) applies only to a standalone
     |          ``himport_set`` call: it catches the resulting ``no such fieldset`` and
     |          re-prepares on the same socket, retrying the SET once. A ``himport_set``
     |          buffered in a **pipeline or transaction** has no such per-command
     |          recovery — its fieldset is PREPAREd once as a pre-flight before the
     |          batch, and if the server loses it between that pre-flight and the batch
     |          the SET fails and surfaces as an error in the batch results. Callers who
     |          need the automatic recovery should issue those sets outside a pipeline.
     |
     |  hincrby(self, name: 'KeyT', key: 'FieldT', amount: 'int' = 1) -> 'int | Awaitable[int]'
     |      Increment the value of ``key`` in hash ``name`` by ``amount``
     |
     |      For more information, see https://redis.io/commands/hincrby
     |
     |  hincrbyfloat(self, name: 'KeyT', key: 'FieldT', amount: 'float' = 1.0) -> 'float | Awaitable[float]'
     |      Increment the value of ``key`` in hash ``name`` by floating ``amount``
     |
     |      For more information, see https://redis.io/commands/hincrbyfloat
     |
     |  hkeys(self, name: 'KeyT') -> 'list[bytes | str] | Awaitable[list[bytes | str]]'
     |      Return the list of keys within hash ``name``
     |
     |      For more information, see https://redis.io/commands/hkeys
     |
     |  hlen(self, name: 'KeyT') -> 'int | Awaitable[int]'
     |      Return the number of elements in hash ``name``
     |
     |      For more information, see https://redis.io/commands/hlen
     |
     |  hmget(self, name: 'KeyT', keys: 'FieldT | Iterable[FieldT]', *args: 'FieldT') -> 'list[bytes | str | None] | Awaitable[list[bytes | str | None]]'
     |      Returns a list of values ordered identically to ``keys``
     |
     |      For more information, see https://redis.io/commands/hmget
     |
     |  hmset(self, name: 'KeyT', mapping: 'Mapping[FieldT, EncodableT]') -> 'bool | Awaitable[bool]'
     |      Set key to value within hash ``name`` for each corresponding
     |      key and value from the ``mapping`` dict.
     |
     |      For more information, see https://redis.io/commands/hmset
     |
     |  hpersist(self, name: 'KeyT', *fields: 'FieldT') -> 'list[int] | Awaitable[list[int]]'
     |      Removes the expiration time for each specified field in a hash.
     |
     |      For more information, see https://redis.io/commands/hpersist
     |
     |      Args:
     |          name: The name of the hash key.
     |          fields: A list of fields within the hash from which to remove the
     |                  expiration time.
     |
     |      Returns:
     |          Returns a list which contains for each field in the request:
     |              - `-2` if the field does not exist, or if the key does not exist.
     |              - `-1` if the field exists but has no associated expiration time.
     |              - `1` if the expiration time was successfully removed from the field.
     |
     |  hpexpire(self, name: 'KeyT', milliseconds: 'ExpiryT', *fields: 'FieldT', nx: 'bool' = False, xx: 'bool' = False, gt: 'bool' = False, lt: 'bool' = False) -> 'list[int] | Awaitable[list[int]]'
     |      Sets or updates the expiration time for fields within a hash key, using relative
     |      time in milliseconds.
     |
     |      If a field already has an expiration time, the behavior of the update can be
     |      controlled using the `nx`, `xx`, `gt`, and `lt` parameters.
     |
     |      The return value provides detailed information about the outcome for each field.
     |
     |      For more information, see https://redis.io/commands/hpexpire
     |
     |      Args:
     |          name: The name of the hash key.
     |          milliseconds: Expiration time in milliseconds, relative. Can be an integer,
     |                        or a Python `timedelta` object.
     |          fields: List of fields within the hash to apply the expiration time to.
     |          nx: Set expiry only when the field has no expiry.
     |          xx: Set expiry only when the field has an existing expiry.
     |          gt: Set expiry only when the new expiry is greater than the current one.
     |          lt: Set expiry only when the new expiry is less than the current one.
     |
     |      Returns:
     |          Returns a list which contains for each field in the request:
     |              - `-2` if the field does not exist, or if the key does not exist.
     |              - `0` if the specified NX | XX | GT | LT condition was not met.
     |              - `1` if the expiration time was set or updated.
     |              - `2` if the field was deleted because the specified expiration time is
     |                in the past.
     |
     |  hpexpireat(self, name: 'KeyT', unix_time_milliseconds: 'AbsExpiryT', *fields: 'FieldT', nx: 'bool' = False, xx: 'bool' = False, gt: 'bool' = False, lt: 'bool' = False) -> 'list[int] | Awaitable[list[int]]'
     |      Sets or updates the expiration time for fields within a hash key, using an
     |      absolute Unix timestamp in milliseconds.
     |
     |      If a field already has an expiration time, the behavior of the update can be
     |      controlled using the `nx`, `xx`, `gt`, and `lt` parameters.
     |
     |      The return value provides detailed information about the outcome for each field.
     |
     |      For more information, see https://redis.io/commands/hpexpireat
     |
     |      Args:
     |          name: The name of the hash key.
     |          unix_time_milliseconds: Expiration time as Unix timestamp in milliseconds.
     |                                  Can be an integer or a Python `datetime` object.
     |          fields: List of fields within the hash to apply the expiry.
     |          nx: Set expiry only when the field has no expiry.
     |          xx: Set expiry only when the field has an existing expiry.
     |          gt: Set expiry only when the new expiry is greater than the current one.
     |          lt: Set expiry only when the new expiry is less than the current one.
     |
     |      Returns:
     |          Returns a list which contains for each field in the request:
     |              - `-2` if the field does not exist, or if the key does not exist.
     |              - `0` if the specified NX | XX | GT | LT condition was not met.
     |              - `1` if the expiration time was set or updated.
     |              - `2` if the field was deleted because the specified expiration time is
     |                in the past.
     |
     |  hpexpiretime(self, key: 'KeyT', *fields: 'FieldT') -> 'list[int] | Awaitable[list[int]]'
     |      Returns the expiration times of hash fields as Unix timestamps in milliseconds.
     |
     |      For more information, see https://redis.io/commands/hpexpiretime
     |
     |      Args:
     |          key: The hash key.
     |          fields: A list of fields within the hash for which to get the expiration
     |                  time.
     |
     |      Returns:
     |          Returns a list which contains for each field in the request:
     |              - `-2` if the field does not exist, or if the key does not exist.
     |              - `-1` if the field exists but has no associated expire time.
     |              - A positive integer representing the expiration Unix timestamp in
     |                milliseconds, if the field has an associated expiration time.
     |
     |  hpttl(self, key: 'KeyT', *fields: 'FieldT') -> 'list[int] | Awaitable[list[int]]'
     |      Returns the TTL (Time To Live) in milliseconds for each specified field within a
     |      hash key.
     |
     |      For more information, see https://redis.io/commands/hpttl
     |
     |      Args:
     |          key: The hash key.
     |          fields: A list of fields within the hash for which to get the TTL.
     |
     |      Returns:
     |          Returns a list which contains for each field in the request:
     |              - `-2` if the field does not exist, or if the key does not exist.
     |              - `-1` if the field exists but has no associated expire time.
     |              - A positive integer representing the TTL in milliseconds if the field
     |                has an associated expiration time.
     |
     |  hset(self, name: 'KeyT', key: 'FieldT | None' = None, value: 'EncodableT | None' = None, mapping: 'Mapping[FieldT, EncodableT] | None' = None, items: 'Sequence[EncodableT] | None' = None) -> 'int | Awaitable[int]'
     |      Set ``key`` to ``value`` within hash ``name``,
     |      ``mapping`` accepts a dict of key/value pairs that will be
     |      added to hash ``name``.
     |      ``items`` accepts a list of key/value pairs that will be
     |      added to hash ``name``.
     |      Returns the number of fields that were added.
     |
     |      For more information, see https://redis.io/commands/hset
     |
     |  hsetex(self, name: 'KeyT', key: 'FieldT | None' = None, value: 'EncodableT | None' = None, mapping: 'Mapping[FieldT, EncodableT] | None' = None, items: 'Sequence[EncodableT] | None' = None, ex: 'ExpiryT | None' = None, px: 'ExpiryT | None' = None, exat: 'AbsExpiryT | None' = None, pxat: 'AbsExpiryT | None' = None, data_persist_option: 'HashDataPersistOptions | None' = None, keepttl: 'bool' = False) -> 'int | Awaitable[int]'
     |      Set ``key`` to ``value`` within hash ``name``
     |
     |      ``mapping`` accepts a dict of key/value pairs that will be
     |      added to hash ``name``.
     |
     |      ``items`` accepts a list of key/value pairs that will be
     |      added to hash ``name``.
     |
     |      ``ex`` sets an expire flag on ``keys`` for ``ex`` seconds.
     |
     |      ``px`` sets an expire flag on ``keys`` for ``px`` milliseconds.
     |
     |      ``exat`` sets an expire flag on ``keys`` for ``ex`` seconds,
     |          specified in unix time.
     |
     |      ``pxat`` sets an expire flag on ``keys`` for ``ex`` milliseconds,
     |          specified in unix time.
     |
     |      ``data_persist_option`` can be set to ``FNX`` or ``FXX`` to control the
     |          behavior of the command.
     |          ``FNX`` will set the value for each provided key to each
     |              provided value only if all do not already exist.
     |          ``FXX`` will set the value for each provided key to each
     |              provided value only if all already exist.
     |
     |      ``keepttl`` if True, retain the time to live associated with the keys.
     |
     |      Returns the number of fields that were added.
     |
     |      Available since Redis 8.0
     |      For more information, see https://redis.io/commands/hsetex
     |
     |  hsetnx(self, name: 'KeyT', key: 'FieldT', value: 'EncodableT') -> 'int | Awaitable[int]'
     |      Set ``key`` to ``value`` within hash ``name`` if ``key`` does not
     |      exist.  Returns 1 if HSETNX created a field, otherwise 0.
     |
     |      For more information, see https://redis.io/commands/hsetnx
     |
     |  hstrlen(self, name: 'KeyT', key: 'FieldT') -> 'int | Awaitable[int]'
     |      Return the number of bytes stored in the value of ``key``
     |      within hash ``name``
     |
     |      For more information, see https://redis.io/commands/hstrlen
     |
     |  httl(self, key: 'KeyT', *fields: 'FieldT') -> 'list[int] | Awaitable[list[int]]'
     |      Returns the TTL (Time To Live) in seconds for each specified field within a hash
     |      key.
     |
     |      For more information, see https://redis.io/commands/httl
     |
     |      Args:
     |          key: The hash key.
     |          fields: A list of fields within the hash for which to get the TTL.
     |
     |      Returns:
     |          Returns a list which contains for each field in the request:
     |              - `-2` if the field does not exist, or if the key does not exist.
     |              - `-1` if the field exists but has no associated expire time.
     |              - A positive integer representing the TTL in seconds if the field has
     |                an associated expiration time.
     |
     |  hvals(self, name: 'KeyT') -> 'list[bytes | str] | Awaitable[list[bytes | str]]'
     |      Return the list of values within hash ``name``
     |
     |      For more information, see https://redis.io/commands/hvals
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from redis.commands.core.GeoCommands:
     |
     |  geoadd(self, name: 'KeyT', values: 'Sequence[EncodableT]', nx: 'bool' = False, xx: 'bool' = False, ch: 'bool' = False) -> 'int | Awaitable[int]'
     |      Add the specified geospatial items to the specified key identified
     |      by the ``name`` argument. The Geospatial items are given as ordered
     |      members of the ``values`` argument, each item or place is formed by
     |      the triad longitude, latitude and name.
     |
     |      Note: You can use ZREM to remove elements.
     |
     |      ``nx`` forces ZADD to only create new elements and not to update
     |      scores for elements that already exist.
     |
     |      ``xx`` forces ZADD to only update scores of elements that already
     |      exist. New elements will not be added.
     |
     |      ``ch`` modifies the return value to be the numbers of elements changed.
     |      Changed elements include new elements that were added and elements
     |      whose scores changed.
     |
     |      For more information, see https://redis.io/commands/geoadd
     |
     |  geodist(self, name: 'KeyT', place1: 'FieldT', place2: 'FieldT', unit: 'str | None' = None) -> 'float | None | Awaitable[float | None]'
     |      Return the distance between ``place1`` and ``place2`` members of the
     |      ``name`` key.
     |      The units must be one of the following : m, km mi, ft. By default
     |      meters are used.
     |
     |      For more information, see https://redis.io/commands/geodist
     |
     |  geohash(self, name: 'KeyT', *values: 'FieldT') -> 'list[bytes | str | None] | Awaitable[list[bytes | str | None]]'
     |      Return the geo hash string for each item of ``values`` members of
     |      the specified key identified by the ``name`` argument.
     |
     |      For more information, see https://redis.io/commands/geohash
     |
     |  geopos(self, name: 'KeyT', *values: 'FieldT') -> 'list[GeoCoordinate | None] | Awaitable[list[GeoCoordinate | None]]'
     |      Return the positions of each item of ``values`` as members of
     |      the specified key identified by the ``name`` argument. Each position
     |      is represented by the pairs lon and lat.
     |
     |      For more information, see https://redis.io/commands/geopos
     |
     |  georadius(self, name: 'KeyT', longitude: 'float', latitude: 'float', radius: 'float', unit: 'str | None' = None, withdist: 'bool' = False, withcoord: 'bool' = False, withhash: 'bool' = False, count: 'int | None' = None, sort: 'str | None' = None, store: 'KeyT | None' = None, store_dist: 'KeyT | None' = None, any: 'bool' = False) -> 'GeoRadiusResponse | Awaitable[GeoRadiusResponse]'
     |      Return the members of the specified key identified by the
     |      ``name`` argument which are within the borders of the area specified
     |      with the ``latitude`` and ``longitude`` location and the maximum
     |      distance from the center specified by the ``radius`` value.
     |
     |      The units must be one of the following : m, km mi, ft. By default
     |
     |      ``withdist`` indicates to return the distances of each place.
     |
     |      ``withcoord`` indicates to return the latitude and longitude of
     |      each place.
     |
     |      ``withhash`` indicates to return the geohash string of each place.
     |
     |      ``count`` indicates to return the number of elements up to N.
     |
     |      ``sort`` indicates to return the places in a sorted way, ASC for
     |      nearest to fairest and DESC for fairest to nearest.
     |
     |      ``store`` indicates to save the places names in a sorted set named
     |      with a specific key, each element of the destination sorted set is
     |      populated with the score got from the original geo sorted set.
     |
     |      ``store_dist`` indicates to save the places names in a sorted set
     |      named with a specific key, instead of ``store`` the sorted set
     |      destination score is set with the distance.
     |
     |      For more information, see https://redis.io/commands/georadius
     |
     |  georadiusbymember(self, name: 'KeyT', member: 'FieldT', radius: 'float', unit: 'str | None' = None, withdist: 'bool' = False, withcoord: 'bool' = False, withhash: 'bool' = False, count: 'int | None' = None, sort: 'str | None' = None, store: 'Union[KeyT, None]' = None, store_dist: 'Union[KeyT, None]' = None, any: 'bool' = False) -> 'GeoRadiusResponse | Awaitable[GeoRadiusResponse]'
     |      This command is exactly like ``georadius`` with the sole difference
     |      that instead of taking, as the center of the area to query, a longitude
     |      and latitude value, it takes the name of a member already existing
     |      inside the geospatial index represented by the sorted set.
     |
     |      For more information, see https://redis.io/commands/georadiusbymember
     |
     |  geosearch(self, name: 'KeyT', member: 'FieldT | None' = None, longitude: 'float | None' = None, latitude: 'float | None' = None, unit: 'str' = 'm', radius: 'float | None' = None, width: 'float | None' = None, height: 'float | None' = None, sort: 'str | None' = None, count: 'int | None' = None, any: 'bool' = False, withcoord: 'bool' = False, withdist: 'bool' = False, withhash: 'bool' = False) -> 'GeoSearchResponse | Awaitable[GeoSearchResponse]'
     |      Return the members of specified key identified by the
     |      ``name`` argument, which are within the borders of the
     |      area specified by a given shape. This command extends the
     |      GEORADIUS command, so in addition to searching within circular
     |      areas, it supports searching within rectangular areas.
     |
     |      This command should be used in place of the deprecated
     |      GEORADIUS and GEORADIUSBYMEMBER commands.
     |
     |      ``member`` Use the position of the given existing
     |       member in the sorted set. Can't be given with ``longitude``
     |       and ``latitude``.
     |
     |      ``longitude`` and ``latitude`` Use the position given by
     |      this coordinates. Can't be given with ``member``
     |      ``radius`` Similar to GEORADIUS, search inside circular
     |      area according the given radius. Can't be given with
     |      ``height`` and ``width``.
     |      ``height`` and ``width`` Search inside an axis-aligned
     |      rectangle, determined by the given height and width.
     |      Can't be given with ``radius``
     |
     |      ``unit`` must be one of the following : m, km, mi, ft.
     |      `m` for meters (the default value), `km` for kilometers,
     |      `mi` for miles and `ft` for feet.
     |
     |      ``sort`` indicates to return the places in a sorted way,
     |      ASC for nearest to furthest and DESC for furthest to nearest.
     |
     |      ``count`` limit the results to the first count matching items.
     |
     |      ``any`` is set to True, the command will return as soon as
     |      enough matches are found. Can't be provided without ``count``
     |
     |      ``withdist`` indicates to return the distances of each place.
     |      ``withcoord`` indicates to return the latitude and longitude of
     |      each place.
     |
     |      ``withhash`` indicates to return the geohash string of each place.
     |
     |      For more information, see https://redis.io/commands/geosearch
     |
     |  geosearchstore(self, dest: 'KeyT', name: 'KeyT', member: 'FieldT | None' = None, longitude: 'float | None' = None, latitude: 'float | None' = None, unit: 'str' = 'm', radius: 'float | None' = None, width: 'float | None' = None, height: 'float | None' = None, sort: 'str | None' = None, count: 'int | None' = None, any: 'bool' = False, storedist: 'bool' = False) -> 'int | Awaitable[int]'
     |      This command is like GEOSEARCH, but stores the result in
     |      ``dest``. By default, it stores the results in the destination
     |      sorted set with their geospatial information.
     |      if ``store_dist`` set to True, the command will stores the
     |      items in a sorted set populated with their distance from the
     |      center of the circle or box, as a floating-point number.
     |
     |      For more information, see https://redis.io/commands/geosearchstore
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from redis.commands.core.ListCommands:
     |
     |  blmpop(self, timeout: 'float', numkeys: 'int', *args: 'str', direction: 'str', count: 'int | None' = 1) -> 'ListMultiPopResponse | Awaitable[ListMultiPopResponse]'
     |      Pop ``count`` values (default 1) from first non-empty in the list
     |      of provided key names.
     |
     |      When all lists are empty this command blocks the connection until another
     |      client pushes to it or until the timeout, timeout of 0 blocks indefinitely
     |
     |      For more information, see https://redis.io/commands/blmpop
     |
     |  blpop(self, keys: 'KeysT', timeout: 'Number | None' = 0) -> 'BlockingListPopResponse | Awaitable[BlockingListPopResponse]'
     |      LPOP a value off of the first non-empty list
     |      named in ``keys``.
     |
     |      If none of the lists in ``keys`` has a value to LPOP, then block
     |      for ``timeout`` seconds, or until a value gets pushed on to one
     |      of the lists.
     |
     |      If timeout is 0, then block indefinitely.
     |
     |      For more information, see https://redis.io/commands/blpop
     |
     |  brpop(self, keys: 'KeysT', timeout: 'Number | None' = 0) -> 'BlockingListPopResponse | Awaitable[BlockingListPopResponse]'
     |      RPOP a value off of the first non-empty list
     |      named in ``keys``.
     |
     |      If none of the lists in ``keys`` has a value to RPOP, then block
     |      for ``timeout`` seconds, or until a value gets pushed on to one
     |      of the lists.
     |
     |      If timeout is 0, then block indefinitely.
     |
     |      For more information, see https://redis.io/commands/brpop
     |
     |  brpoplpush(self, src: 'KeyT', dst: 'KeyT', timeout: 'Number | None' = 0) -> 'bytes | str | None | Awaitable[bytes | str | None]'
     |      Pop a value off the tail of ``src``, push it on the head of ``dst``
     |      and then return it.
     |
     |      This command blocks until a value is in ``src`` or until ``timeout``
     |      seconds elapse, whichever is first. A ``timeout`` value of 0 blocks
     |      forever.
     |
     |      For more information, see https://redis.io/commands/brpoplpush
     |
     |  lindex(self, name: 'KeyT', index: 'int') -> 'bytes | str | None | Awaitable[bytes | str | None]'
     |      Return the item from list ``name`` at position ``index``
     |
     |      Negative indexes are supported and will return an item at the
     |      end of the list
     |
     |      For more information, see https://redis.io/commands/lindex
     |
     |  linsert(self, name: 'KeyT', where: 'str', refvalue: 'str', value: 'str') -> 'int | Awaitable[int]'
     |      Insert ``value`` in list ``name`` either immediately before or after
     |      [``where``] ``refvalue``
     |
     |      Returns the new length of the list on success or -1 if ``refvalue``
     |      is not in the list.
     |
     |      For more information, see https://redis.io/commands/linsert
     |
     |  llen(self, name: 'KeyT') -> 'int | Awaitable[int]'
     |      Return the length of the list ``name``
     |
     |      For more information, see https://redis.io/commands/llen
     |
     |  lmpop(self, num_keys: 'int', *args: 'str', direction: 'str', count: 'int | None' = 1) -> 'ListMultiPopResponse | Awaitable[ListMultiPopResponse]'
     |      Pop ``count`` values (default 1) first non-empty list key from the list
     |      of args provided key names.
     |
     |      For more information, see https://redis.io/commands/lmpop
     |
     |  lpop(self, name: 'KeyT', count: 'int | None' = None) -> 'bytes | str | list[bytes | str] | None | Awaitable[bytes | str | list[bytes | str] | None]'
     |      Removes and returns the first elements of the list ``name``.
     |
     |      By default, the command pops a single element from the beginning of
     |      the list. When provided with the optional ``count`` argument, the reply
     |      will consist of up to count elements, depending on the list's length.
     |
     |      For more information, see https://redis.io/commands/lpop
     |
     |  lpos(self, name: 'KeyT', value: 'str', rank: 'int | None' = None, count: 'int | None' = None, maxlen: 'int | None' = None) -> 'int | list[int] | None | Awaitable[int | list[int] | None]'
     |      Get position of ``value`` within the list ``name``
     |
     |       If specified, ``rank`` indicates the "rank" of the first element to
     |       return in case there are multiple copies of ``value`` in the list.
     |       By default, LPOS returns the position of the first occurrence of
     |       ``value`` in the list. When ``rank`` 2, LPOS returns the position of
     |       the second ``value`` in the list. If ``rank`` is negative, LPOS
     |       searches the list in reverse. For example, -1 would return the
     |       position of the last occurrence of ``value`` and -2 would return the
     |       position of the next to last occurrence of ``value``.
     |
     |       If specified, ``count`` indicates that LPOS should return a list of
     |       up to ``count`` positions. A ``count`` of 2 would return a list of
     |       up to 2 positions. A ``count`` of 0 returns a list of all positions
     |       matching ``value``. When ``count`` is specified and but ``value``
     |       does not exist in the list, an empty list is returned.
     |
     |       If specified, ``maxlen`` indicates the maximum number of list
     |       elements to scan. A ``maxlen`` of 1000 will only return the
     |       position(s) of items within the first 1000 entries in the list.
     |       A ``maxlen`` of 0 (the default) will scan the entire list.
     |
     |       For more information, see https://redis.io/commands/lpos
     |
     |  lpush(self, name: 'KeyT', *values: 'FieldT') -> 'int | Awaitable[int]'
     |      Push ``values`` onto the head of the list ``name``
     |
     |      For more information, see https://redis.io/commands/lpush
     |
     |  lpushx(self, name: 'KeyT', *values: 'FieldT') -> 'int | Awaitable[int]'
     |      Push ``value`` onto the head of the list ``name`` if ``name`` exists
     |
     |      For more information, see https://redis.io/commands/lpushx
     |
     |  lrange(self, name: 'KeyT', start: 'int', end: 'int') -> 'list[bytes | str] | Awaitable[list[bytes | str]]'
     |      Return a slice of the list ``name`` between
     |      position ``start`` and ``end``
     |
     |      ``start`` and ``end`` can be negative numbers just like
     |      Python slicing notation
     |
     |      For more information, see https://redis.io/commands/lrange
     |
     |  lrem(self, name: 'KeyT', count: 'int', value: 'str') -> 'int | Awaitable[int]'
     |      Remove the first ``count`` occurrences of elements equal to ``value``
     |      from the list stored at ``name``.
     |
     |      The count argument influences the operation in the following ways:
     |          count > 0: Remove elements equal to value moving from head to tail.
     |          count < 0: Remove elements equal to value moving from tail to head.
     |          count = 0: Remove all elements equal to value.
     |
     |          For more information, see https://redis.io/commands/lrem
     |
     |  lset(self, name: 'KeyT', index: 'int', value: 'str') -> 'bool | Awaitable[bool]'
     |      Set element at ``index`` of list ``name`` to ``value``
     |
     |      For more information, see https://redis.io/commands/lset
     |
     |  ltrim(self, name: 'KeyT', start: 'int', end: 'int') -> 'bool | Awaitable[bool]'
     |      Trim the list ``name``, removing all values not within the slice
     |      between ``start`` and ``end``
     |
     |      ``start`` and ``end`` can be negative numbers just like
     |      Python slicing notation
     |
     |      For more information, see https://redis.io/commands/ltrim
     |
     |  rpop(self, name: 'KeyT', count: 'int | None' = None) -> 'bytes | str | list[bytes | str] | None | Awaitable[bytes | str | list[bytes | str] | None]'
     |      Removes and returns the last elements of the list ``name``.
     |
     |      By default, the command pops a single element from the end of the list.
     |      When provided with the optional ``count`` argument, the reply will
     |      consist of up to count elements, depending on the list's length.
     |
     |      For more information, see https://redis.io/commands/rpop
     |
     |  rpoplpush(self, src: 'KeyT', dst: 'KeyT') -> 'bytes | str | None | Awaitable[bytes | str | None]'
     |      RPOP a value off of the ``src`` list and atomically LPUSH it
     |      on to the ``dst`` list.  Returns the value.
     |
     |      For more information, see https://redis.io/commands/rpoplpush
     |
     |  rpush(self, name: 'KeyT', *values: 'FieldT') -> 'int | Awaitable[int]'
     |      Push ``values`` onto the tail of the list ``name``
     |
     |      For more information, see https://redis.io/commands/rpush
     |
     |  rpushx(self, name: 'KeyT', *values: 'str') -> 'int | Awaitable[int]'
     |      Push ``value`` onto the tail of the list ``name`` if ``name`` exists
     |
     |      For more information, see https://redis.io/commands/rpushx
     |
     |  sort(self, name: 'KeyT', start: 'int | None' = None, num: 'int | None' = None, by: 'str | None' = None, get: 'list[str] | None' = None, desc: 'bool' = False, alpha: 'bool' = False, store: 'str | None' = None, groups: 'bool | None' = False) -> 'SortResponse | Awaitable[SortResponse]'
     |      Sort and return the list, set or sorted set at ``name``.
     |
     |      ``start`` and ``num`` allow for paging through the sorted data
     |
     |      ``by`` allows using an external key to weight and sort the items.
     |          Use an "*" to indicate where in the key the item value is located
     |
     |      ``get`` allows for returning items from external keys rather than the
     |          sorted data itself.  Use an "*" to indicate where in the key
     |          the item value is located
     |
     |      ``desc`` allows for reversing the sort
     |
     |      ``alpha`` allows for sorting lexicographically rather than numerically
     |
     |      ``store`` allows for storing the result of the sort into
     |          the key ``store``
     |
     |      ``groups`` if set to True and if ``get`` contains at least two
     |          elements, sort will return a list of tuples, each containing the
     |          values fetched from the arguments to ``get``.
     |
     |      For more information, see https://redis.io/commands/sort
     |
     |  sort_ro(self, key: 'str', start: 'int | None' = None, num: 'int | None' = None, by: 'str | None' = None, get: 'list[str] | None' = None, desc: 'bool' = False, alpha: 'bool' = False) -> 'list[bytes | str] | Awaitable[list[bytes | str]]'
     |      Returns the elements contained in the list, set or sorted set at key.
     |      (read-only variant of the SORT command)
     |
     |      ``start`` and ``num`` allow for paging through the sorted data
     |
     |      ``by`` allows using an external key to weight and sort the items.
     |          Use an "*" to indicate where in the key the item value is located
     |
     |      ``get`` allows for returning items from external keys rather than the
     |          sorted data itself.  Use an "*" to indicate where in the key
     |          the item value is located
     |
     |      ``desc`` allows for reversing the sort
     |
     |      ``alpha`` allows for sorting lexicographically rather than numerically
     |
     |      For more information, see https://redis.io/commands/sort_ro
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from redis.commands.core.ArrayCommands:
     |
     |  arcount(self, name: 'KeyT') -> 'int | Awaitable[int]'
     |      Return the number of non-empty elements in the array stored at
     |      ``name``. Returns 0 if ``name`` does not exist.
     |
     |      For more information, see https://redis.io/commands/arcount
     |
     |  ardel(self, name: 'KeyT', *indices: 'int') -> 'int | Awaitable[int]'
     |      Delete elements at the specified ``indices`` in the array stored at
     |      ``name``. Deleting an index that does not exist counts as zero
     |      elements deleted and does not modify the array.
     |
     |      Returns the number of elements deleted.
     |
     |      For more information, see https://redis.io/commands/ardel
     |
     |  ardelrange(self, name: 'KeyT', *ranges: 'tuple[int, int]') -> 'int | Awaitable[int]'
     |      Delete elements within one or more inclusive index ranges in the
     |      array stored at ``name``. Each range is a ``(start, end)`` tuple.
     |      If ``start`` is greater than ``end`` for a given pair, the range is
     |      processed in ascending order regardless. Multiple pairs may overlap;
     |      each element is counted at most once.
     |
     |      Returns the number of elements deleted.
     |
     |      For more information, see https://redis.io/commands/ardelrange
     |
     |  arget(self, name: 'KeyT', index: 'int') -> 'bytes | str | None | Awaitable[bytes | str | None]'
     |      Return the value at ``index`` in the array stored at ``name``.
     |
     |      Returns ``None`` if ``name`` does not exist or no value is set at
     |      ``index``.
     |
     |      For more information, see https://redis.io/commands/arget
     |
     |  argetrange(self, name: 'KeyT', start: 'int', end: 'int') -> 'list[bytes | str | None] | Awaitable[list[bytes | str | None]]'
     |      Return the values in the inclusive index range [``start``, ``end``]
     |      in the array stored at ``name``. If ``start`` is greater than ``end``,
     |      elements are returned in reverse index order.
     |
     |      For more information, see https://redis.io/commands/argetrange
     |
     |  argrep(self, name: 'KeyT', start: 'int', end: 'int', predicates: 'list[tuple[ArrayPredicateType, EncodableT]]', combinator: 'ArrayPredicateCombinator | None' = None, limit: 'int | None' = None, withvalues: 'bool' = False, nocase: 'bool' = False) -> 'list[int] | list[list[int | bytes | str]] | Awaitable[list[int] | list[list[int | bytes | str]]]'
     |      Search elements of the array stored at ``name`` within the inclusive
     |      index range [``start``, ``end``] using one or more textual
     |      ``predicates``. Each predicate is a ``(type, value)`` tuple where
     |      ``type`` is a member of ``ArrayPredicateType``
     |      (``EXACT``, ``MATCH``, ``GLOB``, ``RE``).
     |
     |      Multiple predicates are combined via ``combinator``
     |      (``ArrayPredicateCombinator.AND`` or ``OR``); the server defaults to
     |      OR when omitted. ``limit`` caps the number of matches.
     |      ``withvalues=True`` returns a list of ``[index, value]`` pairs
     |      (``[[idx, val], ...]``) instead of a flat list of indices.
     |      ``nocase=True`` makes all comparisons case-insensitive.
     |
     |      Without ``withvalues``, returns a flat list of matching indices in
     |      traversal order. With ``withvalues``, returns a list of
     |      ``[index, value]`` pairs in traversal order. Empty slots are
     |      skipped.
     |
     |      For more information, see https://redis.io/commands/argrep
     |
     |  arinfo(self, name: 'KeyT', full: 'bool' = False) -> 'dict[str, int] | Awaitable[dict[str, int]]'
     |      Return metadata about the array stored at ``name`` as a dictionary.
     |      When ``full`` is ``True``, additionally include per-slice statistics
     |      (dense/sparse slice counts, average sizes, fill rates), which makes
     |      the call O(N) instead of O(1).
     |
     |      Raises ``ResponseError`` when the key does not exist.
     |
     |      For more information, see https://redis.io/commands/arinfo
     |
     |  arinsert(self, name: 'KeyT', *values: 'FieldT') -> 'int | Awaitable[int]'
     |      Insert one or more ``values`` at consecutive indices in the array
     |      stored at ``name``, beginning at the current insert cursor position.
     |      The cursor advances by one for each value inserted. Use ``ARNEXT``
     |      to inspect the current cursor position and ``ARSEEK`` to reposition
     |      it.
     |
     |      Returns the last index where a value was inserted.
     |
     |      For more information, see https://redis.io/commands/arinsert
     |
     |  arlastitems(self, name: 'KeyT', count: 'int', rev: 'bool' = False) -> 'list[bytes | str | None] | Awaitable[list[bytes | str | None]]'
     |      Return up to ``count`` most recently inserted elements from the array
     |      stored at ``name``. If the array contains fewer elements than
     |      ``count``, all elements are returned.
     |
     |      When ``rev`` is ``True``, elements are returned in reverse
     |      chronological order (most recent first) instead of the default
     |      oldest-first order.
     |
     |      For more information, see https://redis.io/commands/arlastitems
     |
     |  arlen(self, name: 'KeyT') -> 'int | Awaitable[int]'
     |      Return the length of the array stored at ``name``, defined as the
     |      maximum set index plus one. Returns 0 if ``name`` does not exist.
     |
     |      For more information, see https://redis.io/commands/arlen
     |
     |  armget(self, name: 'KeyT', *indices: 'int') -> 'list[bytes | str | None] | Awaitable[list[bytes | str | None]]'
     |      Return the values at the specified ``indices`` in the array stored at
     |      ``name``. The reply preserves the order of the requested indices and
     |      returns ``None`` for any index that is not set or when ``name`` does
     |      not exist.
     |
     |      For more information, see https://redis.io/commands/armget
     |
     |  armset(self, name: 'KeyT', mapping: 'Mapping[int, FieldT]') -> 'int | Awaitable[int]'
     |      Set multiple index/value pairs in the array stored at ``name``.
     |      ``mapping`` is a dictionary of zero-based integer indices to values.
     |      Pairs may be non-contiguous and in any order.
     |
     |      Returns the number of new slots that were set (previously empty).
     |
     |      For more information, see https://redis.io/commands/armset
     |
     |  arnext(self, name: 'KeyT') -> 'int | None | Awaitable[int | None]'
     |      Return the next index ``ARINSERT`` would use for the array stored at
     |      ``name``. Returns 0 if ``name`` does not exist or no insert happened
     |      yet, and ``None`` when the insertion cursor is exhausted (next insert
     |      would overflow).
     |
     |      For more information, see https://redis.io/commands/arnext
     |
     |  arop(self, name: 'KeyT', start: 'int', end: 'int', operation: 'ArrayAggregateOperations', value: 'EncodableT | None' = None) -> 'bytes | str | int | None | Awaitable[bytes | str | int | None]'
     |      Perform an aggregate ``operation`` on elements of the array stored at
     |      ``name`` in the inclusive index range [``start``, ``end``]. The range
     |      is always scanned from the lower to the higher index regardless of
     |      argument order.
     |
     |      ``operation`` is one of the members of ``ArrayAggregateOperations``.
     |      ``value`` is required when ``operation`` is
     |      ``ArrayAggregateOperations.MATCH`` and specifies the value to compare
     |      against.
     |
     |      Returns a bulk string for ``SUM``, ``MIN`` and ``MAX``, an integer
     |      for ``AND``, ``OR``, ``XOR``, ``MATCH`` and ``USED``, or ``None``
     |      when no elements match the operation.
     |
     |      For more information, see https://redis.io/commands/arop
     |
     |  arring(self, name: 'KeyT', size: 'int', *values: 'FieldT') -> 'int | Awaitable[int]'
     |      Insert one or more ``values`` into the array stored at ``name`` as a
     |      fixed-size ring buffer of ``size`` slots. Each value is placed at
     |      ``insert_idx % size``, wrapping back to index 0 once the end is
     |      reached and overwriting older values when full. If ``size`` is
     |      smaller than the current window, the array is truncated to fit.
     |
     |      Returns the last index where a value was inserted.
     |
     |      For more information, see https://redis.io/commands/arring
     |
     |  arscan(self, name: 'KeyT', start: 'int', end: 'int', limit: 'int | None' = None) -> 'list[list[int | bytes | str]] | Awaitable[list[list[int | bytes | str]]]'
     |      Iterate populated elements of the array stored at ``name`` in the
     |      inclusive range [``start``, ``end``] and return a list of
     |      ``[index, value]`` pairs in traversal order:
     |      ``[[idx1, val1], [idx2, val2], ...]``. Empty slots are skipped. If
     |      ``start`` is greater than ``end``, the iteration is reversed.
     |
     |      ``limit`` caps the number of populated elements returned. When
     |      omitted, all populated elements in range are returned.
     |
     |      For more information, see https://redis.io/commands/arscan
     |
     |  arseek(self, name: 'KeyT', index: 'int') -> 'int | Awaitable[int]'
     |      Set the insert cursor of the array stored at ``name`` to ``index``.
     |      Subsequent ``ARINSERT`` and ``ARRING`` operations begin inserting at
     |      this position.
     |
     |      Returns 1 if the cursor was set, 0 if ``name`` does not exist.
     |
     |      For more information, see https://redis.io/commands/arseek
     |
     |  arset(self, name: 'KeyT', index: 'int', *values: 'FieldT') -> 'int | Awaitable[int]'
     |      Set one or more contiguous ``values`` in the array stored at ``name``
     |      starting at ``index``. When multiple values are provided, they are
     |      stored at consecutive indices beginning at ``index``.
     |
     |      Returns the number of new slots that were set (previously empty).
     |
     |      For more information, see https://redis.io/commands/arset
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from redis.commands.core.AsyncScanCommands:
     |
     |  async hscan_iter(self, name: 'KeyT', match: 'Union[PatternT, None]' = None, count: 'Optional[int]' = None, no_values: 'Union[bool, None]' = None) -> 'AsyncIterator'
     |      Make an iterator using the HSCAN command so that the client doesn't
     |      need to remember the cursor position.
     |
     |      ``match`` allows for filtering the keys by pattern
     |
     |      ``count`` allows for hint the minimum number of returns
     |
     |      ``no_values`` indicates to return only the keys, without values
     |
     |  async sscan_iter(self, name: 'KeyT', match: 'Union[PatternT, None]' = None, count: 'Optional[int]' = None) -> 'AsyncIterator'
     |      Make an iterator using the SSCAN command so that the client doesn't
     |      need to remember the cursor position.
     |
     |      ``match`` allows for filtering the keys by pattern
     |
     |      ``count`` allows for hint the minimum number of returns
     |
     |  async zscan_iter(self, name: 'KeyT', match: 'Union[PatternT, None]' = None, count: 'Optional[int]' = None, score_cast_func: 'Union[type, Callable]' = <class 'float'>) -> 'AsyncIterator'
     |      Make an iterator using the ZSCAN command so that the client doesn't
     |      need to remember the cursor position.
     |
     |      ``match`` allows for filtering the keys by pattern
     |
     |      ``count`` allows for hint the minimum number of returns
     |
     |      ``score_cast_func`` a callable used to cast the score return value
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from redis.commands.core.ScanCommands:
     |
     |  hscan(self, name: 'KeyT', cursor: 'int' = 0, match: 'PatternT | None' = None, count: 'int | None' = None, no_values: 'bool | None' = None) -> 'HScanResponse | Awaitable[HScanResponse]'
     |      Incrementally return key/value slices in a hash. Also return a cursor
     |      indicating the scan position.
     |
     |      ``match`` allows for filtering the keys by pattern
     |
     |      ``count`` allows for hint the minimum number of returns
     |
     |      ``no_values`` indicates to return only the keys, without values.
     |
     |      For more information, see https://redis.io/commands/hscan
     |
     |  scan(self, cursor: 'int' = 0, match: 'PatternT | None' = None, count: 'int | None' = None, _type: 'str | None' = None, **kwargs) -> 'ScanResponse | Awaitable[ScanResponse]'
     |      Incrementally return lists of key names. Also return a cursor
     |      indicating the scan position.
     |
     |      ``match`` allows for filtering the keys by pattern
     |
     |      ``count`` provides a hint to Redis about the number of keys to
     |          return per batch.
     |
     |      ``_type`` filters the returned values by a particular Redis type.
     |          Stock Redis instances allow for the following types:
     |          HASH, LIST, SET, STREAM, STRING, ZSET
     |          Additionally, Redis modules can expose other types as well.
     |
     |      For more information, see https://redis.io/commands/scan
     |
     |  sscan(self, name: 'KeyT', cursor: 'int' = 0, match: 'PatternT | None' = None, count: 'int | None' = None) -> 'ScanResponse | Awaitable[ScanResponse]'
     |      Incrementally return lists of elements in a set. Also return a cursor
     |      indicating the scan position.
     |
     |      ``match`` allows for filtering the keys by pattern
     |
     |      ``count`` allows for hint the minimum number of returns
     |
     |      For more information, see https://redis.io/commands/sscan
     |
     |  zscan(self, name: 'KeyT', cursor: 'int' = 0, match: 'PatternT | None' = None, count: 'int | None' = None, score_cast_func: 'type | Callable' = <class 'float'>) -> 'ZScanResponse | Awaitable[ZScanResponse]'
     |      Incrementally return lists of elements in a sorted set. Also return a
     |      cursor indicating the scan position.
     |
     |      ``match`` allows for filtering the keys by pattern
     |
     |      ``count`` allows for hint the minimum number of returns
     |
     |      ``score_cast_func`` a callable used to cast the score return value
     |
     |      For more information, see https://redis.io/commands/zscan
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from redis.commands.core.SetCommands:
     |
     |  sadd(self, name: 'KeyT', *values: 'FieldT') -> 'int | Awaitable[int]'
     |      Add ``value(s)`` to set ``name``
     |
     |      For more information, see https://redis.io/commands/sadd
     |
     |  scard(self, name: 'KeyT') -> 'int | Awaitable[int]'
     |      Return the number of elements in set ``name``
     |
     |      For more information, see https://redis.io/commands/scard
     |
     |  sdiff(self, keys: 'List', *args: 'List') -> 'set[bytes | str] | Awaitable[set[bytes | str]]'
     |      Return the difference of sets specified by ``keys``
     |
     |      For more information, see https://redis.io/commands/sdiff
     |
     |  sdiffcard(self, numkeys: 'int', keys: 'List[KeyT]', limit: 'int' = 0) -> 'int | Awaitable[int]'
     |      Return the cardinality of the difference between the first set and all
     |      the successive sets specified by ``keys``, without returning the
     |      difference itself.
     |
     |      When LIMIT is provided (defaults to 0 and means unlimited), the returned
     |      cardinality is capped at ``limit`` and the server may stop the
     |      computation once the capped result is known.
     |
     |      For more information, see https://redis.io/commands/sdiffcard
     |
     |  sdiffstore(self, dest: 'str', keys: 'List', *args: 'List') -> 'int | Awaitable[int]'
     |      Store the difference of sets specified by ``keys`` into a new
     |      set named ``dest``.  Returns the number of keys in the new set.
     |
     |      For more information, see https://redis.io/commands/sdiffstore
     |
     |  sinter(self, keys: 'List', *args: 'List') -> 'set[bytes | str] | Awaitable[set[bytes | str]]'
     |      Return the intersection of sets specified by ``keys``
     |
     |      For more information, see https://redis.io/commands/sinter
     |
     |  sintercard(self, numkeys: 'int', keys: 'List[KeyT]', limit: 'int' = 0) -> 'int | Awaitable[int]'
     |      Return the cardinality of the intersect of multiple sets specified by ``keys``.
     |
     |      When LIMIT provided (defaults to 0 and means unlimited), if the intersection
     |      cardinality reaches limit partway through the computation, the algorithm will
     |      exit and yield limit as the cardinality
     |
     |      For more information, see https://redis.io/commands/sintercard
     |
     |  sinterstore(self, dest: 'KeyT', keys: 'List', *args: 'List') -> 'int | Awaitable[int]'
     |      Store the intersection of sets specified by ``keys`` into a new
     |      set named ``dest``.  Returns the number of keys in the new set.
     |
     |      For more information, see https://redis.io/commands/sinterstore
     |
     |  sismember(self, name: 'KeyT', value: 'str') -> 'Literal[0] | Literal[1] | Awaitable[Literal[0] | Literal[1]]'
     |      Return whether ``value`` is a member of set ``name``:
     |      - 1 if the value is a member of the set.
     |      - 0 if the value is not a member of the set or if key does not exist.
     |
     |      For more information, see https://redis.io/commands/sismember
     |
     |  smembers(self, name: 'KeyT') -> 'set[bytes | str] | Awaitable[set[bytes | str]]'
     |      Return all members of the set ``name``
     |
     |      For more information, see https://redis.io/commands/smembers
     |
     |  smismember(self, name: 'KeyT', values: 'List', *args: 'List') -> 'list[Literal[0] | Literal[1]] | Awaitable[list[Literal[0] | Literal[1]]]'
     |      Return whether each value in ``values`` is a member of the set ``name``
     |      as a list of ``int`` in the order of ``values``:
     |      - 1 if the value is a member of the set.
     |      - 0 if the value is not a member of the set or if key does not exist.
     |
     |      For more information, see https://redis.io/commands/smismember
     |
     |  smove(self, src: 'KeyT', dst: 'KeyT', value: 'str') -> 'bool | Awaitable[bool]'
     |      Move ``value`` from set ``src`` to set ``dst`` atomically
     |
     |      For more information, see https://redis.io/commands/smove
     |
     |  spop(self, name: 'KeyT', count: 'int | None' = None) -> 'bytes | str | set[bytes | str] | None | Awaitable[bytes | str | set[bytes | str] | None]'
     |      Remove and return a random member of set ``name``
     |
     |      For more information, see https://redis.io/commands/spop
     |
     |  srandmember(self, name: 'KeyT', number: 'int | None' = None) -> 'bytes | str | list[bytes | str] | None | Awaitable[bytes | str | list[bytes | str] | None]'
     |      If ``number`` is None, returns a random member of set ``name``.
     |
     |      If ``number`` is supplied, returns a list of ``number`` random
     |      members of set ``name``. Note this is only available when running
     |      Redis 2.6+.
     |
     |      For more information, see https://redis.io/commands/srandmember
     |
     |  srem(self, name: 'KeyT', *values: 'FieldT') -> 'int | Awaitable[int]'
     |      Remove ``values`` from set ``name``
     |
     |      For more information, see https://redis.io/commands/srem
     |
     |  sunion(self, keys: 'List', *args: 'List') -> 'set[bytes | str] | Awaitable[set[bytes | str]]'
     |      Return the union of sets specified by ``keys``
     |
     |      For more information, see https://redis.io/commands/sunion
     |
     |  sunioncard(self, numkeys: 'int', keys: 'List[KeyT]', limit: 'int' = 0, approx: 'bool' = False) -> 'int | Awaitable[int]'
     |      Return the cardinality of the union of multiple sets specified by
     |      ``keys``, without returning the union itself.
     |
     |      When ``approx`` is True, the ``APPROX`` option is sent and the server
     |      returns an approximate cardinality computed using HyperLogLog.
     |
     |      When LIMIT is provided (defaults to 0 and means unlimited), the returned
     |      cardinality is capped at ``limit``. In exact mode the result equals
     |      ``limit`` when the real cardinality exceeds ``limit``; in approximate
     |      mode the result will not exceed ``limit``. Options are emitted in the
     |      canonical order ``APPROX`` before ``LIMIT``.
     |
     |      For more information, see https://redis.io/commands/sunioncard
     |
     |  sunionstore(self, dest: 'KeyT', keys: 'List', *args: 'List') -> 'int | Awaitable[int]'
     |      Store the union of sets specified by ``keys`` into a new
     |      set named ``dest``.  Returns the number of keys in the new set.
     |
     |      For more information, see https://redis.io/commands/sunionstore
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from redis.commands.core.StreamCommands:
     |
     |  xack(self, name: 'KeyT', groupname: 'GroupT', *ids: 'StreamIdT') -> 'int | Awaitable[int]'
     |      Acknowledges the successful processing of one or more messages.
     |
     |      Args:
     |          name: name of the stream.
     |          groupname: name of the consumer group.
     |          *ids: message ids to acknowledge.
     |
     |      For more information, see https://redis.io/commands/xack
     |
     |  xackdel(self, name: 'KeyT', groupname: 'GroupT', *ids: 'StreamIdT', ref_policy: "Literal['KEEPREF', 'DELREF', 'ACKED']" = 'KEEPREF') -> 'int | Awaitable[int]'
     |      Combines the functionality of XACK and XDEL. Acknowledges the specified
     |      message IDs in the given consumer group and simultaneously attempts to
     |      delete the corresponding entries from the stream.
     |
     |  xadd(self, name: 'KeyT', fields: 'Dict[FieldT, EncodableT]', id: 'StreamIdT' = '*', maxlen: 'Optional[int]' = None, approximate: 'bool' = True, nomkstream: 'bool' = False, minid: 'Union[StreamIdT, None]' = None, limit: 'int | None' = None, ref_policy: "Literal['KEEPREF', 'DELREF', 'ACKED'] | None" = None, idmpauto: 'str | None' = None, idmp: 'tuple[str, bytes] | None' = None) -> 'bytes | str | Awaitable[bytes | str]'
     |      Add to a stream.
     |      name: name of the stream
     |      fields: dict of field/value pairs to insert into the stream
     |      id: Location to insert this record. By default it is appended.
     |      maxlen: truncate old stream members beyond this size.
     |      Can't be specified with minid.
     |      approximate: actual stream length may be slightly more than maxlen
     |      nomkstream: When set to true, do not make a stream
     |      minid: the minimum id in the stream to query.
     |      Can't be specified with maxlen.
     |      limit: specifies the maximum number of entries to retrieve
     |      ref_policy: optional reference policy for consumer groups when trimming:
     |          - KEEPREF (default): When trimming, preserves references in consumer groups' PEL
     |          - DELREF: When trimming, removes all references from consumer groups' PEL
     |          - ACKED: When trimming, only removes entries acknowledged by all consumer groups
     |      idmpauto: Producer ID for automatic idempotent ID calculation.
     |          Automatically calculates an idempotent ID based on entry content to prevent
     |          duplicate entries. Can only be used with id='*'. Creates an IDMP map if it
     |          doesn't exist yet. The producer ID must be unique per producer and consistent
     |          across restarts.
     |      idmp: Tuple of (producer_id, idempotent_id) for explicit idempotent ID.
     |          Uses a specific idempotent ID to prevent duplicate entries. Can only be used
     |          with id='*'. The producer ID must be unique per producer and consistent across
     |          restarts. The idempotent ID must be unique per message and per producer.
     |          Shorter idempotent IDs require less memory and allow faster processing.
     |          Creates an IDMP map if it doesn't exist yet.
     |
     |      For more information, see https://redis.io/commands/xadd
     |
     |  xautoclaim(self, name: 'KeyT', groupname: 'GroupT', consumername: 'ConsumerT', min_idle_time: 'int', start_id: 'StreamIdT' = '0-0', count: 'int | None' = None, justid: 'bool' = False) -> 'list[Any] | Awaitable[list[Any]]'
     |      Transfers ownership of pending stream entries that match the specified
     |      criteria. Conceptually, equivalent to calling XPENDING and then XCLAIM,
     |      but provides a more straightforward way to deal with message delivery
     |      failures via SCAN-like semantics.
     |      name: name of the stream.
     |      groupname: name of the consumer group.
     |      consumername: name of a consumer that claims the message.
     |      min_idle_time: filter messages that were idle less than this amount of
     |      milliseconds.
     |      start_id: filter messages with equal or greater ID.
     |      count: optional integer, upper limit of the number of entries that the
     |      command attempts to claim. Set to 100 by default.
     |      justid: optional boolean, false by default. Return just an array of IDs
     |      of messages successfully claimed, without returning the actual message
     |
     |      For more information, see https://redis.io/commands/xautoclaim
     |
     |  xcfgset(self, name: 'KeyT', idmp_duration: 'int | None' = None, idmp_maxsize: 'int | None' = None) -> 'bytes | str | Awaitable[bytes | str]'
     |      Configure the idempotency parameters for a stream's IDMP map.
     |
     |      Sets how long Redis remembers each idempotent ID (iid) and the maximum
     |      number of iids to track. This command clears the existing IDMP map
     |      (Redis forgets all previously stored iids), but only if the configuration
     |      value actually changes.
     |
     |      Args:
     |          name: The name of the stream.
     |          idmp_duration: How long Redis remembers each iid in seconds.
     |              Default: 100 seconds (or value set by stream-idmp-duration config).
     |              Minimum: 1 second, Maximum: 300 seconds.
     |              Redis won't forget an iid for this duration (unless maxsize is reached).
     |              Should accommodate application crash recovery time.
     |          idmp_maxsize: Maximum number of iids Redis remembers per producer ID (pid).
     |              Default: 100 iids (or value set by stream-idmp-maxsize config).
     |              Minimum: 1 iid, Maximum: 1,000,000 (1M) iids.
     |              Should be set to: mark-delay [in msec] × (messages/msec) + margin.
     |              Example: 10K msgs/sec (10 msgs/msec), 80 msec mark-delay
     |              → maxsize = 10 × 80 + margin = 1000 iids.
     |
     |      Returns:
     |          OK on success.
     |
     |      For more information, see https://redis.io/commands/xcfgset
     |
     |  xclaim(self, name: 'KeyT', groupname: 'GroupT', consumername: 'ConsumerT', min_idle_time: 'int', message_ids: 'Union[List[StreamIdT], Tuple[StreamIdT]]', idle: 'int | None' = None, time: 'int | None' = None, retrycount: 'int | None' = None, force: 'bool' = False, justid: 'bool' = False) -> 'XClaimResponse | Awaitable[XClaimResponse]'
     |      Changes the ownership of a pending message.
     |
     |      name: name of the stream.
     |
     |      groupname: name of the consumer group.
     |
     |      consumername: name of a consumer that claims the message.
     |
     |      min_idle_time: filter messages that were idle less than this amount of
     |      milliseconds
     |
     |      message_ids: non-empty list or tuple of message IDs to claim
     |
     |      idle: optional. Set the idle time (last time it was delivered) of the
     |      message in ms
     |
     |      time: optional integer. This is the same as idle but instead of a
     |      relative amount of milliseconds, it sets the idle time to a specific
     |      Unix time (in milliseconds).
     |
     |      retrycount: optional integer. set the retry counter to the specified
     |      value. This counter is incremented every time a message is delivered
     |      again.
     |
     |      force: optional boolean, false by default. Creates the pending message
     |      entry in the PEL even if certain specified IDs are not already in the
     |      PEL assigned to a different client.
     |
     |      justid: optional boolean, false by default. Return just an array of IDs
     |      of messages successfully claimed, without returning the actual message
     |
     |      For more information, see https://redis.io/commands/xclaim
     |
     |  xdel(self, name: 'KeyT', *ids: 'StreamIdT') -> 'int | Awaitable[int]'
     |      Deletes one or more messages from a stream.
     |
     |      Args:
     |          name: name of the stream.
     |          *ids: message ids to delete.
     |
     |      For more information, see https://redis.io/commands/xdel
     |
     |  xdelex(self, name: 'KeyT', *ids: 'StreamIdT', ref_policy: "Literal['KEEPREF', 'DELREF', 'ACKED']" = 'KEEPREF') -> 'int | Awaitable[int]'
     |      Extended version of XDEL that provides more control over how message entries
     |      are deleted concerning consumer groups.
     |
     |  xgroup_create(self, name: 'KeyT', groupname: 'GroupT', id: 'StreamIdT' = '$', mkstream: 'bool' = False, entries_read: 'int | None' = None) -> 'bool | Awaitable[bool]'
     |      Create a new consumer group associated with a stream.
     |      name: name of the stream.
     |      groupname: name of the consumer group.
     |      id: ID of the last item in the stream to consider already delivered.
     |
     |      For more information, see https://redis.io/commands/xgroup-create
     |
     |  xgroup_createconsumer(self, name: 'KeyT', groupname: 'GroupT', consumername: 'ConsumerT') -> 'int | Awaitable[int]'
     |      Consumers in a consumer group are auto-created every time a new
     |      consumer name is mentioned by some command.
     |      They can be explicitly created by using this command.
     |      name: name of the stream.
     |      groupname: name of the consumer group.
     |      consumername: name of consumer to create.
     |
     |      See: https://redis.io/commands/xgroup-createconsumer
     |
     |  xgroup_delconsumer(self, name: 'KeyT', groupname: 'GroupT', consumername: 'ConsumerT') -> 'int | Awaitable[int]'
     |      Remove a specific consumer from a consumer group.
     |      Returns the number of pending messages that the consumer had before it
     |      was deleted.
     |      name: name of the stream.
     |      groupname: name of the consumer group.
     |      consumername: name of consumer to delete
     |
     |      For more information, see https://redis.io/commands/xgroup-delconsumer
     |
     |  xgroup_destroy(self, name: 'KeyT', groupname: 'GroupT') -> 'bool | Awaitable[bool]'
     |      Destroy a consumer group.
     |      name: name of the stream.
     |      groupname: name of the consumer group.
     |
     |      For more information, see https://redis.io/commands/xgroup-destroy
     |
     |  xgroup_setid(self, name: 'KeyT', groupname: 'GroupT', id: 'StreamIdT', entries_read: 'int | None' = None) -> 'bool | Awaitable[bool]'
     |      Set the consumer group last delivered ID to something else.
     |      name: name of the stream.
     |      groupname: name of the consumer group.
     |      id: ID of the last item in the stream to consider already delivered.
     |
     |      For more information, see https://redis.io/commands/xgroup-setid
     |
     |  xinfo_consumers(self, name: 'KeyT', groupname: 'GroupT') -> 'list[dict[str, Any]] | Awaitable[list[dict[str, Any]]]'
     |      Returns general information about the consumers in the group.
     |      name: name of the stream.
     |      groupname: name of the consumer group.
     |
     |      For more information, see https://redis.io/commands/xinfo-consumers
     |
     |  xinfo_groups(self, name: 'KeyT') -> 'list[dict[str, Any]] | Awaitable[list[dict[str, Any]]]'
     |      Returns general information about the consumer groups of the stream.
     |      name: name of the stream.
     |
     |      For more information, see https://redis.io/commands/xinfo-groups
     |
     |  xinfo_stream(self, name: 'KeyT', full: 'bool' = False) -> 'dict[str, Any] | Awaitable[dict[str, Any]]'
     |      Returns general information about the stream.
     |      name: name of the stream.
     |      full: optional boolean, false by default. Return full summary
     |
     |      For more information, see https://redis.io/commands/xinfo-stream
     |
     |  xlen(self, name: 'KeyT') -> 'int | Awaitable[int]'
     |      Returns the number of elements in a given stream.
     |
     |      For more information, see https://redis.io/commands/xlen
     |
     |  xnack(self, name: 'KeyT', groupname: 'GroupT', mode: "Literal['SILENT', 'FAIL', 'FATAL']", *ids: 'StreamIdT', retrycount: 'int | None' = None, force: 'bool' = False) -> 'int | Awaitable[int]'
     |      Negatively acknowledges one or more messages in a consumer group's
     |      Pending Entries List (PEL).
     |
     |      Args:
     |          name: name of the stream.
     |          groupname: name of the consumer group.
     |          mode: the nacking mode. One of SILENT, FAIL, or FATAL.
     |              SILENT: consumer shutting down; decrements delivery counter.
     |              FAIL: consumer unable to process; delivery counter unchanged.
     |              FATAL: invalid/malicious message; delivery counter set to max.
     |          *ids: one or more message IDs to NACK.
     |          retrycount: optional integer >= 0. Overrides the mode's implicit
     |              delivery counter adjustment with an exact value.
     |          force: if True, creates a new unowned PEL entry for any ID not
     |              already in the group's PEL.
     |
     |      Returns:
     |          The number of messages successfully NACKed.
     |
     |      For more information, see https://redis.io/commands/xnack
     |
     |  xpending(self, name: 'KeyT', groupname: 'GroupT') -> 'dict[str, Any] | Awaitable[dict[str, Any]]'
     |      Returns information about pending messages of a group.
     |      name: name of the stream.
     |      groupname: name of the consumer group.
     |
     |      For more information, see https://redis.io/commands/xpending
     |
     |  xpending_range(self, name: 'KeyT', groupname: 'GroupT', min: 'StreamIdT', max: 'StreamIdT', count: 'int', consumername: 'ConsumerT | None' = None, idle: 'int | None' = None) -> 'XPendingRangeResponse | Awaitable[XPendingRangeResponse]'
     |      Returns information about pending messages, in a range.
     |
     |      name: name of the stream.
     |      groupname: name of the consumer group.
     |      idle: available from  version 6.2. filter entries by their
     |      idle-time, given in milliseconds (optional).
     |      min: minimum stream ID.
     |      max: maximum stream ID.
     |      count: number of messages to return
     |      consumername: name of a consumer to filter by (optional).
     |
     |  xrange(self, name: 'KeyT', min: 'StreamIdT' = '-', max: 'StreamIdT' = '+', count: 'int | None' = None) -> 'StreamRangeResponse | None | Awaitable[StreamRangeResponse | None]'
     |      Read stream values within an interval.
     |
     |      name: name of the stream.
     |
     |      start: first stream ID. defaults to '-',
     |             meaning the earliest available.
     |
     |      finish: last stream ID. defaults to '+',
     |              meaning the latest available.
     |
     |      count: if set, only return this many items, beginning with the
     |             earliest available.
     |
     |      For more information, see https://redis.io/commands/xrange
     |
     |  xread(self, streams: 'Dict[KeyT, StreamIdT]', count: 'int | None' = None, block: 'int | None' = None, max_count: 'int | None' = None, max_size: 'int | None' = None) -> 'XReadResponse | Awaitable[XReadResponse]'
     |      Block and monitor multiple streams for new data.
     |
     |      streams: a dict of stream names to stream IDs, where
     |                 IDs indicate the last ID already seen.
     |
     |      count: if set, only return this many items per stream, beginning with
     |             the earliest available.
     |
     |      block: number of milliseconds to wait, if nothing already present.
     |
     |      max_count: if set, cap the total number of entries returned across all
     |                 streams combined. Unlike ``count`` (a per-stream limit),
     |                 this is a cumulative cap over the whole reply. Must be a
     |                 positive integer and, when ``count`` is also set, must be
     |                 greater than or equal to ``count``. Requires Redis >= 8.10.0.
     |
     |      max_size: if set, a soft cap on the total server reply size in bytes
     |                across all streams combined. Measured server-side including
     |                protocol overhead, so it is not an exact application-payload
     |                size guarantee; a single available entry larger than the cap
     |                may still be returned. Must be a positive integer. Requires
     |                Redis >= 8.10.0.
     |
     |      For more information, see https://redis.io/commands/xread
     |
     |  xreadgroup(self, groupname: 'str', consumername: 'str', streams: 'Dict[KeyT, StreamIdT]', count: 'int | None' = None, block: 'int | None' = None, noack: 'bool' = False, claim_min_idle_time: 'int | None' = None, max_count: 'int | None' = None, max_size: 'int | None' = None) -> 'XReadGroupResponse | Awaitable[XReadGroupResponse]'
     |      Read from a stream via a consumer group.
     |
     |      groupname: name of the consumer group.
     |
     |      consumername: name of the requesting consumer.
     |
     |      streams: a dict of stream names to stream IDs, where
     |             IDs indicate the last ID already seen.
     |
     |      count: if set, only return this many items per stream, beginning with
     |             the earliest available.
     |
     |      block: number of milliseconds to wait, if nothing already present.
     |      noack: do not add messages to the PEL
     |
     |      claim_min_idle_time: accepts an integer type and represents a
     |                           time interval in milliseconds
     |
     |      max_count: if set, cap the total number of entries returned across all
     |                 streams combined. Unlike ``count`` (a per-stream limit),
     |                 this is a cumulative cap over the whole reply. Must be a
     |                 positive integer and, when ``count`` is also set, must be
     |                 greater than or equal to ``count``. Requires Redis 8.10.0.
     |
     |      max_size: if set, a soft cap on the total server reply size in bytes
     |                across all streams combined. Measured server-side including
     |                protocol overhead, so it is not an exact application-payload
     |                size guarantee; a single available entry larger than the cap
     |                may still be returned. Must be a positive integer. Requires
     |                Redis 8.10.0.
     |
     |      For more information, see https://redis.io/commands/xreadgroup
     |
     |  xrevrange(self, name: 'KeyT', max: 'StreamIdT' = '+', min: 'StreamIdT' = '-', count: 'int | None' = None) -> 'StreamRangeResponse | None | Awaitable[StreamRangeResponse | None]'
     |      Read stream values within an interval, in reverse order.
     |
     |      name: name of the stream
     |
     |      start: first stream ID. defaults to '+',
     |             meaning the latest available.
     |
     |      finish: last stream ID. defaults to '-',
     |              meaning the earliest available.
     |
     |      count: if set, only return this many items, beginning with the
     |             latest available.
     |
     |      For more information, see https://redis.io/commands/xrevrange
     |
     |  xtrim(self, name: 'KeyT', maxlen: 'int | None' = None, approximate: 'bool' = True, minid: 'StreamIdT | None' = None, limit: 'int | None' = None, ref_policy: "Literal['KEEPREF', 'DELREF', 'ACKED'] | None" = None) -> 'int | Awaitable[int]'
     |      Trims old messages from a stream.
     |      name: name of the stream.
     |      maxlen: truncate old stream messages beyond this size
     |      Can't be specified with minid.
     |      approximate: actual stream length may be slightly more than maxlen
     |      minid: the minimum id in the stream to query
     |      Can't be specified with maxlen.
     |      limit: specifies the maximum number of entries to retrieve
     |      ref_policy: optional reference policy for consumer groups:
     |          - KEEPREF (default): Trims entries but preserves references in consumer groups' PEL
     |          - DELREF: Trims entries and removes all references from consumer groups' PEL
     |          - ACKED: Only trims entries that were read and acknowledged by all consumer groups
     |
     |      For more information, see https://redis.io/commands/xtrim
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from redis.commands.core.SortedSetCommands:
     |
     |  bzmpop(self, timeout: 'float', numkeys: 'int', keys: 'List[str]', min: 'bool | None' = False, max: 'bool | None' = False, count: 'int | None' = 1) -> 'ZMPopResponse | Awaitable[ZMPopResponse]'
     |      Pop ``count`` values (default 1) off of the first non-empty sorted set
     |      named in the ``keys`` list.
     |
     |      If none of the sorted sets in ``keys`` has a value to pop,
     |      then block for ``timeout`` seconds, or until a member gets added
     |      to one of the sorted sets.
     |
     |      If timeout is 0, then block indefinitely.
     |
     |      For more information, see https://redis.io/commands/bzmpop
     |
     |  bzpopmax(self, keys: 'KeysT', timeout: 'TimeoutSecT' = 0) -> 'BlockingZSetPopResponse | Awaitable[BlockingZSetPopResponse]'
     |      ZPOPMAX a value off of the first non-empty sorted set
     |      named in the ``keys`` list.
     |
     |      If none of the sorted sets in ``keys`` has a value to ZPOPMAX,
     |      then block for ``timeout`` seconds, or until a member gets added
     |      to one of the sorted sets.
     |
     |      If timeout is 0, then block indefinitely.
     |
     |      For more information, see https://redis.io/commands/bzpopmax
     |
     |  bzpopmin(self, keys: 'KeysT', timeout: 'TimeoutSecT' = 0) -> 'BlockingZSetPopResponse | Awaitable[BlockingZSetPopResponse]'
     |      ZPOPMIN a value off of the first non-empty sorted set
     |      named in the ``keys`` list.
     |
     |      If none of the sorted sets in ``keys`` has a value to ZPOPMIN,
     |      then block for ``timeout`` seconds, or until a member gets added
     |      to one of the sorted sets.
     |
     |      If timeout is 0, then block indefinitely.
     |
     |      For more information, see https://redis.io/commands/bzpopmin
     |
     |  zadd(self, name: 'KeyT', mapping: 'Mapping[AnyKeyT, EncodableT]', nx: 'bool' = False, xx: 'bool' = False, ch: 'bool' = False, incr: 'bool' = False, gt: 'bool' = False, lt: 'bool' = False) -> 'int | float | None | Awaitable[int | float | None]'
     |      Set any number of element-name, score pairs to the key ``name``. Pairs
     |      are specified as a dict of element-names keys to score values.
     |
     |      ``nx`` forces ZADD to only create new elements and not to update
     |      scores for elements that already exist.
     |
     |      ``xx`` forces ZADD to only update scores of elements that already
     |      exist. New elements will not be added.
     |
     |      ``ch`` modifies the return value to be the numbers of elements changed.
     |      Changed elements include new elements that were added and elements
     |      whose scores changed.
     |
     |      ``incr`` modifies ZADD to behave like ZINCRBY. In this mode only a
     |      single element/score pair can be specified and the score is the amount
     |      the existing score will be incremented by. When using this mode the
     |      return value of ZADD will be the new score of the element.
     |
     |      ``lt`` only updates existing elements if the new score is less than
     |      the current score. This flag doesn't prevent adding new elements.
     |
     |      ``gt`` only updates existing elements if the new score is greater than
     |      the current score. This flag doesn't prevent adding new elements.
     |
     |      The return value of ZADD varies based on the mode specified. With no
     |      options, ZADD returns the number of new elements added to the sorted
     |      set.
     |
     |      ``nx``, ``lt``, and ``gt`` are mutually exclusive options.
     |
     |      See: https://redis.io/commands/ZADD
     |
     |  zcard(self, name: 'KeyT') -> 'int | Awaitable[int]'
     |      Return the number of elements in the sorted set ``name``
     |
     |      For more information, see https://redis.io/commands/zcard
     |
     |  zcount(self, name: 'KeyT', min: 'ZScoreBoundT', max: 'ZScoreBoundT') -> 'int | Awaitable[int]'
     |      Returns the number of elements in the sorted set at key ``name`` with
     |      a score between ``min`` and ``max``.
     |
     |      For more information, see https://redis.io/commands/zcount
     |
     |  zdiff(self, keys: 'KeysT', withscores: 'bool' = False) -> 'ZSetRangeResponse | Awaitable[ZSetRangeResponse]'
     |      Returns the difference between the first and all successive input
     |      sorted sets provided in ``keys``.
     |
     |      For more information, see https://redis.io/commands/zdiff
     |
     |  zdiffstore(self, dest: 'KeyT', keys: 'KeysT') -> 'int | Awaitable[int]'
     |      Computes the difference between the first and all successive input
     |      sorted sets provided in ``keys`` and stores the result in ``dest``.
     |
     |      For more information, see https://redis.io/commands/zdiffstore
     |
     |  zincrby(self, name: 'KeyT', amount: 'float', value: 'EncodableT') -> 'float | None | Awaitable[float | None]'
     |      Increment the score of ``value`` in sorted set ``name`` by ``amount``
     |
     |      For more information, see https://redis.io/commands/zincrby
     |
     |  zinter(self, keys: 'KeysT', aggregate: 'str | None' = None, withscores: 'bool' = False) -> 'ZSetRangeResponse | Awaitable[ZSetRangeResponse]'
     |      Return the intersect of multiple sorted sets specified by ``keys``.
     |
     |      With the ``aggregate`` option, it is possible to specify how the
     |      results of the intersection are aggregated. Available aggregation
     |      modes:
     |
     |      - ``SUM`` (default): the score of an element is summed across the
     |        inputs where it exists.
     |        Score = SUM(score₁×weight₁, score₂×weight₂, ...)
     |      - ``MIN``: the resulting set will contain the minimum score of an
     |        element across the inputs where it exists.
     |        Score = MIN(score₁×weight₁, score₂×weight₂, ...)
     |      - ``MAX``: the resulting set will contain the maximum score of an
     |        element across the inputs where it exists.
     |        Score = MAX(score₁×weight₁, score₂×weight₂, ...)
     |      - ``COUNT``: ignores the original scores and counts weighted set
     |        membership. Each element's score is the sum of the weights of
     |        the input sets that contain it.
     |        Score = SUM(weight₁, weight₂, ...) for sets containing the element.
     |        When all weights are 1 (default), the score equals the number
     |        of input sets containing the element.
     |
     |      For more information, see https://redis.io/commands/zinter
     |
     |  zintercard(self, numkeys: 'int', keys: 'List[str]', limit: 'int' = 0) -> 'int | Awaitable[int]'
     |      Return the cardinality of the intersect of multiple sorted sets
     |      specified by ``keys``.
     |      When LIMIT provided (defaults to 0 and means unlimited), if the intersection
     |      cardinality reaches limit partway through the computation, the algorithm will
     |      exit and yield limit as the cardinality
     |
     |      For more information, see https://redis.io/commands/zintercard
     |
     |  zinterstore(self, dest: 'KeyT', keys: 'Sequence[KeyT] | Mapping[AnyKeyT, float]', aggregate: 'str | None' = None) -> 'int | Awaitable[int]'
     |      Intersect multiple sorted sets specified by ``keys`` into a new
     |      sorted set, ``dest``. Scores in the destination will be aggregated
     |      based on the ``aggregate``.
     |
     |      Available aggregation modes:
     |
     |      - ``SUM`` (default): the score of an element is summed across the
     |        inputs where it exists.
     |        Score = SUM(score₁×weight₁, score₂×weight₂, ...)
     |      - ``MIN``: the resulting set will contain the minimum score of an
     |        element across the inputs where it exists.
     |        Score = MIN(score₁×weight₁, score₂×weight₂, ...)
     |      - ``MAX``: the resulting set will contain the maximum score of an
     |        element across the inputs where it exists.
     |        Score = MAX(score₁×weight₁, score₂×weight₂, ...)
     |      - ``COUNT``: ignores the original scores and counts weighted set
     |        membership. Each element's score is the sum of the weights of
     |        the input sets that contain it.
     |        Score = SUM(weight₁, weight₂, ...) for sets containing the element.
     |        When all weights are 1 (default), the score equals the number
     |        of input sets containing the element.
     |
     |      For more information, see https://redis.io/commands/zinterstore
     |
     |  zlexcount(self, name: 'KeyT', min: 'EncodableT', max: 'EncodableT') -> 'int | Awaitable[int]'
     |      Return the number of items in the sorted set ``name`` between the
     |      lexicographical range ``min`` and ``max``.
     |
     |      For more information, see https://redis.io/commands/zlexcount
     |
     |  zmpop(self, num_keys: 'int', keys: 'List[str]', min: 'bool | None' = False, max: 'bool | None' = False, count: 'int | None' = 1) -> 'ZMPopResponse | Awaitable[ZMPopResponse]'
     |      Pop ``count`` values (default 1) off of the first non-empty sorted set
     |      named in the ``keys`` list.
     |      For more information, see https://redis.io/commands/zmpop
     |
     |  zmscore(self, key: 'KeyT', members: 'List[str]') -> 'list[float | None] | Awaitable[list[float | None]]'
     |      Returns the scores associated with the specified members
     |      in the sorted set stored at key.
     |      ``members`` should be a list of the member name.
     |      Return type is a list of score.
     |      If the member does not exist, a None will be returned
     |      in corresponding position.
     |
     |      For more information, see https://redis.io/commands/zmscore
     |
     |  zpopmax(self, name: 'KeyT', count: 'int | None' = None) -> 'ZSetRangeResponse | Awaitable[ZSetRangeResponse]'
     |      Remove and return up to ``count`` members with the highest scores
     |      from the sorted set ``name``.
     |
     |      For more information, see https://redis.io/commands/zpopmax
     |
     |  zpopmin(self, name: 'KeyT', count: 'int | None' = None) -> 'ZSetRangeResponse | Awaitable[ZSetRangeResponse]'
     |      Remove and return up to ``count`` members with the lowest scores
     |      from the sorted set ``name``.
     |
     |      For more information, see https://redis.io/commands/zpopmin
     |
     |  zrandmember(self, key: 'KeyT', count: 'int | None' = None, withscores: 'bool' = False) -> 'ZRandMemberResponse | Awaitable[ZRandMemberResponse]'
     |      Return a random element from the sorted set value stored at key.
     |
     |      ``count`` if the argument is positive, return an array of distinct
     |      fields. If called with a negative count, the behavior changes and
     |      the command is allowed to return the same field multiple times.
     |      In this case, the number of returned fields is the absolute value
     |      of the specified count.
     |
     |      ``withscores`` The optional WITHSCORES modifier changes the reply so it
     |      includes the respective scores of the randomly selected elements from
     |      the sorted set.
     |
     |      For more information, see https://redis.io/commands/zrandmember
     |
     |  zrange(self, name: 'KeyT', start: 'EncodableT', end: 'EncodableT', desc: 'bool' = False, withscores: 'bool' = False, score_cast_func: 'type | Callable' = <class 'float'>, byscore: 'bool' = False, bylex: 'bool' = False, offset: 'int | None' = None, num: 'int | None' = None) -> 'ZSetRangeResponse | Awaitable[ZSetRangeResponse]'
     |      Return a range of values from sorted set ``name`` between
     |      ``start`` and ``end`` sorted in ascending order.
     |
     |      ``start`` and ``end`` can be negative, indicating the end of the range.
     |
     |      ``desc`` a boolean indicating whether to sort the results in reversed
     |      order.
     |
     |      ``withscores`` indicates to return the scores along with the values.
     |      The return type is a list of (value, score) pairs.
     |
     |      ``score_cast_func`` a callable used to cast the score return value.
     |
     |      ``byscore`` when set to True, returns the range of elements from the
     |      sorted set having scores equal or between ``start`` and ``end``.
     |
     |      ``bylex`` when set to True, returns the range of elements from the
     |      sorted set between the ``start`` and ``end`` lexicographical closed
     |      range intervals.
     |      Valid ``start`` and ``end`` must start with ( or [, in order to specify
     |      whether the range interval is exclusive or inclusive, respectively.
     |
     |      ``offset`` and ``num`` are specified, then return a slice of the range.
     |      Can't be provided when using ``bylex``.
     |
     |      For more information, see https://redis.io/commands/zrange
     |
     |  zrangebylex(self, name: 'KeyT', min: 'EncodableT', max: 'EncodableT', start: 'int | None' = None, num: 'int | None' = None) -> 'list[bytes | str] | Awaitable[list[bytes | str]]'
     |      Return the lexicographical range of values from sorted set ``name``
     |      between ``min`` and ``max``.
     |
     |      If ``start`` and ``num`` are specified, then return a slice of the
     |      range.
     |
     |      For more information, see https://redis.io/commands/zrangebylex
     |
     |  zrangebyscore(self, name: 'KeyT', min: 'ZScoreBoundT', max: 'ZScoreBoundT', start: 'int | None' = None, num: 'int | None' = None, withscores: 'bool' = False, score_cast_func: 'type | Callable' = <class 'float'>) -> 'ZSetRangeResponse | Awaitable[ZSetRangeResponse]'
     |      Return a range of values from the sorted set ``name`` with scores
     |      between ``min`` and ``max``.
     |
     |      If ``start`` and ``num`` are specified, then return a slice
     |      of the range.
     |
     |      ``withscores`` indicates to return the scores along with the values.
     |      The return type is a list of (value, score) pairs
     |
     |      `score_cast_func`` a callable used to cast the score return value
     |
     |      For more information, see https://redis.io/commands/zrangebyscore
     |
     |  zrangestore(self, dest: 'KeyT', name: 'KeyT', start: 'EncodableT', end: 'EncodableT', byscore: 'bool' = False, bylex: 'bool' = False, desc: 'bool' = False, offset: 'int | None' = None, num: 'int | None' = None) -> 'int | Awaitable[int]'
     |      Stores in ``dest`` the result of a range of values from sorted set
     |      ``name`` between ``start`` and ``end`` sorted in ascending order.
     |
     |      ``start`` and ``end`` can be negative, indicating the end of the range.
     |
     |      ``byscore`` when set to True, returns the range of elements from the
     |      sorted set having scores equal or between ``start`` and ``end``.
     |
     |      ``bylex`` when set to True, returns the range of elements from the
     |      sorted set between the ``start`` and ``end`` lexicographical closed
     |      range intervals.
     |      Valid ``start`` and ``end`` must start with ( or [, in order to specify
     |      whether the range interval is exclusive or inclusive, respectively.
     |
     |      ``desc`` a boolean indicating whether to sort the results in reversed
     |      order.
     |
     |      ``offset`` and ``num`` are specified, then return a slice of the range.
     |      Can't be provided when using ``bylex``.
     |
     |      For more information, see https://redis.io/commands/zrangestore
     |
     |  zrank(self, name: 'KeyT', value: 'EncodableT', withscore: 'bool' = False, score_cast_func: 'type | Callable' = <class 'float'>) -> 'int | list[Any] | None | Awaitable[int | list[Any] | None]'
     |      Returns a 0-based value indicating the rank of ``value`` in sorted set
     |      ``name``.
     |      The optional WITHSCORE argument supplements the command's
     |      reply with the score of the element returned.
     |
     |      ``score_cast_func`` a callable used to cast the score return value
     |
     |      For more information, see https://redis.io/commands/zrank
     |
     |  zrem(self, name: 'KeyT', *values: 'FieldT') -> 'int | Awaitable[int]'
     |      Remove member ``values`` from sorted set ``name``
     |
     |      For more information, see https://redis.io/commands/zrem
     |
     |  zremrangebylex(self, name: 'KeyT', min: 'EncodableT', max: 'EncodableT') -> 'int | Awaitable[int]'
     |      Remove all elements in the sorted set ``name`` between the
     |      lexicographical range specified by ``min`` and ``max``.
     |
     |      Returns the number of elements removed.
     |
     |      For more information, see https://redis.io/commands/zremrangebylex
     |
     |  zremrangebyrank(self, name: 'KeyT', min: 'int', max: 'int') -> 'int | Awaitable[int]'
     |      Remove all elements in the sorted set ``name`` with ranks between
     |      ``min`` and ``max``. Values are 0-based, ordered from smallest score
     |      to largest. Values can be negative indicating the highest scores.
     |      Returns the number of elements removed
     |
     |      For more information, see https://redis.io/commands/zremrangebyrank
     |
     |  zremrangebyscore(self, name: 'KeyT', min: 'ZScoreBoundT', max: 'ZScoreBoundT') -> 'int | Awaitable[int]'
     |      Remove all elements in the sorted set ``name`` with scores
     |      between ``min`` and ``max``. Returns the number of elements removed.
     |
     |      For more information, see https://redis.io/commands/zremrangebyscore
     |
     |  zrevrange(self, name: 'KeyT', start: 'int', end: 'int', withscores: 'bool' = False, score_cast_func: 'type | Callable' = <class 'float'>) -> 'ZSetRangeResponse | Awaitable[ZSetRangeResponse]'
     |      Return a range of values from sorted set ``name`` between
     |      ``start`` and ``end`` sorted in descending order.
     |
     |      ``start`` and ``end`` can be negative, indicating the end of the range.
     |
     |      ``withscores`` indicates to return the scores along with the values
     |      The return type is a list of (value, score) pairs
     |
     |      ``score_cast_func`` a callable used to cast the score return value
     |
     |      For more information, see https://redis.io/commands/zrevrange
     |
     |  zrevrangebylex(self, name: 'KeyT', max: 'EncodableT', min: 'EncodableT', start: 'int | None' = None, num: 'int | None' = None) -> 'list[bytes | str] | Awaitable[list[bytes | str]]'
     |      Return the reversed lexicographical range of values from sorted set
     |      ``name`` between ``max`` and ``min``.
     |
     |      If ``start`` and ``num`` are specified, then return a slice of the
     |      range.
     |
     |      For more information, see https://redis.io/commands/zrevrangebylex
     |
     |  zrevrangebyscore(self, name: 'KeyT', max: 'ZScoreBoundT', min: 'ZScoreBoundT', start: 'int | None' = None, num: 'int | None' = None, withscores: 'bool' = False, score_cast_func: 'type | Callable' = <class 'float'>) -> 'ZSetRangeResponse | Awaitable[ZSetRangeResponse]'
     |      Return a range of values from the sorted set ``name`` with scores
     |      between ``min`` and ``max`` in descending order.
     |
     |      If ``start`` and ``num`` are specified, then return a slice
     |      of the range.
     |
     |      ``withscores`` indicates to return the scores along with the values.
     |      The return type is a list of (value, score) pairs
     |
     |      ``score_cast_func`` a callable used to cast the score return value
     |
     |      For more information, see https://redis.io/commands/zrevrangebyscore
     |
     |  zrevrank(self, name: 'KeyT', value: 'EncodableT', withscore: 'bool' = False, score_cast_func: 'type | Callable' = <class 'float'>) -> 'int | list[Any] | None | Awaitable[int | list[Any] | None]'
     |      Returns a 0-based value indicating the descending rank of
     |      ``value`` in sorted set ``name``.
     |      The optional ``withscore`` argument supplements the command's
     |      reply with the score of the element returned.
     |
     |      ``score_cast_func`` a callable used to cast the score return value
     |
     |      For more information, see https://redis.io/commands/zrevrank
     |
     |  zscore(self, name: 'KeyT', value: 'EncodableT') -> 'float | None | Awaitable[float | None]'
     |      Return the score of element ``value`` in sorted set ``name``
     |
     |      For more information, see https://redis.io/commands/zscore
     |
     |  zunion(self, keys: 'Sequence[KeyT] | Mapping[AnyKeyT, float]', aggregate: 'str | None' = None, withscores: 'bool' = False, score_cast_func: 'type | Callable' = <class 'float'>) -> 'ZSetRangeResponse | Awaitable[ZSetRangeResponse]'
     |      Return the union of multiple sorted sets specified by ``keys``.
     |      ``keys`` can be provided as dictionary of keys and their weights.
     |      Scores will be aggregated based on the ``aggregate``, or SUM if
     |      none is provided.
     |
     |      Available aggregation modes:
     |
     |      - ``SUM`` (default): the score of an element is summed across the
     |        inputs where it exists.
     |        Score = SUM(score₁×weight₁, score₂×weight₂, ...)
     |      - ``MIN``: the resulting set will contain the minimum score of an
     |        element across the inputs where it exists.
     |        Score = MIN(score₁×weight₁, score₂×weight₂, ...)
     |      - ``MAX``: the resulting set will contain the maximum score of an
     |        element across the inputs where it exists.
     |        Score = MAX(score₁×weight₁, score₂×weight₂, ...)
     |      - ``COUNT``: ignores the original scores and counts weighted set
     |        membership. Each element's score is the sum of the weights of
     |        the input sets that contain it.
     |        Score = SUM(weight₁, weight₂, ...) for sets containing the element.
     |        When all weights are 1 (default), the score equals the number
     |        of input sets containing the element.
     |
     |      ``score_cast_func`` a callable used to cast the score return value
     |
     |      For more information, see https://redis.io/commands/zunion
     |
     |  zunionstore(self, dest: 'KeyT', keys: 'Sequence[KeyT] | Mapping[AnyKeyT, float]', aggregate: 'str | None' = None) -> 'int | Awaitable[int]'
     |      Union multiple sorted sets specified by ``keys`` into
     |      a new sorted set, ``dest``. Scores in the destination will be
     |      aggregated based on the ``aggregate``, or SUM if none is provided.
     |
     |      Available aggregation modes:
     |
     |      - ``SUM`` (default): the score of an element is summed across the
     |        inputs where it exists.
     |        Score = SUM(score₁×weight₁, score₂×weight₂, ...)
     |      - ``MIN``: the resulting set will contain the minimum score of an
     |        element across the inputs where it exists.
     |        Score = MIN(score₁×weight₁, score₂×weight₂, ...)
     |      - ``MAX``: the resulting set will contain the maximum score of an
     |        element across the inputs where it exists.
     |        Score = MAX(score₁×weight₁, score₂×weight₂, ...)
     |      - ``COUNT``: ignores the original scores and counts weighted set
     |        membership. Each element's score is the sum of the weights of
     |        the input sets that contain it.
     |        Score = SUM(weight₁, weight₂, ...) for sets containing the element.
     |        When all weights are 1 (default), the score equals the number
     |        of input sets containing the element.
     |
     |      For more information, see https://redis.io/commands/zunionstore
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from redis.commands.core.AsyncScriptCommands:
     |
     |  register_script(self: "Union['redis.asyncio.client.Redis', 'redis.asyncio.cluster.RedisCluster']", script: 'ScriptTextT') -> 'AsyncScript'
     |      Register a Lua ``script`` specifying the ``keys`` it will touch.
     |      Returns a Script object that is callable and hides the complexity of
     |      deal with scripts, keys, and shas. This is the preferred way to work
     |      with Lua scripts.
     |
     |  async script_debug(self, *args) -> 'None'
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from redis.commands.core.ScriptCommands:
     |
     |  eval(self, script: 'str', numkeys: 'int', *keys_and_args: 'KeyT | EncodableT') -> 'Any | Awaitable[Any]'
     |      Execute the Lua ``script``, specifying the ``numkeys`` the script
     |      will touch and the key names and argument values in ``keys_and_args``.
     |      Returns the result of the script.
     |
     |      In practice, use the object returned by ``register_script``. This
     |      function exists purely for Redis API completion.
     |
     |      For more information, see  https://redis.io/commands/eval
     |
     |  eval_ro(self, script: 'str', numkeys: 'int', *keys_and_args: 'KeyT | EncodableT') -> 'Any | Awaitable[Any]'
     |      The read-only variant of the EVAL command
     |
     |      Execute the read-only Lua ``script`` specifying the ``numkeys`` the script
     |      will touch and the key names and argument values in ``keys_and_args``.
     |      Returns the result of the script.
     |
     |      For more information, see  https://redis.io/commands/eval_ro
     |
     |  evalsha(self, sha: 'str', numkeys: 'int', *keys_and_args: 'KeyT | EncodableT') -> 'Any | Awaitable[Any]'
     |      Use the ``sha`` to execute a Lua script already registered via EVAL
     |      or SCRIPT LOAD. Specify the ``numkeys`` the script will touch and the
     |      key names and argument values in ``keys_and_args``. Returns the result
     |      of the script.
     |
     |      In practice, use the object returned by ``register_script``. This
     |      function exists purely for Redis API completion.
     |
     |      For more information, see  https://redis.io/commands/evalsha
     |
     |  evalsha_ro(self, sha: 'str', numkeys: 'int', *keys_and_args: 'KeyT | EncodableT') -> 'Any | Awaitable[Any]'
     |      The read-only variant of the EVALSHA command
     |
     |      Use the ``sha`` to execute a read-only Lua script already registered via EVAL
     |      or SCRIPT LOAD. Specify the ``numkeys`` the script will touch and the
     |      key names and argument values in ``keys_and_args``. Returns the result
     |      of the script.
     |
     |      For more information, see  https://redis.io/commands/evalsha_ro
     |
     |  script_exists(self, *args: 'str') -> 'list[bool] | Awaitable[list[bool]]'
     |      Check if a script exists in the script cache by specifying the SHAs of
     |      each script as ``args``. Returns a list of boolean values indicating if
     |      if each already script exists in the cache_data.
     |
     |      For more information, see  https://redis.io/commands/script-exists
     |
     |  script_flush(self, sync_type: "Literal['SYNC'] | Literal['ASYNC'] | None" = None) -> 'bool | Awaitable[bool]'
     |      Flush all scripts from the script cache_data.
     |
     |      ``sync_type`` is by default SYNC (synchronous) but it can also be
     |                    ASYNC.
     |
     |      For more information, see  https://redis.io/commands/script-flush
     |
     |  script_kill(self) -> 'bool | Awaitable[bool]'
     |      Kill the currently executing Lua script
     |
     |      For more information, see https://redis.io/commands/script-kill
     |
     |  script_load(self, script: 'ScriptTextT') -> 'str | Awaitable[str]'
     |      Load a Lua ``script`` into the script cache_data. Returns the SHA.
     |
     |      For more information, see https://redis.io/commands/script-load
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from redis.commands.core.FunctionCommands:
     |
     |  fcall(self, function, numkeys: 'int', *keys_and_args: 'Any') -> 'Any | Awaitable[Any]'
     |      Invoke a function.
     |
     |      For more information, see https://redis.io/commands/fcall
     |
     |  fcall_ro(self, function, numkeys: 'int', *keys_and_args: 'Any') -> 'Any | Awaitable[Any]'
     |      This is a read-only variant of the FCALL command that cannot
     |      execute commands that modify data.
     |
     |      For more information, see https://redis.io/commands/fcall_ro
     |
     |  function_delete(self, library: 'str') -> 'bool | Awaitable[bool]'
     |      Delete the library called ``library`` and all its functions.
     |
     |      For more information, see https://redis.io/commands/function-delete
     |
     |  function_dump(self) -> 'bytes | Awaitable[bytes]'
     |      Return the serialized payload of loaded libraries.
     |
     |      For more information, see https://redis.io/commands/function-dump
     |
     |  function_flush(self, mode: 'str' = 'SYNC') -> 'bool | Awaitable[bool]'
     |      Deletes all the libraries.
     |
     |      For more information, see https://redis.io/commands/function-flush
     |
     |  function_kill(self) -> 'bytes | str | Awaitable[bytes | str]'
     |      Kill a function that is currently executing.
     |
     |      For more information, see https://redis.io/commands/function-kill
     |
     |  function_list(self, library: 'str | None' = '*', withcode: 'bool | None' = False) -> 'list[Any] | Awaitable[list[Any]]'
     |      Return information about the functions and libraries.
     |
     |      Args:
     |
     |          library: specify a pattern for matching library names
     |          withcode: cause the server to include the libraries source implementation
     |              in the reply
     |
     |  function_load(self, code: 'str', replace: 'bool | None' = False) -> 'bytes | str | Awaitable[bytes | str]'
     |      Load a library to Redis.
     |      :param code: the source code (must start with
     |      Shebang statement that provides a metadata about the library)
     |      :param replace: changes the behavior to overwrite the existing library
     |      with the new contents.
     |      Return the library name that was loaded.
     |
     |      For more information, see https://redis.io/commands/function-load
     |
     |  function_restore(self, payload: 'str', policy: 'str | None' = 'APPEND') -> 'bool | Awaitable[bool]'
     |      Restore libraries from the serialized ``payload``.
     |      You can use the optional policy argument to provide a policy
     |      for handling existing libraries.
     |
     |      For more information, see https://redis.io/commands/function-restore
     |
     |  function_stats(self) -> 'Any | Awaitable[Any]'
     |      Return information about the function that's currently running
     |      and information about the available execution engines.
     |
     |      For more information, see https://redis.io/commands/function-stats
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from redis.commands.core.ModuleCommands:
     |
     |  command_getkeys(self, *args) -> 'list[bytes | str] | Awaitable[list[bytes | str]]'
     |
     |  module_list(self) -> 'list[dict[Any, Any]] | Awaitable[list[dict[Any, Any]]]'
     |      Returns a list of dictionaries containing the name and version of
     |      all loaded modules.
     |
     |      For more information, see https://redis.io/commands/module-list
     |
     |  module_load(self, path, *args) -> 'bool | Awaitable[bool]'
     |      Loads the module from ``path``.
     |      Passes all ``*args`` to the module, during loading.
     |      Raises ``ModuleError`` if a module is not found at ``path``.
     |
     |      For more information, see https://redis.io/commands/module-load
     |
     |  module_loadex(self, path: 'str', options: 'List[str] | None' = None, args: 'List[str] | None' = None) -> 'bytes | str | Awaitable[bytes | str]'
     |      Loads a module from a dynamic library at runtime with configuration directives.
     |
     |      For more information, see https://redis.io/commands/module-loadex
     |
     |  module_unload(self, name) -> 'bool | Awaitable[bool]'
     |      Unloads the module ``name``.
     |      Raises ``ModuleError`` if ``name`` is not in loaded modules.
     |
     |      For more information, see https://redis.io/commands/module-unload
     |
     |  ----------------------------------------------------------------------
     |  Data and other attributes inherited from redis.typing.CommandsProtocol:
     |
     |  __protocol_attrs__ = {'_event_dispatcher', 'execute_command'}
     |
     |  ----------------------------------------------------------------------
     |  Class methods inherited from typing.Protocol:
     |
     |  __init_subclass__(*args, **kwargs)
     |      This method is called when a class is subclassed.
     |
     |      The default implementation does nothing. It may be
     |      overridden to extend subclasses.
     |
     |  ----------------------------------------------------------------------
     |  Class methods inherited from typing.Generic:
     |
     |  __class_getitem__(...)
     |      Parameterizes a generic class.
     |
     |      At least, parameterizing a generic class is the *main* thing this
     |      method does. For example, for some generic class `Foo`, this is called
     |      when we do `Foo[int]` - there, with `cls=Foo` and `params=int`.
     |
     |      However, note that this method is also called when defining generic
     |      classes in the first place with `class Foo[T]: ...`.
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from redis.commands.redismodules.AsyncRedisModuleCommands:
     |
     |  bf(self) -> 'AsyncBFBloom'
     |      Access the bloom namespace.
     |
     |  cf(self) -> 'AsyncCFBloom'
     |      Access the bloom namespace.
     |
     |  cms(self) -> 'AsyncCMSBloom'
     |      Access the bloom namespace.
     |
     |  ft(self, index_name='idx') -> 'AsyncSearch'
     |      Access the search namespace, providing support for redis search.
     |
     |  json(self, encoder=<json.encoder.JSONEncoder object at 0x0000017B9C589190>, decoder=<json.decoder.JSONDecoder object at 0x0000017B9C589220>) -> 'AsyncJSON'
     |      Access the json namespace, providing support for redis json.
     |
     |  tdigest(self) -> 'AsyncTDigestBloom'
     |      Access the bloom namespace.
     |
     |  topk(self) -> 'AsyncTOPKBloom'
     |      Access the bloom namespace.
     |
     |  ts(self) -> 'AsyncTimeSeries'
     |      Access the timeseries namespace, providing support for
     |      redis timeseries data.
     |
     |  vset(self) -> 'AsyncVectorSet'
     |      Access the VectorSet commands namespace.

    class RedisError(builtins.Exception)
     |  RedisError(*args, status_code: str | None = None)
     |
     |  Method resolution order:
     |      RedisError
     |      builtins.Exception
     |      builtins.BaseException
     |      builtins.object
     |
     |  Methods defined here:
     |
     |  __init__(self, *args, status_code: str | None = None)
     |      Initialize self.  See help(type(self)) for accurate signature.
     |
     |  __repr__(self)
     |      Return repr(self).
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors defined here:
     |
     |  __weakref__
     |      list of weak references to the object
     |
     |  ----------------------------------------------------------------------
     |  Static methods inherited from builtins.Exception:
     |
     |  __new__(*args, **kwargs) class method of builtins.Exception
     |      Create and return a new object.  See help(type) for accurate signature.
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from builtins.BaseException:
     |
     |  __getattribute__(self, name, /)
     |      Return getattr(self, name).
     |
     |  __reduce__(...)
     |      Helper for pickle.
     |
     |  __setstate__(...)
     |
     |  __str__(self, /)
     |      Return str(self).
     |
     |  add_note(...)
     |      Exception.add_note(note) --
     |      add a note to the exception
     |
     |  with_traceback(...)
     |      Exception.with_traceback(tb) --
     |      set self.__traceback__ to tb and return self.
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors inherited from builtins.BaseException:
     |
     |  __cause__
     |      exception cause
     |
     |  __context__
     |      exception context
     |
     |  __dict__
     |
     |  __suppress_context__
     |
     |  __traceback__
     |
     |  args

    class ResponseError(RedisError)
     |  ResponseError(*args, status_code: str | None = None)
     |
     |  Method resolution order:
     |      ResponseError
     |      RedisError
     |      builtins.Exception
     |      builtins.BaseException
     |      builtins.object
     |
     |  Methods inherited from RedisError:
     |
     |  __init__(self, *args, status_code: str | None = None)
     |      Initialize self.  See help(type(self)) for accurate signature.
     |
     |  __repr__(self)
     |      Return repr(self).
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors inherited from RedisError:
     |
     |  __weakref__
     |      list of weak references to the object
     |
     |  ----------------------------------------------------------------------
     |  Static methods inherited from builtins.Exception:
     |
     |  __new__(*args, **kwargs) class method of builtins.Exception
     |      Create and return a new object.  See help(type) for accurate signature.
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from builtins.BaseException:
     |
     |  __getattribute__(self, name, /)
     |      Return getattr(self, name).
     |
     |  __reduce__(...)
     |      Helper for pickle.
     |
     |  __setstate__(...)
     |
     |  __str__(self, /)
     |      Return str(self).
     |
     |  add_note(...)
     |      Exception.add_note(note) --
     |      add a note to the exception
     |
     |  with_traceback(...)
     |      Exception.with_traceback(tb) --
     |      set self.__traceback__ to tb and return self.
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors inherited from builtins.BaseException:
     |
     |  __cause__
     |      exception cause
     |
     |  __context__
     |      exception context
     |
     |  __dict__
     |
     |  __suppress_context__
     |
     |  __traceback__
     |
     |  args

    class SSLConnection(Connection)
     |  SSLConnection(ssl_keyfile: Optional[str] = None, ssl_certfile: Optional[str] = None, ssl_cert_reqs: Union[str, ssl.VerifyMode] = 'required', ssl_include_verify_flags: Optional[List[ForwardRef('ssl.VerifyFlags')]] = None, ssl_exclude_verify_flags: Optional[List[ForwardRef('ssl.VerifyFlags')]] = None, ssl_ca_certs: Optional[str] = None, ssl_ca_data: Optional[str] = None, ssl_ca_path: Optional[str] = None, ssl_check_hostname: bool = True, ssl_min_version: Optional[ssl.TLSVersion] = None, ssl_ciphers: Optional[str] = None, ssl_password: Optional[str] = None, **kwargs)
     |
     |  Manages SSL connections to and from the Redis server(s).
     |  This class extends the Connection class, adding SSL functionality, and making
     |  use of ssl.SSLContext (https://docs.python.org/3/library/ssl.html#ssl.SSLContext)
     |
     |  Method resolution order:
     |      SSLConnection
     |      Connection
     |      AbstractConnection
     |      AsyncMaintNotificationsAbstractConnection
     |      builtins.object
     |
     |  Methods defined here:
     |
     |  __init__(self, ssl_keyfile: Optional[str] = None, ssl_certfile: Optional[str] = None, ssl_cert_reqs: Union[str, ssl.VerifyMode] = 'required', ssl_include_verify_flags: Optional[List[ForwardRef('ssl.VerifyFlags')]] = None, ssl_exclude_verify_flags: Optional[List[ForwardRef('ssl.VerifyFlags')]] = None, ssl_ca_certs: Optional[str] = None, ssl_ca_data: Optional[str] = None, ssl_ca_path: Optional[str] = None, ssl_check_hostname: bool = True, ssl_min_version: Optional[ssl.TLSVersion] = None, ssl_ciphers: Optional[str] = None, ssl_password: Optional[str] = None, **kwargs)
     |      Initialize a TCP connection.
     |
     |      Parameters
     |      ----------
     |      socket_keepalive : bool
     |          If `True`, TCP keepalive is enabled for TCP socket connections.
     |      socket_keepalive_options : Mapping[int, int | bytes] | object | None
     |          Mapping of TCP keepalive socket option constants to values, for
     |          example `{socket.TCP_KEEPIDLE: 30}`. If left unspecified, redis-py
     |          uses TCP keepalive defaults when `socket_keepalive` is enabled:
     |          idle 30 seconds, interval 5 seconds, and 3 probes. Platform-specific
     |          options that are not available are skipped. Pass `None` or `{}` to
     |          avoid setting additional TCP keepalive options.
     |
     |  ----------------------------------------------------------------------
     |  Readonly properties defined here:
     |
     |  ca_certs
     |
     |  ca_data
     |
     |  cert_reqs
     |
     |  certfile
     |
     |  check_hostname
     |
     |  exclude_verify_flags
     |
     |  include_verify_flags
     |
     |  keyfile
     |
     |  min_version
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from Connection:
     |
     |  repr_pieces(self)
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors inherited from Connection:
     |
     |  __weakref__
     |      list of weak references to the object
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from AbstractConnection:
     |
     |  __del__(self, _warnings: Any = <module 'warnings' from 'C:\\Users\\Youse\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\warnings.py'>)
     |
     |  __repr__(self)
     |      Return repr(self).
     |
     |  async can_read(self) -> bool
     |      Check the socket to see if there's data loaded in the buffer.
     |
     |  async can_read_destructive(self) -> bool
     |      Check the socket to see if there's data loaded in the buffer.
     |
     |  async check_health(self)
     |      Check the health of the connection with a PING/PONG
     |
     |  async connect(self)
     |      Connects to the Redis server if not already connected
     |
     |  async connect_check_health(self, check_health: bool = True, retry_socket_connect: bool = True)
     |
     |  deregister_connect_callback(self, callback)
     |      De-register a previously registered callback.  It will no-longer receive
     |      notifications on connection events.  Calling this is not required when the
     |      listener goes away, since the callbacks are kept as weak methods.
     |
     |  async disconnect(self, nowait: bool = False, error: Optional[Exception] = None, failure_count: Optional[int] = None, health_check_failed: bool = False) -> None
     |      Disconnects from the Redis server
     |
     |  get_protocol(self)
     |
     |  getpeername(self) -> str | None
     |      Returns the peer name of the connection.
     |
     |  mark_for_reconnect(self)
     |
     |  async on_connect(self) -> None
     |      Initialize the connection, authenticate and select a database
     |
     |  async on_connect_check_health(self, check_health: bool = True) -> None
     |
     |  pack_command(self, *args: Union[bytes, bytearray, memoryview, str, int, float]) -> List[bytes]
     |      Pack a series of arguments into the Redis protocol
     |
     |  pack_commands(self, commands: Iterable[Iterable[Union[bytes, bytearray, memoryview, str, int, float]]]) -> List[bytes]
     |      Pack multiple commands into the Redis protocol
     |
     |  async process_invalidation_messages(self)
     |
     |  async re_auth(self)
     |
     |  async read_response(self, disable_decoding: bool = False, timeout: float | None = None, *, disconnect_on_error: bool = True, push_request: bool | None = False)
     |      Read the response from a previously sent command.
     |
     |      ``timeout`` semantics:
     |      - ``None`` (default): fall back to ``self.socket_timeout``.
     |      - ``math.inf``: block indefinitely with no timeout. Used by PubSub
     |        blocking reads (``listen()`` / ``get_message(timeout=None)`` /
     |        ``parse_response(block=True)``) where the configured
     |        ``socket_timeout`` must not abort the read.
     |      - ``float``: apply that timeout in seconds for this single read.
     |
     |      TODO(next-major): replace the ``math.inf`` opt-in with a SENTINEL
     |      default for ``timeout``. After that change, ``timeout=None`` will
     |      mean "no timeout, block until a response arrives" (matching the
     |      long-standing PubSub docstring contract) and the SENTINEL default
     |      will be the value that falls back to ``self.socket_timeout``.
     |      That swap is a breaking change, so it must wait for a major
     |      release. Until then, callers that need an indefinitely blocking
     |      read pass ``math.inf`` explicitly.
     |
     |  register_connect_callback(self, callback)
     |      Register a callback to be called when the connection is established either
     |      initially or reconnected.  This allows listeners to issue commands that
     |      are ephemeral to the connection, for example pub/sub subscription or
     |      key tracking.  The callback must be a _method_ and will be kept as
     |      a weak reference.
     |
     |  reset_should_reconnect(self)
     |
     |  async send_command(self, *args: Any, **kwargs: Any) -> None
     |      Pack and send a command to the Redis server
     |
     |  async send_packed_command(self, command: Union[bytes, str, Iterable[bytes]], check_health: bool = True) -> None
     |
     |  set_parser(self, parser_class: Type[redis._parsers.base.BaseParser]) -> None
     |      Creates a new instance of parser_class with socket size:
     |      _socket_read_size and assigns it to the parser for the connection
     |      :param parser_class: The required parser class
     |
     |  set_re_auth_token(self, token: redis.auth.token.TokenInterface)
     |
     |  should_reconnect(self)
     |
     |  ----------------------------------------------------------------------
     |  Readonly properties inherited from AbstractConnection:
     |
     |  is_connected
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors inherited from AbstractConnection:
     |
     |  __dict__
     |      dictionary for instance variables
     |
     |  client_name
     |
     |  credential_provider
     |
     |  db
     |
     |  encoder
     |
     |  health_check_interval
     |
     |  last_active_at
     |
     |  lib_name
     |
     |  lib_version
     |
     |  next_health_check
     |
     |  password
     |
     |  protocol
     |
     |  redis_connect_func
     |
     |  retry_on_error
     |
     |  retry_on_timeout
     |
     |  socket_connect_timeout
     |
     |  socket_timeout
     |
     |  ssl_context
     |
     |  username
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from AsyncMaintNotificationsAbstractConnection:
     |
     |  async activate_maint_notifications_handling_if_enabled(self, check_health: bool = True) -> None
     |
     |  add_maint_start_notification(self, id: int) -> None
     |
     |  add_skipped_end_notification(self, id: int) -> None
     |
     |  get_processed_start_notifications(self) -> set[int]
     |
     |  get_resolved_ip(self) -> str | None
     |      Extract the resolved IP address from an established connection or host.
     |
     |      First tries to get the actual peer IP from the async stream writer, then
     |      falls back to DNS resolution if needed.
     |
     |      Returns:
     |          The resolved IP address, or None if it cannot be determined.
     |
     |  get_skipped_end_notifications(self) -> set[int]
     |
     |  reset_received_notifications(self) -> None
     |
     |  reset_tmp_settings(self, reset_host_address: bool = False, reset_relaxed_timeout: bool = False) -> None
     |
     |  set_maint_notifications_cluster_handler_for_connection(self, oss_cluster_maint_notifications_handler: redis.asyncio.maint_notifications.AsyncOSSMaintNotificationsHandler) -> None
     |
     |  set_maint_notifications_pool_handler_for_connection(self, maint_notifications_pool_handler: redis.asyncio.maint_notifications.AsyncMaintNotificationsPoolHandler) -> None
     |
     |  set_tmp_settings(self, tmp_host_address: str | object | None = <object object at 0x0000017B991493E0>, tmp_relaxed_timeout: float | None = -1) -> None
     |      SENTINEL keeps the host unchanged. -1 keeps the relaxed timeout unchanged.
     |
     |  update_current_socket_timeout(self, relaxed_timeout: float | None = None) -> None
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors inherited from AsyncMaintNotificationsAbstractConnection:
     |
     |  maintenance_state

    class Sentinel(redis.commands.sentinel.AsyncSentinelCommands)
     |  Sentinel(sentinels, min_other_sentinels=0, sentinel_kwargs=None, force_master_ip=None, **connection_kwargs)
     |
     |  Redis Sentinel cluster client
     |
     |  >>> from redis.sentinel import Sentinel
     |  >>> sentinel = Sentinel([('localhost', 26379)], socket_timeout=0.1)
     |  >>> master = sentinel.master_for('mymaster', socket_timeout=0.1)
     |  >>> await master.set('foo', 'bar')
     |  >>> slave = sentinel.slave_for('mymaster', socket_timeout=0.1)
     |  >>> await slave.get('foo')
     |  b'bar'
     |
     |  ``sentinels`` is a list of sentinel nodes. Each node is represented by
     |  a pair (hostname, port).
     |
     |  ``min_other_sentinels`` defined a minimum number of peers for a sentinel.
     |  When querying a sentinel, if it doesn't meet this threshold, responses
     |  from that sentinel won't be considered valid.
     |
     |  ``sentinel_kwargs`` is a dictionary of connection arguments used when
     |  connecting to sentinel instances. Any argument that can be passed to
     |  a normal Redis connection can be specified here. If ``sentinel_kwargs`` is
     |  not specified, any socket_timeout and socket_keepalive options specified
     |  in ``connection_kwargs`` will be used.
     |
     |  ``connection_kwargs`` are keyword arguments that will be used when
     |  establishing a connection to a Redis server.
     |
     |  Method resolution order:
     |      Sentinel
     |      redis.commands.sentinel.AsyncSentinelCommands
     |      redis.commands.sentinel.SentinelCommands
     |      builtins.object
     |
     |  Methods defined here:
     |
     |  async __aenter__(self) -> 'Sentinel'
     |
     |  async __aexit__(self, exc_type, exc_value, traceback) -> None
     |
     |  __init__(self, sentinels, min_other_sentinels=0, sentinel_kwargs=None, force_master_ip=None, **connection_kwargs)
     |      Initialize self.  See help(type(self)) for accurate signature.
     |
     |  __repr__(self)
     |      Return repr(self).
     |
     |  async aclose(self) -> None
     |      Close all sentinel clients created by this Sentinel and their
     |      connection pools.
     |
     |      Each client is closed independently: if one raises, the remaining
     |      clients are still closed and the first error is re-raised afterwards.
     |
     |      Clients returned by ``master_for``/``slave_for`` are owned by the
     |      caller and are not closed here.
     |
     |  check_master_state(self, state: dict, service_name: str) -> bool
     |
     |  async discover_master(self, service_name: str)
     |      Asks sentinel servers for the Redis master's address corresponding
     |      to the service labeled ``service_name``.
     |
     |      Returns a pair (address, port) or raises MasterNotFoundError if no
     |      master is found.
     |
     |  async discover_replicas(self, service_name: str) -> Sequence[Tuple[Union[bytes, bytearray, memoryview, str, int, float], Union[bytes, bytearray, memoryview, str, int, float]]]
     |      Returns a list of alive replicas for service ``service_name``.
     |
     |      This is an alias for :py:meth:`discover_slaves`,
     |      using the preferred Redis 5.0+ terminology.
     |
     |  async discover_slaves(self, service_name: str) -> Sequence[Tuple[Union[bytes, bytearray, memoryview, str, int, float], Union[bytes, bytearray, memoryview, str, int, float]]]
     |      Returns a list of alive slaves for service ``service_name``
     |
     |  async execute_command(self, *args, **kwargs)
     |      Execute Sentinel command in sentinel nodes.
     |      once - If set to True, then execute the resulting command on a single
     |             node at random, rather than across the entire sentinel cluster.
     |
     |  filter_replicas(self, replicas: Iterable[Mapping]) -> Sequence[Tuple[Union[bytes, bytearray, memoryview, str, int, float], Union[bytes, bytearray, memoryview, str, int, float]]]
     |      Remove replicas that are in an ODOWN or SDOWN state.
     |
     |      This is an alias for :py:meth:`filter_slaves`,
     |      using the preferred Redis 5.0+ terminology.
     |
     |  filter_slaves(self, slaves: Iterable[Mapping]) -> Sequence[Tuple[Union[bytes, bytearray, memoryview, str, int, float], Union[bytes, bytearray, memoryview, str, int, float]]]
     |      Remove slaves that are in an ODOWN or SDOWN state
     |
     |  master_for(self, service_name: str, redis_class: Type[redis.asyncio.client.Redis] = <class 'redis.asyncio.client.Redis'>, connection_pool_class: Type[redis.asyncio.sentinel.SentinelConnectionPool] = <class 'redis.asyncio.sentinel.SentinelConnectionPool'>, **kwargs)
     |      Returns a redis client instance for the ``service_name`` master.
     |      Sentinel client will detect failover and reconnect Redis clients
     |      automatically.
     |
     |      A :py:class:`~redis.sentinel.SentinelConnectionPool` class is
     |      used to retrieve the master's address before establishing a new
     |      connection.
     |
     |      NOTE: If the master's address has changed, any cached connections to
     |      the old master are closed.
     |
     |      By default clients will be a :py:class:`~redis.Redis` instance.
     |      Specify a different class to the ``redis_class`` argument if you
     |      desire something different.
     |
     |      The ``connection_pool_class`` specifies the connection pool to
     |      use.  The :py:class:`~redis.sentinel.SentinelConnectionPool`
     |      will be used by default.
     |
     |      All other keyword arguments are merged with any connection_kwargs
     |      passed to this class and passed to the connection pool as keyword
     |      arguments to be used to initialize Redis connections.
     |
     |      HIMPORT note: the returned client exposes the HIMPORT command family
     |      (``himport_prepare``, ``himport_set``, ``himport_discard``,
     |      ``himport_discard_all``). Fieldsets are declared at runtime with
     |      ``himport_prepare`` on the client and live on that client's shared registry,
     |      so they survive Sentinel failover automatically: the pool re-points to the
     |      new master and the fieldset is re-prepared lazily on the next
     |      ``himport_set``. Each call to current command returns a *new* client with its *own* empty
     |      registry, so call ``himport_prepare`` on the long-lived client you reuse
     |      rather than creating a fresh one per operation; otherwise ``himport_set``
     |      fails with ``no such fieldset``. (``himport_set`` is a write and is served by
     |      the master.)
     |
     |  replica_for(self, service_name: str, redis_class: Type[redis.asyncio.client.Redis] = <class 'redis.asyncio.client.Redis'>, connection_pool_class: Type[redis.asyncio.sentinel.SentinelConnectionPool] = <class 'redis.asyncio.sentinel.SentinelConnectionPool'>, **kwargs)
     |      Returns redis client instance for the ``service_name`` replica(s).
     |
     |      This is an alias for :py:meth:`slave_for`,
     |      using the preferred Redis 5.0+ terminology.
     |
     |  slave_for(self, service_name: str, redis_class: Type[redis.asyncio.client.Redis] = <class 'redis.asyncio.client.Redis'>, connection_pool_class: Type[redis.asyncio.sentinel.SentinelConnectionPool] = <class 'redis.asyncio.sentinel.SentinelConnectionPool'>, **kwargs)
     |      Returns redis client instance for the ``service_name`` slave(s).
     |
     |      A SentinelConnectionPool class is used to retrieve the slave's
     |      address before establishing a new connection.
     |
     |      By default clients will be a :py:class:`~redis.Redis` instance.
     |      Specify a different class to the ``redis_class`` argument if you
     |      desire something different.
     |
     |      The ``connection_pool_class`` specifies the connection pool to use.
     |      The SentinelConnectionPool will be used by default.
     |
     |      All other keyword arguments are merged with any connection_kwargs
     |      passed to this class and passed to the connection pool as keyword
     |      arguments to be used to initialize Redis connections.
     |
     |      HIMPORT note: the returned client exposes the HIMPORT command family
     |      (``himport_prepare``, ``himport_set``, ``himport_discard``,
     |      ``himport_discard_all``). Fieldsets are declared at runtime with
     |      ``himport_prepare`` on the client and live on that client's shared registry,
     |      so they survive Sentinel failover automatically: the pool re-points to the
     |      new master and the fieldset is re-prepared lazily on the next
     |      ``himport_set``. Each call to current command returns a *new* client with its *own* empty
     |      registry, so call ``himport_prepare`` on the long-lived client you reuse
     |      rather than creating a fresh one per operation; otherwise ``himport_set``
     |      fails with ``no such fieldset``. (``himport_set`` is a write and is served by
     |      the master.)
     |
     |  ----------------------------------------------------------------------
     |  Data and other attributes defined here:
     |
     |  __annotations__ = {}
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from redis.commands.sentinel.AsyncSentinelCommands:
     |
     |  async sentinel(self, *args) -> None
     |      Redis Sentinel's SENTINEL command.
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from redis.commands.sentinel.SentinelCommands:
     |
     |  sentinel_ckquorum(self, new_master_name) -> Union[bool, Awaitable[bool]]
     |      Check if the current Sentinel configuration is able to reach the
     |      quorum needed to failover a master, and the majority needed to
     |      authorize the failover.
     |
     |      This command should be used in monitoring systems to check if a
     |      Sentinel deployment is ok.
     |
     |  sentinel_failover(self, new_master_name) -> Union[bool, Awaitable[bool]]
     |      Force a failover as if the master was not reachable, and without
     |      asking for agreement to other Sentinels (however a new version of the
     |      configuration will be published so that the other Sentinels will
     |      update their configurations).
     |
     |  sentinel_flushconfig(self) -> Union[bool, Awaitable[bool]]
     |      Force Sentinel to rewrite its configuration on disk, including the
     |      current Sentinel state.
     |
     |      Normally Sentinel rewrites the configuration every time something
     |      changes in its state (in the context of the subset of the state which
     |      is persisted on disk across restart).
     |      However sometimes it is possible that the configuration file is lost
     |      because of operation errors, disk failures, package upgrade scripts or
     |      configuration managers. In those cases a way to to force Sentinel to
     |      rewrite the configuration file is handy.
     |
     |      This command works even if the previous configuration file is
     |      completely missing.
     |
     |  sentinel_get_master_addr_by_name(self, service_name, return_responses: bool = False) -> Union[tuple[bytes | str, int], NoneType, bool, Awaitable[tuple[bytes | str, int] | None | bool]]
     |      Returns a (host, port) pair for the given ``service_name`` when return_responses is True,
     |      otherwise returns a boolean value that indicates if the command was successful.
     |
     |  sentinel_master(self, service_name, return_responses: bool = False) -> Union[dict[str, Any], bool, Awaitable[dict[str, Any] | bool]]
     |      Returns a dictionary containing the specified masters state, when return_responses is True,
     |      otherwise returns a boolean value that indicates if the command was successful.
     |
     |  sentinel_masters(self) -> Union[dict[str, dict[str, Any]], list[dict[str, Any]], Awaitable[dict[str, dict[str, Any]] | list[dict[str, Any]]]]
     |      Returns a list of dictionaries containing each master's state.
     |
     |      Important: This function is called by the Sentinel implementation and is
     |      called directly on the Redis standalone client for sentinels,
     |      so it doesn't support the "once" and "return_responses" options.
     |
     |  sentinel_monitor(self, name, ip, port, quorum) -> Union[bool, Awaitable[bool]]
     |      Add a new master to Sentinel to be monitored
     |
     |  sentinel_remove(self, name) -> Union[bool, Awaitable[bool]]
     |      Remove a master from Sentinel's monitoring
     |
     |  sentinel_reset(self, pattern) -> Union[bool, Awaitable[bool]]
     |      This command will reset all the masters with matching name.
     |      The pattern argument is a glob-style pattern.
     |
     |      The reset process clears any previous state in a master (including a
     |      failover in progress), and removes every slave and sentinel already
     |      discovered and associated with the master.
     |
     |  sentinel_sentinels(self, service_name, return_responses: bool = False) -> Union[list[dict[str, Any]], bool, Awaitable[list[dict[str, Any]] | bool]]
     |      Returns a list of sentinels for ``service_name``, when return_responses is True,
     |      otherwise returns a boolean value that indicates if the command was successful.
     |
     |  sentinel_set(self, name, option, value) -> Union[bool, Awaitable[bool]]
     |      Set Sentinel monitoring parameters for a given master
     |
     |  sentinel_slaves(self, service_name) -> Union[list[dict[str, Any]], Awaitable[list[dict[str, Any]]]]
     |      Returns a list of slaves for ``service_name``
     |
     |      Important: This function is called by the Sentinel implementation and is
     |      called directly on the Redis standalone client for sentinels,
     |      so it doesn't support the "once" and "return_responses" options.
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors inherited from redis.commands.sentinel.SentinelCommands:
     |
     |  __dict__
     |      dictionary for instance variables
     |
     |  __weakref__
     |      list of weak references to the object

    class SentinelConnectionPool(redis.asyncio.connection.ConnectionPool)
     |  SentinelConnectionPool(service_name, sentinel_manager, **kwargs)
     |
     |  Sentinel backed connection pool.
     |
     |  If ``check_connection`` flag is set to True, SentinelManagedConnection
     |  sends a PING command right after establishing the connection.
     |
     |  Method resolution order:
     |      SentinelConnectionPool
     |      redis.asyncio.connection.ConnectionPool
     |      redis.asyncio.connection.AsyncMaintNotificationsAbstractConnectionPool
     |      redis.asyncio.connection.ConnectionPoolInterface
     |      abc.ABC
     |      builtins.object
     |
     |  Methods defined here:
     |
     |  __init__(self, service_name, sentinel_manager, **kwargs)
     |      Initialize self.  See help(type(self)) for accurate signature.
     |
     |  __repr__(self)
     |      Return repr(self).
     |
     |  async get_master_address(self)
     |
     |  owns_connection(self, connection: redis.asyncio.connection.Connection)
     |
     |  reset(self)
     |
     |  rotate_replicas(self) -> AsyncIterator
     |      Round-robin replica balancer.
     |
     |      This is an alias for :py:meth:`rotate_slaves`,
     |      using the preferred Redis 5.0+ terminology.
     |
     |  async rotate_slaves(self) -> AsyncIterator
     |      Round-robin slave balancer
     |
     |  ----------------------------------------------------------------------
     |  Data and other attributes defined here:
     |
     |  __abstractmethods__ = frozenset()
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from redis.asyncio.connection.ConnectionPool:
     |
     |  async __aenter__(self: ~_CP) -> ~_CP
     |
     |  async __aexit__(self, exc_type, exc_value, traceback) -> None
     |
     |  __del__(self) -> None
     |      Clean up connection pool and record metrics when garbage collected.
     |
     |  async aclose(self) -> None
     |      Close the pool, disconnecting all connections
     |
     |  can_get_connection(self) -> bool
     |      Return True if a connection can be retrieved from the pool.
     |
     |  async disconnect(self, inuse_connections: bool = True)
     |      Disconnects connections in the pool
     |
     |      If ``inuse_connections`` is True, disconnect connections that are
     |      current in use, potentially by other tasks. Otherwise only disconnect
     |      connections that are idle in the pool.
     |
     |  async ensure_connection(self, connection: redis.asyncio.connection.AbstractConnection)
     |      Ensure that the connection object is connected and valid
     |
     |  get_available_connection(self)
     |      Get a connection from the pool, without making sure it is connected
     |
     |  async get_connection(self, command_name=None, *keys, **options)
     |      Get a connected connection from the pool
     |
     |  get_connection_count(self) -> List[tuple[int, dict]]
     |      Returns a connection count (both idle and in use).
     |
     |  get_encoder(self)
     |      Return an encoder based on encoding settings
     |
     |  get_protocol(self)
     |      Returns:
     |          The RESP protocol version, or ``None`` if the protocol is not specified,
     |          in which case the server default will be used.
     |
     |  make_connection(self)
     |      Create a new connection.  Can be overridden by child classes.
     |
     |  async re_auth_callback(self, token: redis.auth.token.TokenInterface)
     |
     |  async release(self, connection: redis.asyncio.connection.AbstractConnection)
     |      Releases the connection back to the pool
     |
     |  set_retry(self, retry: 'Retry') -> None
     |
     |  async update_active_connections_for_reconnect(self)
     |      Mark all active connections for reconnect.
     |
     |  ----------------------------------------------------------------------
     |  Class methods inherited from redis.asyncio.connection.ConnectionPool:
     |
     |  from_url(url: str, **kwargs) -> ~_CP
     |      Return a connection pool configured from the given URL.
     |
     |      For example::
     |
     |          redis://[[username]:[password]]@localhost:6379/0
     |          rediss://[[username]:[password]]@localhost:6379/0
     |          unix://[username@]/path/to/socket.sock?db=0[&password=password]
     |
     |      Three URL schemes are supported:
     |
     |      - `redis://` creates a TCP socket connection. See more at:
     |        <https://www.iana.org/assignments/uri-schemes/prov/redis>
     |      - `rediss://` creates a SSL wrapped TCP socket connection. See more at:
     |        <https://www.iana.org/assignments/uri-schemes/prov/rediss>
     |      - ``unix://``: creates a Unix Domain Socket connection.
     |
     |      The username, password, hostname, path and all querystring values
     |      are passed through urllib.parse.unquote in order to replace any
     |      percent-encoded values with their corresponding characters.
     |
     |      There are several ways to specify a database number. The first value
     |      found will be used:
     |
     |      1. A ``db`` querystring option, e.g. redis://localhost?db=0
     |
     |      2. If using the redis:// or rediss:// schemes, the path argument
     |             of the url, e.g. redis://localhost/0
     |
     |      3. A ``db`` keyword argument to this function.
     |
     |      If none of these options are specified, the default db=0 is used.
     |
     |      All querystring options are cast to their appropriate Python types.
     |      Boolean arguments can be specified with string values "True"/"False"
     |      or "Yes"/"No". Values that cannot be properly cast cause a
     |      ``ValueError`` to be raised. Once parsed, the querystring arguments
     |      and keyword arguments are passed to the ``ConnectionPool``'s
     |      class initializer. In the case of conflicting arguments, querystring
     |      arguments always win.
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors inherited from redis.asyncio.connection.ConnectionPool:
     |
     |  connection_kwargs
     |
     |  ----------------------------------------------------------------------
     |  Data and other attributes inherited from redis.asyncio.connection.ConnectionPool:
     |
     |  OMIT_REPR_KEYS = frozenset({'himport_registry'})
     |
     |  SENSITIVE_REPR_KEYS = frozenset({'credential_provider', 'password', 's...
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from redis.asyncio.connection.AsyncMaintNotificationsAbstractConnectionPool:
     |
     |  async apply_moving_notification(self, notification: redis.maint_notifications.NodeMovingNotification, config: redis.maint_notifications.MaintNotificationsConfig, moving_address_src: str | None, run_proactive_reconnect: bool = False) -> None
     |      Apply the pool state transition for a MOVING notification atomically.
     |
     |      Async pools use a non-reentrant `asyncio.Lock`, so the handler cannot
     |      safely compose several separately locked calls. Existing connection
     |      updates, optional proactive reconnect, and future `connection_kwargs`
     |      changes must happen under one pool-owned lock; otherwise a connection
     |      can move between active/free lists and escape handling.
     |
     |  async cleanup_moving_notification(self, notification_hash: int, reset_relaxed_timeout: bool, reset_host_address: bool) -> None
     |      Revert MOVING pool state atomically after the notification TTL.
     |
     |      Future connection kwargs and existing connection state must be cleaned
     |      up in the same critical section. Splitting the cleanup lets an
     |      acquire/release interleave, which can leave stale MOVING state or undo a
     |      newer overlapping MOVING notification.
     |
     |  maint_notifications_enabled(self)
     |      Returns:
     |          True if the maintenance notifications are enabled, False otherwise.
     |          The maintenance notifications config is stored in the pool handler.
     |          If the pool handler is not set, the maintenance notifications are not enabled.
     |
     |  async run_proactive_reconnect(self, moving_address_src: str | None = None) -> None
     |      Mark active connections and disconnect free connections atomically.
     |
     |      This operation is pool-owned because the active/free lists can change
     |      while tasks acquire or release connections. Keeping the mark/disconnect
     |      pass under one lock avoids a connection moving between lists between
     |      separately locked calls.
     |
     |  update_connection_kwargs(self, **kwargs: Any) -> None
     |      Update the connection kwargs for all future connections.
     |
     |      This method updates the connection kwargs for all future connections created by the pool.
     |      Existing connections are not affected.
     |
     |  update_connection_settings(self, conn: 'AsyncMaintNotificationsAbstractConnection', state: redis.maint_notifications.MaintenanceState | None = None, maintenance_notification_hash: int | None = None, host_address: str | None = None, relaxed_timeout: float | None = None, update_notification_hash: bool = False, reset_host_address: bool = False, reset_relaxed_timeout: bool = False) -> None
     |      Update the settings for a single connection.
     |
     |  async update_connections_settings(self, state: redis.maint_notifications.MaintenanceState | None = None, maintenance_notification_hash: int | None = None, host_address: str | None = None, relaxed_timeout: float | None = None, matching_address: str | None = None, matching_notification_hash: int | None = None, matching_pattern: Literal['connected_address', 'configured_address', 'notification_hash'] = 'connected_address', update_notification_hash: bool = False, reset_host_address: bool = False, reset_relaxed_timeout: bool = False, include_free_connections: bool = True) -> None
     |      Update the settings for all matching connections in the pool.
     |
     |      This method does not create new connections.
     |      This method does not affect the connection kwargs.
     |
     |      :param state: The maintenance state to set for the connection.
     |      :param maintenance_notification_hash: The hash of the maintenance notification
     |                                             to set for the connection.
     |      :param host_address: The host address to set for the connection.
     |      :param relaxed_timeout: The relaxed timeout to set for the connection.
     |      :param matching_address: The address to match for the connection.
     |      :param matching_notification_hash: The notification hash to match for the connection.
     |      :param matching_pattern: The pattern to match for the connection.
     |      :param update_notification_hash: Whether to update the notification hash for the connection.
     |      :param reset_host_address: Whether to reset the host address to the original address.
     |      :param reset_relaxed_timeout: Whether to reset the relaxed timeout to the original timeout.
     |      :param include_free_connections: Whether to include free/available connections.
     |
     |  async update_maint_notifications_config(self, maint_notifications_config: redis.maint_notifications.MaintNotificationsConfig, oss_cluster_maint_notifications_handler: redis.asyncio.maint_notifications.AsyncOSSMaintNotificationsHandler | None = None) -> None
     |      Updates the maintenance notifications configuration.
     |      This method should be called only if the pool was created
     |      without enabling the maintenance notifications and
     |      in a later point in time maintenance notifications
     |      are requested to be enabled.
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors inherited from redis.asyncio.connection.AsyncMaintNotificationsAbstractConnectionPool:
     |
     |  __dict__
     |      dictionary for instance variables
     |
     |  __weakref__
     |      list of weak references to the object

    class SentinelManagedConnection(redis.asyncio.connection.Connection)
     |  SentinelManagedConnection(**kwargs)
     |
     |  Method resolution order:
     |      SentinelManagedConnection
     |      redis.asyncio.connection.Connection
     |      redis.asyncio.connection.AbstractConnection
     |      redis.asyncio.connection.AsyncMaintNotificationsAbstractConnection
     |      builtins.object
     |
     |  Methods defined here:
     |
     |  __init__(self, **kwargs)
     |      Initialize a TCP connection.
     |
     |      Parameters
     |      ----------
     |      socket_keepalive : bool
     |          If `True`, TCP keepalive is enabled for TCP socket connections.
     |      socket_keepalive_options : Mapping[int, int | bytes] | object | None
     |          Mapping of TCP keepalive socket option constants to values, for
     |          example `{socket.TCP_KEEPIDLE: 30}`. If left unspecified, redis-py
     |          uses TCP keepalive defaults when `socket_keepalive` is enabled:
     |          idle 30 seconds, interval 5 seconds, and 3 probes. Platform-specific
     |          options that are not available are skipped. Pass `None` or `{}` to
     |          avoid setting additional TCP keepalive options.
     |
     |  __repr__(self)
     |      Return repr(self).
     |
     |  async connect(self)
     |      Connects to the Redis server if not already connected
     |
     |  async connect_to(self, address)
     |
     |  async read_response(self, disable_decoding: bool = False, timeout: Optional[float] = None, *, disconnect_on_error: Optional[float] = True, push_request: Optional[bool] = False)
     |      Read the response from a previously sent command.
     |
     |      ``timeout`` semantics:
     |      - ``None`` (default): fall back to ``self.socket_timeout``.
     |      - ``math.inf``: block indefinitely with no timeout. Used by PubSub
     |        blocking reads (``listen()`` / ``get_message(timeout=None)`` /
     |        ``parse_response(block=True)``) where the configured
     |        ``socket_timeout`` must not abort the read.
     |      - ``float``: apply that timeout in seconds for this single read.
     |
     |      TODO(next-major): replace the ``math.inf`` opt-in with a SENTINEL
     |      default for ``timeout``. After that change, ``timeout=None`` will
     |      mean "no timeout, block until a response arrives" (matching the
     |      long-standing PubSub docstring contract) and the SENTINEL default
     |      will be the value that falls back to ``self.socket_timeout``.
     |      That swap is a breaking change, so it must wait for a major
     |      release. Until then, callers that need an indefinitely blocking
     |      read pass ``math.inf`` explicitly.
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from redis.asyncio.connection.Connection:
     |
     |  repr_pieces(self)
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors inherited from redis.asyncio.connection.Connection:
     |
     |  __weakref__
     |      list of weak references to the object
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from redis.asyncio.connection.AbstractConnection:
     |
     |  __del__(self, _warnings: Any = <module 'warnings' from 'C:\\Users\\Youse\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\warnings.py'>)
     |
     |  async can_read(self) -> bool
     |      Check the socket to see if there's data loaded in the buffer.
     |
     |  async can_read_destructive(self) -> bool
     |      Check the socket to see if there's data loaded in the buffer.
     |
     |  async check_health(self)
     |      Check the health of the connection with a PING/PONG
     |
     |  async connect_check_health(self, check_health: bool = True, retry_socket_connect: bool = True)
     |
     |  deregister_connect_callback(self, callback)
     |      De-register a previously registered callback.  It will no-longer receive
     |      notifications on connection events.  Calling this is not required when the
     |      listener goes away, since the callbacks are kept as weak methods.
     |
     |  async disconnect(self, nowait: bool = False, error: Optional[Exception] = None, failure_count: Optional[int] = None, health_check_failed: bool = False) -> None
     |      Disconnects from the Redis server
     |
     |  get_protocol(self)
     |
     |  getpeername(self) -> str | None
     |      Returns the peer name of the connection.
     |
     |  mark_for_reconnect(self)
     |
     |  async on_connect(self) -> None
     |      Initialize the connection, authenticate and select a database
     |
     |  async on_connect_check_health(self, check_health: bool = True) -> None
     |
     |  pack_command(self, *args: Union[bytes, bytearray, memoryview, str, int, float]) -> List[bytes]
     |      Pack a series of arguments into the Redis protocol
     |
     |  pack_commands(self, commands: Iterable[Iterable[Union[bytes, bytearray, memoryview, str, int, float]]]) -> List[bytes]
     |      Pack multiple commands into the Redis protocol
     |
     |  async process_invalidation_messages(self)
     |
     |  async re_auth(self)
     |
     |  register_connect_callback(self, callback)
     |      Register a callback to be called when the connection is established either
     |      initially or reconnected.  This allows listeners to issue commands that
     |      are ephemeral to the connection, for example pub/sub subscription or
     |      key tracking.  The callback must be a _method_ and will be kept as
     |      a weak reference.
     |
     |  reset_should_reconnect(self)
     |
     |  async send_command(self, *args: Any, **kwargs: Any) -> None
     |      Pack and send a command to the Redis server
     |
     |  async send_packed_command(self, command: Union[bytes, str, Iterable[bytes]], check_health: bool = True) -> None
     |
     |  set_parser(self, parser_class: Type[redis._parsers.base.BaseParser]) -> None
     |      Creates a new instance of parser_class with socket size:
     |      _socket_read_size and assigns it to the parser for the connection
     |      :param parser_class: The required parser class
     |
     |  set_re_auth_token(self, token: redis.auth.token.TokenInterface)
     |
     |  should_reconnect(self)
     |
     |  ----------------------------------------------------------------------
     |  Readonly properties inherited from redis.asyncio.connection.AbstractConnection:
     |
     |  is_connected
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors inherited from redis.asyncio.connection.AbstractConnection:
     |
     |  __dict__
     |      dictionary for instance variables
     |
     |  client_name
     |
     |  credential_provider
     |
     |  db
     |
     |  encoder
     |
     |  health_check_interval
     |
     |  last_active_at
     |
     |  lib_name
     |
     |  lib_version
     |
     |  next_health_check
     |
     |  password
     |
     |  protocol
     |
     |  redis_connect_func
     |
     |  retry_on_error
     |
     |  retry_on_timeout
     |
     |  socket_connect_timeout
     |
     |  socket_timeout
     |
     |  ssl_context
     |
     |  username
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from redis.asyncio.connection.AsyncMaintNotificationsAbstractConnection:
     |
     |  async activate_maint_notifications_handling_if_enabled(self, check_health: bool = True) -> None
     |
     |  add_maint_start_notification(self, id: int) -> None
     |
     |  add_skipped_end_notification(self, id: int) -> None
     |
     |  get_processed_start_notifications(self) -> set[int]
     |
     |  get_resolved_ip(self) -> str | None
     |      Extract the resolved IP address from an established connection or host.
     |
     |      First tries to get the actual peer IP from the async stream writer, then
     |      falls back to DNS resolution if needed.
     |
     |      Returns:
     |          The resolved IP address, or None if it cannot be determined.
     |
     |  get_skipped_end_notifications(self) -> set[int]
     |
     |  reset_received_notifications(self) -> None
     |
     |  reset_tmp_settings(self, reset_host_address: bool = False, reset_relaxed_timeout: bool = False) -> None
     |
     |  set_maint_notifications_cluster_handler_for_connection(self, oss_cluster_maint_notifications_handler: redis.asyncio.maint_notifications.AsyncOSSMaintNotificationsHandler) -> None
     |
     |  set_maint_notifications_pool_handler_for_connection(self, maint_notifications_pool_handler: redis.asyncio.maint_notifications.AsyncMaintNotificationsPoolHandler) -> None
     |
     |  set_tmp_settings(self, tmp_host_address: str | object | None = <object object at 0x0000017B991493E0>, tmp_relaxed_timeout: float | None = -1) -> None
     |      SENTINEL keeps the host unchanged. -1 keeps the relaxed timeout unchanged.
     |
     |  update_current_socket_timeout(self, relaxed_timeout: float | None = None) -> None
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors inherited from redis.asyncio.connection.AsyncMaintNotificationsAbstractConnection:
     |
     |  maintenance_state

    class SentinelManagedSSLConnection(SentinelManagedConnection, redis.asyncio.connection.SSLConnection)
     |  SentinelManagedSSLConnection(**kwargs)
     |
     |  Method resolution order:
     |      SentinelManagedSSLConnection
     |      SentinelManagedConnection
     |      redis.asyncio.connection.SSLConnection
     |      redis.asyncio.connection.Connection
     |      redis.asyncio.connection.AbstractConnection
     |      redis.asyncio.connection.AsyncMaintNotificationsAbstractConnection
     |      builtins.object
     |
     |  Methods inherited from SentinelManagedConnection:
     |
     |  __init__(self, **kwargs)
     |      Initialize a TCP connection.
     |
     |      Parameters
     |      ----------
     |      socket_keepalive : bool
     |          If `True`, TCP keepalive is enabled for TCP socket connections.
     |      socket_keepalive_options : Mapping[int, int | bytes] | object | None
     |          Mapping of TCP keepalive socket option constants to values, for
     |          example `{socket.TCP_KEEPIDLE: 30}`. If left unspecified, redis-py
     |          uses TCP keepalive defaults when `socket_keepalive` is enabled:
     |          idle 30 seconds, interval 5 seconds, and 3 probes. Platform-specific
     |          options that are not available are skipped. Pass `None` or `{}` to
     |          avoid setting additional TCP keepalive options.
     |
     |  __repr__(self)
     |      Return repr(self).
     |
     |  async connect(self)
     |      Connects to the Redis server if not already connected
     |
     |  async connect_to(self, address)
     |
     |  async read_response(self, disable_decoding: bool = False, timeout: Optional[float] = None, *, disconnect_on_error: Optional[float] = True, push_request: Optional[bool] = False)
     |      Read the response from a previously sent command.
     |
     |      ``timeout`` semantics:
     |      - ``None`` (default): fall back to ``self.socket_timeout``.
     |      - ``math.inf``: block indefinitely with no timeout. Used by PubSub
     |        blocking reads (``listen()`` / ``get_message(timeout=None)`` /
     |        ``parse_response(block=True)``) where the configured
     |        ``socket_timeout`` must not abort the read.
     |      - ``float``: apply that timeout in seconds for this single read.
     |
     |      TODO(next-major): replace the ``math.inf`` opt-in with a SENTINEL
     |      default for ``timeout``. After that change, ``timeout=None`` will
     |      mean "no timeout, block until a response arrives" (matching the
     |      long-standing PubSub docstring contract) and the SENTINEL default
     |      will be the value that falls back to ``self.socket_timeout``.
     |      That swap is a breaking change, so it must wait for a major
     |      release. Until then, callers that need an indefinitely blocking
     |      read pass ``math.inf`` explicitly.
     |
     |  ----------------------------------------------------------------------
     |  Readonly properties inherited from redis.asyncio.connection.SSLConnection:
     |
     |  ca_certs
     |
     |  ca_data
     |
     |  cert_reqs
     |
     |  certfile
     |
     |  check_hostname
     |
     |  exclude_verify_flags
     |
     |  include_verify_flags
     |
     |  keyfile
     |
     |  min_version
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from redis.asyncio.connection.Connection:
     |
     |  repr_pieces(self)
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors inherited from redis.asyncio.connection.Connection:
     |
     |  __weakref__
     |      list of weak references to the object
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from redis.asyncio.connection.AbstractConnection:
     |
     |  __del__(self, _warnings: Any = <module 'warnings' from 'C:\\Users\\Youse\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\warnings.py'>)
     |
     |  async can_read(self) -> bool
     |      Check the socket to see if there's data loaded in the buffer.
     |
     |  async can_read_destructive(self) -> bool
     |      Check the socket to see if there's data loaded in the buffer.
     |
     |  async check_health(self)
     |      Check the health of the connection with a PING/PONG
     |
     |  async connect_check_health(self, check_health: bool = True, retry_socket_connect: bool = True)
     |
     |  deregister_connect_callback(self, callback)
     |      De-register a previously registered callback.  It will no-longer receive
     |      notifications on connection events.  Calling this is not required when the
     |      listener goes away, since the callbacks are kept as weak methods.
     |
     |  async disconnect(self, nowait: bool = False, error: Optional[Exception] = None, failure_count: Optional[int] = None, health_check_failed: bool = False) -> None
     |      Disconnects from the Redis server
     |
     |  get_protocol(self)
     |
     |  getpeername(self) -> str | None
     |      Returns the peer name of the connection.
     |
     |  mark_for_reconnect(self)
     |
     |  async on_connect(self) -> None
     |      Initialize the connection, authenticate and select a database
     |
     |  async on_connect_check_health(self, check_health: bool = True) -> None
     |
     |  pack_command(self, *args: Union[bytes, bytearray, memoryview, str, int, float]) -> List[bytes]
     |      Pack a series of arguments into the Redis protocol
     |
     |  pack_commands(self, commands: Iterable[Iterable[Union[bytes, bytearray, memoryview, str, int, float]]]) -> List[bytes]
     |      Pack multiple commands into the Redis protocol
     |
     |  async process_invalidation_messages(self)
     |
     |  async re_auth(self)
     |
     |  register_connect_callback(self, callback)
     |      Register a callback to be called when the connection is established either
     |      initially or reconnected.  This allows listeners to issue commands that
     |      are ephemeral to the connection, for example pub/sub subscription or
     |      key tracking.  The callback must be a _method_ and will be kept as
     |      a weak reference.
     |
     |  reset_should_reconnect(self)
     |
     |  async send_command(self, *args: Any, **kwargs: Any) -> None
     |      Pack and send a command to the Redis server
     |
     |  async send_packed_command(self, command: Union[bytes, str, Iterable[bytes]], check_health: bool = True) -> None
     |
     |  set_parser(self, parser_class: Type[redis._parsers.base.BaseParser]) -> None
     |      Creates a new instance of parser_class with socket size:
     |      _socket_read_size and assigns it to the parser for the connection
     |      :param parser_class: The required parser class
     |
     |  set_re_auth_token(self, token: redis.auth.token.TokenInterface)
     |
     |  should_reconnect(self)
     |
     |  ----------------------------------------------------------------------
     |  Readonly properties inherited from redis.asyncio.connection.AbstractConnection:
     |
     |  is_connected
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors inherited from redis.asyncio.connection.AbstractConnection:
     |
     |  __dict__
     |      dictionary for instance variables
     |
     |  client_name
     |
     |  credential_provider
     |
     |  db
     |
     |  encoder
     |
     |  health_check_interval
     |
     |  last_active_at
     |
     |  lib_name
     |
     |  lib_version
     |
     |  next_health_check
     |
     |  password
     |
     |  protocol
     |
     |  redis_connect_func
     |
     |  retry_on_error
     |
     |  retry_on_timeout
     |
     |  socket_connect_timeout
     |
     |  socket_timeout
     |
     |  ssl_context
     |
     |  username
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from redis.asyncio.connection.AsyncMaintNotificationsAbstractConnection:
     |
     |  async activate_maint_notifications_handling_if_enabled(self, check_health: bool = True) -> None
     |
     |  add_maint_start_notification(self, id: int) -> None
     |
     |  add_skipped_end_notification(self, id: int) -> None
     |
     |  get_processed_start_notifications(self) -> set[int]
     |
     |  get_resolved_ip(self) -> str | None
     |      Extract the resolved IP address from an established connection or host.
     |
     |      First tries to get the actual peer IP from the async stream writer, then
     |      falls back to DNS resolution if needed.
     |
     |      Returns:
     |          The resolved IP address, or None if it cannot be determined.
     |
     |  get_skipped_end_notifications(self) -> set[int]
     |
     |  reset_received_notifications(self) -> None
     |
     |  reset_tmp_settings(self, reset_host_address: bool = False, reset_relaxed_timeout: bool = False) -> None
     |
     |  set_maint_notifications_cluster_handler_for_connection(self, oss_cluster_maint_notifications_handler: redis.asyncio.maint_notifications.AsyncOSSMaintNotificationsHandler) -> None
     |
     |  set_maint_notifications_pool_handler_for_connection(self, maint_notifications_pool_handler: redis.asyncio.maint_notifications.AsyncMaintNotificationsPoolHandler) -> None
     |
     |  set_tmp_settings(self, tmp_host_address: str | object | None = <object object at 0x0000017B991493E0>, tmp_relaxed_timeout: float | None = -1) -> None
     |      SENTINEL keeps the host unchanged. -1 keeps the relaxed timeout unchanged.
     |
     |  update_current_socket_timeout(self, relaxed_timeout: float | None = None) -> None
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors inherited from redis.asyncio.connection.AsyncMaintNotificationsAbstractConnection:
     |
     |  maintenance_state

    StrictRedis = class Redis(redis.client.AbstractRedis, redis.commands.redismodules.AsyncRedisModuleCommands, redis.commands.core.AsyncCoreCommands, redis.commands.sentinel.AsyncSentinelCommands)
     |  StrictRedis(*, host: str = 'localhost', port: int = 6379, db: str | int = 0, password: str | None = None, socket_timeout: float | None = 5, socket_connect_timeout: float | None = 5, socket_read_size: int = 32768, socket_keepalive: bool | None = True, socket_keepalive_options: Union[Mapping[int, int | bytes], object, NoneType] = <object object at 0x0000017B991493E0>, connection_pool: redis.asyncio.connection.ConnectionPool | None = None, unix_socket_path: str | None = None, encoding: str = 'utf-8', encoding_errors: str = 'strict', decode_responses: bool = False, retry_on_timeout: bool = False, retry: redis.asyncio.retry.Retry = <redis.asyncio.retry.Retry object at 0x0000017B9C6BE4B0>, retry_on_error: list | None = None, ssl: bool = False, ssl_keyfile: str | None = None, ssl_certfile: str | None = None, ssl_cert_reqs: 'str | VerifyMode' = 'required', ssl_include_verify_flags: Optional[List[ForwardRef('VerifyFlags')]] = None, ssl_exclude_verify_flags: Optional[List[ForwardRef('VerifyFlags')]] = None, ssl_ca_certs: str | None = None, ssl_ca_data: str | None = None, ssl_ca_path: str | None = None, ssl_check_hostname: bool = True, ssl_min_version: 'TLSVersion | None' = None, ssl_ciphers: str | None = None, ssl_password: str | None = None, max_connections: int | None = None, single_connection_client: bool = False, health_check_interval: int = 0, client_name: str | None = None, lib_name: str | object | None = <object object at 0x0000017B991493E0>, lib_version: str | object | None = <object object at 0x0000017B991493E0>, driver_info: redis.driver_info.DriverInfo | object | None = <object object at 0x0000017B991493E0>, username: str | None = None, auto_close_connection_pool: bool | None = None, redis_connect_func=None, credential_provider: redis.credentials.CredentialProvider | None = None, protocol: int | None = None, legacy_responses: bool = True, event_dispatcher: redis.event.EventDispatcher | None = None, maint_notifications_config: redis.maint_notifications.MaintNotificationsConfig | None = None)
     |
     |  Implementation of the Redis protocol.
     |
     |  This abstract class provides a Python interface to all Redis commands
     |  and an implementation of the Redis protocol.
     |
     |  Pipelines derive from this, implementing how
     |  the commands are sent and received to the Redis server. Based on
     |  configuration, an instance will either use a ConnectionPool, or
     |  Connection object to talk to redis.
     |
     |  Method resolution order:
     |      Redis
     |      redis.client.AbstractRedis
     |      redis.commands.redismodules.AsyncRedisModuleCommands
     |      redis.commands.redismodules.RedisModuleCommands
     |      redis.commands.core.AsyncCoreCommands
     |      redis.commands.core.ACLCommands
     |      redis.commands.core.ClusterCommands
     |      redis.commands.core.AsyncDataAccessCommands
     |      redis.commands.core.AsyncBasicKeyCommands
     |      redis.commands.core.BasicKeyCommands
     |      redis.commands.core.HyperlogCommands
     |      redis.commands.core.HashCommands
     |      redis.commands.core.GeoCommands
     |      redis.commands.core.ListCommands
     |      redis.commands.core.ArrayCommands
     |      redis.commands.core.AsyncScanCommands
     |      redis.commands.core.ScanCommands
     |      redis.commands.core.SetCommands
     |      redis.commands.core.StreamCommands
     |      redis.commands.core.SortedSetCommands
     |      redis.commands.core.AsyncManagementCommands
     |      redis.commands.core.ManagementCommands
     |      redis.commands.core.AsyncModuleCommands
     |      redis.commands.core.ModuleCommands
     |      redis.commands.core.PubSubCommands
     |      redis.commands.core.AsyncScriptCommands
     |      redis.commands.core.ScriptCommands
     |      redis.typing.CommandsProtocol
     |      typing.Protocol
     |      typing.Generic
     |      redis.commands.core.FunctionCommands
     |      redis.commands.sentinel.AsyncSentinelCommands
     |      redis.commands.sentinel.SentinelCommands
     |      builtins.object
     |
     |  Methods defined here:
     |
     |  async __aenter__(self: ~_RedisT) -> ~_RedisT
     |      Async context manager entry. Increments a usage counter so that the
     |      connection pool is only closed (via aclose()) when no context is using
     |      the client.
     |
     |  async __aexit__(self, exc_type, exc_value, traceback)
     |      Async context manager exit. Decrements a usage counter. If this is the
     |      last exit (counter becomes zero), the client closes its connection pool.
     |
     |  __await__(self)
     |
     |  __del__(self, _warn: Any = <built-in function warn>, _grl: Any = <built-in function get_running_loop>) -> None
     |      # passing _warnings and _grl as argument default since they may be gone
     |      # by the time __del__ is called at shutdown
     |
     |  __init__(self, *, host: str = 'localhost', port: int = 6379, db: str | int = 0, password: str | None = None, socket_timeout: float | None = 5, socket_connect_timeout: float | None = 5, socket_read_size: int = 32768, socket_keepalive: bool | None = True, socket_keepalive_options: Union[Mapping[int, int | bytes], object, NoneType] = <object object at 0x0000017B991493E0>, connection_pool: redis.asyncio.connection.ConnectionPool | None = None, unix_socket_path: str | None = None, encoding: str = 'utf-8', encoding_errors: str = 'strict', decode_responses: bool = False, retry_on_timeout: bool = False, retry: redis.asyncio.retry.Retry = <redis.asyncio.retry.Retry object at 0x0000017B9C6BE4B0>, retry_on_error: list | None = None, ssl: bool = False, ssl_keyfile: str | None = None, ssl_certfile: str | None = None, ssl_cert_reqs: 'str | VerifyMode' = 'required', ssl_include_verify_flags: Optional[List[ForwardRef('VerifyFlags')]] = None, ssl_exclude_verify_flags: Optional[List[ForwardRef('VerifyFlags')]] = None, ssl_ca_certs: str | None = None, ssl_ca_data: str | None = None, ssl_ca_path: str | None = None, ssl_check_hostname: bool = True, ssl_min_version: 'TLSVersion | None' = None, ssl_ciphers: str | None = None, ssl_password: str | None = None, max_connections: int | None = None, single_connection_client: bool = False, health_check_interval: int = 0, client_name: str | None = None, lib_name: str | object | None = <object object at 0x0000017B991493E0>, lib_version: str | object | None = <object object at 0x0000017B991493E0>, driver_info: redis.driver_info.DriverInfo | object | None = <object object at 0x0000017B991493E0>, username: str | None = None, auto_close_connection_pool: bool | None = None, redis_connect_func=None, credential_provider: redis.credentials.CredentialProvider | None = None, protocol: int | None = None, legacy_responses: bool = True, event_dispatcher: redis.event.EventDispatcher | None = None, maint_notifications_config: redis.maint_notifications.MaintNotificationsConfig | None = None)
     |      Initialize a new Redis client.
     |
     |      To specify a retry policy for specific errors, you have two options:
     |
     |      1. Set the `retry_on_error` to a list of the error/s to retry on, and
     |      you can also set `retry` to a valid `Retry` object(in case the default
     |      one is not appropriate) - with this approach the retries will be triggered
     |      on the default errors specified in the Retry object enriched with the
     |      errors specified in `retry_on_error`.
     |
     |      2. Define a `Retry` object with configured 'supported_errors' and set
     |      it to the `retry` parameter - with this approach you completely redefine
     |      the errors on which retries will happen.
     |
     |      `retry_on_timeout` is deprecated - please include the TimeoutError
     |      either in the Retry object or in the `retry_on_error` list.
     |
     |      When 'connection_pool' is provided - the retry configuration of the
     |      provided pool will be used.
     |
     |      Args:
     |
     |      socket_keepalive:
     |          if `True`, TCP keepalive is enabled for TCP socket connections.
     |          Argument is ignored when connection_pool is provided.
     |      socket_keepalive_options:
     |          mapping of TCP keepalive socket option constants to values, for
     |          example `{socket.TCP_KEEPIDLE: 30}`. If left unspecified, redis-py
     |          uses TCP keepalive defaults when `socket_keepalive` is enabled:
     |          idle 30 seconds, interval 5 seconds, and 3 probes. Platform-specific
     |          options that are not available are skipped. Pass `None` or `{}` to
     |          avoid setting additional TCP keepalive options. Argument is ignored
     |          when connection_pool is provided.
     |      maint_notifications_config:
     |          configures the pool to support maintenance notifications - see
     |          `redis.maint_notifications.MaintNotificationsConfig` for details.
     |          Only supported with RESP3
     |          If not provided and protocol is RESP3, the maintenance notifications
     |          will be enabled by default (logic is included in the connection pool
     |          initialization).
     |          Argument is ignored when connection_pool is provided.
     |
     |  __repr__(self)
     |      Return repr(self).
     |
     |  async aclose(self, close_connection_pool: Optional[bool] = None) -> None
     |      Closes Redis client connection
     |
     |      Args:
     |          close_connection_pool:
     |              decides whether to close the connection pool used by this Redis client,
     |              overriding Redis.auto_close_connection_pool.
     |              By default, let Redis.auto_close_connection_pool decide
     |              whether to close the connection pool.
     |
     |  client(self) -> 'Redis'
     |
     |  async close(self, close_connection_pool: Optional[bool] = None) -> None
     |      Alias for aclose(), for backwards compatibility
     |
     |  async execute_command(self, *args, **options)
     |      Execute a command and return a parsed response
     |
     |  get_connection_kwargs(self)
     |      Get the connection's key-word arguments
     |
     |  get_encoder(self)
     |      Get the connection pool's encoder
     |
     |  get_retry(self) -> Optional[redis.asyncio.retry.Retry]
     |
     |  async himport_discard(self, fieldset_name: str) -> int
     |      Remove a fieldset from the registry.
     |
     |  async himport_discard_all(self) -> int
     |      Remove all fieldsets from the registry.
     |
     |  async himport_prepare(self, fieldset_name: str, fields: Iterable[Union[bytes, bytearray, memoryview, str, int, float]]) -> bool
     |      Declare an HIMPORT fieldset for use by :meth:`himport_set`.
     |
     |  async initialize(self: ~_RedisT) -> ~_RedisT
     |
     |  keyspace_notifications(self, key_prefix: Union[str, bytes, NoneType] = None, ignore_subscribe_messages: bool = True) -> 'AsyncKeyspaceNotifications'
     |      Return an :class:`~redis.asyncio.keyspace_notifications.AsyncKeyspaceNotifications`
     |      object for subscribing to keyspace and keyevent notifications.
     |
     |      Note: Keyspace notifications must be enabled on the Redis server via
     |      the ``notify-keyspace-events`` configuration option.
     |
     |      Args:
     |          key_prefix: Optional prefix to filter and strip from keys in
     |                      notifications.
     |          ignore_subscribe_messages: If True, subscribe/unsubscribe
     |                                    confirmations are not returned by
     |                                    get_message/listen.
     |
     |  load_external_module(self, funcname, func)
     |      This function can be used to add externally defined redis modules,
     |      and their namespaces to the redis client.
     |
     |      funcname - A string containing the name of the function to create
     |      func - The function, being added to this class.
     |
     |      ex: Assume that one has a custom redis module named foomod that
     |      creates command named 'foo.dothing' and 'foo.anotherthing' in redis.
     |      To load function functions into this namespace:
     |
     |      from redis import Redis
     |      from foomodule import F
     |      r = Redis()
     |      r.load_external_module("foo", F)
     |      r.foo().dothing('your', 'arguments')
     |
     |      For a concrete example see the reimport of the redisjson module in
     |      tests/test_connection.py::test_loading_external_modules
     |
     |  lock(self, name: Union[bytes, str, memoryview], timeout: Optional[float] = None, sleep: float = 0.1, blocking: bool = True, blocking_timeout: Optional[float] = None, lock_class: Optional[Type[redis.asyncio.lock.Lock]] = None, thread_local: bool = True, raise_on_release_error: bool = True) -> redis.asyncio.lock.Lock
     |      Return a new Lock object using key ``name`` that mimics
     |      the behavior of threading.Lock.
     |
     |      If specified, ``timeout`` indicates a maximum life for the lock.
     |      By default, it will remain locked until release() is called.
     |
     |      ``sleep`` indicates the amount of time to sleep per loop iteration
     |      when the lock is in blocking mode and another client is currently
     |      holding the lock.
     |
     |      ``blocking`` indicates whether calling ``acquire`` should block until
     |      the lock has been acquired or to fail immediately, causing ``acquire``
     |      to return False and the lock not being acquired. Defaults to True.
     |      Note this value can be overridden by passing a ``blocking``
     |      argument to ``acquire``.
     |
     |      ``blocking_timeout`` indicates the maximum amount of time in seconds to
     |      spend trying to acquire the lock. A value of ``None`` indicates
     |      continue trying forever. ``blocking_timeout`` can be specified as a
     |      float or integer, both representing the number of seconds to wait.
     |
     |      ``lock_class`` forces the specified lock implementation. Note that as
     |      of redis-py 3.0, the only lock class we implement is ``Lock`` (which is
     |      a Lua-based lock). So, it's unlikely you'll need this parameter, unless
     |      you have created your own custom lock class.
     |
     |      ``thread_local`` indicates whether the lock token is placed in
     |      thread-local storage. By default, the token is placed in thread local
     |      storage so that a thread only sees its token, not a token set by
     |      another thread. Consider the following timeline:
     |
     |          time: 0, thread-1 acquires `my-lock`, with a timeout of 5 seconds.
     |                   thread-1 sets the token to "abc"
     |          time: 1, thread-2 blocks trying to acquire `my-lock` using the
     |                   Lock instance.
     |          time: 5, thread-1 has not yet completed. redis expires the lock
     |                   key.
     |          time: 5, thread-2 acquired `my-lock` now that it's available.
     |                   thread-2 sets the token to "xyz"
     |          time: 6, thread-1 finishes its work and calls release(). if the
     |                   token is *not* stored in thread local storage, then
     |                   thread-1 would see the token value as "xyz" and would be
     |                   able to successfully release the thread-2's lock.
     |
     |      ``raise_on_release_error`` indicates whether to raise an exception when
     |      the lock is no longer owned when exiting the context manager. By default,
     |      this is True, meaning an exception will be raised. If False, the warning
     |      will be logged and the exception will be suppressed.
     |
     |      In some use cases it's necessary to disable thread local storage. For
     |      example, if you have code where one thread acquires a lock and passes
     |      that lock instance to a worker thread to release later. If thread
     |      local storage isn't disabled in this case, the worker thread won't see
     |      the token set by the thread that acquired the lock. Our assumption
     |      is that these cases aren't common and as such default to using
     |      thread local storage.
     |
     |  monitor(self) -> 'Monitor'
     |
     |  async parse_response(self, connection: redis.asyncio.connection.Connection, command_name: Union[str, bytes], **options)
     |      Parses a response from the Redis server
     |
     |  pipeline(self, transaction: bool = True, shard_hint: Optional[str] = None) -> 'Pipeline'
     |      Return a new pipeline object that can queue multiple commands for
     |      later execution. ``transaction`` indicates whether all commands
     |      should be executed atomically. Apart from making a group of operations
     |      atomic, pipelines are useful for reducing the back-and-forth overhead
     |      between the client and server.
     |
     |  pubsub(self, **kwargs) -> 'PubSub'
     |      Return a Publish/Subscribe object. With this object, you can
     |      subscribe to channels and listen for messages that get published to
     |      them.
     |
     |  set_response_callback(self, command: str, callback: Union[redis.asyncio.client.ResponseCallbackProtocol, redis.asyncio.client.AsyncResponseCallbackProtocol])
     |      Set a custom Response Callback
     |
     |  set_retry(self, retry: redis.asyncio.retry.Retry) -> None
     |
     |  async transaction(self, func: Callable[[ForwardRef('Pipeline')], Union[Any, Awaitable[Any]]], *watches: Union[bytes, str, memoryview], shard_hint: Optional[str] = None, value_from_callable: bool = False, watch_delay: Optional[float] = None)
     |      Convenience method for executing the callable `func` as a transaction
     |      while watching all keys specified in `watches`. The 'func' callable
     |      should expect a single argument which is a Pipeline object.
     |
     |  ----------------------------------------------------------------------
     |  Class methods defined here:
     |
     |  __subclasshook__ = _proto_hook(other) from typing
     |
     |  from_pool(connection_pool: redis.asyncio.connection.ConnectionPool) -> 'Redis'
     |      Return a Redis client from the given connection pool.
     |      The Redis client will take ownership of the connection pool and
     |      close it when the Redis client is closed.
     |
     |      Because the client closes (disconnects all connections in) the pool
     |      when it is closed or garbage-collected, the pool must not be shared
     |      with other clients. Constructing multiple clients from the same pool
     |      via ``from_pool`` -- for example one per request across tasks -- is
     |      not safe: when one client is closed it will disconnect connections
     |      still in use by the others.
     |
     |      To share a single pool across clients, construct the pool explicitly
     |      and manage its lifecycle instead. Unlike ``from_pool``, the plain
     |      ``Redis(connection_pool=pool)`` constructor does not take ownership of
     |      the pool and will not close it, so a pool created this way can be
     |      safely shared across clients. ``ConnectionPool`` supports the async
     |      context manager protocol for this::
     |
     |          async with ConnectionPool.from_url(url) as pool:
     |              r = Redis(connection_pool=pool)
     |
     |  from_url(url: str, single_connection_client: bool = False, auto_close_connection_pool: Optional[bool] = None, **kwargs) -> 'Redis'
     |      Return a Redis client object configured from the given URL
     |
     |      For example::
     |
     |          redis://[[username]:[password]]@localhost:6379/0
     |          rediss://[[username]:[password]]@localhost:6379/0
     |          unix://[username@]/path/to/socket.sock?db=0[&password=password]
     |
     |      Three URL schemes are supported:
     |
     |      - `redis://` creates a TCP socket connection. See more at:
     |        <https://www.iana.org/assignments/uri-schemes/prov/redis>
     |      - `rediss://` creates a SSL wrapped TCP socket connection. See more at:
     |        <https://www.iana.org/assignments/uri-schemes/prov/rediss>
     |      - ``unix://``: creates a Unix Domain Socket connection.
     |
     |      The username, password, hostname, path and all querystring values
     |      are passed through urllib.parse.unquote in order to replace any
     |      percent-encoded values with their corresponding characters.
     |
     |      There are several ways to specify a database number. The first value
     |      found will be used:
     |
     |      1. A ``db`` querystring option, e.g. redis://localhost?db=0
     |
     |      2. If using the redis:// or rediss:// schemes, the path argument
     |             of the url, e.g. redis://localhost/0
     |
     |      3. A ``db`` keyword argument to this function.
     |
     |      If none of these options are specified, the default db=0 is used.
     |
     |      All querystring options are cast to their appropriate Python types.
     |      Boolean arguments can be specified with string values "True"/"False"
     |      or "Yes"/"No". Values that cannot be properly cast cause a
     |      ``ValueError`` to be raised. Once parsed, the querystring arguments
     |      and keyword arguments are passed to the ``ConnectionPool``'s
     |      class initializer. In the case of conflicting arguments, querystring
     |      arguments always win.
     |
     |  ----------------------------------------------------------------------
     |  Readonly properties defined here:
     |
     |  himport_registry
     |      The client's HIMPORT fieldset registry (empty if none was declared).
     |
     |      Read-only: the registry is mutated only through the HIMPORT command methods.
     |
     |  ----------------------------------------------------------------------
     |  Data and other attributes defined here:
     |
     |  __abstractmethods__ = frozenset()
     |
     |  __annotations__ = {'_is_async_client': typing.Literal[True], 'response...
     |
     |  __parameters__ = ()
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors inherited from redis.client.AbstractRedis:
     |
     |  __dict__
     |      dictionary for instance variables
     |
     |  __weakref__
     |      list of weak references to the object
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from redis.commands.redismodules.AsyncRedisModuleCommands:
     |
     |  bf(self) -> 'AsyncBFBloom'
     |      Access the bloom namespace.
     |
     |  cf(self) -> 'AsyncCFBloom'
     |      Access the bloom namespace.
     |
     |  cms(self) -> 'AsyncCMSBloom'
     |      Access the bloom namespace.
     |
     |  ft(self, index_name='idx') -> 'AsyncSearch'
     |      Access the search namespace, providing support for redis search.
     |
     |  json(self, encoder=<json.encoder.JSONEncoder object at 0x0000017B9C589190>, decoder=<json.decoder.JSONDecoder object at 0x0000017B9C589220>) -> 'AsyncJSON'
     |      Access the json namespace, providing support for redis json.
     |
     |  tdigest(self) -> 'AsyncTDigestBloom'
     |      Access the bloom namespace.
     |
     |  topk(self) -> 'AsyncTOPKBloom'
     |      Access the bloom namespace.
     |
     |  ts(self) -> 'AsyncTimeSeries'
     |      Access the timeseries namespace, providing support for
     |      redis timeseries data.
     |
     |  vset(self) -> 'AsyncVectorSet'
     |      Access the VectorSet commands namespace.
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from redis.commands.core.ACLCommands:
     |
     |  acl_cat(self, category: 'str | None' = None, **kwargs) -> 'list[bytes | str] | Awaitable[list[bytes | str]]'
     |      Returns a list of categories or commands within a category.
     |
     |      If ``category`` is not supplied, returns a list of all categories.
     |      If ``category`` is supplied, returns a list of all commands within
     |      that category.
     |
     |      For more information, see https://redis.io/commands/acl-cat
     |
     |  acl_deluser(self, *username: 'str', **kwargs) -> 'int | Awaitable[int]'
     |      Delete the ACL for the specified ``username``\s
     |
     |      For more information, see https://redis.io/commands/acl-deluser
     |
     |  acl_dryrun(self, username: 'str', *args: 'EncodableT', **kwargs) -> 'bytes | str | Awaitable[bytes | str]'
     |      Simulate the execution of a given command by a given ``username``.
     |
     |      For more information, see https://redis.io/commands/acl-dryrun
     |
     |  acl_genpass(self, bits: 'int | None' = None, **kwargs) -> 'bytes | str | Awaitable[bytes | str]'
     |      Generate a random password value.
     |      If ``bits`` is supplied then use this number of bits, rounded to
     |      the next multiple of 4.
     |      See: https://redis.io/commands/acl-genpass
     |
     |  acl_getuser(self, username: 'str', **kwargs) -> 'ACLGetUserData | Awaitable[ACLGetUserData]'
     |      Get the ACL details for the specified ``username``.
     |
     |      If ``username`` does not exist, return None
     |
     |      For more information, see https://redis.io/commands/acl-getuser
     |
     |  acl_help(self, **kwargs) -> 'list[bytes | str] | Awaitable[list[bytes | str]]'
     |      The ACL HELP command returns helpful text describing
     |      the different subcommands.
     |
     |      For more information, see https://redis.io/commands/acl-help
     |
     |  acl_list(self, **kwargs) -> 'list[bytes | str] | Awaitable[list[bytes | str]]'
     |      Return a list of all ACLs on the server
     |
     |      For more information, see https://redis.io/commands/acl-list
     |
     |  acl_load(self, **kwargs) -> 'bool | Awaitable[bool]'
     |      Load ACL rules from the configured ``aclfile``.
     |
     |      Note that the server must be configured with the ``aclfile``
     |      directive to be able to load ACL rules from an aclfile.
     |
     |      For more information, see https://redis.io/commands/acl-load
     |
     |  acl_log(self, count: 'int | None' = None, **kwargs) -> 'ACLLogData | Awaitable[ACLLogData]'
     |      Get ACL logs as a list.
     |      :param int count: Get logs[0:count].
     |      :rtype: List.
     |
     |      For more information, see https://redis.io/commands/acl-log
     |
     |  acl_log_reset(self, **kwargs) -> 'bool | Awaitable[bool]'
     |      Reset ACL logs.
     |      :rtype: Boolean.
     |
     |      For more information, see https://redis.io/commands/acl-log
     |
     |  acl_save(self, **kwargs) -> 'bool | Awaitable[bool]'
     |      Save ACL rules to the configured ``aclfile``.
     |
     |      Note that the server must be configured with the ``aclfile``
     |      directive to be able to save ACL rules to an aclfile.
     |
     |      For more information, see https://redis.io/commands/acl-save
     |
     |  acl_setuser(self, username: 'str', enabled: 'bool' = False, nopass: 'bool' = False, passwords: 'str | Iterable[str] | None' = None, hashed_passwords: 'str | Iterable[str] | None' = None, categories: 'Iterable[str] | None' = None, commands: 'Iterable[str] | None' = None, keys: 'Iterable[KeyT] | None' = None, channels: 'Iterable[ChannelT] | None' = None, selectors: 'Iterable[Tuple[str, KeyT]] | None' = None, reset: 'bool' = False, reset_keys: 'bool' = False, reset_channels: 'bool' = False, reset_passwords: 'bool' = False, **kwargs) -> 'bool | Awaitable[bool]'
     |      Create or update an ACL user.
     |
     |      Create or update the ACL for `username`. If the user already exists,
     |      the existing ACL is completely overwritten and replaced with the
     |      specified values.
     |
     |      For more information, see https://redis.io/commands/acl-setuser
     |
     |      Args:
     |          username: The name of the user whose ACL is to be created or updated.
     |          enabled: Indicates whether the user should be allowed to authenticate.
     |                   Defaults to `False`.
     |          nopass: Indicates whether the user can authenticate without a password.
     |                  This cannot be `True` if `passwords` are also specified.
     |          passwords: A list of plain text passwords to add to or remove from the user.
     |                     Each password must be prefixed with a '+' to add or a '-' to
     |                     remove. For convenience, a single prefixed string can be used
     |                     when adding or removing a single password.
     |          hashed_passwords: A list of SHA-256 hashed passwords to add to or remove
     |                            from the user. Each hashed password must be prefixed with
     |                            a '+' to add or a '-' to remove. For convenience, a single
     |                            prefixed string can be used when adding or removing a
     |                            single password.
     |          categories: A list of strings representing category permissions. Each string
     |                      must be prefixed with either a '+' to add the category
     |                      permission or a '-' to remove the category permission.
     |          commands: A list of strings representing command permissions. Each string
     |                    must be prefixed with either a '+' to add the command permission
     |                    or a '-' to remove the command permission.
     |          keys: A list of key patterns to grant the user access to. Key patterns allow
     |                ``'*'`` to support wildcard matching. For example, ``'*'`` grants
     |                access to all keys while ``'cache:*'`` grants access to all keys that
     |                are prefixed with ``cache:``.
     |                `keys` should not be prefixed with a ``'~'``.
     |          reset: Indicates whether the user should be fully reset prior to applying
     |                 the new ACL. Setting this to `True` will remove all existing
     |                 passwords, flags, and privileges from the user and then apply the
     |                 specified rules. If `False`, the user's existing passwords, flags,
     |                 and privileges will be kept and any new specified rules will be
     |                 applied on top.
     |          reset_keys: Indicates whether the user's key permissions should be reset
     |                      prior to applying any new key permissions specified in `keys`.
     |                      If `False`, the user's existing key permissions will be kept and
     |                      any new specified key permissions will be applied on top.
     |          reset_channels: Indicates whether the user's channel permissions should be
     |                          reset prior to applying any new channel permissions
     |                          specified in `channels`. If `False`, the user's existing
     |                          channel permissions will be kept and any new specified
     |                          channel permissions will be applied on top.
     |          reset_passwords: Indicates whether to remove all existing passwords and the
     |                           `nopass` flag from the user prior to applying any new
     |                           passwords specified in `passwords` or `hashed_passwords`.
     |                           If `False`, the user's existing passwords and `nopass`
     |                           status will be kept and any new specified passwords or
     |                           hashed passwords will be applied on top.
     |
     |  acl_users(self, **kwargs) -> 'list[bytes | str] | Awaitable[list[bytes | str]]'
     |      Returns a list of all registered users on the server.
     |
     |      For more information, see https://redis.io/commands/acl-users
     |
     |  acl_whoami(self, **kwargs) -> 'bytes | str | Awaitable[bytes | str]'
     |      Get the username for the current connection
     |
     |      For more information, see https://redis.io/commands/acl-whoami
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from redis.commands.core.ClusterCommands:
     |
     |  cluster(self, cluster_arg, *args, **kwargs) -> 'Any | Awaitable[Any]'
     |
     |  readonly(self, **kwargs) -> 'bool | Awaitable[bool]'
     |      Enables read queries for a connection to a Redis Cluster replica node.
     |
     |      For more information, see https://redis.io/commands/readonly
     |
     |  readwrite(self, **kwargs) -> 'bool | Awaitable[bool]'
     |      Disables read queries for a connection to a Redis Cluster slave node.
     |
     |      For more information, see https://redis.io/commands/readwrite
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from redis.commands.core.AsyncBasicKeyCommands:
     |
     |  __contains__(self, name: 'KeyT')
     |      Returns the number of ``names`` that exist
     |
     |      For more information, see https://redis.io/commands/exists
     |
     |  __delitem__(self, name: 'KeyT')
     |
     |  __getitem__(self, name: 'KeyT')
     |      Return the value at key ``name``, raises a KeyError if the key
     |      doesn't exist.
     |
     |  __setitem__(self, name: 'KeyT', value: 'EncodableT')
     |
     |  async unwatch(self) -> 'None'
     |      Unwatches all previously watched keys for a transaction
     |
     |      For more information, see https://redis.io/commands/unwatch
     |
     |  async watch(self, *names: 'KeyT') -> 'None'
     |      Watches the values at keys ``names``, or None if the key doesn't exist
     |
     |      For more information, see https://redis.io/commands/watch
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from redis.commands.core.BasicKeyCommands:
     |
     |  append(self, key: 'KeyT', value: 'EncodableT') -> 'int | Awaitable[int]'
     |      Appends the string ``value`` to the value at ``key``. If ``key``
     |      doesn't already exist, create it with a value of ``value``.
     |      Returns the new length of the value at ``key``.
     |
     |      For more information, see https://redis.io/commands/append
     |
     |  bitcount(self, key: 'KeyT', start: 'int | None' = None, end: 'int | None' = None, mode: 'str | None' = None) -> 'int | Awaitable[int]'
     |      Returns the count of set bits in the value of ``key``.  Optional
     |      ``start`` and ``end`` parameters indicate which bytes to consider
     |
     |      For more information, see https://redis.io/commands/bitcount
     |
     |  bitfield(self: "Union['redis.client.Redis', 'redis.asyncio.client.Redis']", key: 'KeyT', default_overflow: 'str | None' = None) -> 'BitFieldOperation'
     |      Return a BitFieldOperation instance to conveniently construct one or
     |      more bitfield operations on ``key``.
     |
     |      For more information, see https://redis.io/commands/bitfield
     |
     |  bitfield_ro(self: "Union['redis.client.Redis', 'redis.asyncio.client.Redis']", key: 'KeyT', encoding: 'str', offset: 'BitfieldOffsetT', items: 'list[tuple[str, BitfieldOffsetT]] | None' = None) -> 'list[int] | Awaitable[list[int]]'
     |      Return an array of the specified bitfield values
     |      where the first value is found using ``encoding`` and ``offset``
     |      parameters and remaining values are result of corresponding
     |      encoding/offset pairs in optional list ``items``
     |      Read-only variant of the BITFIELD command.
     |
     |      For more information, see https://redis.io/commands/bitfield_ro
     |
     |  bitop(self, operation: 'str', dest: 'KeyT', *keys: 'KeyT') -> 'int | Awaitable[int]'
     |      Perform a bitwise operation using ``operation`` between ``keys`` and
     |      store the result in ``dest``.
     |
     |      For more information, see https://redis.io/commands/bitop
     |
     |  bitpos(self, key: 'KeyT', bit: 'int', start: 'int | None' = None, end: 'int | None' = None, mode: 'str | None' = None) -> 'int | Awaitable[int]'
     |      Return the position of the first bit set to 1 or 0 in a string.
     |      ``start`` and ``end`` defines search range. The range is interpreted
     |      as a range of bytes and not a range of bits, so start=0 and end=2
     |      means to look at the first three bytes.
     |
     |      For more information, see https://redis.io/commands/bitpos
     |
     |  blmove(self, first_list: 'str', second_list: 'str', timeout: 'int', src: 'str' = 'LEFT', dest: 'str' = 'RIGHT') -> 'bytes | str | None | Awaitable[bytes | str | None]'
     |      Blocking version of lmove.
     |
     |      For more information, see https://redis.io/commands/blmove
     |
     |  blmovem(self, first_list: 'str', second_list: 'str', timeout: 'float', src: 'str' = 'LEFT', dest: 'str' = 'RIGHT', count: 'int | None' = None, mode: "Literal['COUNT', 'EXACTLY'] | None" = None, ordering: "Literal['OBO', 'BULK'] | None" = None) -> 'list[bytes | str] | None | Awaitable[list[bytes | str] | None]'
     |      Blocking version of lmovem.
     |
     |      Blocks until elements are available to move or ``timeout`` (in seconds)
     |      is reached; a ``timeout`` of ``0`` blocks indefinitely. With ``COUNT``
     |      the command unblocks once at least one element is available and moves
     |      ``min(count, available)``; with ``EXACTLY`` it blocks until the source
     |      holds at least ``count`` elements, then moves exactly ``count``
     |      atomically. On timeout ``None`` is returned and nothing is moved.
     |
     |      As with ``lmovem``, ``ordering`` (OBO or BULK) is required whenever
     |      ``count`` is given.
     |
     |      For more information, see https://redis.io/commands/blmovem
     |
     |  copy(self, source: 'str', destination: 'str', destination_db: 'str | None' = None, replace: 'bool' = False) -> 'bool | Awaitable[bool]'
     |      Copy the value stored in the ``source`` key to the ``destination`` key.
     |
     |      ``destination_db`` an alternative destination database. By default,
     |      the ``destination`` key is created in the source Redis database.
     |
     |      ``replace`` whether the ``destination`` key should be removed before
     |      copying the value to it. By default, the value is not copied if
     |      the ``destination`` key already exists.
     |
     |      For more information, see https://redis.io/commands/copy
     |
     |  decr = decrby(self, name: 'KeyT', amount: 'int' = 1) -> 'int | Awaitable[int]'
     |
     |  decrby(self, name: 'KeyT', amount: 'int' = 1) -> 'int | Awaitable[int]'
     |      Decrements the value of ``key`` by ``amount``.  If no key exists,
     |      the value will be initialized as 0 - ``amount``
     |
     |      For more information, see https://redis.io/commands/decrby
     |
     |  delete(self, *names: 'KeyT') -> 'int | Awaitable[int]'
     |      Delete one or more keys specified by ``names``
     |
     |  delex(self, name: 'KeyT', ifeq: 'bytes | str | None' = None, ifne: 'bytes | str | None' = None, ifdeq: 'str | None' = None, ifdne: 'str | None' = None) -> 'int | Awaitable[int]'
     |      Conditionally removes the specified key.
     |
     |      Warning:
     |      **Experimental** since 7.1.
     |      This API may change or be removed without notice.
     |      The API may change based on feedback.
     |
     |      Arguments:
     |          name: KeyT - the key to delete
     |          ifeq match-valu: Optional[Union[bytes, str]] - Delete the key only if its value is equal to match-value
     |          ifne match-value: Optional[Union[bytes, str]] - Delete the key only if its value is not equal to match-value
     |          ifdeq match-digest: Optional[str] - Delete the key only if the digest of its value is equal to match-digest
     |          ifdne match-digest: Optional[str] - Delete the key only if the digest of its value is not equal to match-digest
     |
     |      Returns:
     |          int: 1 if the key was deleted, 0 otherwise.
     |      Raises:
     |          redis.exceptions.ResponseError: if key exists but is not a string
     |                                          and a condition is specified.
     |          ValueError: if more than one condition is provided.
     |
     |
     |      Requires Redis 8.4 or greater.
     |      For more information, see https://redis.io/commands/delex
     |
     |  digest(self, name: 'KeyT') -> 'str | bytes | None | Awaitable[str | bytes | None]'
     |      Return the digest of the value stored at the specified key.
     |
     |      Warning:
     |      **Experimental** since 7.1.
     |      This API may change or be removed without notice.
     |      The API may change based on feedback.
     |
     |      Arguments:
     |        - name: KeyT - the key to get the digest of
     |
     |      Returns:
     |        - None if the key does not exist
     |        - (bulk string) the XXH3 digest of the value as a hex string
     |      Raises:
     |        - ResponseError if key exists but is not a string
     |
     |
     |      Requires Redis 8.4 or greater.
     |      For more information, see https://redis.io/commands/digest
     |
     |  digest_local(self, value: 'bytes | str') -> 'bytes | str'
     |      Compute the hexadecimal digest of the value locally, without sending it to the server.
     |
     |      This is useful for conditional operations like IFDEQ/IFDNE where you need to
     |      compute the digest client-side before sending a command.
     |
     |      Warning:
     |      **Experimental** - This API may change or be removed without notice.
     |
     |      Arguments:
     |        - value: Union[bytes, str] - the value to compute the digest of.
     |          If a string is provided, it will be encoded using UTF-8 before hashing,
     |          which matches Redis's default encoding behavior.
     |
     |      Returns:
     |        - (str | bytes) the XXH3 digest of the value as a hex string (16 hex characters).
     |          Returns bytes if decode_responses is False, otherwise returns str.
     |
     |      For more information, see https://redis.io/commands/digest
     |
     |  dump(self, name: 'KeyT') -> 'bytes | None | Awaitable[bytes | None]'
     |      Return a serialized version of the value stored at the specified key.
     |      If key does not exist a nil bulk reply is returned.
     |
     |      For more information, see https://redis.io/commands/dump
     |
     |  exists(self, *names: 'KeyT') -> 'int | Awaitable[int]'
     |      Returns the number of ``names`` that exist
     |
     |      For more information, see https://redis.io/commands/exists
     |
     |  expire(self, name: 'KeyT', time: 'ExpiryT', nx: 'bool' = False, xx: 'bool' = False, gt: 'bool' = False, lt: 'bool' = False) -> 'bool | Awaitable[bool]'
     |      Set an expire flag on key ``name`` for ``time`` seconds with given
     |      ``option``. ``time`` can be represented by an integer or a Python timedelta
     |      object.
     |
     |      Valid options are:
     |          NX -> Set expiry only when the key has no expiry
     |          XX -> Set expiry only when the key has an existing expiry
     |          GT -> Set expiry only when the new expiry is greater than current one
     |          LT -> Set expiry only when the new expiry is less than current one
     |
     |      For more information, see https://redis.io/commands/expire
     |
     |  expireat(self, name: 'KeyT', when: 'AbsExpiryT', nx: 'bool' = False, xx: 'bool' = False, gt: 'bool' = False, lt: 'bool' = False) -> 'bool | Awaitable[bool]'
     |      Set an expire flag on key ``name`` with given ``option``. ``when``
     |      can be represented as an integer indicating unix time or a Python
     |      datetime object.
     |
     |      Valid options are:
     |          -> NX -- Set expiry only when the key has no expiry
     |          -> XX -- Set expiry only when the key has an existing expiry
     |          -> GT -- Set expiry only when the new expiry is greater than current one
     |          -> LT -- Set expiry only when the new expiry is less than current one
     |
     |      For more information, see https://redis.io/commands/expireat
     |
     |  expiretime(self, key: 'str') -> 'int | Awaitable[int]'
     |      Returns the absolute Unix timestamp (since January 1, 1970) in seconds
     |      at which the given key will expire.
     |
     |      For more information, see https://redis.io/commands/expiretime
     |
     |  get(self, name: 'KeyT') -> 'bytes | str | None | Awaitable[bytes | str | None]'
     |      Return the value at key ``name``, or None if the key doesn't exist
     |
     |      For more information, see https://redis.io/commands/get
     |
     |  getbit(self, name: 'KeyT', offset: 'int') -> 'int | Awaitable[int]'
     |      Returns an integer indicating the value of ``offset`` in ``name``
     |
     |      For more information, see https://redis.io/commands/getbit
     |
     |  getdel(self, name: 'KeyT') -> 'bytes | str | None | Awaitable[bytes | str | None]'
     |      Get the value at key ``name`` and delete the key. This command
     |      is similar to GET, except for the fact that it also deletes
     |      the key on success (if and only if the key's value type
     |      is a string).
     |
     |      For more information, see https://redis.io/commands/getdel
     |
     |  getex(self, name: 'KeyT', ex: 'ExpiryT | None' = None, px: 'ExpiryT | None' = None, exat: 'AbsExpiryT | None' = None, pxat: 'AbsExpiryT | None' = None, persist: 'bool' = False) -> 'bytes | str | None | Awaitable[bytes | str | None]'
     |      Get the value of key and optionally set its expiration.
     |      GETEX is similar to GET, but is a write command with
     |      additional options. All time parameters can be given as
     |      datetime.timedelta or integers.
     |
     |      ``ex`` sets an expire flag on key ``name`` for ``ex`` seconds.
     |
     |      ``px`` sets an expire flag on key ``name`` for ``px`` milliseconds.
     |
     |      ``exat`` sets an expire flag on key ``name`` for ``ex`` seconds,
     |      specified in unix time.
     |
     |      ``pxat`` sets an expire flag on key ``name`` for ``ex`` milliseconds,
     |      specified in unix time.
     |
     |      ``persist`` remove the time to live associated with ``name``.
     |
     |      For more information, see https://redis.io/commands/getex
     |
     |  getrange(self, key: 'KeyT', start: 'int', end: 'int') -> 'bytes | str | Awaitable[bytes | str]'
     |      Returns the substring of the string value stored at ``key``,
     |      determined by the offsets ``start`` and ``end`` (both are inclusive)
     |
     |      For more information, see https://redis.io/commands/getrange
     |
     |  getset(self, name: 'KeyT', value: 'EncodableT') -> 'bytes | str | None | Awaitable[bytes | str | None]'
     |      Sets the value at key ``name`` to ``value``
     |      and returns the old value at key ``name`` atomically.
     |
     |      As per Redis 6.2, GETSET is considered deprecated.
     |      Please use SET with GET parameter in new code.
     |
     |      For more information, see https://redis.io/commands/getset
     |
     |  hrandfield(self, key: 'KeyT', count: 'int | None' = None, withvalues: 'bool' = False) -> 'HRandFieldResponse | Awaitable[HRandFieldResponse]'
     |      Return a random field from the hash value stored at key.
     |
     |      count: if the argument is positive, return an array of distinct fields.
     |      If called with a negative count, the behavior changes and the command
     |      is allowed to return the same field multiple times. In this case,
     |      the number of returned fields is the absolute value of the
     |      specified count.
     |      withvalues: The optional WITHVALUES modifier changes the reply so it
     |      includes the respective values of the randomly selected hash fields.
     |
     |      For more information, see https://redis.io/commands/hrandfield
     |
     |  incr = incrby(self, name: 'KeyT', amount: 'int' = 1) -> 'int | Awaitable[int]'
     |
     |  incrby(self, name: 'KeyT', amount: 'int' = 1) -> 'int | Awaitable[int]'
     |      Increments the value of ``key`` by ``amount``.  If no key exists,
     |      the value will be initialized as ``amount``
     |
     |      For more information, see https://redis.io/commands/incrby
     |
     |  incrbyfloat(self, name: 'KeyT', amount: 'float' = 1.0) -> 'float | Awaitable[float]'
     |      Increments the value at key ``name`` by floating ``amount``.
     |      If no key exists, the value will be initialized as ``amount``
     |
     |      For more information, see https://redis.io/commands/incrbyfloat
     |
     |  increx(self, name: 'KeyT', *, byfloat: 'EncodableT | None' = None, byint: 'EncodableT | None' = None, lbound: 'EncodableT | None' = None, ubound: 'EncodableT | None' = None, saturate: 'bool' = False, ex: 'ExpiryT | None' = None, px: 'ExpiryT | None' = None, exat: 'AbsExpiryT | None' = None, pxat: 'AbsExpiryT | None' = None, persist: 'bool' = False, enx: 'bool' = False) -> 'list[Number | bytes | str] | Awaitable[list[Number | bytes | str]]'
     |      Increment the numeric value at key ``name`` and return the new value
     |      and the actual increment.
     |
     |      ``byfloat`` increments a floating point value by the provided amount.
     |
     |      ``byint`` increments an integer value by the provided amount.
     |
     |      If neither ``byfloat`` nor ``byint`` is specified, the value is
     |      incremented by one.
     |
     |      ``lbound`` and ``ubound`` constrain the valid range of the result.
     |
     |      If ``saturate`` is True, out-of-bounds results are saturated to the
     |      specified bound, or to the type limit when no bound is specified.
     |      Otherwise, out-of-bounds results are rejected, leaving the value and
     |      TTL unchanged and returning the current value and zero as the actual
     |      increment.
     |
     |      ``enx`` applies the expiration only when the key does not already
     |      have an expiration, and requires ``ex``, ``px``, ``exat``, or ``pxat``.
     |
     |  keys(self, pattern: 'PatternT' = '*', **kwargs) -> 'list[bytes | str] | Awaitable[list[bytes | str]]'
     |      Returns a list of keys matching ``pattern``
     |
     |      For more information, see https://redis.io/commands/keys
     |
     |  lcs(self, key1: 'str', key2: 'str', len: 'bool | None' = False, idx: 'bool | None' = False, minmatchlen: 'int | None' = 0, withmatchlen: 'bool | None' = False) -> 'LCSCommandResponse | Awaitable[LCSCommandResponse]'
     |      Find the longest common subsequence between ``key1`` and ``key2``.
     |      If ``len`` is true the length of the match will be returned.
     |      If ``idx`` is true the match position in each strings will be returned.
     |      ``minmatchlen`` restrict the list of matches to the ones of
     |      the given ``minmatchlen``.
     |      If ``withmatchlen`` the length of the match also will be returned.
     |      For more information, see https://redis.io/commands/lcs
     |
     |  lmove(self, first_list: 'str', second_list: 'str', src: 'str' = 'LEFT', dest: 'str' = 'RIGHT') -> 'bytes | str | None | Awaitable[bytes | str | None]'
     |      Atomically returns and removes the first/last element of a list,
     |      pushing it as the first/last element on the destination list.
     |      Returns the element being popped and pushed.
     |
     |      For more information, see https://redis.io/commands/lmove
     |
     |  lmovem(self, first_list: 'str', second_list: 'str', src: 'str' = 'LEFT', dest: 'str' = 'RIGHT', count: 'int | None' = None, mode: "Literal['COUNT', 'EXACTLY'] | None" = None, ordering: "Literal['OBO', 'BULK'] | None" = None) -> 'list[bytes | str] | None | Awaitable[list[bytes | str] | None]'
     |      Atomically moves multiple elements from one end of the ``first_list``
     |      to one end of the ``second_list``, returning the moved elements in
     |      destination order.
     |
     |      ``src`` and ``dest`` are the ends to pop from / push to, either
     |      ``LEFT`` (head) or ``RIGHT`` (tail).
     |
     |      When ``count`` is given, ``mode`` selects how many elements to move:
     |      ``COUNT`` (the default) moves up to ``count`` elements, while
     |      ``EXACTLY`` moves exactly ``count`` elements or nothing at all. When
     |      ``count`` is not given a single element is moved.
     |
     |      ``ordering`` controls the order at the destination: ``OBO`` pushes each
     |      element as it is popped (reversing block order, stack semantics) while
     |      ``BULK`` preserves the original relative order (queue semantics). It is
     |      required whenever ``count`` is given.
     |
     |      Returns the array of moved elements, or ``None`` if nothing was moved.
     |
     |      For more information, see https://redis.io/commands/lmovem
     |
     |  mget(self, keys: 'KeysT', *args: 'EncodableT') -> 'list[bytes | str | None] | Awaitable[list[bytes | str | None]]'
     |      Returns a list of values ordered identically to ``keys``
     |
     |      ** Important ** When this method is used with Cluster clients, all keys
     |              must be in the same hash slot, otherwise a RedisClusterException
     |              will be raised.
     |
     |      For more information, see https://redis.io/commands/mget
     |
     |  move(self, name: 'KeyT', db: 'int') -> 'bool | Awaitable[bool]'
     |      Moves the key ``name`` to a different Redis database ``db``
     |
     |      For more information, see https://redis.io/commands/move
     |
     |  mset(self, mapping: 'Mapping[AnyKeyT, EncodableT]') -> 'bool | Awaitable[bool]'
     |      Sets key/values based on a mapping. Mapping is a dictionary of
     |      key/value pairs. Both keys and values should be strings or types that
     |      can be cast to a string via str().
     |
     |      ** Important ** When this method is used with Cluster clients, all keys
     |              must be in the same hash slot, otherwise a RedisClusterException
     |              will be raised.
     |
     |      For more information, see https://redis.io/commands/mset
     |
     |  msetex(self, mapping: 'Mapping[AnyKeyT, EncodableT]', data_persist_option: 'DataPersistOptions | None' = None, ex: 'ExpiryT | None' = None, px: 'ExpiryT | None' = None, exat: 'AbsExpiryT | None' = None, pxat: 'AbsExpiryT | None' = None, keepttl: 'bool' = False) -> 'int | Awaitable[int]'
     |      Sets key/values based on the provided ``mapping`` items.
     |
     |      ** Important ** When this method is used with Cluster clients, all keys
     |                      must be in the same hash slot, otherwise a RedisClusterException
     |                      will be raised.
     |
     |      ``mapping`` accepts a dict of key/value pairs that will be added to the database.
     |
     |      ``data_persist_option`` can be set to ``NX`` or ``XX`` to control the
     |          behavior of the command.
     |          ``NX`` will set the value for each provided key to each
     |              provided value only if all do not already exist.
     |          ``XX`` will set the value for each provided key to each
     |              provided value only if all already exist.
     |
     |      ``ex`` sets an expire flag on the keys in ``mapping`` for ``ex`` seconds.
     |
     |      ``px`` sets an expire flag on the keys in ``mapping`` for ``px`` milliseconds.
     |
     |      ``exat`` sets an expire flag on the keys in ``mapping`` for ``exat`` seconds,
     |          specified in unix time.
     |
     |      ``pxat`` sets an expire flag on the keys in ``mapping`` for ``pxat`` milliseconds,
     |          specified in unix time.
     |
     |      ``keepttl`` if True, retain the time to live associated with the keys.
     |
     |      Returns the number of fields that were added.
     |
     |      Available since Redis 8.4
     |      For more information, see https://redis.io/commands/msetex
     |
     |  msetnx(self, mapping: 'Mapping[AnyKeyT, EncodableT]') -> 'bool | Awaitable[bool]'
     |      Sets key/values based on a mapping if none of the keys are already set.
     |      Mapping is a dictionary of key/value pairs. Both keys and values
     |      should be strings or types that can be cast to a string via str().
     |      Returns a boolean indicating if the operation was successful.
     |
     |      ** Important ** When this method is used with Cluster clients, all keys
     |                      must be in the same hash slot, otherwise a RedisClusterException
     |                      will be raised.
     |
     |      For more information, see https://redis.io/commands/msetnx
     |
     |  persist(self, name: 'KeyT') -> 'bool | Awaitable[bool]'
     |      Removes an expiration on ``name``
     |
     |      For more information, see https://redis.io/commands/persist
     |
     |  pexpire(self, name: 'KeyT', time: 'ExpiryT', nx: 'bool' = False, xx: 'bool' = False, gt: 'bool' = False, lt: 'bool' = False) -> 'bool | Awaitable[bool]'
     |      Set an expire flag on key ``name`` for ``time`` milliseconds
     |      with given ``option``. ``time`` can be represented by an
     |      integer or a Python timedelta object.
     |
     |      Valid options are:
     |          NX -> Set expiry only when the key has no expiry
     |          XX -> Set expiry only when the key has an existing expiry
     |          GT -> Set expiry only when the new expiry is greater than current one
     |          LT -> Set expiry only when the new expiry is less than current one
     |
     |      For more information, see https://redis.io/commands/pexpire
     |
     |  pexpireat(self, name: 'KeyT', when: 'AbsExpiryT', nx: 'bool' = False, xx: 'bool' = False, gt: 'bool' = False, lt: 'bool' = False) -> 'bool | Awaitable[bool]'
     |      Set an expire flag on key ``name`` with given ``option``. ``when``
     |      can be represented as an integer representing unix time in
     |      milliseconds (unix time * 1000) or a Python datetime object.
     |
     |      Valid options are:
     |          NX -> Set expiry only when the key has no expiry
     |          XX -> Set expiry only when the key has an existing expiry
     |          GT -> Set expiry only when the new expiry is greater than current one
     |          LT -> Set expiry only when the new expiry is less than current one
     |
     |      For more information, see https://redis.io/commands/pexpireat
     |
     |  pexpiretime(self, key: 'str') -> 'int | Awaitable[int]'
     |      Returns the absolute Unix timestamp (since January 1, 1970) in milliseconds
     |      at which the given key will expire.
     |
     |      For more information, see https://redis.io/commands/pexpiretime
     |
     |  psetex(self, name: 'KeyT', time_ms: 'ExpiryT', value: 'EncodableT') -> 'bool | Awaitable[bool]'
     |      Set the value of key ``name`` to ``value`` that expires in ``time_ms``
     |      milliseconds. ``time_ms`` can be represented by an integer or a Python
     |      timedelta object
     |
     |      For more information, see https://redis.io/commands/psetex
     |
     |  pttl(self, name: 'KeyT') -> 'int | Awaitable[int]'
     |      Returns the number of milliseconds until the key ``name`` will expire
     |
     |      For more information, see https://redis.io/commands/pttl
     |
     |  randomkey(self, **kwargs) -> 'bytes | str | None | Awaitable[bytes | str | None]'
     |      Returns the name of a random key
     |
     |      For more information, see https://redis.io/commands/randomkey
     |
     |  rename(self, src: 'KeyT', dst: 'KeyT') -> 'bool | Awaitable[bool]'
     |      Rename key ``src`` to ``dst``
     |
     |      For more information, see https://redis.io/commands/rename
     |
     |  renamenx(self, src: 'KeyT', dst: 'KeyT') -> 'bool | Awaitable[bool]'
     |      Rename key ``src`` to ``dst`` if ``dst`` doesn't already exist
     |
     |      For more information, see https://redis.io/commands/renamenx
     |
     |  restore(self, name: 'KeyT', ttl: 'float', value: 'EncodableT', replace: 'bool' = False, absttl: 'bool' = False, idletime: 'int | None' = None, frequency: 'int | None' = None) -> 'bytes | str | Awaitable[bytes | str]'
     |      Create a key using the provided serialized value, previously obtained
     |      using DUMP.
     |
     |      ``replace`` allows an existing key on ``name`` to be overridden. If
     |      it's not specified an error is raised on collision.
     |
     |      ``absttl`` if True, specified ``ttl`` should represent an absolute Unix
     |      timestamp in milliseconds in which the key will expire. (Redis 5.0 or
     |      greater).
     |
     |      ``idletime`` Used for eviction, this is the number of seconds the
     |      key must be idle, prior to execution.
     |
     |      ``frequency`` Used for eviction, this is the frequency counter of
     |      the object stored at the key, prior to execution.
     |
     |      For more information, see https://redis.io/commands/restore
     |
     |  set(self, name: 'KeyT', value: 'EncodableT', ex: 'ExpiryT | None' = None, px: 'ExpiryT | None' = None, nx: 'bool' = False, xx: 'bool' = False, keepttl: 'bool' = False, get: 'bool' = False, exat: 'AbsExpiryT | None' = None, pxat: 'AbsExpiryT | None' = None, ifeq: 'bytes | str | None' = None, ifne: 'bytes | str | None' = None, ifdeq: 'str | None' = None, ifdne: 'str | None' = None) -> 'bool | str | bytes | None | Awaitable[bool | str | bytes | None]'
     |      Set the value at key ``name`` to ``value``
     |
     |      Warning:
     |      **Experimental** since 7.1.
     |      The usage of the arguments ``ifeq``, ``ifne``, ``ifdeq``, and ``ifdne``
     |      is experimental. The API or returned results when those parameters are used
     |      may change based on feedback.
     |
     |      ``ex`` sets an expire flag on key ``name`` for ``ex`` seconds.
     |
     |      ``px`` sets an expire flag on key ``name`` for ``px`` milliseconds.
     |
     |      ``nx`` if set to True, set the value at key ``name`` to ``value`` only
     |          if it does not exist.
     |
     |      ``xx`` if set to True, set the value at key ``name`` to ``value`` only
     |          if it already exists.
     |
     |      ``keepttl`` if True, retain the time to live associated with the key.
     |          (Available since Redis 6.0)
     |
     |      ``get`` if True, set the value at key ``name`` to ``value`` and return
     |          the old value stored at key, or None if the key did not exist.
     |          (Available since Redis 6.2)
     |
     |      ``exat`` sets an expire flag on key ``name`` for ``ex`` seconds,
     |          specified in unix time.
     |
     |      ``pxat`` sets an expire flag on key ``name`` for ``ex`` milliseconds,
     |          specified in unix time.
     |
     |      ``ifeq`` set the value at key ``name`` to ``value`` only if the current
     |          value exactly matches the argument.
     |          If key doesn’t exist - it won’t be created.
     |          (Requires Redis 8.4 or greater)
     |
     |      ``ifne`` set the value at key ``name`` to ``value`` only if the current
     |          value does not exactly match the argument.
     |          If key doesn’t exist - it will be created.
     |          (Requires Redis 8.4 or greater)
     |
     |      ``ifdeq`` set the value at key ``name`` to ``value`` only if the current
     |          value XXH3 hex digest exactly matches the argument.
     |          If key doesn’t exist - it won’t be created.
     |          (Requires Redis 8.4 or greater)
     |
     |      ``ifdne`` set the value at key ``name`` to ``value`` only if the current
     |          value XXH3 hex digest does not exactly match the argument.
     |          If key doesn’t exist - it will be created.
     |          (Requires Redis 8.4 or greater)
     |
     |      For more information, see https://redis.io/commands/set
     |
     |  setbit(self, name: 'KeyT', offset: 'int', value: 'int') -> 'int | Awaitable[int]'
     |      Flag the ``offset`` in ``name`` as ``value``. Returns an integer
     |      indicating the previous value of ``offset``.
     |
     |      For more information, see https://redis.io/commands/setbit
     |
     |  setex(self, name: 'KeyT', time: 'ExpiryT', value: 'EncodableT') -> 'bool | Awaitable[bool]'
     |      Set the value of key ``name`` to ``value`` that expires in ``time``
     |      seconds. ``time`` can be represented by an integer or a Python
     |      timedelta object.
     |
     |      As per Redis 2.6.12, SETEX is considered deprecated.
     |      Please use SET with EX parameter in new code.
     |
     |      For more information, see https://redis.io/commands/setex
     |
     |  setnx(self, name: 'KeyT', value: 'EncodableT') -> 'bool | Awaitable[bool]'
     |      Set the value of key ``name`` to ``value`` if key doesn't exist
     |
     |      For more information, see https://redis.io/commands/setnx
     |
     |  setrange(self, name: 'KeyT', offset: 'int', value: 'EncodableT') -> 'int | Awaitable[int]'
     |      Overwrite bytes in the value of ``name`` starting at ``offset`` with
     |      ``value``. If ``offset`` plus the length of ``value`` exceeds the
     |      length of the original value, the new value will be larger than before.
     |      If ``offset`` exceeds the length of the original value, null bytes
     |      will be used to pad between the end of the previous value and the start
     |      of what's being injected.
     |
     |      Returns the length of the new string.
     |
     |      For more information, see https://redis.io/commands/setrange
     |
     |  stralgo(self, algo: "Literal['LCS']", value1: 'KeyT', value2: 'KeyT', specific_argument: "Literal['strings'] | Literal['keys']" = 'strings', len: 'bool' = False, idx: 'bool' = False, minmatchlen: 'int | None' = None, withmatchlen: 'bool' = False, **kwargs) -> 'StralgoResponse | Awaitable[StralgoResponse]'
     |      Implements complex algorithms that operate on strings.
     |      Right now the only algorithm implemented is the LCS algorithm
     |      (longest common substring). However new algorithms could be
     |      implemented in the future.
     |
     |      ``algo`` Right now must be LCS
     |      ``value1`` and ``value2`` Can be two strings or two keys
     |      ``specific_argument`` Specifying if the arguments to the algorithm
     |      will be keys or strings. strings is the default.
     |      ``len`` Returns just the len of the match.
     |      ``idx`` Returns the match positions in each string.
     |      ``minmatchlen`` Restrict the list of matches to the ones of a given
     |      minimal length. Can be provided only when ``idx`` set to True.
     |      ``withmatchlen`` Returns the matches with the len of the match.
     |      Can be provided only when ``idx`` set to True.
     |
     |      For more information, see https://redis.io/commands/stralgo
     |
     |  strlen(self, name: 'KeyT') -> 'int | Awaitable[int]'
     |      Return the number of bytes stored in the value of ``name``
     |
     |      For more information, see https://redis.io/commands/strlen
     |
     |  substr(self, name: 'KeyT', start: 'int', end: 'int' = -1) -> 'bytes | str | Awaitable[bytes | str]'
     |      Return a substring of the string at key ``name``. ``start`` and ``end``
     |      are 0-based integers specifying the portion of the string to return.
     |
     |  touch(self, *args: 'KeyT') -> 'int | Awaitable[int]'
     |      Alters the last access time of a key(s) ``*args``. A key is ignored
     |      if it does not exist.
     |
     |      For more information, see https://redis.io/commands/touch
     |
     |  ttl(self, name: 'KeyT') -> 'int | Awaitable[int]'
     |      Returns the number of seconds until the key ``name`` will expire
     |
     |      For more information, see https://redis.io/commands/ttl
     |
     |  type(self, name: 'KeyT') -> 'bytes | str | Awaitable[bytes | str]'
     |      Returns the type of key ``name``
     |
     |      For more information, see https://redis.io/commands/type
     |
     |  unlink(self, *names: 'KeyT') -> 'int | Awaitable[int]'
     |      Unlink one or more keys specified by ``names``
     |
     |      For more information, see https://redis.io/commands/unlink
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from redis.commands.core.HyperlogCommands:
     |
     |  pfadd(self, name: 'KeyT', *values: 'FieldT') -> 'int | Awaitable[int]'
     |      Adds the specified elements to the specified HyperLogLog.
     |
     |      For more information, see https://redis.io/commands/pfadd
     |
     |  pfcount(self, *sources: 'KeyT') -> 'int | Awaitable[int]'
     |      Return the approximated cardinality of
     |      the set observed by the HyperLogLog at key(s).
     |
     |      For more information, see https://redis.io/commands/pfcount
     |
     |  pfmerge(self, dest: 'KeyT', *sources: 'KeyT') -> 'bool | Awaitable[bool]'
     |      Merge N different HyperLogLogs into a single one.
     |
     |      For more information, see https://redis.io/commands/pfmerge
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from redis.commands.core.HashCommands:
     |
     |  hdel(self, name: 'KeyT', *keys: 'FieldT') -> 'int | Awaitable[int]'
     |      Delete ``keys`` from hash ``name``
     |
     |      For more information, see https://redis.io/commands/hdel
     |
     |  hexists(self, name: 'KeyT', key: 'FieldT') -> 'bool | Awaitable[bool]'
     |      Returns a boolean indicating if ``key`` exists within hash ``name``
     |
     |      For more information, see https://redis.io/commands/hexists
     |
     |  hexpire(self, name: 'KeyT', seconds: 'ExpiryT', *fields: 'FieldT', nx: 'bool' = False, xx: 'bool' = False, gt: 'bool' = False, lt: 'bool' = False) -> 'list[int] | Awaitable[list[int]]'
     |      Sets or updates the expiration time for fields within a hash key, using relative
     |      time in seconds.
     |
     |      If a field already has an expiration time, the behavior of the update can be
     |      controlled using the `nx`, `xx`, `gt`, and `lt` parameters.
     |
     |      The return value provides detailed information about the outcome for each field.
     |
     |      For more information, see https://redis.io/commands/hexpire
     |
     |      Args:
     |          name: The name of the hash key.
     |          seconds: Expiration time in seconds, relative. Can be an integer, or a
     |                   Python `timedelta` object.
     |          fields: List of fields within the hash to apply the expiration time to.
     |          nx: Set expiry only when the field has no expiry.
     |          xx: Set expiry only when the field has an existing expiry.
     |          gt: Set expiry only when the new expiry is greater than the current one.
     |          lt: Set expiry only when the new expiry is less than the current one.
     |
     |      Returns:
     |          Returns a list which contains for each field in the request:
     |              - `-2` if the field does not exist, or if the key does not exist.
     |              - `0` if the specified NX | XX | GT | LT condition was not met.
     |              - `1` if the expiration time was set or updated.
     |              - `2` if the field was deleted because the specified expiration time is
     |                in the past.
     |
     |  hexpireat(self, name: 'KeyT', unix_time_seconds: 'AbsExpiryT', *fields: 'FieldT', nx: 'bool' = False, xx: 'bool' = False, gt: 'bool' = False, lt: 'bool' = False) -> 'list[int] | Awaitable[list[int]]'
     |      Sets or updates the expiration time for fields within a hash key, using an
     |      absolute Unix timestamp in seconds.
     |
     |      If a field already has an expiration time, the behavior of the update can be
     |      controlled using the `nx`, `xx`, `gt`, and `lt` parameters.
     |
     |      The return value provides detailed information about the outcome for each field.
     |
     |      For more information, see https://redis.io/commands/hexpireat
     |
     |      Args:
     |          name: The name of the hash key.
     |          unix_time_seconds: Expiration time as Unix timestamp in seconds. Can be an
     |                             integer or a Python `datetime` object.
     |          fields: List of fields within the hash to apply the expiration time to.
     |          nx: Set expiry only when the field has no expiry.
     |          xx: Set expiry only when the field has an existing expiration time.
     |          gt: Set expiry only when the new expiry is greater than the current one.
     |          lt: Set expiry only when the new expiry is less than the current one.
     |
     |      Returns:
     |          Returns a list which contains for each field in the request:
     |              - `-2` if the field does not exist, or if the key does not exist.
     |              - `0` if the specified NX | XX | GT | LT condition was not met.
     |              - `1` if the expiration time was set or updated.
     |              - `2` if the field was deleted because the specified expiration time is
     |                in the past.
     |
     |  hexpiretime(self, key: 'KeyT', *fields: 'FieldT') -> 'list[int] | Awaitable[list[int]]'
     |      Returns the expiration times of hash fields as Unix timestamps in seconds.
     |
     |      For more information, see https://redis.io/commands/hexpiretime
     |
     |      Args:
     |          key: The hash key.
     |          fields: A list of fields within the hash for which to get the expiration
     |                  time.
     |
     |      Returns:
     |          Returns a list which contains for each field in the request:
     |              - `-2` if the field does not exist, or if the key does not exist.
     |              - `-1` if the field exists but has no associated expire time.
     |              - A positive integer representing the expiration Unix timestamp in
     |                seconds, if the field has an associated expiration time.
     |
     |  hget(self, name: 'KeyT', key: 'FieldT') -> 'bytes | str | None | Awaitable[bytes | str | None]'
     |      Return the value of ``key`` within the hash ``name``
     |
     |      For more information, see https://redis.io/commands/hget
     |
     |  hgetall(self, name: 'KeyT') -> 'dict[bytes | str, bytes | str] | Awaitable[dict[bytes | str, bytes | str]]'
     |      Return a Python dict of the hash's name/value pairs
     |
     |      For more information, see https://redis.io/commands/hgetall
     |
     |  hgetdel(self, name: 'KeyT', *keys: 'FieldT') -> 'list[bytes | str | None] | Awaitable[list[bytes | str | None]]'
     |      Return the value of ``key`` within the hash ``name`` and
     |      delete the field in the hash.
     |      This command is similar to HGET, except for the fact that it also deletes
     |      the key on success from the hash with the provided ```name```.
     |
     |      Available since Redis 8.0
     |      For more information, see https://redis.io/commands/hgetdel
     |
     |  hgetex(self, name: 'KeyT', *keys: 'FieldT', ex: 'ExpiryT | None' = None, px: 'ExpiryT | None' = None, exat: 'AbsExpiryT | None' = None, pxat: 'AbsExpiryT | None' = None, persist: 'bool' = False) -> 'list[bytes | str | None] | Awaitable[list[bytes | str | None]]'
     |      Return the values of ``key`` and ``keys`` within the hash ``name``
     |      and optionally set their expiration.
     |
     |      ``ex`` sets an expire flag on ``kyes`` for ``ex`` seconds.
     |
     |      ``px`` sets an expire flag on ``keys`` for ``px`` milliseconds.
     |
     |      ``exat`` sets an expire flag on ``keys`` for ``ex`` seconds,
     |      specified in unix time.
     |
     |      ``pxat`` sets an expire flag on ``keys`` for ``ex`` milliseconds,
     |      specified in unix time.
     |
     |      ``persist`` remove the time to live associated with the ``keys``.
     |
     |      Available since Redis 8.0
     |      For more information, see https://redis.io/commands/hgetex
     |
     |  himport_discard_all_internal(self) -> 'int | Awaitable[int]'
     |      Send ``HIMPORT DISCARDALL`` (returns the number of fieldsets removed).
     |
     |      .. warning::
     |          Internal wire mapping — not for direct use on a pooled client. It
     |          DISCARDs on a single arbitrary borrowed connection and bypasses the
     |          client's shared fieldset registry, leaving other connections and the
     |          registry out of sync. Use the client's ``himport_discard_all`` instead;
     |          call this only on a pinned single-connection client where you manage
     |          session state yourself.
     |
     |  himport_discard_internal(self, fieldset_name: 'str') -> 'int | Awaitable[int]'
     |      Send ``HIMPORT DISCARD fieldset_name`` (``1`` removed, ``0`` not found).
     |
     |      .. warning::
     |          Internal wire mapping — not for direct use on a pooled client. It
     |          DISCARDs on a single arbitrary borrowed connection and bypasses the
     |          client's shared fieldset registry, leaving other connections and the
     |          registry out of sync. Use the client's ``himport_discard`` instead; call
     |          this only on a pinned single-connection client where you manage session
     |          state yourself.
     |
     |  himport_prepare_internal(self, fieldset_name: 'str', fields: 'Iterable[FieldT]') -> 'bool | Awaitable[bool]'
     |      Send ``HIMPORT PREPARE fieldset_name field [field ...]``.
     |
     |      Registers the ordered field list under ``fieldset_name`` in the executing
     |      connection's session. Fields are sent in the caller's order, unmodified.
     |
     |      .. warning::
     |          Internal wire mapping — not for direct use on a pooled client. It
     |          PREPAREs on a single arbitrary borrowed connection and bypasses the
     |          client's shared fieldset registry, so other connections stay unaware and
     |          reintroduce the nondeterministic "no such fieldset" the HIMPORT design
     |          prevents. Use the client's ``himport_prepare`` instead; call this only
     |          on a pinned single-connection client where you manage session state
     |          yourself.
     |
     |  himport_set(self, key: 'KeyT', fieldset_name: 'str', values: 'Iterable[EncodableT]') -> 'bool | Awaitable[bool]'
     |      Create/replace ``key`` as a hash using ``fieldset_name``'s field list.
     |
     |      Values are sent in the caller's order and map positionally to the prepared
     |      fields. The fieldset is prepared on the serving connection on first use
     |      (PREPARE bundled with SET in one write) and reused on subsequent calls;
     |      runtime discards are reconciled on the next use of the connection. All of
     |      this happens inside the normal command path, so retry, disconnect-on-error
     |      and (for the cluster) routing / MOVED-ASK apply exactly as for any command.
     |
     |      .. note::
     |          Recovery from a mid-connection fieldset loss (the server dropping the
     |          prepared fieldset without dropping the socket, e.g. ``RESET`` or
     |          ``maxmemory-clients`` eviction) applies only to a standalone
     |          ``himport_set`` call: it catches the resulting ``no such fieldset`` and
     |          re-prepares on the same socket, retrying the SET once. A ``himport_set``
     |          buffered in a **pipeline or transaction** has no such per-command
     |          recovery — its fieldset is PREPAREd once as a pre-flight before the
     |          batch, and if the server loses it between that pre-flight and the batch
     |          the SET fails and surfaces as an error in the batch results. Callers who
     |          need the automatic recovery should issue those sets outside a pipeline.
     |
     |  hincrby(self, name: 'KeyT', key: 'FieldT', amount: 'int' = 1) -> 'int | Awaitable[int]'
     |      Increment the value of ``key`` in hash ``name`` by ``amount``
     |
     |      For more information, see https://redis.io/commands/hincrby
     |
     |  hincrbyfloat(self, name: 'KeyT', key: 'FieldT', amount: 'float' = 1.0) -> 'float | Awaitable[float]'
     |      Increment the value of ``key`` in hash ``name`` by floating ``amount``
     |
     |      For more information, see https://redis.io/commands/hincrbyfloat
     |
     |  hkeys(self, name: 'KeyT') -> 'list[bytes | str] | Awaitable[list[bytes | str]]'
     |      Return the list of keys within hash ``name``
     |
     |      For more information, see https://redis.io/commands/hkeys
     |
     |  hlen(self, name: 'KeyT') -> 'int | Awaitable[int]'
     |      Return the number of elements in hash ``name``
     |
     |      For more information, see https://redis.io/commands/hlen
     |
     |  hmget(self, name: 'KeyT', keys: 'FieldT | Iterable[FieldT]', *args: 'FieldT') -> 'list[bytes | str | None] | Awaitable[list[bytes | str | None]]'
     |      Returns a list of values ordered identically to ``keys``
     |
     |      For more information, see https://redis.io/commands/hmget
     |
     |  hmset(self, name: 'KeyT', mapping: 'Mapping[FieldT, EncodableT]') -> 'bool | Awaitable[bool]'
     |      Set key to value within hash ``name`` for each corresponding
     |      key and value from the ``mapping`` dict.
     |
     |      For more information, see https://redis.io/commands/hmset
     |
     |  hpersist(self, name: 'KeyT', *fields: 'FieldT') -> 'list[int] | Awaitable[list[int]]'
     |      Removes the expiration time for each specified field in a hash.
     |
     |      For more information, see https://redis.io/commands/hpersist
     |
     |      Args:
     |          name: The name of the hash key.
     |          fields: A list of fields within the hash from which to remove the
     |                  expiration time.
     |
     |      Returns:
     |          Returns a list which contains for each field in the request:
     |              - `-2` if the field does not exist, or if the key does not exist.
     |              - `-1` if the field exists but has no associated expiration time.
     |              - `1` if the expiration time was successfully removed from the field.
     |
     |  hpexpire(self, name: 'KeyT', milliseconds: 'ExpiryT', *fields: 'FieldT', nx: 'bool' = False, xx: 'bool' = False, gt: 'bool' = False, lt: 'bool' = False) -> 'list[int] | Awaitable[list[int]]'
     |      Sets or updates the expiration time for fields within a hash key, using relative
     |      time in milliseconds.
     |
     |      If a field already has an expiration time, the behavior of the update can be
     |      controlled using the `nx`, `xx`, `gt`, and `lt` parameters.
     |
     |      The return value provides detailed information about the outcome for each field.
     |
     |      For more information, see https://redis.io/commands/hpexpire
     |
     |      Args:
     |          name: The name of the hash key.
     |          milliseconds: Expiration time in milliseconds, relative. Can be an integer,
     |                        or a Python `timedelta` object.
     |          fields: List of fields within the hash to apply the expiration time to.
     |          nx: Set expiry only when the field has no expiry.
     |          xx: Set expiry only when the field has an existing expiry.
     |          gt: Set expiry only when the new expiry is greater than the current one.
     |          lt: Set expiry only when the new expiry is less than the current one.
     |
     |      Returns:
     |          Returns a list which contains for each field in the request:
     |              - `-2` if the field does not exist, or if the key does not exist.
     |              - `0` if the specified NX | XX | GT | LT condition was not met.
     |              - `1` if the expiration time was set or updated.
     |              - `2` if the field was deleted because the specified expiration time is
     |                in the past.
     |
     |  hpexpireat(self, name: 'KeyT', unix_time_milliseconds: 'AbsExpiryT', *fields: 'FieldT', nx: 'bool' = False, xx: 'bool' = False, gt: 'bool' = False, lt: 'bool' = False) -> 'list[int] | Awaitable[list[int]]'
     |      Sets or updates the expiration time for fields within a hash key, using an
     |      absolute Unix timestamp in milliseconds.
     |
     |      If a field already has an expiration time, the behavior of the update can be
     |      controlled using the `nx`, `xx`, `gt`, and `lt` parameters.
     |
     |      The return value provides detailed information about the outcome for each field.
     |
     |      For more information, see https://redis.io/commands/hpexpireat
     |
     |      Args:
     |          name: The name of the hash key.
     |          unix_time_milliseconds: Expiration time as Unix timestamp in milliseconds.
     |                                  Can be an integer or a Python `datetime` object.
     |          fields: List of fields within the hash to apply the expiry.
     |          nx: Set expiry only when the field has no expiry.
     |          xx: Set expiry only when the field has an existing expiry.
     |          gt: Set expiry only when the new expiry is greater than the current one.
     |          lt: Set expiry only when the new expiry is less than the current one.
     |
     |      Returns:
     |          Returns a list which contains for each field in the request:
     |              - `-2` if the field does not exist, or if the key does not exist.
     |              - `0` if the specified NX | XX | GT | LT condition was not met.
     |              - `1` if the expiration time was set or updated.
     |              - `2` if the field was deleted because the specified expiration time is
     |                in the past.
     |
     |  hpexpiretime(self, key: 'KeyT', *fields: 'FieldT') -> 'list[int] | Awaitable[list[int]]'
     |      Returns the expiration times of hash fields as Unix timestamps in milliseconds.
     |
     |      For more information, see https://redis.io/commands/hpexpiretime
     |
     |      Args:
     |          key: The hash key.
     |          fields: A list of fields within the hash for which to get the expiration
     |                  time.
     |
     |      Returns:
     |          Returns a list which contains for each field in the request:
     |              - `-2` if the field does not exist, or if the key does not exist.
     |              - `-1` if the field exists but has no associated expire time.
     |              - A positive integer representing the expiration Unix timestamp in
     |                milliseconds, if the field has an associated expiration time.
     |
     |  hpttl(self, key: 'KeyT', *fields: 'FieldT') -> 'list[int] | Awaitable[list[int]]'
     |      Returns the TTL (Time To Live) in milliseconds for each specified field within a
     |      hash key.
     |
     |      For more information, see https://redis.io/commands/hpttl
     |
     |      Args:
     |          key: The hash key.
     |          fields: A list of fields within the hash for which to get the TTL.
     |
     |      Returns:
     |          Returns a list which contains for each field in the request:
     |              - `-2` if the field does not exist, or if the key does not exist.
     |              - `-1` if the field exists but has no associated expire time.
     |              - A positive integer representing the TTL in milliseconds if the field
     |                has an associated expiration time.
     |
     |  hset(self, name: 'KeyT', key: 'FieldT | None' = None, value: 'EncodableT | None' = None, mapping: 'Mapping[FieldT, EncodableT] | None' = None, items: 'Sequence[EncodableT] | None' = None) -> 'int | Awaitable[int]'
     |      Set ``key`` to ``value`` within hash ``name``,
     |      ``mapping`` accepts a dict of key/value pairs that will be
     |      added to hash ``name``.
     |      ``items`` accepts a list of key/value pairs that will be
     |      added to hash ``name``.
     |      Returns the number of fields that were added.
     |
     |      For more information, see https://redis.io/commands/hset
     |
     |  hsetex(self, name: 'KeyT', key: 'FieldT | None' = None, value: 'EncodableT | None' = None, mapping: 'Mapping[FieldT, EncodableT] | None' = None, items: 'Sequence[EncodableT] | None' = None, ex: 'ExpiryT | None' = None, px: 'ExpiryT | None' = None, exat: 'AbsExpiryT | None' = None, pxat: 'AbsExpiryT | None' = None, data_persist_option: 'HashDataPersistOptions | None' = None, keepttl: 'bool' = False) -> 'int | Awaitable[int]'
     |      Set ``key`` to ``value`` within hash ``name``
     |
     |      ``mapping`` accepts a dict of key/value pairs that will be
     |      added to hash ``name``.
     |
     |      ``items`` accepts a list of key/value pairs that will be
     |      added to hash ``name``.
     |
     |      ``ex`` sets an expire flag on ``keys`` for ``ex`` seconds.
     |
     |      ``px`` sets an expire flag on ``keys`` for ``px`` milliseconds.
     |
     |      ``exat`` sets an expire flag on ``keys`` for ``ex`` seconds,
     |          specified in unix time.
     |
     |      ``pxat`` sets an expire flag on ``keys`` for ``ex`` milliseconds,
     |          specified in unix time.
     |
     |      ``data_persist_option`` can be set to ``FNX`` or ``FXX`` to control the
     |          behavior of the command.
     |          ``FNX`` will set the value for each provided key to each
     |              provided value only if all do not already exist.
     |          ``FXX`` will set the value for each provided key to each
     |              provided value only if all already exist.
     |
     |      ``keepttl`` if True, retain the time to live associated with the keys.
     |
     |      Returns the number of fields that were added.
     |
     |      Available since Redis 8.0
     |      For more information, see https://redis.io/commands/hsetex
     |
     |  hsetnx(self, name: 'KeyT', key: 'FieldT', value: 'EncodableT') -> 'int | Awaitable[int]'
     |      Set ``key`` to ``value`` within hash ``name`` if ``key`` does not
     |      exist.  Returns 1 if HSETNX created a field, otherwise 0.
     |
     |      For more information, see https://redis.io/commands/hsetnx
     |
     |  hstrlen(self, name: 'KeyT', key: 'FieldT') -> 'int | Awaitable[int]'
     |      Return the number of bytes stored in the value of ``key``
     |      within hash ``name``
     |
     |      For more information, see https://redis.io/commands/hstrlen
     |
     |  httl(self, key: 'KeyT', *fields: 'FieldT') -> 'list[int] | Awaitable[list[int]]'
     |      Returns the TTL (Time To Live) in seconds for each specified field within a hash
     |      key.
     |
     |      For more information, see https://redis.io/commands/httl
     |
     |      Args:
     |          key: The hash key.
     |          fields: A list of fields within the hash for which to get the TTL.
     |
     |      Returns:
     |          Returns a list which contains for each field in the request:
     |              - `-2` if the field does not exist, or if the key does not exist.
     |              - `-1` if the field exists but has no associated expire time.
     |              - A positive integer representing the TTL in seconds if the field has
     |                an associated expiration time.
     |
     |  hvals(self, name: 'KeyT') -> 'list[bytes | str] | Awaitable[list[bytes | str]]'
     |      Return the list of values within hash ``name``
     |
     |      For more information, see https://redis.io/commands/hvals
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from redis.commands.core.GeoCommands:
     |
     |  geoadd(self, name: 'KeyT', values: 'Sequence[EncodableT]', nx: 'bool' = False, xx: 'bool' = False, ch: 'bool' = False) -> 'int | Awaitable[int]'
     |      Add the specified geospatial items to the specified key identified
     |      by the ``name`` argument. The Geospatial items are given as ordered
     |      members of the ``values`` argument, each item or place is formed by
     |      the triad longitude, latitude and name.
     |
     |      Note: You can use ZREM to remove elements.
     |
     |      ``nx`` forces ZADD to only create new elements and not to update
     |      scores for elements that already exist.
     |
     |      ``xx`` forces ZADD to only update scores of elements that already
     |      exist. New elements will not be added.
     |
     |      ``ch`` modifies the return value to be the numbers of elements changed.
     |      Changed elements include new elements that were added and elements
     |      whose scores changed.
     |
     |      For more information, see https://redis.io/commands/geoadd
     |
     |  geodist(self, name: 'KeyT', place1: 'FieldT', place2: 'FieldT', unit: 'str | None' = None) -> 'float | None | Awaitable[float | None]'
     |      Return the distance between ``place1`` and ``place2`` members of the
     |      ``name`` key.
     |      The units must be one of the following : m, km mi, ft. By default
     |      meters are used.
     |
     |      For more information, see https://redis.io/commands/geodist
     |
     |  geohash(self, name: 'KeyT', *values: 'FieldT') -> 'list[bytes | str | None] | Awaitable[list[bytes | str | None]]'
     |      Return the geo hash string for each item of ``values`` members of
     |      the specified key identified by the ``name`` argument.
     |
     |      For more information, see https://redis.io/commands/geohash
     |
     |  geopos(self, name: 'KeyT', *values: 'FieldT') -> 'list[GeoCoordinate | None] | Awaitable[list[GeoCoordinate | None]]'
     |      Return the positions of each item of ``values`` as members of
     |      the specified key identified by the ``name`` argument. Each position
     |      is represented by the pairs lon and lat.
     |
     |      For more information, see https://redis.io/commands/geopos
     |
     |  georadius(self, name: 'KeyT', longitude: 'float', latitude: 'float', radius: 'float', unit: 'str | None' = None, withdist: 'bool' = False, withcoord: 'bool' = False, withhash: 'bool' = False, count: 'int | None' = None, sort: 'str | None' = None, store: 'KeyT | None' = None, store_dist: 'KeyT | None' = None, any: 'bool' = False) -> 'GeoRadiusResponse | Awaitable[GeoRadiusResponse]'
     |      Return the members of the specified key identified by the
     |      ``name`` argument which are within the borders of the area specified
     |      with the ``latitude`` and ``longitude`` location and the maximum
     |      distance from the center specified by the ``radius`` value.
     |
     |      The units must be one of the following : m, km mi, ft. By default
     |
     |      ``withdist`` indicates to return the distances of each place.
     |
     |      ``withcoord`` indicates to return the latitude and longitude of
     |      each place.
     |
     |      ``withhash`` indicates to return the geohash string of each place.
     |
     |      ``count`` indicates to return the number of elements up to N.
     |
     |      ``sort`` indicates to return the places in a sorted way, ASC for
     |      nearest to fairest and DESC for fairest to nearest.
     |
     |      ``store`` indicates to save the places names in a sorted set named
     |      with a specific key, each element of the destination sorted set is
     |      populated with the score got from the original geo sorted set.
     |
     |      ``store_dist`` indicates to save the places names in a sorted set
     |      named with a specific key, instead of ``store`` the sorted set
     |      destination score is set with the distance.
     |
     |      For more information, see https://redis.io/commands/georadius
     |
     |  georadiusbymember(self, name: 'KeyT', member: 'FieldT', radius: 'float', unit: 'str | None' = None, withdist: 'bool' = False, withcoord: 'bool' = False, withhash: 'bool' = False, count: 'int | None' = None, sort: 'str | None' = None, store: 'Union[KeyT, None]' = None, store_dist: 'Union[KeyT, None]' = None, any: 'bool' = False) -> 'GeoRadiusResponse | Awaitable[GeoRadiusResponse]'
     |      This command is exactly like ``georadius`` with the sole difference
     |      that instead of taking, as the center of the area to query, a longitude
     |      and latitude value, it takes the name of a member already existing
     |      inside the geospatial index represented by the sorted set.
     |
     |      For more information, see https://redis.io/commands/georadiusbymember
     |
     |  geosearch(self, name: 'KeyT', member: 'FieldT | None' = None, longitude: 'float | None' = None, latitude: 'float | None' = None, unit: 'str' = 'm', radius: 'float | None' = None, width: 'float | None' = None, height: 'float | None' = None, sort: 'str | None' = None, count: 'int | None' = None, any: 'bool' = False, withcoord: 'bool' = False, withdist: 'bool' = False, withhash: 'bool' = False) -> 'GeoSearchResponse | Awaitable[GeoSearchResponse]'
     |      Return the members of specified key identified by the
     |      ``name`` argument, which are within the borders of the
     |      area specified by a given shape. This command extends the
     |      GEORADIUS command, so in addition to searching within circular
     |      areas, it supports searching within rectangular areas.
     |
     |      This command should be used in place of the deprecated
     |      GEORADIUS and GEORADIUSBYMEMBER commands.
     |
     |      ``member`` Use the position of the given existing
     |       member in the sorted set. Can't be given with ``longitude``
     |       and ``latitude``.
     |
     |      ``longitude`` and ``latitude`` Use the position given by
     |      this coordinates. Can't be given with ``member``
     |      ``radius`` Similar to GEORADIUS, search inside circular
     |      area according the given radius. Can't be given with
     |      ``height`` and ``width``.
     |      ``height`` and ``width`` Search inside an axis-aligned
     |      rectangle, determined by the given height and width.
     |      Can't be given with ``radius``
     |
     |      ``unit`` must be one of the following : m, km, mi, ft.
     |      `m` for meters (the default value), `km` for kilometers,
     |      `mi` for miles and `ft` for feet.
     |
     |      ``sort`` indicates to return the places in a sorted way,
     |      ASC for nearest to furthest and DESC for furthest to nearest.
     |
     |      ``count`` limit the results to the first count matching items.
     |
     |      ``any`` is set to True, the command will return as soon as
     |      enough matches are found. Can't be provided without ``count``
     |
     |      ``withdist`` indicates to return the distances of each place.
     |      ``withcoord`` indicates to return the latitude and longitude of
     |      each place.
     |
     |      ``withhash`` indicates to return the geohash string of each place.
     |
     |      For more information, see https://redis.io/commands/geosearch
     |
     |  geosearchstore(self, dest: 'KeyT', name: 'KeyT', member: 'FieldT | None' = None, longitude: 'float | None' = None, latitude: 'float | None' = None, unit: 'str' = 'm', radius: 'float | None' = None, width: 'float | None' = None, height: 'float | None' = None, sort: 'str | None' = None, count: 'int | None' = None, any: 'bool' = False, storedist: 'bool' = False) -> 'int | Awaitable[int]'
     |      This command is like GEOSEARCH, but stores the result in
     |      ``dest``. By default, it stores the results in the destination
     |      sorted set with their geospatial information.
     |      if ``store_dist`` set to True, the command will stores the
     |      items in a sorted set populated with their distance from the
     |      center of the circle or box, as a floating-point number.
     |
     |      For more information, see https://redis.io/commands/geosearchstore
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from redis.commands.core.ListCommands:
     |
     |  blmpop(self, timeout: 'float', numkeys: 'int', *args: 'str', direction: 'str', count: 'int | None' = 1) -> 'ListMultiPopResponse | Awaitable[ListMultiPopResponse]'
     |      Pop ``count`` values (default 1) from first non-empty in the list
     |      of provided key names.
     |
     |      When all lists are empty this command blocks the connection until another
     |      client pushes to it or until the timeout, timeout of 0 blocks indefinitely
     |
     |      For more information, see https://redis.io/commands/blmpop
     |
     |  blpop(self, keys: 'KeysT', timeout: 'Number | None' = 0) -> 'BlockingListPopResponse | Awaitable[BlockingListPopResponse]'
     |      LPOP a value off of the first non-empty list
     |      named in ``keys``.
     |
     |      If none of the lists in ``keys`` has a value to LPOP, then block
     |      for ``timeout`` seconds, or until a value gets pushed on to one
     |      of the lists.
     |
     |      If timeout is 0, then block indefinitely.
     |
     |      For more information, see https://redis.io/commands/blpop
     |
     |  brpop(self, keys: 'KeysT', timeout: 'Number | None' = 0) -> 'BlockingListPopResponse | Awaitable[BlockingListPopResponse]'
     |      RPOP a value off of the first non-empty list
     |      named in ``keys``.
     |
     |      If none of the lists in ``keys`` has a value to RPOP, then block
     |      for ``timeout`` seconds, or until a value gets pushed on to one
     |      of the lists.
     |
     |      If timeout is 0, then block indefinitely.
     |
     |      For more information, see https://redis.io/commands/brpop
     |
     |  brpoplpush(self, src: 'KeyT', dst: 'KeyT', timeout: 'Number | None' = 0) -> 'bytes | str | None | Awaitable[bytes | str | None]'
     |      Pop a value off the tail of ``src``, push it on the head of ``dst``
     |      and then return it.
     |
     |      This command blocks until a value is in ``src`` or until ``timeout``
     |      seconds elapse, whichever is first. A ``timeout`` value of 0 blocks
     |      forever.
     |
     |      For more information, see https://redis.io/commands/brpoplpush
     |
     |  lindex(self, name: 'KeyT', index: 'int') -> 'bytes | str | None | Awaitable[bytes | str | None]'
     |      Return the item from list ``name`` at position ``index``
     |
     |      Negative indexes are supported and will return an item at the
     |      end of the list
     |
     |      For more information, see https://redis.io/commands/lindex
     |
     |  linsert(self, name: 'KeyT', where: 'str', refvalue: 'str', value: 'str') -> 'int | Awaitable[int]'
     |      Insert ``value`` in list ``name`` either immediately before or after
     |      [``where``] ``refvalue``
     |
     |      Returns the new length of the list on success or -1 if ``refvalue``
     |      is not in the list.
     |
     |      For more information, see https://redis.io/commands/linsert
     |
     |  llen(self, name: 'KeyT') -> 'int | Awaitable[int]'
     |      Return the length of the list ``name``
     |
     |      For more information, see https://redis.io/commands/llen
     |
     |  lmpop(self, num_keys: 'int', *args: 'str', direction: 'str', count: 'int | None' = 1) -> 'ListMultiPopResponse | Awaitable[ListMultiPopResponse]'
     |      Pop ``count`` values (default 1) first non-empty list key from the list
     |      of args provided key names.
     |
     |      For more information, see https://redis.io/commands/lmpop
     |
     |  lpop(self, name: 'KeyT', count: 'int | None' = None) -> 'bytes | str | list[bytes | str] | None | Awaitable[bytes | str | list[bytes | str] | None]'
     |      Removes and returns the first elements of the list ``name``.
     |
     |      By default, the command pops a single element from the beginning of
     |      the list. When provided with the optional ``count`` argument, the reply
     |      will consist of up to count elements, depending on the list's length.
     |
     |      For more information, see https://redis.io/commands/lpop
     |
     |  lpos(self, name: 'KeyT', value: 'str', rank: 'int | None' = None, count: 'int | None' = None, maxlen: 'int | None' = None) -> 'int | list[int] | None | Awaitable[int | list[int] | None]'
     |      Get position of ``value`` within the list ``name``
     |
     |       If specified, ``rank`` indicates the "rank" of the first element to
     |       return in case there are multiple copies of ``value`` in the list.
     |       By default, LPOS returns the position of the first occurrence of
     |       ``value`` in the list. When ``rank`` 2, LPOS returns the position of
     |       the second ``value`` in the list. If ``rank`` is negative, LPOS
     |       searches the list in reverse. For example, -1 would return the
     |       position of the last occurrence of ``value`` and -2 would return the
     |       position of the next to last occurrence of ``value``.
     |
     |       If specified, ``count`` indicates that LPOS should return a list of
     |       up to ``count`` positions. A ``count`` of 2 would return a list of
     |       up to 2 positions. A ``count`` of 0 returns a list of all positions
     |       matching ``value``. When ``count`` is specified and but ``value``
     |       does not exist in the list, an empty list is returned.
     |
     |       If specified, ``maxlen`` indicates the maximum number of list
     |       elements to scan. A ``maxlen`` of 1000 will only return the
     |       position(s) of items within the first 1000 entries in the list.
     |       A ``maxlen`` of 0 (the default) will scan the entire list.
     |
     |       For more information, see https://redis.io/commands/lpos
     |
     |  lpush(self, name: 'KeyT', *values: 'FieldT') -> 'int | Awaitable[int]'
     |      Push ``values`` onto the head of the list ``name``
     |
     |      For more information, see https://redis.io/commands/lpush
     |
     |  lpushx(self, name: 'KeyT', *values: 'FieldT') -> 'int | Awaitable[int]'
     |      Push ``value`` onto the head of the list ``name`` if ``name`` exists
     |
     |      For more information, see https://redis.io/commands/lpushx
     |
     |  lrange(self, name: 'KeyT', start: 'int', end: 'int') -> 'list[bytes | str] | Awaitable[list[bytes | str]]'
     |      Return a slice of the list ``name`` between
     |      position ``start`` and ``end``
     |
     |      ``start`` and ``end`` can be negative numbers just like
     |      Python slicing notation
     |
     |      For more information, see https://redis.io/commands/lrange
     |
     |  lrem(self, name: 'KeyT', count: 'int', value: 'str') -> 'int | Awaitable[int]'
     |      Remove the first ``count`` occurrences of elements equal to ``value``
     |      from the list stored at ``name``.
     |
     |      The count argument influences the operation in the following ways:
     |          count > 0: Remove elements equal to value moving from head to tail.
     |          count < 0: Remove elements equal to value moving from tail to head.
     |          count = 0: Remove all elements equal to value.
     |
     |          For more information, see https://redis.io/commands/lrem
     |
     |  lset(self, name: 'KeyT', index: 'int', value: 'str') -> 'bool | Awaitable[bool]'
     |      Set element at ``index`` of list ``name`` to ``value``
     |
     |      For more information, see https://redis.io/commands/lset
     |
     |  ltrim(self, name: 'KeyT', start: 'int', end: 'int') -> 'bool | Awaitable[bool]'
     |      Trim the list ``name``, removing all values not within the slice
     |      between ``start`` and ``end``
     |
     |      ``start`` and ``end`` can be negative numbers just like
     |      Python slicing notation
     |
     |      For more information, see https://redis.io/commands/ltrim
     |
     |  rpop(self, name: 'KeyT', count: 'int | None' = None) -> 'bytes | str | list[bytes | str] | None | Awaitable[bytes | str | list[bytes | str] | None]'
     |      Removes and returns the last elements of the list ``name``.
     |
     |      By default, the command pops a single element from the end of the list.
     |      When provided with the optional ``count`` argument, the reply will
     |      consist of up to count elements, depending on the list's length.
     |
     |      For more information, see https://redis.io/commands/rpop
     |
     |  rpoplpush(self, src: 'KeyT', dst: 'KeyT') -> 'bytes | str | None | Awaitable[bytes | str | None]'
     |      RPOP a value off of the ``src`` list and atomically LPUSH it
     |      on to the ``dst`` list.  Returns the value.
     |
     |      For more information, see https://redis.io/commands/rpoplpush
     |
     |  rpush(self, name: 'KeyT', *values: 'FieldT') -> 'int | Awaitable[int]'
     |      Push ``values`` onto the tail of the list ``name``
     |
     |      For more information, see https://redis.io/commands/rpush
     |
     |  rpushx(self, name: 'KeyT', *values: 'str') -> 'int | Awaitable[int]'
     |      Push ``value`` onto the tail of the list ``name`` if ``name`` exists
     |
     |      For more information, see https://redis.io/commands/rpushx
     |
     |  sort(self, name: 'KeyT', start: 'int | None' = None, num: 'int | None' = None, by: 'str | None' = None, get: 'list[str] | None' = None, desc: 'bool' = False, alpha: 'bool' = False, store: 'str | None' = None, groups: 'bool | None' = False) -> 'SortResponse | Awaitable[SortResponse]'
     |      Sort and return the list, set or sorted set at ``name``.
     |
     |      ``start`` and ``num`` allow for paging through the sorted data
     |
     |      ``by`` allows using an external key to weight and sort the items.
     |          Use an "*" to indicate where in the key the item value is located
     |
     |      ``get`` allows for returning items from external keys rather than the
     |          sorted data itself.  Use an "*" to indicate where in the key
     |          the item value is located
     |
     |      ``desc`` allows for reversing the sort
     |
     |      ``alpha`` allows for sorting lexicographically rather than numerically
     |
     |      ``store`` allows for storing the result of the sort into
     |          the key ``store``
     |
     |      ``groups`` if set to True and if ``get`` contains at least two
     |          elements, sort will return a list of tuples, each containing the
     |          values fetched from the arguments to ``get``.
     |
     |      For more information, see https://redis.io/commands/sort
     |
     |  sort_ro(self, key: 'str', start: 'int | None' = None, num: 'int | None' = None, by: 'str | None' = None, get: 'list[str] | None' = None, desc: 'bool' = False, alpha: 'bool' = False) -> 'list[bytes | str] | Awaitable[list[bytes | str]]'
     |      Returns the elements contained in the list, set or sorted set at key.
     |      (read-only variant of the SORT command)
     |
     |      ``start`` and ``num`` allow for paging through the sorted data
     |
     |      ``by`` allows using an external key to weight and sort the items.
     |          Use an "*" to indicate where in the key the item value is located
     |
     |      ``get`` allows for returning items from external keys rather than the
     |          sorted data itself.  Use an "*" to indicate where in the key
     |          the item value is located
     |
     |      ``desc`` allows for reversing the sort
     |
     |      ``alpha`` allows for sorting lexicographically rather than numerically
     |
     |      For more information, see https://redis.io/commands/sort_ro
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from redis.commands.core.ArrayCommands:
     |
     |  arcount(self, name: 'KeyT') -> 'int | Awaitable[int]'
     |      Return the number of non-empty elements in the array stored at
     |      ``name``. Returns 0 if ``name`` does not exist.
     |
     |      For more information, see https://redis.io/commands/arcount
     |
     |  ardel(self, name: 'KeyT', *indices: 'int') -> 'int | Awaitable[int]'
     |      Delete elements at the specified ``indices`` in the array stored at
     |      ``name``. Deleting an index that does not exist counts as zero
     |      elements deleted and does not modify the array.
     |
     |      Returns the number of elements deleted.
     |
     |      For more information, see https://redis.io/commands/ardel
     |
     |  ardelrange(self, name: 'KeyT', *ranges: 'tuple[int, int]') -> 'int | Awaitable[int]'
     |      Delete elements within one or more inclusive index ranges in the
     |      array stored at ``name``. Each range is a ``(start, end)`` tuple.
     |      If ``start`` is greater than ``end`` for a given pair, the range is
     |      processed in ascending order regardless. Multiple pairs may overlap;
     |      each element is counted at most once.
     |
     |      Returns the number of elements deleted.
     |
     |      For more information, see https://redis.io/commands/ardelrange
     |
     |  arget(self, name: 'KeyT', index: 'int') -> 'bytes | str | None | Awaitable[bytes | str | None]'
     |      Return the value at ``index`` in the array stored at ``name``.
     |
     |      Returns ``None`` if ``name`` does not exist or no value is set at
     |      ``index``.
     |
     |      For more information, see https://redis.io/commands/arget
     |
     |  argetrange(self, name: 'KeyT', start: 'int', end: 'int') -> 'list[bytes | str | None] | Awaitable[list[bytes | str | None]]'
     |      Return the values in the inclusive index range [``start``, ``end``]
     |      in the array stored at ``name``. If ``start`` is greater than ``end``,
     |      elements are returned in reverse index order.
     |
     |      For more information, see https://redis.io/commands/argetrange
     |
     |  argrep(self, name: 'KeyT', start: 'int', end: 'int', predicates: 'list[tuple[ArrayPredicateType, EncodableT]]', combinator: 'ArrayPredicateCombinator | None' = None, limit: 'int | None' = None, withvalues: 'bool' = False, nocase: 'bool' = False) -> 'list[int] | list[list[int | bytes | str]] | Awaitable[list[int] | list[list[int | bytes | str]]]'
     |      Search elements of the array stored at ``name`` within the inclusive
     |      index range [``start``, ``end``] using one or more textual
     |      ``predicates``. Each predicate is a ``(type, value)`` tuple where
     |      ``type`` is a member of ``ArrayPredicateType``
     |      (``EXACT``, ``MATCH``, ``GLOB``, ``RE``).
     |
     |      Multiple predicates are combined via ``combinator``
     |      (``ArrayPredicateCombinator.AND`` or ``OR``); the server defaults to
     |      OR when omitted. ``limit`` caps the number of matches.
     |      ``withvalues=True`` returns a list of ``[index, value]`` pairs
     |      (``[[idx, val], ...]``) instead of a flat list of indices.
     |      ``nocase=True`` makes all comparisons case-insensitive.
     |
     |      Without ``withvalues``, returns a flat list of matching indices in
     |      traversal order. With ``withvalues``, returns a list of
     |      ``[index, value]`` pairs in traversal order. Empty slots are
     |      skipped.
     |
     |      For more information, see https://redis.io/commands/argrep
     |
     |  arinfo(self, name: 'KeyT', full: 'bool' = False) -> 'dict[str, int] | Awaitable[dict[str, int]]'
     |      Return metadata about the array stored at ``name`` as a dictionary.
     |      When ``full`` is ``True``, additionally include per-slice statistics
     |      (dense/sparse slice counts, average sizes, fill rates), which makes
     |      the call O(N) instead of O(1).
     |
     |      Raises ``ResponseError`` when the key does not exist.
     |
     |      For more information, see https://redis.io/commands/arinfo
     |
     |  arinsert(self, name: 'KeyT', *values: 'FieldT') -> 'int | Awaitable[int]'
     |      Insert one or more ``values`` at consecutive indices in the array
     |      stored at ``name``, beginning at the current insert cursor position.
     |      The cursor advances by one for each value inserted. Use ``ARNEXT``
     |      to inspect the current cursor position and ``ARSEEK`` to reposition
     |      it.
     |
     |      Returns the last index where a value was inserted.
     |
     |      For more information, see https://redis.io/commands/arinsert
     |
     |  arlastitems(self, name: 'KeyT', count: 'int', rev: 'bool' = False) -> 'list[bytes | str | None] | Awaitable[list[bytes | str | None]]'
     |      Return up to ``count`` most recently inserted elements from the array
     |      stored at ``name``. If the array contains fewer elements than
     |      ``count``, all elements are returned.
     |
     |      When ``rev`` is ``True``, elements are returned in reverse
     |      chronological order (most recent first) instead of the default
     |      oldest-first order.
     |
     |      For more information, see https://redis.io/commands/arlastitems
     |
     |  arlen(self, name: 'KeyT') -> 'int | Awaitable[int]'
     |      Return the length of the array stored at ``name``, defined as the
     |      maximum set index plus one. Returns 0 if ``name`` does not exist.
     |
     |      For more information, see https://redis.io/commands/arlen
     |
     |  armget(self, name: 'KeyT', *indices: 'int') -> 'list[bytes | str | None] | Awaitable[list[bytes | str | None]]'
     |      Return the values at the specified ``indices`` in the array stored at
     |      ``name``. The reply preserves the order of the requested indices and
     |      returns ``None`` for any index that is not set or when ``name`` does
     |      not exist.
     |
     |      For more information, see https://redis.io/commands/armget
     |
     |  armset(self, name: 'KeyT', mapping: 'Mapping[int, FieldT]') -> 'int | Awaitable[int]'
     |      Set multiple index/value pairs in the array stored at ``name``.
     |      ``mapping`` is a dictionary of zero-based integer indices to values.
     |      Pairs may be non-contiguous and in any order.
     |
     |      Returns the number of new slots that were set (previously empty).
     |
     |      For more information, see https://redis.io/commands/armset
     |
     |  arnext(self, name: 'KeyT') -> 'int | None | Awaitable[int | None]'
     |      Return the next index ``ARINSERT`` would use for the array stored at
     |      ``name``. Returns 0 if ``name`` does not exist or no insert happened
     |      yet, and ``None`` when the insertion cursor is exhausted (next insert
     |      would overflow).
     |
     |      For more information, see https://redis.io/commands/arnext
     |
     |  arop(self, name: 'KeyT', start: 'int', end: 'int', operation: 'ArrayAggregateOperations', value: 'EncodableT | None' = None) -> 'bytes | str | int | None | Awaitable[bytes | str | int | None]'
     |      Perform an aggregate ``operation`` on elements of the array stored at
     |      ``name`` in the inclusive index range [``start``, ``end``]. The range
     |      is always scanned from the lower to the higher index regardless of
     |      argument order.
     |
     |      ``operation`` is one of the members of ``ArrayAggregateOperations``.
     |      ``value`` is required when ``operation`` is
     |      ``ArrayAggregateOperations.MATCH`` and specifies the value to compare
     |      against.
     |
     |      Returns a bulk string for ``SUM``, ``MIN`` and ``MAX``, an integer
     |      for ``AND``, ``OR``, ``XOR``, ``MATCH`` and ``USED``, or ``None``
     |      when no elements match the operation.
     |
     |      For more information, see https://redis.io/commands/arop
     |
     |  arring(self, name: 'KeyT', size: 'int', *values: 'FieldT') -> 'int | Awaitable[int]'
     |      Insert one or more ``values`` into the array stored at ``name`` as a
     |      fixed-size ring buffer of ``size`` slots. Each value is placed at
     |      ``insert_idx % size``, wrapping back to index 0 once the end is
     |      reached and overwriting older values when full. If ``size`` is
     |      smaller than the current window, the array is truncated to fit.
     |
     |      Returns the last index where a value was inserted.
     |
     |      For more information, see https://redis.io/commands/arring
     |
     |  arscan(self, name: 'KeyT', start: 'int', end: 'int', limit: 'int | None' = None) -> 'list[list[int | bytes | str]] | Awaitable[list[list[int | bytes | str]]]'
     |      Iterate populated elements of the array stored at ``name`` in the
     |      inclusive range [``start``, ``end``] and return a list of
     |      ``[index, value]`` pairs in traversal order:
     |      ``[[idx1, val1], [idx2, val2], ...]``. Empty slots are skipped. If
     |      ``start`` is greater than ``end``, the iteration is reversed.
     |
     |      ``limit`` caps the number of populated elements returned. When
     |      omitted, all populated elements in range are returned.
     |
     |      For more information, see https://redis.io/commands/arscan
     |
     |  arseek(self, name: 'KeyT', index: 'int') -> 'int | Awaitable[int]'
     |      Set the insert cursor of the array stored at ``name`` to ``index``.
     |      Subsequent ``ARINSERT`` and ``ARRING`` operations begin inserting at
     |      this position.
     |
     |      Returns 1 if the cursor was set, 0 if ``name`` does not exist.
     |
     |      For more information, see https://redis.io/commands/arseek
     |
     |  arset(self, name: 'KeyT', index: 'int', *values: 'FieldT') -> 'int | Awaitable[int]'
     |      Set one or more contiguous ``values`` in the array stored at ``name``
     |      starting at ``index``. When multiple values are provided, they are
     |      stored at consecutive indices beginning at ``index``.
     |
     |      Returns the number of new slots that were set (previously empty).
     |
     |      For more information, see https://redis.io/commands/arset
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from redis.commands.core.AsyncScanCommands:
     |
     |  async hscan_iter(self, name: 'KeyT', match: 'Union[PatternT, None]' = None, count: 'Optional[int]' = None, no_values: 'Union[bool, None]' = None) -> 'AsyncIterator'
     |      Make an iterator using the HSCAN command so that the client doesn't
     |      need to remember the cursor position.
     |
     |      ``match`` allows for filtering the keys by pattern
     |
     |      ``count`` allows for hint the minimum number of returns
     |
     |      ``no_values`` indicates to return only the keys, without values
     |
     |  async scan_iter(self, match: 'Union[PatternT, None]' = None, count: 'Optional[int]' = None, _type: 'Optional[str]' = None, **kwargs) -> 'AsyncIterator'
     |      Make an iterator using the SCAN command so that the client doesn't
     |      need to remember the cursor position.
     |
     |      ``match`` allows for filtering the keys by pattern
     |
     |      ``count`` provides a hint to Redis about the number of keys to
     |          return per batch.
     |
     |      ``_type`` filters the returned values by a particular Redis type.
     |          Stock Redis instances allow for the following types:
     |          HASH, LIST, SET, STREAM, STRING, ZSET
     |          Additionally, Redis modules can expose other types as well.
     |
     |  async sscan_iter(self, name: 'KeyT', match: 'Union[PatternT, None]' = None, count: 'Optional[int]' = None) -> 'AsyncIterator'
     |      Make an iterator using the SSCAN command so that the client doesn't
     |      need to remember the cursor position.
     |
     |      ``match`` allows for filtering the keys by pattern
     |
     |      ``count`` allows for hint the minimum number of returns
     |
     |  async zscan_iter(self, name: 'KeyT', match: 'Union[PatternT, None]' = None, count: 'Optional[int]' = None, score_cast_func: 'Union[type, Callable]' = <class 'float'>) -> 'AsyncIterator'
     |      Make an iterator using the ZSCAN command so that the client doesn't
     |      need to remember the cursor position.
     |
     |      ``match`` allows for filtering the keys by pattern
     |
     |      ``count`` allows for hint the minimum number of returns
     |
     |      ``score_cast_func`` a callable used to cast the score return value
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from redis.commands.core.ScanCommands:
     |
     |  hscan(self, name: 'KeyT', cursor: 'int' = 0, match: 'PatternT | None' = None, count: 'int | None' = None, no_values: 'bool | None' = None) -> 'HScanResponse | Awaitable[HScanResponse]'
     |      Incrementally return key/value slices in a hash. Also return a cursor
     |      indicating the scan position.
     |
     |      ``match`` allows for filtering the keys by pattern
     |
     |      ``count`` allows for hint the minimum number of returns
     |
     |      ``no_values`` indicates to return only the keys, without values.
     |
     |      For more information, see https://redis.io/commands/hscan
     |
     |  scan(self, cursor: 'int' = 0, match: 'PatternT | None' = None, count: 'int | None' = None, _type: 'str | None' = None, **kwargs) -> 'ScanResponse | Awaitable[ScanResponse]'
     |      Incrementally return lists of key names. Also return a cursor
     |      indicating the scan position.
     |
     |      ``match`` allows for filtering the keys by pattern
     |
     |      ``count`` provides a hint to Redis about the number of keys to
     |          return per batch.
     |
     |      ``_type`` filters the returned values by a particular Redis type.
     |          Stock Redis instances allow for the following types:
     |          HASH, LIST, SET, STREAM, STRING, ZSET
     |          Additionally, Redis modules can expose other types as well.
     |
     |      For more information, see https://redis.io/commands/scan
     |
     |  sscan(self, name: 'KeyT', cursor: 'int' = 0, match: 'PatternT | None' = None, count: 'int | None' = None) -> 'ScanResponse | Awaitable[ScanResponse]'
     |      Incrementally return lists of elements in a set. Also return a cursor
     |      indicating the scan position.
     |
     |      ``match`` allows for filtering the keys by pattern
     |
     |      ``count`` allows for hint the minimum number of returns
     |
     |      For more information, see https://redis.io/commands/sscan
     |
     |  zscan(self, name: 'KeyT', cursor: 'int' = 0, match: 'PatternT | None' = None, count: 'int | None' = None, score_cast_func: 'type | Callable' = <class 'float'>) -> 'ZScanResponse | Awaitable[ZScanResponse]'
     |      Incrementally return lists of elements in a sorted set. Also return a
     |      cursor indicating the scan position.
     |
     |      ``match`` allows for filtering the keys by pattern
     |
     |      ``count`` allows for hint the minimum number of returns
     |
     |      ``score_cast_func`` a callable used to cast the score return value
     |
     |      For more information, see https://redis.io/commands/zscan
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from redis.commands.core.SetCommands:
     |
     |  sadd(self, name: 'KeyT', *values: 'FieldT') -> 'int | Awaitable[int]'
     |      Add ``value(s)`` to set ``name``
     |
     |      For more information, see https://redis.io/commands/sadd
     |
     |  scard(self, name: 'KeyT') -> 'int | Awaitable[int]'
     |      Return the number of elements in set ``name``
     |
     |      For more information, see https://redis.io/commands/scard
     |
     |  sdiff(self, keys: 'List', *args: 'List') -> 'set[bytes | str] | Awaitable[set[bytes | str]]'
     |      Return the difference of sets specified by ``keys``
     |
     |      For more information, see https://redis.io/commands/sdiff
     |
     |  sdiffcard(self, numkeys: 'int', keys: 'List[KeyT]', limit: 'int' = 0) -> 'int | Awaitable[int]'
     |      Return the cardinality of the difference between the first set and all
     |      the successive sets specified by ``keys``, without returning the
     |      difference itself.
     |
     |      When LIMIT is provided (defaults to 0 and means unlimited), the returned
     |      cardinality is capped at ``limit`` and the server may stop the
     |      computation once the capped result is known.
     |
     |      For more information, see https://redis.io/commands/sdiffcard
     |
     |  sdiffstore(self, dest: 'str', keys: 'List', *args: 'List') -> 'int | Awaitable[int]'
     |      Store the difference of sets specified by ``keys`` into a new
     |      set named ``dest``.  Returns the number of keys in the new set.
     |
     |      For more information, see https://redis.io/commands/sdiffstore
     |
     |  sinter(self, keys: 'List', *args: 'List') -> 'set[bytes | str] | Awaitable[set[bytes | str]]'
     |      Return the intersection of sets specified by ``keys``
     |
     |      For more information, see https://redis.io/commands/sinter
     |
     |  sintercard(self, numkeys: 'int', keys: 'List[KeyT]', limit: 'int' = 0) -> 'int | Awaitable[int]'
     |      Return the cardinality of the intersect of multiple sets specified by ``keys``.
     |
     |      When LIMIT provided (defaults to 0 and means unlimited), if the intersection
     |      cardinality reaches limit partway through the computation, the algorithm will
     |      exit and yield limit as the cardinality
     |
     |      For more information, see https://redis.io/commands/sintercard
     |
     |  sinterstore(self, dest: 'KeyT', keys: 'List', *args: 'List') -> 'int | Awaitable[int]'
     |      Store the intersection of sets specified by ``keys`` into a new
     |      set named ``dest``.  Returns the number of keys in the new set.
     |
     |      For more information, see https://redis.io/commands/sinterstore
     |
     |  sismember(self, name: 'KeyT', value: 'str') -> 'Literal[0] | Literal[1] | Awaitable[Literal[0] | Literal[1]]'
     |      Return whether ``value`` is a member of set ``name``:
     |      - 1 if the value is a member of the set.
     |      - 0 if the value is not a member of the set or if key does not exist.
     |
     |      For more information, see https://redis.io/commands/sismember
     |
     |  smembers(self, name: 'KeyT') -> 'set[bytes | str] | Awaitable[set[bytes | str]]'
     |      Return all members of the set ``name``
     |
     |      For more information, see https://redis.io/commands/smembers
     |
     |  smismember(self, name: 'KeyT', values: 'List', *args: 'List') -> 'list[Literal[0] | Literal[1]] | Awaitable[list[Literal[0] | Literal[1]]]'
     |      Return whether each value in ``values`` is a member of the set ``name``
     |      as a list of ``int`` in the order of ``values``:
     |      - 1 if the value is a member of the set.
     |      - 0 if the value is not a member of the set or if key does not exist.
     |
     |      For more information, see https://redis.io/commands/smismember
     |
     |  smove(self, src: 'KeyT', dst: 'KeyT', value: 'str') -> 'bool | Awaitable[bool]'
     |      Move ``value`` from set ``src`` to set ``dst`` atomically
     |
     |      For more information, see https://redis.io/commands/smove
     |
     |  spop(self, name: 'KeyT', count: 'int | None' = None) -> 'bytes | str | set[bytes | str] | None | Awaitable[bytes | str | set[bytes | str] | None]'
     |      Remove and return a random member of set ``name``
     |
     |      For more information, see https://redis.io/commands/spop
     |
     |  srandmember(self, name: 'KeyT', number: 'int | None' = None) -> 'bytes | str | list[bytes | str] | None | Awaitable[bytes | str | list[bytes | str] | None]'
     |      If ``number`` is None, returns a random member of set ``name``.
     |
     |      If ``number`` is supplied, returns a list of ``number`` random
     |      members of set ``name``. Note this is only available when running
     |      Redis 2.6+.
     |
     |      For more information, see https://redis.io/commands/srandmember
     |
     |  srem(self, name: 'KeyT', *values: 'FieldT') -> 'int | Awaitable[int]'
     |      Remove ``values`` from set ``name``
     |
     |      For more information, see https://redis.io/commands/srem
     |
     |  sunion(self, keys: 'List', *args: 'List') -> 'set[bytes | str] | Awaitable[set[bytes | str]]'
     |      Return the union of sets specified by ``keys``
     |
     |      For more information, see https://redis.io/commands/sunion
     |
     |  sunioncard(self, numkeys: 'int', keys: 'List[KeyT]', limit: 'int' = 0, approx: 'bool' = False) -> 'int | Awaitable[int]'
     |      Return the cardinality of the union of multiple sets specified by
     |      ``keys``, without returning the union itself.
     |
     |      When ``approx`` is True, the ``APPROX`` option is sent and the server
     |      returns an approximate cardinality computed using HyperLogLog.
     |
     |      When LIMIT is provided (defaults to 0 and means unlimited), the returned
     |      cardinality is capped at ``limit``. In exact mode the result equals
     |      ``limit`` when the real cardinality exceeds ``limit``; in approximate
     |      mode the result will not exceed ``limit``. Options are emitted in the
     |      canonical order ``APPROX`` before ``LIMIT``.
     |
     |      For more information, see https://redis.io/commands/sunioncard
     |
     |  sunionstore(self, dest: 'KeyT', keys: 'List', *args: 'List') -> 'int | Awaitable[int]'
     |      Store the union of sets specified by ``keys`` into a new
     |      set named ``dest``.  Returns the number of keys in the new set.
     |
     |      For more information, see https://redis.io/commands/sunionstore
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from redis.commands.core.StreamCommands:
     |
     |  xack(self, name: 'KeyT', groupname: 'GroupT', *ids: 'StreamIdT') -> 'int | Awaitable[int]'
     |      Acknowledges the successful processing of one or more messages.
     |
     |      Args:
     |          name: name of the stream.
     |          groupname: name of the consumer group.
     |          *ids: message ids to acknowledge.
     |
     |      For more information, see https://redis.io/commands/xack
     |
     |  xackdel(self, name: 'KeyT', groupname: 'GroupT', *ids: 'StreamIdT', ref_policy: "Literal['KEEPREF', 'DELREF', 'ACKED']" = 'KEEPREF') -> 'int | Awaitable[int]'
     |      Combines the functionality of XACK and XDEL. Acknowledges the specified
     |      message IDs in the given consumer group and simultaneously attempts to
     |      delete the corresponding entries from the stream.
     |
     |  xadd(self, name: 'KeyT', fields: 'Dict[FieldT, EncodableT]', id: 'StreamIdT' = '*', maxlen: 'Optional[int]' = None, approximate: 'bool' = True, nomkstream: 'bool' = False, minid: 'Union[StreamIdT, None]' = None, limit: 'int | None' = None, ref_policy: "Literal['KEEPREF', 'DELREF', 'ACKED'] | None" = None, idmpauto: 'str | None' = None, idmp: 'tuple[str, bytes] | None' = None) -> 'bytes | str | Awaitable[bytes | str]'
     |      Add to a stream.
     |      name: name of the stream
     |      fields: dict of field/value pairs to insert into the stream
     |      id: Location to insert this record. By default it is appended.
     |      maxlen: truncate old stream members beyond this size.
     |      Can't be specified with minid.
     |      approximate: actual stream length may be slightly more than maxlen
     |      nomkstream: When set to true, do not make a stream
     |      minid: the minimum id in the stream to query.
     |      Can't be specified with maxlen.
     |      limit: specifies the maximum number of entries to retrieve
     |      ref_policy: optional reference policy for consumer groups when trimming:
     |          - KEEPREF (default): When trimming, preserves references in consumer groups' PEL
     |          - DELREF: When trimming, removes all references from consumer groups' PEL
     |          - ACKED: When trimming, only removes entries acknowledged by all consumer groups
     |      idmpauto: Producer ID for automatic idempotent ID calculation.
     |          Automatically calculates an idempotent ID based on entry content to prevent
     |          duplicate entries. Can only be used with id='*'. Creates an IDMP map if it
     |          doesn't exist yet. The producer ID must be unique per producer and consistent
     |          across restarts.
     |      idmp: Tuple of (producer_id, idempotent_id) for explicit idempotent ID.
     |          Uses a specific idempotent ID to prevent duplicate entries. Can only be used
     |          with id='*'. The producer ID must be unique per producer and consistent across
     |          restarts. The idempotent ID must be unique per message and per producer.
     |          Shorter idempotent IDs require less memory and allow faster processing.
     |          Creates an IDMP map if it doesn't exist yet.
     |
     |      For more information, see https://redis.io/commands/xadd
     |
     |  xautoclaim(self, name: 'KeyT', groupname: 'GroupT', consumername: 'ConsumerT', min_idle_time: 'int', start_id: 'StreamIdT' = '0-0', count: 'int | None' = None, justid: 'bool' = False) -> 'list[Any] | Awaitable[list[Any]]'
     |      Transfers ownership of pending stream entries that match the specified
     |      criteria. Conceptually, equivalent to calling XPENDING and then XCLAIM,
     |      but provides a more straightforward way to deal with message delivery
     |      failures via SCAN-like semantics.
     |      name: name of the stream.
     |      groupname: name of the consumer group.
     |      consumername: name of a consumer that claims the message.
     |      min_idle_time: filter messages that were idle less than this amount of
     |      milliseconds.
     |      start_id: filter messages with equal or greater ID.
     |      count: optional integer, upper limit of the number of entries that the
     |      command attempts to claim. Set to 100 by default.
     |      justid: optional boolean, false by default. Return just an array of IDs
     |      of messages successfully claimed, without returning the actual message
     |
     |      For more information, see https://redis.io/commands/xautoclaim
     |
     |  xcfgset(self, name: 'KeyT', idmp_duration: 'int | None' = None, idmp_maxsize: 'int | None' = None) -> 'bytes | str | Awaitable[bytes | str]'
     |      Configure the idempotency parameters for a stream's IDMP map.
     |
     |      Sets how long Redis remembers each idempotent ID (iid) and the maximum
     |      number of iids to track. This command clears the existing IDMP map
     |      (Redis forgets all previously stored iids), but only if the configuration
     |      value actually changes.
     |
     |      Args:
     |          name: The name of the stream.
     |          idmp_duration: How long Redis remembers each iid in seconds.
     |              Default: 100 seconds (or value set by stream-idmp-duration config).
     |              Minimum: 1 second, Maximum: 300 seconds.
     |              Redis won't forget an iid for this duration (unless maxsize is reached).
     |              Should accommodate application crash recovery time.
     |          idmp_maxsize: Maximum number of iids Redis remembers per producer ID (pid).
     |              Default: 100 iids (or value set by stream-idmp-maxsize config).
     |              Minimum: 1 iid, Maximum: 1,000,000 (1M) iids.
     |              Should be set to: mark-delay [in msec] × (messages/msec) + margin.
     |              Example: 10K msgs/sec (10 msgs/msec), 80 msec mark-delay
     |              → maxsize = 10 × 80 + margin = 1000 iids.
     |
     |      Returns:
     |          OK on success.
     |
     |      For more information, see https://redis.io/commands/xcfgset
     |
     |  xclaim(self, name: 'KeyT', groupname: 'GroupT', consumername: 'ConsumerT', min_idle_time: 'int', message_ids: 'Union[List[StreamIdT], Tuple[StreamIdT]]', idle: 'int | None' = None, time: 'int | None' = None, retrycount: 'int | None' = None, force: 'bool' = False, justid: 'bool' = False) -> 'XClaimResponse | Awaitable[XClaimResponse]'
     |      Changes the ownership of a pending message.
     |
     |      name: name of the stream.
     |
     |      groupname: name of the consumer group.
     |
     |      consumername: name of a consumer that claims the message.
     |
     |      min_idle_time: filter messages that were idle less than this amount of
     |      milliseconds
     |
     |      message_ids: non-empty list or tuple of message IDs to claim
     |
     |      idle: optional. Set the idle time (last time it was delivered) of the
     |      message in ms
     |
     |      time: optional integer. This is the same as idle but instead of a
     |      relative amount of milliseconds, it sets the idle time to a specific
     |      Unix time (in milliseconds).
     |
     |      retrycount: optional integer. set the retry counter to the specified
     |      value. This counter is incremented every time a message is delivered
     |      again.
     |
     |      force: optional boolean, false by default. Creates the pending message
     |      entry in the PEL even if certain specified IDs are not already in the
     |      PEL assigned to a different client.
     |
     |      justid: optional boolean, false by default. Return just an array of IDs
     |      of messages successfully claimed, without returning the actual message
     |
     |      For more information, see https://redis.io/commands/xclaim
     |
     |  xdel(self, name: 'KeyT', *ids: 'StreamIdT') -> 'int | Awaitable[int]'
     |      Deletes one or more messages from a stream.
     |
     |      Args:
     |          name: name of the stream.
     |          *ids: message ids to delete.
     |
     |      For more information, see https://redis.io/commands/xdel
     |
     |  xdelex(self, name: 'KeyT', *ids: 'StreamIdT', ref_policy: "Literal['KEEPREF', 'DELREF', 'ACKED']" = 'KEEPREF') -> 'int | Awaitable[int]'
     |      Extended version of XDEL that provides more control over how message entries
     |      are deleted concerning consumer groups.
     |
     |  xgroup_create(self, name: 'KeyT', groupname: 'GroupT', id: 'StreamIdT' = '$', mkstream: 'bool' = False, entries_read: 'int | None' = None) -> 'bool | Awaitable[bool]'
     |      Create a new consumer group associated with a stream.
     |      name: name of the stream.
     |      groupname: name of the consumer group.
     |      id: ID of the last item in the stream to consider already delivered.
     |
     |      For more information, see https://redis.io/commands/xgroup-create
     |
     |  xgroup_createconsumer(self, name: 'KeyT', groupname: 'GroupT', consumername: 'ConsumerT') -> 'int | Awaitable[int]'
     |      Consumers in a consumer group are auto-created every time a new
     |      consumer name is mentioned by some command.
     |      They can be explicitly created by using this command.
     |      name: name of the stream.
     |      groupname: name of the consumer group.
     |      consumername: name of consumer to create.
     |
     |      See: https://redis.io/commands/xgroup-createconsumer
     |
     |  xgroup_delconsumer(self, name: 'KeyT', groupname: 'GroupT', consumername: 'ConsumerT') -> 'int | Awaitable[int]'
     |      Remove a specific consumer from a consumer group.
     |      Returns the number of pending messages that the consumer had before it
     |      was deleted.
     |      name: name of the stream.
     |      groupname: name of the consumer group.
     |      consumername: name of consumer to delete
     |
     |      For more information, see https://redis.io/commands/xgroup-delconsumer
     |
     |  xgroup_destroy(self, name: 'KeyT', groupname: 'GroupT') -> 'bool | Awaitable[bool]'
     |      Destroy a consumer group.
     |      name: name of the stream.
     |      groupname: name of the consumer group.
     |
     |      For more information, see https://redis.io/commands/xgroup-destroy
     |
     |  xgroup_setid(self, name: 'KeyT', groupname: 'GroupT', id: 'StreamIdT', entries_read: 'int | None' = None) -> 'bool | Awaitable[bool]'
     |      Set the consumer group last delivered ID to something else.
     |      name: name of the stream.
     |      groupname: name of the consumer group.
     |      id: ID of the last item in the stream to consider already delivered.
     |
     |      For more information, see https://redis.io/commands/xgroup-setid
     |
     |  xinfo_consumers(self, name: 'KeyT', groupname: 'GroupT') -> 'list[dict[str, Any]] | Awaitable[list[dict[str, Any]]]'
     |      Returns general information about the consumers in the group.
     |      name: name of the stream.
     |      groupname: name of the consumer group.
     |
     |      For more information, see https://redis.io/commands/xinfo-consumers
     |
     |  xinfo_groups(self, name: 'KeyT') -> 'list[dict[str, Any]] | Awaitable[list[dict[str, Any]]]'
     |      Returns general information about the consumer groups of the stream.
     |      name: name of the stream.
     |
     |      For more information, see https://redis.io/commands/xinfo-groups
     |
     |  xinfo_stream(self, name: 'KeyT', full: 'bool' = False) -> 'dict[str, Any] | Awaitable[dict[str, Any]]'
     |      Returns general information about the stream.
     |      name: name of the stream.
     |      full: optional boolean, false by default. Return full summary
     |
     |      For more information, see https://redis.io/commands/xinfo-stream
     |
     |  xlen(self, name: 'KeyT') -> 'int | Awaitable[int]'
     |      Returns the number of elements in a given stream.
     |
     |      For more information, see https://redis.io/commands/xlen
     |
     |  xnack(self, name: 'KeyT', groupname: 'GroupT', mode: "Literal['SILENT', 'FAIL', 'FATAL']", *ids: 'StreamIdT', retrycount: 'int | None' = None, force: 'bool' = False) -> 'int | Awaitable[int]'
     |      Negatively acknowledges one or more messages in a consumer group's
     |      Pending Entries List (PEL).
     |
     |      Args:
     |          name: name of the stream.
     |          groupname: name of the consumer group.
     |          mode: the nacking mode. One of SILENT, FAIL, or FATAL.
     |              SILENT: consumer shutting down; decrements delivery counter.
     |              FAIL: consumer unable to process; delivery counter unchanged.
     |              FATAL: invalid/malicious message; delivery counter set to max.
     |          *ids: one or more message IDs to NACK.
     |          retrycount: optional integer >= 0. Overrides the mode's implicit
     |              delivery counter adjustment with an exact value.
     |          force: if True, creates a new unowned PEL entry for any ID not
     |              already in the group's PEL.
     |
     |      Returns:
     |          The number of messages successfully NACKed.
     |
     |      For more information, see https://redis.io/commands/xnack
     |
     |  xpending(self, name: 'KeyT', groupname: 'GroupT') -> 'dict[str, Any] | Awaitable[dict[str, Any]]'
     |      Returns information about pending messages of a group.
     |      name: name of the stream.
     |      groupname: name of the consumer group.
     |
     |      For more information, see https://redis.io/commands/xpending
     |
     |  xpending_range(self, name: 'KeyT', groupname: 'GroupT', min: 'StreamIdT', max: 'StreamIdT', count: 'int', consumername: 'ConsumerT | None' = None, idle: 'int | None' = None) -> 'XPendingRangeResponse | Awaitable[XPendingRangeResponse]'
     |      Returns information about pending messages, in a range.
     |
     |      name: name of the stream.
     |      groupname: name of the consumer group.
     |      idle: available from  version 6.2. filter entries by their
     |      idle-time, given in milliseconds (optional).
     |      min: minimum stream ID.
     |      max: maximum stream ID.
     |      count: number of messages to return
     |      consumername: name of a consumer to filter by (optional).
     |
     |  xrange(self, name: 'KeyT', min: 'StreamIdT' = '-', max: 'StreamIdT' = '+', count: 'int | None' = None) -> 'StreamRangeResponse | None | Awaitable[StreamRangeResponse | None]'
     |      Read stream values within an interval.
     |
     |      name: name of the stream.
     |
     |      start: first stream ID. defaults to '-',
     |             meaning the earliest available.
     |
     |      finish: last stream ID. defaults to '+',
     |              meaning the latest available.
     |
     |      count: if set, only return this many items, beginning with the
     |             earliest available.
     |
     |      For more information, see https://redis.io/commands/xrange
     |
     |  xread(self, streams: 'Dict[KeyT, StreamIdT]', count: 'int | None' = None, block: 'int | None' = None, max_count: 'int | None' = None, max_size: 'int | None' = None) -> 'XReadResponse | Awaitable[XReadResponse]'
     |      Block and monitor multiple streams for new data.
     |
     |      streams: a dict of stream names to stream IDs, where
     |                 IDs indicate the last ID already seen.
     |
     |      count: if set, only return this many items per stream, beginning with
     |             the earliest available.
     |
     |      block: number of milliseconds to wait, if nothing already present.
     |
     |      max_count: if set, cap the total number of entries returned across all
     |                 streams combined. Unlike ``count`` (a per-stream limit),
     |                 this is a cumulative cap over the whole reply. Must be a
     |                 positive integer and, when ``count`` is also set, must be
     |                 greater than or equal to ``count``. Requires Redis >= 8.10.0.
     |
     |      max_size: if set, a soft cap on the total server reply size in bytes
     |                across all streams combined. Measured server-side including
     |                protocol overhead, so it is not an exact application-payload
     |                size guarantee; a single available entry larger than the cap
     |                may still be returned. Must be a positive integer. Requires
     |                Redis >= 8.10.0.
     |
     |      For more information, see https://redis.io/commands/xread
     |
     |  xreadgroup(self, groupname: 'str', consumername: 'str', streams: 'Dict[KeyT, StreamIdT]', count: 'int | None' = None, block: 'int | None' = None, noack: 'bool' = False, claim_min_idle_time: 'int | None' = None, max_count: 'int | None' = None, max_size: 'int | None' = None) -> 'XReadGroupResponse | Awaitable[XReadGroupResponse]'
     |      Read from a stream via a consumer group.
     |
     |      groupname: name of the consumer group.
     |
     |      consumername: name of the requesting consumer.
     |
     |      streams: a dict of stream names to stream IDs, where
     |             IDs indicate the last ID already seen.
     |
     |      count: if set, only return this many items per stream, beginning with
     |             the earliest available.
     |
     |      block: number of milliseconds to wait, if nothing already present.
     |      noack: do not add messages to the PEL
     |
     |      claim_min_idle_time: accepts an integer type and represents a
     |                           time interval in milliseconds
     |
     |      max_count: if set, cap the total number of entries returned across all
     |                 streams combined. Unlike ``count`` (a per-stream limit),
     |                 this is a cumulative cap over the whole reply. Must be a
     |                 positive integer and, when ``count`` is also set, must be
     |                 greater than or equal to ``count``. Requires Redis 8.10.0.
     |
     |      max_size: if set, a soft cap on the total server reply size in bytes
     |                across all streams combined. Measured server-side including
     |                protocol overhead, so it is not an exact application-payload
     |                size guarantee; a single available entry larger than the cap
     |                may still be returned. Must be a positive integer. Requires
     |                Redis 8.10.0.
     |
     |      For more information, see https://redis.io/commands/xreadgroup
     |
     |  xrevrange(self, name: 'KeyT', max: 'StreamIdT' = '+', min: 'StreamIdT' = '-', count: 'int | None' = None) -> 'StreamRangeResponse | None | Awaitable[StreamRangeResponse | None]'
     |      Read stream values within an interval, in reverse order.
     |
     |      name: name of the stream
     |
     |      start: first stream ID. defaults to '+',
     |             meaning the latest available.
     |
     |      finish: last stream ID. defaults to '-',
     |              meaning the earliest available.
     |
     |      count: if set, only return this many items, beginning with the
     |             latest available.
     |
     |      For more information, see https://redis.io/commands/xrevrange
     |
     |  xtrim(self, name: 'KeyT', maxlen: 'int | None' = None, approximate: 'bool' = True, minid: 'StreamIdT | None' = None, limit: 'int | None' = None, ref_policy: "Literal['KEEPREF', 'DELREF', 'ACKED'] | None" = None) -> 'int | Awaitable[int]'
     |      Trims old messages from a stream.
     |      name: name of the stream.
     |      maxlen: truncate old stream messages beyond this size
     |      Can't be specified with minid.
     |      approximate: actual stream length may be slightly more than maxlen
     |      minid: the minimum id in the stream to query
     |      Can't be specified with maxlen.
     |      limit: specifies the maximum number of entries to retrieve
     |      ref_policy: optional reference policy for consumer groups:
     |          - KEEPREF (default): Trims entries but preserves references in consumer groups' PEL
     |          - DELREF: Trims entries and removes all references from consumer groups' PEL
     |          - ACKED: Only trims entries that were read and acknowledged by all consumer groups
     |
     |      For more information, see https://redis.io/commands/xtrim
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from redis.commands.core.SortedSetCommands:
     |
     |  bzmpop(self, timeout: 'float', numkeys: 'int', keys: 'List[str]', min: 'bool | None' = False, max: 'bool | None' = False, count: 'int | None' = 1) -> 'ZMPopResponse | Awaitable[ZMPopResponse]'
     |      Pop ``count`` values (default 1) off of the first non-empty sorted set
     |      named in the ``keys`` list.
     |
     |      If none of the sorted sets in ``keys`` has a value to pop,
     |      then block for ``timeout`` seconds, or until a member gets added
     |      to one of the sorted sets.
     |
     |      If timeout is 0, then block indefinitely.
     |
     |      For more information, see https://redis.io/commands/bzmpop
     |
     |  bzpopmax(self, keys: 'KeysT', timeout: 'TimeoutSecT' = 0) -> 'BlockingZSetPopResponse | Awaitable[BlockingZSetPopResponse]'
     |      ZPOPMAX a value off of the first non-empty sorted set
     |      named in the ``keys`` list.
     |
     |      If none of the sorted sets in ``keys`` has a value to ZPOPMAX,
     |      then block for ``timeout`` seconds, or until a member gets added
     |      to one of the sorted sets.
     |
     |      If timeout is 0, then block indefinitely.
     |
     |      For more information, see https://redis.io/commands/bzpopmax
     |
     |  bzpopmin(self, keys: 'KeysT', timeout: 'TimeoutSecT' = 0) -> 'BlockingZSetPopResponse | Awaitable[BlockingZSetPopResponse]'
     |      ZPOPMIN a value off of the first non-empty sorted set
     |      named in the ``keys`` list.
     |
     |      If none of the sorted sets in ``keys`` has a value to ZPOPMIN,
     |      then block for ``timeout`` seconds, or until a member gets added
     |      to one of the sorted sets.
     |
     |      If timeout is 0, then block indefinitely.
     |
     |      For more information, see https://redis.io/commands/bzpopmin
     |
     |  zadd(self, name: 'KeyT', mapping: 'Mapping[AnyKeyT, EncodableT]', nx: 'bool' = False, xx: 'bool' = False, ch: 'bool' = False, incr: 'bool' = False, gt: 'bool' = False, lt: 'bool' = False) -> 'int | float | None | Awaitable[int | float | None]'
     |      Set any number of element-name, score pairs to the key ``name``. Pairs
     |      are specified as a dict of element-names keys to score values.
     |
     |      ``nx`` forces ZADD to only create new elements and not to update
     |      scores for elements that already exist.
     |
     |      ``xx`` forces ZADD to only update scores of elements that already
     |      exist. New elements will not be added.
     |
     |      ``ch`` modifies the return value to be the numbers of elements changed.
     |      Changed elements include new elements that were added and elements
     |      whose scores changed.
     |
     |      ``incr`` modifies ZADD to behave like ZINCRBY. In this mode only a
     |      single element/score pair can be specified and the score is the amount
     |      the existing score will be incremented by. When using this mode the
     |      return value of ZADD will be the new score of the element.
     |
     |      ``lt`` only updates existing elements if the new score is less than
     |      the current score. This flag doesn't prevent adding new elements.
     |
     |      ``gt`` only updates existing elements if the new score is greater than
     |      the current score. This flag doesn't prevent adding new elements.
     |
     |      The return value of ZADD varies based on the mode specified. With no
     |      options, ZADD returns the number of new elements added to the sorted
     |      set.
     |
     |      ``nx``, ``lt``, and ``gt`` are mutually exclusive options.
     |
     |      See: https://redis.io/commands/ZADD
     |
     |  zcard(self, name: 'KeyT') -> 'int | Awaitable[int]'
     |      Return the number of elements in the sorted set ``name``
     |
     |      For more information, see https://redis.io/commands/zcard
     |
     |  zcount(self, name: 'KeyT', min: 'ZScoreBoundT', max: 'ZScoreBoundT') -> 'int | Awaitable[int]'
     |      Returns the number of elements in the sorted set at key ``name`` with
     |      a score between ``min`` and ``max``.
     |
     |      For more information, see https://redis.io/commands/zcount
     |
     |  zdiff(self, keys: 'KeysT', withscores: 'bool' = False) -> 'ZSetRangeResponse | Awaitable[ZSetRangeResponse]'
     |      Returns the difference between the first and all successive input
     |      sorted sets provided in ``keys``.
     |
     |      For more information, see https://redis.io/commands/zdiff
     |
     |  zdiffstore(self, dest: 'KeyT', keys: 'KeysT') -> 'int | Awaitable[int]'
     |      Computes the difference between the first and all successive input
     |      sorted sets provided in ``keys`` and stores the result in ``dest``.
     |
     |      For more information, see https://redis.io/commands/zdiffstore
     |
     |  zincrby(self, name: 'KeyT', amount: 'float', value: 'EncodableT') -> 'float | None | Awaitable[float | None]'
     |      Increment the score of ``value`` in sorted set ``name`` by ``amount``
     |
     |      For more information, see https://redis.io/commands/zincrby
     |
     |  zinter(self, keys: 'KeysT', aggregate: 'str | None' = None, withscores: 'bool' = False) -> 'ZSetRangeResponse | Awaitable[ZSetRangeResponse]'
     |      Return the intersect of multiple sorted sets specified by ``keys``.
     |
     |      With the ``aggregate`` option, it is possible to specify how the
     |      results of the intersection are aggregated. Available aggregation
     |      modes:
     |
     |      - ``SUM`` (default): the score of an element is summed across the
     |        inputs where it exists.
     |        Score = SUM(score₁×weight₁, score₂×weight₂, ...)
     |      - ``MIN``: the resulting set will contain the minimum score of an
     |        element across the inputs where it exists.
     |        Score = MIN(score₁×weight₁, score₂×weight₂, ...)
     |      - ``MAX``: the resulting set will contain the maximum score of an
     |        element across the inputs where it exists.
     |        Score = MAX(score₁×weight₁, score₂×weight₂, ...)
     |      - ``COUNT``: ignores the original scores and counts weighted set
     |        membership. Each element's score is the sum of the weights of
     |        the input sets that contain it.
     |        Score = SUM(weight₁, weight₂, ...) for sets containing the element.
     |        When all weights are 1 (default), the score equals the number
     |        of input sets containing the element.
     |
     |      For more information, see https://redis.io/commands/zinter
     |
     |  zintercard(self, numkeys: 'int', keys: 'List[str]', limit: 'int' = 0) -> 'int | Awaitable[int]'
     |      Return the cardinality of the intersect of multiple sorted sets
     |      specified by ``keys``.
     |      When LIMIT provided (defaults to 0 and means unlimited), if the intersection
     |      cardinality reaches limit partway through the computation, the algorithm will
     |      exit and yield limit as the cardinality
     |
     |      For more information, see https://redis.io/commands/zintercard
     |
     |  zinterstore(self, dest: 'KeyT', keys: 'Sequence[KeyT] | Mapping[AnyKeyT, float]', aggregate: 'str | None' = None) -> 'int | Awaitable[int]'
     |      Intersect multiple sorted sets specified by ``keys`` into a new
     |      sorted set, ``dest``. Scores in the destination will be aggregated
     |      based on the ``aggregate``.
     |
     |      Available aggregation modes:
     |
     |      - ``SUM`` (default): the score of an element is summed across the
     |        inputs where it exists.
     |        Score = SUM(score₁×weight₁, score₂×weight₂, ...)
     |      - ``MIN``: the resulting set will contain the minimum score of an
     |        element across the inputs where it exists.
     |        Score = MIN(score₁×weight₁, score₂×weight₂, ...)
     |      - ``MAX``: the resulting set will contain the maximum score of an
     |        element across the inputs where it exists.
     |        Score = MAX(score₁×weight₁, score₂×weight₂, ...)
     |      - ``COUNT``: ignores the original scores and counts weighted set
     |        membership. Each element's score is the sum of the weights of
     |        the input sets that contain it.
     |        Score = SUM(weight₁, weight₂, ...) for sets containing the element.
     |        When all weights are 1 (default), the score equals the number
     |        of input sets containing the element.
     |
     |      For more information, see https://redis.io/commands/zinterstore
     |
     |  zlexcount(self, name: 'KeyT', min: 'EncodableT', max: 'EncodableT') -> 'int | Awaitable[int]'
     |      Return the number of items in the sorted set ``name`` between the
     |      lexicographical range ``min`` and ``max``.
     |
     |      For more information, see https://redis.io/commands/zlexcount
     |
     |  zmpop(self, num_keys: 'int', keys: 'List[str]', min: 'bool | None' = False, max: 'bool | None' = False, count: 'int | None' = 1) -> 'ZMPopResponse | Awaitable[ZMPopResponse]'
     |      Pop ``count`` values (default 1) off of the first non-empty sorted set
     |      named in the ``keys`` list.
     |      For more information, see https://redis.io/commands/zmpop
     |
     |  zmscore(self, key: 'KeyT', members: 'List[str]') -> 'list[float | None] | Awaitable[list[float | None]]'
     |      Returns the scores associated with the specified members
     |      in the sorted set stored at key.
     |      ``members`` should be a list of the member name.
     |      Return type is a list of score.
     |      If the member does not exist, a None will be returned
     |      in corresponding position.
     |
     |      For more information, see https://redis.io/commands/zmscore
     |
     |  zpopmax(self, name: 'KeyT', count: 'int | None' = None) -> 'ZSetRangeResponse | Awaitable[ZSetRangeResponse]'
     |      Remove and return up to ``count`` members with the highest scores
     |      from the sorted set ``name``.
     |
     |      For more information, see https://redis.io/commands/zpopmax
     |
     |  zpopmin(self, name: 'KeyT', count: 'int | None' = None) -> 'ZSetRangeResponse | Awaitable[ZSetRangeResponse]'
     |      Remove and return up to ``count`` members with the lowest scores
     |      from the sorted set ``name``.
     |
     |      For more information, see https://redis.io/commands/zpopmin
     |
     |  zrandmember(self, key: 'KeyT', count: 'int | None' = None, withscores: 'bool' = False) -> 'ZRandMemberResponse | Awaitable[ZRandMemberResponse]'
     |      Return a random element from the sorted set value stored at key.
     |
     |      ``count`` if the argument is positive, return an array of distinct
     |      fields. If called with a negative count, the behavior changes and
     |      the command is allowed to return the same field multiple times.
     |      In this case, the number of returned fields is the absolute value
     |      of the specified count.
     |
     |      ``withscores`` The optional WITHSCORES modifier changes the reply so it
     |      includes the respective scores of the randomly selected elements from
     |      the sorted set.
     |
     |      For more information, see https://redis.io/commands/zrandmember
     |
     |  zrange(self, name: 'KeyT', start: 'EncodableT', end: 'EncodableT', desc: 'bool' = False, withscores: 'bool' = False, score_cast_func: 'type | Callable' = <class 'float'>, byscore: 'bool' = False, bylex: 'bool' = False, offset: 'int | None' = None, num: 'int | None' = None) -> 'ZSetRangeResponse | Awaitable[ZSetRangeResponse]'
     |      Return a range of values from sorted set ``name`` between
     |      ``start`` and ``end`` sorted in ascending order.
     |
     |      ``start`` and ``end`` can be negative, indicating the end of the range.
     |
     |      ``desc`` a boolean indicating whether to sort the results in reversed
     |      order.
     |
     |      ``withscores`` indicates to return the scores along with the values.
     |      The return type is a list of (value, score) pairs.
     |
     |      ``score_cast_func`` a callable used to cast the score return value.
     |
     |      ``byscore`` when set to True, returns the range of elements from the
     |      sorted set having scores equal or between ``start`` and ``end``.
     |
     |      ``bylex`` when set to True, returns the range of elements from the
     |      sorted set between the ``start`` and ``end`` lexicographical closed
     |      range intervals.
     |      Valid ``start`` and ``end`` must start with ( or [, in order to specify
     |      whether the range interval is exclusive or inclusive, respectively.
     |
     |      ``offset`` and ``num`` are specified, then return a slice of the range.
     |      Can't be provided when using ``bylex``.
     |
     |      For more information, see https://redis.io/commands/zrange
     |
     |  zrangebylex(self, name: 'KeyT', min: 'EncodableT', max: 'EncodableT', start: 'int | None' = None, num: 'int | None' = None) -> 'list[bytes | str] | Awaitable[list[bytes | str]]'
     |      Return the lexicographical range of values from sorted set ``name``
     |      between ``min`` and ``max``.
     |
     |      If ``start`` and ``num`` are specified, then return a slice of the
     |      range.
     |
     |      For more information, see https://redis.io/commands/zrangebylex
     |
     |  zrangebyscore(self, name: 'KeyT', min: 'ZScoreBoundT', max: 'ZScoreBoundT', start: 'int | None' = None, num: 'int | None' = None, withscores: 'bool' = False, score_cast_func: 'type | Callable' = <class 'float'>) -> 'ZSetRangeResponse | Awaitable[ZSetRangeResponse]'
     |      Return a range of values from the sorted set ``name`` with scores
     |      between ``min`` and ``max``.
     |
     |      If ``start`` and ``num`` are specified, then return a slice
     |      of the range.
     |
     |      ``withscores`` indicates to return the scores along with the values.
     |      The return type is a list of (value, score) pairs
     |
     |      `score_cast_func`` a callable used to cast the score return value
     |
     |      For more information, see https://redis.io/commands/zrangebyscore
     |
     |  zrangestore(self, dest: 'KeyT', name: 'KeyT', start: 'EncodableT', end: 'EncodableT', byscore: 'bool' = False, bylex: 'bool' = False, desc: 'bool' = False, offset: 'int | None' = None, num: 'int | None' = None) -> 'int | Awaitable[int]'
     |      Stores in ``dest`` the result of a range of values from sorted set
     |      ``name`` between ``start`` and ``end`` sorted in ascending order.
     |
     |      ``start`` and ``end`` can be negative, indicating the end of the range.
     |
     |      ``byscore`` when set to True, returns the range of elements from the
     |      sorted set having scores equal or between ``start`` and ``end``.
     |
     |      ``bylex`` when set to True, returns the range of elements from the
     |      sorted set between the ``start`` and ``end`` lexicographical closed
     |      range intervals.
     |      Valid ``start`` and ``end`` must start with ( or [, in order to specify
     |      whether the range interval is exclusive or inclusive, respectively.
     |
     |      ``desc`` a boolean indicating whether to sort the results in reversed
     |      order.
     |
     |      ``offset`` and ``num`` are specified, then return a slice of the range.
     |      Can't be provided when using ``bylex``.
     |
     |      For more information, see https://redis.io/commands/zrangestore
     |
     |  zrank(self, name: 'KeyT', value: 'EncodableT', withscore: 'bool' = False, score_cast_func: 'type | Callable' = <class 'float'>) -> 'int | list[Any] | None | Awaitable[int | list[Any] | None]'
     |      Returns a 0-based value indicating the rank of ``value`` in sorted set
     |      ``name``.
     |      The optional WITHSCORE argument supplements the command's
     |      reply with the score of the element returned.
     |
     |      ``score_cast_func`` a callable used to cast the score return value
     |
     |      For more information, see https://redis.io/commands/zrank
     |
     |  zrem(self, name: 'KeyT', *values: 'FieldT') -> 'int | Awaitable[int]'
     |      Remove member ``values`` from sorted set ``name``
     |
     |      For more information, see https://redis.io/commands/zrem
     |
     |  zremrangebylex(self, name: 'KeyT', min: 'EncodableT', max: 'EncodableT') -> 'int | Awaitable[int]'
     |      Remove all elements in the sorted set ``name`` between the
     |      lexicographical range specified by ``min`` and ``max``.
     |
     |      Returns the number of elements removed.
     |
     |      For more information, see https://redis.io/commands/zremrangebylex
     |
     |  zremrangebyrank(self, name: 'KeyT', min: 'int', max: 'int') -> 'int | Awaitable[int]'
     |      Remove all elements in the sorted set ``name`` with ranks between
     |      ``min`` and ``max``. Values are 0-based, ordered from smallest score
     |      to largest. Values can be negative indicating the highest scores.
     |      Returns the number of elements removed
     |
     |      For more information, see https://redis.io/commands/zremrangebyrank
     |
     |  zremrangebyscore(self, name: 'KeyT', min: 'ZScoreBoundT', max: 'ZScoreBoundT') -> 'int | Awaitable[int]'
     |      Remove all elements in the sorted set ``name`` with scores
     |      between ``min`` and ``max``. Returns the number of elements removed.
     |
     |      For more information, see https://redis.io/commands/zremrangebyscore
     |
     |  zrevrange(self, name: 'KeyT', start: 'int', end: 'int', withscores: 'bool' = False, score_cast_func: 'type | Callable' = <class 'float'>) -> 'ZSetRangeResponse | Awaitable[ZSetRangeResponse]'
     |      Return a range of values from sorted set ``name`` between
     |      ``start`` and ``end`` sorted in descending order.
     |
     |      ``start`` and ``end`` can be negative, indicating the end of the range.
     |
     |      ``withscores`` indicates to return the scores along with the values
     |      The return type is a list of (value, score) pairs
     |
     |      ``score_cast_func`` a callable used to cast the score return value
     |
     |      For more information, see https://redis.io/commands/zrevrange
     |
     |  zrevrangebylex(self, name: 'KeyT', max: 'EncodableT', min: 'EncodableT', start: 'int | None' = None, num: 'int | None' = None) -> 'list[bytes | str] | Awaitable[list[bytes | str]]'
     |      Return the reversed lexicographical range of values from sorted set
     |      ``name`` between ``max`` and ``min``.
     |
     |      If ``start`` and ``num`` are specified, then return a slice of the
     |      range.
     |
     |      For more information, see https://redis.io/commands/zrevrangebylex
     |
     |  zrevrangebyscore(self, name: 'KeyT', max: 'ZScoreBoundT', min: 'ZScoreBoundT', start: 'int | None' = None, num: 'int | None' = None, withscores: 'bool' = False, score_cast_func: 'type | Callable' = <class 'float'>) -> 'ZSetRangeResponse | Awaitable[ZSetRangeResponse]'
     |      Return a range of values from the sorted set ``name`` with scores
     |      between ``min`` and ``max`` in descending order.
     |
     |      If ``start`` and ``num`` are specified, then return a slice
     |      of the range.
     |
     |      ``withscores`` indicates to return the scores along with the values.
     |      The return type is a list of (value, score) pairs
     |
     |      ``score_cast_func`` a callable used to cast the score return value
     |
     |      For more information, see https://redis.io/commands/zrevrangebyscore
     |
     |  zrevrank(self, name: 'KeyT', value: 'EncodableT', withscore: 'bool' = False, score_cast_func: 'type | Callable' = <class 'float'>) -> 'int | list[Any] | None | Awaitable[int | list[Any] | None]'
     |      Returns a 0-based value indicating the descending rank of
     |      ``value`` in sorted set ``name``.
     |      The optional ``withscore`` argument supplements the command's
     |      reply with the score of the element returned.
     |
     |      ``score_cast_func`` a callable used to cast the score return value
     |
     |      For more information, see https://redis.io/commands/zrevrank
     |
     |  zscore(self, name: 'KeyT', value: 'EncodableT') -> 'float | None | Awaitable[float | None]'
     |      Return the score of element ``value`` in sorted set ``name``
     |
     |      For more information, see https://redis.io/commands/zscore
     |
     |  zunion(self, keys: 'Sequence[KeyT] | Mapping[AnyKeyT, float]', aggregate: 'str | None' = None, withscores: 'bool' = False, score_cast_func: 'type | Callable' = <class 'float'>) -> 'ZSetRangeResponse | Awaitable[ZSetRangeResponse]'
     |      Return the union of multiple sorted sets specified by ``keys``.
     |      ``keys`` can be provided as dictionary of keys and their weights.
     |      Scores will be aggregated based on the ``aggregate``, or SUM if
     |      none is provided.
     |
     |      Available aggregation modes:
     |
     |      - ``SUM`` (default): the score of an element is summed across the
     |        inputs where it exists.
     |        Score = SUM(score₁×weight₁, score₂×weight₂, ...)
     |      - ``MIN``: the resulting set will contain the minimum score of an
     |        element across the inputs where it exists.
     |        Score = MIN(score₁×weight₁, score₂×weight₂, ...)
     |      - ``MAX``: the resulting set will contain the maximum score of an
     |        element across the inputs where it exists.
     |        Score = MAX(score₁×weight₁, score₂×weight₂, ...)
     |      - ``COUNT``: ignores the original scores and counts weighted set
     |        membership. Each element's score is the sum of the weights of
     |        the input sets that contain it.
     |        Score = SUM(weight₁, weight₂, ...) for sets containing the element.
     |        When all weights are 1 (default), the score equals the number
     |        of input sets containing the element.
     |
     |      ``score_cast_func`` a callable used to cast the score return value
     |
     |      For more information, see https://redis.io/commands/zunion
     |
     |  zunionstore(self, dest: 'KeyT', keys: 'Sequence[KeyT] | Mapping[AnyKeyT, float]', aggregate: 'str | None' = None) -> 'int | Awaitable[int]'
     |      Union multiple sorted sets specified by ``keys`` into
     |      a new sorted set, ``dest``. Scores in the destination will be
     |      aggregated based on the ``aggregate``, or SUM if none is provided.
     |
     |      Available aggregation modes:
     |
     |      - ``SUM`` (default): the score of an element is summed across the
     |        inputs where it exists.
     |        Score = SUM(score₁×weight₁, score₂×weight₂, ...)
     |      - ``MIN``: the resulting set will contain the minimum score of an
     |        element across the inputs where it exists.
     |        Score = MIN(score₁×weight₁, score₂×weight₂, ...)
     |      - ``MAX``: the resulting set will contain the maximum score of an
     |        element across the inputs where it exists.
     |        Score = MAX(score₁×weight₁, score₂×weight₂, ...)
     |      - ``COUNT``: ignores the original scores and counts weighted set
     |        membership. Each element's score is the sum of the weights of
     |        the input sets that contain it.
     |        Score = SUM(weight₁, weight₂, ...) for sets containing the element.
     |        When all weights are 1 (default), the score equals the number
     |        of input sets containing the element.
     |
     |      For more information, see https://redis.io/commands/zunionstore
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from redis.commands.core.AsyncManagementCommands:
     |
     |  async command_info(self, **kwargs) -> 'None'
     |
     |  async debug_segfault(self, **kwargs) -> 'None'
     |
     |  async memory_doctor(self, **kwargs) -> 'None'
     |
     |  async memory_help(self, **kwargs) -> 'None'
     |
     |  async shutdown(self, save: 'bool' = False, nosave: 'bool' = False, now: 'bool' = False, force: 'bool' = False, abort: 'bool' = False, **kwargs) -> 'None'
     |      Shutdown the Redis server.  If Redis has persistence configured,
     |      data will be flushed before shutdown.  If the "save" option is set,
     |      a data flush will be attempted even if there is no persistence
     |      configured.  If the "nosave" option is set, no data flush will be
     |      attempted.  The "save" and "nosave" options cannot both be set.
     |
     |      For more information, see https://redis.io/commands/shutdown
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from redis.commands.core.ManagementCommands:
     |
     |  auth(self, password: 'str', username: 'str | None' = None, **kwargs) -> 'bool | Awaitable[bool]'
     |      Authenticates the user. If you do not pass username, Redis will try to
     |      authenticate for the "default" user. If you do pass username, it will
     |      authenticate for the given user.
     |      For more information, see https://redis.io/commands/auth
     |
     |  bgrewriteaof(self, **kwargs) -> 'bool | bytes | str | Awaitable[bool | bytes | str]'
     |      Tell the Redis server to rewrite the AOF file from data in memory.
     |
     |      For more information, see https://redis.io/commands/bgrewriteaof
     |
     |  bgsave(self, schedule: 'bool' = True, **kwargs) -> 'bool | bytes | str | Awaitable[bool | bytes | str]'
     |      Tell the Redis server to save its data to disk.  Unlike save(),
     |      this method is asynchronous and returns immediately.
     |
     |      For more information, see https://redis.io/commands/bgsave
     |
     |  client_getname(self, **kwargs) -> 'bytes | str | None | Awaitable[bytes | str | None]'
     |      Returns the current connection name
     |
     |      For more information, see https://redis.io/commands/client-getname
     |
     |  client_getredir(self, **kwargs) -> 'int | Awaitable[int]'
     |      Returns the ID (an integer) of the client to whom we are
     |      redirecting tracking notifications.
     |
     |      see: https://redis.io/commands/client-getredir
     |
     |  client_id(self, **kwargs) -> 'int | Awaitable[int]'
     |      Returns the current connection id
     |
     |      For more information, see https://redis.io/commands/client-id
     |
     |  client_info(self, **kwargs) -> 'dict[str, str | int] | Awaitable[dict[str, str | int]]'
     |      Returns information and statistics about the current
     |      client connection.
     |
     |      For more information, see https://redis.io/commands/client-info
     |
     |  client_kill(self, address: 'str', **kwargs) -> 'bool | int | Awaitable[bool | int]'
     |      Disconnects the client at ``address`` (ip:port)
     |
     |      For more information, see https://redis.io/commands/client-kill
     |
     |  client_kill_filter(self, _id: 'str | None' = None, _type: 'str | None' = None, addr: 'str | None' = None, skipme: 'bool | None' = None, laddr: 'bool | None' = None, user: 'str | None' = None, maxage: 'int | None' = None, **kwargs) -> 'int | Awaitable[int]'
     |      Disconnects client(s) using a variety of filter options
     |      :param _id: Kills a client by its unique ID field
     |      :param _type: Kills a client by type where type is one of 'normal',
     |      'master', 'slave', 'replica' or 'pubsub'
     |      :param addr: Kills a client by its 'address:port'
     |      :param skipme: If True, then the client calling the command
     |      will not get killed even if it is identified by one of the filter
     |      options. If skipme is not provided, the server defaults to skipme=True
     |      :param laddr: Kills a client by its 'local (bind) address:port'
     |      :param user: Kills a client for a specific user name
     |      :param maxage: Kills clients that are older than the specified age in seconds
     |
     |  client_list(self, _type: 'str | None' = None, client_id: 'List[EncodableT]' = [], **kwargs) -> 'list[dict[str, str]] | Awaitable[list[dict[str, str]]]'
     |      Returns a list of currently connected clients.
     |      If type of client specified, only that type will be returned.
     |
     |      :param _type: optional. one of the client types (normal, master,
     |       replica, pubsub)
     |      :param client_id: optional. a list of client ids
     |
     |      For more information, see https://redis.io/commands/client-list
     |
     |  client_no_evict(self, mode: 'str') -> 'bytes | str | Awaitable[bytes | str]'
     |      Sets the client eviction mode for the current connection.
     |
     |      For more information, see https://redis.io/commands/client-no-evict
     |
     |  client_no_touch(self, mode: 'str') -> 'bytes | str | Awaitable[bytes | str]'
     |      # The command controls whether commands sent by the client will alter
     |      # the LRU/LFU of the keys they access.
     |      # When turned on, the current client will not change LFU/LRU stats,
     |      # unless it sends the TOUCH command.
     |
     |      For more information, see https://redis.io/commands/client-no-touch
     |
     |  client_pause(self, timeout: 'int', all: 'bool' = True, **kwargs) -> 'bool | Awaitable[bool]'
     |      Suspend all the Redis clients for the specified amount of time.
     |
     |
     |      For more information, see https://redis.io/commands/client-pause
     |
     |      Args:
     |          timeout: milliseconds to pause clients
     |          all: If true (default) all client commands are blocked.
     |               otherwise, clients are only blocked if they attempt to execute
     |               a write command.
     |
     |      For the WRITE mode, some commands have special behavior:
     |
     |      * EVAL/EVALSHA: Will block client for all scripts.
     |      * PUBLISH: Will block client.
     |      * PFCOUNT: Will block client.
     |      * WAIT: Acknowledgments will be delayed, so this command will
     |          appear blocked.
     |
     |  client_reply(self, reply: "Literal['ON', 'OFF', 'SKIP']", **kwargs) -> 'bytes | str | Awaitable[bytes | str]'
     |      Enable and disable redis server replies.
     |
     |      ``reply`` Must be ON OFF or SKIP,
     |      ON - The default most with server replies to commands
     |      OFF - Disable server responses to commands
     |      SKIP - Skip the response of the immediately following command.
     |
     |      Note: When setting OFF or SKIP replies, you will need a client object
     |      with a timeout specified in seconds, and will need to catch the
     |      TimeoutError.
     |      The test_client_reply unit test illustrates this, and
     |      conftest.py has a client with a timeout.
     |
     |      See https://redis.io/commands/client-reply
     |
     |  client_setinfo(self, attr: 'str', value: 'str', **kwargs) -> 'bool | Awaitable[bool]'
     |      Sets the current connection library name or version
     |      For more information see https://redis.io/commands/client-setinfo
     |
     |  client_setname(self, name: 'str', **kwargs) -> 'bool | Awaitable[bool]'
     |      Sets the current connection name
     |
     |      For more information, see https://redis.io/commands/client-setname
     |
     |      .. note::
     |         This method sets client name only for **current** connection.
     |
     |         If you want to set a common name for all connections managed
     |         by this client, use ``client_name`` constructor argument.
     |
     |  client_tracking(self, on: 'bool' = True, clientid: 'int | None' = None, prefix: 'Sequence[KeyT]' = [], bcast: 'bool' = False, optin: 'bool' = False, optout: 'bool' = False, noloop: 'bool' = False, **kwargs) -> 'bytes | str | Awaitable[bytes | str]'
     |      Enables the tracking feature of the Redis server, that is used
     |      for server assisted client side caching.
     |
     |      ``on`` indicate for tracking on or tracking off. The default is on.
     |
     |      ``clientid`` send invalidation messages to the connection with
     |      the specified ID.
     |
     |      ``bcast`` enable tracking in broadcasting mode. In this mode
     |      invalidation messages are reported for all the prefixes
     |      specified, regardless of the keys requested by the connection.
     |
     |      ``optin``  when broadcasting is NOT active, normally don't track
     |      keys in read only commands, unless they are called immediately
     |      after a CLIENT CACHING yes command.
     |
     |      ``optout`` when broadcasting is NOT active, normally track keys in
     |      read only commands, unless they are called immediately after a
     |      CLIENT CACHING no command.
     |
     |      ``noloop`` don't send notifications about keys modified by this
     |      connection itself.
     |
     |      ``prefix``  for broadcasting, register a given key prefix, so that
     |      notifications will be provided only for keys starting with this string.
     |
     |      See https://redis.io/commands/client-tracking
     |
     |  client_tracking_off(self, clientid: 'int | None' = None, prefix: 'Sequence[KeyT]' = [], bcast: 'bool' = False, optin: 'bool' = False, optout: 'bool' = False, noloop: 'bool' = False) -> 'bytes | str | Awaitable[bytes | str]'
     |      Turn off the tracking mode.
     |      For more information, about the options look at client_tracking func.
     |
     |      See https://redis.io/commands/client-tracking
     |
     |  client_tracking_on(self, clientid: 'int | None' = None, prefix: 'Sequence[KeyT]' = [], bcast: 'bool' = False, optin: 'bool' = False, optout: 'bool' = False, noloop: 'bool' = False) -> 'bytes | str | Awaitable[bytes | str]'
     |      Turn on the tracking mode.
     |      For more information, about the options look at client_tracking func.
     |
     |      See https://redis.io/commands/client-tracking
     |
     |  client_trackinginfo(self, **kwargs) -> 'ClientTrackingInfoResponse | Awaitable[ClientTrackingInfoResponse]'
     |      Returns the information about the current client connection's
     |      use of the server assisted client side cache.
     |
     |      See https://redis.io/commands/client-trackinginfo
     |
     |  client_unblock(self, client_id: 'int', error: 'bool' = False, **kwargs) -> 'bool | Awaitable[bool]'
     |      Unblocks a connection by its client id.
     |      If ``error`` is True, unblocks the client with a special error message.
     |      If ``error`` is False (default), the client is unblocked using the
     |      regular timeout mechanism.
     |
     |      For more information, see https://redis.io/commands/client-unblock
     |
     |  client_unpause(self, **kwargs) -> 'bytes | str | Awaitable[bytes | str]'
     |      Unpause all redis clients
     |
     |      For more information, see https://redis.io/commands/client-unpause
     |
     |  command(self, **kwargs) -> 'dict[str, dict[str, Any]] | Awaitable[dict[str, dict[str, Any]]]'
     |      Returns dict reply of details about all Redis commands.
     |
     |      For more information, see https://redis.io/commands/command
     |
     |  command_count(self, **kwargs) -> 'int | Awaitable[int]'
     |
     |  command_docs(self, *args)
     |      This function throws a NotImplementedError since it is intentionally
     |      not supported.
     |
     |  command_getkeysandflags(self, *args: 'str') -> 'CommandGetKeysAndFlagsResponse | Awaitable[CommandGetKeysAndFlagsResponse]'
     |      Returns array of keys from a full Redis command and their usage flags.
     |
     |      For more information, see https://redis.io/commands/command-getkeysandflags
     |
     |  command_list(self, module: 'str | None' = None, category: 'str | None' = None, pattern: 'str | None' = None) -> 'list[bytes | str] | Awaitable[list[bytes | str]]'
     |      Return an array of the server's command names.
     |      You can use one of the following filters:
     |      ``module``: get the commands that belong to the module
     |      ``category``: get the commands in the ACL category
     |      ``pattern``: get the commands that match the given pattern
     |
     |      For more information, see https://redis.io/commands/command-list/
     |
     |  config_get(self, pattern: 'PatternT' = '*', *args: 'PatternT', **kwargs) -> 'dict[str | None, str | None] | Awaitable[dict[str | None, str | None]]'
     |      Return a dictionary of configuration based on the ``pattern``
     |
     |      For more information, see https://redis.io/commands/config-get
     |
     |  config_resetstat(self, **kwargs) -> 'bool | Awaitable[bool]'
     |      Reset runtime statistics
     |
     |      For more information, see https://redis.io/commands/config-resetstat
     |
     |  config_rewrite(self, **kwargs) -> 'bytes | str | Awaitable[bytes | str]'
     |      Rewrite config file with the minimal change to reflect running config.
     |
     |      For more information, see https://redis.io/commands/config-rewrite
     |
     |  config_set(self, name: 'KeyT', value: 'EncodableT', *args: 'Union[KeyT, EncodableT]', **kwargs) -> 'bool | Awaitable[bool]'
     |      Set config item ``name`` with ``value``
     |
     |      For more information, see https://redis.io/commands/config-set
     |
     |  dbsize(self, **kwargs) -> 'int | Awaitable[int]'
     |      Returns the number of keys in the current database
     |
     |      For more information, see https://redis.io/commands/dbsize
     |
     |  debug_object(self, key: 'KeyT', **kwargs) -> 'dict[str, str | int] | bytes | str | Awaitable[dict[str, str | int] | bytes | str]'
     |      Returns version specific meta information about a given key
     |
     |      For more information, see https://redis.io/commands/debug-object
     |
     |  echo(self, value: 'EncodableT', **kwargs) -> 'bytes | str | Awaitable[bytes | str]'
     |      Echo the string back from the server
     |
     |      For more information, see https://redis.io/commands/echo
     |
     |  failover(self)
     |      This function throws a NotImplementedError since it is intentionally
     |      not supported.
     |
     |  flushall(self, asynchronous: 'bool' = False, **kwargs) -> 'bool | Awaitable[bool]'
     |      Delete all keys in all databases on the current host.
     |
     |      ``asynchronous`` indicates whether the operation is
     |      executed asynchronously by the server.
     |
     |      For more information, see https://redis.io/commands/flushall
     |
     |  flushdb(self, asynchronous: 'bool' = False, **kwargs) -> 'bool | Awaitable[bool]'
     |      Delete all keys in the current database.
     |
     |      ``asynchronous`` indicates whether the operation is
     |      executed asynchronously by the server.
     |
     |      For more information, see https://redis.io/commands/flushdb
     |
     |  hello(self)
     |      This function throws a NotImplementedError since it is intentionally
     |      not supported.
     |
     |  hotkeys_get(self, **kwargs) -> 'Union[Awaitable[list[dict[str | bytes, Any]]], list[dict[str | bytes, Any]]]'
     |      Retrieve the result of the ongoing collection session (if any),
     |      or the last collection session (if any).
     |
     |      HOTKEYS GET response is wrapped in an array for aggregation support.
     |      Each node returns a single-element array, allowing multiple node
     |      responses to be concatenated by DMC or other aggregators.
     |
     |      For more information, see https://redis.io/commands/hotkeys-get
     |
     |  hotkeys_reset(self, **kwargs) -> 'bytes | str | Awaitable[bytes | str]'
     |      Discard the last hotkeys collection session results (in order to save memory).
     |      Error if there is an ongoing collection session.
     |
     |      For more information, see https://redis.io/commands/hotkeys-reset
     |
     |  hotkeys_start(self, metrics: 'List[HotkeysMetricsTypes]', count: 'int | None' = None, duration: 'int | None' = None, sample_ratio: 'int | None' = None, slots: 'List[int] | None' = None, **kwargs) -> 'bytes | str | Awaitable[bytes | str]'
     |      Start collecting hotkeys data.
     |      Returns an error if there is an ongoing collection session.
     |
     |      Args:
     |          count: The number of keys to collect in each criteria (CPU and network consumption)
     |          metrics: List of metrics to track. Supported values: [HotkeysMetricsTypes.CPU, HotkeysMetricsTypes.NET]
     |          duration: Automatically stop the collection after `duration` seconds
     |          sample_ratio: Commands are sampled with probability 1/ratio (1 means no sampling)
     |          slots: Only track keys on the specified hash slots
     |
     |      For more information, see https://redis.io/commands/hotkeys-start
     |
     |  hotkeys_stop(self, **kwargs) -> 'bytes | str | Awaitable[bytes | str]'
     |      Stop the ongoing hotkeys collection session (if any).
     |      The results of the last collection session are kept for consumption with HOTKEYS GET.
     |
     |      For more information, see https://redis.io/commands/hotkeys-stop
     |
     |  info(self, section: 'Optional[str]' = None, *args: 'str', **kwargs) -> 'dict[str, Any] | Awaitable[dict[str, Any]]'
     |      Returns a dictionary containing information about the Redis server
     |
     |      The ``section`` option can be used to select a specific section
     |      of information
     |
     |      The section option is not supported by older versions of Redis Server,
     |      and will generate ResponseError
     |
     |      For more information, see https://redis.io/commands/info
     |
     |  lastsave(self, **kwargs) -> 'datetime.datetime | Awaitable[datetime.datetime]'
     |      Return a Python datetime object representing the last time the
     |      Redis database was saved to disk
     |
     |      For more information, see https://redis.io/commands/lastsave
     |
     |  latency_doctor(self)
     |      Raise a NotImplementedError, as the client will not support LATENCY DOCTOR.
     |      This function is best used within the redis-cli.
     |
     |      For more information, see https://redis.io/commands/latency-doctor
     |
     |  latency_graph(self)
     |      Raise a NotImplementedError, as the client will not support LATENCY GRAPH.
     |      This function is best used within the redis-cli.
     |
     |      For more information, see https://redis.io/commands/latency-graph.
     |
     |  latency_histogram(self, *args)
     |      This function throws a NotImplementedError since it is intentionally
     |      not supported.
     |
     |  latency_history(self, event: 'str') -> 'list[list[int]] | Awaitable[list[list[int]]]'
     |      Returns the raw data of the ``event``'s latency spikes time series.
     |
     |      For more information, see https://redis.io/commands/latency-history
     |
     |  latency_latest(self) -> 'list[list[bytes | str | int]] | Awaitable[list[list[bytes | str | int]]]'
     |      Reports the latest latency events logged.
     |
     |      For more information, see https://redis.io/commands/latency-latest
     |
     |  latency_reset(self, *events: 'str') -> 'int | Awaitable[int]'
     |      Resets the latency spikes time series of all, or only some, events.
     |
     |      For more information, see https://redis.io/commands/latency-reset
     |
     |  lolwut(self, *version_numbers: 'Union[str, float]', **kwargs) -> 'bytes | str | Awaitable[bytes | str]'
     |      Get the Redis version and a piece of generative computer art
     |
     |      See: https://redis.io/commands/lolwut
     |
     |  memory_malloc_stats(self, **kwargs) -> 'bytes | str | Awaitable[bytes | str]'
     |      Return an internal statistics report from the memory allocator.
     |
     |      See: https://redis.io/commands/memory-malloc-stats
     |
     |  memory_purge(self, **kwargs) -> 'bool | Awaitable[bool]'
     |      Attempts to purge dirty pages for reclamation by allocator
     |
     |      For more information, see https://redis.io/commands/memory-purge
     |
     |  memory_stats(self, **kwargs) -> 'dict[str, Any] | Awaitable[dict[str, Any]]'
     |      Return a dictionary of memory stats
     |
     |      For more information, see https://redis.io/commands/memory-stats
     |
     |  memory_usage(self, key: 'KeyT', samples: 'int | None' = None, **kwargs) -> 'int | None | Awaitable[int | None]'
     |      Return the total memory usage for key, its value and associated
     |      administrative overheads.
     |
     |      For nested data structures, ``samples`` is the number of elements to
     |      sample. If left unspecified, the server's default is 5. Use 0 to sample
     |      all elements.
     |
     |      For more information, see https://redis.io/commands/memory-usage
     |
     |  migrate(self, host: 'str', port: 'int', keys: 'KeysT', destination_db: 'int', timeout: 'int', copy: 'bool' = False, replace: 'bool' = False, auth: 'str | None' = None, **kwargs) -> 'bytes | str | Awaitable[bytes | str]'
     |      Migrate 1 or more keys from the current Redis server to a different
     |      server specified by the ``host``, ``port`` and ``destination_db``.
     |
     |      The ``timeout``, specified in milliseconds, indicates the maximum
     |      time the connection between the two servers can be idle before the
     |      command is interrupted.
     |
     |      If ``copy`` is True, the specified ``keys`` are NOT deleted from
     |      the source server.
     |
     |      If ``replace`` is True, this operation will overwrite the keys
     |      on the destination server if they exist.
     |
     |      If ``auth`` is specified, authenticate to the destination server with
     |      the password provided.
     |
     |      For more information, see https://redis.io/commands/migrate
     |
     |  object(self, infotype: 'str', key: 'KeyT', **kwargs) -> 'Any | Awaitable[Any]'
     |      Return the encoding, idletime, or refcount about the key
     |
     |  ping(self, **kwargs) -> 'Union[Awaitable[bool], bool]'
     |      Ping the Redis server to test connectivity.
     |
     |      Sends a PING command to the Redis server and returns True if the server
     |      responds with "PONG".
     |
     |      This command is useful for:
     |      - Testing whether a connection is still alive
     |      - Verifying the server's ability to serve data
     |
     |      For more information on the underlying ping command see https://redis.io/commands/ping
     |
     |  psync(self, replicationid: 'str', offset: 'int') -> 'bytes | Awaitable[bytes]'
     |      Initiates a replication stream from the master.
     |      Newer version for `sync`.
     |
     |      For more information, see https://redis.io/commands/sync
     |
     |  quit(self, **kwargs) -> 'bool | Awaitable[bool]'
     |      Ask the server to close the connection.
     |
     |      For more information, see https://redis.io/commands/quit
     |
     |  replicaof(self, *args, **kwargs) -> 'bytes | str | Awaitable[bytes | str]'
     |      Update the replication settings of a redis replica, on the fly.
     |
     |      Examples of valid arguments include:
     |
     |      NO ONE (set no replication)
     |      host port (set to the host and port of a redis server)
     |
     |      For more information, see  https://redis.io/commands/replicaof
     |
     |  reset(self) -> 'bytes | str | Awaitable[bytes | str]'
     |      Perform a full reset on the connection's server-side context.
     |
     |      See: https://redis.io/commands/reset
     |
     |  role(self) -> 'list[Any] | Awaitable[list[Any]]'
     |      Provide information on the role of a Redis instance in
     |      the context of replication, by returning if the instance
     |      is currently a master, slave, or sentinel.
     |
     |      For more information, see https://redis.io/commands/role
     |
     |  save(self, **kwargs) -> 'bool | Awaitable[bool]'
     |      Tell the Redis server to save its data to disk,
     |      blocking until the save is complete
     |
     |      For more information, see https://redis.io/commands/save
     |
     |  select(self, index: 'int', **kwargs) -> 'bool | Awaitable[bool]'
     |      Select the Redis logical database at index.
     |
     |      See: https://redis.io/commands/select
     |
     |  slaveof(self, host: 'str | None' = None, port: 'int | None' = None, **kwargs) -> 'bool | Awaitable[bool]'
     |      Set the server to be a replicated slave of the instance identified
     |      by the ``host`` and ``port``. If called without arguments, the
     |      instance is promoted to a master instead.
     |
     |      For more information, see https://redis.io/commands/slaveof
     |
     |  slowlog_get(self, num: 'int | None' = None, **kwargs) -> 'list[dict[str, Any]] | Awaitable[list[dict[str, Any]]]'
     |      Get the entries from the slowlog. If ``num`` is specified, get the
     |      most recent ``num`` items.
     |
     |      For more information, see https://redis.io/commands/slowlog-get
     |
     |  slowlog_len(self, **kwargs) -> 'int | Awaitable[int]'
     |      Get the number of items in the slowlog
     |
     |      For more information, see https://redis.io/commands/slowlog-len
     |
     |  slowlog_reset(self, **kwargs) -> 'bool | Awaitable[bool]'
     |      Remove all items in the slowlog
     |
     |      For more information, see https://redis.io/commands/slowlog-reset
     |
     |  swapdb(self, first: 'int', second: 'int', **kwargs) -> 'bool | Awaitable[bool]'
     |      Swap two databases
     |
     |      For more information, see https://redis.io/commands/swapdb
     |
     |  sync(self) -> 'bytes | Awaitable[bytes]'
     |      Initiates a replication stream from the master.
     |
     |      For more information, see https://redis.io/commands/sync
     |
     |  time(self, **kwargs) -> 'tuple[int, int] | Awaitable[tuple[int, int]]'
     |      Returns the server time as a 2-item tuple of ints:
     |      (seconds since epoch, microseconds into this second).
     |
     |      For more information, see https://redis.io/commands/time
     |
     |  wait(self, num_replicas: 'int', timeout: 'int', **kwargs) -> 'int | Awaitable[int]'
     |      Redis synchronous replication
     |      That returns the number of replicas that processed the query when
     |      we finally have at least ``num_replicas``, or when the ``timeout`` was
     |      reached.
     |
     |      For more information, see https://redis.io/commands/wait
     |
     |  waitaof(self, num_local: 'int', num_replicas: 'int', timeout: 'int', **kwargs) -> 'list[int] | Awaitable[list[int]]'
     |      This command blocks the current client until all previous write
     |      commands by that client are acknowledged as having been fsynced
     |      to the AOF of the local Redis and/or at least the specified number
     |      of replicas.
     |
     |      For more information, see https://redis.io/commands/waitaof
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from redis.commands.core.ModuleCommands:
     |
     |  command_getkeys(self, *args) -> 'list[bytes | str] | Awaitable[list[bytes | str]]'
     |
     |  module_list(self) -> 'list[dict[Any, Any]] | Awaitable[list[dict[Any, Any]]]'
     |      Returns a list of dictionaries containing the name and version of
     |      all loaded modules.
     |
     |      For more information, see https://redis.io/commands/module-list
     |
     |  module_load(self, path, *args) -> 'bool | Awaitable[bool]'
     |      Loads the module from ``path``.
     |      Passes all ``*args`` to the module, during loading.
     |      Raises ``ModuleError`` if a module is not found at ``path``.
     |
     |      For more information, see https://redis.io/commands/module-load
     |
     |  module_loadex(self, path: 'str', options: 'List[str] | None' = None, args: 'List[str] | None' = None) -> 'bytes | str | Awaitable[bytes | str]'
     |      Loads a module from a dynamic library at runtime with configuration directives.
     |
     |      For more information, see https://redis.io/commands/module-loadex
     |
     |  module_unload(self, name) -> 'bool | Awaitable[bool]'
     |      Unloads the module ``name``.
     |      Raises ``ModuleError`` if ``name`` is not in loaded modules.
     |
     |      For more information, see https://redis.io/commands/module-unload
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from redis.commands.core.PubSubCommands:
     |
     |  publish(self, channel: 'ChannelT', message: 'EncodableT', **kwargs) -> 'int | Awaitable[int]'
     |      Publish ``message`` on ``channel``.
     |      Returns the number of subscribers the message was delivered to.
     |
     |      For more information, see https://redis.io/commands/publish
     |
     |  pubsub_channels(self, pattern: 'PatternT' = '*', **kwargs) -> 'list[bytes | str] | Awaitable[list[bytes | str]]'
     |      Return a list of channels that have at least one subscriber
     |
     |      For more information, see https://redis.io/commands/pubsub-channels
     |
     |  pubsub_numpat(self, **kwargs) -> 'int | Awaitable[int]'
     |      Returns the number of subscriptions to patterns
     |
     |      For more information, see https://redis.io/commands/pubsub-numpat
     |
     |  pubsub_numsub(self, *args: 'ChannelT', **kwargs) -> 'list[tuple[bytes | str, int]] | Awaitable[list[tuple[bytes | str, int]]]'
     |      Return a list of (channel, number of subscribers) tuples
     |      for each channel given in ``*args``
     |
     |      For more information, see https://redis.io/commands/pubsub-numsub
     |
     |  pubsub_shardchannels(self, pattern: 'PatternT' = '*', **kwargs) -> 'list[bytes | str] | Awaitable[list[bytes | str]]'
     |      Return a list of shard_channels that have at least one subscriber
     |
     |      For more information, see https://redis.io/commands/pubsub-shardchannels
     |
     |  pubsub_shardnumsub(self, *args: 'ChannelT', **kwargs) -> 'list[tuple[bytes | str, int]] | Awaitable[list[tuple[bytes | str, int]]]'
     |      Return a list of (shard_channel, number of subscribers) tuples
     |      for each channel given in ``*args``
     |
     |      For more information, see https://redis.io/commands/pubsub-shardnumsub
     |
     |  spublish(self, shard_channel: 'ChannelT', message: 'EncodableT') -> 'int | Awaitable[int]'
     |      Posts a message to the given shard channel.
     |      Returns the number of clients that received the message
     |
     |      For more information, see https://redis.io/commands/spublish
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from redis.commands.core.AsyncScriptCommands:
     |
     |  register_script(self: "Union['redis.asyncio.client.Redis', 'redis.asyncio.cluster.RedisCluster']", script: 'ScriptTextT') -> 'AsyncScript'
     |      Register a Lua ``script`` specifying the ``keys`` it will touch.
     |      Returns a Script object that is callable and hides the complexity of
     |      deal with scripts, keys, and shas. This is the preferred way to work
     |      with Lua scripts.
     |
     |  async script_debug(self, *args) -> 'None'
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from redis.commands.core.ScriptCommands:
     |
     |  eval(self, script: 'str', numkeys: 'int', *keys_and_args: 'KeyT | EncodableT') -> 'Any | Awaitable[Any]'
     |      Execute the Lua ``script``, specifying the ``numkeys`` the script
     |      will touch and the key names and argument values in ``keys_and_args``.
     |      Returns the result of the script.
     |
     |      In practice, use the object returned by ``register_script``. This
     |      function exists purely for Redis API completion.
     |
     |      For more information, see  https://redis.io/commands/eval
     |
     |  eval_ro(self, script: 'str', numkeys: 'int', *keys_and_args: 'KeyT | EncodableT') -> 'Any | Awaitable[Any]'
     |      The read-only variant of the EVAL command
     |
     |      Execute the read-only Lua ``script`` specifying the ``numkeys`` the script
     |      will touch and the key names and argument values in ``keys_and_args``.
     |      Returns the result of the script.
     |
     |      For more information, see  https://redis.io/commands/eval_ro
     |
     |  evalsha(self, sha: 'str', numkeys: 'int', *keys_and_args: 'KeyT | EncodableT') -> 'Any | Awaitable[Any]'
     |      Use the ``sha`` to execute a Lua script already registered via EVAL
     |      or SCRIPT LOAD. Specify the ``numkeys`` the script will touch and the
     |      key names and argument values in ``keys_and_args``. Returns the result
     |      of the script.
     |
     |      In practice, use the object returned by ``register_script``. This
     |      function exists purely for Redis API completion.
     |
     |      For more information, see  https://redis.io/commands/evalsha
     |
     |  evalsha_ro(self, sha: 'str', numkeys: 'int', *keys_and_args: 'KeyT | EncodableT') -> 'Any | Awaitable[Any]'
     |      The read-only variant of the EVALSHA command
     |
     |      Use the ``sha`` to execute a read-only Lua script already registered via EVAL
     |      or SCRIPT LOAD. Specify the ``numkeys`` the script will touch and the
     |      key names and argument values in ``keys_and_args``. Returns the result
     |      of the script.
     |
     |      For more information, see  https://redis.io/commands/evalsha_ro
     |
     |  script_exists(self, *args: 'str') -> 'list[bool] | Awaitable[list[bool]]'
     |      Check if a script exists in the script cache by specifying the SHAs of
     |      each script as ``args``. Returns a list of boolean values indicating if
     |      if each already script exists in the cache_data.
     |
     |      For more information, see  https://redis.io/commands/script-exists
     |
     |  script_flush(self, sync_type: "Literal['SYNC'] | Literal['ASYNC'] | None" = None) -> 'bool | Awaitable[bool]'
     |      Flush all scripts from the script cache_data.
     |
     |      ``sync_type`` is by default SYNC (synchronous) but it can also be
     |                    ASYNC.
     |
     |      For more information, see  https://redis.io/commands/script-flush
     |
     |  script_kill(self) -> 'bool | Awaitable[bool]'
     |      Kill the currently executing Lua script
     |
     |      For more information, see https://redis.io/commands/script-kill
     |
     |  script_load(self, script: 'ScriptTextT') -> 'str | Awaitable[str]'
     |      Load a Lua ``script`` into the script cache_data. Returns the SHA.
     |
     |      For more information, see https://redis.io/commands/script-load
     |
     |  ----------------------------------------------------------------------
     |  Data and other attributes inherited from redis.typing.CommandsProtocol:
     |
     |  __protocol_attrs__ = {'_event_dispatcher', 'execute_command'}
     |
     |  ----------------------------------------------------------------------
     |  Class methods inherited from typing.Protocol:
     |
     |  __init_subclass__(*args, **kwargs)
     |      This method is called when a class is subclassed.
     |
     |      The default implementation does nothing. It may be
     |      overridden to extend subclasses.
     |
     |  ----------------------------------------------------------------------
     |  Class methods inherited from typing.Generic:
     |
     |  __class_getitem__(...)
     |      Parameterizes a generic class.
     |
     |      At least, parameterizing a generic class is the *main* thing this
     |      method does. For example, for some generic class `Foo`, this is called
     |      when we do `Foo[int]` - there, with `cls=Foo` and `params=int`.
     |
     |      However, note that this method is also called when defining generic
     |      classes in the first place with `class Foo[T]: ...`.
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from redis.commands.core.FunctionCommands:
     |
     |  fcall(self, function, numkeys: 'int', *keys_and_args: 'Any') -> 'Any | Awaitable[Any]'
     |      Invoke a function.
     |
     |      For more information, see https://redis.io/commands/fcall
     |
     |  fcall_ro(self, function, numkeys: 'int', *keys_and_args: 'Any') -> 'Any | Awaitable[Any]'
     |      This is a read-only variant of the FCALL command that cannot
     |      execute commands that modify data.
     |
     |      For more information, see https://redis.io/commands/fcall_ro
     |
     |  function_delete(self, library: 'str') -> 'bool | Awaitable[bool]'
     |      Delete the library called ``library`` and all its functions.
     |
     |      For more information, see https://redis.io/commands/function-delete
     |
     |  function_dump(self) -> 'bytes | Awaitable[bytes]'
     |      Return the serialized payload of loaded libraries.
     |
     |      For more information, see https://redis.io/commands/function-dump
     |
     |  function_flush(self, mode: 'str' = 'SYNC') -> 'bool | Awaitable[bool]'
     |      Deletes all the libraries.
     |
     |      For more information, see https://redis.io/commands/function-flush
     |
     |  function_kill(self) -> 'bytes | str | Awaitable[bytes | str]'
     |      Kill a function that is currently executing.
     |
     |      For more information, see https://redis.io/commands/function-kill
     |
     |  function_list(self, library: 'str | None' = '*', withcode: 'bool | None' = False) -> 'list[Any] | Awaitable[list[Any]]'
     |      Return information about the functions and libraries.
     |
     |      Args:
     |
     |          library: specify a pattern for matching library names
     |          withcode: cause the server to include the libraries source implementation
     |              in the reply
     |
     |  function_load(self, code: 'str', replace: 'bool | None' = False) -> 'bytes | str | Awaitable[bytes | str]'
     |      Load a library to Redis.
     |      :param code: the source code (must start with
     |      Shebang statement that provides a metadata about the library)
     |      :param replace: changes the behavior to overwrite the existing library
     |      with the new contents.
     |      Return the library name that was loaded.
     |
     |      For more information, see https://redis.io/commands/function-load
     |
     |  function_restore(self, payload: 'str', policy: 'str | None' = 'APPEND') -> 'bool | Awaitable[bool]'
     |      Restore libraries from the serialized ``payload``.
     |      You can use the optional policy argument to provide a policy
     |      for handling existing libraries.
     |
     |      For more information, see https://redis.io/commands/function-restore
     |
     |  function_stats(self) -> 'Any | Awaitable[Any]'
     |      Return information about the function that's currently running
     |      and information about the available execution engines.
     |
     |      For more information, see https://redis.io/commands/function-stats
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from redis.commands.sentinel.AsyncSentinelCommands:
     |
     |  async sentinel(self, *args) -> None
     |      Redis Sentinel's SENTINEL command.
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from redis.commands.sentinel.SentinelCommands:
     |
     |  sentinel_ckquorum(self, new_master_name) -> Union[bool, Awaitable[bool]]
     |      Check if the current Sentinel configuration is able to reach the
     |      quorum needed to failover a master, and the majority needed to
     |      authorize the failover.
     |
     |      This command should be used in monitoring systems to check if a
     |      Sentinel deployment is ok.
     |
     |  sentinel_failover(self, new_master_name) -> Union[bool, Awaitable[bool]]
     |      Force a failover as if the master was not reachable, and without
     |      asking for agreement to other Sentinels (however a new version of the
     |      configuration will be published so that the other Sentinels will
     |      update their configurations).
     |
     |  sentinel_flushconfig(self) -> Union[bool, Awaitable[bool]]
     |      Force Sentinel to rewrite its configuration on disk, including the
     |      current Sentinel state.
     |
     |      Normally Sentinel rewrites the configuration every time something
     |      changes in its state (in the context of the subset of the state which
     |      is persisted on disk across restart).
     |      However sometimes it is possible that the configuration file is lost
     |      because of operation errors, disk failures, package upgrade scripts or
     |      configuration managers. In those cases a way to to force Sentinel to
     |      rewrite the configuration file is handy.
     |
     |      This command works even if the previous configuration file is
     |      completely missing.
     |
     |  sentinel_get_master_addr_by_name(self, service_name, return_responses: bool = False) -> Union[tuple[bytes | str, int], NoneType, bool, Awaitable[tuple[bytes | str, int] | None | bool]]
     |      Returns a (host, port) pair for the given ``service_name`` when return_responses is True,
     |      otherwise returns a boolean value that indicates if the command was successful.
     |
     |  sentinel_master(self, service_name, return_responses: bool = False) -> Union[dict[str, Any], bool, Awaitable[dict[str, Any] | bool]]
     |      Returns a dictionary containing the specified masters state, when return_responses is True,
     |      otherwise returns a boolean value that indicates if the command was successful.
     |
     |  sentinel_masters(self) -> Union[dict[str, dict[str, Any]], list[dict[str, Any]], Awaitable[dict[str, dict[str, Any]] | list[dict[str, Any]]]]
     |      Returns a list of dictionaries containing each master's state.
     |
     |      Important: This function is called by the Sentinel implementation and is
     |      called directly on the Redis standalone client for sentinels,
     |      so it doesn't support the "once" and "return_responses" options.
     |
     |  sentinel_monitor(self, name, ip, port, quorum) -> Union[bool, Awaitable[bool]]
     |      Add a new master to Sentinel to be monitored
     |
     |  sentinel_remove(self, name) -> Union[bool, Awaitable[bool]]
     |      Remove a master from Sentinel's monitoring
     |
     |  sentinel_reset(self, pattern) -> Union[bool, Awaitable[bool]]
     |      This command will reset all the masters with matching name.
     |      The pattern argument is a glob-style pattern.
     |
     |      The reset process clears any previous state in a master (including a
     |      failover in progress), and removes every slave and sentinel already
     |      discovered and associated with the master.
     |
     |  sentinel_sentinels(self, service_name, return_responses: bool = False) -> Union[list[dict[str, Any]], bool, Awaitable[list[dict[str, Any]] | bool]]
     |      Returns a list of sentinels for ``service_name``, when return_responses is True,
     |      otherwise returns a boolean value that indicates if the command was successful.
     |
     |  sentinel_set(self, name, option, value) -> Union[bool, Awaitable[bool]]
     |      Set Sentinel monitoring parameters for a given master
     |
     |  sentinel_slaves(self, service_name) -> Union[list[dict[str, Any]], Awaitable[list[dict[str, Any]]]]
     |      Returns a list of slaves for ``service_name``
     |
     |      Important: This function is called by the Sentinel implementation and is
     |      called directly on the Redis standalone client for sentinels,
     |      so it doesn't support the "once" and "return_responses" options.

    class Subscription(builtins.object)
     |  Subscription(name: Union[bytes, str, memoryview], handler: Optional[Callable[[dict[str, Any]], Any]] = None) -> None
     |
     |  PubSub channel or pattern subscription with an optional handler.
     |
     |  Methods defined here:
     |
     |  __delattr__(self, name)
     |      Implement delattr(self, name).
     |
     |  __eq__(self, other)
     |      Return self==value.
     |
     |  __hash__(self)
     |      Return hash(self).
     |
     |  __init__(self, name: Union[bytes, str, memoryview], handler: Optional[Callable[[dict[str, Any]], Any]] = None) -> None
     |      Initialize self.  See help(type(self)) for accurate signature.
     |
     |  __repr__(self)
     |      Return repr(self).
     |
     |  __setattr__(self, name, value)
     |      Implement setattr(self, name, value).
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors defined here:
     |
     |  __dict__
     |      dictionary for instance variables
     |
     |  __weakref__
     |      list of weak references to the object
     |
     |  ----------------------------------------------------------------------
     |  Data and other attributes defined here:
     |
     |  __annotations__ = {'handler': typing.Optional[typing.Callable[[dict[st...
     |
     |  __dataclass_fields__ = {'handler': Field(name='handler',type=typing.Op...
     |
     |  __dataclass_params__ = _DataclassParams(init=True,repr=True,eq=True,or...
     |
     |  __match_args__ = ('name', 'handler')
     |
     |  handler = None

    class TimeoutError(RedisError)
     |  TimeoutError(*args, status_code: str | None = None)
     |
     |  Method resolution order:
     |      TimeoutError
     |      RedisError
     |      builtins.Exception
     |      builtins.BaseException
     |      builtins.object
     |
     |  Methods defined here:
     |
     |  __init__(self, *args, status_code: str | None = None)
     |      Initialize self.  See help(type(self)) for accurate signature.
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from RedisError:
     |
     |  __repr__(self)
     |      Return repr(self).
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors inherited from RedisError:
     |
     |  __weakref__
     |      list of weak references to the object
     |
     |  ----------------------------------------------------------------------
     |  Static methods inherited from builtins.Exception:
     |
     |  __new__(*args, **kwargs) class method of builtins.Exception
     |      Create and return a new object.  See help(type) for accurate signature.
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from builtins.BaseException:
     |
     |  __getattribute__(self, name, /)
     |      Return getattr(self, name).
     |
     |  __reduce__(...)
     |      Helper for pickle.
     |
     |  __setstate__(...)
     |
     |  __str__(self, /)
     |      Return str(self).
     |
     |  add_note(...)
     |      Exception.add_note(note) --
     |      add a note to the exception
     |
     |  with_traceback(...)
     |      Exception.with_traceback(tb) --
     |      set self.__traceback__ to tb and return self.
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors inherited from builtins.BaseException:
     |
     |  __cause__
     |      exception cause
     |
     |  __context__
     |      exception context
     |
     |  __dict__
     |
     |  __suppress_context__
     |
     |  __traceback__
     |
     |  args

    class UnixDomainSocketConnection(AbstractConnection)
     |  UnixDomainSocketConnection(*, path: str = '', **kwargs)
     |
     |  Manages UDS communication to and from a Redis server
     |
     |  Method resolution order:
     |      UnixDomainSocketConnection
     |      AbstractConnection
     |      AsyncMaintNotificationsAbstractConnection
     |      builtins.object
     |
     |  Methods defined here:
     |
     |  __init__(self, *, path: str = '', **kwargs)
     |      Initialize a new async Connection.
     |
     |      Parameters
     |      ----------
     |      driver_info : DriverInfo, optional
     |          Driver metadata for CLIENT SETINFO. If provided, lib_name and lib_version
     |          are ignored. If not provided, a DriverInfo will be created from lib_name
     |          and lib_version. Explicit None disables CLIENT SETINFO.
     |      lib_name : str, optional
     |          **Deprecated.** Use driver_info instead. Library name for CLIENT SETINFO.
     |      lib_version : str, optional
     |          **Deprecated.** Use driver_info instead. Library version for CLIENT SETINFO.
     |
     |  repr_pieces(self) -> Iterable[Tuple[str, Union[str, int]]]
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors defined here:
     |
     |  __weakref__
     |      list of weak references to the object
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from AbstractConnection:
     |
     |  __del__(self, _warnings: Any = <module 'warnings' from 'C:\\Users\\Youse\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\warnings.py'>)
     |
     |  __repr__(self)
     |      Return repr(self).
     |
     |  async can_read(self) -> bool
     |      Check the socket to see if there's data loaded in the buffer.
     |
     |  async can_read_destructive(self) -> bool
     |      Check the socket to see if there's data loaded in the buffer.
     |
     |  async check_health(self)
     |      Check the health of the connection with a PING/PONG
     |
     |  async connect(self)
     |      Connects to the Redis server if not already connected
     |
     |  async connect_check_health(self, check_health: bool = True, retry_socket_connect: bool = True)
     |
     |  deregister_connect_callback(self, callback)
     |      De-register a previously registered callback.  It will no-longer receive
     |      notifications on connection events.  Calling this is not required when the
     |      listener goes away, since the callbacks are kept as weak methods.
     |
     |  async disconnect(self, nowait: bool = False, error: Optional[Exception] = None, failure_count: Optional[int] = None, health_check_failed: bool = False) -> None
     |      Disconnects from the Redis server
     |
     |  get_protocol(self)
     |
     |  getpeername(self) -> str | None
     |      Returns the peer name of the connection.
     |
     |  mark_for_reconnect(self)
     |
     |  async on_connect(self) -> None
     |      Initialize the connection, authenticate and select a database
     |
     |  async on_connect_check_health(self, check_health: bool = True) -> None
     |
     |  pack_command(self, *args: Union[bytes, bytearray, memoryview, str, int, float]) -> List[bytes]
     |      Pack a series of arguments into the Redis protocol
     |
     |  pack_commands(self, commands: Iterable[Iterable[Union[bytes, bytearray, memoryview, str, int, float]]]) -> List[bytes]
     |      Pack multiple commands into the Redis protocol
     |
     |  async process_invalidation_messages(self)
     |
     |  async re_auth(self)
     |
     |  async read_response(self, disable_decoding: bool = False, timeout: float | None = None, *, disconnect_on_error: bool = True, push_request: bool | None = False)
     |      Read the response from a previously sent command.
     |
     |      ``timeout`` semantics:
     |      - ``None`` (default): fall back to ``self.socket_timeout``.
     |      - ``math.inf``: block indefinitely with no timeout. Used by PubSub
     |        blocking reads (``listen()`` / ``get_message(timeout=None)`` /
     |        ``parse_response(block=True)``) where the configured
     |        ``socket_timeout`` must not abort the read.
     |      - ``float``: apply that timeout in seconds for this single read.
     |
     |      TODO(next-major): replace the ``math.inf`` opt-in with a SENTINEL
     |      default for ``timeout``. After that change, ``timeout=None`` will
     |      mean "no timeout, block until a response arrives" (matching the
     |      long-standing PubSub docstring contract) and the SENTINEL default
     |      will be the value that falls back to ``self.socket_timeout``.
     |      That swap is a breaking change, so it must wait for a major
     |      release. Until then, callers that need an indefinitely blocking
     |      read pass ``math.inf`` explicitly.
     |
     |  register_connect_callback(self, callback)
     |      Register a callback to be called when the connection is established either
     |      initially or reconnected.  This allows listeners to issue commands that
     |      are ephemeral to the connection, for example pub/sub subscription or
     |      key tracking.  The callback must be a _method_ and will be kept as
     |      a weak reference.
     |
     |  reset_should_reconnect(self)
     |
     |  async send_command(self, *args: Any, **kwargs: Any) -> None
     |      Pack and send a command to the Redis server
     |
     |  async send_packed_command(self, command: Union[bytes, str, Iterable[bytes]], check_health: bool = True) -> None
     |
     |  set_parser(self, parser_class: Type[redis._parsers.base.BaseParser]) -> None
     |      Creates a new instance of parser_class with socket size:
     |      _socket_read_size and assigns it to the parser for the connection
     |      :param parser_class: The required parser class
     |
     |  set_re_auth_token(self, token: redis.auth.token.TokenInterface)
     |
     |  should_reconnect(self)
     |
     |  ----------------------------------------------------------------------
     |  Readonly properties inherited from AbstractConnection:
     |
     |  is_connected
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors inherited from AbstractConnection:
     |
     |  __dict__
     |      dictionary for instance variables
     |
     |  client_name
     |
     |  credential_provider
     |
     |  db
     |
     |  encoder
     |
     |  health_check_interval
     |
     |  last_active_at
     |
     |  lib_name
     |
     |  lib_version
     |
     |  next_health_check
     |
     |  password
     |
     |  protocol
     |
     |  redis_connect_func
     |
     |  retry_on_error
     |
     |  retry_on_timeout
     |
     |  socket_connect_timeout
     |
     |  socket_timeout
     |
     |  ssl_context
     |
     |  username
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from AsyncMaintNotificationsAbstractConnection:
     |
     |  async activate_maint_notifications_handling_if_enabled(self, check_health: bool = True) -> None
     |
     |  add_maint_start_notification(self, id: int) -> None
     |
     |  add_skipped_end_notification(self, id: int) -> None
     |
     |  get_processed_start_notifications(self) -> set[int]
     |
     |  get_resolved_ip(self) -> str | None
     |      Extract the resolved IP address from an established connection or host.
     |
     |      First tries to get the actual peer IP from the async stream writer, then
     |      falls back to DNS resolution if needed.
     |
     |      Returns:
     |          The resolved IP address, or None if it cannot be determined.
     |
     |  get_skipped_end_notifications(self) -> set[int]
     |
     |  reset_received_notifications(self) -> None
     |
     |  reset_tmp_settings(self, reset_host_address: bool = False, reset_relaxed_timeout: bool = False) -> None
     |
     |  set_maint_notifications_cluster_handler_for_connection(self, oss_cluster_maint_notifications_handler: redis.asyncio.maint_notifications.AsyncOSSMaintNotificationsHandler) -> None
     |
     |  set_maint_notifications_pool_handler_for_connection(self, maint_notifications_pool_handler: redis.asyncio.maint_notifications.AsyncMaintNotificationsPoolHandler) -> None
     |
     |  set_tmp_settings(self, tmp_host_address: str | object | None = <object object at 0x0000017B991493E0>, tmp_relaxed_timeout: float | None = -1) -> None
     |      SENTINEL keeps the host unchanged. -1 keeps the relaxed timeout unchanged.
     |
     |  update_current_socket_timeout(self, relaxed_timeout: float | None = None) -> None
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors inherited from AsyncMaintNotificationsAbstractConnection:
     |
     |  maintenance_state

    class WatchError(RedisError)
     |  WatchError(*args, status_code: str | None = None)
     |
     |  Method resolution order:
     |      WatchError
     |      RedisError
     |      builtins.Exception
     |      builtins.BaseException
     |      builtins.object
     |
     |  Methods inherited from RedisError:
     |
     |  __init__(self, *args, status_code: str | None = None)
     |      Initialize self.  See help(type(self)) for accurate signature.
     |
     |  __repr__(self)
     |      Return repr(self).
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors inherited from RedisError:
     |
     |  __weakref__
     |      list of weak references to the object
     |
     |  ----------------------------------------------------------------------
     |  Static methods inherited from builtins.Exception:
     |
     |  __new__(*args, **kwargs) class method of builtins.Exception
     |      Create and return a new object.  See help(type) for accurate signature.
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from builtins.BaseException:
     |
     |  __getattribute__(self, name, /)
     |      Return getattr(self, name).
     |
     |  __reduce__(...)
     |      Helper for pickle.
     |
     |  __setstate__(...)
     |
     |  __str__(self, /)
     |      Return str(self).
     |
     |  add_note(...)
     |      Exception.add_note(note) --
     |      add a note to the exception
     |
     |  with_traceback(...)
     |      Exception.with_traceback(tb) --
     |      set self.__traceback__ to tb and return self.
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors inherited from builtins.BaseException:
     |
     |  __cause__
     |      exception cause
     |
     |  __context__
     |      exception context
     |
     |  __dict__
     |
     |  __suppress_context__
     |
     |  __traceback__
     |
     |  args

FUNCTIONS
    default_backoff()

    from_url(url: str, **kwargs: Any) -> 'Redis'
        Returns an active Redis client generated from the given database URL.

        Will attempt to extract the database id from the path url fragment, if
        none is provided.

DATA
    __all__ = ['AsyncClusterKeyspaceNotifications', 'AsyncKeyspaceNotifica...

FILE
    c:\users\youse\appdata\local\programs\python\python312\lib\site-packages\redis\asyncio\__init__.py

Python Library Documentation: package redis.auth in redis

NAME
    redis.auth

PACKAGE CONTENTS
    err
    idp
    token
    token_manager

FILE
    c:\users\youse\appdata\local\programs\python\python312\lib\site-packages\redis\auth\__init__.py

Python Library Documentation: module redis.backoff in redis

NAME
    redis.backoff

CLASSES
    abc.ABC(builtins.object)
        AbstractBackoff
            ConstantBackoff
                NoBackoff
            DecorrelatedJitterBackoff
            EqualJitterBackoff
            ExponentialBackoff
            ExponentialWithJitterBackoff
            FullJitterBackoff

    class AbstractBackoff(abc.ABC)
     |  Backoff interface
     |
     |  Method resolution order:
     |      AbstractBackoff
     |      abc.ABC
     |      builtins.object
     |
     |  Methods defined here:
     |
     |  compute(self, failures: int) -> float
     |      Compute backoff in seconds upon failure
     |
     |  reset(self)
     |      Reset internal state before an operation.
     |      `reset` is called once at the beginning of
     |      every call to `Retry.call_with_retry`
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors defined here:
     |
     |  __dict__
     |      dictionary for instance variables
     |
     |  __weakref__
     |      list of weak references to the object
     |
     |  ----------------------------------------------------------------------
     |  Data and other attributes defined here:
     |
     |  __abstractmethods__ = frozenset({'compute'})

    class ConstantBackoff(AbstractBackoff)
     |  ConstantBackoff(backoff: float) -> None
     |
     |  Constant backoff upon failure
     |
     |  Method resolution order:
     |      ConstantBackoff
     |      AbstractBackoff
     |      abc.ABC
     |      builtins.object
     |
     |  Methods defined here:
     |
     |  __eq__(self, other) -> bool
     |      Return self==value.
     |
     |  __hash__(self) -> int
     |      Return hash(self).
     |
     |  __init__(self, backoff: float) -> None
     |      `backoff`: backoff time in seconds
     |
     |  compute(self, failures: int) -> float
     |      Compute backoff in seconds upon failure
     |
     |  ----------------------------------------------------------------------
     |  Data and other attributes defined here:
     |
     |  __abstractmethods__ = frozenset()
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from AbstractBackoff:
     |
     |  reset(self)
     |      Reset internal state before an operation.
     |      `reset` is called once at the beginning of
     |      every call to `Retry.call_with_retry`
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors inherited from AbstractBackoff:
     |
     |  __dict__
     |      dictionary for instance variables
     |
     |  __weakref__
     |      list of weak references to the object

    class DecorrelatedJitterBackoff(AbstractBackoff)
     |  DecorrelatedJitterBackoff(cap: float = 0.512, base: float = 0.008) -> None
     |
     |  Decorrelated jitter backoff upon failure
     |
     |  Method resolution order:
     |      DecorrelatedJitterBackoff
     |      AbstractBackoff
     |      abc.ABC
     |      builtins.object
     |
     |  Methods defined here:
     |
     |  __eq__(self, other) -> bool
     |      Return self==value.
     |
     |  __hash__(self) -> int
     |      Return hash(self).
     |
     |  __init__(self, cap: float = 0.512, base: float = 0.008) -> None
     |      `cap`: maximum backoff time in seconds
     |      `base`: base backoff time in seconds
     |
     |  compute(self, failures: int) -> float
     |      Compute backoff in seconds upon failure
     |
     |  reset(self) -> None
     |      Reset internal state before an operation.
     |      `reset` is called once at the beginning of
     |      every call to `Retry.call_with_retry`
     |
     |  ----------------------------------------------------------------------
     |  Data and other attributes defined here:
     |
     |  __abstractmethods__ = frozenset()
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors inherited from AbstractBackoff:
     |
     |  __dict__
     |      dictionary for instance variables
     |
     |  __weakref__
     |      list of weak references to the object

    class EqualJitterBackoff(AbstractBackoff)
     |  EqualJitterBackoff(cap: float = 0.512, base: float = 0.008) -> None
     |
     |  Equal jitter backoff upon failure
     |
     |  Method resolution order:
     |      EqualJitterBackoff
     |      AbstractBackoff
     |      abc.ABC
     |      builtins.object
     |
     |  Methods defined here:
     |
     |  __eq__(self, other) -> bool
     |      Return self==value.
     |
     |  __hash__(self) -> int
     |      Return hash(self).
     |
     |  __init__(self, cap: float = 0.512, base: float = 0.008) -> None
     |      `cap`: maximum backoff time in seconds
     |      `base`: base backoff time in seconds
     |
     |  compute(self, failures: int) -> float
     |      Compute backoff in seconds upon failure
     |
     |  ----------------------------------------------------------------------
     |  Data and other attributes defined here:
     |
     |  __abstractmethods__ = frozenset()
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from AbstractBackoff:
     |
     |  reset(self)
     |      Reset internal state before an operation.
     |      `reset` is called once at the beginning of
     |      every call to `Retry.call_with_retry`
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors inherited from AbstractBackoff:
     |
     |  __dict__
     |      dictionary for instance variables
     |
     |  __weakref__
     |      list of weak references to the object

    class ExponentialBackoff(AbstractBackoff)
     |  ExponentialBackoff(cap: float = 0.512, base: float = 0.008)
     |
     |  Exponential backoff upon failure
     |
     |  Method resolution order:
     |      ExponentialBackoff
     |      AbstractBackoff
     |      abc.ABC
     |      builtins.object
     |
     |  Methods defined here:
     |
     |  __eq__(self, other) -> bool
     |      Return self==value.
     |
     |  __hash__(self) -> int
     |      Return hash(self).
     |
     |  __init__(self, cap: float = 0.512, base: float = 0.008)
     |      `cap`: maximum backoff time in seconds
     |      `base`: base backoff time in seconds
     |
     |  compute(self, failures: int) -> float
     |      Compute backoff in seconds upon failure
     |
     |  ----------------------------------------------------------------------
     |  Data and other attributes defined here:
     |
     |  __abstractmethods__ = frozenset()
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from AbstractBackoff:
     |
     |  reset(self)
     |      Reset internal state before an operation.
     |      `reset` is called once at the beginning of
     |      every call to `Retry.call_with_retry`
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors inherited from AbstractBackoff:
     |
     |  __dict__
     |      dictionary for instance variables
     |
     |  __weakref__
     |      list of weak references to the object

    class ExponentialWithJitterBackoff(AbstractBackoff)
     |  ExponentialWithJitterBackoff(cap: float = 0.512, base: float = 0.008) -> None
     |
     |  Exponential backoff upon failure, with jitter
     |
     |  Method resolution order:
     |      ExponentialWithJitterBackoff
     |      AbstractBackoff
     |      abc.ABC
     |      builtins.object
     |
     |  Methods defined here:
     |
     |  __eq__(self, other) -> bool
     |      Return self==value.
     |
     |  __hash__(self) -> int
     |      Return hash(self).
     |
     |  __init__(self, cap: float = 0.512, base: float = 0.008) -> None
     |      `cap`: maximum backoff time in seconds
     |      `base`: base backoff time in seconds
     |
     |  compute(self, failures: int) -> float
     |      Compute backoff in seconds upon failure
     |
     |  ----------------------------------------------------------------------
     |  Data and other attributes defined here:
     |
     |  __abstractmethods__ = frozenset()
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from AbstractBackoff:
     |
     |  reset(self)
     |      Reset internal state before an operation.
     |      `reset` is called once at the beginning of
     |      every call to `Retry.call_with_retry`
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors inherited from AbstractBackoff:
     |
     |  __dict__
     |      dictionary for instance variables
     |
     |  __weakref__
     |      list of weak references to the object

    class FullJitterBackoff(AbstractBackoff)
     |  FullJitterBackoff(cap: float = 0.512, base: float = 0.008) -> None
     |
     |  Full jitter backoff upon failure
     |
     |  Method resolution order:
     |      FullJitterBackoff
     |      AbstractBackoff
     |      abc.ABC
     |      builtins.object
     |
     |  Methods defined here:
     |
     |  __eq__(self, other) -> bool
     |      Return self==value.
     |
     |  __hash__(self) -> int
     |      Return hash(self).
     |
     |  __init__(self, cap: float = 0.512, base: float = 0.008) -> None
     |      `cap`: maximum backoff time in seconds
     |      `base`: base backoff time in seconds
     |
     |  compute(self, failures: int) -> float
     |      Compute backoff in seconds upon failure
     |
     |  ----------------------------------------------------------------------
     |  Data and other attributes defined here:
     |
     |  __abstractmethods__ = frozenset()
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from AbstractBackoff:
     |
     |  reset(self)
     |      Reset internal state before an operation.
     |      `reset` is called once at the beginning of
     |      every call to `Retry.call_with_retry`
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors inherited from AbstractBackoff:
     |
     |  __dict__
     |      dictionary for instance variables
     |
     |  __weakref__
     |      list of weak references to the object

    class NoBackoff(ConstantBackoff)
     |  NoBackoff() -> None
     |
     |  No backoff upon failure
     |
     |  Method resolution order:
     |      NoBackoff
     |      ConstantBackoff
     |      AbstractBackoff
     |      abc.ABC
     |      builtins.object
     |
     |  Methods defined here:
     |
     |  __init__(self) -> None
     |      `backoff`: backoff time in seconds
     |
     |  ----------------------------------------------------------------------
     |  Data and other attributes defined here:
     |
     |  __abstractmethods__ = frozenset()
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from ConstantBackoff:
     |
     |  __eq__(self, other) -> bool
     |      Return self==value.
     |
     |  __hash__(self) -> int
     |      Return hash(self).
     |
     |  compute(self, failures: int) -> float
     |      Compute backoff in seconds upon failure
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from AbstractBackoff:
     |
     |  reset(self)
     |      Reset internal state before an operation.
     |      `reset` is called once at the beginning of
     |      every call to `Retry.call_with_retry`
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors inherited from AbstractBackoff:
     |
     |  __dict__
     |      dictionary for instance variables
     |
     |  __weakref__
     |      list of weak references to the object

FUNCTIONS
    default_backoff()

DATA
    DEFAULT_BASE = 0.008
    DEFAULT_CAP = 0.512

FILE
    c:\users\youse\appdata\local\programs\python\python312\lib\site-packages\redis\backoff.py

Python Library Documentation: module redis.cache in redis

NAME
    redis.cache

CLASSES
    abc.ABC(builtins.object)
        CacheConfigurationInterface
            CacheConfig
        CacheFactoryInterface
            CacheFactory
        CacheInterface
            CacheProxy
            DefaultCache
        EvictionPolicyInterface
            LRUPolicy
    builtins.object
        CacheEntry
        CacheKey
    enum.Enum(builtins.object)
        CacheEntryStatus
        EvictionPolicy
        EvictionPolicyType

    class CacheConfig(CacheConfigurationInterface)
     |  CacheConfig(max_size: int = 10000, cache_class: Any = <class 'redis.cache.DefaultCache'>, eviction_policy: redis.cache.EvictionPolicy = <EvictionPolicy.LRU: <class 'redis.cache.LRUPolicy'>>)
     |
     |  Method resolution order:
     |      CacheConfig
     |      CacheConfigurationInterface
     |      abc.ABC
     |      builtins.object
     |
     |  Methods defined here:
     |
     |  __init__(self, max_size: int = 10000, cache_class: Any = <class 'redis.cache.DefaultCache'>, eviction_policy: redis.cache.EvictionPolicy = <EvictionPolicy.LRU: <class 'redis.cache.LRUPolicy'>>)
     |      Initialize self.  See help(type(self)) for accurate signature.
     |
     |  get_cache_class(self)
     |
     |  get_eviction_policy(self) -> redis.cache.EvictionPolicy
     |
     |  get_max_size(self) -> int
     |
     |  is_allowed_to_cache(self, command: str) -> bool
     |
     |  is_exceeds_max_size(self, count: int) -> bool
     |
     |  ----------------------------------------------------------------------
     |  Data and other attributes defined here:
     |
     |  DEFAULT_ALLOW_LIST = ['BITCOUNT', 'BITFIELD_RO', 'BITPOS', 'EXISTS', '...
     |
     |  DEFAULT_CACHE_CLASS = <class 'redis.cache.DefaultCache'>
     |
     |  DEFAULT_EVICTION_POLICY = <EvictionPolicy.LRU: <class 'redis.cache.LRU...
     |
     |  DEFAULT_MAX_SIZE = 10000
     |
     |  __abstractmethods__ = frozenset()
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors inherited from CacheConfigurationInterface:
     |
     |  __dict__
     |      dictionary for instance variables
     |
     |  __weakref__
     |      list of weak references to the object

    class CacheConfigurationInterface(abc.ABC)
     |  Method resolution order:
     |      CacheConfigurationInterface
     |      abc.ABC
     |      builtins.object
     |
     |  Methods defined here:
     |
     |  get_cache_class(self)
     |
     |  get_eviction_policy(self)
     |
     |  get_max_size(self) -> int
     |
     |  is_allowed_to_cache(self, command: str) -> bool
     |
     |  is_exceeds_max_size(self, count: int) -> bool
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors defined here:
     |
     |  __dict__
     |      dictionary for instance variables
     |
     |  __weakref__
     |      list of weak references to the object
     |
     |  ----------------------------------------------------------------------
     |  Data and other attributes defined here:
     |
     |  __abstractmethods__ = frozenset({'get_cache_class', 'get_eviction_poli...

    class CacheEntry(builtins.object)
     |  CacheEntry(cache_key: redis.cache.CacheKey, cache_value: bytes, status: redis.cache.CacheEntryStatus, connection_ref)
     |
     |  Methods defined here:
     |
     |  __eq__(self, other)
     |      Return self==value.
     |
     |  __hash__(self)
     |      Return hash(self).
     |
     |  __init__(self, cache_key: redis.cache.CacheKey, cache_value: bytes, status: redis.cache.CacheEntryStatus, connection_ref)
     |      Initialize self.  See help(type(self)) for accurate signature.
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors defined here:
     |
     |  __dict__
     |      dictionary for instance variables
     |
     |  __weakref__
     |      list of weak references to the object

    class CacheEntryStatus(enum.Enum)
     |  CacheEntryStatus(*values)
     |
     |  Method resolution order:
     |      CacheEntryStatus
     |      enum.Enum
     |      builtins.object
     |
     |  Data and other attributes defined here:
     |
     |  IN_PROGRESS = <CacheEntryStatus.IN_PROGRESS: 'IN_PROGRESS'>
     |
     |  VALID = <CacheEntryStatus.VALID: 'VALID'>
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors inherited from enum.Enum:
     |
     |  name
     |      The name of the Enum member.
     |
     |  value
     |      The value of the Enum member.
     |
     |  ----------------------------------------------------------------------
     |  Static methods inherited from enum.EnumType:
     |
     |  __contains__(value)
     |      Return True if `value` is in `cls`.
     |
     |      `value` is in `cls` if:
     |      1) `value` is a member of `cls`, or
     |      2) `value` is the value of one of the `cls`'s members.
     |
     |  __getitem__(name)
     |      Return the member matching `name`.
     |
     |  __iter__()
     |      Return members in definition order.
     |
     |  __len__()
     |      Return the number of members (no aliases)
     |
     |  ----------------------------------------------------------------------
     |  Readonly properties inherited from enum.EnumType:
     |
     |  __members__
     |      Returns a mapping of member name->value.
     |
     |      This mapping lists all enum members, including aliases. Note that this
     |      is a read-only view of the internal mapping.

    class CacheFactory(CacheFactoryInterface)
     |  CacheFactory(cache_config: Optional[redis.cache.CacheConfig] = None)
     |
     |  Method resolution order:
     |      CacheFactory
     |      CacheFactoryInterface
     |      abc.ABC
     |      builtins.object
     |
     |  Methods defined here:
     |
     |  __init__(self, cache_config: Optional[redis.cache.CacheConfig] = None)
     |      Initialize self.  See help(type(self)) for accurate signature.
     |
     |  get_cache(self) -> redis.cache.CacheInterface
     |
     |  ----------------------------------------------------------------------
     |  Data and other attributes defined here:
     |
     |  __abstractmethods__ = frozenset()
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors inherited from CacheFactoryInterface:
     |
     |  __dict__
     |      dictionary for instance variables
     |
     |  __weakref__
     |      list of weak references to the object

    class CacheFactoryInterface(abc.ABC)
     |  Method resolution order:
     |      CacheFactoryInterface
     |      abc.ABC
     |      builtins.object
     |
     |  Methods defined here:
     |
     |  get_cache(self) -> redis.cache.CacheInterface
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors defined here:
     |
     |  __dict__
     |      dictionary for instance variables
     |
     |  __weakref__
     |      list of weak references to the object
     |
     |  ----------------------------------------------------------------------
     |  Data and other attributes defined here:
     |
     |  __abstractmethods__ = frozenset({'get_cache'})

    class CacheInterface(abc.ABC)
     |  Method resolution order:
     |      CacheInterface
     |      abc.ABC
     |      builtins.object
     |
     |  Methods defined here:
     |
     |  delete_by_cache_keys(self, cache_keys: List[redis.cache.CacheKey]) -> List[bool]
     |
     |  delete_by_redis_keys(self, redis_keys: List[bytes]) -> List[bool]
     |
     |  flush(self) -> int
     |
     |  get(self, key: redis.cache.CacheKey) -> Optional[redis.cache.CacheEntry]
     |
     |  is_cachable(self, key: redis.cache.CacheKey) -> bool
     |
     |  set(self, entry: redis.cache.CacheEntry) -> bool
     |
     |  ----------------------------------------------------------------------
     |  Readonly properties defined here:
     |
     |  collection
     |
     |  config
     |
     |  eviction_policy
     |
     |  size
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors defined here:
     |
     |  __dict__
     |      dictionary for instance variables
     |
     |  __weakref__
     |      list of weak references to the object
     |
     |  ----------------------------------------------------------------------
     |  Data and other attributes defined here:
     |
     |  __abstractmethods__ = frozenset({'collection', 'config', 'delete_by_ca...

    class CacheKey(builtins.object)
     |  CacheKey(command: str, redis_keys: tuple, redis_args: tuple = ()) -> None
     |
     |  Represents a unique key for a cache entry.
     |
     |  Attributes:
     |      command (str): The Redis command being cached.
     |      redis_keys (tuple): The Redis keys involved in the command.
     |      redis_args (tuple): Additional arguments for the Redis command.
     |          This field is included in the cache key to ensure uniqueness
     |          when commands have the same keys but different arguments.
     |          Changing this field will affect cache key uniqueness.
     |
     |  Methods defined here:
     |
     |  __delattr__(self, name)
     |      Implement delattr(self, name).
     |
     |  __eq__(self, other)
     |      Return self==value.
     |
     |  __hash__(self)
     |      Return hash(self).
     |
     |  __init__(self, command: str, redis_keys: tuple, redis_args: tuple = ()) -> None
     |      Initialize self.  See help(type(self)) for accurate signature.
     |
     |  __repr__(self)
     |      Return repr(self).
     |
     |  __setattr__(self, name, value)
     |      Implement setattr(self, name, value).
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors defined here:
     |
     |  __dict__
     |      dictionary for instance variables
     |
     |  __weakref__
     |      list of weak references to the object
     |
     |  ----------------------------------------------------------------------
     |  Data and other attributes defined here:
     |
     |  __annotations__ = {'command': <class 'str'>, 'redis_args': <class 'tup...
     |
     |  __dataclass_fields__ = {'command': Field(name='command',type=<class 's...
     |
     |  __dataclass_params__ = _DataclassParams(init=True,repr=True,eq=True,or...
     |
     |  __match_args__ = ('command', 'redis_keys', 'redis_args')
     |
     |  redis_args = ()

    class CacheProxy(CacheInterface)
     |  CacheProxy(cache: redis.cache.CacheInterface)
     |
     |  Proxy object that wraps cache implementations to enable additional logic on top
     |
     |  Method resolution order:
     |      CacheProxy
     |      CacheInterface
     |      abc.ABC
     |      builtins.object
     |
     |  Methods defined here:
     |
     |  __init__(self, cache: redis.cache.CacheInterface)
     |      Initialize self.  See help(type(self)) for accurate signature.
     |
     |  delete_by_cache_keys(self, cache_keys: List[redis.cache.CacheKey]) -> List[bool]
     |
     |  delete_by_redis_keys(self, redis_keys: List[bytes]) -> List[bool]
     |
     |  flush(self) -> int
     |
     |  get(self, key: redis.cache.CacheKey) -> Optional[redis.cache.CacheEntry]
     |
     |  is_cachable(self, key: redis.cache.CacheKey) -> bool
     |
     |  set(self, entry: redis.cache.CacheEntry) -> bool
     |
     |  ----------------------------------------------------------------------
     |  Readonly properties defined here:
     |
     |  collection
     |
     |  config
     |
     |  eviction_policy
     |
     |  size
     |
     |  ----------------------------------------------------------------------
     |  Data and other attributes defined here:
     |
     |  __abstractmethods__ = frozenset()
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors inherited from CacheInterface:
     |
     |  __dict__
     |      dictionary for instance variables
     |
     |  __weakref__
     |      list of weak references to the object

    class DefaultCache(CacheInterface)
     |  DefaultCache(cache_config: redis.cache.CacheConfigurationInterface) -> None
     |
     |  Method resolution order:
     |      DefaultCache
     |      CacheInterface
     |      abc.ABC
     |      builtins.object
     |
     |  Methods defined here:
     |
     |  __init__(self, cache_config: redis.cache.CacheConfigurationInterface) -> None
     |      Initialize self.  See help(type(self)) for accurate signature.
     |
     |  delete_by_cache_keys(self, cache_keys: List[redis.cache.CacheKey]) -> List[bool]
     |
     |  delete_by_redis_keys(self, redis_keys: Union[List[bytes], List[str]]) -> List[bool]
     |
     |  flush(self) -> int
     |
     |  get(self, key: redis.cache.CacheKey) -> Optional[redis.cache.CacheEntry]
     |
     |  is_cachable(self, key: redis.cache.CacheKey) -> bool
     |
     |  set(self, entry: redis.cache.CacheEntry) -> bool
     |
     |  ----------------------------------------------------------------------
     |  Readonly properties defined here:
     |
     |  collection
     |
     |  config
     |
     |  eviction_policy
     |
     |  size
     |
     |  ----------------------------------------------------------------------
     |  Data and other attributes defined here:
     |
     |  __abstractmethods__ = frozenset()
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors inherited from CacheInterface:
     |
     |  __dict__
     |      dictionary for instance variables
     |
     |  __weakref__
     |      list of weak references to the object

    class EvictionPolicy(enum.Enum)
     |  EvictionPolicy(*values)
     |
     |  Method resolution order:
     |      EvictionPolicy
     |      enum.Enum
     |      builtins.object
     |
     |  Data and other attributes defined here:
     |
     |  LRU = <EvictionPolicy.LRU: <class 'redis.cache.LRUPolicy'>>
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors inherited from enum.Enum:
     |
     |  name
     |      The name of the Enum member.
     |
     |  value
     |      The value of the Enum member.
     |
     |  ----------------------------------------------------------------------
     |  Static methods inherited from enum.EnumType:
     |
     |  __contains__(value)
     |      Return True if `value` is in `cls`.
     |
     |      `value` is in `cls` if:
     |      1) `value` is a member of `cls`, or
     |      2) `value` is the value of one of the `cls`'s members.
     |
     |  __getitem__(name)
     |      Return the member matching `name`.
     |
     |  __iter__()
     |      Return members in definition order.
     |
     |  __len__()
     |      Return the number of members (no aliases)
     |
     |  ----------------------------------------------------------------------
     |  Readonly properties inherited from enum.EnumType:
     |
     |  __members__
     |      Returns a mapping of member name->value.
     |
     |      This mapping lists all enum members, including aliases. Note that this
     |      is a read-only view of the internal mapping.

    class EvictionPolicyInterface(abc.ABC)
     |  Method resolution order:
     |      EvictionPolicyInterface
     |      abc.ABC
     |      builtins.object
     |
     |  Methods defined here:
     |
     |  evict_many(self, count: int) -> List[redis.cache.CacheKey]
     |
     |  evict_next(self) -> redis.cache.CacheKey
     |
     |  touch(self, cache_key: redis.cache.CacheKey) -> None
     |
     |  ----------------------------------------------------------------------
     |  Readonly properties defined here:
     |
     |  type
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors defined here:
     |
     |  __dict__
     |      dictionary for instance variables
     |
     |  __weakref__
     |      list of weak references to the object
     |
     |  cache
     |
     |  ----------------------------------------------------------------------
     |  Data and other attributes defined here:
     |
     |  __abstractmethods__ = frozenset({'cache', 'evict_many', 'evict_next', ...

    class EvictionPolicyType(enum.Enum)
     |  EvictionPolicyType(*values)
     |
     |  Method resolution order:
     |      EvictionPolicyType
     |      enum.Enum
     |      builtins.object
     |
     |  Data and other attributes defined here:
     |
     |  frequency_based = <EvictionPolicyType.frequency_based: 'frequency_base...
     |
     |  time_based = <EvictionPolicyType.time_based: 'time_based'>
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors inherited from enum.Enum:
     |
     |  name
     |      The name of the Enum member.
     |
     |  value
     |      The value of the Enum member.
     |
     |  ----------------------------------------------------------------------
     |  Static methods inherited from enum.EnumType:
     |
     |  __contains__(value)
     |      Return True if `value` is in `cls`.
     |
     |      `value` is in `cls` if:
     |      1) `value` is a member of `cls`, or
     |      2) `value` is the value of one of the `cls`'s members.
     |
     |  __getitem__(name)
     |      Return the member matching `name`.
     |
     |  __iter__()
     |      Return members in definition order.
     |
     |  __len__()
     |      Return the number of members (no aliases)
     |
     |  ----------------------------------------------------------------------
     |  Readonly properties inherited from enum.EnumType:
     |
     |  __members__
     |      Returns a mapping of member name->value.
     |
     |      This mapping lists all enum members, including aliases. Note that this
     |      is a read-only view of the internal mapping.

    class LRUPolicy(EvictionPolicyInterface)
     |  Method resolution order:
     |      LRUPolicy
     |      EvictionPolicyInterface
     |      abc.ABC
     |      builtins.object
     |
     |  Methods defined here:
     |
     |  __init__(self)
     |      Initialize self.  See help(type(self)) for accurate signature.
     |
     |  evict_many(self, count: int) -> List[redis.cache.CacheKey]
     |
     |  evict_next(self) -> redis.cache.CacheKey
     |
     |  touch(self, cache_key: redis.cache.CacheKey) -> None
     |
     |  ----------------------------------------------------------------------
     |  Readonly properties defined here:
     |
     |  type
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors defined here:
     |
     |  cache
     |
     |  ----------------------------------------------------------------------
     |  Data and other attributes defined here:
     |
     |  __abstractmethods__ = frozenset()
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors inherited from EvictionPolicyInterface:
     |
     |  __dict__
     |      dictionary for instance variables
     |
     |  __weakref__
     |      list of weak references to the object

DATA
    List = typing.List
        A generic version of list.

    Optional = typing.Optional
        Optional[X] is equivalent to Union[X, None].

    Union = typing.Union
        Union type; Union[X, Y] means either X or Y.

        On Python 3.10 and higher, the | operator
        can also be used to denote unions;
        X | Y means the same thing to the type checker as Union[X, Y].

        To define a union, use e.g. Union[int, str]. Details:
        - The arguments must be types and there must be at least one.
        - None as an argument is a special case and is replaced by
          type(None).
        - Unions of unions are flattened, e.g.::

            assert Union[Union[int, str], float] == Union[int, str, float]

        - Unions of a single argument vanish, e.g.::

            assert Union[int] == int  # The constructor actually returns int

        - Redundant arguments are skipped, e.g.::

            assert Union[int, str, int] == Union[int, str]

        - When comparing unions, the argument order is ignored, e.g.::

            assert Union[int, str] == Union[str, int]

        - You cannot subclass or instantiate a union.
        - You can use Optional[X] as a shorthand for Union[X, None].

FILE
    c:\users\youse\appdata\local\programs\python\python312\lib\site-packages\redis\cache.py

Python Library Documentation: module redis.client in redis

NAME
    redis.client

CLASSES
    builtins.dict(builtins.object)
        CaseInsensitiveDict
    builtins.object
        AbstractRedis
        Monitor
        PubSub
    redis.commands.core.CoreCommands(redis.commands.core.ACLCommands, redis.commands.core.ClusterCommands, redis.commands.core.DataAccessCommands, redis.commands.core.ManagementCommands, redis.commands.core.ModuleCommands, redis.commands.core.PubSubCommands, redis.commands.core.ScriptCommands, redis.commands.core.FunctionCommands)
        Redis(redis.commands.redismodules.RedisModuleCommands, redis.commands.core.CoreCommands, redis.commands.sentinel.SentinelCommands)
            Pipeline
    redis.commands.redismodules.RedisModuleCommands(builtins.object)
        Redis(redis.commands.redismodules.RedisModuleCommands, redis.commands.core.CoreCommands, redis.commands.sentinel.SentinelCommands)
            Pipeline
    redis.commands.sentinel.SentinelCommands(builtins.object)
        Redis(redis.commands.redismodules.RedisModuleCommands, redis.commands.core.CoreCommands, redis.commands.sentinel.SentinelCommands)
            Pipeline
    threading.Thread(builtins.object)
        PubSubWorkerThread

    class AbstractRedis(builtins.object)
     |  Data descriptors defined here:
     |
     |  __dict__
     |      dictionary for instance variables
     |
     |  __weakref__
     |      list of weak references to the object
     |
     |  ----------------------------------------------------------------------
     |  Data and other attributes defined here:
     |
     |  __annotations__ = {}

    class CaseInsensitiveDict(builtins.dict)
     |  CaseInsensitiveDict(data: Dict[str, str]) -> None
     |
     |  Case insensitive dict implementation. Assumes string keys only.
     |
     |  Method resolution order:
     |      CaseInsensitiveDict
     |      builtins.dict
     |      builtins.object
     |
     |  Methods defined here:
     |
     |  __contains__(self, k)
     |      True if the dictionary has the specified key, else False.
     |
     |  __delitem__(self, k)
     |      Delete self[key].
     |
     |  __getitem__(self, k)
     |      Return self[key].
     |
     |  __init__(self, data: Dict[str, str]) -> None
     |      Initialize self.  See help(type(self)) for accurate signature.
     |
     |  __setitem__(self, k, v)
     |      Set self[key] to value.
     |
     |  get(self, k, default=None)
     |      Return the value for key if key is in the dictionary, else default.
     |
     |  update(self, data)
     |      D.update([E, ]**F) -> None.  Update D from dict/iterable E and F.
     |      If E is present and has a .keys() method, then does:  for k in E: D[k] = E[k]
     |      If E is present and lacks a .keys() method, then does:  for k, v in E: D[k] = v
     |      In either case, this is followed by: for k in F:  D[k] = F[k]
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors defined here:
     |
     |  __dict__
     |      dictionary for instance variables
     |
     |  __weakref__
     |      list of weak references to the object
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from builtins.dict:
     |
     |  __eq__(self, value, /)
     |      Return self==value.
     |
     |  __ge__(self, value, /)
     |      Return self>=value.
     |
     |  __getattribute__(self, name, /)
     |      Return getattr(self, name).
     |
     |  __gt__(self, value, /)
     |      Return self>value.
     |
     |  __ior__(self, value, /)
     |      Return self|=value.
     |
     |  __iter__(self, /)
     |      Implement iter(self).
     |
     |  __le__(self, value, /)
     |      Return self<=value.
     |
     |  __len__(self, /)
     |      Return len(self).
     |
     |  __lt__(self, value, /)
     |      Return self<value.
     |
     |  __ne__(self, value, /)
     |      Return self!=value.
     |
     |  __or__(self, value, /)
     |      Return self|value.
     |
     |  __repr__(self, /)
     |      Return repr(self).
     |
     |  __reversed__(self, /)
     |      Return a reverse iterator over the dict keys.
     |
     |  __ror__(self, value, /)
     |      Return value|self.
     |
     |  __sizeof__(...)
     |      D.__sizeof__() -> size of D in memory, in bytes
     |
     |  clear(...)
     |      D.clear() -> None.  Remove all items from D.
     |
     |  copy(...)
     |      D.copy() -> a shallow copy of D
     |
     |  items(...)
     |      D.items() -> a set-like object providing a view on D's items
     |
     |  keys(...)
     |      D.keys() -> a set-like object providing a view on D's keys
     |
     |  pop(...)
     |      D.pop(k[,d]) -> v, remove specified key and return the corresponding value.
     |
     |      If the key is not found, return the default if given; otherwise,
     |      raise a KeyError.
     |
     |  popitem(self, /)
     |      Remove and return a (key, value) pair as a 2-tuple.
     |
     |      Pairs are returned in LIFO (last-in, first-out) order.
     |      Raises KeyError if the dict is empty.
     |
     |  setdefault(self, key, default=None, /)
     |      Insert key with a value of default if key is not in the dictionary.
     |
     |      Return the value for key if key is in the dictionary, else default.
     |
     |  values(...)
     |      D.values() -> an object providing a view on D's values
     |
     |  ----------------------------------------------------------------------
     |  Class methods inherited from builtins.dict:
     |
     |  __class_getitem__(...)
     |      See PEP 585
     |
     |  fromkeys(iterable, value=None, /)
     |      Create a new dictionary with keys from iterable and values set to value.
     |
     |  ----------------------------------------------------------------------
     |  Static methods inherited from builtins.dict:
     |
     |  __new__(*args, **kwargs) class method of builtins.dict
     |      Create and return a new object.  See help(type) for accurate signature.
     |
     |  ----------------------------------------------------------------------
     |  Data and other attributes inherited from builtins.dict:
     |
     |  __hash__ = None

    class Monitor(builtins.object)
     |  Monitor(connection_pool)
     |
     |  Monitor is useful for handling the MONITOR command to the redis server.
     |  next_command() method returns one command from monitor
     |  listen() method yields commands from monitor.
     |
     |  Methods defined here:
     |
     |  __enter__(self)
     |
     |  __exit__(self, *args)
     |
     |  __init__(self, connection_pool)
     |      Initialize self.  See help(type(self)) for accurate signature.
     |
     |  listen(self)
     |      Listen for commands coming to the server.
     |
     |  next_command(self)
     |      Parse the response from a monitor command
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors defined here:
     |
     |  __dict__
     |      dictionary for instance variables
     |
     |  __weakref__
     |      list of weak references to the object
     |
     |  ----------------------------------------------------------------------
     |  Data and other attributes defined here:
     |
     |  command_re = re.compile('"(.*?)(?<!\\\\)"')
     |
     |  monitor_re = re.compile('\\[(\\d+) (.*?)\\] (.*)')

    class Pipeline(Redis)
     |  Pipeline(connection_pool: redis.connection.ConnectionPool, response_callbacks, transaction, shard_hint)
     |
     |  Pipelines provide a way to transmit multiple commands to the Redis server
     |  in one transmission.  This is convenient for batch processing, such as
     |  saving all the values in a list to Redis.
     |
     |  All commands executed within a pipeline(when running in transactional mode,
     |  which is the default behavior) are wrapped with MULTI and EXEC
     |  calls. This guarantees all commands executed in the pipeline will be
     |  executed atomically.
     |
     |  Any command raising an exception does *not* halt the execution of
     |  subsequent commands in the pipeline. Instead, the exception is caught
     |  and its instance is placed into the response list returned by execute().
     |  Code iterating over the response list should be able to deal with an
     |  instance of an exception as a potential value. In general, these will be
     |  ResponseError exceptions, such as those raised when issuing a command
     |  on a key of a different datatype.
     |
     |  Method resolution order:
     |      Pipeline
     |      Redis
     |      redis.commands.redismodules.RedisModuleCommands
     |      redis.commands.core.CoreCommands
     |      redis.commands.core.ACLCommands
     |      redis.commands.core.ClusterCommands
     |      redis.commands.core.DataAccessCommands
     |      redis.commands.core.BasicKeyCommands
     |      redis.commands.core.HyperlogCommands
     |      redis.commands.core.HashCommands
     |      redis.commands.core.GeoCommands
     |      redis.commands.core.ListCommands
     |      redis.commands.core.ArrayCommands
     |      redis.commands.core.ScanCommands
     |      redis.commands.core.SetCommands
     |      redis.commands.core.StreamCommands
     |      redis.commands.core.SortedSetCommands
     |      redis.commands.core.ManagementCommands
     |      redis.commands.core.ModuleCommands
     |      redis.commands.core.PubSubCommands
     |      redis.commands.core.ScriptCommands
     |      redis.typing.CommandsProtocol
     |      typing.Protocol
     |      typing.Generic
     |      redis.commands.core.FunctionCommands
     |      redis.commands.sentinel.SentinelCommands
     |      builtins.object
     |
     |  Methods defined here:
     |
     |  __bool__(self) -> bool
     |      Pipeline instances should always evaluate to True
     |
     |  __del__(self)
     |
     |  __enter__(self) -> 'Pipeline'
     |
     |  __exit__(self, exc_type, exc_value, traceback)
     |
     |  __init__(self, connection_pool: redis.connection.ConnectionPool, response_callbacks, transaction, shard_hint)
     |      Initialize a new Redis client.
     |
     |      To specify a retry policy for specific errors, you have two options:
     |
     |      1. Set the `retry_on_error` to a list of the error/s to retry on, and
     |      you can also set `retry` to a valid `Retry` object(in case the default
     |      one is not appropriate) - with this approach the retries will be triggered
     |      on the default errors specified in the Retry object enriched with the
     |      errors specified in `retry_on_error`.
     |
     |      2. Define a `Retry` object with configured 'supported_errors' and set
     |      it to the `retry` parameter - with this approach you completely redefine
     |      the errors on which retries will happen.
     |
     |      `retry_on_timeout` is deprecated - please include the TimeoutError
     |      either in the Retry object or in the `retry_on_error` list.
     |
     |      When 'connection_pool' is provided - the retry configuration of the
     |      provided pool will be used.
     |
     |      Args:
     |
     |      socket_keepalive:
     |          if `True`, TCP keepalive is enabled for TCP socket connections.
     |          Argument is ignored when connection_pool is provided.
     |      socket_keepalive_options:
     |          mapping of TCP keepalive socket option constants to values, for
     |          example `{socket.TCP_KEEPIDLE: 30}`. If left unspecified, redis-py
     |          uses TCP keepalive defaults when `socket_keepalive` is enabled:
     |          idle 30 seconds, interval 5 seconds, and 3 probes. Platform-specific
     |          options that are not available are skipped. Pass `None` or `{}` to
     |          avoid setting additional TCP keepalive options. Argument is ignored
     |          when connection_pool is provided.
     |      single_connection_client:
     |          if `True`, connection pool is not used. In that case `Redis`
     |          instance use is not thread safe.
     |      decode_responses:
     |          if `True`, the response will be decoded to utf-8.
     |          Argument is ignored when connection_pool is provided.
     |      driver_info:
     |          Optional DriverInfo object to identify upstream libraries.
     |          If provided, lib_name and lib_version are ignored.
     |          If not provided, a DriverInfo will be created from lib_name and lib_version.
     |          Explicit None disables CLIENT SETINFO.
     |          Argument is ignored when connection_pool is provided.
     |      lib_name:
     |          **Deprecated.** Use driver_info instead. Library name for CLIENT SETINFO.
     |      lib_version:
     |          **Deprecated.** Use driver_info instead. Library version for CLIENT SETINFO.
     |      maint_notifications_config:
     |          configures the pool to support maintenance notifications - see
     |          `redis.maint_notifications.MaintNotificationsConfig` for details.
     |          Only supported with RESP3
     |          If not provided and protocol is RESP3, the maintenance notifications
     |          will be enabled by default (logic is included in the connection pool
     |          initialization).
     |          Argument is ignored when connection_pool is provided.
     |      oss_cluster_maint_notifications_handler:
     |          handler for OSS cluster notifications - see
     |          `redis.maint_notifications.OSSMaintNotificationsHandler` for details.
     |          Only supported with RESP3
     |          Argument is ignored when connection_pool is provided.
     |
     |  __len__(self) -> int
     |
     |  annotate_exception(self, exception, number, command)
     |
     |  close(self) -> None
     |      Close the pipeline
     |
     |  discard(self)
     |      Flushes all previously queued commands
     |      See: https://redis.io/commands/DISCARD
     |
     |  execute(self, raise_on_error: bool = True) -> List[Any]
     |      Execute all the commands in the current pipeline
     |
     |  execute_command(self, *args, **kwargs)
     |
     |  immediate_execute_command(self, *args, **options)
     |      Execute a command immediately, but don't auto-retry on the supported
     |      errors for retry if we're already WATCHing a variable.
     |      Used when issuing WATCH or subsequent commands retrieving their values but before
     |      MULTI is called.
     |
     |  load_scripts(self)
     |
     |  multi(self) -> None
     |      Start a transactional block of the pipeline after WATCH commands
     |      are issued. End the transactional block with `execute`.
     |
     |  parse_response(self, connection, command_name, **options)
     |      Parses a response from the Redis server
     |
     |  pipeline_execute_command(self, *args, **options) -> 'Pipeline'
     |      Stage a command to be executed when execute() is next called
     |
     |      Returns the current Pipeline object back so commands can be
     |      chained together, such as:
     |
     |      pipe = pipe.set('foo', 'bar').incr('baz').decr('bang')
     |
     |      At some other point, you can then run: pipe.execute(),
     |      which will execute all commands queued in the pipe.
     |
     |  raise_first_error(self, commands, response)
     |
     |  reset(self) -> None
     |      Perform a full reset on the connection's server-side context.
     |
     |      See: https://redis.io/commands/reset
     |
     |  unwatch(self) -> bool
     |      Unwatches all previously specified keys
     |
     |  watch(self, *names)
     |      Watches the values at keys ``names``
     |
     |  ----------------------------------------------------------------------
     |  Class methods defined here:
     |
     |  __subclasshook__ = _proto_hook(other) from typing
     |
     |  ----------------------------------------------------------------------
     |  Data and other attributes defined here:
     |
     |  UNWATCH_COMMANDS = {'DISCARD', 'EXEC', 'UNWATCH'}
     |
     |  __abstractmethods__ = frozenset()
     |
     |  __annotations__ = {}
     |
     |  __parameters__ = ()
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from Redis:
     |
     |  __repr__(self) -> str
     |      Return repr(self).
     |
     |  client(self)
     |
     |  get_cache(self) -> Optional[redis.cache.CacheInterface]
     |
     |  get_connection_kwargs(self) -> Dict
     |      Get the connection's key-word arguments
     |
     |  get_encoder(self) -> 'Encoder'
     |      Get the connection pool's encoder
     |
     |  get_retry(self) -> Optional[redis.retry.Retry]
     |
     |  himport_discard(self, fieldset_name: str) -> int
     |      Remove a fieldset from the registry.
     |
     |      Returns ``1`` if it was registered, ``0`` otherwise. On a pooled client the
     |      server-side ``DISCARD`` is reconciled lazily when each connection is next
     |      used for ``himport_set``. On a single connection client it runs immediately
     |      on the pinned connection when it is live; while that connection is not
     |      connected there is nothing prepared on the server to discard (its tracking is
     |      reset on connect), so no server call is made.
     |
     |  himport_discard_all(self) -> int
     |      Remove all fieldsets from the registry.
     |
     |      Returns the number removed from the registry. Server-side removal follows the
     |      same live/lazy rule as :meth:`himport_discard`.
     |
     |  himport_prepare(self, fieldset_name: str, fields: Iterable[Union[bytes, bytearray, memoryview, str, int, float]]) -> bool
     |      Declare an HIMPORT fieldset for use by :meth:`himport_set`.
     |
     |      Registers ``fieldset_name`` (ordered ``fields``, verbatim) in the client's
     |      shared registry. On a pooled client the server-side ``PREPARE`` is deferred
     |      and bundled into the next ``himport_set`` per connection. On a single
     |      connection client it is run immediately when the pinned connection is live;
     |      while that connection is not connected there is no session state to prepare,
     |      so the next ``himport_set`` prepares it lazily instead.
     |
     |  keyspace_notifications(self, key_prefix: Union[str, bytes, NoneType] = None, ignore_subscribe_messages: bool = True) -> 'KeyspaceNotifications'
     |      Return a :class:`~redis.keyspace_notifications.KeyspaceNotifications`
     |      object for subscribing to keyspace and keyevent notifications.
     |
     |      Note: Keyspace notifications must be enabled on the Redis server via
     |      the ``notify-keyspace-events`` configuration option.
     |
     |      Args:
     |          key_prefix: Optional prefix to filter and strip from keys in
     |                      notifications.
     |          ignore_subscribe_messages: If True, subscribe/unsubscribe
     |                                    confirmations are not returned by
     |                                    get_message/listen.
     |
     |  load_external_module(self, funcname, func) -> None
     |      This function can be used to add externally defined redis modules,
     |      and their namespaces to the redis client.
     |
     |      funcname - A string containing the name of the function to create
     |      func - The function, being added to this class.
     |
     |      ex: Assume that one has a custom redis module named foomod that
     |      creates command named 'foo.dothing' and 'foo.anotherthing' in redis.
     |      To load function functions into this namespace:
     |
     |      from redis import Redis
     |      from foomodule import F
     |      r = Redis()
     |      r.load_external_module("foo", F)
     |      r.foo().dothing('your', 'arguments')
     |
     |      For a concrete example see the reimport of the redisjson module in
     |      tests/test_connection.py::test_loading_external_modules
     |
     |  lock(self, name: str, timeout: Optional[float] = None, sleep: float = 0.1, blocking: bool = True, blocking_timeout: Optional[float] = None, lock_class: Optional[Any] = None, thread_local: bool = True, raise_on_release_error: bool = True)
     |      Return a new Lock object using key ``name`` that mimics
     |      the behavior of threading.Lock.
     |
     |      If specified, ``timeout`` indicates a maximum life for the lock.
     |      By default, it will remain locked until release() is called.
     |
     |      ``sleep`` indicates the amount of time to sleep per loop iteration
     |      when the lock is in blocking mode and another client is currently
     |      holding the lock.
     |
     |      ``blocking`` indicates whether calling ``acquire`` should block until
     |      the lock has been acquired or to fail immediately, causing ``acquire``
     |      to return False and the lock not being acquired. Defaults to True.
     |      Note this value can be overridden by passing a ``blocking``
     |      argument to ``acquire``.
     |
     |      ``blocking_timeout`` indicates the maximum amount of time in seconds to
     |      spend trying to acquire the lock. A value of ``None`` indicates
     |      continue trying forever. ``blocking_timeout`` can be specified as a
     |      float or integer, both representing the number of seconds to wait.
     |
     |      ``lock_class`` forces the specified lock implementation. Note that as
     |      of redis-py 3.0, the only lock class we implement is ``Lock`` (which is
     |      a Lua-based lock). So, it's unlikely you'll need this parameter, unless
     |      you have created your own custom lock class.
     |
     |      ``thread_local`` indicates whether the lock token is placed in
     |      thread-local storage. By default, the token is placed in thread local
     |      storage so that a thread only sees its token, not a token set by
     |      another thread. Consider the following timeline:
     |
     |          time: 0, thread-1 acquires `my-lock`, with a timeout of 5 seconds.
     |                   thread-1 sets the token to "abc"
     |          time: 1, thread-2 blocks trying to acquire `my-lock` using the
     |                   Lock instance.
     |          time: 5, thread-1 has not yet completed. redis expires the lock
     |                   key.
     |          time: 5, thread-2 acquired `my-lock` now that it's available.
     |                   thread-2 sets the token to "xyz"
     |          time: 6, thread-1 finishes its work and calls release(). if the
     |                   token is *not* stored in thread local storage, then
     |                   thread-1 would see the token value as "xyz" and would be
     |                   able to successfully release the thread-2's lock.
     |
     |      ``raise_on_release_error`` indicates whether to raise an exception when
     |      the lock is no longer owned when exiting the context manager. By default,
     |      this is True, meaning an exception will be raised. If False, the warning
     |      will be logged and the exception will be suppressed.
     |
     |      In some use cases it's necessary to disable thread local storage. For
     |      example, if you have code where one thread acquires a lock and passes
     |      that lock instance to a worker thread to release later. If thread
     |      local storage isn't disabled in this case, the worker thread won't see
     |      the token set by the thread that acquired the lock. Our assumption
     |      is that these cases aren't common and as such default to using
     |      thread local storage.
     |
     |  monitor(self)
     |
     |  pipeline(self, transaction=True, shard_hint=None) -> 'Pipeline'
     |      Return a new pipeline object that can queue multiple commands for
     |      later execution. ``transaction`` indicates whether all commands
     |      should be executed atomically. Apart from making a group of operations
     |      atomic, pipelines are useful for reducing the back-and-forth overhead
     |      between the client and server.
     |
     |  pubsub(self, **kwargs)
     |      Return a Publish/Subscribe object. With this object, you can
     |      subscribe to channels and listen for messages that get published to
     |      them.
     |
     |  set_response_callback(self, command: str, callback: Callable) -> None
     |      Set a custom Response Callback
     |
     |  set_retry(self, retry: redis.retry.Retry) -> None
     |
     |  transaction(self, func: Callable[[ForwardRef('Pipeline')], NoneType], *watches, **kwargs) -> Union[List[Any], Any, NoneType]
     |      Convenience method for executing the callable `func` as a transaction
     |      while watching all keys specified in `watches`. The 'func' callable
     |      should expect a single argument which is a Pipeline object.
     |
     |  ----------------------------------------------------------------------
     |  Class methods inherited from Redis:
     |
     |  from_pool(connection_pool: redis.connection.ConnectionPool) -> 'Redis'
     |      Return a Redis client from the given connection pool.
     |      The Redis client will take ownership of the connection pool and
     |      close it when the Redis client is closed.
     |
     |      Because the client closes (disconnects all connections in) the pool
     |      when it is closed or garbage-collected, the pool must not be shared
     |      with other clients. Constructing multiple clients from the same pool
     |      via ``from_pool`` -- for example one per request across threads -- is
     |      not thread safe: when one client is closed it will disconnect
     |      connections still in use by the others.
     |
     |      To share a single pool across clients, construct the pool explicitly
     |      and manage its lifecycle instead. Unlike ``from_pool``, the plain
     |      ``Redis(connection_pool=pool)`` constructor does not take ownership of
     |      the pool and will not close it, so a pool created this way can be
     |      safely shared across clients. ``ConnectionPool`` supports the context
     |      manager protocol for this::
     |
     |          with ConnectionPool.from_url(url) as pool:
     |              r = Redis(connection_pool=pool)
     |
     |  from_url(url: str, **kwargs) -> 'Redis'
     |      Return a Redis client object configured from the given URL
     |
     |      For example::
     |
     |          redis://[[username]:[password]]@localhost:6379/0
     |          rediss://[[username]:[password]]@localhost:6379/0
     |          unix://[username@]/path/to/socket.sock?db=0[&password=password]
     |
     |      Three URL schemes are supported:
     |
     |      - `redis://` creates a TCP socket connection. See more at:
     |        <https://www.iana.org/assignments/uri-schemes/prov/redis>
     |      - `rediss://` creates a SSL wrapped TCP socket connection. See more at:
     |        <https://www.iana.org/assignments/uri-schemes/prov/rediss>
     |      - ``unix://``: creates a Unix Domain Socket connection.
     |
     |      The username, password, hostname, path and all querystring values
     |      are passed through urllib.parse.unquote in order to replace any
     |      percent-encoded values with their corresponding characters.
     |
     |      There are several ways to specify a database number. The first value
     |      found will be used:
     |
     |          1. A ``db`` querystring option, e.g. redis://localhost?db=0
     |          2. If using the redis:// or rediss:// schemes, the path argument
     |             of the url, e.g. redis://localhost/0
     |          3. A ``db`` keyword argument to this function.
     |
     |      If none of these options are specified, the default db=0 is used.
     |
     |      All querystring options are cast to their appropriate Python types.
     |      Boolean arguments can be specified with string values "True"/"False"
     |      or "Yes"/"No". Values that cannot be properly cast cause a
     |      ``ValueError`` to be raised. Once parsed, the querystring arguments
     |      and keyword arguments are passed to the ``ConnectionPool``'s
     |      class initializer. In the case of conflicting arguments, querystring
     |      arguments always win.
     |
     |  ----------------------------------------------------------------------
     |  Readonly properties inherited from Redis:
     |
     |  himport_registry
     |      The client's HIMPORT fieldset registry (contains empty
     |      schema registry if none was declared).
     |
     |      Read-only: the registry is mutated only through the HIMPORT command methods.
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from redis.commands.redismodules.RedisModuleCommands:
     |
     |  bf(self) -> 'BFBloom'
     |      Access the bloom namespace.
     |
     |  cf(self) -> 'CFBloom'
     |      Access the bloom namespace.
     |
     |  cms(self) -> 'CMSBloom'
     |      Access the bloom namespace.
     |
     |  ft(self, index_name='idx') -> 'Search'
     |      Access the search namespace, providing support for redis search.
     |
     |  json(self, encoder=<json.encoder.JSONEncoder object at 0x0000017B9C588F50>, decoder=<json.decoder.JSONDecoder object at 0x0000017B9C588FB0>) -> 'JSON'
     |      Access the json namespace, providing support for redis json.
     |
     |  tdigest(self) -> 'TDigestBloom'
     |      Access the bloom namespace.
     |
     |  topk(self) -> 'TOPKBloom'
     |      Access the bloom namespace.
     |
     |  ts(self) -> 'TimeSeries'
     |      Access the timeseries namespace, providing support for
     |      redis timeseries data.
     |
     |  vset(self) -> 'VectorSet'
     |      Access the VectorSet commands namespace.
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors inherited from redis.commands.redismodules.RedisModuleCommands:
     |
     |  __dict__
     |      dictionary for instance variables
     |
     |  __weakref__
     |      list of weak references to the object
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from redis.commands.core.ACLCommands:
     |
     |  acl_cat(self, category: 'str | None' = None, **kwargs) -> 'list[bytes | str] | Awaitable[list[bytes | str]]'
     |      Returns a list of categories or commands within a category.
     |
     |      If ``category`` is not supplied, returns a list of all categories.
     |      If ``category`` is supplied, returns a list of all commands within
     |      that category.
     |
     |      For more information, see https://redis.io/commands/acl-cat
     |
     |  acl_deluser(self, *username: 'str', **kwargs) -> 'int | Awaitable[int]'
     |      Delete the ACL for the specified ``username``\s
     |
     |      For more information, see https://redis.io/commands/acl-deluser
     |
     |  acl_dryrun(self, username: 'str', *args: 'EncodableT', **kwargs) -> 'bytes | str | Awaitable[bytes | str]'
     |      Simulate the execution of a given command by a given ``username``.
     |
     |      For more information, see https://redis.io/commands/acl-dryrun
     |
     |  acl_genpass(self, bits: 'int | None' = None, **kwargs) -> 'bytes | str | Awaitable[bytes | str]'
     |      Generate a random password value.
     |      If ``bits`` is supplied then use this number of bits, rounded to
     |      the next multiple of 4.
     |      See: https://redis.io/commands/acl-genpass
     |
     |  acl_getuser(self, username: 'str', **kwargs) -> 'ACLGetUserData | Awaitable[ACLGetUserData]'
     |      Get the ACL details for the specified ``username``.
     |
     |      If ``username`` does not exist, return None
     |
     |      For more information, see https://redis.io/commands/acl-getuser
     |
     |  acl_help(self, **kwargs) -> 'list[bytes | str] | Awaitable[list[bytes | str]]'
     |      The ACL HELP command returns helpful text describing
     |      the different subcommands.
     |
     |      For more information, see https://redis.io/commands/acl-help
     |
     |  acl_list(self, **kwargs) -> 'list[bytes | str] | Awaitable[list[bytes | str]]'
     |      Return a list of all ACLs on the server
     |
     |      For more information, see https://redis.io/commands/acl-list
     |
     |  acl_load(self, **kwargs) -> 'bool | Awaitable[bool]'
     |      Load ACL rules from the configured ``aclfile``.
     |
     |      Note that the server must be configured with the ``aclfile``
     |      directive to be able to load ACL rules from an aclfile.
     |
     |      For more information, see https://redis.io/commands/acl-load
     |
     |  acl_log(self, count: 'int | None' = None, **kwargs) -> 'ACLLogData | Awaitable[ACLLogData]'
     |      Get ACL logs as a list.
     |      :param int count: Get logs[0:count].
     |      :rtype: List.
     |
     |      For more information, see https://redis.io/commands/acl-log
     |
     |  acl_log_reset(self, **kwargs) -> 'bool | Awaitable[bool]'
     |      Reset ACL logs.
     |      :rtype: Boolean.
     |
     |      For more information, see https://redis.io/commands/acl-log
     |
     |  acl_save(self, **kwargs) -> 'bool | Awaitable[bool]'
     |      Save ACL rules to the configured ``aclfile``.
     |
     |      Note that the server must be configured with the ``aclfile``
     |      directive to be able to save ACL rules to an aclfile.
     |
     |      For more information, see https://redis.io/commands/acl-save
     |
     |  acl_setuser(self, username: 'str', enabled: 'bool' = False, nopass: 'bool' = False, passwords: 'str | Iterable[str] | None' = None, hashed_passwords: 'str | Iterable[str] | None' = None, categories: 'Iterable[str] | None' = None, commands: 'Iterable[str] | None' = None, keys: 'Iterable[KeyT] | None' = None, channels: 'Iterable[ChannelT] | None' = None, selectors: 'Iterable[Tuple[str, KeyT]] | None' = None, reset: 'bool' = False, reset_keys: 'bool' = False, reset_channels: 'bool' = False, reset_passwords: 'bool' = False, **kwargs) -> 'bool | Awaitable[bool]'
     |      Create or update an ACL user.
     |
     |      Create or update the ACL for `username`. If the user already exists,
     |      the existing ACL is completely overwritten and replaced with the
     |      specified values.
     |
     |      For more information, see https://redis.io/commands/acl-setuser
     |
     |      Args:
     |          username: The name of the user whose ACL is to be created or updated.
     |          enabled: Indicates whether the user should be allowed to authenticate.
     |                   Defaults to `False`.
     |          nopass: Indicates whether the user can authenticate without a password.
     |                  This cannot be `True` if `passwords` are also specified.
     |          passwords: A list of plain text passwords to add to or remove from the user.
     |                     Each password must be prefixed with a '+' to add or a '-' to
     |                     remove. For convenience, a single prefixed string can be used
     |                     when adding or removing a single password.
     |          hashed_passwords: A list of SHA-256 hashed passwords to add to or remove
     |                            from the user. Each hashed password must be prefixed with
     |                            a '+' to add or a '-' to remove. For convenience, a single
     |                            prefixed string can be used when adding or removing a
     |                            single password.
     |          categories: A list of strings representing category permissions. Each string
     |                      must be prefixed with either a '+' to add the category
     |                      permission or a '-' to remove the category permission.
     |          commands: A list of strings representing command permissions. Each string
     |                    must be prefixed with either a '+' to add the command permission
     |                    or a '-' to remove the command permission.
     |          keys: A list of key patterns to grant the user access to. Key patterns allow
     |                ``'*'`` to support wildcard matching. For example, ``'*'`` grants
     |                access to all keys while ``'cache:*'`` grants access to all keys that
     |                are prefixed with ``cache:``.
     |                `keys` should not be prefixed with a ``'~'``.
     |          reset: Indicates whether the user should be fully reset prior to applying
     |                 the new ACL. Setting this to `True` will remove all existing
     |                 passwords, flags, and privileges from the user and then apply the
     |                 specified rules. If `False`, the user's existing passwords, flags,
     |                 and privileges will be kept and any new specified rules will be
     |                 applied on top.
     |          reset_keys: Indicates whether the user's key permissions should be reset
     |                      prior to applying any new key permissions specified in `keys`.
     |                      If `False`, the user's existing key permissions will be kept and
     |                      any new specified key permissions will be applied on top.
     |          reset_channels: Indicates whether the user's channel permissions should be
     |                          reset prior to applying any new channel permissions
     |                          specified in `channels`. If `False`, the user's existing
     |                          channel permissions will be kept and any new specified
     |                          channel permissions will be applied on top.
     |          reset_passwords: Indicates whether to remove all existing passwords and the
     |                           `nopass` flag from the user prior to applying any new
     |                           passwords specified in `passwords` or `hashed_passwords`.
     |                           If `False`, the user's existing passwords and `nopass`
     |                           status will be kept and any new specified passwords or
     |                           hashed passwords will be applied on top.
     |
     |  acl_users(self, **kwargs) -> 'list[bytes | str] | Awaitable[list[bytes | str]]'
     |      Returns a list of all registered users on the server.
     |
     |      For more information, see https://redis.io/commands/acl-users
     |
     |  acl_whoami(self, **kwargs) -> 'bytes | str | Awaitable[bytes | str]'
     |      Get the username for the current connection
     |
     |      For more information, see https://redis.io/commands/acl-whoami
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from redis.commands.core.ClusterCommands:
     |
     |  cluster(self, cluster_arg, *args, **kwargs) -> 'Any | Awaitable[Any]'
     |
     |  readonly(self, **kwargs) -> 'bool | Awaitable[bool]'
     |      Enables read queries for a connection to a Redis Cluster replica node.
     |
     |      For more information, see https://redis.io/commands/readonly
     |
     |  readwrite(self, **kwargs) -> 'bool | Awaitable[bool]'
     |      Disables read queries for a connection to a Redis Cluster slave node.
     |
     |      For more information, see https://redis.io/commands/readwrite
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from redis.commands.core.BasicKeyCommands:
     |
     |  __contains__ = exists(self, *names: 'KeyT') -> 'int | Awaitable[int]'
     |
     |  __delitem__(self, name: 'KeyT')
     |
     |  __getitem__(self, name: 'KeyT')
     |      Return the value at key ``name``, raises a KeyError if the key
     |      doesn't exist.
     |
     |  __setitem__(self, name: 'KeyT', value: 'EncodableT')
     |
     |  append(self, key: 'KeyT', value: 'EncodableT') -> 'int | Awaitable[int]'
     |      Appends the string ``value`` to the value at ``key``. If ``key``
     |      doesn't already exist, create it with a value of ``value``.
     |      Returns the new length of the value at ``key``.
     |
     |      For more information, see https://redis.io/commands/append
     |
     |  bitcount(self, key: 'KeyT', start: 'int | None' = None, end: 'int | None' = None, mode: 'str | None' = None) -> 'int | Awaitable[int]'
     |      Returns the count of set bits in the value of ``key``.  Optional
     |      ``start`` and ``end`` parameters indicate which bytes to consider
     |
     |      For more information, see https://redis.io/commands/bitcount
     |
     |  bitfield(self: "Union['redis.client.Redis', 'redis.asyncio.client.Redis']", key: 'KeyT', default_overflow: 'str | None' = None) -> 'BitFieldOperation'
     |      Return a BitFieldOperation instance to conveniently construct one or
     |      more bitfield operations on ``key``.
     |
     |      For more information, see https://redis.io/commands/bitfield
     |
     |  bitfield_ro(self: "Union['redis.client.Redis', 'redis.asyncio.client.Redis']", key: 'KeyT', encoding: 'str', offset: 'BitfieldOffsetT', items: 'list[tuple[str, BitfieldOffsetT]] | None' = None) -> 'list[int] | Awaitable[list[int]]'
     |      Return an array of the specified bitfield values
     |      where the first value is found using ``encoding`` and ``offset``
     |      parameters and remaining values are result of corresponding
     |      encoding/offset pairs in optional list ``items``
     |      Read-only variant of the BITFIELD command.
     |
     |      For more information, see https://redis.io/commands/bitfield_ro
     |
     |  bitop(self, operation: 'str', dest: 'KeyT', *keys: 'KeyT') -> 'int | Awaitable[int]'
     |      Perform a bitwise operation using ``operation`` between ``keys`` and
     |      store the result in ``dest``.
     |
     |      For more information, see https://redis.io/commands/bitop
     |
     |  bitpos(self, key: 'KeyT', bit: 'int', start: 'int | None' = None, end: 'int | None' = None, mode: 'str | None' = None) -> 'int | Awaitable[int]'
     |      Return the position of the first bit set to 1 or 0 in a string.
     |      ``start`` and ``end`` defines search range. The range is interpreted
     |      as a range of bytes and not a range of bits, so start=0 and end=2
     |      means to look at the first three bytes.
     |
     |      For more information, see https://redis.io/commands/bitpos
     |
     |  blmove(self, first_list: 'str', second_list: 'str', timeout: 'int', src: 'str' = 'LEFT', dest: 'str' = 'RIGHT') -> 'bytes | str | None | Awaitable[bytes | str | None]'
     |      Blocking version of lmove.
     |
     |      For more information, see https://redis.io/commands/blmove
     |
     |  blmovem(self, first_list: 'str', second_list: 'str', timeout: 'float', src: 'str' = 'LEFT', dest: 'str' = 'RIGHT', count: 'int | None' = None, mode: "Literal['COUNT', 'EXACTLY'] | None" = None, ordering: "Literal['OBO', 'BULK'] | None" = None) -> 'list[bytes | str] | None | Awaitable[list[bytes | str] | None]'
     |      Blocking version of lmovem.
     |
     |      Blocks until elements are available to move or ``timeout`` (in seconds)
     |      is reached; a ``timeout`` of ``0`` blocks indefinitely. With ``COUNT``
     |      the command unblocks once at least one element is available and moves
     |      ``min(count, available)``; with ``EXACTLY`` it blocks until the source
     |      holds at least ``count`` elements, then moves exactly ``count``
     |      atomically. On timeout ``None`` is returned and nothing is moved.
     |
     |      As with ``lmovem``, ``ordering`` (OBO or BULK) is required whenever
     |      ``count`` is given.
     |
     |      For more information, see https://redis.io/commands/blmovem
     |
     |  copy(self, source: 'str', destination: 'str', destination_db: 'str | None' = None, replace: 'bool' = False) -> 'bool | Awaitable[bool]'
     |      Copy the value stored in the ``source`` key to the ``destination`` key.
     |
     |      ``destination_db`` an alternative destination database. By default,
     |      the ``destination`` key is created in the source Redis database.
     |
     |      ``replace`` whether the ``destination`` key should be removed before
     |      copying the value to it. By default, the value is not copied if
     |      the ``destination`` key already exists.
     |
     |      For more information, see https://redis.io/commands/copy
     |
     |  decr = decrby(self, name: 'KeyT', amount: 'int' = 1) -> 'int | Awaitable[int]'
     |
     |  decrby(self, name: 'KeyT', amount: 'int' = 1) -> 'int | Awaitable[int]'
     |      Decrements the value of ``key`` by ``amount``.  If no key exists,
     |      the value will be initialized as 0 - ``amount``
     |
     |      For more information, see https://redis.io/commands/decrby
     |
     |  delete(self, *names: 'KeyT') -> 'int | Awaitable[int]'
     |      Delete one or more keys specified by ``names``
     |
     |  delex(self, name: 'KeyT', ifeq: 'bytes | str | None' = None, ifne: 'bytes | str | None' = None, ifdeq: 'str | None' = None, ifdne: 'str | None' = None) -> 'int | Awaitable[int]'
     |      Conditionally removes the specified key.
     |
     |      Warning:
     |      **Experimental** since 7.1.
     |      This API may change or be removed without notice.
     |      The API may change based on feedback.
     |
     |      Arguments:
     |          name: KeyT - the key to delete
     |          ifeq match-valu: Optional[Union[bytes, str]] - Delete the key only if its value is equal to match-value
     |          ifne match-value: Optional[Union[bytes, str]] - Delete the key only if its value is not equal to match-value
     |          ifdeq match-digest: Optional[str] - Delete the key only if the digest of its value is equal to match-digest
     |          ifdne match-digest: Optional[str] - Delete the key only if the digest of its value is not equal to match-digest
     |
     |      Returns:
     |          int: 1 if the key was deleted, 0 otherwise.
     |      Raises:
     |          redis.exceptions.ResponseError: if key exists but is not a string
     |                                          and a condition is specified.
     |          ValueError: if more than one condition is provided.
     |
     |
     |      Requires Redis 8.4 or greater.
     |      For more information, see https://redis.io/commands/delex
     |
     |  digest(self, name: 'KeyT') -> 'str | bytes | None | Awaitable[str | bytes | None]'
     |      Return the digest of the value stored at the specified key.
     |
     |      Warning:
     |      **Experimental** since 7.1.
     |      This API may change or be removed without notice.
     |      The API may change based on feedback.
     |
     |      Arguments:
     |        - name: KeyT - the key to get the digest of
     |
     |      Returns:
     |        - None if the key does not exist
     |        - (bulk string) the XXH3 digest of the value as a hex string
     |      Raises:
     |        - ResponseError if key exists but is not a string
     |
     |
     |      Requires Redis 8.4 or greater.
     |      For more information, see https://redis.io/commands/digest
     |
     |  digest_local(self, value: 'bytes | str') -> 'bytes | str'
     |      Compute the hexadecimal digest of the value locally, without sending it to the server.
     |
     |      This is useful for conditional operations like IFDEQ/IFDNE where you need to
     |      compute the digest client-side before sending a command.
     |
     |      Warning:
     |      **Experimental** - This API may change or be removed without notice.
     |
     |      Arguments:
     |        - value: Union[bytes, str] - the value to compute the digest of.
     |          If a string is provided, it will be encoded using UTF-8 before hashing,
     |          which matches Redis's default encoding behavior.
     |
     |      Returns:
     |        - (str | bytes) the XXH3 digest of the value as a hex string (16 hex characters).
     |          Returns bytes if decode_responses is False, otherwise returns str.
     |
     |      For more information, see https://redis.io/commands/digest
     |
     |  dump(self, name: 'KeyT') -> 'bytes | None | Awaitable[bytes | None]'
     |      Return a serialized version of the value stored at the specified key.
     |      If key does not exist a nil bulk reply is returned.
     |
     |      For more information, see https://redis.io/commands/dump
     |
     |  exists(self, *names: 'KeyT') -> 'int | Awaitable[int]'
     |      Returns the number of ``names`` that exist
     |
     |      For more information, see https://redis.io/commands/exists
     |
     |  expire(self, name: 'KeyT', time: 'ExpiryT', nx: 'bool' = False, xx: 'bool' = False, gt: 'bool' = False, lt: 'bool' = False) -> 'bool | Awaitable[bool]'
     |      Set an expire flag on key ``name`` for ``time`` seconds with given
     |      ``option``. ``time`` can be represented by an integer or a Python timedelta
     |      object.
     |
     |      Valid options are:
     |          NX -> Set expiry only when the key has no expiry
     |          XX -> Set expiry only when the key has an existing expiry
     |          GT -> Set expiry only when the new expiry is greater than current one
     |          LT -> Set expiry only when the new expiry is less than current one
     |
     |      For more information, see https://redis.io/commands/expire
     |
     |  expireat(self, name: 'KeyT', when: 'AbsExpiryT', nx: 'bool' = False, xx: 'bool' = False, gt: 'bool' = False, lt: 'bool' = False) -> 'bool | Awaitable[bool]'
     |      Set an expire flag on key ``name`` with given ``option``. ``when``
     |      can be represented as an integer indicating unix time or a Python
     |      datetime object.
     |
     |      Valid options are:
     |          -> NX -- Set expiry only when the key has no expiry
     |          -> XX -- Set expiry only when the key has an existing expiry
     |          -> GT -- Set expiry only when the new expiry is greater than current one
     |          -> LT -- Set expiry only when the new expiry is less than current one
     |
     |      For more information, see https://redis.io/commands/expireat
     |
     |  expiretime(self, key: 'str') -> 'int | Awaitable[int]'
     |      Returns the absolute Unix timestamp (since January 1, 1970) in seconds
     |      at which the given key will expire.
     |
     |      For more information, see https://redis.io/commands/expiretime
     |
     |  get(self, name: 'KeyT') -> 'bytes | str | None | Awaitable[bytes | str | None]'
     |      Return the value at key ``name``, or None if the key doesn't exist
     |
     |      For more information, see https://redis.io/commands/get
     |
     |  getbit(self, name: 'KeyT', offset: 'int') -> 'int | Awaitable[int]'
     |      Returns an integer indicating the value of ``offset`` in ``name``
     |
     |      For more information, see https://redis.io/commands/getbit
     |
     |  getdel(self, name: 'KeyT') -> 'bytes | str | None | Awaitable[bytes | str | None]'
     |      Get the value at key ``name`` and delete the key. This command
     |      is similar to GET, except for the fact that it also deletes
     |      the key on success (if and only if the key's value type
     |      is a string).
     |
     |      For more information, see https://redis.io/commands/getdel
     |
     |  getex(self, name: 'KeyT', ex: 'ExpiryT | None' = None, px: 'ExpiryT | None' = None, exat: 'AbsExpiryT | None' = None, pxat: 'AbsExpiryT | None' = None, persist: 'bool' = False) -> 'bytes | str | None | Awaitable[bytes | str | None]'
     |      Get the value of key and optionally set its expiration.
     |      GETEX is similar to GET, but is a write command with
     |      additional options. All time parameters can be given as
     |      datetime.timedelta or integers.
     |
     |      ``ex`` sets an expire flag on key ``name`` for ``ex`` seconds.
     |
     |      ``px`` sets an expire flag on key ``name`` for ``px`` milliseconds.
     |
     |      ``exat`` sets an expire flag on key ``name`` for ``ex`` seconds,
     |      specified in unix time.
     |
     |      ``pxat`` sets an expire flag on key ``name`` for ``ex`` milliseconds,
     |      specified in unix time.
     |
     |      ``persist`` remove the time to live associated with ``name``.
     |
     |      For more information, see https://redis.io/commands/getex
     |
     |  getrange(self, key: 'KeyT', start: 'int', end: 'int') -> 'bytes | str | Awaitable[bytes | str]'
     |      Returns the substring of the string value stored at ``key``,
     |      determined by the offsets ``start`` and ``end`` (both are inclusive)
     |
     |      For more information, see https://redis.io/commands/getrange
     |
     |  getset(self, name: 'KeyT', value: 'EncodableT') -> 'bytes | str | None | Awaitable[bytes | str | None]'
     |      Sets the value at key ``name`` to ``value``
     |      and returns the old value at key ``name`` atomically.
     |
     |      As per Redis 6.2, GETSET is considered deprecated.
     |      Please use SET with GET parameter in new code.
     |
     |      For more information, see https://redis.io/commands/getset
     |
     |  hrandfield(self, key: 'KeyT', count: 'int | None' = None, withvalues: 'bool' = False) -> 'HRandFieldResponse | Awaitable[HRandFieldResponse]'
     |      Return a random field from the hash value stored at key.
     |
     |      count: if the argument is positive, return an array of distinct fields.
     |      If called with a negative count, the behavior changes and the command
     |      is allowed to return the same field multiple times. In this case,
     |      the number of returned fields is the absolute value of the
     |      specified count.
     |      withvalues: The optional WITHVALUES modifier changes the reply so it
     |      includes the respective values of the randomly selected hash fields.
     |
     |      For more information, see https://redis.io/commands/hrandfield
     |
     |  incr = incrby(self, name: 'KeyT', amount: 'int' = 1) -> 'int | Awaitable[int]'
     |
     |  incrby(self, name: 'KeyT', amount: 'int' = 1) -> 'int | Awaitable[int]'
     |      Increments the value of ``key`` by ``amount``.  If no key exists,
     |      the value will be initialized as ``amount``
     |
     |      For more information, see https://redis.io/commands/incrby
     |
     |  incrbyfloat(self, name: 'KeyT', amount: 'float' = 1.0) -> 'float | Awaitable[float]'
     |      Increments the value at key ``name`` by floating ``amount``.
     |      If no key exists, the value will be initialized as ``amount``
     |
     |      For more information, see https://redis.io/commands/incrbyfloat
     |
     |  increx(self, name: 'KeyT', *, byfloat: 'EncodableT | None' = None, byint: 'EncodableT | None' = None, lbound: 'EncodableT | None' = None, ubound: 'EncodableT | None' = None, saturate: 'bool' = False, ex: 'ExpiryT | None' = None, px: 'ExpiryT | None' = None, exat: 'AbsExpiryT | None' = None, pxat: 'AbsExpiryT | None' = None, persist: 'bool' = False, enx: 'bool' = False) -> 'list[Number | bytes | str] | Awaitable[list[Number | bytes | str]]'
     |      Increment the numeric value at key ``name`` and return the new value
     |      and the actual increment.
     |
     |      ``byfloat`` increments a floating point value by the provided amount.
     |
     |      ``byint`` increments an integer value by the provided amount.
     |
     |      If neither ``byfloat`` nor ``byint`` is specified, the value is
     |      incremented by one.
     |
     |      ``lbound`` and ``ubound`` constrain the valid range of the result.
     |
     |      If ``saturate`` is True, out-of-bounds results are saturated to the
     |      specified bound, or to the type limit when no bound is specified.
     |      Otherwise, out-of-bounds results are rejected, leaving the value and
     |      TTL unchanged and returning the current value and zero as the actual
     |      increment.
     |
     |      ``enx`` applies the expiration only when the key does not already
     |      have an expiration, and requires ``ex``, ``px``, ``exat``, or ``pxat``.
     |
     |  keys(self, pattern: 'PatternT' = '*', **kwargs) -> 'list[bytes | str] | Awaitable[list[bytes | str]]'
     |      Returns a list of keys matching ``pattern``
     |
     |      For more information, see https://redis.io/commands/keys
     |
     |  lcs(self, key1: 'str', key2: 'str', len: 'bool | None' = False, idx: 'bool | None' = False, minmatchlen: 'int | None' = 0, withmatchlen: 'bool | None' = False) -> 'LCSCommandResponse | Awaitable[LCSCommandResponse]'
     |      Find the longest common subsequence between ``key1`` and ``key2``.
     |      If ``len`` is true the length of the match will be returned.
     |      If ``idx`` is true the match position in each strings will be returned.
     |      ``minmatchlen`` restrict the list of matches to the ones of
     |      the given ``minmatchlen``.
     |      If ``withmatchlen`` the length of the match also will be returned.
     |      For more information, see https://redis.io/commands/lcs
     |
     |  lmove(self, first_list: 'str', second_list: 'str', src: 'str' = 'LEFT', dest: 'str' = 'RIGHT') -> 'bytes | str | None | Awaitable[bytes | str | None]'
     |      Atomically returns and removes the first/last element of a list,
     |      pushing it as the first/last element on the destination list.
     |      Returns the element being popped and pushed.
     |
     |      For more information, see https://redis.io/commands/lmove
     |
     |  lmovem(self, first_list: 'str', second_list: 'str', src: 'str' = 'LEFT', dest: 'str' = 'RIGHT', count: 'int | None' = None, mode: "Literal['COUNT', 'EXACTLY'] | None" = None, ordering: "Literal['OBO', 'BULK'] | None" = None) -> 'list[bytes | str] | None | Awaitable[list[bytes | str] | None]'
     |      Atomically moves multiple elements from one end of the ``first_list``
     |      to one end of the ``second_list``, returning the moved elements in
     |      destination order.
     |
     |      ``src`` and ``dest`` are the ends to pop from / push to, either
     |      ``LEFT`` (head) or ``RIGHT`` (tail).
     |
     |      When ``count`` is given, ``mode`` selects how many elements to move:
     |      ``COUNT`` (the default) moves up to ``count`` elements, while
     |      ``EXACTLY`` moves exactly ``count`` elements or nothing at all. When
     |      ``count`` is not given a single element is moved.
     |
     |      ``ordering`` controls the order at the destination: ``OBO`` pushes each
     |      element as it is popped (reversing block order, stack semantics) while
     |      ``BULK`` preserves the original relative order (queue semantics). It is
     |      required whenever ``count`` is given.
     |
     |      Returns the array of moved elements, or ``None`` if nothing was moved.
     |
     |      For more information, see https://redis.io/commands/lmovem
     |
     |  mget(self, keys: 'KeysT', *args: 'EncodableT') -> 'list[bytes | str | None] | Awaitable[list[bytes | str | None]]'
     |      Returns a list of values ordered identically to ``keys``
     |
     |      ** Important ** When this method is used with Cluster clients, all keys
     |              must be in the same hash slot, otherwise a RedisClusterException
     |              will be raised.
     |
     |      For more information, see https://redis.io/commands/mget
     |
     |  move(self, name: 'KeyT', db: 'int') -> 'bool | Awaitable[bool]'
     |      Moves the key ``name`` to a different Redis database ``db``
     |
     |      For more information, see https://redis.io/commands/move
     |
     |  mset(self, mapping: 'Mapping[AnyKeyT, EncodableT]') -> 'bool | Awaitable[bool]'
     |      Sets key/values based on a mapping. Mapping is a dictionary of
     |      key/value pairs. Both keys and values should be strings or types that
     |      can be cast to a string via str().
     |
     |      ** Important ** When this method is used with Cluster clients, all keys
     |              must be in the same hash slot, otherwise a RedisClusterException
     |              will be raised.
     |
     |      For more information, see https://redis.io/commands/mset
     |
     |  msetex(self, mapping: 'Mapping[AnyKeyT, EncodableT]', data_persist_option: 'DataPersistOptions | None' = None, ex: 'ExpiryT | None' = None, px: 'ExpiryT | None' = None, exat: 'AbsExpiryT | None' = None, pxat: 'AbsExpiryT | None' = None, keepttl: 'bool' = False) -> 'int | Awaitable[int]'
     |      Sets key/values based on the provided ``mapping`` items.
     |
     |      ** Important ** When this method is used with Cluster clients, all keys
     |                      must be in the same hash slot, otherwise a RedisClusterException
     |                      will be raised.
     |
     |      ``mapping`` accepts a dict of key/value pairs that will be added to the database.
     |
     |      ``data_persist_option`` can be set to ``NX`` or ``XX`` to control the
     |          behavior of the command.
     |          ``NX`` will set the value for each provided key to each
     |              provided value only if all do not already exist.
     |          ``XX`` will set the value for each provided key to each
     |              provided value only if all already exist.
     |
     |      ``ex`` sets an expire flag on the keys in ``mapping`` for ``ex`` seconds.
     |
     |      ``px`` sets an expire flag on the keys in ``mapping`` for ``px`` milliseconds.
     |
     |      ``exat`` sets an expire flag on the keys in ``mapping`` for ``exat`` seconds,
     |          specified in unix time.
     |
     |      ``pxat`` sets an expire flag on the keys in ``mapping`` for ``pxat`` milliseconds,
     |          specified in unix time.
     |
     |      ``keepttl`` if True, retain the time to live associated with the keys.
     |
     |      Returns the number of fields that were added.
     |
     |      Available since Redis 8.4
     |      For more information, see https://redis.io/commands/msetex
     |
     |  msetnx(self, mapping: 'Mapping[AnyKeyT, EncodableT]') -> 'bool | Awaitable[bool]'
     |      Sets key/values based on a mapping if none of the keys are already set.
     |      Mapping is a dictionary of key/value pairs. Both keys and values
     |      should be strings or types that can be cast to a string via str().
     |      Returns a boolean indicating if the operation was successful.
     |
     |      ** Important ** When this method is used with Cluster clients, all keys
     |                      must be in the same hash slot, otherwise a RedisClusterException
     |                      will be raised.
     |
     |      For more information, see https://redis.io/commands/msetnx
     |
     |  persist(self, name: 'KeyT') -> 'bool | Awaitable[bool]'
     |      Removes an expiration on ``name``
     |
     |      For more information, see https://redis.io/commands/persist
     |
     |  pexpire(self, name: 'KeyT', time: 'ExpiryT', nx: 'bool' = False, xx: 'bool' = False, gt: 'bool' = False, lt: 'bool' = False) -> 'bool | Awaitable[bool]'
     |      Set an expire flag on key ``name`` for ``time`` milliseconds
     |      with given ``option``. ``time`` can be represented by an
     |      integer or a Python timedelta object.
     |
     |      Valid options are:
     |          NX -> Set expiry only when the key has no expiry
     |          XX -> Set expiry only when the key has an existing expiry
     |          GT -> Set expiry only when the new expiry is greater than current one
     |          LT -> Set expiry only when the new expiry is less than current one
     |
     |      For more information, see https://redis.io/commands/pexpire
     |
     |  pexpireat(self, name: 'KeyT', when: 'AbsExpiryT', nx: 'bool' = False, xx: 'bool' = False, gt: 'bool' = False, lt: 'bool' = False) -> 'bool | Awaitable[bool]'
     |      Set an expire flag on key ``name`` with given ``option``. ``when``
     |      can be represented as an integer representing unix time in
     |      milliseconds (unix time * 1000) or a Python datetime object.
     |
     |      Valid options are:
     |          NX -> Set expiry only when the key has no expiry
     |          XX -> Set expiry only when the key has an existing expiry
     |          GT -> Set expiry only when the new expiry is greater than current one
     |          LT -> Set expiry only when the new expiry is less than current one
     |
     |      For more information, see https://redis.io/commands/pexpireat
     |
     |  pexpiretime(self, key: 'str') -> 'int | Awaitable[int]'
     |      Returns the absolute Unix timestamp (since January 1, 1970) in milliseconds
     |      at which the given key will expire.
     |
     |      For more information, see https://redis.io/commands/pexpiretime
     |
     |  psetex(self, name: 'KeyT', time_ms: 'ExpiryT', value: 'EncodableT') -> 'bool | Awaitable[bool]'
     |      Set the value of key ``name`` to ``value`` that expires in ``time_ms``
     |      milliseconds. ``time_ms`` can be represented by an integer or a Python
     |      timedelta object
     |
     |      For more information, see https://redis.io/commands/psetex
     |
     |  pttl(self, name: 'KeyT') -> 'int | Awaitable[int]'
     |      Returns the number of milliseconds until the key ``name`` will expire
     |
     |      For more information, see https://redis.io/commands/pttl
     |
     |  randomkey(self, **kwargs) -> 'bytes | str | None | Awaitable[bytes | str | None]'
     |      Returns the name of a random key
     |
     |      For more information, see https://redis.io/commands/randomkey
     |
     |  rename(self, src: 'KeyT', dst: 'KeyT') -> 'bool | Awaitable[bool]'
     |      Rename key ``src`` to ``dst``
     |
     |      For more information, see https://redis.io/commands/rename
     |
     |  renamenx(self, src: 'KeyT', dst: 'KeyT') -> 'bool | Awaitable[bool]'
     |      Rename key ``src`` to ``dst`` if ``dst`` doesn't already exist
     |
     |      For more information, see https://redis.io/commands/renamenx
     |
     |  restore(self, name: 'KeyT', ttl: 'float', value: 'EncodableT', replace: 'bool' = False, absttl: 'bool' = False, idletime: 'int | None' = None, frequency: 'int | None' = None) -> 'bytes | str | Awaitable[bytes | str]'
     |      Create a key using the provided serialized value, previously obtained
     |      using DUMP.
     |
     |      ``replace`` allows an existing key on ``name`` to be overridden. If
     |      it's not specified an error is raised on collision.
     |
     |      ``absttl`` if True, specified ``ttl`` should represent an absolute Unix
     |      timestamp in milliseconds in which the key will expire. (Redis 5.0 or
     |      greater).
     |
     |      ``idletime`` Used for eviction, this is the number of seconds the
     |      key must be idle, prior to execution.
     |
     |      ``frequency`` Used for eviction, this is the frequency counter of
     |      the object stored at the key, prior to execution.
     |
     |      For more information, see https://redis.io/commands/restore
     |
     |  set(self, name: 'KeyT', value: 'EncodableT', ex: 'ExpiryT | None' = None, px: 'ExpiryT | None' = None, nx: 'bool' = False, xx: 'bool' = False, keepttl: 'bool' = False, get: 'bool' = False, exat: 'AbsExpiryT | None' = None, pxat: 'AbsExpiryT | None' = None, ifeq: 'bytes | str | None' = None, ifne: 'bytes | str | None' = None, ifdeq: 'str | None' = None, ifdne: 'str | None' = None) -> 'bool | str | bytes | None | Awaitable[bool | str | bytes | None]'
     |      Set the value at key ``name`` to ``value``
     |
     |      Warning:
     |      **Experimental** since 7.1.
     |      The usage of the arguments ``ifeq``, ``ifne``, ``ifdeq``, and ``ifdne``
     |      is experimental. The API or returned results when those parameters are used
     |      may change based on feedback.
     |
     |      ``ex`` sets an expire flag on key ``name`` for ``ex`` seconds.
     |
     |      ``px`` sets an expire flag on key ``name`` for ``px`` milliseconds.
     |
     |      ``nx`` if set to True, set the value at key ``name`` to ``value`` only
     |          if it does not exist.
     |
     |      ``xx`` if set to True, set the value at key ``name`` to ``value`` only
     |          if it already exists.
     |
     |      ``keepttl`` if True, retain the time to live associated with the key.
     |          (Available since Redis 6.0)
     |
     |      ``get`` if True, set the value at key ``name`` to ``value`` and return
     |          the old value stored at key, or None if the key did not exist.
     |          (Available since Redis 6.2)
     |
     |      ``exat`` sets an expire flag on key ``name`` for ``ex`` seconds,
     |          specified in unix time.
     |
     |      ``pxat`` sets an expire flag on key ``name`` for ``ex`` milliseconds,
     |          specified in unix time.
     |
     |      ``ifeq`` set the value at key ``name`` to ``value`` only if the current
     |          value exactly matches the argument.
     |          If key doesn’t exist - it won’t be created.
     |          (Requires Redis 8.4 or greater)
     |
     |      ``ifne`` set the value at key ``name`` to ``value`` only if the current
     |          value does not exactly match the argument.
     |          If key doesn’t exist - it will be created.
     |          (Requires Redis 8.4 or greater)
     |
     |      ``ifdeq`` set the value at key ``name`` to ``value`` only if the current
     |          value XXH3 hex digest exactly matches the argument.
     |          If key doesn’t exist - it won’t be created.
     |          (Requires Redis 8.4 or greater)
     |
     |      ``ifdne`` set the value at key ``name`` to ``value`` only if the current
     |          value XXH3 hex digest does not exactly match the argument.
     |          If key doesn’t exist - it will be created.
     |          (Requires Redis 8.4 or greater)
     |
     |      For more information, see https://redis.io/commands/set
     |
     |  setbit(self, name: 'KeyT', offset: 'int', value: 'int') -> 'int | Awaitable[int]'
     |      Flag the ``offset`` in ``name`` as ``value``. Returns an integer
     |      indicating the previous value of ``offset``.
     |
     |      For more information, see https://redis.io/commands/setbit
     |
     |  setex(self, name: 'KeyT', time: 'ExpiryT', value: 'EncodableT') -> 'bool | Awaitable[bool]'
     |      Set the value of key ``name`` to ``value`` that expires in ``time``
     |      seconds. ``time`` can be represented by an integer or a Python
     |      timedelta object.
     |
     |      As per Redis 2.6.12, SETEX is considered deprecated.
     |      Please use SET with EX parameter in new code.
     |
     |      For more information, see https://redis.io/commands/setex
     |
     |  setnx(self, name: 'KeyT', value: 'EncodableT') -> 'bool | Awaitable[bool]'
     |      Set the value of key ``name`` to ``value`` if key doesn't exist
     |
     |      For more information, see https://redis.io/commands/setnx
     |
     |  setrange(self, name: 'KeyT', offset: 'int', value: 'EncodableT') -> 'int | Awaitable[int]'
     |      Overwrite bytes in the value of ``name`` starting at ``offset`` with
     |      ``value``. If ``offset`` plus the length of ``value`` exceeds the
     |      length of the original value, the new value will be larger than before.
     |      If ``offset`` exceeds the length of the original value, null bytes
     |      will be used to pad between the end of the previous value and the start
     |      of what's being injected.
     |
     |      Returns the length of the new string.
     |
     |      For more information, see https://redis.io/commands/setrange
     |
     |  stralgo(self, algo: "Literal['LCS']", value1: 'KeyT', value2: 'KeyT', specific_argument: "Literal['strings'] | Literal['keys']" = 'strings', len: 'bool' = False, idx: 'bool' = False, minmatchlen: 'int | None' = None, withmatchlen: 'bool' = False, **kwargs) -> 'StralgoResponse | Awaitable[StralgoResponse]'
     |      Implements complex algorithms that operate on strings.
     |      Right now the only algorithm implemented is the LCS algorithm
     |      (longest common substring). However new algorithms could be
     |      implemented in the future.
     |
     |      ``algo`` Right now must be LCS
     |      ``value1`` and ``value2`` Can be two strings or two keys
     |      ``specific_argument`` Specifying if the arguments to the algorithm
     |      will be keys or strings. strings is the default.
     |      ``len`` Returns just the len of the match.
     |      ``idx`` Returns the match positions in each string.
     |      ``minmatchlen`` Restrict the list of matches to the ones of a given
     |      minimal length. Can be provided only when ``idx`` set to True.
     |      ``withmatchlen`` Returns the matches with the len of the match.
     |      Can be provided only when ``idx`` set to True.
     |
     |      For more information, see https://redis.io/commands/stralgo
     |
     |  strlen(self, name: 'KeyT') -> 'int | Awaitable[int]'
     |      Return the number of bytes stored in the value of ``name``
     |
     |      For more information, see https://redis.io/commands/strlen
     |
     |  substr(self, name: 'KeyT', start: 'int', end: 'int' = -1) -> 'bytes | str | Awaitable[bytes | str]'
     |      Return a substring of the string at key ``name``. ``start`` and ``end``
     |      are 0-based integers specifying the portion of the string to return.
     |
     |  touch(self, *args: 'KeyT') -> 'int | Awaitable[int]'
     |      Alters the last access time of a key(s) ``*args``. A key is ignored
     |      if it does not exist.
     |
     |      For more information, see https://redis.io/commands/touch
     |
     |  ttl(self, name: 'KeyT') -> 'int | Awaitable[int]'
     |      Returns the number of seconds until the key ``name`` will expire
     |
     |      For more information, see https://redis.io/commands/ttl
     |
     |  type(self, name: 'KeyT') -> 'bytes | str | Awaitable[bytes | str]'
     |      Returns the type of key ``name``
     |
     |      For more information, see https://redis.io/commands/type
     |
     |  unlink(self, *names: 'KeyT') -> 'int | Awaitable[int]'
     |      Unlink one or more keys specified by ``names``
     |
     |      For more information, see https://redis.io/commands/unlink
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from redis.commands.core.HyperlogCommands:
     |
     |  pfadd(self, name: 'KeyT', *values: 'FieldT') -> 'int | Awaitable[int]'
     |      Adds the specified elements to the specified HyperLogLog.
     |
     |      For more information, see https://redis.io/commands/pfadd
     |
     |  pfcount(self, *sources: 'KeyT') -> 'int | Awaitable[int]'
     |      Return the approximated cardinality of
     |      the set observed by the HyperLogLog at key(s).
     |
     |      For more information, see https://redis.io/commands/pfcount
     |
     |  pfmerge(self, dest: 'KeyT', *sources: 'KeyT') -> 'bool | Awaitable[bool]'
     |      Merge N different HyperLogLogs into a single one.
     |
     |      For more information, see https://redis.io/commands/pfmerge
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from redis.commands.core.HashCommands:
     |
     |  hdel(self, name: 'KeyT', *keys: 'FieldT') -> 'int | Awaitable[int]'
     |      Delete ``keys`` from hash ``name``
     |
     |      For more information, see https://redis.io/commands/hdel
     |
     |  hexists(self, name: 'KeyT', key: 'FieldT') -> 'bool | Awaitable[bool]'
     |      Returns a boolean indicating if ``key`` exists within hash ``name``
     |
     |      For more information, see https://redis.io/commands/hexists
     |
     |  hexpire(self, name: 'KeyT', seconds: 'ExpiryT', *fields: 'FieldT', nx: 'bool' = False, xx: 'bool' = False, gt: 'bool' = False, lt: 'bool' = False) -> 'list[int] | Awaitable[list[int]]'
     |      Sets or updates the expiration time for fields within a hash key, using relative
     |      time in seconds.
     |
     |      If a field already has an expiration time, the behavior of the update can be
     |      controlled using the `nx`, `xx`, `gt`, and `lt` parameters.
     |
     |      The return value provides detailed information about the outcome for each field.
     |
     |      For more information, see https://redis.io/commands/hexpire
     |
     |      Args:
     |          name: The name of the hash key.
     |          seconds: Expiration time in seconds, relative. Can be an integer, or a
     |                   Python `timedelta` object.
     |          fields: List of fields within the hash to apply the expiration time to.
     |          nx: Set expiry only when the field has no expiry.
     |          xx: Set expiry only when the field has an existing expiry.
     |          gt: Set expiry only when the new expiry is greater than the current one.
     |          lt: Set expiry only when the new expiry is less than the current one.
     |
     |      Returns:
     |          Returns a list which contains for each field in the request:
     |              - `-2` if the field does not exist, or if the key does not exist.
     |              - `0` if the specified NX | XX | GT | LT condition was not met.
     |              - `1` if the expiration time was set or updated.
     |              - `2` if the field was deleted because the specified expiration time is
     |                in the past.
     |
     |  hexpireat(self, name: 'KeyT', unix_time_seconds: 'AbsExpiryT', *fields: 'FieldT', nx: 'bool' = False, xx: 'bool' = False, gt: 'bool' = False, lt: 'bool' = False) -> 'list[int] | Awaitable[list[int]]'
     |      Sets or updates the expiration time for fields within a hash key, using an
     |      absolute Unix timestamp in seconds.
     |
     |      If a field already has an expiration time, the behavior of the update can be
     |      controlled using the `nx`, `xx`, `gt`, and `lt` parameters.
     |
     |      The return value provides detailed information about the outcome for each field.
     |
     |      For more information, see https://redis.io/commands/hexpireat
     |
     |      Args:
     |          name: The name of the hash key.
     |          unix_time_seconds: Expiration time as Unix timestamp in seconds. Can be an
     |                             integer or a Python `datetime` object.
     |          fields: List of fields within the hash to apply the expiration time to.
     |          nx: Set expiry only when the field has no expiry.
     |          xx: Set expiry only when the field has an existing expiration time.
     |          gt: Set expiry only when the new expiry is greater than the current one.
     |          lt: Set expiry only when the new expiry is less than the current one.
     |
     |      Returns:
     |          Returns a list which contains for each field in the request:
     |              - `-2` if the field does not exist, or if the key does not exist.
     |              - `0` if the specified NX | XX | GT | LT condition was not met.
     |              - `1` if the expiration time was set or updated.
     |              - `2` if the field was deleted because the specified expiration time is
     |                in the past.
     |
     |  hexpiretime(self, key: 'KeyT', *fields: 'FieldT') -> 'list[int] | Awaitable[list[int]]'
     |      Returns the expiration times of hash fields as Unix timestamps in seconds.
     |
     |      For more information, see https://redis.io/commands/hexpiretime
     |
     |      Args:
     |          key: The hash key.
     |          fields: A list of fields within the hash for which to get the expiration
     |                  time.
     |
     |      Returns:
     |          Returns a list which contains for each field in the request:
     |              - `-2` if the field does not exist, or if the key does not exist.
     |              - `-1` if the field exists but has no associated expire time.
     |              - A positive integer representing the expiration Unix timestamp in
     |                seconds, if the field has an associated expiration time.
     |
     |  hget(self, name: 'KeyT', key: 'FieldT') -> 'bytes | str | None | Awaitable[bytes | str | None]'
     |      Return the value of ``key`` within the hash ``name``
     |
     |      For more information, see https://redis.io/commands/hget
     |
     |  hgetall(self, name: 'KeyT') -> 'dict[bytes | str, bytes | str] | Awaitable[dict[bytes | str, bytes | str]]'
     |      Return a Python dict of the hash's name/value pairs
     |
     |      For more information, see https://redis.io/commands/hgetall
     |
     |  hgetdel(self, name: 'KeyT', *keys: 'FieldT') -> 'list[bytes | str | None] | Awaitable[list[bytes | str | None]]'
     |      Return the value of ``key`` within the hash ``name`` and
     |      delete the field in the hash.
     |      This command is similar to HGET, except for the fact that it also deletes
     |      the key on success from the hash with the provided ```name```.
     |
     |      Available since Redis 8.0
     |      For more information, see https://redis.io/commands/hgetdel
     |
     |  hgetex(self, name: 'KeyT', *keys: 'FieldT', ex: 'ExpiryT | None' = None, px: 'ExpiryT | None' = None, exat: 'AbsExpiryT | None' = None, pxat: 'AbsExpiryT | None' = None, persist: 'bool' = False) -> 'list[bytes | str | None] | Awaitable[list[bytes | str | None]]'
     |      Return the values of ``key`` and ``keys`` within the hash ``name``
     |      and optionally set their expiration.
     |
     |      ``ex`` sets an expire flag on ``kyes`` for ``ex`` seconds.
     |
     |      ``px`` sets an expire flag on ``keys`` for ``px`` milliseconds.
     |
     |      ``exat`` sets an expire flag on ``keys`` for ``ex`` seconds,
     |      specified in unix time.
     |
     |      ``pxat`` sets an expire flag on ``keys`` for ``ex`` milliseconds,
     |      specified in unix time.
     |
     |      ``persist`` remove the time to live associated with the ``keys``.
     |
     |      Available since Redis 8.0
     |      For more information, see https://redis.io/commands/hgetex
     |
     |  himport_discard_all_internal(self) -> 'int | Awaitable[int]'
     |      Send ``HIMPORT DISCARDALL`` (returns the number of fieldsets removed).
     |
     |      .. warning::
     |          Internal wire mapping — not for direct use on a pooled client. It
     |          DISCARDs on a single arbitrary borrowed connection and bypasses the
     |          client's shared fieldset registry, leaving other connections and the
     |          registry out of sync. Use the client's ``himport_discard_all`` instead;
     |          call this only on a pinned single-connection client where you manage
     |          session state yourself.
     |
     |  himport_discard_internal(self, fieldset_name: 'str') -> 'int | Awaitable[int]'
     |      Send ``HIMPORT DISCARD fieldset_name`` (``1`` removed, ``0`` not found).
     |
     |      .. warning::
     |          Internal wire mapping — not for direct use on a pooled client. It
     |          DISCARDs on a single arbitrary borrowed connection and bypasses the
     |          client's shared fieldset registry, leaving other connections and the
     |          registry out of sync. Use the client's ``himport_discard`` instead; call
     |          this only on a pinned single-connection client where you manage session
     |          state yourself.
     |
     |  himport_prepare_internal(self, fieldset_name: 'str', fields: 'Iterable[FieldT]') -> 'bool | Awaitable[bool]'
     |      Send ``HIMPORT PREPARE fieldset_name field [field ...]``.
     |
     |      Registers the ordered field list under ``fieldset_name`` in the executing
     |      connection's session. Fields are sent in the caller's order, unmodified.
     |
     |      .. warning::
     |          Internal wire mapping — not for direct use on a pooled client. It
     |          PREPAREs on a single arbitrary borrowed connection and bypasses the
     |          client's shared fieldset registry, so other connections stay unaware and
     |          reintroduce the nondeterministic "no such fieldset" the HIMPORT design
     |          prevents. Use the client's ``himport_prepare`` instead; call this only
     |          on a pinned single-connection client where you manage session state
     |          yourself.
     |
     |  himport_set(self, key: 'KeyT', fieldset_name: 'str', values: 'Iterable[EncodableT]') -> 'bool | Awaitable[bool]'
     |      Create/replace ``key`` as a hash using ``fieldset_name``'s field list.
     |
     |      Values are sent in the caller's order and map positionally to the prepared
     |      fields. The fieldset is prepared on the serving connection on first use
     |      (PREPARE bundled with SET in one write) and reused on subsequent calls;
     |      runtime discards are reconciled on the next use of the connection. All of
     |      this happens inside the normal command path, so retry, disconnect-on-error
     |      and (for the cluster) routing / MOVED-ASK apply exactly as for any command.
     |
     |      .. note::
     |          Recovery from a mid-connection fieldset loss (the server dropping the
     |          prepared fieldset without dropping the socket, e.g. ``RESET`` or
     |          ``maxmemory-clients`` eviction) applies only to a standalone
     |          ``himport_set`` call: it catches the resulting ``no such fieldset`` and
     |          re-prepares on the same socket, retrying the SET once. A ``himport_set``
     |          buffered in a **pipeline or transaction** has no such per-command
     |          recovery — its fieldset is PREPAREd once as a pre-flight before the
     |          batch, and if the server loses it between that pre-flight and the batch
     |          the SET fails and surfaces as an error in the batch results. Callers who
     |          need the automatic recovery should issue those sets outside a pipeline.
     |
     |  hincrby(self, name: 'KeyT', key: 'FieldT', amount: 'int' = 1) -> 'int | Awaitable[int]'
     |      Increment the value of ``key`` in hash ``name`` by ``amount``
     |
     |      For more information, see https://redis.io/commands/hincrby
     |
     |  hincrbyfloat(self, name: 'KeyT', key: 'FieldT', amount: 'float' = 1.0) -> 'float | Awaitable[float]'
     |      Increment the value of ``key`` in hash ``name`` by floating ``amount``
     |
     |      For more information, see https://redis.io/commands/hincrbyfloat
     |
     |  hkeys(self, name: 'KeyT') -> 'list[bytes | str] | Awaitable[list[bytes | str]]'
     |      Return the list of keys within hash ``name``
     |
     |      For more information, see https://redis.io/commands/hkeys
     |
     |  hlen(self, name: 'KeyT') -> 'int | Awaitable[int]'
     |      Return the number of elements in hash ``name``
     |
     |      For more information, see https://redis.io/commands/hlen
     |
     |  hmget(self, name: 'KeyT', keys: 'FieldT | Iterable[FieldT]', *args: 'FieldT') -> 'list[bytes | str | None] | Awaitable[list[bytes | str | None]]'
     |      Returns a list of values ordered identically to ``keys``
     |
     |      For more information, see https://redis.io/commands/hmget
     |
     |  hmset(self, name: 'KeyT', mapping: 'Mapping[FieldT, EncodableT]') -> 'bool | Awaitable[bool]'
     |      Set key to value within hash ``name`` for each corresponding
     |      key and value from the ``mapping`` dict.
     |
     |      For more information, see https://redis.io/commands/hmset
     |
     |  hpersist(self, name: 'KeyT', *fields: 'FieldT') -> 'list[int] | Awaitable[list[int]]'
     |      Removes the expiration time for each specified field in a hash.
     |
     |      For more information, see https://redis.io/commands/hpersist
     |
     |      Args:
     |          name: The name of the hash key.
     |          fields: A list of fields within the hash from which to remove the
     |                  expiration time.
     |
     |      Returns:
     |          Returns a list which contains for each field in the request:
     |              - `-2` if the field does not exist, or if the key does not exist.
     |              - `-1` if the field exists but has no associated expiration time.
     |              - `1` if the expiration time was successfully removed from the field.
     |
     |  hpexpire(self, name: 'KeyT', milliseconds: 'ExpiryT', *fields: 'FieldT', nx: 'bool' = False, xx: 'bool' = False, gt: 'bool' = False, lt: 'bool' = False) -> 'list[int] | Awaitable[list[int]]'
     |      Sets or updates the expiration time for fields within a hash key, using relative
     |      time in milliseconds.
     |
     |      If a field already has an expiration time, the behavior of the update can be
     |      controlled using the `nx`, `xx`, `gt`, and `lt` parameters.
     |
     |      The return value provides detailed information about the outcome for each field.
     |
     |      For more information, see https://redis.io/commands/hpexpire
     |
     |      Args:
     |          name: The name of the hash key.
     |          milliseconds: Expiration time in milliseconds, relative. Can be an integer,
     |                        or a Python `timedelta` object.
     |          fields: List of fields within the hash to apply the expiration time to.
     |          nx: Set expiry only when the field has no expiry.
     |          xx: Set expiry only when the field has an existing expiry.
     |          gt: Set expiry only when the new expiry is greater than the current one.
     |          lt: Set expiry only when the new expiry is less than the current one.
     |
     |      Returns:
     |          Returns a list which contains for each field in the request:
     |              - `-2` if the field does not exist, or if the key does not exist.
     |              - `0` if the specified NX | XX | GT | LT condition was not met.
     |              - `1` if the expiration time was set or updated.
     |              - `2` if the field was deleted because the specified expiration time is
     |                in the past.
     |
     |  hpexpireat(self, name: 'KeyT', unix_time_milliseconds: 'AbsExpiryT', *fields: 'FieldT', nx: 'bool' = False, xx: 'bool' = False, gt: 'bool' = False, lt: 'bool' = False) -> 'list[int] | Awaitable[list[int]]'
     |      Sets or updates the expiration time for fields within a hash key, using an
     |      absolute Unix timestamp in milliseconds.
     |
     |      If a field already has an expiration time, the behavior of the update can be
     |      controlled using the `nx`, `xx`, `gt`, and `lt` parameters.
     |
     |      The return value provides detailed information about the outcome for each field.
     |
     |      For more information, see https://redis.io/commands/hpexpireat
     |
     |      Args:
     |          name: The name of the hash key.
     |          unix_time_milliseconds: Expiration time as Unix timestamp in milliseconds.
     |                                  Can be an integer or a Python `datetime` object.
     |          fields: List of fields within the hash to apply the expiry.
     |          nx: Set expiry only when the field has no expiry.
     |          xx: Set expiry only when the field has an existing expiry.
     |          gt: Set expiry only when the new expiry is greater than the current one.
     |          lt: Set expiry only when the new expiry is less than the current one.
     |
     |      Returns:
     |          Returns a list which contains for each field in the request:
     |              - `-2` if the field does not exist, or if the key does not exist.
     |              - `0` if the specified NX | XX | GT | LT condition was not met.
     |              - `1` if the expiration time was set or updated.
     |              - `2` if the field was deleted because the specified expiration time is
     |                in the past.
     |
     |  hpexpiretime(self, key: 'KeyT', *fields: 'FieldT') -> 'list[int] | Awaitable[list[int]]'
     |      Returns the expiration times of hash fields as Unix timestamps in milliseconds.
     |
     |      For more information, see https://redis.io/commands/hpexpiretime
     |
     |      Args:
     |          key: The hash key.
     |          fields: A list of fields within the hash for which to get the expiration
     |                  time.
     |
     |      Returns:
     |          Returns a list which contains for each field in the request:
     |              - `-2` if the field does not exist, or if the key does not exist.
     |              - `-1` if the field exists but has no associated expire time.
     |              - A positive integer representing the expiration Unix timestamp in
     |                milliseconds, if the field has an associated expiration time.
     |
     |  hpttl(self, key: 'KeyT', *fields: 'FieldT') -> 'list[int] | Awaitable[list[int]]'
     |      Returns the TTL (Time To Live) in milliseconds for each specified field within a
     |      hash key.
     |
     |      For more information, see https://redis.io/commands/hpttl
     |
     |      Args:
     |          key: The hash key.
     |          fields: A list of fields within the hash for which to get the TTL.
     |
     |      Returns:
     |          Returns a list which contains for each field in the request:
     |              - `-2` if the field does not exist, or if the key does not exist.
     |              - `-1` if the field exists but has no associated expire time.
     |              - A positive integer representing the TTL in milliseconds if the field
     |                has an associated expiration time.
     |
     |  hset(self, name: 'KeyT', key: 'FieldT | None' = None, value: 'EncodableT | None' = None, mapping: 'Mapping[FieldT, EncodableT] | None' = None, items: 'Sequence[EncodableT] | None' = None) -> 'int | Awaitable[int]'
     |      Set ``key`` to ``value`` within hash ``name``,
     |      ``mapping`` accepts a dict of key/value pairs that will be
     |      added to hash ``name``.
     |      ``items`` accepts a list of key/value pairs that will be
     |      added to hash ``name``.
     |      Returns the number of fields that were added.
     |
     |      For more information, see https://redis.io/commands/hset
     |
     |  hsetex(self, name: 'KeyT', key: 'FieldT | None' = None, value: 'EncodableT | None' = None, mapping: 'Mapping[FieldT, EncodableT] | None' = None, items: 'Sequence[EncodableT] | None' = None, ex: 'ExpiryT | None' = None, px: 'ExpiryT | None' = None, exat: 'AbsExpiryT | None' = None, pxat: 'AbsExpiryT | None' = None, data_persist_option: 'HashDataPersistOptions | None' = None, keepttl: 'bool' = False) -> 'int | Awaitable[int]'
     |      Set ``key`` to ``value`` within hash ``name``
     |
     |      ``mapping`` accepts a dict of key/value pairs that will be
     |      added to hash ``name``.
     |
     |      ``items`` accepts a list of key/value pairs that will be
     |      added to hash ``name``.
     |
     |      ``ex`` sets an expire flag on ``keys`` for ``ex`` seconds.
     |
     |      ``px`` sets an expire flag on ``keys`` for ``px`` milliseconds.
     |
     |      ``exat`` sets an expire flag on ``keys`` for ``ex`` seconds,
     |          specified in unix time.
     |
     |      ``pxat`` sets an expire flag on ``keys`` for ``ex`` milliseconds,
     |          specified in unix time.
     |
     |      ``data_persist_option`` can be set to ``FNX`` or ``FXX`` to control the
     |          behavior of the command.
     |          ``FNX`` will set the value for each provided key to each
     |              provided value only if all do not already exist.
     |          ``FXX`` will set the value for each provided key to each
     |              provided value only if all already exist.
     |
     |      ``keepttl`` if True, retain the time to live associated with the keys.
     |
     |      Returns the number of fields that were added.
     |
     |      Available since Redis 8.0
     |      For more information, see https://redis.io/commands/hsetex
     |
     |  hsetnx(self, name: 'KeyT', key: 'FieldT', value: 'EncodableT') -> 'int | Awaitable[int]'
     |      Set ``key`` to ``value`` within hash ``name`` if ``key`` does not
     |      exist.  Returns 1 if HSETNX created a field, otherwise 0.
     |
     |      For more information, see https://redis.io/commands/hsetnx
     |
     |  hstrlen(self, name: 'KeyT', key: 'FieldT') -> 'int | Awaitable[int]'
     |      Return the number of bytes stored in the value of ``key``
     |      within hash ``name``
     |
     |      For more information, see https://redis.io/commands/hstrlen
     |
     |  httl(self, key: 'KeyT', *fields: 'FieldT') -> 'list[int] | Awaitable[list[int]]'
     |      Returns the TTL (Time To Live) in seconds for each specified field within a hash
     |      key.
     |
     |      For more information, see https://redis.io/commands/httl
     |
     |      Args:
     |          key: The hash key.
     |          fields: A list of fields within the hash for which to get the TTL.
     |
     |      Returns:
     |          Returns a list which contains for each field in the request:
     |              - `-2` if the field does not exist, or if the key does not exist.
     |              - `-1` if the field exists but has no associated expire time.
     |              - A positive integer representing the TTL in seconds if the field has
     |                an associated expiration time.
     |
     |  hvals(self, name: 'KeyT') -> 'list[bytes | str] | Awaitable[list[bytes | str]]'
     |      Return the list of values within hash ``name``
     |
     |      For more information, see https://redis.io/commands/hvals
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from redis.commands.core.GeoCommands:
     |
     |  geoadd(self, name: 'KeyT', values: 'Sequence[EncodableT]', nx: 'bool' = False, xx: 'bool' = False, ch: 'bool' = False) -> 'int | Awaitable[int]'
     |      Add the specified geospatial items to the specified key identified
     |      by the ``name`` argument. The Geospatial items are given as ordered
     |      members of the ``values`` argument, each item or place is formed by
     |      the triad longitude, latitude and name.
     |
     |      Note: You can use ZREM to remove elements.
     |
     |      ``nx`` forces ZADD to only create new elements and not to update
     |      scores for elements that already exist.
     |
     |      ``xx`` forces ZADD to only update scores of elements that already
     |      exist. New elements will not be added.
     |
     |      ``ch`` modifies the return value to be the numbers of elements changed.
     |      Changed elements include new elements that were added and elements
     |      whose scores changed.
     |
     |      For more information, see https://redis.io/commands/geoadd
     |
     |  geodist(self, name: 'KeyT', place1: 'FieldT', place2: 'FieldT', unit: 'str | None' = None) -> 'float | None | Awaitable[float | None]'
     |      Return the distance between ``place1`` and ``place2`` members of the
     |      ``name`` key.
     |      The units must be one of the following : m, km mi, ft. By default
     |      meters are used.
     |
     |      For more information, see https://redis.io/commands/geodist
     |
     |  geohash(self, name: 'KeyT', *values: 'FieldT') -> 'list[bytes | str | None] | Awaitable[list[bytes | str | None]]'
     |      Return the geo hash string for each item of ``values`` members of
     |      the specified key identified by the ``name`` argument.
     |
     |      For more information, see https://redis.io/commands/geohash
     |
     |  geopos(self, name: 'KeyT', *values: 'FieldT') -> 'list[GeoCoordinate | None] | Awaitable[list[GeoCoordinate | None]]'
     |      Return the positions of each item of ``values`` as members of
     |      the specified key identified by the ``name`` argument. Each position
     |      is represented by the pairs lon and lat.
     |
     |      For more information, see https://redis.io/commands/geopos
     |
     |  georadius(self, name: 'KeyT', longitude: 'float', latitude: 'float', radius: 'float', unit: 'str | None' = None, withdist: 'bool' = False, withcoord: 'bool' = False, withhash: 'bool' = False, count: 'int | None' = None, sort: 'str | None' = None, store: 'KeyT | None' = None, store_dist: 'KeyT | None' = None, any: 'bool' = False) -> 'GeoRadiusResponse | Awaitable[GeoRadiusResponse]'
     |      Return the members of the specified key identified by the
     |      ``name`` argument which are within the borders of the area specified
     |      with the ``latitude`` and ``longitude`` location and the maximum
     |      distance from the center specified by the ``radius`` value.
     |
     |      The units must be one of the following : m, km mi, ft. By default
     |
     |      ``withdist`` indicates to return the distances of each place.
     |
     |      ``withcoord`` indicates to return the latitude and longitude of
     |      each place.
     |
     |      ``withhash`` indicates to return the geohash string of each place.
     |
     |      ``count`` indicates to return the number of elements up to N.
     |
     |      ``sort`` indicates to return the places in a sorted way, ASC for
     |      nearest to fairest and DESC for fairest to nearest.
     |
     |      ``store`` indicates to save the places names in a sorted set named
     |      with a specific key, each element of the destination sorted set is
     |      populated with the score got from the original geo sorted set.
     |
     |      ``store_dist`` indicates to save the places names in a sorted set
     |      named with a specific key, instead of ``store`` the sorted set
     |      destination score is set with the distance.
     |
     |      For more information, see https://redis.io/commands/georadius
     |
     |  georadiusbymember(self, name: 'KeyT', member: 'FieldT', radius: 'float', unit: 'str | None' = None, withdist: 'bool' = False, withcoord: 'bool' = False, withhash: 'bool' = False, count: 'int | None' = None, sort: 'str | None' = None, store: 'Union[KeyT, None]' = None, store_dist: 'Union[KeyT, None]' = None, any: 'bool' = False) -> 'GeoRadiusResponse | Awaitable[GeoRadiusResponse]'
     |      This command is exactly like ``georadius`` with the sole difference
     |      that instead of taking, as the center of the area to query, a longitude
     |      and latitude value, it takes the name of a member already existing
     |      inside the geospatial index represented by the sorted set.
     |
     |      For more information, see https://redis.io/commands/georadiusbymember
     |
     |  geosearch(self, name: 'KeyT', member: 'FieldT | None' = None, longitude: 'float | None' = None, latitude: 'float | None' = None, unit: 'str' = 'm', radius: 'float | None' = None, width: 'float | None' = None, height: 'float | None' = None, sort: 'str | None' = None, count: 'int | None' = None, any: 'bool' = False, withcoord: 'bool' = False, withdist: 'bool' = False, withhash: 'bool' = False) -> 'GeoSearchResponse | Awaitable[GeoSearchResponse]'
     |      Return the members of specified key identified by the
     |      ``name`` argument, which are within the borders of the
     |      area specified by a given shape. This command extends the
     |      GEORADIUS command, so in addition to searching within circular
     |      areas, it supports searching within rectangular areas.
     |
     |      This command should be used in place of the deprecated
     |      GEORADIUS and GEORADIUSBYMEMBER commands.
     |
     |      ``member`` Use the position of the given existing
     |       member in the sorted set. Can't be given with ``longitude``
     |       and ``latitude``.
     |
     |      ``longitude`` and ``latitude`` Use the position given by
     |      this coordinates. Can't be given with ``member``
     |      ``radius`` Similar to GEORADIUS, search inside circular
     |      area according the given radius. Can't be given with
     |      ``height`` and ``width``.
     |      ``height`` and ``width`` Search inside an axis-aligned
     |      rectangle, determined by the given height and width.
     |      Can't be given with ``radius``
     |
     |      ``unit`` must be one of the following : m, km, mi, ft.
     |      `m` for meters (the default value), `km` for kilometers,
     |      `mi` for miles and `ft` for feet.
     |
     |      ``sort`` indicates to return the places in a sorted way,
     |      ASC for nearest to furthest and DESC for furthest to nearest.
     |
     |      ``count`` limit the results to the first count matching items.
     |
     |      ``any`` is set to True, the command will return as soon as
     |      enough matches are found. Can't be provided without ``count``
     |
     |      ``withdist`` indicates to return the distances of each place.
     |      ``withcoord`` indicates to return the latitude and longitude of
     |      each place.
     |
     |      ``withhash`` indicates to return the geohash string of each place.
     |
     |      For more information, see https://redis.io/commands/geosearch
     |
     |  geosearchstore(self, dest: 'KeyT', name: 'KeyT', member: 'FieldT | None' = None, longitude: 'float | None' = None, latitude: 'float | None' = None, unit: 'str' = 'm', radius: 'float | None' = None, width: 'float | None' = None, height: 'float | None' = None, sort: 'str | None' = None, count: 'int | None' = None, any: 'bool' = False, storedist: 'bool' = False) -> 'int | Awaitable[int]'
     |      This command is like GEOSEARCH, but stores the result in
     |      ``dest``. By default, it stores the results in the destination
     |      sorted set with their geospatial information.
     |      if ``store_dist`` set to True, the command will stores the
     |      items in a sorted set populated with their distance from the
     |      center of the circle or box, as a floating-point number.
     |
     |      For more information, see https://redis.io/commands/geosearchstore
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from redis.commands.core.ListCommands:
     |
     |  blmpop(self, timeout: 'float', numkeys: 'int', *args: 'str', direction: 'str', count: 'int | None' = 1) -> 'ListMultiPopResponse | Awaitable[ListMultiPopResponse]'
     |      Pop ``count`` values (default 1) from first non-empty in the list
     |      of provided key names.
     |
     |      When all lists are empty this command blocks the connection until another
     |      client pushes to it or until the timeout, timeout of 0 blocks indefinitely
     |
     |      For more information, see https://redis.io/commands/blmpop
     |
     |  blpop(self, keys: 'KeysT', timeout: 'Number | None' = 0) -> 'BlockingListPopResponse | Awaitable[BlockingListPopResponse]'
     |      LPOP a value off of the first non-empty list
     |      named in ``keys``.
     |
     |      If none of the lists in ``keys`` has a value to LPOP, then block
     |      for ``timeout`` seconds, or until a value gets pushed on to one
     |      of the lists.
     |
     |      If timeout is 0, then block indefinitely.
     |
     |      For more information, see https://redis.io/commands/blpop
     |
     |  brpop(self, keys: 'KeysT', timeout: 'Number | None' = 0) -> 'BlockingListPopResponse | Awaitable[BlockingListPopResponse]'
     |      RPOP a value off of the first non-empty list
     |      named in ``keys``.
     |
     |      If none of the lists in ``keys`` has a value to RPOP, then block
     |      for ``timeout`` seconds, or until a value gets pushed on to one
     |      of the lists.
     |
     |      If timeout is 0, then block indefinitely.
     |
     |      For more information, see https://redis.io/commands/brpop
     |
     |  brpoplpush(self, src: 'KeyT', dst: 'KeyT', timeout: 'Number | None' = 0) -> 'bytes | str | None | Awaitable[bytes | str | None]'
     |      Pop a value off the tail of ``src``, push it on the head of ``dst``
     |      and then return it.
     |
     |      This command blocks until a value is in ``src`` or until ``timeout``
     |      seconds elapse, whichever is first. A ``timeout`` value of 0 blocks
     |      forever.
     |
     |      For more information, see https://redis.io/commands/brpoplpush
     |
     |  lindex(self, name: 'KeyT', index: 'int') -> 'bytes | str | None | Awaitable[bytes | str | None]'
     |      Return the item from list ``name`` at position ``index``
     |
     |      Negative indexes are supported and will return an item at the
     |      end of the list
     |
     |      For more information, see https://redis.io/commands/lindex
     |
     |  linsert(self, name: 'KeyT', where: 'str', refvalue: 'str', value: 'str') -> 'int | Awaitable[int]'
     |      Insert ``value`` in list ``name`` either immediately before or after
     |      [``where``] ``refvalue``
     |
     |      Returns the new length of the list on success or -1 if ``refvalue``
     |      is not in the list.
     |
     |      For more information, see https://redis.io/commands/linsert
     |
     |  llen(self, name: 'KeyT') -> 'int | Awaitable[int]'
     |      Return the length of the list ``name``
     |
     |      For more information, see https://redis.io/commands/llen
     |
     |  lmpop(self, num_keys: 'int', *args: 'str', direction: 'str', count: 'int | None' = 1) -> 'ListMultiPopResponse | Awaitable[ListMultiPopResponse]'
     |      Pop ``count`` values (default 1) first non-empty list key from the list
     |      of args provided key names.
     |
     |      For more information, see https://redis.io/commands/lmpop
     |
     |  lpop(self, name: 'KeyT', count: 'int | None' = None) -> 'bytes | str | list[bytes | str] | None | Awaitable[bytes | str | list[bytes | str] | None]'
     |      Removes and returns the first elements of the list ``name``.
     |
     |      By default, the command pops a single element from the beginning of
     |      the list. When provided with the optional ``count`` argument, the reply
     |      will consist of up to count elements, depending on the list's length.
     |
     |      For more information, see https://redis.io/commands/lpop
     |
     |  lpos(self, name: 'KeyT', value: 'str', rank: 'int | None' = None, count: 'int | None' = None, maxlen: 'int | None' = None) -> 'int | list[int] | None | Awaitable[int | list[int] | None]'
     |      Get position of ``value`` within the list ``name``
     |
     |       If specified, ``rank`` indicates the "rank" of the first element to
     |       return in case there are multiple copies of ``value`` in the list.
     |       By default, LPOS returns the position of the first occurrence of
     |       ``value`` in the list. When ``rank`` 2, LPOS returns the position of
     |       the second ``value`` in the list. If ``rank`` is negative, LPOS
     |       searches the list in reverse. For example, -1 would return the
     |       position of the last occurrence of ``value`` and -2 would return the
     |       position of the next to last occurrence of ``value``.
     |
     |       If specified, ``count`` indicates that LPOS should return a list of
     |       up to ``count`` positions. A ``count`` of 2 would return a list of
     |       up to 2 positions. A ``count`` of 0 returns a list of all positions
     |       matching ``value``. When ``count`` is specified and but ``value``
     |       does not exist in the list, an empty list is returned.
     |
     |       If specified, ``maxlen`` indicates the maximum number of list
     |       elements to scan. A ``maxlen`` of 1000 will only return the
     |       position(s) of items within the first 1000 entries in the list.
     |       A ``maxlen`` of 0 (the default) will scan the entire list.
     |
     |       For more information, see https://redis.io/commands/lpos
     |
     |  lpush(self, name: 'KeyT', *values: 'FieldT') -> 'int | Awaitable[int]'
     |      Push ``values`` onto the head of the list ``name``
     |
     |      For more information, see https://redis.io/commands/lpush
     |
     |  lpushx(self, name: 'KeyT', *values: 'FieldT') -> 'int | Awaitable[int]'
     |      Push ``value`` onto the head of the list ``name`` if ``name`` exists
     |
     |      For more information, see https://redis.io/commands/lpushx
     |
     |  lrange(self, name: 'KeyT', start: 'int', end: 'int') -> 'list[bytes | str] | Awaitable[list[bytes | str]]'
     |      Return a slice of the list ``name`` between
     |      position ``start`` and ``end``
     |
     |      ``start`` and ``end`` can be negative numbers just like
     |      Python slicing notation
     |
     |      For more information, see https://redis.io/commands/lrange
     |
     |  lrem(self, name: 'KeyT', count: 'int', value: 'str') -> 'int | Awaitable[int]'
     |      Remove the first ``count`` occurrences of elements equal to ``value``
     |      from the list stored at ``name``.
     |
     |      The count argument influences the operation in the following ways:
     |          count > 0: Remove elements equal to value moving from head to tail.
     |          count < 0: Remove elements equal to value moving from tail to head.
     |          count = 0: Remove all elements equal to value.
     |
     |          For more information, see https://redis.io/commands/lrem
     |
     |  lset(self, name: 'KeyT', index: 'int', value: 'str') -> 'bool | Awaitable[bool]'
     |      Set element at ``index`` of list ``name`` to ``value``
     |
     |      For more information, see https://redis.io/commands/lset
     |
     |  ltrim(self, name: 'KeyT', start: 'int', end: 'int') -> 'bool | Awaitable[bool]'
     |      Trim the list ``name``, removing all values not within the slice
     |      between ``start`` and ``end``
     |
     |      ``start`` and ``end`` can be negative numbers just like
     |      Python slicing notation
     |
     |      For more information, see https://redis.io/commands/ltrim
     |
     |  rpop(self, name: 'KeyT', count: 'int | None' = None) -> 'bytes | str | list[bytes | str] | None | Awaitable[bytes | str | list[bytes | str] | None]'
     |      Removes and returns the last elements of the list ``name``.
     |
     |      By default, the command pops a single element from the end of the list.
     |      When provided with the optional ``count`` argument, the reply will
     |      consist of up to count elements, depending on the list's length.
     |
     |      For more information, see https://redis.io/commands/rpop
     |
     |  rpoplpush(self, src: 'KeyT', dst: 'KeyT') -> 'bytes | str | None | Awaitable[bytes | str | None]'
     |      RPOP a value off of the ``src`` list and atomically LPUSH it
     |      on to the ``dst`` list.  Returns the value.
     |
     |      For more information, see https://redis.io/commands/rpoplpush
     |
     |  rpush(self, name: 'KeyT', *values: 'FieldT') -> 'int | Awaitable[int]'
     |      Push ``values`` onto the tail of the list ``name``
     |
     |      For more information, see https://redis.io/commands/rpush
     |
     |  rpushx(self, name: 'KeyT', *values: 'str') -> 'int | Awaitable[int]'
     |      Push ``value`` onto the tail of the list ``name`` if ``name`` exists
     |
     |      For more information, see https://redis.io/commands/rpushx
     |
     |  sort(self, name: 'KeyT', start: 'int | None' = None, num: 'int | None' = None, by: 'str | None' = None, get: 'list[str] | None' = None, desc: 'bool' = False, alpha: 'bool' = False, store: 'str | None' = None, groups: 'bool | None' = False) -> 'SortResponse | Awaitable[SortResponse]'
     |      Sort and return the list, set or sorted set at ``name``.
     |
     |      ``start`` and ``num`` allow for paging through the sorted data
     |
     |      ``by`` allows using an external key to weight and sort the items.
     |          Use an "*" to indicate where in the key the item value is located
     |
     |      ``get`` allows for returning items from external keys rather than the
     |          sorted data itself.  Use an "*" to indicate where in the key
     |          the item value is located
     |
     |      ``desc`` allows for reversing the sort
     |
     |      ``alpha`` allows for sorting lexicographically rather than numerically
     |
     |      ``store`` allows for storing the result of the sort into
     |          the key ``store``
     |
     |      ``groups`` if set to True and if ``get`` contains at least two
     |          elements, sort will return a list of tuples, each containing the
     |          values fetched from the arguments to ``get``.
     |
     |      For more information, see https://redis.io/commands/sort
     |
     |  sort_ro(self, key: 'str', start: 'int | None' = None, num: 'int | None' = None, by: 'str | None' = None, get: 'list[str] | None' = None, desc: 'bool' = False, alpha: 'bool' = False) -> 'list[bytes | str] | Awaitable[list[bytes | str]]'
     |      Returns the elements contained in the list, set or sorted set at key.
     |      (read-only variant of the SORT command)
     |
     |      ``start`` and ``num`` allow for paging through the sorted data
     |
     |      ``by`` allows using an external key to weight and sort the items.
     |          Use an "*" to indicate where in the key the item value is located
     |
     |      ``get`` allows for returning items from external keys rather than the
     |          sorted data itself.  Use an "*" to indicate where in the key
     |          the item value is located
     |
     |      ``desc`` allows for reversing the sort
     |
     |      ``alpha`` allows for sorting lexicographically rather than numerically
     |
     |      For more information, see https://redis.io/commands/sort_ro
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from redis.commands.core.ArrayCommands:
     |
     |  arcount(self, name: 'KeyT') -> 'int | Awaitable[int]'
     |      Return the number of non-empty elements in the array stored at
     |      ``name``. Returns 0 if ``name`` does not exist.
     |
     |      For more information, see https://redis.io/commands/arcount
     |
     |  ardel(self, name: 'KeyT', *indices: 'int') -> 'int | Awaitable[int]'
     |      Delete elements at the specified ``indices`` in the array stored at
     |      ``name``. Deleting an index that does not exist counts as zero
     |      elements deleted and does not modify the array.
     |
     |      Returns the number of elements deleted.
     |
     |      For more information, see https://redis.io/commands/ardel
     |
     |  ardelrange(self, name: 'KeyT', *ranges: 'tuple[int, int]') -> 'int | Awaitable[int]'
     |      Delete elements within one or more inclusive index ranges in the
     |      array stored at ``name``. Each range is a ``(start, end)`` tuple.
     |      If ``start`` is greater than ``end`` for a given pair, the range is
     |      processed in ascending order regardless. Multiple pairs may overlap;
     |      each element is counted at most once.
     |
     |      Returns the number of elements deleted.
     |
     |      For more information, see https://redis.io/commands/ardelrange
     |
     |  arget(self, name: 'KeyT', index: 'int') -> 'bytes | str | None | Awaitable[bytes | str | None]'
     |      Return the value at ``index`` in the array stored at ``name``.
     |
     |      Returns ``None`` if ``name`` does not exist or no value is set at
     |      ``index``.
     |
     |      For more information, see https://redis.io/commands/arget
     |
     |  argetrange(self, name: 'KeyT', start: 'int', end: 'int') -> 'list[bytes | str | None] | Awaitable[list[bytes | str | None]]'
     |      Return the values in the inclusive index range [``start``, ``end``]
     |      in the array stored at ``name``. If ``start`` is greater than ``end``,
     |      elements are returned in reverse index order.
     |
     |      For more information, see https://redis.io/commands/argetrange
     |
     |  argrep(self, name: 'KeyT', start: 'int', end: 'int', predicates: 'list[tuple[ArrayPredicateType, EncodableT]]', combinator: 'ArrayPredicateCombinator | None' = None, limit: 'int | None' = None, withvalues: 'bool' = False, nocase: 'bool' = False) -> 'list[int] | list[list[int | bytes | str]] | Awaitable[list[int] | list[list[int | bytes | str]]]'
     |      Search elements of the array stored at ``name`` within the inclusive
     |      index range [``start``, ``end``] using one or more textual
     |      ``predicates``. Each predicate is a ``(type, value)`` tuple where
     |      ``type`` is a member of ``ArrayPredicateType``
     |      (``EXACT``, ``MATCH``, ``GLOB``, ``RE``).
     |
     |      Multiple predicates are combined via ``combinator``
     |      (``ArrayPredicateCombinator.AND`` or ``OR``); the server defaults to
     |      OR when omitted. ``limit`` caps the number of matches.
     |      ``withvalues=True`` returns a list of ``[index, value]`` pairs
     |      (``[[idx, val], ...]``) instead of a flat list of indices.
     |      ``nocase=True`` makes all comparisons case-insensitive.
     |
     |      Without ``withvalues``, returns a flat list of matching indices in
     |      traversal order. With ``withvalues``, returns a list of
     |      ``[index, value]`` pairs in traversal order. Empty slots are
     |      skipped.
     |
     |      For more information, see https://redis.io/commands/argrep
     |
     |  arinfo(self, name: 'KeyT', full: 'bool' = False) -> 'dict[str, int] | Awaitable[dict[str, int]]'
     |      Return metadata about the array stored at ``name`` as a dictionary.
     |      When ``full`` is ``True``, additionally include per-slice statistics
     |      (dense/sparse slice counts, average sizes, fill rates), which makes
     |      the call O(N) instead of O(1).
     |
     |      Raises ``ResponseError`` when the key does not exist.
     |
     |      For more information, see https://redis.io/commands/arinfo
     |
     |  arinsert(self, name: 'KeyT', *values: 'FieldT') -> 'int | Awaitable[int]'
     |      Insert one or more ``values`` at consecutive indices in the array
     |      stored at ``name``, beginning at the current insert cursor position.
     |      The cursor advances by one for each value inserted. Use ``ARNEXT``
     |      to inspect the current cursor position and ``ARSEEK`` to reposition
     |      it.
     |
     |      Returns the last index where a value was inserted.
     |
     |      For more information, see https://redis.io/commands/arinsert
     |
     |  arlastitems(self, name: 'KeyT', count: 'int', rev: 'bool' = False) -> 'list[bytes | str | None] | Awaitable[list[bytes | str | None]]'
     |      Return up to ``count`` most recently inserted elements from the array
     |      stored at ``name``. If the array contains fewer elements than
     |      ``count``, all elements are returned.
     |
     |      When ``rev`` is ``True``, elements are returned in reverse
     |      chronological order (most recent first) instead of the default
     |      oldest-first order.
     |
     |      For more information, see https://redis.io/commands/arlastitems
     |
     |  arlen(self, name: 'KeyT') -> 'int | Awaitable[int]'
     |      Return the length of the array stored at ``name``, defined as the
     |      maximum set index plus one. Returns 0 if ``name`` does not exist.
     |
     |      For more information, see https://redis.io/commands/arlen
     |
     |  armget(self, name: 'KeyT', *indices: 'int') -> 'list[bytes | str | None] | Awaitable[list[bytes | str | None]]'
     |      Return the values at the specified ``indices`` in the array stored at
     |      ``name``. The reply preserves the order of the requested indices and
     |      returns ``None`` for any index that is not set or when ``name`` does
     |      not exist.
     |
     |      For more information, see https://redis.io/commands/armget
     |
     |  armset(self, name: 'KeyT', mapping: 'Mapping[int, FieldT]') -> 'int | Awaitable[int]'
     |      Set multiple index/value pairs in the array stored at ``name``.
     |      ``mapping`` is a dictionary of zero-based integer indices to values.
     |      Pairs may be non-contiguous and in any order.
     |
     |      Returns the number of new slots that were set (previously empty).
     |
     |      For more information, see https://redis.io/commands/armset
     |
     |  arnext(self, name: 'KeyT') -> 'int | None | Awaitable[int | None]'
     |      Return the next index ``ARINSERT`` would use for the array stored at
     |      ``name``. Returns 0 if ``name`` does not exist or no insert happened
     |      yet, and ``None`` when the insertion cursor is exhausted (next insert
     |      would overflow).
     |
     |      For more information, see https://redis.io/commands/arnext
     |
     |  arop(self, name: 'KeyT', start: 'int', end: 'int', operation: 'ArrayAggregateOperations', value: 'EncodableT | None' = None) -> 'bytes | str | int | None | Awaitable[bytes | str | int | None]'
     |      Perform an aggregate ``operation`` on elements of the array stored at
     |      ``name`` in the inclusive index range [``start``, ``end``]. The range
     |      is always scanned from the lower to the higher index regardless of
     |      argument order.
     |
     |      ``operation`` is one of the members of ``ArrayAggregateOperations``.
     |      ``value`` is required when ``operation`` is
     |      ``ArrayAggregateOperations.MATCH`` and specifies the value to compare
     |      against.
     |
     |      Returns a bulk string for ``SUM``, ``MIN`` and ``MAX``, an integer
     |      for ``AND``, ``OR``, ``XOR``, ``MATCH`` and ``USED``, or ``None``
     |      when no elements match the operation.
     |
     |      For more information, see https://redis.io/commands/arop
     |
     |  arring(self, name: 'KeyT', size: 'int', *values: 'FieldT') -> 'int | Awaitable[int]'
     |      Insert one or more ``values`` into the array stored at ``name`` as a
     |      fixed-size ring buffer of ``size`` slots. Each value is placed at
     |      ``insert_idx % size``, wrapping back to index 0 once the end is
     |      reached and overwriting older values when full. If ``size`` is
     |      smaller than the current window, the array is truncated to fit.
     |
     |      Returns the last index where a value was inserted.
     |
     |      For more information, see https://redis.io/commands/arring
     |
     |  arscan(self, name: 'KeyT', start: 'int', end: 'int', limit: 'int | None' = None) -> 'list[list[int | bytes | str]] | Awaitable[list[list[int | bytes | str]]]'
     |      Iterate populated elements of the array stored at ``name`` in the
     |      inclusive range [``start``, ``end``] and return a list of
     |      ``[index, value]`` pairs in traversal order:
     |      ``[[idx1, val1], [idx2, val2], ...]``. Empty slots are skipped. If
     |      ``start`` is greater than ``end``, the iteration is reversed.
     |
     |      ``limit`` caps the number of populated elements returned. When
     |      omitted, all populated elements in range are returned.
     |
     |      For more information, see https://redis.io/commands/arscan
     |
     |  arseek(self, name: 'KeyT', index: 'int') -> 'int | Awaitable[int]'
     |      Set the insert cursor of the array stored at ``name`` to ``index``.
     |      Subsequent ``ARINSERT`` and ``ARRING`` operations begin inserting at
     |      this position.
     |
     |      Returns 1 if the cursor was set, 0 if ``name`` does not exist.
     |
     |      For more information, see https://redis.io/commands/arseek
     |
     |  arset(self, name: 'KeyT', index: 'int', *values: 'FieldT') -> 'int | Awaitable[int]'
     |      Set one or more contiguous ``values`` in the array stored at ``name``
     |      starting at ``index``. When multiple values are provided, they are
     |      stored at consecutive indices beginning at ``index``.
     |
     |      Returns the number of new slots that were set (previously empty).
     |
     |      For more information, see https://redis.io/commands/arset
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from redis.commands.core.ScanCommands:
     |
     |  hscan(self, name: 'KeyT', cursor: 'int' = 0, match: 'PatternT | None' = None, count: 'int | None' = None, no_values: 'bool | None' = None) -> 'HScanResponse | Awaitable[HScanResponse]'
     |      Incrementally return key/value slices in a hash. Also return a cursor
     |      indicating the scan position.
     |
     |      ``match`` allows for filtering the keys by pattern
     |
     |      ``count`` allows for hint the minimum number of returns
     |
     |      ``no_values`` indicates to return only the keys, without values.
     |
     |      For more information, see https://redis.io/commands/hscan
     |
     |  hscan_iter(self, name: 'KeyT', match: 'Union[PatternT, None]' = None, count: 'Optional[int]' = None, no_values: 'Union[bool, None]' = None) -> 'Iterator'
     |      Make an iterator using the HSCAN command so that the client doesn't
     |      need to remember the cursor position.
     |
     |      ``match`` allows for filtering the keys by pattern
     |
     |      ``count`` allows for hint the minimum number of returns
     |
     |      ``no_values`` indicates to return only the keys, without values
     |
     |  scan(self, cursor: 'int' = 0, match: 'PatternT | None' = None, count: 'int | None' = None, _type: 'str | None' = None, **kwargs) -> 'ScanResponse | Awaitable[ScanResponse]'
     |      Incrementally return lists of key names. Also return a cursor
     |      indicating the scan position.
     |
     |      ``match`` allows for filtering the keys by pattern
     |
     |      ``count`` provides a hint to Redis about the number of keys to
     |          return per batch.
     |
     |      ``_type`` filters the returned values by a particular Redis type.
     |          Stock Redis instances allow for the following types:
     |          HASH, LIST, SET, STREAM, STRING, ZSET
     |          Additionally, Redis modules can expose other types as well.
     |
     |      For more information, see https://redis.io/commands/scan
     |
     |  scan_iter(self, match: 'Union[PatternT, None]' = None, count: 'Optional[int]' = None, _type: 'Optional[str]' = None, **kwargs) -> 'Iterator'
     |      Make an iterator using the SCAN command so that the client doesn't
     |      need to remember the cursor position.
     |
     |      ``match`` allows for filtering the keys by pattern
     |
     |      ``count`` provides a hint to Redis about the number of keys to
     |          return per batch.
     |
     |      ``_type`` filters the returned values by a particular Redis type.
     |          Stock Redis instances allow for the following types:
     |          HASH, LIST, SET, STREAM, STRING, ZSET
     |          Additionally, Redis modules can expose other types as well.
     |
     |  sscan(self, name: 'KeyT', cursor: 'int' = 0, match: 'PatternT | None' = None, count: 'int | None' = None) -> 'ScanResponse | Awaitable[ScanResponse]'
     |      Incrementally return lists of elements in a set. Also return a cursor
     |      indicating the scan position.
     |
     |      ``match`` allows for filtering the keys by pattern
     |
     |      ``count`` allows for hint the minimum number of returns
     |
     |      For more information, see https://redis.io/commands/sscan
     |
     |  sscan_iter(self, name: 'KeyT', match: 'Union[PatternT, None]' = None, count: 'Optional[int]' = None) -> 'Iterator'
     |      Make an iterator using the SSCAN command so that the client doesn't
     |      need to remember the cursor position.
     |
     |      ``match`` allows for filtering the keys by pattern
     |
     |      ``count`` allows for hint the minimum number of returns
     |
     |  zscan(self, name: 'KeyT', cursor: 'int' = 0, match: 'PatternT | None' = None, count: 'int | None' = None, score_cast_func: 'type | Callable' = <class 'float'>) -> 'ZScanResponse | Awaitable[ZScanResponse]'
     |      Incrementally return lists of elements in a sorted set. Also return a
     |      cursor indicating the scan position.
     |
     |      ``match`` allows for filtering the keys by pattern
     |
     |      ``count`` allows for hint the minimum number of returns
     |
     |      ``score_cast_func`` a callable used to cast the score return value
     |
     |      For more information, see https://redis.io/commands/zscan
     |
     |  zscan_iter(self, name: 'KeyT', match: 'Union[PatternT, None]' = None, count: 'Optional[int]' = None, score_cast_func: 'Union[type, Callable]' = <class 'float'>) -> 'Iterator'
     |      Make an iterator using the ZSCAN command so that the client doesn't
     |      need to remember the cursor position.
     |
     |      ``match`` allows for filtering the keys by pattern
     |
     |      ``count`` allows for hint the minimum number of returns
     |
     |      ``score_cast_func`` a callable used to cast the score return value
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from redis.commands.core.SetCommands:
     |
     |  sadd(self, name: 'KeyT', *values: 'FieldT') -> 'int | Awaitable[int]'
     |      Add ``value(s)`` to set ``name``
     |
     |      For more information, see https://redis.io/commands/sadd
     |
     |  scard(self, name: 'KeyT') -> 'int | Awaitable[int]'
     |      Return the number of elements in set ``name``
     |
     |      For more information, see https://redis.io/commands/scard
     |
     |  sdiff(self, keys: 'List', *args: 'List') -> 'set[bytes | str] | Awaitable[set[bytes | str]]'
     |      Return the difference of sets specified by ``keys``
     |
     |      For more information, see https://redis.io/commands/sdiff
     |
     |  sdiffcard(self, numkeys: 'int', keys: 'List[KeyT]', limit: 'int' = 0) -> 'int | Awaitable[int]'
     |      Return the cardinality of the difference between the first set and all
     |      the successive sets specified by ``keys``, without returning the
     |      difference itself.
     |
     |      When LIMIT is provided (defaults to 0 and means unlimited), the returned
     |      cardinality is capped at ``limit`` and the server may stop the
     |      computation once the capped result is known.
     |
     |      For more information, see https://redis.io/commands/sdiffcard
     |
     |  sdiffstore(self, dest: 'str', keys: 'List', *args: 'List') -> 'int | Awaitable[int]'
     |      Store the difference of sets specified by ``keys`` into a new
     |      set named ``dest``.  Returns the number of keys in the new set.
     |
     |      For more information, see https://redis.io/commands/sdiffstore
     |
     |  sinter(self, keys: 'List', *args: 'List') -> 'set[bytes | str] | Awaitable[set[bytes | str]]'
     |      Return the intersection of sets specified by ``keys``
     |
     |      For more information, see https://redis.io/commands/sinter
     |
     |  sintercard(self, numkeys: 'int', keys: 'List[KeyT]', limit: 'int' = 0) -> 'int | Awaitable[int]'
     |      Return the cardinality of the intersect of multiple sets specified by ``keys``.
     |
     |      When LIMIT provided (defaults to 0 and means unlimited), if the intersection
     |      cardinality reaches limit partway through the computation, the algorithm will
     |      exit and yield limit as the cardinality
     |
     |      For more information, see https://redis.io/commands/sintercard
     |
     |  sinterstore(self, dest: 'KeyT', keys: 'List', *args: 'List') -> 'int | Awaitable[int]'
     |      Store the intersection of sets specified by ``keys`` into a new
     |      set named ``dest``.  Returns the number of keys in the new set.
     |
     |      For more information, see https://redis.io/commands/sinterstore
     |
     |  sismember(self, name: 'KeyT', value: 'str') -> 'Literal[0] | Literal[1] | Awaitable[Literal[0] | Literal[1]]'
     |      Return whether ``value`` is a member of set ``name``:
     |      - 1 if the value is a member of the set.
     |      - 0 if the value is not a member of the set or if key does not exist.
     |
     |      For more information, see https://redis.io/commands/sismember
     |
     |  smembers(self, name: 'KeyT') -> 'set[bytes | str] | Awaitable[set[bytes | str]]'
     |      Return all members of the set ``name``
     |
     |      For more information, see https://redis.io/commands/smembers
     |
     |  smismember(self, name: 'KeyT', values: 'List', *args: 'List') -> 'list[Literal[0] | Literal[1]] | Awaitable[list[Literal[0] | Literal[1]]]'
     |      Return whether each value in ``values`` is a member of the set ``name``
     |      as a list of ``int`` in the order of ``values``:
     |      - 1 if the value is a member of the set.
     |      - 0 if the value is not a member of the set or if key does not exist.
     |
     |      For more information, see https://redis.io/commands/smismember
     |
     |  smove(self, src: 'KeyT', dst: 'KeyT', value: 'str') -> 'bool | Awaitable[bool]'
     |      Move ``value`` from set ``src`` to set ``dst`` atomically
     |
     |      For more information, see https://redis.io/commands/smove
     |
     |  spop(self, name: 'KeyT', count: 'int | None' = None) -> 'bytes | str | set[bytes | str] | None | Awaitable[bytes | str | set[bytes | str] | None]'
     |      Remove and return a random member of set ``name``
     |
     |      For more information, see https://redis.io/commands/spop
     |
     |  srandmember(self, name: 'KeyT', number: 'int | None' = None) -> 'bytes | str | list[bytes | str] | None | Awaitable[bytes | str | list[bytes | str] | None]'
     |      If ``number`` is None, returns a random member of set ``name``.
     |
     |      If ``number`` is supplied, returns a list of ``number`` random
     |      members of set ``name``. Note this is only available when running
     |      Redis 2.6+.
     |
     |      For more information, see https://redis.io/commands/srandmember
     |
     |  srem(self, name: 'KeyT', *values: 'FieldT') -> 'int | Awaitable[int]'
     |      Remove ``values`` from set ``name``
     |
     |      For more information, see https://redis.io/commands/srem
     |
     |  sunion(self, keys: 'List', *args: 'List') -> 'set[bytes | str] | Awaitable[set[bytes | str]]'
     |      Return the union of sets specified by ``keys``
     |
     |      For more information, see https://redis.io/commands/sunion
     |
     |  sunioncard(self, numkeys: 'int', keys: 'List[KeyT]', limit: 'int' = 0, approx: 'bool' = False) -> 'int | Awaitable[int]'
     |      Return the cardinality of the union of multiple sets specified by
     |      ``keys``, without returning the union itself.
     |
     |      When ``approx`` is True, the ``APPROX`` option is sent and the server
     |      returns an approximate cardinality computed using HyperLogLog.
     |
     |      When LIMIT is provided (defaults to 0 and means unlimited), the returned
     |      cardinality is capped at ``limit``. In exact mode the result equals
     |      ``limit`` when the real cardinality exceeds ``limit``; in approximate
     |      mode the result will not exceed ``limit``. Options are emitted in the
     |      canonical order ``APPROX`` before ``LIMIT``.
     |
     |      For more information, see https://redis.io/commands/sunioncard
     |
     |  sunionstore(self, dest: 'KeyT', keys: 'List', *args: 'List') -> 'int | Awaitable[int]'
     |      Store the union of sets specified by ``keys`` into a new
     |      set named ``dest``.  Returns the number of keys in the new set.
     |
     |      For more information, see https://redis.io/commands/sunionstore
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from redis.commands.core.StreamCommands:
     |
     |  xack(self, name: 'KeyT', groupname: 'GroupT', *ids: 'StreamIdT') -> 'int | Awaitable[int]'
     |      Acknowledges the successful processing of one or more messages.
     |
     |      Args:
     |          name: name of the stream.
     |          groupname: name of the consumer group.
     |          *ids: message ids to acknowledge.
     |
     |      For more information, see https://redis.io/commands/xack
     |
     |  xackdel(self, name: 'KeyT', groupname: 'GroupT', *ids: 'StreamIdT', ref_policy: "Literal['KEEPREF', 'DELREF', 'ACKED']" = 'KEEPREF') -> 'int | Awaitable[int]'
     |      Combines the functionality of XACK and XDEL. Acknowledges the specified
     |      message IDs in the given consumer group and simultaneously attempts to
     |      delete the corresponding entries from the stream.
     |
     |  xadd(self, name: 'KeyT', fields: 'Dict[FieldT, EncodableT]', id: 'StreamIdT' = '*', maxlen: 'Optional[int]' = None, approximate: 'bool' = True, nomkstream: 'bool' = False, minid: 'Union[StreamIdT, None]' = None, limit: 'int | None' = None, ref_policy: "Literal['KEEPREF', 'DELREF', 'ACKED'] | None" = None, idmpauto: 'str | None' = None, idmp: 'tuple[str, bytes] | None' = None) -> 'bytes | str | Awaitable[bytes | str]'
     |      Add to a stream.
     |      name: name of the stream
     |      fields: dict of field/value pairs to insert into the stream
     |      id: Location to insert this record. By default it is appended.
     |      maxlen: truncate old stream members beyond this size.
     |      Can't be specified with minid.
     |      approximate: actual stream length may be slightly more than maxlen
     |      nomkstream: When set to true, do not make a stream
     |      minid: the minimum id in the stream to query.
     |      Can't be specified with maxlen.
     |      limit: specifies the maximum number of entries to retrieve
     |      ref_policy: optional reference policy for consumer groups when trimming:
     |          - KEEPREF (default): When trimming, preserves references in consumer groups' PEL
     |          - DELREF: When trimming, removes all references from consumer groups' PEL
     |          - ACKED: When trimming, only removes entries acknowledged by all consumer groups
     |      idmpauto: Producer ID for automatic idempotent ID calculation.
     |          Automatically calculates an idempotent ID based on entry content to prevent
     |          duplicate entries. Can only be used with id='*'. Creates an IDMP map if it
     |          doesn't exist yet. The producer ID must be unique per producer and consistent
     |          across restarts.
     |      idmp: Tuple of (producer_id, idempotent_id) for explicit idempotent ID.
     |          Uses a specific idempotent ID to prevent duplicate entries. Can only be used
     |          with id='*'. The producer ID must be unique per producer and consistent across
     |          restarts. The idempotent ID must be unique per message and per producer.
     |          Shorter idempotent IDs require less memory and allow faster processing.
     |          Creates an IDMP map if it doesn't exist yet.
     |
     |      For more information, see https://redis.io/commands/xadd
     |
     |  xautoclaim(self, name: 'KeyT', groupname: 'GroupT', consumername: 'ConsumerT', min_idle_time: 'int', start_id: 'StreamIdT' = '0-0', count: 'int | None' = None, justid: 'bool' = False) -> 'list[Any] | Awaitable[list[Any]]'
     |      Transfers ownership of pending stream entries that match the specified
     |      criteria. Conceptually, equivalent to calling XPENDING and then XCLAIM,
     |      but provides a more straightforward way to deal with message delivery
     |      failures via SCAN-like semantics.
     |      name: name of the stream.
     |      groupname: name of the consumer group.
     |      consumername: name of a consumer that claims the message.
     |      min_idle_time: filter messages that were idle less than this amount of
     |      milliseconds.
     |      start_id: filter messages with equal or greater ID.
     |      count: optional integer, upper limit of the number of entries that the
     |      command attempts to claim. Set to 100 by default.
     |      justid: optional boolean, false by default. Return just an array of IDs
     |      of messages successfully claimed, without returning the actual message
     |
     |      For more information, see https://redis.io/commands/xautoclaim
     |
     |  xcfgset(self, name: 'KeyT', idmp_duration: 'int | None' = None, idmp_maxsize: 'int | None' = None) -> 'bytes | str | Awaitable[bytes | str]'
     |      Configure the idempotency parameters for a stream's IDMP map.
     |
     |      Sets how long Redis remembers each idempotent ID (iid) and the maximum
     |      number of iids to track. This command clears the existing IDMP map
     |      (Redis forgets all previously stored iids), but only if the configuration
     |      value actually changes.
     |
     |      Args:
     |          name: The name of the stream.
     |          idmp_duration: How long Redis remembers each iid in seconds.
     |              Default: 100 seconds (or value set by stream-idmp-duration config).
     |              Minimum: 1 second, Maximum: 300 seconds.
     |              Redis won't forget an iid for this duration (unless maxsize is reached).
     |              Should accommodate application crash recovery time.
     |          idmp_maxsize: Maximum number of iids Redis remembers per producer ID (pid).
     |              Default: 100 iids (or value set by stream-idmp-maxsize config).
     |              Minimum: 1 iid, Maximum: 1,000,000 (1M) iids.
     |              Should be set to: mark-delay [in msec] × (messages/msec) + margin.
     |              Example: 10K msgs/sec (10 msgs/msec), 80 msec mark-delay
     |              → maxsize = 10 × 80 + margin = 1000 iids.
     |
     |      Returns:
     |          OK on success.
     |
     |      For more information, see https://redis.io/commands/xcfgset
     |
     |  xclaim(self, name: 'KeyT', groupname: 'GroupT', consumername: 'ConsumerT', min_idle_time: 'int', message_ids: 'Union[List[StreamIdT], Tuple[StreamIdT]]', idle: 'int | None' = None, time: 'int | None' = None, retrycount: 'int | None' = None, force: 'bool' = False, justid: 'bool' = False) -> 'XClaimResponse | Awaitable[XClaimResponse]'
     |      Changes the ownership of a pending message.
     |
     |      name: name of the stream.
     |
     |      groupname: name of the consumer group.
     |
     |      consumername: name of a consumer that claims the message.
     |
     |      min_idle_time: filter messages that were idle less than this amount of
     |      milliseconds
     |
     |      message_ids: non-empty list or tuple of message IDs to claim
     |
     |      idle: optional. Set the idle time (last time it was delivered) of the
     |      message in ms
     |
     |      time: optional integer. This is the same as idle but instead of a
     |      relative amount of milliseconds, it sets the idle time to a specific
     |      Unix time (in milliseconds).
     |
     |      retrycount: optional integer. set the retry counter to the specified
     |      value. This counter is incremented every time a message is delivered
     |      again.
     |
     |      force: optional boolean, false by default. Creates the pending message
     |      entry in the PEL even if certain specified IDs are not already in the
     |      PEL assigned to a different client.
     |
     |      justid: optional boolean, false by default. Return just an array of IDs
     |      of messages successfully claimed, without returning the actual message
     |
     |      For more information, see https://redis.io/commands/xclaim
     |
     |  xdel(self, name: 'KeyT', *ids: 'StreamIdT') -> 'int | Awaitable[int]'
     |      Deletes one or more messages from a stream.
     |
     |      Args:
     |          name: name of the stream.
     |          *ids: message ids to delete.
     |
     |      For more information, see https://redis.io/commands/xdel
     |
     |  xdelex(self, name: 'KeyT', *ids: 'StreamIdT', ref_policy: "Literal['KEEPREF', 'DELREF', 'ACKED']" = 'KEEPREF') -> 'int | Awaitable[int]'
     |      Extended version of XDEL that provides more control over how message entries
     |      are deleted concerning consumer groups.
     |
     |  xgroup_create(self, name: 'KeyT', groupname: 'GroupT', id: 'StreamIdT' = '$', mkstream: 'bool' = False, entries_read: 'int | None' = None) -> 'bool | Awaitable[bool]'
     |      Create a new consumer group associated with a stream.
     |      name: name of the stream.
     |      groupname: name of the consumer group.
     |      id: ID of the last item in the stream to consider already delivered.
     |
     |      For more information, see https://redis.io/commands/xgroup-create
     |
     |  xgroup_createconsumer(self, name: 'KeyT', groupname: 'GroupT', consumername: 'ConsumerT') -> 'int | Awaitable[int]'
     |      Consumers in a consumer group are auto-created every time a new
     |      consumer name is mentioned by some command.
     |      They can be explicitly created by using this command.
     |      name: name of the stream.
     |      groupname: name of the consumer group.
     |      consumername: name of consumer to create.
     |
     |      See: https://redis.io/commands/xgroup-createconsumer
     |
     |  xgroup_delconsumer(self, name: 'KeyT', groupname: 'GroupT', consumername: 'ConsumerT') -> 'int | Awaitable[int]'
     |      Remove a specific consumer from a consumer group.
     |      Returns the number of pending messages that the consumer had before it
     |      was deleted.
     |      name: name of the stream.
     |      groupname: name of the consumer group.
     |      consumername: name of consumer to delete
     |
     |      For more information, see https://redis.io/commands/xgroup-delconsumer
     |
     |  xgroup_destroy(self, name: 'KeyT', groupname: 'GroupT') -> 'bool | Awaitable[bool]'
     |      Destroy a consumer group.
     |      name: name of the stream.
     |      groupname: name of the consumer group.
     |
     |      For more information, see https://redis.io/commands/xgroup-destroy
     |
     |  xgroup_setid(self, name: 'KeyT', groupname: 'GroupT', id: 'StreamIdT', entries_read: 'int | None' = None) -> 'bool | Awaitable[bool]'
     |      Set the consumer group last delivered ID to something else.
     |      name: name of the stream.
     |      groupname: name of the consumer group.
     |      id: ID of the last item in the stream to consider already delivered.
     |
     |      For more information, see https://redis.io/commands/xgroup-setid
     |
     |  xinfo_consumers(self, name: 'KeyT', groupname: 'GroupT') -> 'list[dict[str, Any]] | Awaitable[list[dict[str, Any]]]'
     |      Returns general information about the consumers in the group.
     |      name: name of the stream.
     |      groupname: name of the consumer group.
     |
     |      For more information, see https://redis.io/commands/xinfo-consumers
     |
     |  xinfo_groups(self, name: 'KeyT') -> 'list[dict[str, Any]] | Awaitable[list[dict[str, Any]]]'
     |      Returns general information about the consumer groups of the stream.
     |      name: name of the stream.
     |
     |      For more information, see https://redis.io/commands/xinfo-groups
     |
     |  xinfo_stream(self, name: 'KeyT', full: 'bool' = False) -> 'dict[str, Any] | Awaitable[dict[str, Any]]'
     |      Returns general information about the stream.
     |      name: name of the stream.
     |      full: optional boolean, false by default. Return full summary
     |
     |      For more information, see https://redis.io/commands/xinfo-stream
     |
     |  xlen(self, name: 'KeyT') -> 'int | Awaitable[int]'
     |      Returns the number of elements in a given stream.
     |
     |      For more information, see https://redis.io/commands/xlen
     |
     |  xnack(self, name: 'KeyT', groupname: 'GroupT', mode: "Literal['SILENT', 'FAIL', 'FATAL']", *ids: 'StreamIdT', retrycount: 'int | None' = None, force: 'bool' = False) -> 'int | Awaitable[int]'
     |      Negatively acknowledges one or more messages in a consumer group's
     |      Pending Entries List (PEL).
     |
     |      Args:
     |          name: name of the stream.
     |          groupname: name of the consumer group.
     |          mode: the nacking mode. One of SILENT, FAIL, or FATAL.
     |              SILENT: consumer shutting down; decrements delivery counter.
     |              FAIL: consumer unable to process; delivery counter unchanged.
     |              FATAL: invalid/malicious message; delivery counter set to max.
     |          *ids: one or more message IDs to NACK.
     |          retrycount: optional integer >= 0. Overrides the mode's implicit
     |              delivery counter adjustment with an exact value.
     |          force: if True, creates a new unowned PEL entry for any ID not
     |              already in the group's PEL.
     |
     |      Returns:
     |          The number of messages successfully NACKed.
     |
     |      For more information, see https://redis.io/commands/xnack
     |
     |  xpending(self, name: 'KeyT', groupname: 'GroupT') -> 'dict[str, Any] | Awaitable[dict[str, Any]]'
     |      Returns information about pending messages of a group.
     |      name: name of the stream.
     |      groupname: name of the consumer group.
     |
     |      For more information, see https://redis.io/commands/xpending
     |
     |  xpending_range(self, name: 'KeyT', groupname: 'GroupT', min: 'StreamIdT', max: 'StreamIdT', count: 'int', consumername: 'ConsumerT | None' = None, idle: 'int | None' = None) -> 'XPendingRangeResponse | Awaitable[XPendingRangeResponse]'
     |      Returns information about pending messages, in a range.
     |
     |      name: name of the stream.
     |      groupname: name of the consumer group.
     |      idle: available from  version 6.2. filter entries by their
     |      idle-time, given in milliseconds (optional).
     |      min: minimum stream ID.
     |      max: maximum stream ID.
     |      count: number of messages to return
     |      consumername: name of a consumer to filter by (optional).
     |
     |  xrange(self, name: 'KeyT', min: 'StreamIdT' = '-', max: 'StreamIdT' = '+', count: 'int | None' = None) -> 'StreamRangeResponse | None | Awaitable[StreamRangeResponse | None]'
     |      Read stream values within an interval.
     |
     |      name: name of the stream.
     |
     |      start: first stream ID. defaults to '-',
     |             meaning the earliest available.
     |
     |      finish: last stream ID. defaults to '+',
     |              meaning the latest available.
     |
     |      count: if set, only return this many items, beginning with the
     |             earliest available.
     |
     |      For more information, see https://redis.io/commands/xrange
     |
     |  xread(self, streams: 'Dict[KeyT, StreamIdT]', count: 'int | None' = None, block: 'int | None' = None, max_count: 'int | None' = None, max_size: 'int | None' = None) -> 'XReadResponse | Awaitable[XReadResponse]'
     |      Block and monitor multiple streams for new data.
     |
     |      streams: a dict of stream names to stream IDs, where
     |                 IDs indicate the last ID already seen.
     |
     |      count: if set, only return this many items per stream, beginning with
     |             the earliest available.
     |
     |      block: number of milliseconds to wait, if nothing already present.
     |
     |      max_count: if set, cap the total number of entries returned across all
     |                 streams combined. Unlike ``count`` (a per-stream limit),
     |                 this is a cumulative cap over the whole reply. Must be a
     |                 positive integer and, when ``count`` is also set, must be
     |                 greater than or equal to ``count``. Requires Redis >= 8.10.0.
     |
     |      max_size: if set, a soft cap on the total server reply size in bytes
     |                across all streams combined. Measured server-side including
     |                protocol overhead, so it is not an exact application-payload
     |                size guarantee; a single available entry larger than the cap
     |                may still be returned. Must be a positive integer. Requires
     |                Redis >= 8.10.0.
     |
     |      For more information, see https://redis.io/commands/xread
     |
     |  xreadgroup(self, groupname: 'str', consumername: 'str', streams: 'Dict[KeyT, StreamIdT]', count: 'int | None' = None, block: 'int | None' = None, noack: 'bool' = False, claim_min_idle_time: 'int | None' = None, max_count: 'int | None' = None, max_size: 'int | None' = None) -> 'XReadGroupResponse | Awaitable[XReadGroupResponse]'
     |      Read from a stream via a consumer group.
     |
     |      groupname: name of the consumer group.
     |
     |      consumername: name of the requesting consumer.
     |
     |      streams: a dict of stream names to stream IDs, where
     |             IDs indicate the last ID already seen.
     |
     |      count: if set, only return this many items per stream, beginning with
     |             the earliest available.
     |
     |      block: number of milliseconds to wait, if nothing already present.
     |      noack: do not add messages to the PEL
     |
     |      claim_min_idle_time: accepts an integer type and represents a
     |                           time interval in milliseconds
     |
     |      max_count: if set, cap the total number of entries returned across all
     |                 streams combined. Unlike ``count`` (a per-stream limit),
     |                 this is a cumulative cap over the whole reply. Must be a
     |                 positive integer and, when ``count`` is also set, must be
     |                 greater than or equal to ``count``. Requires Redis 8.10.0.
     |
     |      max_size: if set, a soft cap on the total server reply size in bytes
     |                across all streams combined. Measured server-side including
     |                protocol overhead, so it is not an exact application-payload
     |                size guarantee; a single available entry larger than the cap
     |                may still be returned. Must be a positive integer. Requires
     |                Redis 8.10.0.
     |
     |      For more information, see https://redis.io/commands/xreadgroup
     |
     |  xrevrange(self, name: 'KeyT', max: 'StreamIdT' = '+', min: 'StreamIdT' = '-', count: 'int | None' = None) -> 'StreamRangeResponse | None | Awaitable[StreamRangeResponse | None]'
     |      Read stream values within an interval, in reverse order.
     |
     |      name: name of the stream
     |
     |      start: first stream ID. defaults to '+',
     |             meaning the latest available.
     |
     |      finish: last stream ID. defaults to '-',
     |              meaning the earliest available.
     |
     |      count: if set, only return this many items, beginning with the
     |             latest available.
     |
     |      For more information, see https://redis.io/commands/xrevrange
     |
     |  xtrim(self, name: 'KeyT', maxlen: 'int | None' = None, approximate: 'bool' = True, minid: 'StreamIdT | None' = None, limit: 'int | None' = None, ref_policy: "Literal['KEEPREF', 'DELREF', 'ACKED'] | None" = None) -> 'int | Awaitable[int]'
     |      Trims old messages from a stream.
     |      name: name of the stream.
     |      maxlen: truncate old stream messages beyond this size
     |      Can't be specified with minid.
     |      approximate: actual stream length may be slightly more than maxlen
     |      minid: the minimum id in the stream to query
     |      Can't be specified with maxlen.
     |      limit: specifies the maximum number of entries to retrieve
     |      ref_policy: optional reference policy for consumer groups:
     |          - KEEPREF (default): Trims entries but preserves references in consumer groups' PEL
     |          - DELREF: Trims entries and removes all references from consumer groups' PEL
     |          - ACKED: Only trims entries that were read and acknowledged by all consumer groups
     |
     |      For more information, see https://redis.io/commands/xtrim
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from redis.commands.core.SortedSetCommands:
     |
     |  bzmpop(self, timeout: 'float', numkeys: 'int', keys: 'List[str]', min: 'bool | None' = False, max: 'bool | None' = False, count: 'int | None' = 1) -> 'ZMPopResponse | Awaitable[ZMPopResponse]'
     |      Pop ``count`` values (default 1) off of the first non-empty sorted set
     |      named in the ``keys`` list.
     |
     |      If none of the sorted sets in ``keys`` has a value to pop,
     |      then block for ``timeout`` seconds, or until a member gets added
     |      to one of the sorted sets.
     |
     |      If timeout is 0, then block indefinitely.
     |
     |      For more information, see https://redis.io/commands/bzmpop
     |
     |  bzpopmax(self, keys: 'KeysT', timeout: 'TimeoutSecT' = 0) -> 'BlockingZSetPopResponse | Awaitable[BlockingZSetPopResponse]'
     |      ZPOPMAX a value off of the first non-empty sorted set
     |      named in the ``keys`` list.
     |
     |      If none of the sorted sets in ``keys`` has a value to ZPOPMAX,
     |      then block for ``timeout`` seconds, or until a member gets added
     |      to one of the sorted sets.
     |
     |      If timeout is 0, then block indefinitely.
     |
     |      For more information, see https://redis.io/commands/bzpopmax
     |
     |  bzpopmin(self, keys: 'KeysT', timeout: 'TimeoutSecT' = 0) -> 'BlockingZSetPopResponse | Awaitable[BlockingZSetPopResponse]'
     |      ZPOPMIN a value off of the first non-empty sorted set
     |      named in the ``keys`` list.
     |
     |      If none of the sorted sets in ``keys`` has a value to ZPOPMIN,
     |      then block for ``timeout`` seconds, or until a member gets added
     |      to one of the sorted sets.
     |
     |      If timeout is 0, then block indefinitely.
     |
     |      For more information, see https://redis.io/commands/bzpopmin
     |
     |  zadd(self, name: 'KeyT', mapping: 'Mapping[AnyKeyT, EncodableT]', nx: 'bool' = False, xx: 'bool' = False, ch: 'bool' = False, incr: 'bool' = False, gt: 'bool' = False, lt: 'bool' = False) -> 'int | float | None | Awaitable[int | float | None]'
     |      Set any number of element-name, score pairs to the key ``name``. Pairs
     |      are specified as a dict of element-names keys to score values.
     |
     |      ``nx`` forces ZADD to only create new elements and not to update
     |      scores for elements that already exist.
     |
     |      ``xx`` forces ZADD to only update scores of elements that already
     |      exist. New elements will not be added.
     |
     |      ``ch`` modifies the return value to be the numbers of elements changed.
     |      Changed elements include new elements that were added and elements
     |      whose scores changed.
     |
     |      ``incr`` modifies ZADD to behave like ZINCRBY. In this mode only a
     |      single element/score pair can be specified and the score is the amount
     |      the existing score will be incremented by. When using this mode the
     |      return value of ZADD will be the new score of the element.
     |
     |      ``lt`` only updates existing elements if the new score is less than
     |      the current score. This flag doesn't prevent adding new elements.
     |
     |      ``gt`` only updates existing elements if the new score is greater than
     |      the current score. This flag doesn't prevent adding new elements.
     |
     |      The return value of ZADD varies based on the mode specified. With no
     |      options, ZADD returns the number of new elements added to the sorted
     |      set.
     |
     |      ``nx``, ``lt``, and ``gt`` are mutually exclusive options.
     |
     |      See: https://redis.io/commands/ZADD
     |
     |  zcard(self, name: 'KeyT') -> 'int | Awaitable[int]'
     |      Return the number of elements in the sorted set ``name``
     |
     |      For more information, see https://redis.io/commands/zcard
     |
     |  zcount(self, name: 'KeyT', min: 'ZScoreBoundT', max: 'ZScoreBoundT') -> 'int | Awaitable[int]'
     |      Returns the number of elements in the sorted set at key ``name`` with
     |      a score between ``min`` and ``max``.
     |
     |      For more information, see https://redis.io/commands/zcount
     |
     |  zdiff(self, keys: 'KeysT', withscores: 'bool' = False) -> 'ZSetRangeResponse | Awaitable[ZSetRangeResponse]'
     |      Returns the difference between the first and all successive input
     |      sorted sets provided in ``keys``.
     |
     |      For more information, see https://redis.io/commands/zdiff
     |
     |  zdiffstore(self, dest: 'KeyT', keys: 'KeysT') -> 'int | Awaitable[int]'
     |      Computes the difference between the first and all successive input
     |      sorted sets provided in ``keys`` and stores the result in ``dest``.
     |
     |      For more information, see https://redis.io/commands/zdiffstore
     |
     |  zincrby(self, name: 'KeyT', amount: 'float', value: 'EncodableT') -> 'float | None | Awaitable[float | None]'
     |      Increment the score of ``value`` in sorted set ``name`` by ``amount``
     |
     |      For more information, see https://redis.io/commands/zincrby
     |
     |  zinter(self, keys: 'KeysT', aggregate: 'str | None' = None, withscores: 'bool' = False) -> 'ZSetRangeResponse | Awaitable[ZSetRangeResponse]'
     |      Return the intersect of multiple sorted sets specified by ``keys``.
     |
     |      With the ``aggregate`` option, it is possible to specify how the
     |      results of the intersection are aggregated. Available aggregation
     |      modes:
     |
     |      - ``SUM`` (default): the score of an element is summed across the
     |        inputs where it exists.
     |        Score = SUM(score₁×weight₁, score₂×weight₂, ...)
     |      - ``MIN``: the resulting set will contain the minimum score of an
     |        element across the inputs where it exists.
     |        Score = MIN(score₁×weight₁, score₂×weight₂, ...)
     |      - ``MAX``: the resulting set will contain the maximum score of an
     |        element across the inputs where it exists.
     |        Score = MAX(score₁×weight₁, score₂×weight₂, ...)
     |      - ``COUNT``: ignores the original scores and counts weighted set
     |        membership. Each element's score is the sum of the weights of
     |        the input sets that contain it.
     |        Score = SUM(weight₁, weight₂, ...) for sets containing the element.
     |        When all weights are 1 (default), the score equals the number
     |        of input sets containing the element.
     |
     |      For more information, see https://redis.io/commands/zinter
     |
     |  zintercard(self, numkeys: 'int', keys: 'List[str]', limit: 'int' = 0) -> 'int | Awaitable[int]'
     |      Return the cardinality of the intersect of multiple sorted sets
     |      specified by ``keys``.
     |      When LIMIT provided (defaults to 0 and means unlimited), if the intersection
     |      cardinality reaches limit partway through the computation, the algorithm will
     |      exit and yield limit as the cardinality
     |
     |      For more information, see https://redis.io/commands/zintercard
     |
     |  zinterstore(self, dest: 'KeyT', keys: 'Sequence[KeyT] | Mapping[AnyKeyT, float]', aggregate: 'str | None' = None) -> 'int | Awaitable[int]'
     |      Intersect multiple sorted sets specified by ``keys`` into a new
     |      sorted set, ``dest``. Scores in the destination will be aggregated
     |      based on the ``aggregate``.
     |
     |      Available aggregation modes:
     |
     |      - ``SUM`` (default): the score of an element is summed across the
     |        inputs where it exists.
     |        Score = SUM(score₁×weight₁, score₂×weight₂, ...)
     |      - ``MIN``: the resulting set will contain the minimum score of an
     |        element across the inputs where it exists.
     |        Score = MIN(score₁×weight₁, score₂×weight₂, ...)
     |      - ``MAX``: the resulting set will contain the maximum score of an
     |        element across the inputs where it exists.
     |        Score = MAX(score₁×weight₁, score₂×weight₂, ...)
     |      - ``COUNT``: ignores the original scores and counts weighted set
     |        membership. Each element's score is the sum of the weights of
     |        the input sets that contain it.
     |        Score = SUM(weight₁, weight₂, ...) for sets containing the element.
     |        When all weights are 1 (default), the score equals the number
     |        of input sets containing the element.
     |
     |      For more information, see https://redis.io/commands/zinterstore
     |
     |  zlexcount(self, name: 'KeyT', min: 'EncodableT', max: 'EncodableT') -> 'int | Awaitable[int]'
     |      Return the number of items in the sorted set ``name`` between the
     |      lexicographical range ``min`` and ``max``.
     |
     |      For more information, see https://redis.io/commands/zlexcount
     |
     |  zmpop(self, num_keys: 'int', keys: 'List[str]', min: 'bool | None' = False, max: 'bool | None' = False, count: 'int | None' = 1) -> 'ZMPopResponse | Awaitable[ZMPopResponse]'
     |      Pop ``count`` values (default 1) off of the first non-empty sorted set
     |      named in the ``keys`` list.
     |      For more information, see https://redis.io/commands/zmpop
     |
     |  zmscore(self, key: 'KeyT', members: 'List[str]') -> 'list[float | None] | Awaitable[list[float | None]]'
     |      Returns the scores associated with the specified members
     |      in the sorted set stored at key.
     |      ``members`` should be a list of the member name.
     |      Return type is a list of score.
     |      If the member does not exist, a None will be returned
     |      in corresponding position.
     |
     |      For more information, see https://redis.io/commands/zmscore
     |
     |  zpopmax(self, name: 'KeyT', count: 'int | None' = None) -> 'ZSetRangeResponse | Awaitable[ZSetRangeResponse]'
     |      Remove and return up to ``count`` members with the highest scores
     |      from the sorted set ``name``.
     |
     |      For more information, see https://redis.io/commands/zpopmax
     |
     |  zpopmin(self, name: 'KeyT', count: 'int | None' = None) -> 'ZSetRangeResponse | Awaitable[ZSetRangeResponse]'
     |      Remove and return up to ``count`` members with the lowest scores
     |      from the sorted set ``name``.
     |
     |      For more information, see https://redis.io/commands/zpopmin
     |
     |  zrandmember(self, key: 'KeyT', count: 'int | None' = None, withscores: 'bool' = False) -> 'ZRandMemberResponse | Awaitable[ZRandMemberResponse]'
     |      Return a random element from the sorted set value stored at key.
     |
     |      ``count`` if the argument is positive, return an array of distinct
     |      fields. If called with a negative count, the behavior changes and
     |      the command is allowed to return the same field multiple times.
     |      In this case, the number of returned fields is the absolute value
     |      of the specified count.
     |
     |      ``withscores`` The optional WITHSCORES modifier changes the reply so it
     |      includes the respective scores of the randomly selected elements from
     |      the sorted set.
     |
     |      For more information, see https://redis.io/commands/zrandmember
     |
     |  zrange(self, name: 'KeyT', start: 'EncodableT', end: 'EncodableT', desc: 'bool' = False, withscores: 'bool' = False, score_cast_func: 'type | Callable' = <class 'float'>, byscore: 'bool' = False, bylex: 'bool' = False, offset: 'int | None' = None, num: 'int | None' = None) -> 'ZSetRangeResponse | Awaitable[ZSetRangeResponse]'
     |      Return a range of values from sorted set ``name`` between
     |      ``start`` and ``end`` sorted in ascending order.
     |
     |      ``start`` and ``end`` can be negative, indicating the end of the range.
     |
     |      ``desc`` a boolean indicating whether to sort the results in reversed
     |      order.
     |
     |      ``withscores`` indicates to return the scores along with the values.
     |      The return type is a list of (value, score) pairs.
     |
     |      ``score_cast_func`` a callable used to cast the score return value.
     |
     |      ``byscore`` when set to True, returns the range of elements from the
     |      sorted set having scores equal or between ``start`` and ``end``.
     |
     |      ``bylex`` when set to True, returns the range of elements from the
     |      sorted set between the ``start`` and ``end`` lexicographical closed
     |      range intervals.
     |      Valid ``start`` and ``end`` must start with ( or [, in order to specify
     |      whether the range interval is exclusive or inclusive, respectively.
     |
     |      ``offset`` and ``num`` are specified, then return a slice of the range.
     |      Can't be provided when using ``bylex``.
     |
     |      For more information, see https://redis.io/commands/zrange
     |
     |  zrangebylex(self, name: 'KeyT', min: 'EncodableT', max: 'EncodableT', start: 'int | None' = None, num: 'int | None' = None) -> 'list[bytes | str] | Awaitable[list[bytes | str]]'
     |      Return the lexicographical range of values from sorted set ``name``
     |      between ``min`` and ``max``.
     |
     |      If ``start`` and ``num`` are specified, then return a slice of the
     |      range.
     |
     |      For more information, see https://redis.io/commands/zrangebylex
     |
     |  zrangebyscore(self, name: 'KeyT', min: 'ZScoreBoundT', max: 'ZScoreBoundT', start: 'int | None' = None, num: 'int | None' = None, withscores: 'bool' = False, score_cast_func: 'type | Callable' = <class 'float'>) -> 'ZSetRangeResponse | Awaitable[ZSetRangeResponse]'
     |      Return a range of values from the sorted set ``name`` with scores
     |      between ``min`` and ``max``.
     |
     |      If ``start`` and ``num`` are specified, then return a slice
     |      of the range.
     |
     |      ``withscores`` indicates to return the scores along with the values.
     |      The return type is a list of (value, score) pairs
     |
     |      `score_cast_func`` a callable used to cast the score return value
     |
     |      For more information, see https://redis.io/commands/zrangebyscore
     |
     |  zrangestore(self, dest: 'KeyT', name: 'KeyT', start: 'EncodableT', end: 'EncodableT', byscore: 'bool' = False, bylex: 'bool' = False, desc: 'bool' = False, offset: 'int | None' = None, num: 'int | None' = None) -> 'int | Awaitable[int]'
     |      Stores in ``dest`` the result of a range of values from sorted set
     |      ``name`` between ``start`` and ``end`` sorted in ascending order.
     |
     |      ``start`` and ``end`` can be negative, indicating the end of the range.
     |
     |      ``byscore`` when set to True, returns the range of elements from the
     |      sorted set having scores equal or between ``start`` and ``end``.
     |
     |      ``bylex`` when set to True, returns the range of elements from the
     |      sorted set between the ``start`` and ``end`` lexicographical closed
     |      range intervals.
     |      Valid ``start`` and ``end`` must start with ( or [, in order to specify
     |      whether the range interval is exclusive or inclusive, respectively.
     |
     |      ``desc`` a boolean indicating whether to sort the results in reversed
     |      order.
     |
     |      ``offset`` and ``num`` are specified, then return a slice of the range.
     |      Can't be provided when using ``bylex``.
     |
     |      For more information, see https://redis.io/commands/zrangestore
     |
     |  zrank(self, name: 'KeyT', value: 'EncodableT', withscore: 'bool' = False, score_cast_func: 'type | Callable' = <class 'float'>) -> 'int | list[Any] | None | Awaitable[int | list[Any] | None]'
     |      Returns a 0-based value indicating the rank of ``value`` in sorted set
     |      ``name``.
     |      The optional WITHSCORE argument supplements the command's
     |      reply with the score of the element returned.
     |
     |      ``score_cast_func`` a callable used to cast the score return value
     |
     |      For more information, see https://redis.io/commands/zrank
     |
     |  zrem(self, name: 'KeyT', *values: 'FieldT') -> 'int | Awaitable[int]'
     |      Remove member ``values`` from sorted set ``name``
     |
     |      For more information, see https://redis.io/commands/zrem
     |
     |  zremrangebylex(self, name: 'KeyT', min: 'EncodableT', max: 'EncodableT') -> 'int | Awaitable[int]'
     |      Remove all elements in the sorted set ``name`` between the
     |      lexicographical range specified by ``min`` and ``max``.
     |
     |      Returns the number of elements removed.
     |
     |      For more information, see https://redis.io/commands/zremrangebylex
     |
     |  zremrangebyrank(self, name: 'KeyT', min: 'int', max: 'int') -> 'int | Awaitable[int]'
     |      Remove all elements in the sorted set ``name`` with ranks between
     |      ``min`` and ``max``. Values are 0-based, ordered from smallest score
     |      to largest. Values can be negative indicating the highest scores.
     |      Returns the number of elements removed
     |
     |      For more information, see https://redis.io/commands/zremrangebyrank
     |
     |  zremrangebyscore(self, name: 'KeyT', min: 'ZScoreBoundT', max: 'ZScoreBoundT') -> 'int | Awaitable[int]'
     |      Remove all elements in the sorted set ``name`` with scores
     |      between ``min`` and ``max``. Returns the number of elements removed.
     |
     |      For more information, see https://redis.io/commands/zremrangebyscore
     |
     |  zrevrange(self, name: 'KeyT', start: 'int', end: 'int', withscores: 'bool' = False, score_cast_func: 'type | Callable' = <class 'float'>) -> 'ZSetRangeResponse | Awaitable[ZSetRangeResponse]'
     |      Return a range of values from sorted set ``name`` between
     |      ``start`` and ``end`` sorted in descending order.
     |
     |      ``start`` and ``end`` can be negative, indicating the end of the range.
     |
     |      ``withscores`` indicates to return the scores along with the values
     |      The return type is a list of (value, score) pairs
     |
     |      ``score_cast_func`` a callable used to cast the score return value
     |
     |      For more information, see https://redis.io/commands/zrevrange
     |
     |  zrevrangebylex(self, name: 'KeyT', max: 'EncodableT', min: 'EncodableT', start: 'int | None' = None, num: 'int | None' = None) -> 'list[bytes | str] | Awaitable[list[bytes | str]]'
     |      Return the reversed lexicographical range of values from sorted set
     |      ``name`` between ``max`` and ``min``.
     |
     |      If ``start`` and ``num`` are specified, then return a slice of the
     |      range.
     |
     |      For more information, see https://redis.io/commands/zrevrangebylex
     |
     |  zrevrangebyscore(self, name: 'KeyT', max: 'ZScoreBoundT', min: 'ZScoreBoundT', start: 'int | None' = None, num: 'int | None' = None, withscores: 'bool' = False, score_cast_func: 'type | Callable' = <class 'float'>) -> 'ZSetRangeResponse | Awaitable[ZSetRangeResponse]'
     |      Return a range of values from the sorted set ``name`` with scores
     |      between ``min`` and ``max`` in descending order.
     |
     |      If ``start`` and ``num`` are specified, then return a slice
     |      of the range.
     |
     |      ``withscores`` indicates to return the scores along with the values.
     |      The return type is a list of (value, score) pairs
     |
     |      ``score_cast_func`` a callable used to cast the score return value
     |
     |      For more information, see https://redis.io/commands/zrevrangebyscore
     |
     |  zrevrank(self, name: 'KeyT', value: 'EncodableT', withscore: 'bool' = False, score_cast_func: 'type | Callable' = <class 'float'>) -> 'int | list[Any] | None | Awaitable[int | list[Any] | None]'
     |      Returns a 0-based value indicating the descending rank of
     |      ``value`` in sorted set ``name``.
     |      The optional ``withscore`` argument supplements the command's
     |      reply with the score of the element returned.
     |
     |      ``score_cast_func`` a callable used to cast the score return value
     |
     |      For more information, see https://redis.io/commands/zrevrank
     |
     |  zscore(self, name: 'KeyT', value: 'EncodableT') -> 'float | None | Awaitable[float | None]'
     |      Return the score of element ``value`` in sorted set ``name``
     |
     |      For more information, see https://redis.io/commands/zscore
     |
     |  zunion(self, keys: 'Sequence[KeyT] | Mapping[AnyKeyT, float]', aggregate: 'str | None' = None, withscores: 'bool' = False, score_cast_func: 'type | Callable' = <class 'float'>) -> 'ZSetRangeResponse | Awaitable[ZSetRangeResponse]'
     |      Return the union of multiple sorted sets specified by ``keys``.
     |      ``keys`` can be provided as dictionary of keys and their weights.
     |      Scores will be aggregated based on the ``aggregate``, or SUM if
     |      none is provided.
     |
     |      Available aggregation modes:
     |
     |      - ``SUM`` (default): the score of an element is summed across the
     |        inputs where it exists.
     |        Score = SUM(score₁×weight₁, score₂×weight₂, ...)
     |      - ``MIN``: the resulting set will contain the minimum score of an
     |        element across the inputs where it exists.
     |        Score = MIN(score₁×weight₁, score₂×weight₂, ...)
     |      - ``MAX``: the resulting set will contain the maximum score of an
     |        element across the inputs where it exists.
     |        Score = MAX(score₁×weight₁, score₂×weight₂, ...)
     |      - ``COUNT``: ignores the original scores and counts weighted set
     |        membership. Each element's score is the sum of the weights of
     |        the input sets that contain it.
     |        Score = SUM(weight₁, weight₂, ...) for sets containing the element.
     |        When all weights are 1 (default), the score equals the number
     |        of input sets containing the element.
     |
     |      ``score_cast_func`` a callable used to cast the score return value
     |
     |      For more information, see https://redis.io/commands/zunion
     |
     |  zunionstore(self, dest: 'KeyT', keys: 'Sequence[KeyT] | Mapping[AnyKeyT, float]', aggregate: 'str | None' = None) -> 'int | Awaitable[int]'
     |      Union multiple sorted sets specified by ``keys`` into
     |      a new sorted set, ``dest``. Scores in the destination will be
     |      aggregated based on the ``aggregate``, or SUM if none is provided.
     |
     |      Available aggregation modes:
     |
     |      - ``SUM`` (default): the score of an element is summed across the
     |        inputs where it exists.
     |        Score = SUM(score₁×weight₁, score₂×weight₂, ...)
     |      - ``MIN``: the resulting set will contain the minimum score of an
     |        element across the inputs where it exists.
     |        Score = MIN(score₁×weight₁, score₂×weight₂, ...)
     |      - ``MAX``: the resulting set will contain the maximum score of an
     |        element across the inputs where it exists.
     |        Score = MAX(score₁×weight₁, score₂×weight₂, ...)
     |      - ``COUNT``: ignores the original scores and counts weighted set
     |        membership. Each element's score is the sum of the weights of
     |        the input sets that contain it.
     |        Score = SUM(weight₁, weight₂, ...) for sets containing the element.
     |        When all weights are 1 (default), the score equals the number
     |        of input sets containing the element.
     |
     |      For more information, see https://redis.io/commands/zunionstore
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from redis.commands.core.ManagementCommands:
     |
     |  auth(self, password: 'str', username: 'str | None' = None, **kwargs) -> 'bool | Awaitable[bool]'
     |      Authenticates the user. If you do not pass username, Redis will try to
     |      authenticate for the "default" user. If you do pass username, it will
     |      authenticate for the given user.
     |      For more information, see https://redis.io/commands/auth
     |
     |  bgrewriteaof(self, **kwargs) -> 'bool | bytes | str | Awaitable[bool | bytes | str]'
     |      Tell the Redis server to rewrite the AOF file from data in memory.
     |
     |      For more information, see https://redis.io/commands/bgrewriteaof
     |
     |  bgsave(self, schedule: 'bool' = True, **kwargs) -> 'bool | bytes | str | Awaitable[bool | bytes | str]'
     |      Tell the Redis server to save its data to disk.  Unlike save(),
     |      this method is asynchronous and returns immediately.
     |
     |      For more information, see https://redis.io/commands/bgsave
     |
     |  client_getname(self, **kwargs) -> 'bytes | str | None | Awaitable[bytes | str | None]'
     |      Returns the current connection name
     |
     |      For more information, see https://redis.io/commands/client-getname
     |
     |  client_getredir(self, **kwargs) -> 'int | Awaitable[int]'
     |      Returns the ID (an integer) of the client to whom we are
     |      redirecting tracking notifications.
     |
     |      see: https://redis.io/commands/client-getredir
     |
     |  client_id(self, **kwargs) -> 'int | Awaitable[int]'
     |      Returns the current connection id
     |
     |      For more information, see https://redis.io/commands/client-id
     |
     |  client_info(self, **kwargs) -> 'dict[str, str | int] | Awaitable[dict[str, str | int]]'
     |      Returns information and statistics about the current
     |      client connection.
     |
     |      For more information, see https://redis.io/commands/client-info
     |
     |  client_kill(self, address: 'str', **kwargs) -> 'bool | int | Awaitable[bool | int]'
     |      Disconnects the client at ``address`` (ip:port)
     |
     |      For more information, see https://redis.io/commands/client-kill
     |
     |  client_kill_filter(self, _id: 'str | None' = None, _type: 'str | None' = None, addr: 'str | None' = None, skipme: 'bool | None' = None, laddr: 'bool | None' = None, user: 'str | None' = None, maxage: 'int | None' = None, **kwargs) -> 'int | Awaitable[int]'
     |      Disconnects client(s) using a variety of filter options
     |      :param _id: Kills a client by its unique ID field
     |      :param _type: Kills a client by type where type is one of 'normal',
     |      'master', 'slave', 'replica' or 'pubsub'
     |      :param addr: Kills a client by its 'address:port'
     |      :param skipme: If True, then the client calling the command
     |      will not get killed even if it is identified by one of the filter
     |      options. If skipme is not provided, the server defaults to skipme=True
     |      :param laddr: Kills a client by its 'local (bind) address:port'
     |      :param user: Kills a client for a specific user name
     |      :param maxage: Kills clients that are older than the specified age in seconds
     |
     |  client_list(self, _type: 'str | None' = None, client_id: 'List[EncodableT]' = [], **kwargs) -> 'list[dict[str, str]] | Awaitable[list[dict[str, str]]]'
     |      Returns a list of currently connected clients.
     |      If type of client specified, only that type will be returned.
     |
     |      :param _type: optional. one of the client types (normal, master,
     |       replica, pubsub)
     |      :param client_id: optional. a list of client ids
     |
     |      For more information, see https://redis.io/commands/client-list
     |
     |  client_no_evict(self, mode: 'str') -> 'bytes | str | Awaitable[bytes | str]'
     |      Sets the client eviction mode for the current connection.
     |
     |      For more information, see https://redis.io/commands/client-no-evict
     |
     |  client_no_touch(self, mode: 'str') -> 'bytes | str | Awaitable[bytes | str]'
     |      # The command controls whether commands sent by the client will alter
     |      # the LRU/LFU of the keys they access.
     |      # When turned on, the current client will not change LFU/LRU stats,
     |      # unless it sends the TOUCH command.
     |
     |      For more information, see https://redis.io/commands/client-no-touch
     |
     |  client_pause(self, timeout: 'int', all: 'bool' = True, **kwargs) -> 'bool | Awaitable[bool]'
     |      Suspend all the Redis clients for the specified amount of time.
     |
     |
     |      For more information, see https://redis.io/commands/client-pause
     |
     |      Args:
     |          timeout: milliseconds to pause clients
     |          all: If true (default) all client commands are blocked.
     |               otherwise, clients are only blocked if they attempt to execute
     |               a write command.
     |
     |      For the WRITE mode, some commands have special behavior:
     |
     |      * EVAL/EVALSHA: Will block client for all scripts.
     |      * PUBLISH: Will block client.
     |      * PFCOUNT: Will block client.
     |      * WAIT: Acknowledgments will be delayed, so this command will
     |          appear blocked.
     |
     |  client_reply(self, reply: "Literal['ON', 'OFF', 'SKIP']", **kwargs) -> 'bytes | str | Awaitable[bytes | str]'
     |      Enable and disable redis server replies.
     |
     |      ``reply`` Must be ON OFF or SKIP,
     |      ON - The default most with server replies to commands
     |      OFF - Disable server responses to commands
     |      SKIP - Skip the response of the immediately following command.
     |
     |      Note: When setting OFF or SKIP replies, you will need a client object
     |      with a timeout specified in seconds, and will need to catch the
     |      TimeoutError.
     |      The test_client_reply unit test illustrates this, and
     |      conftest.py has a client with a timeout.
     |
     |      See https://redis.io/commands/client-reply
     |
     |  client_setinfo(self, attr: 'str', value: 'str', **kwargs) -> 'bool | Awaitable[bool]'
     |      Sets the current connection library name or version
     |      For more information see https://redis.io/commands/client-setinfo
     |
     |  client_setname(self, name: 'str', **kwargs) -> 'bool | Awaitable[bool]'
     |      Sets the current connection name
     |
     |      For more information, see https://redis.io/commands/client-setname
     |
     |      .. note::
     |         This method sets client name only for **current** connection.
     |
     |         If you want to set a common name for all connections managed
     |         by this client, use ``client_name`` constructor argument.
     |
     |  client_tracking(self, on: 'bool' = True, clientid: 'int | None' = None, prefix: 'Sequence[KeyT]' = [], bcast: 'bool' = False, optin: 'bool' = False, optout: 'bool' = False, noloop: 'bool' = False, **kwargs) -> 'bytes | str | Awaitable[bytes | str]'
     |      Enables the tracking feature of the Redis server, that is used
     |      for server assisted client side caching.
     |
     |      ``on`` indicate for tracking on or tracking off. The default is on.
     |
     |      ``clientid`` send invalidation messages to the connection with
     |      the specified ID.
     |
     |      ``bcast`` enable tracking in broadcasting mode. In this mode
     |      invalidation messages are reported for all the prefixes
     |      specified, regardless of the keys requested by the connection.
     |
     |      ``optin``  when broadcasting is NOT active, normally don't track
     |      keys in read only commands, unless they are called immediately
     |      after a CLIENT CACHING yes command.
     |
     |      ``optout`` when broadcasting is NOT active, normally track keys in
     |      read only commands, unless they are called immediately after a
     |      CLIENT CACHING no command.
     |
     |      ``noloop`` don't send notifications about keys modified by this
     |      connection itself.
     |
     |      ``prefix``  for broadcasting, register a given key prefix, so that
     |      notifications will be provided only for keys starting with this string.
     |
     |      See https://redis.io/commands/client-tracking
     |
     |  client_tracking_off(self, clientid: 'int | None' = None, prefix: 'Sequence[KeyT]' = [], bcast: 'bool' = False, optin: 'bool' = False, optout: 'bool' = False, noloop: 'bool' = False) -> 'bytes | str | Awaitable[bytes | str]'
     |      Turn off the tracking mode.
     |      For more information, about the options look at client_tracking func.
     |
     |      See https://redis.io/commands/client-tracking
     |
     |  client_tracking_on(self, clientid: 'int | None' = None, prefix: 'Sequence[KeyT]' = [], bcast: 'bool' = False, optin: 'bool' = False, optout: 'bool' = False, noloop: 'bool' = False) -> 'bytes | str | Awaitable[bytes | str]'
     |      Turn on the tracking mode.
     |      For more information, about the options look at client_tracking func.
     |
     |      See https://redis.io/commands/client-tracking
     |
     |  client_trackinginfo(self, **kwargs) -> 'ClientTrackingInfoResponse | Awaitable[ClientTrackingInfoResponse]'
     |      Returns the information about the current client connection's
     |      use of the server assisted client side cache.
     |
     |      See https://redis.io/commands/client-trackinginfo
     |
     |  client_unblock(self, client_id: 'int', error: 'bool' = False, **kwargs) -> 'bool | Awaitable[bool]'
     |      Unblocks a connection by its client id.
     |      If ``error`` is True, unblocks the client with a special error message.
     |      If ``error`` is False (default), the client is unblocked using the
     |      regular timeout mechanism.
     |
     |      For more information, see https://redis.io/commands/client-unblock
     |
     |  client_unpause(self, **kwargs) -> 'bytes | str | Awaitable[bytes | str]'
     |      Unpause all redis clients
     |
     |      For more information, see https://redis.io/commands/client-unpause
     |
     |  command(self, **kwargs) -> 'dict[str, dict[str, Any]] | Awaitable[dict[str, dict[str, Any]]]'
     |      Returns dict reply of details about all Redis commands.
     |
     |      For more information, see https://redis.io/commands/command
     |
     |  command_count(self, **kwargs) -> 'int | Awaitable[int]'
     |
     |  command_docs(self, *args)
     |      This function throws a NotImplementedError since it is intentionally
     |      not supported.
     |
     |  command_getkeysandflags(self, *args: 'str') -> 'CommandGetKeysAndFlagsResponse | Awaitable[CommandGetKeysAndFlagsResponse]'
     |      Returns array of keys from a full Redis command and their usage flags.
     |
     |      For more information, see https://redis.io/commands/command-getkeysandflags
     |
     |  command_info(self, **kwargs) -> 'None'
     |
     |  command_list(self, module: 'str | None' = None, category: 'str | None' = None, pattern: 'str | None' = None) -> 'list[bytes | str] | Awaitable[list[bytes | str]]'
     |      Return an array of the server's command names.
     |      You can use one of the following filters:
     |      ``module``: get the commands that belong to the module
     |      ``category``: get the commands in the ACL category
     |      ``pattern``: get the commands that match the given pattern
     |
     |      For more information, see https://redis.io/commands/command-list/
     |
     |  config_get(self, pattern: 'PatternT' = '*', *args: 'PatternT', **kwargs) -> 'dict[str | None, str | None] | Awaitable[dict[str | None, str | None]]'
     |      Return a dictionary of configuration based on the ``pattern``
     |
     |      For more information, see https://redis.io/commands/config-get
     |
     |  config_resetstat(self, **kwargs) -> 'bool | Awaitable[bool]'
     |      Reset runtime statistics
     |
     |      For more information, see https://redis.io/commands/config-resetstat
     |
     |  config_rewrite(self, **kwargs) -> 'bytes | str | Awaitable[bytes | str]'
     |      Rewrite config file with the minimal change to reflect running config.
     |
     |      For more information, see https://redis.io/commands/config-rewrite
     |
     |  config_set(self, name: 'KeyT', value: 'EncodableT', *args: 'Union[KeyT, EncodableT]', **kwargs) -> 'bool | Awaitable[bool]'
     |      Set config item ``name`` with ``value``
     |
     |      For more information, see https://redis.io/commands/config-set
     |
     |  dbsize(self, **kwargs) -> 'int | Awaitable[int]'
     |      Returns the number of keys in the current database
     |
     |      For more information, see https://redis.io/commands/dbsize
     |
     |  debug_object(self, key: 'KeyT', **kwargs) -> 'dict[str, str | int] | bytes | str | Awaitable[dict[str, str | int] | bytes | str]'
     |      Returns version specific meta information about a given key
     |
     |      For more information, see https://redis.io/commands/debug-object
     |
     |  debug_segfault(self, **kwargs) -> 'None'
     |
     |  echo(self, value: 'EncodableT', **kwargs) -> 'bytes | str | Awaitable[bytes | str]'
     |      Echo the string back from the server
     |
     |      For more information, see https://redis.io/commands/echo
     |
     |  failover(self)
     |      This function throws a NotImplementedError since it is intentionally
     |      not supported.
     |
     |  flushall(self, asynchronous: 'bool' = False, **kwargs) -> 'bool | Awaitable[bool]'
     |      Delete all keys in all databases on the current host.
     |
     |      ``asynchronous`` indicates whether the operation is
     |      executed asynchronously by the server.
     |
     |      For more information, see https://redis.io/commands/flushall
     |
     |  flushdb(self, asynchronous: 'bool' = False, **kwargs) -> 'bool | Awaitable[bool]'
     |      Delete all keys in the current database.
     |
     |      ``asynchronous`` indicates whether the operation is
     |      executed asynchronously by the server.
     |
     |      For more information, see https://redis.io/commands/flushdb
     |
     |  hello(self)
     |      This function throws a NotImplementedError since it is intentionally
     |      not supported.
     |
     |  hotkeys_get(self, **kwargs) -> 'Union[Awaitable[list[dict[str | bytes, Any]]], list[dict[str | bytes, Any]]]'
     |      Retrieve the result of the ongoing collection session (if any),
     |      or the last collection session (if any).
     |
     |      HOTKEYS GET response is wrapped in an array for aggregation support.
     |      Each node returns a single-element array, allowing multiple node
     |      responses to be concatenated by DMC or other aggregators.
     |
     |      For more information, see https://redis.io/commands/hotkeys-get
     |
     |  hotkeys_reset(self, **kwargs) -> 'bytes | str | Awaitable[bytes | str]'
     |      Discard the last hotkeys collection session results (in order to save memory).
     |      Error if there is an ongoing collection session.
     |
     |      For more information, see https://redis.io/commands/hotkeys-reset
     |
     |  hotkeys_start(self, metrics: 'List[HotkeysMetricsTypes]', count: 'int | None' = None, duration: 'int | None' = None, sample_ratio: 'int | None' = None, slots: 'List[int] | None' = None, **kwargs) -> 'bytes | str | Awaitable[bytes | str]'
     |      Start collecting hotkeys data.
     |      Returns an error if there is an ongoing collection session.
     |
     |      Args:
     |          count: The number of keys to collect in each criteria (CPU and network consumption)
     |          metrics: List of metrics to track. Supported values: [HotkeysMetricsTypes.CPU, HotkeysMetricsTypes.NET]
     |          duration: Automatically stop the collection after `duration` seconds
     |          sample_ratio: Commands are sampled with probability 1/ratio (1 means no sampling)
     |          slots: Only track keys on the specified hash slots
     |
     |      For more information, see https://redis.io/commands/hotkeys-start
     |
     |  hotkeys_stop(self, **kwargs) -> 'bytes | str | Awaitable[bytes | str]'
     |      Stop the ongoing hotkeys collection session (if any).
     |      The results of the last collection session are kept for consumption with HOTKEYS GET.
     |
     |      For more information, see https://redis.io/commands/hotkeys-stop
     |
     |  info(self, section: 'Optional[str]' = None, *args: 'str', **kwargs) -> 'dict[str, Any] | Awaitable[dict[str, Any]]'
     |      Returns a dictionary containing information about the Redis server
     |
     |      The ``section`` option can be used to select a specific section
     |      of information
     |
     |      The section option is not supported by older versions of Redis Server,
     |      and will generate ResponseError
     |
     |      For more information, see https://redis.io/commands/info
     |
     |  lastsave(self, **kwargs) -> 'datetime.datetime | Awaitable[datetime.datetime]'
     |      Return a Python datetime object representing the last time the
     |      Redis database was saved to disk
     |
     |      For more information, see https://redis.io/commands/lastsave
     |
     |  latency_doctor(self)
     |      Raise a NotImplementedError, as the client will not support LATENCY DOCTOR.
     |      This function is best used within the redis-cli.
     |
     |      For more information, see https://redis.io/commands/latency-doctor
     |
     |  latency_graph(self)
     |      Raise a NotImplementedError, as the client will not support LATENCY GRAPH.
     |      This function is best used within the redis-cli.
     |
     |      For more information, see https://redis.io/commands/latency-graph.
     |
     |  latency_histogram(self, *args)
     |      This function throws a NotImplementedError since it is intentionally
     |      not supported.
     |
     |  latency_history(self, event: 'str') -> 'list[list[int]] | Awaitable[list[list[int]]]'
     |      Returns the raw data of the ``event``'s latency spikes time series.
     |
     |      For more information, see https://redis.io/commands/latency-history
     |
     |  latency_latest(self) -> 'list[list[bytes | str | int]] | Awaitable[list[list[bytes | str | int]]]'
     |      Reports the latest latency events logged.
     |
     |      For more information, see https://redis.io/commands/latency-latest
     |
     |  latency_reset(self, *events: 'str') -> 'int | Awaitable[int]'
     |      Resets the latency spikes time series of all, or only some, events.
     |
     |      For more information, see https://redis.io/commands/latency-reset
     |
     |  lolwut(self, *version_numbers: 'Union[str, float]', **kwargs) -> 'bytes | str | Awaitable[bytes | str]'
     |      Get the Redis version and a piece of generative computer art
     |
     |      See: https://redis.io/commands/lolwut
     |
     |  memory_doctor(self, **kwargs) -> 'None'
     |
     |  memory_help(self, **kwargs) -> 'None'
     |
     |  memory_malloc_stats(self, **kwargs) -> 'bytes | str | Awaitable[bytes | str]'
     |      Return an internal statistics report from the memory allocator.
     |
     |      See: https://redis.io/commands/memory-malloc-stats
     |
     |  memory_purge(self, **kwargs) -> 'bool | Awaitable[bool]'
     |      Attempts to purge dirty pages for reclamation by allocator
     |
     |      For more information, see https://redis.io/commands/memory-purge
     |
     |  memory_stats(self, **kwargs) -> 'dict[str, Any] | Awaitable[dict[str, Any]]'
     |      Return a dictionary of memory stats
     |
     |      For more information, see https://redis.io/commands/memory-stats
     |
     |  memory_usage(self, key: 'KeyT', samples: 'int | None' = None, **kwargs) -> 'int | None | Awaitable[int | None]'
     |      Return the total memory usage for key, its value and associated
     |      administrative overheads.
     |
     |      For nested data structures, ``samples`` is the number of elements to
     |      sample. If left unspecified, the server's default is 5. Use 0 to sample
     |      all elements.
     |
     |      For more information, see https://redis.io/commands/memory-usage
     |
     |  migrate(self, host: 'str', port: 'int', keys: 'KeysT', destination_db: 'int', timeout: 'int', copy: 'bool' = False, replace: 'bool' = False, auth: 'str | None' = None, **kwargs) -> 'bytes | str | Awaitable[bytes | str]'
     |      Migrate 1 or more keys from the current Redis server to a different
     |      server specified by the ``host``, ``port`` and ``destination_db``.
     |
     |      The ``timeout``, specified in milliseconds, indicates the maximum
     |      time the connection between the two servers can be idle before the
     |      command is interrupted.
     |
     |      If ``copy`` is True, the specified ``keys`` are NOT deleted from
     |      the source server.
     |
     |      If ``replace`` is True, this operation will overwrite the keys
     |      on the destination server if they exist.
     |
     |      If ``auth`` is specified, authenticate to the destination server with
     |      the password provided.
     |
     |      For more information, see https://redis.io/commands/migrate
     |
     |  object(self, infotype: 'str', key: 'KeyT', **kwargs) -> 'Any | Awaitable[Any]'
     |      Return the encoding, idletime, or refcount about the key
     |
     |  ping(self, **kwargs) -> 'Union[Awaitable[bool], bool]'
     |      Ping the Redis server to test connectivity.
     |
     |      Sends a PING command to the Redis server and returns True if the server
     |      responds with "PONG".
     |
     |      This command is useful for:
     |      - Testing whether a connection is still alive
     |      - Verifying the server's ability to serve data
     |
     |      For more information on the underlying ping command see https://redis.io/commands/ping
     |
     |  psync(self, replicationid: 'str', offset: 'int') -> 'bytes | Awaitable[bytes]'
     |      Initiates a replication stream from the master.
     |      Newer version for `sync`.
     |
     |      For more information, see https://redis.io/commands/sync
     |
     |  quit(self, **kwargs) -> 'bool | Awaitable[bool]'
     |      Ask the server to close the connection.
     |
     |      For more information, see https://redis.io/commands/quit
     |
     |  replicaof(self, *args, **kwargs) -> 'bytes | str | Awaitable[bytes | str]'
     |      Update the replication settings of a redis replica, on the fly.
     |
     |      Examples of valid arguments include:
     |
     |      NO ONE (set no replication)
     |      host port (set to the host and port of a redis server)
     |
     |      For more information, see  https://redis.io/commands/replicaof
     |
     |  role(self) -> 'list[Any] | Awaitable[list[Any]]'
     |      Provide information on the role of a Redis instance in
     |      the context of replication, by returning if the instance
     |      is currently a master, slave, or sentinel.
     |
     |      For more information, see https://redis.io/commands/role
     |
     |  save(self, **kwargs) -> 'bool | Awaitable[bool]'
     |      Tell the Redis server to save its data to disk,
     |      blocking until the save is complete
     |
     |      For more information, see https://redis.io/commands/save
     |
     |  select(self, index: 'int', **kwargs) -> 'bool | Awaitable[bool]'
     |      Select the Redis logical database at index.
     |
     |      See: https://redis.io/commands/select
     |
     |  shutdown(self, save: 'bool' = False, nosave: 'bool' = False, now: 'bool' = False, force: 'bool' = False, abort: 'bool' = False, **kwargs) -> 'None'
     |      Shutdown the Redis server.  If Redis has persistence configured,
     |      data will be flushed before shutdown.
     |      It is possible to specify modifiers to alter the behavior of the command:
     |      ``save`` will force a DB saving operation even if no save points are configured.
     |      ``nosave`` will prevent a DB saving operation even if one or more save points
     |      are configured.
     |      ``now`` skips waiting for lagging replicas, i.e. it bypasses the first step in
     |      the shutdown sequence.
     |      ``force`` ignores any errors that would normally prevent the server from exiting
     |      ``abort`` cancels an ongoing shutdown and cannot be combined with other flags.
     |
     |      For more information, see https://redis.io/commands/shutdown
     |
     |  slaveof(self, host: 'str | None' = None, port: 'int | None' = None, **kwargs) -> 'bool | Awaitable[bool]'
     |      Set the server to be a replicated slave of the instance identified
     |      by the ``host`` and ``port``. If called without arguments, the
     |      instance is promoted to a master instead.
     |
     |      For more information, see https://redis.io/commands/slaveof
     |
     |  slowlog_get(self, num: 'int | None' = None, **kwargs) -> 'list[dict[str, Any]] | Awaitable[list[dict[str, Any]]]'
     |      Get the entries from the slowlog. If ``num`` is specified, get the
     |      most recent ``num`` items.
     |
     |      For more information, see https://redis.io/commands/slowlog-get
     |
     |  slowlog_len(self, **kwargs) -> 'int | Awaitable[int]'
     |      Get the number of items in the slowlog
     |
     |      For more information, see https://redis.io/commands/slowlog-len
     |
     |  slowlog_reset(self, **kwargs) -> 'bool | Awaitable[bool]'
     |      Remove all items in the slowlog
     |
     |      For more information, see https://redis.io/commands/slowlog-reset
     |
     |  swapdb(self, first: 'int', second: 'int', **kwargs) -> 'bool | Awaitable[bool]'
     |      Swap two databases
     |
     |      For more information, see https://redis.io/commands/swapdb
     |
     |  sync(self) -> 'bytes | Awaitable[bytes]'
     |      Initiates a replication stream from the master.
     |
     |      For more information, see https://redis.io/commands/sync
     |
     |  time(self, **kwargs) -> 'tuple[int, int] | Awaitable[tuple[int, int]]'
     |      Returns the server time as a 2-item tuple of ints:
     |      (seconds since epoch, microseconds into this second).
     |
     |      For more information, see https://redis.io/commands/time
     |
     |  wait(self, num_replicas: 'int', timeout: 'int', **kwargs) -> 'int | Awaitable[int]'
     |      Redis synchronous replication
     |      That returns the number of replicas that processed the query when
     |      we finally have at least ``num_replicas``, or when the ``timeout`` was
     |      reached.
     |
     |      For more information, see https://redis.io/commands/wait
     |
     |  waitaof(self, num_local: 'int', num_replicas: 'int', timeout: 'int', **kwargs) -> 'list[int] | Awaitable[list[int]]'
     |      This command blocks the current client until all previous write
     |      commands by that client are acknowledged as having been fsynced
     |      to the AOF of the local Redis and/or at least the specified number
     |      of replicas.
     |
     |      For more information, see https://redis.io/commands/waitaof
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from redis.commands.core.ModuleCommands:
     |
     |  command_getkeys(self, *args) -> 'list[bytes | str] | Awaitable[list[bytes | str]]'
     |
     |  module_list(self) -> 'list[dict[Any, Any]] | Awaitable[list[dict[Any, Any]]]'
     |      Returns a list of dictionaries containing the name and version of
     |      all loaded modules.
     |
     |      For more information, see https://redis.io/commands/module-list
     |
     |  module_load(self, path, *args) -> 'bool | Awaitable[bool]'
     |      Loads the module from ``path``.
     |      Passes all ``*args`` to the module, during loading.
     |      Raises ``ModuleError`` if a module is not found at ``path``.
     |
     |      For more information, see https://redis.io/commands/module-load
     |
     |  module_loadex(self, path: 'str', options: 'List[str] | None' = None, args: 'List[str] | None' = None) -> 'bytes | str | Awaitable[bytes | str]'
     |      Loads a module from a dynamic library at runtime with configuration directives.
     |
     |      For more information, see https://redis.io/commands/module-loadex
     |
     |  module_unload(self, name) -> 'bool | Awaitable[bool]'
     |      Unloads the module ``name``.
     |      Raises ``ModuleError`` if ``name`` is not in loaded modules.
     |
     |      For more information, see https://redis.io/commands/module-unload
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from redis.commands.core.PubSubCommands:
     |
     |  publish(self, channel: 'ChannelT', message: 'EncodableT', **kwargs) -> 'int | Awaitable[int]'
     |      Publish ``message`` on ``channel``.
     |      Returns the number of subscribers the message was delivered to.
     |
     |      For more information, see https://redis.io/commands/publish
     |
     |  pubsub_channels(self, pattern: 'PatternT' = '*', **kwargs) -> 'list[bytes | str] | Awaitable[list[bytes | str]]'
     |      Return a list of channels that have at least one subscriber
     |
     |      For more information, see https://redis.io/commands/pubsub-channels
     |
     |  pubsub_numpat(self, **kwargs) -> 'int | Awaitable[int]'
     |      Returns the number of subscriptions to patterns
     |
     |      For more information, see https://redis.io/commands/pubsub-numpat
     |
     |  pubsub_numsub(self, *args: 'ChannelT', **kwargs) -> 'list[tuple[bytes | str, int]] | Awaitable[list[tuple[bytes | str, int]]]'
     |      Return a list of (channel, number of subscribers) tuples
     |      for each channel given in ``*args``
     |
     |      For more information, see https://redis.io/commands/pubsub-numsub
     |
     |  pubsub_shardchannels(self, pattern: 'PatternT' = '*', **kwargs) -> 'list[bytes | str] | Awaitable[list[bytes | str]]'
     |      Return a list of shard_channels that have at least one subscriber
     |
     |      For more information, see https://redis.io/commands/pubsub-shardchannels
     |
     |  pubsub_shardnumsub(self, *args: 'ChannelT', **kwargs) -> 'list[tuple[bytes | str, int]] | Awaitable[list[tuple[bytes | str, int]]]'
     |      Return a list of (shard_channel, number of subscribers) tuples
     |      for each channel given in ``*args``
     |
     |      For more information, see https://redis.io/commands/pubsub-shardnumsub
     |
     |  spublish(self, shard_channel: 'ChannelT', message: 'EncodableT') -> 'int | Awaitable[int]'
     |      Posts a message to the given shard channel.
     |      Returns the number of clients that received the message
     |
     |      For more information, see https://redis.io/commands/spublish
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from redis.commands.core.ScriptCommands:
     |
     |  eval(self, script: 'str', numkeys: 'int', *keys_and_args: 'KeyT | EncodableT') -> 'Any | Awaitable[Any]'
     |      Execute the Lua ``script``, specifying the ``numkeys`` the script
     |      will touch and the key names and argument values in ``keys_and_args``.
     |      Returns the result of the script.
     |
     |      In practice, use the object returned by ``register_script``. This
     |      function exists purely for Redis API completion.
     |
     |      For more information, see  https://redis.io/commands/eval
     |
     |  eval_ro(self, script: 'str', numkeys: 'int', *keys_and_args: 'KeyT | EncodableT') -> 'Any | Awaitable[Any]'
     |      The read-only variant of the EVAL command
     |
     |      Execute the read-only Lua ``script`` specifying the ``numkeys`` the script
     |      will touch and the key names and argument values in ``keys_and_args``.
     |      Returns the result of the script.
     |
     |      For more information, see  https://redis.io/commands/eval_ro
     |
     |  evalsha(self, sha: 'str', numkeys: 'int', *keys_and_args: 'KeyT | EncodableT') -> 'Any | Awaitable[Any]'
     |      Use the ``sha`` to execute a Lua script already registered via EVAL
     |      or SCRIPT LOAD. Specify the ``numkeys`` the script will touch and the
     |      key names and argument values in ``keys_and_args``. Returns the result
     |      of the script.
     |
     |      In practice, use the object returned by ``register_script``. This
     |      function exists purely for Redis API completion.
     |
     |      For more information, see  https://redis.io/commands/evalsha
     |
     |  evalsha_ro(self, sha: 'str', numkeys: 'int', *keys_and_args: 'KeyT | EncodableT') -> 'Any | Awaitable[Any]'
     |      The read-only variant of the EVALSHA command
     |
     |      Use the ``sha`` to execute a read-only Lua script already registered via EVAL
     |      or SCRIPT LOAD. Specify the ``numkeys`` the script will touch and the
     |      key names and argument values in ``keys_and_args``. Returns the result
     |      of the script.
     |
     |      For more information, see  https://redis.io/commands/evalsha_ro
     |
     |  register_script(self: "Union['redis.client.Redis', 'redis.cluster.RedisCluster']", script: 'ScriptTextT') -> 'Script'
     |      Register a Lua ``script`` specifying the ``keys`` it will touch.
     |      Returns a Script object that is callable and hides the complexity of
     |      deal with scripts, keys, and shas. This is the preferred way to work
     |      with Lua scripts.
     |
     |  script_debug(self, *args) -> 'None'
     |
     |  script_exists(self, *args: 'str') -> 'list[bool] | Awaitable[list[bool]]'
     |      Check if a script exists in the script cache by specifying the SHAs of
     |      each script as ``args``. Returns a list of boolean values indicating if
     |      if each already script exists in the cache_data.
     |
     |      For more information, see  https://redis.io/commands/script-exists
     |
     |  script_flush(self, sync_type: "Literal['SYNC'] | Literal['ASYNC'] | None" = None) -> 'bool | Awaitable[bool]'
     |      Flush all scripts from the script cache_data.
     |
     |      ``sync_type`` is by default SYNC (synchronous) but it can also be
     |                    ASYNC.
     |
     |      For more information, see  https://redis.io/commands/script-flush
     |
     |  script_kill(self) -> 'bool | Awaitable[bool]'
     |      Kill the currently executing Lua script
     |
     |      For more information, see https://redis.io/commands/script-kill
     |
     |  script_load(self, script: 'ScriptTextT') -> 'str | Awaitable[str]'
     |      Load a Lua ``script`` into the script cache_data. Returns the SHA.
     |
     |      For more information, see https://redis.io/commands/script-load
     |
     |  ----------------------------------------------------------------------
     |  Data and other attributes inherited from redis.typing.CommandsProtocol:
     |
     |  __protocol_attrs__ = {'_event_dispatcher', 'execute_command'}
     |
     |  ----------------------------------------------------------------------
     |  Class methods inherited from typing.Protocol:
     |
     |  __init_subclass__(*args, **kwargs)
     |      This method is called when a class is subclassed.
     |
     |      The default implementation does nothing. It may be
     |      overridden to extend subclasses.
     |
     |  ----------------------------------------------------------------------
     |  Class methods inherited from typing.Generic:
     |
     |  __class_getitem__(...)
     |      Parameterizes a generic class.
     |
     |      At least, parameterizing a generic class is the *main* thing this
     |      method does. For example, for some generic class `Foo`, this is called
     |      when we do `Foo[int]` - there, with `cls=Foo` and `params=int`.
     |
     |      However, note that this method is also called when defining generic
     |      classes in the first place with `class Foo[T]: ...`.
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from redis.commands.core.FunctionCommands:
     |
     |  fcall(self, function, numkeys: 'int', *keys_and_args: 'Any') -> 'Any | Awaitable[Any]'
     |      Invoke a function.
     |
     |      For more information, see https://redis.io/commands/fcall
     |
     |  fcall_ro(self, function, numkeys: 'int', *keys_and_args: 'Any') -> 'Any | Awaitable[Any]'
     |      This is a read-only variant of the FCALL command that cannot
     |      execute commands that modify data.
     |
     |      For more information, see https://redis.io/commands/fcall_ro
     |
     |  function_delete(self, library: 'str') -> 'bool | Awaitable[bool]'
     |      Delete the library called ``library`` and all its functions.
     |
     |      For more information, see https://redis.io/commands/function-delete
     |
     |  function_dump(self) -> 'bytes | Awaitable[bytes]'
     |      Return the serialized payload of loaded libraries.
     |
     |      For more information, see https://redis.io/commands/function-dump
     |
     |  function_flush(self, mode: 'str' = 'SYNC') -> 'bool | Awaitable[bool]'
     |      Deletes all the libraries.
     |
     |      For more information, see https://redis.io/commands/function-flush
     |
     |  function_kill(self) -> 'bytes | str | Awaitable[bytes | str]'
     |      Kill a function that is currently executing.
     |
     |      For more information, see https://redis.io/commands/function-kill
     |
     |  function_list(self, library: 'str | None' = '*', withcode: 'bool | None' = False) -> 'list[Any] | Awaitable[list[Any]]'
     |      Return information about the functions and libraries.
     |
     |      Args:
     |
     |          library: specify a pattern for matching library names
     |          withcode: cause the server to include the libraries source implementation
     |              in the reply
     |
     |  function_load(self, code: 'str', replace: 'bool | None' = False) -> 'bytes | str | Awaitable[bytes | str]'
     |      Load a library to Redis.
     |      :param code: the source code (must start with
     |      Shebang statement that provides a metadata about the library)
     |      :param replace: changes the behavior to overwrite the existing library
     |      with the new contents.
     |      Return the library name that was loaded.
     |
     |      For more information, see https://redis.io/commands/function-load
     |
     |  function_restore(self, payload: 'str', policy: 'str | None' = 'APPEND') -> 'bool | Awaitable[bool]'
     |      Restore libraries from the serialized ``payload``.
     |      You can use the optional policy argument to provide a policy
     |      for handling existing libraries.
     |
     |      For more information, see https://redis.io/commands/function-restore
     |
     |  function_stats(self) -> 'Any | Awaitable[Any]'
     |      Return information about the function that's currently running
     |      and information about the available execution engines.
     |
     |      For more information, see https://redis.io/commands/function-stats
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from redis.commands.sentinel.SentinelCommands:
     |
     |  sentinel(self, *args)
     |      Redis Sentinel's SENTINEL command.
     |
     |  sentinel_ckquorum(self, new_master_name) -> Union[bool, Awaitable[bool]]
     |      Check if the current Sentinel configuration is able to reach the
     |      quorum needed to failover a master, and the majority needed to
     |      authorize the failover.
     |
     |      This command should be used in monitoring systems to check if a
     |      Sentinel deployment is ok.
     |
     |  sentinel_failover(self, new_master_name) -> Union[bool, Awaitable[bool]]
     |      Force a failover as if the master was not reachable, and without
     |      asking for agreement to other Sentinels (however a new version of the
     |      configuration will be published so that the other Sentinels will
     |      update their configurations).
     |
     |  sentinel_flushconfig(self) -> Union[bool, Awaitable[bool]]
     |      Force Sentinel to rewrite its configuration on disk, including the
     |      current Sentinel state.
     |
     |      Normally Sentinel rewrites the configuration every time something
     |      changes in its state (in the context of the subset of the state which
     |      is persisted on disk across restart).
     |      However sometimes it is possible that the configuration file is lost
     |      because of operation errors, disk failures, package upgrade scripts or
     |      configuration managers. In those cases a way to to force Sentinel to
     |      rewrite the configuration file is handy.
     |
     |      This command works even if the previous configuration file is
     |      completely missing.
     |
     |  sentinel_get_master_addr_by_name(self, service_name, return_responses: bool = False) -> Union[tuple[bytes | str, int], NoneType, bool, Awaitable[tuple[bytes | str, int] | None | bool]]
     |      Returns a (host, port) pair for the given ``service_name`` when return_responses is True,
     |      otherwise returns a boolean value that indicates if the command was successful.
     |
     |  sentinel_master(self, service_name, return_responses: bool = False) -> Union[dict[str, Any], bool, Awaitable[dict[str, Any] | bool]]
     |      Returns a dictionary containing the specified masters state, when return_responses is True,
     |      otherwise returns a boolean value that indicates if the command was successful.
     |
     |  sentinel_masters(self) -> Union[dict[str, dict[str, Any]], list[dict[str, Any]], Awaitable[dict[str, dict[str, Any]] | list[dict[str, Any]]]]
     |      Returns a list of dictionaries containing each master's state.
     |
     |      Important: This function is called by the Sentinel implementation and is
     |      called directly on the Redis standalone client for sentinels,
     |      so it doesn't support the "once" and "return_responses" options.
     |
     |  sentinel_monitor(self, name, ip, port, quorum) -> Union[bool, Awaitable[bool]]
     |      Add a new master to Sentinel to be monitored
     |
     |  sentinel_remove(self, name) -> Union[bool, Awaitable[bool]]
     |      Remove a master from Sentinel's monitoring
     |
     |  sentinel_reset(self, pattern) -> Union[bool, Awaitable[bool]]
     |      This command will reset all the masters with matching name.
     |      The pattern argument is a glob-style pattern.
     |
     |      The reset process clears any previous state in a master (including a
     |      failover in progress), and removes every slave and sentinel already
     |      discovered and associated with the master.
     |
     |  sentinel_sentinels(self, service_name, return_responses: bool = False) -> Union[list[dict[str, Any]], bool, Awaitable[list[dict[str, Any]] | bool]]
     |      Returns a list of sentinels for ``service_name``, when return_responses is True,
     |      otherwise returns a boolean value that indicates if the command was successful.
     |
     |  sentinel_set(self, name, option, value) -> Union[bool, Awaitable[bool]]
     |      Set Sentinel monitoring parameters for a given master
     |
     |  sentinel_slaves(self, service_name) -> Union[list[dict[str, Any]], Awaitable[list[dict[str, Any]]]]
     |      Returns a list of slaves for ``service_name``
     |
     |      Important: This function is called by the Sentinel implementation and is
     |      called directly on the Redis standalone client for sentinels,
     |      so it doesn't support the "once" and "return_responses" options.

    class PubSub(builtins.object)
     |  PubSub(connection_pool, shard_hint=None, ignore_subscribe_messages: bool = False, encoder: Optional[ForwardRef('Encoder')] = None, push_handler_func: Optional[Callable[[str], NoneType]] = None, event_dispatcher: Optional[ForwardRef('EventDispatcher')] = None)
     |
     |  PubSub provides publish, subscribe and listen support to Redis channels.
     |
     |  After subscribing to one or more channels, the listen() method will block
     |  until a message arrives on one of the subscribed channels. That message
     |  will be returned and it's safe to start listening again.
     |
     |  Methods defined here:
     |
     |  __del__(self) -> None
     |
     |  __enter__(self) -> 'PubSub'
     |
     |  __exit__(self, exc_type, exc_value, traceback) -> None
     |
     |  __init__(self, connection_pool, shard_hint=None, ignore_subscribe_messages: bool = False, encoder: Optional[ForwardRef('Encoder')] = None, push_handler_func: Optional[Callable[[str], NoneType]] = None, event_dispatcher: Optional[ForwardRef('EventDispatcher')] = None)
     |      Initialize self.  See help(type(self)) for accurate signature.
     |
     |  check_health(self) -> None
     |
     |  clean_health_check_responses(self) -> None
     |      If any health check responses are present, clean them
     |
     |  close(self) -> None
     |
     |  execute_command(self, *args)
     |      Execute a publish/subscribe command
     |
     |  get_message(self, ignore_subscribe_messages: bool = False, timeout: float = 0.0)
     |      Get the next message if one is available, otherwise None.
     |
     |      If timeout is specified, the system will wait for `timeout` seconds
     |      before returning. Timeout should be specified as a floating point
     |      number, or None, to wait indefinitely.
     |
     |  get_sharded_message = get_message(self, ignore_subscribe_messages: bool = False, timeout: float = 0.0)
     |
     |  handle_message(self, response, ignore_subscribe_messages=False)
     |      Parses a pub/sub message. If the channel or pattern was subscribed to
     |      with a message handler, the handler is invoked instead of a parsed
     |      message being returned.
     |
     |  is_health_check_response(self, response) -> bool
     |      Check if the response is a health check response.
     |      If there are no subscriptions redis responds to PING command with a
     |      bulk response, instead of a multi-bulk with "pong" and the response.
     |
     |  listen(self)
     |      Listen for messages on channels this client has been subscribed to
     |
     |  on_connect(self, connection) -> None
     |      Re-subscribe to any channels and patterns previously subscribed to
     |
     |  parse_response(self, block=True, timeout=0)
     |      Parse the response from a publish/subscribe command.
     |
     |      Args:
     |          block: If True, block indefinitely until a message is available.
     |                 If False, return immediately if no message is available.
     |                 Default: True
     |          timeout: The timeout in seconds for reading a response when block=False.
     |                   This parameter is ignored when block=True.
     |                   Default: 0 (return immediately if no data available)
     |
     |      Returns:
     |          The parsed response from the server, or None if no message is available
     |          within the timeout period (when block=False).
     |
     |      Important:
     |          The block and timeout parameters work together:
     |          - When block=True: timeout is IGNORED, method blocks indefinitely
     |          - When block=False: timeout is USED, method returns after timeout expires
     |
     |          Typically, you should use get_message(timeout=X) instead of calling
     |          parse_response() directly. The get_message() method automatically sets
     |          block=False when a timeout is provided, and block=True when timeout=None.
     |
     |      Example:
     |          # Block indefinitely (timeout is ignored)
     |          response = pubsub.parse_response(block=True, timeout=0.1)
     |
     |          # Non-blocking with 0.1 second timeout
     |          response = pubsub.parse_response(block=False, timeout=0.1)
     |
     |          # Non-blocking, return immediately
     |          response = pubsub.parse_response(block=False, timeout=0)
     |
     |          # Recommended: use get_message() instead
     |          msg = pubsub.get_message(timeout=0.1)  # automatically sets block=False
     |          msg = pubsub.get_message(timeout=None)  # automatically sets block=True
     |
     |  ping(self, message: Optional[str] = None) -> bool
     |      Ping the Redis server to test connectivity.
     |
     |      Sends a PING command to the Redis server and returns True if the server
     |      responds with "PONG".
     |
     |  psubscribe(self, *args: Union[bytes, str, memoryview, redis.typing.Subscription], **kwargs: Callable[[dict[str, Any]], Any]) -> None
     |      Subscribe to channel patterns.
     |      Patterns supplied as keyword arguments expect a pattern name as the
     |      key and a callable as the value.
     |      ``Subscription`` objects can also be supplied positionally with an
     |      optional handler.
     |      A pattern's callable will be invoked automatically
     |      when a message is received on that pattern rather than producing a
     |      message via ``listen()``.
     |
     |  punsubscribe(self, *args)
     |      Unsubscribe from the supplied patterns. If empty, unsubscribe from
     |      all patterns.
     |
     |  reset(self) -> None
     |
     |  run_in_thread(self, sleep_time: float = 0.0, daemon: bool = False, exception_handler: Optional[Callable] = None, pubsub=None, sharded_pubsub: bool = False) -> 'PubSubWorkerThread'
     |
     |  ssubscribe(self, *args: Union[bytes, str, memoryview, redis.typing.Subscription], target_node: Any = None, **kwargs: Callable[[dict[str, Any]], Any]) -> None
     |      Subscribes the client to the specified shard channels.
     |      Channels supplied as keyword arguments expect a channel name as the key
     |      and a callable as the value.
     |      ``Subscription`` objects can also be supplied positionally
     |      with an optional handler.
     |      A channel's callable will be invoked automatically when a message
     |      is received on that channel rather than producing a message
     |      via ``listen()`` or ``get_sharded_message()``.
     |
     |  subscribe(self, *args: Union[bytes, str, memoryview, redis.typing.Subscription], **kwargs: Callable[[dict[str, Any]], Any]) -> None
     |      Subscribe to channels.
     |      Channels supplied as keyword arguments expect
     |      a channel name as the key and a callable as the value.
     |      ``Subscription`` objects can also be supplied positionally with an
     |      optional handler.
     |      A channel's callable will be invoked automatically
     |      when a message is received on that channel rather than producing a
     |      message via ``listen()`` or ``get_message()``.
     |
     |  sunsubscribe(self, *args, target_node=None)
     |      Unsubscribe from the supplied shard_channels. If empty, unsubscribe from
     |      all shard_channels
     |
     |  unsubscribe(self, *args)
     |      Unsubscribe from the supplied channels. If empty, unsubscribe from
     |      all channels
     |
     |  ----------------------------------------------------------------------
     |  Readonly properties defined here:
     |
     |  subscribed
     |      Indicates if there are subscriptions to any channels or patterns
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors defined here:
     |
     |  __dict__
     |      dictionary for instance variables
     |
     |  __weakref__
     |      list of weak references to the object
     |
     |  ----------------------------------------------------------------------
     |  Data and other attributes defined here:
     |
     |  HEALTH_CHECK_MESSAGE = 'redis-py-health-check'
     |
     |  PUBLISH_MESSAGE_TYPES = ('message', 'pmessage', 'smessage')
     |
     |  UNSUBSCRIBE_MESSAGE_TYPES = ('unsubscribe', 'punsubscribe', 'sunsubscr...

    class PubSubWorkerThread(threading.Thread)
     |  PubSubWorkerThread(pubsub, sleep_time: float, daemon: bool = False, exception_handler: Optional[Callable[[Exception, ForwardRef('PubSub'), ForwardRef('PubSubWorkerThread')], NoneType]] = None, sharded_pubsub: bool = False)
     |
     |  Method resolution order:
     |      PubSubWorkerThread
     |      threading.Thread
     |      builtins.object
     |
     |  Methods defined here:
     |
     |  __init__(self, pubsub, sleep_time: float, daemon: bool = False, exception_handler: Optional[Callable[[Exception, ForwardRef('PubSub'), ForwardRef('PubSubWorkerThread')], NoneType]] = None, sharded_pubsub: bool = False)
     |      This constructor should always be called with keyword arguments. Arguments are:
     |
     |      *group* should be None; reserved for future extension when a ThreadGroup
     |      class is implemented.
     |
     |      *target* is the callable object to be invoked by the run()
     |      method. Defaults to None, meaning nothing is called.
     |
     |      *name* is the thread name. By default, a unique name is constructed of
     |      the form "Thread-N" where N is a small decimal number.
     |
     |      *args* is a list or tuple of arguments for the target invocation. Defaults to ().
     |
     |      *kwargs* is a dictionary of keyword arguments for the target
     |      invocation. Defaults to {}.
     |
     |      If a subclass overrides the constructor, it must make sure to invoke
     |      the base class constructor (Thread.__init__()) before doing anything
     |      else to the thread.
     |
     |  run(self) -> None
     |      Method representing the thread's activity.
     |
     |      You may override this method in a subclass. The standard run() method
     |      invokes the callable object passed to the object's constructor as the
     |      target argument, if any, with sequential and keyword arguments taken
     |      from the args and kwargs arguments, respectively.
     |
     |  stop(self) -> None
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from threading.Thread:
     |
     |  __repr__(self)
     |      Return repr(self).
     |
     |  getName(self)
     |      Return a string used for identification purposes only.
     |
     |      This method is deprecated, use the name attribute instead.
     |
     |  isDaemon(self)
     |      Return whether this thread is a daemon.
     |
     |      This method is deprecated, use the daemon attribute instead.
     |
     |  is_alive(self)
     |      Return whether the thread is alive.
     |
     |      This method returns True just before the run() method starts until just
     |      after the run() method terminates. See also the module function
     |      enumerate().
     |
     |  join(self, timeout=None)
     |      Wait until the thread terminates.
     |
     |      This blocks the calling thread until the thread whose join() method is
     |      called terminates -- either normally or through an unhandled exception
     |      or until the optional timeout occurs.
     |
     |      When the timeout argument is present and not None, it should be a
     |      floating-point number specifying a timeout for the operation in seconds
     |      (or fractions thereof). As join() always returns None, you must call
     |      is_alive() after join() to decide whether a timeout happened -- if the
     |      thread is still alive, the join() call timed out.
     |
     |      When the timeout argument is not present or None, the operation will
     |      block until the thread terminates.
     |
     |      A thread can be join()ed many times.
     |
     |      join() raises a RuntimeError if an attempt is made to join the current
     |      thread as that would cause a deadlock. It is also an error to join() a
     |      thread before it has been started and attempts to do so raises the same
     |      exception.
     |
     |  setDaemon(self, daemonic)
     |      Set whether this thread is a daemon.
     |
     |      This method is deprecated, use the .daemon property instead.
     |
     |  setName(self, name)
     |      Set the name string for this thread.
     |
     |      This method is deprecated, use the name attribute instead.
     |
     |  start(self)
     |      Start the thread's activity.
     |
     |      It must be called at most once per thread object. It arranges for the
     |      object's run() method to be invoked in a separate thread of control.
     |
     |      This method will raise a RuntimeError if called more than once on the
     |      same thread object.
     |
     |  ----------------------------------------------------------------------
     |  Readonly properties inherited from threading.Thread:
     |
     |  ident
     |      Thread identifier of this thread or None if it has not been started.
     |
     |      This is a nonzero integer. See the get_ident() function. Thread
     |      identifiers may be recycled when a thread exits and another thread is
     |      created. The identifier is available even after the thread has exited.
     |
     |  native_id
     |      Native integral thread ID of this thread, or None if it has not been started.
     |
     |      This is a non-negative integer. See the get_native_id() function.
     |      This represents the Thread ID as reported by the kernel.
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors inherited from threading.Thread:
     |
     |  __dict__
     |      dictionary for instance variables
     |
     |  __weakref__
     |      list of weak references to the object
     |
     |  daemon
     |      A boolean value indicating whether this thread is a daemon thread.
     |
     |      This must be set before start() is called, otherwise RuntimeError is
     |      raised. Its initial value is inherited from the creating thread; the
     |      main thread is not a daemon thread and therefore all threads created in
     |      the main thread default to daemon = False.
     |
     |      The entire Python program exits when only daemon threads are left.
     |
     |  name
     |      A string used for identification purposes only.
     |
     |      It has no semantics. Multiple threads may be given the same name. The
     |      initial name is set by the constructor.

    class Redis(redis.commands.redismodules.RedisModuleCommands, redis.commands.core.CoreCommands, redis.commands.sentinel.SentinelCommands)
     |  Redis(host: str = 'localhost', port: int = 6379, db: int = 0, password: str | None = None, socket_timeout: float | None = 5, socket_connect_timeout: float | None = 5, socket_read_size: int = 32768, socket_keepalive: bool | None = True, socket_keepalive_options: Union[Mapping[int, int | bytes], object, NoneType] = <object object at 0x0000017B991493E0>, connection_pool: redis.connection.ConnectionPool | None = None, unix_socket_path: str | None = None, encoding: str = 'utf-8', encoding_errors: str = 'strict', decode_responses: bool = False, retry_on_timeout: bool = False, retry: redis.retry.Retry = <redis.retry.Retry object at 0x0000017B9C6BD640>, retry_on_error: Optional[List[Type[Exception]]] = None, ssl: bool = False, ssl_keyfile: str | None = None, ssl_certfile: str | None = None, ssl_cert_reqs: 'str | ssl.VerifyMode' = 'required', ssl_include_verify_flags: Optional[List[ForwardRef('ssl.VerifyFlags')]] = None, ssl_exclude_verify_flags: Optional[List[ForwardRef('ssl.VerifyFlags')]] = None, ssl_ca_certs: str | None = None, ssl_ca_path: str | None = None, ssl_ca_data: str | None = None, ssl_check_hostname: bool = True, ssl_password: str | None = None, ssl_validate_ocsp: bool = False, ssl_validate_ocsp_stapled: bool = False, ssl_ocsp_context: 'OpenSSL.SSL.Context | None' = None, ssl_ocsp_expected_cert: str | None = None, ssl_min_version: 'ssl.TLSVersion | None' = None, ssl_ciphers: str | None = None, max_connections: int | None = None, single_connection_client: bool = False, health_check_interval: int = 0, client_name: str | None = None, lib_name: str | object | None = <object object at 0x0000017B991493E0>, lib_version: str | object | None = <object object at 0x0000017B991493E0>, driver_info: redis.driver_info.DriverInfo | object | None = <object object at 0x0000017B991493E0>, username: str | None = None, redis_connect_func: Optional[Callable[[], NoneType]] = None, credential_provider: redis.credentials.CredentialProvider | None = None, protocol: int | None = None, legacy_responses: bool = True, cache: redis.cache.CacheInterface | None = None, cache_config: redis.cache.CacheConfig | None = None, event_dispatcher: redis.event.EventDispatcher | None = None, maint_notifications_config: redis.maint_notifications.MaintNotificationsConfig | None = None, oss_cluster_maint_notifications_handler: redis.maint_notifications.OSSMaintNotificationsHandler | None = None) -> None
     |
     |  Implementation of the Redis protocol.
     |
     |  This abstract class provides a Python interface to all Redis commands
     |  and an implementation of the Redis protocol.
     |
     |  Pipelines derive from this, implementing how
     |  the commands are sent and received to the Redis server. Based on
     |  configuration, an instance will either use a ConnectionPool, or
     |  Connection object to talk to redis.
     |
     |  It is not safe to pass PubSub or Pipeline objects between threads.
     |
     |  Method resolution order:
     |      Redis
     |      redis.commands.redismodules.RedisModuleCommands
     |      redis.commands.core.CoreCommands
     |      redis.commands.core.ACLCommands
     |      redis.commands.core.ClusterCommands
     |      redis.commands.core.DataAccessCommands
     |      redis.commands.core.BasicKeyCommands
     |      redis.commands.core.HyperlogCommands
     |      redis.commands.core.HashCommands
     |      redis.commands.core.GeoCommands
     |      redis.commands.core.ListCommands
     |      redis.commands.core.ArrayCommands
     |      redis.commands.core.ScanCommands
     |      redis.commands.core.SetCommands
     |      redis.commands.core.StreamCommands
     |      redis.commands.core.SortedSetCommands
     |      redis.commands.core.ManagementCommands
     |      redis.commands.core.ModuleCommands
     |      redis.commands.core.PubSubCommands
     |      redis.commands.core.ScriptCommands
     |      redis.typing.CommandsProtocol
     |      typing.Protocol
     |      typing.Generic
     |      redis.commands.core.FunctionCommands
     |      redis.commands.sentinel.SentinelCommands
     |      builtins.object
     |
     |  Methods defined here:
     |
     |  __del__(self)
     |
     |  __enter__(self)
     |
     |  __exit__(self, exc_type, exc_value, traceback)
     |
     |  __init__(self, host: str = 'localhost', port: int = 6379, db: int = 0, password: str | None = None, socket_timeout: float | None = 5, socket_connect_timeout: float | None = 5, socket_read_size: int = 32768, socket_keepalive: bool | None = True, socket_keepalive_options: Union[Mapping[int, int | bytes], object, NoneType] = <object object at 0x0000017B991493E0>, connection_pool: redis.connection.ConnectionPool | None = None, unix_socket_path: str | None = None, encoding: str = 'utf-8', encoding_errors: str = 'strict', decode_responses: bool = False, retry_on_timeout: bool = False, retry: redis.retry.Retry = <redis.retry.Retry object at 0x0000017B9C6BD640>, retry_on_error: Optional[List[Type[Exception]]] = None, ssl: bool = False, ssl_keyfile: str | None = None, ssl_certfile: str | None = None, ssl_cert_reqs: 'str | ssl.VerifyMode' = 'required', ssl_include_verify_flags: Optional[List[ForwardRef('ssl.VerifyFlags')]] = None, ssl_exclude_verify_flags: Optional[List[ForwardRef('ssl.VerifyFlags')]] = None, ssl_ca_certs: str | None = None, ssl_ca_path: str | None = None, ssl_ca_data: str | None = None, ssl_check_hostname: bool = True, ssl_password: str | None = None, ssl_validate_ocsp: bool = False, ssl_validate_ocsp_stapled: bool = False, ssl_ocsp_context: 'OpenSSL.SSL.Context | None' = None, ssl_ocsp_expected_cert: str | None = None, ssl_min_version: 'ssl.TLSVersion | None' = None, ssl_ciphers: str | None = None, max_connections: int | None = None, single_connection_client: bool = False, health_check_interval: int = 0, client_name: str | None = None, lib_name: str | object | None = <object object at 0x0000017B991493E0>, lib_version: str | object | None = <object object at 0x0000017B991493E0>, driver_info: redis.driver_info.DriverInfo | object | None = <object object at 0x0000017B991493E0>, username: str | None = None, redis_connect_func: Optional[Callable[[], NoneType]] = None, credential_provider: redis.credentials.CredentialProvider | None = None, protocol: int | None = None, legacy_responses: bool = True, cache: redis.cache.CacheInterface | None = None, cache_config: redis.cache.CacheConfig | None = None, event_dispatcher: redis.event.EventDispatcher | None = None, maint_notifications_config: redis.maint_notifications.MaintNotificationsConfig | None = None, oss_cluster_maint_notifications_handler: redis.maint_notifications.OSSMaintNotificationsHandler | None = None) -> None
     |      Initialize a new Redis client.
     |
     |      To specify a retry policy for specific errors, you have two options:
     |
     |      1. Set the `retry_on_error` to a list of the error/s to retry on, and
     |      you can also set `retry` to a valid `Retry` object(in case the default
     |      one is not appropriate) - with this approach the retries will be triggered
     |      on the default errors specified in the Retry object enriched with the
     |      errors specified in `retry_on_error`.
     |
     |      2. Define a `Retry` object with configured 'supported_errors' and set
     |      it to the `retry` parameter - with this approach you completely redefine
     |      the errors on which retries will happen.
     |
     |      `retry_on_timeout` is deprecated - please include the TimeoutError
     |      either in the Retry object or in the `retry_on_error` list.
     |
     |      When 'connection_pool' is provided - the retry configuration of the
     |      provided pool will be used.
     |
     |      Args:
     |
     |      socket_keepalive:
     |          if `True`, TCP keepalive is enabled for TCP socket connections.
     |          Argument is ignored when connection_pool is provided.
     |      socket_keepalive_options:
     |          mapping of TCP keepalive socket option constants to values, for
     |          example `{socket.TCP_KEEPIDLE: 30}`. If left unspecified, redis-py
     |          uses TCP keepalive defaults when `socket_keepalive` is enabled:
     |          idle 30 seconds, interval 5 seconds, and 3 probes. Platform-specific
     |          options that are not available are skipped. Pass `None` or `{}` to
     |          avoid setting additional TCP keepalive options. Argument is ignored
     |          when connection_pool is provided.
     |      single_connection_client:
     |          if `True`, connection pool is not used. In that case `Redis`
     |          instance use is not thread safe.
     |      decode_responses:
     |          if `True`, the response will be decoded to utf-8.
     |          Argument is ignored when connection_pool is provided.
     |      driver_info:
     |          Optional DriverInfo object to identify upstream libraries.
     |          If provided, lib_name and lib_version are ignored.
     |          If not provided, a DriverInfo will be created from lib_name and lib_version.
     |          Explicit None disables CLIENT SETINFO.
     |          Argument is ignored when connection_pool is provided.
     |      lib_name:
     |          **Deprecated.** Use driver_info instead. Library name for CLIENT SETINFO.
     |      lib_version:
     |          **Deprecated.** Use driver_info instead. Library version for CLIENT SETINFO.
     |      maint_notifications_config:
     |          configures the pool to support maintenance notifications - see
     |          `redis.maint_notifications.MaintNotificationsConfig` for details.
     |          Only supported with RESP3
     |          If not provided and protocol is RESP3, the maintenance notifications
     |          will be enabled by default (logic is included in the connection pool
     |          initialization).
     |          Argument is ignored when connection_pool is provided.
     |      oss_cluster_maint_notifications_handler:
     |          handler for OSS cluster notifications - see
     |          `redis.maint_notifications.OSSMaintNotificationsHandler` for details.
     |          Only supported with RESP3
     |          Argument is ignored when connection_pool is provided.
     |
     |  __repr__(self) -> str
     |      Return repr(self).
     |
     |  client(self)
     |
     |  close(self) -> None
     |
     |  execute_command(self, *args, **options)
     |      # COMMAND EXECUTION AND PROTOCOL PARSING
     |
     |  get_cache(self) -> Optional[redis.cache.CacheInterface]
     |
     |  get_connection_kwargs(self) -> Dict
     |      Get the connection's key-word arguments
     |
     |  get_encoder(self) -> 'Encoder'
     |      Get the connection pool's encoder
     |
     |  get_retry(self) -> Optional[redis.retry.Retry]
     |
     |  himport_discard(self, fieldset_name: str) -> int
     |      Remove a fieldset from the registry.
     |
     |      Returns ``1`` if it was registered, ``0`` otherwise. On a pooled client the
     |      server-side ``DISCARD`` is reconciled lazily when each connection is next
     |      used for ``himport_set``. On a single connection client it runs immediately
     |      on the pinned connection when it is live; while that connection is not
     |      connected there is nothing prepared on the server to discard (its tracking is
     |      reset on connect), so no server call is made.
     |
     |  himport_discard_all(self) -> int
     |      Remove all fieldsets from the registry.
     |
     |      Returns the number removed from the registry. Server-side removal follows the
     |      same live/lazy rule as :meth:`himport_discard`.
     |
     |  himport_prepare(self, fieldset_name: str, fields: Iterable[Union[bytes, bytearray, memoryview, str, int, float]]) -> bool
     |      Declare an HIMPORT fieldset for use by :meth:`himport_set`.
     |
     |      Registers ``fieldset_name`` (ordered ``fields``, verbatim) in the client's
     |      shared registry. On a pooled client the server-side ``PREPARE`` is deferred
     |      and bundled into the next ``himport_set`` per connection. On a single
     |      connection client it is run immediately when the pinned connection is live;
     |      while that connection is not connected there is no session state to prepare,
     |      so the next ``himport_set`` prepares it lazily instead.
     |
     |  keyspace_notifications(self, key_prefix: Union[str, bytes, NoneType] = None, ignore_subscribe_messages: bool = True) -> 'KeyspaceNotifications'
     |      Return a :class:`~redis.keyspace_notifications.KeyspaceNotifications`
     |      object for subscribing to keyspace and keyevent notifications.
     |
     |      Note: Keyspace notifications must be enabled on the Redis server via
     |      the ``notify-keyspace-events`` configuration option.
     |
     |      Args:
     |          key_prefix: Optional prefix to filter and strip from keys in
     |                      notifications.
     |          ignore_subscribe_messages: If True, subscribe/unsubscribe
     |                                    confirmations are not returned by
     |                                    get_message/listen.
     |
     |  load_external_module(self, funcname, func) -> None
     |      This function can be used to add externally defined redis modules,
     |      and their namespaces to the redis client.
     |
     |      funcname - A string containing the name of the function to create
     |      func - The function, being added to this class.
     |
     |      ex: Assume that one has a custom redis module named foomod that
     |      creates command named 'foo.dothing' and 'foo.anotherthing' in redis.
     |      To load function functions into this namespace:
     |
     |      from redis import Redis
     |      from foomodule import F
     |      r = Redis()
     |      r.load_external_module("foo", F)
     |      r.foo().dothing('your', 'arguments')
     |
     |      For a concrete example see the reimport of the redisjson module in
     |      tests/test_connection.py::test_loading_external_modules
     |
     |  lock(self, name: str, timeout: Optional[float] = None, sleep: float = 0.1, blocking: bool = True, blocking_timeout: Optional[float] = None, lock_class: Optional[Any] = None, thread_local: bool = True, raise_on_release_error: bool = True)
     |      Return a new Lock object using key ``name`` that mimics
     |      the behavior of threading.Lock.
     |
     |      If specified, ``timeout`` indicates a maximum life for the lock.
     |      By default, it will remain locked until release() is called.
     |
     |      ``sleep`` indicates the amount of time to sleep per loop iteration
     |      when the lock is in blocking mode and another client is currently
     |      holding the lock.
     |
     |      ``blocking`` indicates whether calling ``acquire`` should block until
     |      the lock has been acquired or to fail immediately, causing ``acquire``
     |      to return False and the lock not being acquired. Defaults to True.
     |      Note this value can be overridden by passing a ``blocking``
     |      argument to ``acquire``.
     |
     |      ``blocking_timeout`` indicates the maximum amount of time in seconds to
     |      spend trying to acquire the lock. A value of ``None`` indicates
     |      continue trying forever. ``blocking_timeout`` can be specified as a
     |      float or integer, both representing the number of seconds to wait.
     |
     |      ``lock_class`` forces the specified lock implementation. Note that as
     |      of redis-py 3.0, the only lock class we implement is ``Lock`` (which is
     |      a Lua-based lock). So, it's unlikely you'll need this parameter, unless
     |      you have created your own custom lock class.
     |
     |      ``thread_local`` indicates whether the lock token is placed in
     |      thread-local storage. By default, the token is placed in thread local
     |      storage so that a thread only sees its token, not a token set by
     |      another thread. Consider the following timeline:
     |
     |          time: 0, thread-1 acquires `my-lock`, with a timeout of 5 seconds.
     |                   thread-1 sets the token to "abc"
     |          time: 1, thread-2 blocks trying to acquire `my-lock` using the
     |                   Lock instance.
     |          time: 5, thread-1 has not yet completed. redis expires the lock
     |                   key.
     |          time: 5, thread-2 acquired `my-lock` now that it's available.
     |                   thread-2 sets the token to "xyz"
     |          time: 6, thread-1 finishes its work and calls release(). if the
     |                   token is *not* stored in thread local storage, then
     |                   thread-1 would see the token value as "xyz" and would be
     |                   able to successfully release the thread-2's lock.
     |
     |      ``raise_on_release_error`` indicates whether to raise an exception when
     |      the lock is no longer owned when exiting the context manager. By default,
     |      this is True, meaning an exception will be raised. If False, the warning
     |      will be logged and the exception will be suppressed.
     |
     |      In some use cases it's necessary to disable thread local storage. For
     |      example, if you have code where one thread acquires a lock and passes
     |      that lock instance to a worker thread to release later. If thread
     |      local storage isn't disabled in this case, the worker thread won't see
     |      the token set by the thread that acquired the lock. Our assumption
     |      is that these cases aren't common and as such default to using
     |      thread local storage.
     |
     |  monitor(self)
     |
     |  parse_response(self, connection, command_name, **options)
     |      Parses a response from the Redis server
     |
     |  pipeline(self, transaction=True, shard_hint=None) -> 'Pipeline'
     |      Return a new pipeline object that can queue multiple commands for
     |      later execution. ``transaction`` indicates whether all commands
     |      should be executed atomically. Apart from making a group of operations
     |      atomic, pipelines are useful for reducing the back-and-forth overhead
     |      between the client and server.
     |
     |  pubsub(self, **kwargs)
     |      Return a Publish/Subscribe object. With this object, you can
     |      subscribe to channels and listen for messages that get published to
     |      them.
     |
     |  set_response_callback(self, command: str, callback: Callable) -> None
     |      Set a custom Response Callback
     |
     |  set_retry(self, retry: redis.retry.Retry) -> None
     |
     |  transaction(self, func: Callable[[ForwardRef('Pipeline')], NoneType], *watches, **kwargs) -> Union[List[Any], Any, NoneType]
     |      Convenience method for executing the callable `func` as a transaction
     |      while watching all keys specified in `watches`. The 'func' callable
     |      should expect a single argument which is a Pipeline object.
     |
     |  ----------------------------------------------------------------------
     |  Class methods defined here:
     |
     |  __subclasshook__ = _proto_hook(other) from typing
     |
     |  from_pool(connection_pool: redis.connection.ConnectionPool) -> 'Redis'
     |      Return a Redis client from the given connection pool.
     |      The Redis client will take ownership of the connection pool and
     |      close it when the Redis client is closed.
     |
     |      Because the client closes (disconnects all connections in) the pool
     |      when it is closed or garbage-collected, the pool must not be shared
     |      with other clients. Constructing multiple clients from the same pool
     |      via ``from_pool`` -- for example one per request across threads -- is
     |      not thread safe: when one client is closed it will disconnect
     |      connections still in use by the others.
     |
     |      To share a single pool across clients, construct the pool explicitly
     |      and manage its lifecycle instead. Unlike ``from_pool``, the plain
     |      ``Redis(connection_pool=pool)`` constructor does not take ownership of
     |      the pool and will not close it, so a pool created this way can be
     |      safely shared across clients. ``ConnectionPool`` supports the context
     |      manager protocol for this::
     |
     |          with ConnectionPool.from_url(url) as pool:
     |              r = Redis(connection_pool=pool)
     |
     |  from_url(url: str, **kwargs) -> 'Redis'
     |      Return a Redis client object configured from the given URL
     |
     |      For example::
     |
     |          redis://[[username]:[password]]@localhost:6379/0
     |          rediss://[[username]:[password]]@localhost:6379/0
     |          unix://[username@]/path/to/socket.sock?db=0[&password=password]
     |
     |      Three URL schemes are supported:
     |
     |      - `redis://` creates a TCP socket connection. See more at:
     |        <https://www.iana.org/assignments/uri-schemes/prov/redis>
     |      - `rediss://` creates a SSL wrapped TCP socket connection. See more at:
     |        <https://www.iana.org/assignments/uri-schemes/prov/rediss>
     |      - ``unix://``: creates a Unix Domain Socket connection.
     |
     |      The username, password, hostname, path and all querystring values
     |      are passed through urllib.parse.unquote in order to replace any
     |      percent-encoded values with their corresponding characters.
     |
     |      There are several ways to specify a database number. The first value
     |      found will be used:
     |
     |          1. A ``db`` querystring option, e.g. redis://localhost?db=0
     |          2. If using the redis:// or rediss:// schemes, the path argument
     |             of the url, e.g. redis://localhost/0
     |          3. A ``db`` keyword argument to this function.
     |
     |      If none of these options are specified, the default db=0 is used.
     |
     |      All querystring options are cast to their appropriate Python types.
     |      Boolean arguments can be specified with string values "True"/"False"
     |      or "Yes"/"No". Values that cannot be properly cast cause a
     |      ``ValueError`` to be raised. Once parsed, the querystring arguments
     |      and keyword arguments are passed to the ``ConnectionPool``'s
     |      class initializer. In the case of conflicting arguments, querystring
     |      arguments always win.
     |
     |  ----------------------------------------------------------------------
     |  Readonly properties defined here:
     |
     |  himport_registry
     |      The client's HIMPORT fieldset registry (contains empty
     |      schema registry if none was declared).
     |
     |      Read-only: the registry is mutated only through the HIMPORT command methods.
     |
     |  ----------------------------------------------------------------------
     |  Data and other attributes defined here:
     |
     |  __abstractmethods__ = frozenset()
     |
     |  __annotations__ = {'_is_async_client': typing.Literal[False]}
     |
     |  __parameters__ = ()
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from redis.commands.redismodules.RedisModuleCommands:
     |
     |  bf(self) -> 'BFBloom'
     |      Access the bloom namespace.
     |
     |  cf(self) -> 'CFBloom'
     |      Access the bloom namespace.
     |
     |  cms(self) -> 'CMSBloom'
     |      Access the bloom namespace.
     |
     |  ft(self, index_name='idx') -> 'Search'
     |      Access the search namespace, providing support for redis search.
     |
     |  json(self, encoder=<json.encoder.JSONEncoder object at 0x0000017B9C588F50>, decoder=<json.decoder.JSONDecoder object at 0x0000017B9C588FB0>) -> 'JSON'
     |      Access the json namespace, providing support for redis json.
     |
     |  tdigest(self) -> 'TDigestBloom'
     |      Access the bloom namespace.
     |
     |  topk(self) -> 'TOPKBloom'
     |      Access the bloom namespace.
     |
     |  ts(self) -> 'TimeSeries'
     |      Access the timeseries namespace, providing support for
     |      redis timeseries data.
     |
     |  vset(self) -> 'VectorSet'
     |      Access the VectorSet commands namespace.
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors inherited from redis.commands.redismodules.RedisModuleCommands:
     |
     |  __dict__
     |      dictionary for instance variables
     |
     |  __weakref__
     |      list of weak references to the object
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from redis.commands.core.ACLCommands:
     |
     |  acl_cat(self, category: 'str | None' = None, **kwargs) -> 'list[bytes | str] | Awaitable[list[bytes | str]]'
     |      Returns a list of categories or commands within a category.
     |
     |      If ``category`` is not supplied, returns a list of all categories.
     |      If ``category`` is supplied, returns a list of all commands within
     |      that category.
     |
     |      For more information, see https://redis.io/commands/acl-cat
     |
     |  acl_deluser(self, *username: 'str', **kwargs) -> 'int | Awaitable[int]'
     |      Delete the ACL for the specified ``username``\s
     |
     |      For more information, see https://redis.io/commands/acl-deluser
     |
     |  acl_dryrun(self, username: 'str', *args: 'EncodableT', **kwargs) -> 'bytes | str | Awaitable[bytes | str]'
     |      Simulate the execution of a given command by a given ``username``.
     |
     |      For more information, see https://redis.io/commands/acl-dryrun
     |
     |  acl_genpass(self, bits: 'int | None' = None, **kwargs) -> 'bytes | str | Awaitable[bytes | str]'
     |      Generate a random password value.
     |      If ``bits`` is supplied then use this number of bits, rounded to
     |      the next multiple of 4.
     |      See: https://redis.io/commands/acl-genpass
     |
     |  acl_getuser(self, username: 'str', **kwargs) -> 'ACLGetUserData | Awaitable[ACLGetUserData]'
     |      Get the ACL details for the specified ``username``.
     |
     |      If ``username`` does not exist, return None
     |
     |      For more information, see https://redis.io/commands/acl-getuser
     |
     |  acl_help(self, **kwargs) -> 'list[bytes | str] | Awaitable[list[bytes | str]]'
     |      The ACL HELP command returns helpful text describing
     |      the different subcommands.
     |
     |      For more information, see https://redis.io/commands/acl-help
     |
     |  acl_list(self, **kwargs) -> 'list[bytes | str] | Awaitable[list[bytes | str]]'
     |      Return a list of all ACLs on the server
     |
     |      For more information, see https://redis.io/commands/acl-list
     |
     |  acl_load(self, **kwargs) -> 'bool | Awaitable[bool]'
     |      Load ACL rules from the configured ``aclfile``.
     |
     |      Note that the server must be configured with the ``aclfile``
     |      directive to be able to load ACL rules from an aclfile.
     |
     |      For more information, see https://redis.io/commands/acl-load
     |
     |  acl_log(self, count: 'int | None' = None, **kwargs) -> 'ACLLogData | Awaitable[ACLLogData]'
     |      Get ACL logs as a list.
     |      :param int count: Get logs[0:count].
     |      :rtype: List.
     |
     |      For more information, see https://redis.io/commands/acl-log
     |
     |  acl_log_reset(self, **kwargs) -> 'bool | Awaitable[bool]'
     |      Reset ACL logs.
     |      :rtype: Boolean.
     |
     |      For more information, see https://redis.io/commands/acl-log
     |
     |  acl_save(self, **kwargs) -> 'bool | Awaitable[bool]'
     |      Save ACL rules to the configured ``aclfile``.
     |
     |      Note that the server must be configured with the ``aclfile``
     |      directive to be able to save ACL rules to an aclfile.
     |
     |      For more information, see https://redis.io/commands/acl-save
     |
     |  acl_setuser(self, username: 'str', enabled: 'bool' = False, nopass: 'bool' = False, passwords: 'str | Iterable[str] | None' = None, hashed_passwords: 'str | Iterable[str] | None' = None, categories: 'Iterable[str] | None' = None, commands: 'Iterable[str] | None' = None, keys: 'Iterable[KeyT] | None' = None, channels: 'Iterable[ChannelT] | None' = None, selectors: 'Iterable[Tuple[str, KeyT]] | None' = None, reset: 'bool' = False, reset_keys: 'bool' = False, reset_channels: 'bool' = False, reset_passwords: 'bool' = False, **kwargs) -> 'bool | Awaitable[bool]'
     |      Create or update an ACL user.
     |
     |      Create or update the ACL for `username`. If the user already exists,
     |      the existing ACL is completely overwritten and replaced with the
     |      specified values.
     |
     |      For more information, see https://redis.io/commands/acl-setuser
     |
     |      Args:
     |          username: The name of the user whose ACL is to be created or updated.
     |          enabled: Indicates whether the user should be allowed to authenticate.
     |                   Defaults to `False`.
     |          nopass: Indicates whether the user can authenticate without a password.
     |                  This cannot be `True` if `passwords` are also specified.
     |          passwords: A list of plain text passwords to add to or remove from the user.
     |                     Each password must be prefixed with a '+' to add or a '-' to
     |                     remove. For convenience, a single prefixed string can be used
     |                     when adding or removing a single password.
     |          hashed_passwords: A list of SHA-256 hashed passwords to add to or remove
     |                            from the user. Each hashed password must be prefixed with
     |                            a '+' to add or a '-' to remove. For convenience, a single
     |                            prefixed string can be used when adding or removing a
     |                            single password.
     |          categories: A list of strings representing category permissions. Each string
     |                      must be prefixed with either a '+' to add the category
     |                      permission or a '-' to remove the category permission.
     |          commands: A list of strings representing command permissions. Each string
     |                    must be prefixed with either a '+' to add the command permission
     |                    or a '-' to remove the command permission.
     |          keys: A list of key patterns to grant the user access to. Key patterns allow
     |                ``'*'`` to support wildcard matching. For example, ``'*'`` grants
     |                access to all keys while ``'cache:*'`` grants access to all keys that
     |                are prefixed with ``cache:``.
     |                `keys` should not be prefixed with a ``'~'``.
     |          reset: Indicates whether the user should be fully reset prior to applying
     |                 the new ACL. Setting this to `True` will remove all existing
     |                 passwords, flags, and privileges from the user and then apply the
     |                 specified rules. If `False`, the user's existing passwords, flags,
     |                 and privileges will be kept and any new specified rules will be
     |                 applied on top.
     |          reset_keys: Indicates whether the user's key permissions should be reset
     |                      prior to applying any new key permissions specified in `keys`.
     |                      If `False`, the user's existing key permissions will be kept and
     |                      any new specified key permissions will be applied on top.
     |          reset_channels: Indicates whether the user's channel permissions should be
     |                          reset prior to applying any new channel permissions
     |                          specified in `channels`. If `False`, the user's existing
     |                          channel permissions will be kept and any new specified
     |                          channel permissions will be applied on top.
     |          reset_passwords: Indicates whether to remove all existing passwords and the
     |                           `nopass` flag from the user prior to applying any new
     |                           passwords specified in `passwords` or `hashed_passwords`.
     |                           If `False`, the user's existing passwords and `nopass`
     |                           status will be kept and any new specified passwords or
     |                           hashed passwords will be applied on top.
     |
     |  acl_users(self, **kwargs) -> 'list[bytes | str] | Awaitable[list[bytes | str]]'
     |      Returns a list of all registered users on the server.
     |
     |      For more information, see https://redis.io/commands/acl-users
     |
     |  acl_whoami(self, **kwargs) -> 'bytes | str | Awaitable[bytes | str]'
     |      Get the username for the current connection
     |
     |      For more information, see https://redis.io/commands/acl-whoami
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from redis.commands.core.ClusterCommands:
     |
     |  cluster(self, cluster_arg, *args, **kwargs) -> 'Any | Awaitable[Any]'
     |
     |  readonly(self, **kwargs) -> 'bool | Awaitable[bool]'
     |      Enables read queries for a connection to a Redis Cluster replica node.
     |
     |      For more information, see https://redis.io/commands/readonly
     |
     |  readwrite(self, **kwargs) -> 'bool | Awaitable[bool]'
     |      Disables read queries for a connection to a Redis Cluster slave node.
     |
     |      For more information, see https://redis.io/commands/readwrite
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from redis.commands.core.BasicKeyCommands:
     |
     |  __contains__ = exists(self, *names: 'KeyT') -> 'int | Awaitable[int]'
     |
     |  __delitem__(self, name: 'KeyT')
     |
     |  __getitem__(self, name: 'KeyT')
     |      Return the value at key ``name``, raises a KeyError if the key
     |      doesn't exist.
     |
     |  __setitem__(self, name: 'KeyT', value: 'EncodableT')
     |
     |  append(self, key: 'KeyT', value: 'EncodableT') -> 'int | Awaitable[int]'
     |      Appends the string ``value`` to the value at ``key``. If ``key``
     |      doesn't already exist, create it with a value of ``value``.
     |      Returns the new length of the value at ``key``.
     |
     |      For more information, see https://redis.io/commands/append
     |
     |  bitcount(self, key: 'KeyT', start: 'int | None' = None, end: 'int | None' = None, mode: 'str | None' = None) -> 'int | Awaitable[int]'
     |      Returns the count of set bits in the value of ``key``.  Optional
     |      ``start`` and ``end`` parameters indicate which bytes to consider
     |
     |      For more information, see https://redis.io/commands/bitcount
     |
     |  bitfield(self: "Union['redis.client.Redis', 'redis.asyncio.client.Redis']", key: 'KeyT', default_overflow: 'str | None' = None) -> 'BitFieldOperation'
     |      Return a BitFieldOperation instance to conveniently construct one or
     |      more bitfield operations on ``key``.
     |
     |      For more information, see https://redis.io/commands/bitfield
     |
     |  bitfield_ro(self: "Union['redis.client.Redis', 'redis.asyncio.client.Redis']", key: 'KeyT', encoding: 'str', offset: 'BitfieldOffsetT', items: 'list[tuple[str, BitfieldOffsetT]] | None' = None) -> 'list[int] | Awaitable[list[int]]'
     |      Return an array of the specified bitfield values
     |      where the first value is found using ``encoding`` and ``offset``
     |      parameters and remaining values are result of corresponding
     |      encoding/offset pairs in optional list ``items``
     |      Read-only variant of the BITFIELD command.
     |
     |      For more information, see https://redis.io/commands/bitfield_ro
     |
     |  bitop(self, operation: 'str', dest: 'KeyT', *keys: 'KeyT') -> 'int | Awaitable[int]'
     |      Perform a bitwise operation using ``operation`` between ``keys`` and
     |      store the result in ``dest``.
     |
     |      For more information, see https://redis.io/commands/bitop
     |
     |  bitpos(self, key: 'KeyT', bit: 'int', start: 'int | None' = None, end: 'int | None' = None, mode: 'str | None' = None) -> 'int | Awaitable[int]'
     |      Return the position of the first bit set to 1 or 0 in a string.
     |      ``start`` and ``end`` defines search range. The range is interpreted
     |      as a range of bytes and not a range of bits, so start=0 and end=2
     |      means to look at the first three bytes.
     |
     |      For more information, see https://redis.io/commands/bitpos
     |
     |  blmove(self, first_list: 'str', second_list: 'str', timeout: 'int', src: 'str' = 'LEFT', dest: 'str' = 'RIGHT') -> 'bytes | str | None | Awaitable[bytes | str | None]'
     |      Blocking version of lmove.
     |
     |      For more information, see https://redis.io/commands/blmove
     |
     |  blmovem(self, first_list: 'str', second_list: 'str', timeout: 'float', src: 'str' = 'LEFT', dest: 'str' = 'RIGHT', count: 'int | None' = None, mode: "Literal['COUNT', 'EXACTLY'] | None" = None, ordering: "Literal['OBO', 'BULK'] | None" = None) -> 'list[bytes | str] | None | Awaitable[list[bytes | str] | None]'
     |      Blocking version of lmovem.
     |
     |      Blocks until elements are available to move or ``timeout`` (in seconds)
     |      is reached; a ``timeout`` of ``0`` blocks indefinitely. With ``COUNT``
     |      the command unblocks once at least one element is available and moves
     |      ``min(count, available)``; with ``EXACTLY`` it blocks until the source
     |      holds at least ``count`` elements, then moves exactly ``count``
     |      atomically. On timeout ``None`` is returned and nothing is moved.
     |
     |      As with ``lmovem``, ``ordering`` (OBO or BULK) is required whenever
     |      ``count`` is given.
     |
     |      For more information, see https://redis.io/commands/blmovem
     |
     |  copy(self, source: 'str', destination: 'str', destination_db: 'str | None' = None, replace: 'bool' = False) -> 'bool | Awaitable[bool]'
     |      Copy the value stored in the ``source`` key to the ``destination`` key.
     |
     |      ``destination_db`` an alternative destination database. By default,
     |      the ``destination`` key is created in the source Redis database.
     |
     |      ``replace`` whether the ``destination`` key should be removed before
     |      copying the value to it. By default, the value is not copied if
     |      the ``destination`` key already exists.
     |
     |      For more information, see https://redis.io/commands/copy
     |
     |  decr = decrby(self, name: 'KeyT', amount: 'int' = 1) -> 'int | Awaitable[int]'
     |
     |  decrby(self, name: 'KeyT', amount: 'int' = 1) -> 'int | Awaitable[int]'
     |      Decrements the value of ``key`` by ``amount``.  If no key exists,
     |      the value will be initialized as 0 - ``amount``
     |
     |      For more information, see https://redis.io/commands/decrby
     |
     |  delete(self, *names: 'KeyT') -> 'int | Awaitable[int]'
     |      Delete one or more keys specified by ``names``
     |
     |  delex(self, name: 'KeyT', ifeq: 'bytes | str | None' = None, ifne: 'bytes | str | None' = None, ifdeq: 'str | None' = None, ifdne: 'str | None' = None) -> 'int | Awaitable[int]'
     |      Conditionally removes the specified key.
     |
     |      Warning:
     |      **Experimental** since 7.1.
     |      This API may change or be removed without notice.
     |      The API may change based on feedback.
     |
     |      Arguments:
     |          name: KeyT - the key to delete
     |          ifeq match-valu: Optional[Union[bytes, str]] - Delete the key only if its value is equal to match-value
     |          ifne match-value: Optional[Union[bytes, str]] - Delete the key only if its value is not equal to match-value
     |          ifdeq match-digest: Optional[str] - Delete the key only if the digest of its value is equal to match-digest
     |          ifdne match-digest: Optional[str] - Delete the key only if the digest of its value is not equal to match-digest
     |
     |      Returns:
     |          int: 1 if the key was deleted, 0 otherwise.
     |      Raises:
     |          redis.exceptions.ResponseError: if key exists but is not a string
     |                                          and a condition is specified.
     |          ValueError: if more than one condition is provided.
     |
     |
     |      Requires Redis 8.4 or greater.
     |      For more information, see https://redis.io/commands/delex
     |
     |  digest(self, name: 'KeyT') -> 'str | bytes | None | Awaitable[str | bytes | None]'
     |      Return the digest of the value stored at the specified key.
     |
     |      Warning:
     |      **Experimental** since 7.1.
     |      This API may change or be removed without notice.
     |      The API may change based on feedback.
     |
     |      Arguments:
     |        - name: KeyT - the key to get the digest of
     |
     |      Returns:
     |        - None if the key does not exist
     |        - (bulk string) the XXH3 digest of the value as a hex string
     |      Raises:
     |        - ResponseError if key exists but is not a string
     |
     |
     |      Requires Redis 8.4 or greater.
     |      For more information, see https://redis.io/commands/digest
     |
     |  digest_local(self, value: 'bytes | str') -> 'bytes | str'
     |      Compute the hexadecimal digest of the value locally, without sending it to the server.
     |
     |      This is useful for conditional operations like IFDEQ/IFDNE where you need to
     |      compute the digest client-side before sending a command.
     |
     |      Warning:
     |      **Experimental** - This API may change or be removed without notice.
     |
     |      Arguments:
     |        - value: Union[bytes, str] - the value to compute the digest of.
     |          If a string is provided, it will be encoded using UTF-8 before hashing,
     |          which matches Redis's default encoding behavior.
     |
     |      Returns:
     |        - (str | bytes) the XXH3 digest of the value as a hex string (16 hex characters).
     |          Returns bytes if decode_responses is False, otherwise returns str.
     |
     |      For more information, see https://redis.io/commands/digest
     |
     |  dump(self, name: 'KeyT') -> 'bytes | None | Awaitable[bytes | None]'
     |      Return a serialized version of the value stored at the specified key.
     |      If key does not exist a nil bulk reply is returned.
     |
     |      For more information, see https://redis.io/commands/dump
     |
     |  exists(self, *names: 'KeyT') -> 'int | Awaitable[int]'
     |      Returns the number of ``names`` that exist
     |
     |      For more information, see https://redis.io/commands/exists
     |
     |  expire(self, name: 'KeyT', time: 'ExpiryT', nx: 'bool' = False, xx: 'bool' = False, gt: 'bool' = False, lt: 'bool' = False) -> 'bool | Awaitable[bool]'
     |      Set an expire flag on key ``name`` for ``time`` seconds with given
     |      ``option``. ``time`` can be represented by an integer or a Python timedelta
     |      object.
     |
     |      Valid options are:
     |          NX -> Set expiry only when the key has no expiry
     |          XX -> Set expiry only when the key has an existing expiry
     |          GT -> Set expiry only when the new expiry is greater than current one
     |          LT -> Set expiry only when the new expiry is less than current one
     |
     |      For more information, see https://redis.io/commands/expire
     |
     |  expireat(self, name: 'KeyT', when: 'AbsExpiryT', nx: 'bool' = False, xx: 'bool' = False, gt: 'bool' = False, lt: 'bool' = False) -> 'bool | Awaitable[bool]'
     |      Set an expire flag on key ``name`` with given ``option``. ``when``
     |      can be represented as an integer indicating unix time or a Python
     |      datetime object.
     |
     |      Valid options are:
     |          -> NX -- Set expiry only when the key has no expiry
     |          -> XX -- Set expiry only when the key has an existing expiry
     |          -> GT -- Set expiry only when the new expiry is greater than current one
     |          -> LT -- Set expiry only when the new expiry is less than current one
     |
     |      For more information, see https://redis.io/commands/expireat
     |
     |  expiretime(self, key: 'str') -> 'int | Awaitable[int]'
     |      Returns the absolute Unix timestamp (since January 1, 1970) in seconds
     |      at which the given key will expire.
     |
     |      For more information, see https://redis.io/commands/expiretime
     |
     |  get(self, name: 'KeyT') -> 'bytes | str | None | Awaitable[bytes | str | None]'
     |      Return the value at key ``name``, or None if the key doesn't exist
     |
     |      For more information, see https://redis.io/commands/get
     |
     |  getbit(self, name: 'KeyT', offset: 'int') -> 'int | Awaitable[int]'
     |      Returns an integer indicating the value of ``offset`` in ``name``
     |
     |      For more information, see https://redis.io/commands/getbit
     |
     |  getdel(self, name: 'KeyT') -> 'bytes | str | None | Awaitable[bytes | str | None]'
     |      Get the value at key ``name`` and delete the key. This command
     |      is similar to GET, except for the fact that it also deletes
     |      the key on success (if and only if the key's value type
     |      is a string).
     |
     |      For more information, see https://redis.io/commands/getdel
     |
     |  getex(self, name: 'KeyT', ex: 'ExpiryT | None' = None, px: 'ExpiryT | None' = None, exat: 'AbsExpiryT | None' = None, pxat: 'AbsExpiryT | None' = None, persist: 'bool' = False) -> 'bytes | str | None | Awaitable[bytes | str | None]'
     |      Get the value of key and optionally set its expiration.
     |      GETEX is similar to GET, but is a write command with
     |      additional options. All time parameters can be given as
     |      datetime.timedelta or integers.
     |
     |      ``ex`` sets an expire flag on key ``name`` for ``ex`` seconds.
     |
     |      ``px`` sets an expire flag on key ``name`` for ``px`` milliseconds.
     |
     |      ``exat`` sets an expire flag on key ``name`` for ``ex`` seconds,
     |      specified in unix time.
     |
     |      ``pxat`` sets an expire flag on key ``name`` for ``ex`` milliseconds,
     |      specified in unix time.
     |
     |      ``persist`` remove the time to live associated with ``name``.
     |
     |      For more information, see https://redis.io/commands/getex
     |
     |  getrange(self, key: 'KeyT', start: 'int', end: 'int') -> 'bytes | str | Awaitable[bytes | str]'
     |      Returns the substring of the string value stored at ``key``,
     |      determined by the offsets ``start`` and ``end`` (both are inclusive)
     |
     |      For more information, see https://redis.io/commands/getrange
     |
     |  getset(self, name: 'KeyT', value: 'EncodableT') -> 'bytes | str | None | Awaitable[bytes | str | None]'
     |      Sets the value at key ``name`` to ``value``
     |      and returns the old value at key ``name`` atomically.
     |
     |      As per Redis 6.2, GETSET is considered deprecated.
     |      Please use SET with GET parameter in new code.
     |
     |      For more information, see https://redis.io/commands/getset
     |
     |  hrandfield(self, key: 'KeyT', count: 'int | None' = None, withvalues: 'bool' = False) -> 'HRandFieldResponse | Awaitable[HRandFieldResponse]'
     |      Return a random field from the hash value stored at key.
     |
     |      count: if the argument is positive, return an array of distinct fields.
     |      If called with a negative count, the behavior changes and the command
     |      is allowed to return the same field multiple times. In this case,
     |      the number of returned fields is the absolute value of the
     |      specified count.
     |      withvalues: The optional WITHVALUES modifier changes the reply so it
     |      includes the respective values of the randomly selected hash fields.
     |
     |      For more information, see https://redis.io/commands/hrandfield
     |
     |  incr = incrby(self, name: 'KeyT', amount: 'int' = 1) -> 'int | Awaitable[int]'
     |
     |  incrby(self, name: 'KeyT', amount: 'int' = 1) -> 'int | Awaitable[int]'
     |      Increments the value of ``key`` by ``amount``.  If no key exists,
     |      the value will be initialized as ``amount``
     |
     |      For more information, see https://redis.io/commands/incrby
     |
     |  incrbyfloat(self, name: 'KeyT', amount: 'float' = 1.0) -> 'float | Awaitable[float]'
     |      Increments the value at key ``name`` by floating ``amount``.
     |      If no key exists, the value will be initialized as ``amount``
     |
     |      For more information, see https://redis.io/commands/incrbyfloat
     |
     |  increx(self, name: 'KeyT', *, byfloat: 'EncodableT | None' = None, byint: 'EncodableT | None' = None, lbound: 'EncodableT | None' = None, ubound: 'EncodableT | None' = None, saturate: 'bool' = False, ex: 'ExpiryT | None' = None, px: 'ExpiryT | None' = None, exat: 'AbsExpiryT | None' = None, pxat: 'AbsExpiryT | None' = None, persist: 'bool' = False, enx: 'bool' = False) -> 'list[Number | bytes | str] | Awaitable[list[Number | bytes | str]]'
     |      Increment the numeric value at key ``name`` and return the new value
     |      and the actual increment.
     |
     |      ``byfloat`` increments a floating point value by the provided amount.
     |
     |      ``byint`` increments an integer value by the provided amount.
     |
     |      If neither ``byfloat`` nor ``byint`` is specified, the value is
     |      incremented by one.
     |
     |      ``lbound`` and ``ubound`` constrain the valid range of the result.
     |
     |      If ``saturate`` is True, out-of-bounds results are saturated to the
     |      specified bound, or to the type limit when no bound is specified.
     |      Otherwise, out-of-bounds results are rejected, leaving the value and
     |      TTL unchanged and returning the current value and zero as the actual
     |      increment.
     |
     |      ``enx`` applies the expiration only when the key does not already
     |      have an expiration, and requires ``ex``, ``px``, ``exat``, or ``pxat``.
     |
     |  keys(self, pattern: 'PatternT' = '*', **kwargs) -> 'list[bytes | str] | Awaitable[list[bytes | str]]'
     |      Returns a list of keys matching ``pattern``
     |
     |      For more information, see https://redis.io/commands/keys
     |
     |  lcs(self, key1: 'str', key2: 'str', len: 'bool | None' = False, idx: 'bool | None' = False, minmatchlen: 'int | None' = 0, withmatchlen: 'bool | None' = False) -> 'LCSCommandResponse | Awaitable[LCSCommandResponse]'
     |      Find the longest common subsequence between ``key1`` and ``key2``.
     |      If ``len`` is true the length of the match will be returned.
     |      If ``idx`` is true the match position in each strings will be returned.
     |      ``minmatchlen`` restrict the list of matches to the ones of
     |      the given ``minmatchlen``.
     |      If ``withmatchlen`` the length of the match also will be returned.
     |      For more information, see https://redis.io/commands/lcs
     |
     |  lmove(self, first_list: 'str', second_list: 'str', src: 'str' = 'LEFT', dest: 'str' = 'RIGHT') -> 'bytes | str | None | Awaitable[bytes | str | None]'
     |      Atomically returns and removes the first/last element of a list,
     |      pushing it as the first/last element on the destination list.
     |      Returns the element being popped and pushed.
     |
     |      For more information, see https://redis.io/commands/lmove
     |
     |  lmovem(self, first_list: 'str', second_list: 'str', src: 'str' = 'LEFT', dest: 'str' = 'RIGHT', count: 'int | None' = None, mode: "Literal['COUNT', 'EXACTLY'] | None" = None, ordering: "Literal['OBO', 'BULK'] | None" = None) -> 'list[bytes | str] | None | Awaitable[list[bytes | str] | None]'
     |      Atomically moves multiple elements from one end of the ``first_list``
     |      to one end of the ``second_list``, returning the moved elements in
     |      destination order.
     |
     |      ``src`` and ``dest`` are the ends to pop from / push to, either
     |      ``LEFT`` (head) or ``RIGHT`` (tail).
     |
     |      When ``count`` is given, ``mode`` selects how many elements to move:
     |      ``COUNT`` (the default) moves up to ``count`` elements, while
     |      ``EXACTLY`` moves exactly ``count`` elements or nothing at all. When
     |      ``count`` is not given a single element is moved.
     |
     |      ``ordering`` controls the order at the destination: ``OBO`` pushes each
     |      element as it is popped (reversing block order, stack semantics) while
     |      ``BULK`` preserves the original relative order (queue semantics). It is
     |      required whenever ``count`` is given.
     |
     |      Returns the array of moved elements, or ``None`` if nothing was moved.
     |
     |      For more information, see https://redis.io/commands/lmovem
     |
     |  mget(self, keys: 'KeysT', *args: 'EncodableT') -> 'list[bytes | str | None] | Awaitable[list[bytes | str | None]]'
     |      Returns a list of values ordered identically to ``keys``
     |
     |      ** Important ** When this method is used with Cluster clients, all keys
     |              must be in the same hash slot, otherwise a RedisClusterException
     |              will be raised.
     |
     |      For more information, see https://redis.io/commands/mget
     |
     |  move(self, name: 'KeyT', db: 'int') -> 'bool | Awaitable[bool]'
     |      Moves the key ``name`` to a different Redis database ``db``
     |
     |      For more information, see https://redis.io/commands/move
     |
     |  mset(self, mapping: 'Mapping[AnyKeyT, EncodableT]') -> 'bool | Awaitable[bool]'
     |      Sets key/values based on a mapping. Mapping is a dictionary of
     |      key/value pairs. Both keys and values should be strings or types that
     |      can be cast to a string via str().
     |
     |      ** Important ** When this method is used with Cluster clients, all keys
     |              must be in the same hash slot, otherwise a RedisClusterException
     |              will be raised.
     |
     |      For more information, see https://redis.io/commands/mset
     |
     |  msetex(self, mapping: 'Mapping[AnyKeyT, EncodableT]', data_persist_option: 'DataPersistOptions | None' = None, ex: 'ExpiryT | None' = None, px: 'ExpiryT | None' = None, exat: 'AbsExpiryT | None' = None, pxat: 'AbsExpiryT | None' = None, keepttl: 'bool' = False) -> 'int | Awaitable[int]'
     |      Sets key/values based on the provided ``mapping`` items.
     |
     |      ** Important ** When this method is used with Cluster clients, all keys
     |                      must be in the same hash slot, otherwise a RedisClusterException
     |                      will be raised.
     |
     |      ``mapping`` accepts a dict of key/value pairs that will be added to the database.
     |
     |      ``data_persist_option`` can be set to ``NX`` or ``XX`` to control the
     |          behavior of the command.
     |          ``NX`` will set the value for each provided key to each
     |              provided value only if all do not already exist.
     |          ``XX`` will set the value for each provided key to each
     |              provided value only if all already exist.
     |
     |      ``ex`` sets an expire flag on the keys in ``mapping`` for ``ex`` seconds.
     |
     |      ``px`` sets an expire flag on the keys in ``mapping`` for ``px`` milliseconds.
     |
     |      ``exat`` sets an expire flag on the keys in ``mapping`` for ``exat`` seconds,
     |          specified in unix time.
     |
     |      ``pxat`` sets an expire flag on the keys in ``mapping`` for ``pxat`` milliseconds,
     |          specified in unix time.
     |
     |      ``keepttl`` if True, retain the time to live associated with the keys.
     |
     |      Returns the number of fields that were added.
     |
     |      Available since Redis 8.4
     |      For more information, see https://redis.io/commands/msetex
     |
     |  msetnx(self, mapping: 'Mapping[AnyKeyT, EncodableT]') -> 'bool | Awaitable[bool]'
     |      Sets key/values based on a mapping if none of the keys are already set.
     |      Mapping is a dictionary of key/value pairs. Both keys and values
     |      should be strings or types that can be cast to a string via str().
     |      Returns a boolean indicating if the operation was successful.
     |
     |      ** Important ** When this method is used with Cluster clients, all keys
     |                      must be in the same hash slot, otherwise a RedisClusterException
     |                      will be raised.
     |
     |      For more information, see https://redis.io/commands/msetnx
     |
     |  persist(self, name: 'KeyT') -> 'bool | Awaitable[bool]'
     |      Removes an expiration on ``name``
     |
     |      For more information, see https://redis.io/commands/persist
     |
     |  pexpire(self, name: 'KeyT', time: 'ExpiryT', nx: 'bool' = False, xx: 'bool' = False, gt: 'bool' = False, lt: 'bool' = False) -> 'bool | Awaitable[bool]'
     |      Set an expire flag on key ``name`` for ``time`` milliseconds
     |      with given ``option``. ``time`` can be represented by an
     |      integer or a Python timedelta object.
     |
     |      Valid options are:
     |          NX -> Set expiry only when the key has no expiry
     |          XX -> Set expiry only when the key has an existing expiry
     |          GT -> Set expiry only when the new expiry is greater than current one
     |          LT -> Set expiry only when the new expiry is less than current one
     |
     |      For more information, see https://redis.io/commands/pexpire
     |
     |  pexpireat(self, name: 'KeyT', when: 'AbsExpiryT', nx: 'bool' = False, xx: 'bool' = False, gt: 'bool' = False, lt: 'bool' = False) -> 'bool | Awaitable[bool]'
     |      Set an expire flag on key ``name`` with given ``option``. ``when``
     |      can be represented as an integer representing unix time in
     |      milliseconds (unix time * 1000) or a Python datetime object.
     |
     |      Valid options are:
     |          NX -> Set expiry only when the key has no expiry
     |          XX -> Set expiry only when the key has an existing expiry
     |          GT -> Set expiry only when the new expiry is greater than current one
     |          LT -> Set expiry only when the new expiry is less than current one
     |
     |      For more information, see https://redis.io/commands/pexpireat
     |
     |  pexpiretime(self, key: 'str') -> 'int | Awaitable[int]'
     |      Returns the absolute Unix timestamp (since January 1, 1970) in milliseconds
     |      at which the given key will expire.
     |
     |      For more information, see https://redis.io/commands/pexpiretime
     |
     |  psetex(self, name: 'KeyT', time_ms: 'ExpiryT', value: 'EncodableT') -> 'bool | Awaitable[bool]'
     |      Set the value of key ``name`` to ``value`` that expires in ``time_ms``
     |      milliseconds. ``time_ms`` can be represented by an integer or a Python
     |      timedelta object
     |
     |      For more information, see https://redis.io/commands/psetex
     |
     |  pttl(self, name: 'KeyT') -> 'int | Awaitable[int]'
     |      Returns the number of milliseconds until the key ``name`` will expire
     |
     |      For more information, see https://redis.io/commands/pttl
     |
     |  randomkey(self, **kwargs) -> 'bytes | str | None | Awaitable[bytes | str | None]'
     |      Returns the name of a random key
     |
     |      For more information, see https://redis.io/commands/randomkey
     |
     |  rename(self, src: 'KeyT', dst: 'KeyT') -> 'bool | Awaitable[bool]'
     |      Rename key ``src`` to ``dst``
     |
     |      For more information, see https://redis.io/commands/rename
     |
     |  renamenx(self, src: 'KeyT', dst: 'KeyT') -> 'bool | Awaitable[bool]'
     |      Rename key ``src`` to ``dst`` if ``dst`` doesn't already exist
     |
     |      For more information, see https://redis.io/commands/renamenx
     |
     |  restore(self, name: 'KeyT', ttl: 'float', value: 'EncodableT', replace: 'bool' = False, absttl: 'bool' = False, idletime: 'int | None' = None, frequency: 'int | None' = None) -> 'bytes | str | Awaitable[bytes | str]'
     |      Create a key using the provided serialized value, previously obtained
     |      using DUMP.
     |
     |      ``replace`` allows an existing key on ``name`` to be overridden. If
     |      it's not specified an error is raised on collision.
     |
     |      ``absttl`` if True, specified ``ttl`` should represent an absolute Unix
     |      timestamp in milliseconds in which the key will expire. (Redis 5.0 or
     |      greater).
     |
     |      ``idletime`` Used for eviction, this is the number of seconds the
     |      key must be idle, prior to execution.
     |
     |      ``frequency`` Used for eviction, this is the frequency counter of
     |      the object stored at the key, prior to execution.
     |
     |      For more information, see https://redis.io/commands/restore
     |
     |  set(self, name: 'KeyT', value: 'EncodableT', ex: 'ExpiryT | None' = None, px: 'ExpiryT | None' = None, nx: 'bool' = False, xx: 'bool' = False, keepttl: 'bool' = False, get: 'bool' = False, exat: 'AbsExpiryT | None' = None, pxat: 'AbsExpiryT | None' = None, ifeq: 'bytes | str | None' = None, ifne: 'bytes | str | None' = None, ifdeq: 'str | None' = None, ifdne: 'str | None' = None) -> 'bool | str | bytes | None | Awaitable[bool | str | bytes | None]'
     |      Set the value at key ``name`` to ``value``
     |
     |      Warning:
     |      **Experimental** since 7.1.
     |      The usage of the arguments ``ifeq``, ``ifne``, ``ifdeq``, and ``ifdne``
     |      is experimental. The API or returned results when those parameters are used
     |      may change based on feedback.
     |
     |      ``ex`` sets an expire flag on key ``name`` for ``ex`` seconds.
     |
     |      ``px`` sets an expire flag on key ``name`` for ``px`` milliseconds.
     |
     |      ``nx`` if set to True, set the value at key ``name`` to ``value`` only
     |          if it does not exist.
     |
     |      ``xx`` if set to True, set the value at key ``name`` to ``value`` only
     |          if it already exists.
     |
     |      ``keepttl`` if True, retain the time to live associated with the key.
     |          (Available since Redis 6.0)
     |
     |      ``get`` if True, set the value at key ``name`` to ``value`` and return
     |          the old value stored at key, or None if the key did not exist.
     |          (Available since Redis 6.2)
     |
     |      ``exat`` sets an expire flag on key ``name`` for ``ex`` seconds,
     |          specified in unix time.
     |
     |      ``pxat`` sets an expire flag on key ``name`` for ``ex`` milliseconds,
     |          specified in unix time.
     |
     |      ``ifeq`` set the value at key ``name`` to ``value`` only if the current
     |          value exactly matches the argument.
     |          If key doesn’t exist - it won’t be created.
     |          (Requires Redis 8.4 or greater)
     |
     |      ``ifne`` set the value at key ``name`` to ``value`` only if the current
     |          value does not exactly match the argument.
     |          If key doesn’t exist - it will be created.
     |          (Requires Redis 8.4 or greater)
     |
     |      ``ifdeq`` set the value at key ``name`` to ``value`` only if the current
     |          value XXH3 hex digest exactly matches the argument.
     |          If key doesn’t exist - it won’t be created.
     |          (Requires Redis 8.4 or greater)
     |
     |      ``ifdne`` set the value at key ``name`` to ``value`` only if the current
     |          value XXH3 hex digest does not exactly match the argument.
     |          If key doesn’t exist - it will be created.
     |          (Requires Redis 8.4 or greater)
     |
     |      For more information, see https://redis.io/commands/set
     |
     |  setbit(self, name: 'KeyT', offset: 'int', value: 'int') -> 'int | Awaitable[int]'
     |      Flag the ``offset`` in ``name`` as ``value``. Returns an integer
     |      indicating the previous value of ``offset``.
     |
     |      For more information, see https://redis.io/commands/setbit
     |
     |  setex(self, name: 'KeyT', time: 'ExpiryT', value: 'EncodableT') -> 'bool | Awaitable[bool]'
     |      Set the value of key ``name`` to ``value`` that expires in ``time``
     |      seconds. ``time`` can be represented by an integer or a Python
     |      timedelta object.
     |
     |      As per Redis 2.6.12, SETEX is considered deprecated.
     |      Please use SET with EX parameter in new code.
     |
     |      For more information, see https://redis.io/commands/setex
     |
     |  setnx(self, name: 'KeyT', value: 'EncodableT') -> 'bool | Awaitable[bool]'
     |      Set the value of key ``name`` to ``value`` if key doesn't exist
     |
     |      For more information, see https://redis.io/commands/setnx
     |
     |  setrange(self, name: 'KeyT', offset: 'int', value: 'EncodableT') -> 'int | Awaitable[int]'
     |      Overwrite bytes in the value of ``name`` starting at ``offset`` with
     |      ``value``. If ``offset`` plus the length of ``value`` exceeds the
     |      length of the original value, the new value will be larger than before.
     |      If ``offset`` exceeds the length of the original value, null bytes
     |      will be used to pad between the end of the previous value and the start
     |      of what's being injected.
     |
     |      Returns the length of the new string.
     |
     |      For more information, see https://redis.io/commands/setrange
     |
     |  stralgo(self, algo: "Literal['LCS']", value1: 'KeyT', value2: 'KeyT', specific_argument: "Literal['strings'] | Literal['keys']" = 'strings', len: 'bool' = False, idx: 'bool' = False, minmatchlen: 'int | None' = None, withmatchlen: 'bool' = False, **kwargs) -> 'StralgoResponse | Awaitable[StralgoResponse]'
     |      Implements complex algorithms that operate on strings.
     |      Right now the only algorithm implemented is the LCS algorithm
     |      (longest common substring). However new algorithms could be
     |      implemented in the future.
     |
     |      ``algo`` Right now must be LCS
     |      ``value1`` and ``value2`` Can be two strings or two keys
     |      ``specific_argument`` Specifying if the arguments to the algorithm
     |      will be keys or strings. strings is the default.
     |      ``len`` Returns just the len of the match.
     |      ``idx`` Returns the match positions in each string.
     |      ``minmatchlen`` Restrict the list of matches to the ones of a given
     |      minimal length. Can be provided only when ``idx`` set to True.
     |      ``withmatchlen`` Returns the matches with the len of the match.
     |      Can be provided only when ``idx`` set to True.
     |
     |      For more information, see https://redis.io/commands/stralgo
     |
     |  strlen(self, name: 'KeyT') -> 'int | Awaitable[int]'
     |      Return the number of bytes stored in the value of ``name``
     |
     |      For more information, see https://redis.io/commands/strlen
     |
     |  substr(self, name: 'KeyT', start: 'int', end: 'int' = -1) -> 'bytes | str | Awaitable[bytes | str]'
     |      Return a substring of the string at key ``name``. ``start`` and ``end``
     |      are 0-based integers specifying the portion of the string to return.
     |
     |  touch(self, *args: 'KeyT') -> 'int | Awaitable[int]'
     |      Alters the last access time of a key(s) ``*args``. A key is ignored
     |      if it does not exist.
     |
     |      For more information, see https://redis.io/commands/touch
     |
     |  ttl(self, name: 'KeyT') -> 'int | Awaitable[int]'
     |      Returns the number of seconds until the key ``name`` will expire
     |
     |      For more information, see https://redis.io/commands/ttl
     |
     |  type(self, name: 'KeyT') -> 'bytes | str | Awaitable[bytes | str]'
     |      Returns the type of key ``name``
     |
     |      For more information, see https://redis.io/commands/type
     |
     |  unlink(self, *names: 'KeyT') -> 'int | Awaitable[int]'
     |      Unlink one or more keys specified by ``names``
     |
     |      For more information, see https://redis.io/commands/unlink
     |
     |  unwatch(self) -> 'None'
     |      Unwatches all previously watched keys for a transaction
     |
     |      For more information, see https://redis.io/commands/unwatch
     |
     |  watch(self, *names: 'KeyT') -> 'None'
     |      Watches the values at keys ``names``, or None if the key doesn't exist
     |
     |      For more information, see https://redis.io/commands/watch
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from redis.commands.core.HyperlogCommands:
     |
     |  pfadd(self, name: 'KeyT', *values: 'FieldT') -> 'int | Awaitable[int]'
     |      Adds the specified elements to the specified HyperLogLog.
     |
     |      For more information, see https://redis.io/commands/pfadd
     |
     |  pfcount(self, *sources: 'KeyT') -> 'int | Awaitable[int]'
     |      Return the approximated cardinality of
     |      the set observed by the HyperLogLog at key(s).
     |
     |      For more information, see https://redis.io/commands/pfcount
     |
     |  pfmerge(self, dest: 'KeyT', *sources: 'KeyT') -> 'bool | Awaitable[bool]'
     |      Merge N different HyperLogLogs into a single one.
     |
     |      For more information, see https://redis.io/commands/pfmerge
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from redis.commands.core.HashCommands:
     |
     |  hdel(self, name: 'KeyT', *keys: 'FieldT') -> 'int | Awaitable[int]'
     |      Delete ``keys`` from hash ``name``
     |
     |      For more information, see https://redis.io/commands/hdel
     |
     |  hexists(self, name: 'KeyT', key: 'FieldT') -> 'bool | Awaitable[bool]'
     |      Returns a boolean indicating if ``key`` exists within hash ``name``
     |
     |      For more information, see https://redis.io/commands/hexists
     |
     |  hexpire(self, name: 'KeyT', seconds: 'ExpiryT', *fields: 'FieldT', nx: 'bool' = False, xx: 'bool' = False, gt: 'bool' = False, lt: 'bool' = False) -> 'list[int] | Awaitable[list[int]]'
     |      Sets or updates the expiration time for fields within a hash key, using relative
     |      time in seconds.
     |
     |      If a field already has an expiration time, the behavior of the update can be
     |      controlled using the `nx`, `xx`, `gt`, and `lt` parameters.
     |
     |      The return value provides detailed information about the outcome for each field.
     |
     |      For more information, see https://redis.io/commands/hexpire
     |
     |      Args:
     |          name: The name of the hash key.
     |          seconds: Expiration time in seconds, relative. Can be an integer, or a
     |                   Python `timedelta` object.
     |          fields: List of fields within the hash to apply the expiration time to.
     |          nx: Set expiry only when the field has no expiry.
     |          xx: Set expiry only when the field has an existing expiry.
     |          gt: Set expiry only when the new expiry is greater than the current one.
     |          lt: Set expiry only when the new expiry is less than the current one.
     |
     |      Returns:
     |          Returns a list which contains for each field in the request:
     |              - `-2` if the field does not exist, or if the key does not exist.
     |              - `0` if the specified NX | XX | GT | LT condition was not met.
     |              - `1` if the expiration time was set or updated.
     |              - `2` if the field was deleted because the specified expiration time is
     |                in the past.
     |
     |  hexpireat(self, name: 'KeyT', unix_time_seconds: 'AbsExpiryT', *fields: 'FieldT', nx: 'bool' = False, xx: 'bool' = False, gt: 'bool' = False, lt: 'bool' = False) -> 'list[int] | Awaitable[list[int]]'
     |      Sets or updates the expiration time for fields within a hash key, using an
     |      absolute Unix timestamp in seconds.
     |
     |      If a field already has an expiration time, the behavior of the update can be
     |      controlled using the `nx`, `xx`, `gt`, and `lt` parameters.
     |
     |      The return value provides detailed information about the outcome for each field.
     |
     |      For more information, see https://redis.io/commands/hexpireat
     |
     |      Args:
     |          name: The name of the hash key.
     |          unix_time_seconds: Expiration time as Unix timestamp in seconds. Can be an
     |                             integer or a Python `datetime` object.
     |          fields: List of fields within the hash to apply the expiration time to.
     |          nx: Set expiry only when the field has no expiry.
     |          xx: Set expiry only when the field has an existing expiration time.
     |          gt: Set expiry only when the new expiry is greater than the current one.
     |          lt: Set expiry only when the new expiry is less than the current one.
     |
     |      Returns:
     |          Returns a list which contains for each field in the request:
     |              - `-2` if the field does not exist, or if the key does not exist.
     |              - `0` if the specified NX | XX | GT | LT condition was not met.
     |              - `1` if the expiration time was set or updated.
     |              - `2` if the field was deleted because the specified expiration time is
     |                in the past.
     |
     |  hexpiretime(self, key: 'KeyT', *fields: 'FieldT') -> 'list[int] | Awaitable[list[int]]'
     |      Returns the expiration times of hash fields as Unix timestamps in seconds.
     |
     |      For more information, see https://redis.io/commands/hexpiretime
     |
     |      Args:
     |          key: The hash key.
     |          fields: A list of fields within the hash for which to get the expiration
     |                  time.
     |
     |      Returns:
     |          Returns a list which contains for each field in the request:
     |              - `-2` if the field does not exist, or if the key does not exist.
     |              - `-1` if the field exists but has no associated expire time.
     |              - A positive integer representing the expiration Unix timestamp in
     |                seconds, if the field has an associated expiration time.
     |
     |  hget(self, name: 'KeyT', key: 'FieldT') -> 'bytes | str | None | Awaitable[bytes | str | None]'
     |      Return the value of ``key`` within the hash ``name``
     |
     |      For more information, see https://redis.io/commands/hget
     |
     |  hgetall(self, name: 'KeyT') -> 'dict[bytes | str, bytes | str] | Awaitable[dict[bytes | str, bytes | str]]'
     |      Return a Python dict of the hash's name/value pairs
     |
     |      For more information, see https://redis.io/commands/hgetall
     |
     |  hgetdel(self, name: 'KeyT', *keys: 'FieldT') -> 'list[bytes | str | None] | Awaitable[list[bytes | str | None]]'
     |      Return the value of ``key`` within the hash ``name`` and
     |      delete the field in the hash.
     |      This command is similar to HGET, except for the fact that it also deletes
     |      the key on success from the hash with the provided ```name```.
     |
     |      Available since Redis 8.0
     |      For more information, see https://redis.io/commands/hgetdel
     |
     |  hgetex(self, name: 'KeyT', *keys: 'FieldT', ex: 'ExpiryT | None' = None, px: 'ExpiryT | None' = None, exat: 'AbsExpiryT | None' = None, pxat: 'AbsExpiryT | None' = None, persist: 'bool' = False) -> 'list[bytes | str | None] | Awaitable[list[bytes | str | None]]'
     |      Return the values of ``key`` and ``keys`` within the hash ``name``
     |      and optionally set their expiration.
     |
     |      ``ex`` sets an expire flag on ``kyes`` for ``ex`` seconds.
     |
     |      ``px`` sets an expire flag on ``keys`` for ``px`` milliseconds.
     |
     |      ``exat`` sets an expire flag on ``keys`` for ``ex`` seconds,
     |      specified in unix time.
     |
     |      ``pxat`` sets an expire flag on ``keys`` for ``ex`` milliseconds,
     |      specified in unix time.
     |
     |      ``persist`` remove the time to live associated with the ``keys``.
     |
     |      Available since Redis 8.0
     |      For more information, see https://redis.io/commands/hgetex
     |
     |  himport_discard_all_internal(self) -> 'int | Awaitable[int]'
     |      Send ``HIMPORT DISCARDALL`` (returns the number of fieldsets removed).
     |
     |      .. warning::
     |          Internal wire mapping — not for direct use on a pooled client. It
     |          DISCARDs on a single arbitrary borrowed connection and bypasses the
     |          client's shared fieldset registry, leaving other connections and the
     |          registry out of sync. Use the client's ``himport_discard_all`` instead;
     |          call this only on a pinned single-connection client where you manage
     |          session state yourself.
     |
     |  himport_discard_internal(self, fieldset_name: 'str') -> 'int | Awaitable[int]'
     |      Send ``HIMPORT DISCARD fieldset_name`` (``1`` removed, ``0`` not found).
     |
     |      .. warning::
     |          Internal wire mapping — not for direct use on a pooled client. It
     |          DISCARDs on a single arbitrary borrowed connection and bypasses the
     |          client's shared fieldset registry, leaving other connections and the
     |          registry out of sync. Use the client's ``himport_discard`` instead; call
     |          this only on a pinned single-connection client where you manage session
     |          state yourself.
     |
     |  himport_prepare_internal(self, fieldset_name: 'str', fields: 'Iterable[FieldT]') -> 'bool | Awaitable[bool]'
     |      Send ``HIMPORT PREPARE fieldset_name field [field ...]``.
     |
     |      Registers the ordered field list under ``fieldset_name`` in the executing
     |      connection's session. Fields are sent in the caller's order, unmodified.
     |
     |      .. warning::
     |          Internal wire mapping — not for direct use on a pooled client. It
     |          PREPAREs on a single arbitrary borrowed connection and bypasses the
     |          client's shared fieldset registry, so other connections stay unaware and
     |          reintroduce the nondeterministic "no such fieldset" the HIMPORT design
     |          prevents. Use the client's ``himport_prepare`` instead; call this only
     |          on a pinned single-connection client where you manage session state
     |          yourself.
     |
     |  himport_set(self, key: 'KeyT', fieldset_name: 'str', values: 'Iterable[EncodableT]') -> 'bool | Awaitable[bool]'
     |      Create/replace ``key`` as a hash using ``fieldset_name``'s field list.
     |
     |      Values are sent in the caller's order and map positionally to the prepared
     |      fields. The fieldset is prepared on the serving connection on first use
     |      (PREPARE bundled with SET in one write) and reused on subsequent calls;
     |      runtime discards are reconciled on the next use of the connection. All of
     |      this happens inside the normal command path, so retry, disconnect-on-error
     |      and (for the cluster) routing / MOVED-ASK apply exactly as for any command.
     |
     |      .. note::
     |          Recovery from a mid-connection fieldset loss (the server dropping the
     |          prepared fieldset without dropping the socket, e.g. ``RESET`` or
     |          ``maxmemory-clients`` eviction) applies only to a standalone
     |          ``himport_set`` call: it catches the resulting ``no such fieldset`` and
     |          re-prepares on the same socket, retrying the SET once. A ``himport_set``
     |          buffered in a **pipeline or transaction** has no such per-command
     |          recovery — its fieldset is PREPAREd once as a pre-flight before the
     |          batch, and if the server loses it between that pre-flight and the batch
     |          the SET fails and surfaces as an error in the batch results. Callers who
     |          need the automatic recovery should issue those sets outside a pipeline.
     |
     |  hincrby(self, name: 'KeyT', key: 'FieldT', amount: 'int' = 1) -> 'int | Awaitable[int]'
     |      Increment the value of ``key`` in hash ``name`` by ``amount``
     |
     |      For more information, see https://redis.io/commands/hincrby
     |
     |  hincrbyfloat(self, name: 'KeyT', key: 'FieldT', amount: 'float' = 1.0) -> 'float | Awaitable[float]'
     |      Increment the value of ``key`` in hash ``name`` by floating ``amount``
     |
     |      For more information, see https://redis.io/commands/hincrbyfloat
     |
     |  hkeys(self, name: 'KeyT') -> 'list[bytes | str] | Awaitable[list[bytes | str]]'
     |      Return the list of keys within hash ``name``
     |
     |      For more information, see https://redis.io/commands/hkeys
     |
     |  hlen(self, name: 'KeyT') -> 'int | Awaitable[int]'
     |      Return the number of elements in hash ``name``
     |
     |      For more information, see https://redis.io/commands/hlen
     |
     |  hmget(self, name: 'KeyT', keys: 'FieldT | Iterable[FieldT]', *args: 'FieldT') -> 'list[bytes | str | None] | Awaitable[list[bytes | str | None]]'
     |      Returns a list of values ordered identically to ``keys``
     |
     |      For more information, see https://redis.io/commands/hmget
     |
     |  hmset(self, name: 'KeyT', mapping: 'Mapping[FieldT, EncodableT]') -> 'bool | Awaitable[bool]'
     |      Set key to value within hash ``name`` for each corresponding
     |      key and value from the ``mapping`` dict.
     |
     |      For more information, see https://redis.io/commands/hmset
     |
     |  hpersist(self, name: 'KeyT', *fields: 'FieldT') -> 'list[int] | Awaitable[list[int]]'
     |      Removes the expiration time for each specified field in a hash.
     |
     |      For more information, see https://redis.io/commands/hpersist
     |
     |      Args:
     |          name: The name of the hash key.
     |          fields: A list of fields within the hash from which to remove the
     |                  expiration time.
     |
     |      Returns:
     |          Returns a list which contains for each field in the request:
     |              - `-2` if the field does not exist, or if the key does not exist.
     |              - `-1` if the field exists but has no associated expiration time.
     |              - `1` if the expiration time was successfully removed from the field.
     |
     |  hpexpire(self, name: 'KeyT', milliseconds: 'ExpiryT', *fields: 'FieldT', nx: 'bool' = False, xx: 'bool' = False, gt: 'bool' = False, lt: 'bool' = False) -> 'list[int] | Awaitable[list[int]]'
     |      Sets or updates the expiration time for fields within a hash key, using relative
     |      time in milliseconds.
     |
     |      If a field already has an expiration time, the behavior of the update can be
     |      controlled using the `nx`, `xx`, `gt`, and `lt` parameters.
     |
     |      The return value provides detailed information about the outcome for each field.
     |
     |      For more information, see https://redis.io/commands/hpexpire
     |
     |      Args:
     |          name: The name of the hash key.
     |          milliseconds: Expiration time in milliseconds, relative. Can be an integer,
     |                        or a Python `timedelta` object.
     |          fields: List of fields within the hash to apply the expiration time to.
     |          nx: Set expiry only when the field has no expiry.
     |          xx: Set expiry only when the field has an existing expiry.
     |          gt: Set expiry only when the new expiry is greater than the current one.
     |          lt: Set expiry only when the new expiry is less than the current one.
     |
     |      Returns:
     |          Returns a list which contains for each field in the request:
     |              - `-2` if the field does not exist, or if the key does not exist.
     |              - `0` if the specified NX | XX | GT | LT condition was not met.
     |              - `1` if the expiration time was set or updated.
     |              - `2` if the field was deleted because the specified expiration time is
     |                in the past.
     |
     |  hpexpireat(self, name: 'KeyT', unix_time_milliseconds: 'AbsExpiryT', *fields: 'FieldT', nx: 'bool' = False, xx: 'bool' = False, gt: 'bool' = False, lt: 'bool' = False) -> 'list[int] | Awaitable[list[int]]'
     |      Sets or updates the expiration time for fields within a hash key, using an
     |      absolute Unix timestamp in milliseconds.
     |
     |      If a field already has an expiration time, the behavior of the update can be
     |      controlled using the `nx`, `xx`, `gt`, and `lt` parameters.
     |
     |      The return value provides detailed information about the outcome for each field.
     |
     |      For more information, see https://redis.io/commands/hpexpireat
     |
     |      Args:
     |          name: The name of the hash key.
     |          unix_time_milliseconds: Expiration time as Unix timestamp in milliseconds.
     |                                  Can be an integer or a Python `datetime` object.
     |          fields: List of fields within the hash to apply the expiry.
     |          nx: Set expiry only when the field has no expiry.
     |          xx: Set expiry only when the field has an existing expiry.
     |          gt: Set expiry only when the new expiry is greater than the current one.
     |          lt: Set expiry only when the new expiry is less than the current one.
     |
     |      Returns:
     |          Returns a list which contains for each field in the request:
     |              - `-2` if the field does not exist, or if the key does not exist.
     |              - `0` if the specified NX | XX | GT | LT condition was not met.
     |              - `1` if the expiration time was set or updated.
     |              - `2` if the field was deleted because the specified expiration time is
     |                in the past.
     |
     |  hpexpiretime(self, key: 'KeyT', *fields: 'FieldT') -> 'list[int] | Awaitable[list[int]]'
     |      Returns the expiration times of hash fields as Unix timestamps in milliseconds.
     |
     |      For more information, see https://redis.io/commands/hpexpiretime
     |
     |      Args:
     |          key: The hash key.
     |          fields: A list of fields within the hash for which to get the expiration
     |                  time.
     |
     |      Returns:
     |          Returns a list which contains for each field in the request:
     |              - `-2` if the field does not exist, or if the key does not exist.
     |              - `-1` if the field exists but has no associated expire time.
     |              - A positive integer representing the expiration Unix timestamp in
     |                milliseconds, if the field has an associated expiration time.
     |
     |  hpttl(self, key: 'KeyT', *fields: 'FieldT') -> 'list[int] | Awaitable[list[int]]'
     |      Returns the TTL (Time To Live) in milliseconds for each specified field within a
     |      hash key.
     |
     |      For more information, see https://redis.io/commands/hpttl
     |
     |      Args:
     |          key: The hash key.
     |          fields: A list of fields within the hash for which to get the TTL.
     |
     |      Returns:
     |          Returns a list which contains for each field in the request:
     |              - `-2` if the field does not exist, or if the key does not exist.
     |              - `-1` if the field exists but has no associated expire time.
     |              - A positive integer representing the TTL in milliseconds if the field
     |                has an associated expiration time.
     |
     |  hset(self, name: 'KeyT', key: 'FieldT | None' = None, value: 'EncodableT | None' = None, mapping: 'Mapping[FieldT, EncodableT] | None' = None, items: 'Sequence[EncodableT] | None' = None) -> 'int | Awaitable[int]'
     |      Set ``key`` to ``value`` within hash ``name``,
     |      ``mapping`` accepts a dict of key/value pairs that will be
     |      added to hash ``name``.
     |      ``items`` accepts a list of key/value pairs that will be
     |      added to hash ``name``.
     |      Returns the number of fields that were added.
     |
     |      For more information, see https://redis.io/commands/hset
     |
     |  hsetex(self, name: 'KeyT', key: 'FieldT | None' = None, value: 'EncodableT | None' = None, mapping: 'Mapping[FieldT, EncodableT] | None' = None, items: 'Sequence[EncodableT] | None' = None, ex: 'ExpiryT | None' = None, px: 'ExpiryT | None' = None, exat: 'AbsExpiryT | None' = None, pxat: 'AbsExpiryT | None' = None, data_persist_option: 'HashDataPersistOptions | None' = None, keepttl: 'bool' = False) -> 'int | Awaitable[int]'
     |      Set ``key`` to ``value`` within hash ``name``
     |
     |      ``mapping`` accepts a dict of key/value pairs that will be
     |      added to hash ``name``.
     |
     |      ``items`` accepts a list of key/value pairs that will be
     |      added to hash ``name``.
     |
     |      ``ex`` sets an expire flag on ``keys`` for ``ex`` seconds.
     |
     |      ``px`` sets an expire flag on ``keys`` for ``px`` milliseconds.
     |
     |      ``exat`` sets an expire flag on ``keys`` for ``ex`` seconds,
     |          specified in unix time.
     |
     |      ``pxat`` sets an expire flag on ``keys`` for ``ex`` milliseconds,
     |          specified in unix time.
     |
     |      ``data_persist_option`` can be set to ``FNX`` or ``FXX`` to control the
     |          behavior of the command.
     |          ``FNX`` will set the value for each provided key to each
     |              provided value only if all do not already exist.
     |          ``FXX`` will set the value for each provided key to each
     |              provided value only if all already exist.
     |
     |      ``keepttl`` if True, retain the time to live associated with the keys.
     |
     |      Returns the number of fields that were added.
     |
     |      Available since Redis 8.0
     |      For more information, see https://redis.io/commands/hsetex
     |
     |  hsetnx(self, name: 'KeyT', key: 'FieldT', value: 'EncodableT') -> 'int | Awaitable[int]'
     |      Set ``key`` to ``value`` within hash ``name`` if ``key`` does not
     |      exist.  Returns 1 if HSETNX created a field, otherwise 0.
     |
     |      For more information, see https://redis.io/commands/hsetnx
     |
     |  hstrlen(self, name: 'KeyT', key: 'FieldT') -> 'int | Awaitable[int]'
     |      Return the number of bytes stored in the value of ``key``
     |      within hash ``name``
     |
     |      For more information, see https://redis.io/commands/hstrlen
     |
     |  httl(self, key: 'KeyT', *fields: 'FieldT') -> 'list[int] | Awaitable[list[int]]'
     |      Returns the TTL (Time To Live) in seconds for each specified field within a hash
     |      key.
     |
     |      For more information, see https://redis.io/commands/httl
     |
     |      Args:
     |          key: The hash key.
     |          fields: A list of fields within the hash for which to get the TTL.
     |
     |      Returns:
     |          Returns a list which contains for each field in the request:
     |              - `-2` if the field does not exist, or if the key does not exist.
     |              - `-1` if the field exists but has no associated expire time.
     |              - A positive integer representing the TTL in seconds if the field has
     |                an associated expiration time.
     |
     |  hvals(self, name: 'KeyT') -> 'list[bytes | str] | Awaitable[list[bytes | str]]'
     |      Return the list of values within hash ``name``
     |
     |      For more information, see https://redis.io/commands/hvals
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from redis.commands.core.GeoCommands:
     |
     |  geoadd(self, name: 'KeyT', values: 'Sequence[EncodableT]', nx: 'bool' = False, xx: 'bool' = False, ch: 'bool' = False) -> 'int | Awaitable[int]'
     |      Add the specified geospatial items to the specified key identified
     |      by the ``name`` argument. The Geospatial items are given as ordered
     |      members of the ``values`` argument, each item or place is formed by
     |      the triad longitude, latitude and name.
     |
     |      Note: You can use ZREM to remove elements.
     |
     |      ``nx`` forces ZADD to only create new elements and not to update
     |      scores for elements that already exist.
     |
     |      ``xx`` forces ZADD to only update scores of elements that already
     |      exist. New elements will not be added.
     |
     |      ``ch`` modifies the return value to be the numbers of elements changed.
     |      Changed elements include new elements that were added and elements
     |      whose scores changed.
     |
     |      For more information, see https://redis.io/commands/geoadd
     |
     |  geodist(self, name: 'KeyT', place1: 'FieldT', place2: 'FieldT', unit: 'str | None' = None) -> 'float | None | Awaitable[float | None]'
     |      Return the distance between ``place1`` and ``place2`` members of the
     |      ``name`` key.
     |      The units must be one of the following : m, km mi, ft. By default
     |      meters are used.
     |
     |      For more information, see https://redis.io/commands/geodist
     |
     |  geohash(self, name: 'KeyT', *values: 'FieldT') -> 'list[bytes | str | None] | Awaitable[list[bytes | str | None]]'
     |      Return the geo hash string for each item of ``values`` members of
     |      the specified key identified by the ``name`` argument.
     |
     |      For more information, see https://redis.io/commands/geohash
     |
     |  geopos(self, name: 'KeyT', *values: 'FieldT') -> 'list[GeoCoordinate | None] | Awaitable[list[GeoCoordinate | None]]'
     |      Return the positions of each item of ``values`` as members of
     |      the specified key identified by the ``name`` argument. Each position
     |      is represented by the pairs lon and lat.
     |
     |      For more information, see https://redis.io/commands/geopos
     |
     |  georadius(self, name: 'KeyT', longitude: 'float', latitude: 'float', radius: 'float', unit: 'str | None' = None, withdist: 'bool' = False, withcoord: 'bool' = False, withhash: 'bool' = False, count: 'int | None' = None, sort: 'str | None' = None, store: 'KeyT | None' = None, store_dist: 'KeyT | None' = None, any: 'bool' = False) -> 'GeoRadiusResponse | Awaitable[GeoRadiusResponse]'
     |      Return the members of the specified key identified by the
     |      ``name`` argument which are within the borders of the area specified
     |      with the ``latitude`` and ``longitude`` location and the maximum
     |      distance from the center specified by the ``radius`` value.
     |
     |      The units must be one of the following : m, km mi, ft. By default
     |
     |      ``withdist`` indicates to return the distances of each place.
     |
     |      ``withcoord`` indicates to return the latitude and longitude of
     |      each place.
     |
     |      ``withhash`` indicates to return the geohash string of each place.
     |
     |      ``count`` indicates to return the number of elements up to N.
     |
     |      ``sort`` indicates to return the places in a sorted way, ASC for
     |      nearest to fairest and DESC for fairest to nearest.
     |
     |      ``store`` indicates to save the places names in a sorted set named
     |      with a specific key, each element of the destination sorted set is
     |      populated with the score got from the original geo sorted set.
     |
     |      ``store_dist`` indicates to save the places names in a sorted set
     |      named with a specific key, instead of ``store`` the sorted set
     |      destination score is set with the distance.
     |
     |      For more information, see https://redis.io/commands/georadius
     |
     |  georadiusbymember(self, name: 'KeyT', member: 'FieldT', radius: 'float', unit: 'str | None' = None, withdist: 'bool' = False, withcoord: 'bool' = False, withhash: 'bool' = False, count: 'int | None' = None, sort: 'str | None' = None, store: 'Union[KeyT, None]' = None, store_dist: 'Union[KeyT, None]' = None, any: 'bool' = False) -> 'GeoRadiusResponse | Awaitable[GeoRadiusResponse]'
     |      This command is exactly like ``georadius`` with the sole difference
     |      that instead of taking, as the center of the area to query, a longitude
     |      and latitude value, it takes the name of a member already existing
     |      inside the geospatial index represented by the sorted set.
     |
     |      For more information, see https://redis.io/commands/georadiusbymember
     |
     |  geosearch(self, name: 'KeyT', member: 'FieldT | None' = None, longitude: 'float | None' = None, latitude: 'float | None' = None, unit: 'str' = 'm', radius: 'float | None' = None, width: 'float | None' = None, height: 'float | None' = None, sort: 'str | None' = None, count: 'int | None' = None, any: 'bool' = False, withcoord: 'bool' = False, withdist: 'bool' = False, withhash: 'bool' = False) -> 'GeoSearchResponse | Awaitable[GeoSearchResponse]'
     |      Return the members of specified key identified by the
     |      ``name`` argument, which are within the borders of the
     |      area specified by a given shape. This command extends the
     |      GEORADIUS command, so in addition to searching within circular
     |      areas, it supports searching within rectangular areas.
     |
     |      This command should be used in place of the deprecated
     |      GEORADIUS and GEORADIUSBYMEMBER commands.
     |
     |      ``member`` Use the position of the given existing
     |       member in the sorted set. Can't be given with ``longitude``
     |       and ``latitude``.
     |
     |      ``longitude`` and ``latitude`` Use the position given by
     |      this coordinates. Can't be given with ``member``
     |      ``radius`` Similar to GEORADIUS, search inside circular
     |      area according the given radius. Can't be given with
     |      ``height`` and ``width``.
     |      ``height`` and ``width`` Search inside an axis-aligned
     |      rectangle, determined by the given height and width.
     |      Can't be given with ``radius``
     |
     |      ``unit`` must be one of the following : m, km, mi, ft.
     |      `m` for meters (the default value), `km` for kilometers,
     |      `mi` for miles and `ft` for feet.
     |
     |      ``sort`` indicates to return the places in a sorted way,
     |      ASC for nearest to furthest and DESC for furthest to nearest.
     |
     |      ``count`` limit the results to the first count matching items.
     |
     |      ``any`` is set to True, the command will return as soon as
     |      enough matches are found. Can't be provided without ``count``
     |
     |      ``withdist`` indicates to return the distances of each place.
     |      ``withcoord`` indicates to return the latitude and longitude of
     |      each place.
     |
     |      ``withhash`` indicates to return the geohash string of each place.
     |
     |      For more information, see https://redis.io/commands/geosearch
     |
     |  geosearchstore(self, dest: 'KeyT', name: 'KeyT', member: 'FieldT | None' = None, longitude: 'float | None' = None, latitude: 'float | None' = None, unit: 'str' = 'm', radius: 'float | None' = None, width: 'float | None' = None, height: 'float | None' = None, sort: 'str | None' = None, count: 'int | None' = None, any: 'bool' = False, storedist: 'bool' = False) -> 'int | Awaitable[int]'
     |      This command is like GEOSEARCH, but stores the result in
     |      ``dest``. By default, it stores the results in the destination
     |      sorted set with their geospatial information.
     |      if ``store_dist`` set to True, the command will stores the
     |      items in a sorted set populated with their distance from the
     |      center of the circle or box, as a floating-point number.
     |
     |      For more information, see https://redis.io/commands/geosearchstore
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from redis.commands.core.ListCommands:
     |
     |  blmpop(self, timeout: 'float', numkeys: 'int', *args: 'str', direction: 'str', count: 'int | None' = 1) -> 'ListMultiPopResponse | Awaitable[ListMultiPopResponse]'
     |      Pop ``count`` values (default 1) from first non-empty in the list
     |      of provided key names.
     |
     |      When all lists are empty this command blocks the connection until another
     |      client pushes to it or until the timeout, timeout of 0 blocks indefinitely
     |
     |      For more information, see https://redis.io/commands/blmpop
     |
     |  blpop(self, keys: 'KeysT', timeout: 'Number | None' = 0) -> 'BlockingListPopResponse | Awaitable[BlockingListPopResponse]'
     |      LPOP a value off of the first non-empty list
     |      named in ``keys``.
     |
     |      If none of the lists in ``keys`` has a value to LPOP, then block
     |      for ``timeout`` seconds, or until a value gets pushed on to one
     |      of the lists.
     |
     |      If timeout is 0, then block indefinitely.
     |
     |      For more information, see https://redis.io/commands/blpop
     |
     |  brpop(self, keys: 'KeysT', timeout: 'Number | None' = 0) -> 'BlockingListPopResponse | Awaitable[BlockingListPopResponse]'
     |      RPOP a value off of the first non-empty list
     |      named in ``keys``.
     |
     |      If none of the lists in ``keys`` has a value to RPOP, then block
     |      for ``timeout`` seconds, or until a value gets pushed on to one
     |      of the lists.
     |
     |      If timeout is 0, then block indefinitely.
     |
     |      For more information, see https://redis.io/commands/brpop
     |
     |  brpoplpush(self, src: 'KeyT', dst: 'KeyT', timeout: 'Number | None' = 0) -> 'bytes | str | None | Awaitable[bytes | str | None]'
     |      Pop a value off the tail of ``src``, push it on the head of ``dst``
     |      and then return it.
     |
     |      This command blocks until a value is in ``src`` or until ``timeout``
     |      seconds elapse, whichever is first. A ``timeout`` value of 0 blocks
     |      forever.
     |
     |      For more information, see https://redis.io/commands/brpoplpush
     |
     |  lindex(self, name: 'KeyT', index: 'int') -> 'bytes | str | None | Awaitable[bytes | str | None]'
     |      Return the item from list ``name`` at position ``index``
     |
     |      Negative indexes are supported and will return an item at the
     |      end of the list
     |
     |      For more information, see https://redis.io/commands/lindex
     |
     |  linsert(self, name: 'KeyT', where: 'str', refvalue: 'str', value: 'str') -> 'int | Awaitable[int]'
     |      Insert ``value`` in list ``name`` either immediately before or after
     |      [``where``] ``refvalue``
     |
     |      Returns the new length of the list on success or -1 if ``refvalue``
     |      is not in the list.
     |
     |      For more information, see https://redis.io/commands/linsert
     |
     |  llen(self, name: 'KeyT') -> 'int | Awaitable[int]'
     |      Return the length of the list ``name``
     |
     |      For more information, see https://redis.io/commands/llen
     |
     |  lmpop(self, num_keys: 'int', *args: 'str', direction: 'str', count: 'int | None' = 1) -> 'ListMultiPopResponse | Awaitable[ListMultiPopResponse]'
     |      Pop ``count`` values (default 1) first non-empty list key from the list
     |      of args provided key names.
     |
     |      For more information, see https://redis.io/commands/lmpop
     |
     |  lpop(self, name: 'KeyT', count: 'int | None' = None) -> 'bytes | str | list[bytes | str] | None | Awaitable[bytes | str | list[bytes | str] | None]'
     |      Removes and returns the first elements of the list ``name``.
     |
     |      By default, the command pops a single element from the beginning of
     |      the list. When provided with the optional ``count`` argument, the reply
     |      will consist of up to count elements, depending on the list's length.
     |
     |      For more information, see https://redis.io/commands/lpop
     |
     |  lpos(self, name: 'KeyT', value: 'str', rank: 'int | None' = None, count: 'int | None' = None, maxlen: 'int | None' = None) -> 'int | list[int] | None | Awaitable[int | list[int] | None]'
     |      Get position of ``value`` within the list ``name``
     |
     |       If specified, ``rank`` indicates the "rank" of the first element to
     |       return in case there are multiple copies of ``value`` in the list.
     |       By default, LPOS returns the position of the first occurrence of
     |       ``value`` in the list. When ``rank`` 2, LPOS returns the position of
     |       the second ``value`` in the list. If ``rank`` is negative, LPOS
     |       searches the list in reverse. For example, -1 would return the
     |       position of the last occurrence of ``value`` and -2 would return the
     |       position of the next to last occurrence of ``value``.
     |
     |       If specified, ``count`` indicates that LPOS should return a list of
     |       up to ``count`` positions. A ``count`` of 2 would return a list of
     |       up to 2 positions. A ``count`` of 0 returns a list of all positions
     |       matching ``value``. When ``count`` is specified and but ``value``
     |       does not exist in the list, an empty list is returned.
     |
     |       If specified, ``maxlen`` indicates the maximum number of list
     |       elements to scan. A ``maxlen`` of 1000 will only return the
     |       position(s) of items within the first 1000 entries in the list.
     |       A ``maxlen`` of 0 (the default) will scan the entire list.
     |
     |       For more information, see https://redis.io/commands/lpos
     |
     |  lpush(self, name: 'KeyT', *values: 'FieldT') -> 'int | Awaitable[int]'
     |      Push ``values`` onto the head of the list ``name``
     |
     |      For more information, see https://redis.io/commands/lpush
     |
     |  lpushx(self, name: 'KeyT', *values: 'FieldT') -> 'int | Awaitable[int]'
     |      Push ``value`` onto the head of the list ``name`` if ``name`` exists
     |
     |      For more information, see https://redis.io/commands/lpushx
     |
     |  lrange(self, name: 'KeyT', start: 'int', end: 'int') -> 'list[bytes | str] | Awaitable[list[bytes | str]]'
     |      Return a slice of the list ``name`` between
     |      position ``start`` and ``end``
     |
     |      ``start`` and ``end`` can be negative numbers just like
     |      Python slicing notation
     |
     |      For more information, see https://redis.io/commands/lrange
     |
     |  lrem(self, name: 'KeyT', count: 'int', value: 'str') -> 'int | Awaitable[int]'
     |      Remove the first ``count`` occurrences of elements equal to ``value``
     |      from the list stored at ``name``.
     |
     |      The count argument influences the operation in the following ways:
     |          count > 0: Remove elements equal to value moving from head to tail.
     |          count < 0: Remove elements equal to value moving from tail to head.
     |          count = 0: Remove all elements equal to value.
     |
     |          For more information, see https://redis.io/commands/lrem
     |
     |  lset(self, name: 'KeyT', index: 'int', value: 'str') -> 'bool | Awaitable[bool]'
     |      Set element at ``index`` of list ``name`` to ``value``
     |
     |      For more information, see https://redis.io/commands/lset
     |
     |  ltrim(self, name: 'KeyT', start: 'int', end: 'int') -> 'bool | Awaitable[bool]'
     |      Trim the list ``name``, removing all values not within the slice
     |      between ``start`` and ``end``
     |
     |      ``start`` and ``end`` can be negative numbers just like
     |      Python slicing notation
     |
     |      For more information, see https://redis.io/commands/ltrim
     |
     |  rpop(self, name: 'KeyT', count: 'int | None' = None) -> 'bytes | str | list[bytes | str] | None | Awaitable[bytes | str | list[bytes | str] | None]'
     |      Removes and returns the last elements of the list ``name``.
     |
     |      By default, the command pops a single element from the end of the list.
     |      When provided with the optional ``count`` argument, the reply will
     |      consist of up to count elements, depending on the list's length.
     |
     |      For more information, see https://redis.io/commands/rpop
     |
     |  rpoplpush(self, src: 'KeyT', dst: 'KeyT') -> 'bytes | str | None | Awaitable[bytes | str | None]'
     |      RPOP a value off of the ``src`` list and atomically LPUSH it
     |      on to the ``dst`` list.  Returns the value.
     |
     |      For more information, see https://redis.io/commands/rpoplpush
     |
     |  rpush(self, name: 'KeyT', *values: 'FieldT') -> 'int | Awaitable[int]'
     |      Push ``values`` onto the tail of the list ``name``
     |
     |      For more information, see https://redis.io/commands/rpush
     |
     |  rpushx(self, name: 'KeyT', *values: 'str') -> 'int | Awaitable[int]'
     |      Push ``value`` onto the tail of the list ``name`` if ``name`` exists
     |
     |      For more information, see https://redis.io/commands/rpushx
     |
     |  sort(self, name: 'KeyT', start: 'int | None' = None, num: 'int | None' = None, by: 'str | None' = None, get: 'list[str] | None' = None, desc: 'bool' = False, alpha: 'bool' = False, store: 'str | None' = None, groups: 'bool | None' = False) -> 'SortResponse | Awaitable[SortResponse]'
     |      Sort and return the list, set or sorted set at ``name``.
     |
     |      ``start`` and ``num`` allow for paging through the sorted data
     |
     |      ``by`` allows using an external key to weight and sort the items.
     |          Use an "*" to indicate where in the key the item value is located
     |
     |      ``get`` allows for returning items from external keys rather than the
     |          sorted data itself.  Use an "*" to indicate where in the key
     |          the item value is located
     |
     |      ``desc`` allows for reversing the sort
     |
     |      ``alpha`` allows for sorting lexicographically rather than numerically
     |
     |      ``store`` allows for storing the result of the sort into
     |          the key ``store``
     |
     |      ``groups`` if set to True and if ``get`` contains at least two
     |          elements, sort will return a list of tuples, each containing the
     |          values fetched from the arguments to ``get``.
     |
     |      For more information, see https://redis.io/commands/sort
     |
     |  sort_ro(self, key: 'str', start: 'int | None' = None, num: 'int | None' = None, by: 'str | None' = None, get: 'list[str] | None' = None, desc: 'bool' = False, alpha: 'bool' = False) -> 'list[bytes | str] | Awaitable[list[bytes | str]]'
     |      Returns the elements contained in the list, set or sorted set at key.
     |      (read-only variant of the SORT command)
     |
     |      ``start`` and ``num`` allow for paging through the sorted data
     |
     |      ``by`` allows using an external key to weight and sort the items.
     |          Use an "*" to indicate where in the key the item value is located
     |
     |      ``get`` allows for returning items from external keys rather than the
     |          sorted data itself.  Use an "*" to indicate where in the key
     |          the item value is located
     |
     |      ``desc`` allows for reversing the sort
     |
     |      ``alpha`` allows for sorting lexicographically rather than numerically
     |
     |      For more information, see https://redis.io/commands/sort_ro
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from redis.commands.core.ArrayCommands:
     |
     |  arcount(self, name: 'KeyT') -> 'int | Awaitable[int]'
     |      Return the number of non-empty elements in the array stored at
     |      ``name``. Returns 0 if ``name`` does not exist.
     |
     |      For more information, see https://redis.io/commands/arcount
     |
     |  ardel(self, name: 'KeyT', *indices: 'int') -> 'int | Awaitable[int]'
     |      Delete elements at the specified ``indices`` in the array stored at
     |      ``name``. Deleting an index that does not exist counts as zero
     |      elements deleted and does not modify the array.
     |
     |      Returns the number of elements deleted.
     |
     |      For more information, see https://redis.io/commands/ardel
     |
     |  ardelrange(self, name: 'KeyT', *ranges: 'tuple[int, int]') -> 'int | Awaitable[int]'
     |      Delete elements within one or more inclusive index ranges in the
     |      array stored at ``name``. Each range is a ``(start, end)`` tuple.
     |      If ``start`` is greater than ``end`` for a given pair, the range is
     |      processed in ascending order regardless. Multiple pairs may overlap;
     |      each element is counted at most once.
     |
     |      Returns the number of elements deleted.
     |
     |      For more information, see https://redis.io/commands/ardelrange
     |
     |  arget(self, name: 'KeyT', index: 'int') -> 'bytes | str | None | Awaitable[bytes | str | None]'
     |      Return the value at ``index`` in the array stored at ``name``.
     |
     |      Returns ``None`` if ``name`` does not exist or no value is set at
     |      ``index``.
     |
     |      For more information, see https://redis.io/commands/arget
     |
     |  argetrange(self, name: 'KeyT', start: 'int', end: 'int') -> 'list[bytes | str | None] | Awaitable[list[bytes | str | None]]'
     |      Return the values in the inclusive index range [``start``, ``end``]
     |      in the array stored at ``name``. If ``start`` is greater than ``end``,
     |      elements are returned in reverse index order.
     |
     |      For more information, see https://redis.io/commands/argetrange
     |
     |  argrep(self, name: 'KeyT', start: 'int', end: 'int', predicates: 'list[tuple[ArrayPredicateType, EncodableT]]', combinator: 'ArrayPredicateCombinator | None' = None, limit: 'int | None' = None, withvalues: 'bool' = False, nocase: 'bool' = False) -> 'list[int] | list[list[int | bytes | str]] | Awaitable[list[int] | list[list[int | bytes | str]]]'
     |      Search elements of the array stored at ``name`` within the inclusive
     |      index range [``start``, ``end``] using one or more textual
     |      ``predicates``. Each predicate is a ``(type, value)`` tuple where
     |      ``type`` is a member of ``ArrayPredicateType``
     |      (``EXACT``, ``MATCH``, ``GLOB``, ``RE``).
     |
     |      Multiple predicates are combined via ``combinator``
     |      (``ArrayPredicateCombinator.AND`` or ``OR``); the server defaults to
     |      OR when omitted. ``limit`` caps the number of matches.
     |      ``withvalues=True`` returns a list of ``[index, value]`` pairs
     |      (``[[idx, val], ...]``) instead of a flat list of indices.
     |      ``nocase=True`` makes all comparisons case-insensitive.
     |
     |      Without ``withvalues``, returns a flat list of matching indices in
     |      traversal order. With ``withvalues``, returns a list of
     |      ``[index, value]`` pairs in traversal order. Empty slots are
     |      skipped.
     |
     |      For more information, see https://redis.io/commands/argrep
     |
     |  arinfo(self, name: 'KeyT', full: 'bool' = False) -> 'dict[str, int] | Awaitable[dict[str, int]]'
     |      Return metadata about the array stored at ``name`` as a dictionary.
     |      When ``full`` is ``True``, additionally include per-slice statistics
     |      (dense/sparse slice counts, average sizes, fill rates), which makes
     |      the call O(N) instead of O(1).
     |
     |      Raises ``ResponseError`` when the key does not exist.
     |
     |      For more information, see https://redis.io/commands/arinfo
     |
     |  arinsert(self, name: 'KeyT', *values: 'FieldT') -> 'int | Awaitable[int]'
     |      Insert one or more ``values`` at consecutive indices in the array
     |      stored at ``name``, beginning at the current insert cursor position.
     |      The cursor advances by one for each value inserted. Use ``ARNEXT``
     |      to inspect the current cursor position and ``ARSEEK`` to reposition
     |      it.
     |
     |      Returns the last index where a value was inserted.
     |
     |      For more information, see https://redis.io/commands/arinsert
     |
     |  arlastitems(self, name: 'KeyT', count: 'int', rev: 'bool' = False) -> 'list[bytes | str | None] | Awaitable[list[bytes | str | None]]'
     |      Return up to ``count`` most recently inserted elements from the array
     |      stored at ``name``. If the array contains fewer elements than
     |      ``count``, all elements are returned.
     |
     |      When ``rev`` is ``True``, elements are returned in reverse
     |      chronological order (most recent first) instead of the default
     |      oldest-first order.
     |
     |      For more information, see https://redis.io/commands/arlastitems
     |
     |  arlen(self, name: 'KeyT') -> 'int | Awaitable[int]'
     |      Return the length of the array stored at ``name``, defined as the
     |      maximum set index plus one. Returns 0 if ``name`` does not exist.
     |
     |      For more information, see https://redis.io/commands/arlen
     |
     |  armget(self, name: 'KeyT', *indices: 'int') -> 'list[bytes | str | None] | Awaitable[list[bytes | str | None]]'
     |      Return the values at the specified ``indices`` in the array stored at
     |      ``name``. The reply preserves the order of the requested indices and
     |      returns ``None`` for any index that is not set or when ``name`` does
     |      not exist.
     |
     |      For more information, see https://redis.io/commands/armget
     |
     |  armset(self, name: 'KeyT', mapping: 'Mapping[int, FieldT]') -> 'int | Awaitable[int]'
     |      Set multiple index/value pairs in the array stored at ``name``.
     |      ``mapping`` is a dictionary of zero-based integer indices to values.
     |      Pairs may be non-contiguous and in any order.
     |
     |      Returns the number of new slots that were set (previously empty).
     |
     |      For more information, see https://redis.io/commands/armset
     |
     |  arnext(self, name: 'KeyT') -> 'int | None | Awaitable[int | None]'
     |      Return the next index ``ARINSERT`` would use for the array stored at
     |      ``name``. Returns 0 if ``name`` does not exist or no insert happened
     |      yet, and ``None`` when the insertion cursor is exhausted (next insert
     |      would overflow).
     |
     |      For more information, see https://redis.io/commands/arnext
     |
     |  arop(self, name: 'KeyT', start: 'int', end: 'int', operation: 'ArrayAggregateOperations', value: 'EncodableT | None' = None) -> 'bytes | str | int | None | Awaitable[bytes | str | int | None]'
     |      Perform an aggregate ``operation`` on elements of the array stored at
     |      ``name`` in the inclusive index range [``start``, ``end``]. The range
     |      is always scanned from the lower to the higher index regardless of
     |      argument order.
     |
     |      ``operation`` is one of the members of ``ArrayAggregateOperations``.
     |      ``value`` is required when ``operation`` is
     |      ``ArrayAggregateOperations.MATCH`` and specifies the value to compare
     |      against.
     |
     |      Returns a bulk string for ``SUM``, ``MIN`` and ``MAX``, an integer
     |      for ``AND``, ``OR``, ``XOR``, ``MATCH`` and ``USED``, or ``None``
     |      when no elements match the operation.
     |
     |      For more information, see https://redis.io/commands/arop
     |
     |  arring(self, name: 'KeyT', size: 'int', *values: 'FieldT') -> 'int | Awaitable[int]'
     |      Insert one or more ``values`` into the array stored at ``name`` as a
     |      fixed-size ring buffer of ``size`` slots. Each value is placed at
     |      ``insert_idx % size``, wrapping back to index 0 once the end is
     |      reached and overwriting older values when full. If ``size`` is
     |      smaller than the current window, the array is truncated to fit.
     |
     |      Returns the last index where a value was inserted.
     |
     |      For more information, see https://redis.io/commands/arring
     |
     |  arscan(self, name: 'KeyT', start: 'int', end: 'int', limit: 'int | None' = None) -> 'list[list[int | bytes | str]] | Awaitable[list[list[int | bytes | str]]]'
     |      Iterate populated elements of the array stored at ``name`` in the
     |      inclusive range [``start``, ``end``] and return a list of
     |      ``[index, value]`` pairs in traversal order:
     |      ``[[idx1, val1], [idx2, val2], ...]``. Empty slots are skipped. If
     |      ``start`` is greater than ``end``, the iteration is reversed.
     |
     |      ``limit`` caps the number of populated elements returned. When
     |      omitted, all populated elements in range are returned.
     |
     |      For more information, see https://redis.io/commands/arscan
     |
     |  arseek(self, name: 'KeyT', index: 'int') -> 'int | Awaitable[int]'
     |      Set the insert cursor of the array stored at ``name`` to ``index``.
     |      Subsequent ``ARINSERT`` and ``ARRING`` operations begin inserting at
     |      this position.
     |
     |      Returns 1 if the cursor was set, 0 if ``name`` does not exist.
     |
     |      For more information, see https://redis.io/commands/arseek
     |
     |  arset(self, name: 'KeyT', index: 'int', *values: 'FieldT') -> 'int | Awaitable[int]'
     |      Set one or more contiguous ``values`` in the array stored at ``name``
     |      starting at ``index``. When multiple values are provided, they are
     |      stored at consecutive indices beginning at ``index``.
     |
     |      Returns the number of new slots that were set (previously empty).
     |
     |      For more information, see https://redis.io/commands/arset
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from redis.commands.core.ScanCommands:
     |
     |  hscan(self, name: 'KeyT', cursor: 'int' = 0, match: 'PatternT | None' = None, count: 'int | None' = None, no_values: 'bool | None' = None) -> 'HScanResponse | Awaitable[HScanResponse]'
     |      Incrementally return key/value slices in a hash. Also return a cursor
     |      indicating the scan position.
     |
     |      ``match`` allows for filtering the keys by pattern
     |
     |      ``count`` allows for hint the minimum number of returns
     |
     |      ``no_values`` indicates to return only the keys, without values.
     |
     |      For more information, see https://redis.io/commands/hscan
     |
     |  hscan_iter(self, name: 'KeyT', match: 'Union[PatternT, None]' = None, count: 'Optional[int]' = None, no_values: 'Union[bool, None]' = None) -> 'Iterator'
     |      Make an iterator using the HSCAN command so that the client doesn't
     |      need to remember the cursor position.
     |
     |      ``match`` allows for filtering the keys by pattern
     |
     |      ``count`` allows for hint the minimum number of returns
     |
     |      ``no_values`` indicates to return only the keys, without values
     |
     |  scan(self, cursor: 'int' = 0, match: 'PatternT | None' = None, count: 'int | None' = None, _type: 'str | None' = None, **kwargs) -> 'ScanResponse | Awaitable[ScanResponse]'
     |      Incrementally return lists of key names. Also return a cursor
     |      indicating the scan position.
     |
     |      ``match`` allows for filtering the keys by pattern
     |
     |      ``count`` provides a hint to Redis about the number of keys to
     |          return per batch.
     |
     |      ``_type`` filters the returned values by a particular Redis type.
     |          Stock Redis instances allow for the following types:
     |          HASH, LIST, SET, STREAM, STRING, ZSET
     |          Additionally, Redis modules can expose other types as well.
     |
     |      For more information, see https://redis.io/commands/scan
     |
     |  scan_iter(self, match: 'Union[PatternT, None]' = None, count: 'Optional[int]' = None, _type: 'Optional[str]' = None, **kwargs) -> 'Iterator'
     |      Make an iterator using the SCAN command so that the client doesn't
     |      need to remember the cursor position.
     |
     |      ``match`` allows for filtering the keys by pattern
     |
     |      ``count`` provides a hint to Redis about the number of keys to
     |          return per batch.
     |
     |      ``_type`` filters the returned values by a particular Redis type.
     |          Stock Redis instances allow for the following types:
     |          HASH, LIST, SET, STREAM, STRING, ZSET
     |          Additionally, Redis modules can expose other types as well.
     |
     |  sscan(self, name: 'KeyT', cursor: 'int' = 0, match: 'PatternT | None' = None, count: 'int | None' = None) -> 'ScanResponse | Awaitable[ScanResponse]'
     |      Incrementally return lists of elements in a set. Also return a cursor
     |      indicating the scan position.
     |
     |      ``match`` allows for filtering the keys by pattern
     |
     |      ``count`` allows for hint the minimum number of returns
     |
     |      For more information, see https://redis.io/commands/sscan
     |
     |  sscan_iter(self, name: 'KeyT', match: 'Union[PatternT, None]' = None, count: 'Optional[int]' = None) -> 'Iterator'
     |      Make an iterator using the SSCAN command so that the client doesn't
     |      need to remember the cursor position.
     |
     |      ``match`` allows for filtering the keys by pattern
     |
     |      ``count`` allows for hint the minimum number of returns
     |
     |  zscan(self, name: 'KeyT', cursor: 'int' = 0, match: 'PatternT | None' = None, count: 'int | None' = None, score_cast_func: 'type | Callable' = <class 'float'>) -> 'ZScanResponse | Awaitable[ZScanResponse]'
     |      Incrementally return lists of elements in a sorted set. Also return a
     |      cursor indicating the scan position.
     |
     |      ``match`` allows for filtering the keys by pattern
     |
     |      ``count`` allows for hint the minimum number of returns
     |
     |      ``score_cast_func`` a callable used to cast the score return value
     |
     |      For more information, see https://redis.io/commands/zscan
     |
     |  zscan_iter(self, name: 'KeyT', match: 'Union[PatternT, None]' = None, count: 'Optional[int]' = None, score_cast_func: 'Union[type, Callable]' = <class 'float'>) -> 'Iterator'
     |      Make an iterator using the ZSCAN command so that the client doesn't
     |      need to remember the cursor position.
     |
     |      ``match`` allows for filtering the keys by pattern
     |
     |      ``count`` allows for hint the minimum number of returns
     |
     |      ``score_cast_func`` a callable used to cast the score return value
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from redis.commands.core.SetCommands:
     |
     |  sadd(self, name: 'KeyT', *values: 'FieldT') -> 'int | Awaitable[int]'
     |      Add ``value(s)`` to set ``name``
     |
     |      For more information, see https://redis.io/commands/sadd
     |
     |  scard(self, name: 'KeyT') -> 'int | Awaitable[int]'
     |      Return the number of elements in set ``name``
     |
     |      For more information, see https://redis.io/commands/scard
     |
     |  sdiff(self, keys: 'List', *args: 'List') -> 'set[bytes | str] | Awaitable[set[bytes | str]]'
     |      Return the difference of sets specified by ``keys``
     |
     |      For more information, see https://redis.io/commands/sdiff
     |
     |  sdiffcard(self, numkeys: 'int', keys: 'List[KeyT]', limit: 'int' = 0) -> 'int | Awaitable[int]'
     |      Return the cardinality of the difference between the first set and all
     |      the successive sets specified by ``keys``, without returning the
     |      difference itself.
     |
     |      When LIMIT is provided (defaults to 0 and means unlimited), the returned
     |      cardinality is capped at ``limit`` and the server may stop the
     |      computation once the capped result is known.
     |
     |      For more information, see https://redis.io/commands/sdiffcard
     |
     |  sdiffstore(self, dest: 'str', keys: 'List', *args: 'List') -> 'int | Awaitable[int]'
     |      Store the difference of sets specified by ``keys`` into a new
     |      set named ``dest``.  Returns the number of keys in the new set.
     |
     |      For more information, see https://redis.io/commands/sdiffstore
     |
     |  sinter(self, keys: 'List', *args: 'List') -> 'set[bytes | str] | Awaitable[set[bytes | str]]'
     |      Return the intersection of sets specified by ``keys``
     |
     |      For more information, see https://redis.io/commands/sinter
     |
     |  sintercard(self, numkeys: 'int', keys: 'List[KeyT]', limit: 'int' = 0) -> 'int | Awaitable[int]'
     |      Return the cardinality of the intersect of multiple sets specified by ``keys``.
     |
     |      When LIMIT provided (defaults to 0 and means unlimited), if the intersection
     |      cardinality reaches limit partway through the computation, the algorithm will
     |      exit and yield limit as the cardinality
     |
     |      For more information, see https://redis.io/commands/sintercard
     |
     |  sinterstore(self, dest: 'KeyT', keys: 'List', *args: 'List') -> 'int | Awaitable[int]'
     |      Store the intersection of sets specified by ``keys`` into a new
     |      set named ``dest``.  Returns the number of keys in the new set.
     |
     |      For more information, see https://redis.io/commands/sinterstore
     |
     |  sismember(self, name: 'KeyT', value: 'str') -> 'Literal[0] | Literal[1] | Awaitable[Literal[0] | Literal[1]]'
     |      Return whether ``value`` is a member of set ``name``:
     |      - 1 if the value is a member of the set.
     |      - 0 if the value is not a member of the set or if key does not exist.
     |
     |      For more information, see https://redis.io/commands/sismember
     |
     |  smembers(self, name: 'KeyT') -> 'set[bytes | str] | Awaitable[set[bytes | str]]'
     |      Return all members of the set ``name``
     |
     |      For more information, see https://redis.io/commands/smembers
     |
     |  smismember(self, name: 'KeyT', values: 'List', *args: 'List') -> 'list[Literal[0] | Literal[1]] | Awaitable[list[Literal[0] | Literal[1]]]'
     |      Return whether each value in ``values`` is a member of the set ``name``
     |      as a list of ``int`` in the order of ``values``:
     |      - 1 if the value is a member of the set.
     |      - 0 if the value is not a member of the set or if key does not exist.
     |
     |      For more information, see https://redis.io/commands/smismember
     |
     |  smove(self, src: 'KeyT', dst: 'KeyT', value: 'str') -> 'bool | Awaitable[bool]'
     |      Move ``value`` from set ``src`` to set ``dst`` atomically
     |
     |      For more information, see https://redis.io/commands/smove
     |
     |  spop(self, name: 'KeyT', count: 'int | None' = None) -> 'bytes | str | set[bytes | str] | None | Awaitable[bytes | str | set[bytes | str] | None]'
     |      Remove and return a random member of set ``name``
     |
     |      For more information, see https://redis.io/commands/spop
     |
     |  srandmember(self, name: 'KeyT', number: 'int | None' = None) -> 'bytes | str | list[bytes | str] | None | Awaitable[bytes | str | list[bytes | str] | None]'
     |      If ``number`` is None, returns a random member of set ``name``.
     |
     |      If ``number`` is supplied, returns a list of ``number`` random
     |      members of set ``name``. Note this is only available when running
     |      Redis 2.6+.
     |
     |      For more information, see https://redis.io/commands/srandmember
     |
     |  srem(self, name: 'KeyT', *values: 'FieldT') -> 'int | Awaitable[int]'
     |      Remove ``values`` from set ``name``
     |
     |      For more information, see https://redis.io/commands/srem
     |
     |  sunion(self, keys: 'List', *args: 'List') -> 'set[bytes | str] | Awaitable[set[bytes | str]]'
     |      Return the union of sets specified by ``keys``
     |
     |      For more information, see https://redis.io/commands/sunion
     |
     |  sunioncard(self, numkeys: 'int', keys: 'List[KeyT]', limit: 'int' = 0, approx: 'bool' = False) -> 'int | Awaitable[int]'
     |      Return the cardinality of the union of multiple sets specified by
     |      ``keys``, without returning the union itself.
     |
     |      When ``approx`` is True, the ``APPROX`` option is sent and the server
     |      returns an approximate cardinality computed using HyperLogLog.
     |
     |      When LIMIT is provided (defaults to 0 and means unlimited), the returned
     |      cardinality is capped at ``limit``. In exact mode the result equals
     |      ``limit`` when the real cardinality exceeds ``limit``; in approximate
     |      mode the result will not exceed ``limit``. Options are emitted in the
     |      canonical order ``APPROX`` before ``LIMIT``.
     |
     |      For more information, see https://redis.io/commands/sunioncard
     |
     |  sunionstore(self, dest: 'KeyT', keys: 'List', *args: 'List') -> 'int | Awaitable[int]'
     |      Store the union of sets specified by ``keys`` into a new
     |      set named ``dest``.  Returns the number of keys in the new set.
     |
     |      For more information, see https://redis.io/commands/sunionstore
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from redis.commands.core.StreamCommands:
     |
     |  xack(self, name: 'KeyT', groupname: 'GroupT', *ids: 'StreamIdT') -> 'int | Awaitable[int]'
     |      Acknowledges the successful processing of one or more messages.
     |
     |      Args:
     |          name: name of the stream.
     |          groupname: name of the consumer group.
     |          *ids: message ids to acknowledge.
     |
     |      For more information, see https://redis.io/commands/xack
     |
     |  xackdel(self, name: 'KeyT', groupname: 'GroupT', *ids: 'StreamIdT', ref_policy: "Literal['KEEPREF', 'DELREF', 'ACKED']" = 'KEEPREF') -> 'int | Awaitable[int]'
     |      Combines the functionality of XACK and XDEL. Acknowledges the specified
     |      message IDs in the given consumer group and simultaneously attempts to
     |      delete the corresponding entries from the stream.
     |
     |  xadd(self, name: 'KeyT', fields: 'Dict[FieldT, EncodableT]', id: 'StreamIdT' = '*', maxlen: 'Optional[int]' = None, approximate: 'bool' = True, nomkstream: 'bool' = False, minid: 'Union[StreamIdT, None]' = None, limit: 'int | None' = None, ref_policy: "Literal['KEEPREF', 'DELREF', 'ACKED'] | None" = None, idmpauto: 'str | None' = None, idmp: 'tuple[str, bytes] | None' = None) -> 'bytes | str | Awaitable[bytes | str]'
     |      Add to a stream.
     |      name: name of the stream
     |      fields: dict of field/value pairs to insert into the stream
     |      id: Location to insert this record. By default it is appended.
     |      maxlen: truncate old stream members beyond this size.
     |      Can't be specified with minid.
     |      approximate: actual stream length may be slightly more than maxlen
     |      nomkstream: When set to true, do not make a stream
     |      minid: the minimum id in the stream to query.
     |      Can't be specified with maxlen.
     |      limit: specifies the maximum number of entries to retrieve
     |      ref_policy: optional reference policy for consumer groups when trimming:
     |          - KEEPREF (default): When trimming, preserves references in consumer groups' PEL
     |          - DELREF: When trimming, removes all references from consumer groups' PEL
     |          - ACKED: When trimming, only removes entries acknowledged by all consumer groups
     |      idmpauto: Producer ID for automatic idempotent ID calculation.
     |          Automatically calculates an idempotent ID based on entry content to prevent
     |          duplicate entries. Can only be used with id='*'. Creates an IDMP map if it
     |          doesn't exist yet. The producer ID must be unique per producer and consistent
     |          across restarts.
     |      idmp: Tuple of (producer_id, idempotent_id) for explicit idempotent ID.
     |          Uses a specific idempotent ID to prevent duplicate entries. Can only be used
     |          with id='*'. The producer ID must be unique per producer and consistent across
     |          restarts. The idempotent ID must be unique per message and per producer.
     |          Shorter idempotent IDs require less memory and allow faster processing.
     |          Creates an IDMP map if it doesn't exist yet.
     |
     |      For more information, see https://redis.io/commands/xadd
     |
     |  xautoclaim(self, name: 'KeyT', groupname: 'GroupT', consumername: 'ConsumerT', min_idle_time: 'int', start_id: 'StreamIdT' = '0-0', count: 'int | None' = None, justid: 'bool' = False) -> 'list[Any] | Awaitable[list[Any]]'
     |      Transfers ownership of pending stream entries that match the specified
     |      criteria. Conceptually, equivalent to calling XPENDING and then XCLAIM,
     |      but provides a more straightforward way to deal with message delivery
     |      failures via SCAN-like semantics.
     |      name: name of the stream.
     |      groupname: name of the consumer group.
     |      consumername: name of a consumer that claims the message.
     |      min_idle_time: filter messages that were idle less than this amount of
     |      milliseconds.
     |      start_id: filter messages with equal or greater ID.
     |      count: optional integer, upper limit of the number of entries that the
     |      command attempts to claim. Set to 100 by default.
     |      justid: optional boolean, false by default. Return just an array of IDs
     |      of messages successfully claimed, without returning the actual message
     |
     |      For more information, see https://redis.io/commands/xautoclaim
     |
     |  xcfgset(self, name: 'KeyT', idmp_duration: 'int | None' = None, idmp_maxsize: 'int | None' = None) -> 'bytes | str | Awaitable[bytes | str]'
     |      Configure the idempotency parameters for a stream's IDMP map.
     |
     |      Sets how long Redis remembers each idempotent ID (iid) and the maximum
     |      number of iids to track. This command clears the existing IDMP map
     |      (Redis forgets all previously stored iids), but only if the configuration
     |      value actually changes.
     |
     |      Args:
     |          name: The name of the stream.
     |          idmp_duration: How long Redis remembers each iid in seconds.
     |              Default: 100 seconds (or value set by stream-idmp-duration config).
     |              Minimum: 1 second, Maximum: 300 seconds.
     |              Redis won't forget an iid for this duration (unless maxsize is reached).
     |              Should accommodate application crash recovery time.
     |          idmp_maxsize: Maximum number of iids Redis remembers per producer ID (pid).
     |              Default: 100 iids (or value set by stream-idmp-maxsize config).
     |              Minimum: 1 iid, Maximum: 1,000,000 (1M) iids.
     |              Should be set to: mark-delay [in msec] × (messages/msec) + margin.
     |              Example: 10K msgs/sec (10 msgs/msec), 80 msec mark-delay
     |              → maxsize = 10 × 80 + margin = 1000 iids.
     |
     |      Returns:
     |          OK on success.
     |
     |      For more information, see https://redis.io/commands/xcfgset
     |
     |  xclaim(self, name: 'KeyT', groupname: 'GroupT', consumername: 'ConsumerT', min_idle_time: 'int', message_ids: 'Union[List[StreamIdT], Tuple[StreamIdT]]', idle: 'int | None' = None, time: 'int | None' = None, retrycount: 'int | None' = None, force: 'bool' = False, justid: 'bool' = False) -> 'XClaimResponse | Awaitable[XClaimResponse]'
     |      Changes the ownership of a pending message.
     |
     |      name: name of the stream.
     |
     |      groupname: name of the consumer group.
     |
     |      consumername: name of a consumer that claims the message.
     |
     |      min_idle_time: filter messages that were idle less than this amount of
     |      milliseconds
     |
     |      message_ids: non-empty list or tuple of message IDs to claim
     |
     |      idle: optional. Set the idle time (last time it was delivered) of the
     |      message in ms
     |
     |      time: optional integer. This is the same as idle but instead of a
     |      relative amount of milliseconds, it sets the idle time to a specific
     |      Unix time (in milliseconds).
     |
     |      retrycount: optional integer. set the retry counter to the specified
     |      value. This counter is incremented every time a message is delivered
     |      again.
     |
     |      force: optional boolean, false by default. Creates the pending message
     |      entry in the PEL even if certain specified IDs are not already in the
     |      PEL assigned to a different client.
     |
     |      justid: optional boolean, false by default. Return just an array of IDs
     |      of messages successfully claimed, without returning the actual message
     |
     |      For more information, see https://redis.io/commands/xclaim
     |
     |  xdel(self, name: 'KeyT', *ids: 'StreamIdT') -> 'int | Awaitable[int]'
     |      Deletes one or more messages from a stream.
     |
     |      Args:
     |          name: name of the stream.
     |          *ids: message ids to delete.
     |
     |      For more information, see https://redis.io/commands/xdel
     |
     |  xdelex(self, name: 'KeyT', *ids: 'StreamIdT', ref_policy: "Literal['KEEPREF', 'DELREF', 'ACKED']" = 'KEEPREF') -> 'int | Awaitable[int]'
     |      Extended version of XDEL that provides more control over how message entries
     |      are deleted concerning consumer groups.
     |
     |  xgroup_create(self, name: 'KeyT', groupname: 'GroupT', id: 'StreamIdT' = '$', mkstream: 'bool' = False, entries_read: 'int | None' = None) -> 'bool | Awaitable[bool]'
     |      Create a new consumer group associated with a stream.
     |      name: name of the stream.
     |      groupname: name of the consumer group.
     |      id: ID of the last item in the stream to consider already delivered.
     |
     |      For more information, see https://redis.io/commands/xgroup-create
     |
     |  xgroup_createconsumer(self, name: 'KeyT', groupname: 'GroupT', consumername: 'ConsumerT') -> 'int | Awaitable[int]'
     |      Consumers in a consumer group are auto-created every time a new
     |      consumer name is mentioned by some command.
     |      They can be explicitly created by using this command.
     |      name: name of the stream.
     |      groupname: name of the consumer group.
     |      consumername: name of consumer to create.
     |
     |      See: https://redis.io/commands/xgroup-createconsumer
     |
     |  xgroup_delconsumer(self, name: 'KeyT', groupname: 'GroupT', consumername: 'ConsumerT') -> 'int | Awaitable[int]'
     |      Remove a specific consumer from a consumer group.
     |      Returns the number of pending messages that the consumer had before it
     |      was deleted.
     |      name: name of the stream.
     |      groupname: name of the consumer group.
     |      consumername: name of consumer to delete
     |
     |      For more information, see https://redis.io/commands/xgroup-delconsumer
     |
     |  xgroup_destroy(self, name: 'KeyT', groupname: 'GroupT') -> 'bool | Awaitable[bool]'
     |      Destroy a consumer group.
     |      name: name of the stream.
     |      groupname: name of the consumer group.
     |
     |      For more information, see https://redis.io/commands/xgroup-destroy
     |
     |  xgroup_setid(self, name: 'KeyT', groupname: 'GroupT', id: 'StreamIdT', entries_read: 'int | None' = None) -> 'bool | Awaitable[bool]'
     |      Set the consumer group last delivered ID to something else.
     |      name: name of the stream.
     |      groupname: name of the consumer group.
     |      id: ID of the last item in the stream to consider already delivered.
     |
     |      For more information, see https://redis.io/commands/xgroup-setid
     |
     |  xinfo_consumers(self, name: 'KeyT', groupname: 'GroupT') -> 'list[dict[str, Any]] | Awaitable[list[dict[str, Any]]]'
     |      Returns general information about the consumers in the group.
     |      name: name of the stream.
     |      groupname: name of the consumer group.
     |
     |      For more information, see https://redis.io/commands/xinfo-consumers
     |
     |  xinfo_groups(self, name: 'KeyT') -> 'list[dict[str, Any]] | Awaitable[list[dict[str, Any]]]'
     |      Returns general information about the consumer groups of the stream.
     |      name: name of the stream.
     |
     |      For more information, see https://redis.io/commands/xinfo-groups
     |
     |  xinfo_stream(self, name: 'KeyT', full: 'bool' = False) -> 'dict[str, Any] | Awaitable[dict[str, Any]]'
     |      Returns general information about the stream.
     |      name: name of the stream.
     |      full: optional boolean, false by default. Return full summary
     |
     |      For more information, see https://redis.io/commands/xinfo-stream
     |
     |  xlen(self, name: 'KeyT') -> 'int | Awaitable[int]'
     |      Returns the number of elements in a given stream.
     |
     |      For more information, see https://redis.io/commands/xlen
     |
     |  xnack(self, name: 'KeyT', groupname: 'GroupT', mode: "Literal['SILENT', 'FAIL', 'FATAL']", *ids: 'StreamIdT', retrycount: 'int | None' = None, force: 'bool' = False) -> 'int | Awaitable[int]'
     |      Negatively acknowledges one or more messages in a consumer group's
     |      Pending Entries List (PEL).
     |
     |      Args:
     |          name: name of the stream.
     |          groupname: name of the consumer group.
     |          mode: the nacking mode. One of SILENT, FAIL, or FATAL.
     |              SILENT: consumer shutting down; decrements delivery counter.
     |              FAIL: consumer unable to process; delivery counter unchanged.
     |              FATAL: invalid/malicious message; delivery counter set to max.
     |          *ids: one or more message IDs to NACK.
     |          retrycount: optional integer >= 0. Overrides the mode's implicit
     |              delivery counter adjustment with an exact value.
     |          force: if True, creates a new unowned PEL entry for any ID not
     |              already in the group's PEL.
     |
     |      Returns:
     |          The number of messages successfully NACKed.
     |
     |      For more information, see https://redis.io/commands/xnack
     |
     |  xpending(self, name: 'KeyT', groupname: 'GroupT') -> 'dict[str, Any] | Awaitable[dict[str, Any]]'
     |      Returns information about pending messages of a group.
     |      name: name of the stream.
     |      groupname: name of the consumer group.
     |
     |      For more information, see https://redis.io/commands/xpending
     |
     |  xpending_range(self, name: 'KeyT', groupname: 'GroupT', min: 'StreamIdT', max: 'StreamIdT', count: 'int', consumername: 'ConsumerT | None' = None, idle: 'int | None' = None) -> 'XPendingRangeResponse | Awaitable[XPendingRangeResponse]'
     |      Returns information about pending messages, in a range.
     |
     |      name: name of the stream.
     |      groupname: name of the consumer group.
     |      idle: available from  version 6.2. filter entries by their
     |      idle-time, given in milliseconds (optional).
     |      min: minimum stream ID.
     |      max: maximum stream ID.
     |      count: number of messages to return
     |      consumername: name of a consumer to filter by (optional).
     |
     |  xrange(self, name: 'KeyT', min: 'StreamIdT' = '-', max: 'StreamIdT' = '+', count: 'int | None' = None) -> 'StreamRangeResponse | None | Awaitable[StreamRangeResponse | None]'
     |      Read stream values within an interval.
     |
     |      name: name of the stream.
     |
     |      start: first stream ID. defaults to '-',
     |             meaning the earliest available.
     |
     |      finish: last stream ID. defaults to '+',
     |              meaning the latest available.
     |
     |      count: if set, only return this many items, beginning with the
     |             earliest available.
     |
     |      For more information, see https://redis.io/commands/xrange
     |
     |  xread(self, streams: 'Dict[KeyT, StreamIdT]', count: 'int | None' = None, block: 'int | None' = None, max_count: 'int | None' = None, max_size: 'int | None' = None) -> 'XReadResponse | Awaitable[XReadResponse]'
     |      Block and monitor multiple streams for new data.
     |
     |      streams: a dict of stream names to stream IDs, where
     |                 IDs indicate the last ID already seen.
     |
     |      count: if set, only return this many items per stream, beginning with
     |             the earliest available.
     |
     |      block: number of milliseconds to wait, if nothing already present.
     |
     |      max_count: if set, cap the total number of entries returned across all
     |                 streams combined. Unlike ``count`` (a per-stream limit),
     |                 this is a cumulative cap over the whole reply. Must be a
     |                 positive integer and, when ``count`` is also set, must be
     |                 greater than or equal to ``count``. Requires Redis >= 8.10.0.
     |
     |      max_size: if set, a soft cap on the total server reply size in bytes
     |                across all streams combined. Measured server-side including
     |                protocol overhead, so it is not an exact application-payload
     |                size guarantee; a single available entry larger than the cap
     |                may still be returned. Must be a positive integer. Requires
     |                Redis >= 8.10.0.
     |
     |      For more information, see https://redis.io/commands/xread
     |
     |  xreadgroup(self, groupname: 'str', consumername: 'str', streams: 'Dict[KeyT, StreamIdT]', count: 'int | None' = None, block: 'int | None' = None, noack: 'bool' = False, claim_min_idle_time: 'int | None' = None, max_count: 'int | None' = None, max_size: 'int | None' = None) -> 'XReadGroupResponse | Awaitable[XReadGroupResponse]'
     |      Read from a stream via a consumer group.
     |
     |      groupname: name of the consumer group.
     |
     |      consumername: name of the requesting consumer.
     |
     |      streams: a dict of stream names to stream IDs, where
     |             IDs indicate the last ID already seen.
     |
     |      count: if set, only return this many items per stream, beginning with
     |             the earliest available.
     |
     |      block: number of milliseconds to wait, if nothing already present.
     |      noack: do not add messages to the PEL
     |
     |      claim_min_idle_time: accepts an integer type and represents a
     |                           time interval in milliseconds
     |
     |      max_count: if set, cap the total number of entries returned across all
     |                 streams combined. Unlike ``count`` (a per-stream limit),
     |                 this is a cumulative cap over the whole reply. Must be a
     |                 positive integer and, when ``count`` is also set, must be
     |                 greater than or equal to ``count``. Requires Redis 8.10.0.
     |
     |      max_size: if set, a soft cap on the total server reply size in bytes
     |                across all streams combined. Measured server-side including
     |                protocol overhead, so it is not an exact application-payload
     |                size guarantee; a single available entry larger than the cap
     |                may still be returned. Must be a positive integer. Requires
     |                Redis 8.10.0.
     |
     |      For more information, see https://redis.io/commands/xreadgroup
     |
     |  xrevrange(self, name: 'KeyT', max: 'StreamIdT' = '+', min: 'StreamIdT' = '-', count: 'int | None' = None) -> 'StreamRangeResponse | None | Awaitable[StreamRangeResponse | None]'
     |      Read stream values within an interval, in reverse order.
     |
     |      name: name of the stream
     |
     |      start: first stream ID. defaults to '+',
     |             meaning the latest available.
     |
     |      finish: last stream ID. defaults to '-',
     |              meaning the earliest available.
     |
     |      count: if set, only return this many items, beginning with the
     |             latest available.
     |
     |      For more information, see https://redis.io/commands/xrevrange
     |
     |  xtrim(self, name: 'KeyT', maxlen: 'int | None' = None, approximate: 'bool' = True, minid: 'StreamIdT | None' = None, limit: 'int | None' = None, ref_policy: "Literal['KEEPREF', 'DELREF', 'ACKED'] | None" = None) -> 'int | Awaitable[int]'
     |      Trims old messages from a stream.
     |      name: name of the stream.
     |      maxlen: truncate old stream messages beyond this size
     |      Can't be specified with minid.
     |      approximate: actual stream length may be slightly more than maxlen
     |      minid: the minimum id in the stream to query
     |      Can't be specified with maxlen.
     |      limit: specifies the maximum number of entries to retrieve
     |      ref_policy: optional reference policy for consumer groups:
     |          - KEEPREF (default): Trims entries but preserves references in consumer groups' PEL
     |          - DELREF: Trims entries and removes all references from consumer groups' PEL
     |          - ACKED: Only trims entries that were read and acknowledged by all consumer groups
     |
     |      For more information, see https://redis.io/commands/xtrim
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from redis.commands.core.SortedSetCommands:
     |
     |  bzmpop(self, timeout: 'float', numkeys: 'int', keys: 'List[str]', min: 'bool | None' = False, max: 'bool | None' = False, count: 'int | None' = 1) -> 'ZMPopResponse | Awaitable[ZMPopResponse]'
     |      Pop ``count`` values (default 1) off of the first non-empty sorted set
     |      named in the ``keys`` list.
     |
     |      If none of the sorted sets in ``keys`` has a value to pop,
     |      then block for ``timeout`` seconds, or until a member gets added
     |      to one of the sorted sets.
     |
     |      If timeout is 0, then block indefinitely.
     |
     |      For more information, see https://redis.io/commands/bzmpop
     |
     |  bzpopmax(self, keys: 'KeysT', timeout: 'TimeoutSecT' = 0) -> 'BlockingZSetPopResponse | Awaitable[BlockingZSetPopResponse]'
     |      ZPOPMAX a value off of the first non-empty sorted set
     |      named in the ``keys`` list.
     |
     |      If none of the sorted sets in ``keys`` has a value to ZPOPMAX,
     |      then block for ``timeout`` seconds, or until a member gets added
     |      to one of the sorted sets.
     |
     |      If timeout is 0, then block indefinitely.
     |
     |      For more information, see https://redis.io/commands/bzpopmax
     |
     |  bzpopmin(self, keys: 'KeysT', timeout: 'TimeoutSecT' = 0) -> 'BlockingZSetPopResponse | Awaitable[BlockingZSetPopResponse]'
     |      ZPOPMIN a value off of the first non-empty sorted set
     |      named in the ``keys`` list.
     |
     |      If none of the sorted sets in ``keys`` has a value to ZPOPMIN,
     |      then block for ``timeout`` seconds, or until a member gets added
     |      to one of the sorted sets.
     |
     |      If timeout is 0, then block indefinitely.
     |
     |      For more information, see https://redis.io/commands/bzpopmin
     |
     |  zadd(self, name: 'KeyT', mapping: 'Mapping[AnyKeyT, EncodableT]', nx: 'bool' = False, xx: 'bool' = False, ch: 'bool' = False, incr: 'bool' = False, gt: 'bool' = False, lt: 'bool' = False) -> 'int | float | None | Awaitable[int | float | None]'
     |      Set any number of element-name, score pairs to the key ``name``. Pairs
     |      are specified as a dict of element-names keys to score values.
     |
     |      ``nx`` forces ZADD to only create new elements and not to update
     |      scores for elements that already exist.
     |
     |      ``xx`` forces ZADD to only update scores of elements that already
     |      exist. New elements will not be added.
     |
     |      ``ch`` modifies the return value to be the numbers of elements changed.
     |      Changed elements include new elements that were added and elements
     |      whose scores changed.
     |
     |      ``incr`` modifies ZADD to behave like ZINCRBY. In this mode only a
     |      single element/score pair can be specified and the score is the amount
     |      the existing score will be incremented by. When using this mode the
     |      return value of ZADD will be the new score of the element.
     |
     |      ``lt`` only updates existing elements if the new score is less than
     |      the current score. This flag doesn't prevent adding new elements.
     |
     |      ``gt`` only updates existing elements if the new score is greater than
     |      the current score. This flag doesn't prevent adding new elements.
     |
     |      The return value of ZADD varies based on the mode specified. With no
     |      options, ZADD returns the number of new elements added to the sorted
     |      set.
     |
     |      ``nx``, ``lt``, and ``gt`` are mutually exclusive options.
     |
     |      See: https://redis.io/commands/ZADD
     |
     |  zcard(self, name: 'KeyT') -> 'int | Awaitable[int]'
     |      Return the number of elements in the sorted set ``name``
     |
     |      For more information, see https://redis.io/commands/zcard
     |
     |  zcount(self, name: 'KeyT', min: 'ZScoreBoundT', max: 'ZScoreBoundT') -> 'int | Awaitable[int]'
     |      Returns the number of elements in the sorted set at key ``name`` with
     |      a score between ``min`` and ``max``.
     |
     |      For more information, see https://redis.io/commands/zcount
     |
     |  zdiff(self, keys: 'KeysT', withscores: 'bool' = False) -> 'ZSetRangeResponse | Awaitable[ZSetRangeResponse]'
     |      Returns the difference between the first and all successive input
     |      sorted sets provided in ``keys``.
     |
     |      For more information, see https://redis.io/commands/zdiff
     |
     |  zdiffstore(self, dest: 'KeyT', keys: 'KeysT') -> 'int | Awaitable[int]'
     |      Computes the difference between the first and all successive input
     |      sorted sets provided in ``keys`` and stores the result in ``dest``.
     |
     |      For more information, see https://redis.io/commands/zdiffstore
     |
     |  zincrby(self, name: 'KeyT', amount: 'float', value: 'EncodableT') -> 'float | None | Awaitable[float | None]'
     |      Increment the score of ``value`` in sorted set ``name`` by ``amount``
     |
     |      For more information, see https://redis.io/commands/zincrby
     |
     |  zinter(self, keys: 'KeysT', aggregate: 'str | None' = None, withscores: 'bool' = False) -> 'ZSetRangeResponse | Awaitable[ZSetRangeResponse]'
     |      Return the intersect of multiple sorted sets specified by ``keys``.
     |
     |      With the ``aggregate`` option, it is possible to specify how the
     |      results of the intersection are aggregated. Available aggregation
     |      modes:
     |
     |      - ``SUM`` (default): the score of an element is summed across the
     |        inputs where it exists.
     |        Score = SUM(score₁×weight₁, score₂×weight₂, ...)
     |      - ``MIN``: the resulting set will contain the minimum score of an
     |        element across the inputs where it exists.
     |        Score = MIN(score₁×weight₁, score₂×weight₂, ...)
     |      - ``MAX``: the resulting set will contain the maximum score of an
     |        element across the inputs where it exists.
     |        Score = MAX(score₁×weight₁, score₂×weight₂, ...)
     |      - ``COUNT``: ignores the original scores and counts weighted set
     |        membership. Each element's score is the sum of the weights of
     |        the input sets that contain it.
     |        Score = SUM(weight₁, weight₂, ...) for sets containing the element.
     |        When all weights are 1 (default), the score equals the number
     |        of input sets containing the element.
     |
     |      For more information, see https://redis.io/commands/zinter
     |
     |  zintercard(self, numkeys: 'int', keys: 'List[str]', limit: 'int' = 0) -> 'int | Awaitable[int]'
     |      Return the cardinality of the intersect of multiple sorted sets
     |      specified by ``keys``.
     |      When LIMIT provided (defaults to 0 and means unlimited), if the intersection
     |      cardinality reaches limit partway through the computation, the algorithm will
     |      exit and yield limit as the cardinality
     |
     |      For more information, see https://redis.io/commands/zintercard
     |
     |  zinterstore(self, dest: 'KeyT', keys: 'Sequence[KeyT] | Mapping[AnyKeyT, float]', aggregate: 'str | None' = None) -> 'int | Awaitable[int]'
     |      Intersect multiple sorted sets specified by ``keys`` into a new
     |      sorted set, ``dest``. Scores in the destination will be aggregated
     |      based on the ``aggregate``.
     |
     |      Available aggregation modes:
     |
     |      - ``SUM`` (default): the score of an element is summed across the
     |        inputs where it exists.
     |        Score = SUM(score₁×weight₁, score₂×weight₂, ...)
     |      - ``MIN``: the resulting set will contain the minimum score of an
     |        element across the inputs where it exists.
     |        Score = MIN(score₁×weight₁, score₂×weight₂, ...)
     |      - ``MAX``: the resulting set will contain the maximum score of an
     |        element across the inputs where it exists.
     |        Score = MAX(score₁×weight₁, score₂×weight₂, ...)
     |      - ``COUNT``: ignores the original scores and counts weighted set
     |        membership. Each element's score is the sum of the weights of
     |        the input sets that contain it.
     |        Score = SUM(weight₁, weight₂, ...) for sets containing the element.
     |        When all weights are 1 (default), the score equals the number
     |        of input sets containing the element.
     |
     |      For more information, see https://redis.io/commands/zinterstore
     |
     |  zlexcount(self, name: 'KeyT', min: 'EncodableT', max: 'EncodableT') -> 'int | Awaitable[int]'
     |      Return the number of items in the sorted set ``name`` between the
     |      lexicographical range ``min`` and ``max``.
     |
     |      For more information, see https://redis.io/commands/zlexcount
     |
     |  zmpop(self, num_keys: 'int', keys: 'List[str]', min: 'bool | None' = False, max: 'bool | None' = False, count: 'int | None' = 1) -> 'ZMPopResponse | Awaitable[ZMPopResponse]'
     |      Pop ``count`` values (default 1) off of the first non-empty sorted set
     |      named in the ``keys`` list.
     |      For more information, see https://redis.io/commands/zmpop
     |
     |  zmscore(self, key: 'KeyT', members: 'List[str]') -> 'list[float | None] | Awaitable[list[float | None]]'
     |      Returns the scores associated with the specified members
     |      in the sorted set stored at key.
     |      ``members`` should be a list of the member name.
     |      Return type is a list of score.
     |      If the member does not exist, a None will be returned
     |      in corresponding position.
     |
     |      For more information, see https://redis.io/commands/zmscore
     |
     |  zpopmax(self, name: 'KeyT', count: 'int | None' = None) -> 'ZSetRangeResponse | Awaitable[ZSetRangeResponse]'
     |      Remove and return up to ``count`` members with the highest scores
     |      from the sorted set ``name``.
     |
     |      For more information, see https://redis.io/commands/zpopmax
     |
     |  zpopmin(self, name: 'KeyT', count: 'int | None' = None) -> 'ZSetRangeResponse | Awaitable[ZSetRangeResponse]'
     |      Remove and return up to ``count`` members with the lowest scores
     |      from the sorted set ``name``.
     |
     |      For more information, see https://redis.io/commands/zpopmin
     |
     |  zrandmember(self, key: 'KeyT', count: 'int | None' = None, withscores: 'bool' = False) -> 'ZRandMemberResponse | Awaitable[ZRandMemberResponse]'
     |      Return a random element from the sorted set value stored at key.
     |
     |      ``count`` if the argument is positive, return an array of distinct
     |      fields. If called with a negative count, the behavior changes and
     |      the command is allowed to return the same field multiple times.
     |      In this case, the number of returned fields is the absolute value
     |      of the specified count.
     |
     |      ``withscores`` The optional WITHSCORES modifier changes the reply so it
     |      includes the respective scores of the randomly selected elements from
     |      the sorted set.
     |
     |      For more information, see https://redis.io/commands/zrandmember
     |
     |  zrange(self, name: 'KeyT', start: 'EncodableT', end: 'EncodableT', desc: 'bool' = False, withscores: 'bool' = False, score_cast_func: 'type | Callable' = <class 'float'>, byscore: 'bool' = False, bylex: 'bool' = False, offset: 'int | None' = None, num: 'int | None' = None) -> 'ZSetRangeResponse | Awaitable[ZSetRangeResponse]'
     |      Return a range of values from sorted set ``name`` between
     |      ``start`` and ``end`` sorted in ascending order.
     |
     |      ``start`` and ``end`` can be negative, indicating the end of the range.
     |
     |      ``desc`` a boolean indicating whether to sort the results in reversed
     |      order.
     |
     |      ``withscores`` indicates to return the scores along with the values.
     |      The return type is a list of (value, score) pairs.
     |
     |      ``score_cast_func`` a callable used to cast the score return value.
     |
     |      ``byscore`` when set to True, returns the range of elements from the
     |      sorted set having scores equal or between ``start`` and ``end``.
     |
     |      ``bylex`` when set to True, returns the range of elements from the
     |      sorted set between the ``start`` and ``end`` lexicographical closed
     |      range intervals.
     |      Valid ``start`` and ``end`` must start with ( or [, in order to specify
     |      whether the range interval is exclusive or inclusive, respectively.
     |
     |      ``offset`` and ``num`` are specified, then return a slice of the range.
     |      Can't be provided when using ``bylex``.
     |
     |      For more information, see https://redis.io/commands/zrange
     |
     |  zrangebylex(self, name: 'KeyT', min: 'EncodableT', max: 'EncodableT', start: 'int | None' = None, num: 'int | None' = None) -> 'list[bytes | str] | Awaitable[list[bytes | str]]'
     |      Return the lexicographical range of values from sorted set ``name``
     |      between ``min`` and ``max``.
     |
     |      If ``start`` and ``num`` are specified, then return a slice of the
     |      range.
     |
     |      For more information, see https://redis.io/commands/zrangebylex
     |
     |  zrangebyscore(self, name: 'KeyT', min: 'ZScoreBoundT', max: 'ZScoreBoundT', start: 'int | None' = None, num: 'int | None' = None, withscores: 'bool' = False, score_cast_func: 'type | Callable' = <class 'float'>) -> 'ZSetRangeResponse | Awaitable[ZSetRangeResponse]'
     |      Return a range of values from the sorted set ``name`` with scores
     |      between ``min`` and ``max``.
     |
     |      If ``start`` and ``num`` are specified, then return a slice
     |      of the range.
     |
     |      ``withscores`` indicates to return the scores along with the values.
     |      The return type is a list of (value, score) pairs
     |
     |      `score_cast_func`` a callable used to cast the score return value
     |
     |      For more information, see https://redis.io/commands/zrangebyscore
     |
     |  zrangestore(self, dest: 'KeyT', name: 'KeyT', start: 'EncodableT', end: 'EncodableT', byscore: 'bool' = False, bylex: 'bool' = False, desc: 'bool' = False, offset: 'int | None' = None, num: 'int | None' = None) -> 'int | Awaitable[int]'
     |      Stores in ``dest`` the result of a range of values from sorted set
     |      ``name`` between ``start`` and ``end`` sorted in ascending order.
     |
     |      ``start`` and ``end`` can be negative, indicating the end of the range.
     |
     |      ``byscore`` when set to True, returns the range of elements from the
     |      sorted set having scores equal or between ``start`` and ``end``.
     |
     |      ``bylex`` when set to True, returns the range of elements from the
     |      sorted set between the ``start`` and ``end`` lexicographical closed
     |      range intervals.
     |      Valid ``start`` and ``end`` must start with ( or [, in order to specify
     |      whether the range interval is exclusive or inclusive, respectively.
     |
     |      ``desc`` a boolean indicating whether to sort the results in reversed
     |      order.
     |
     |      ``offset`` and ``num`` are specified, then return a slice of the range.
     |      Can't be provided when using ``bylex``.
     |
     |      For more information, see https://redis.io/commands/zrangestore
     |
     |  zrank(self, name: 'KeyT', value: 'EncodableT', withscore: 'bool' = False, score_cast_func: 'type | Callable' = <class 'float'>) -> 'int | list[Any] | None | Awaitable[int | list[Any] | None]'
     |      Returns a 0-based value indicating the rank of ``value`` in sorted set
     |      ``name``.
     |      The optional WITHSCORE argument supplements the command's
     |      reply with the score of the element returned.
     |
     |      ``score_cast_func`` a callable used to cast the score return value
     |
     |      For more information, see https://redis.io/commands/zrank
     |
     |  zrem(self, name: 'KeyT', *values: 'FieldT') -> 'int | Awaitable[int]'
     |      Remove member ``values`` from sorted set ``name``
     |
     |      For more information, see https://redis.io/commands/zrem
     |
     |  zremrangebylex(self, name: 'KeyT', min: 'EncodableT', max: 'EncodableT') -> 'int | Awaitable[int]'
     |      Remove all elements in the sorted set ``name`` between the
     |      lexicographical range specified by ``min`` and ``max``.
     |
     |      Returns the number of elements removed.
     |
     |      For more information, see https://redis.io/commands/zremrangebylex
     |
     |  zremrangebyrank(self, name: 'KeyT', min: 'int', max: 'int') -> 'int | Awaitable[int]'
     |      Remove all elements in the sorted set ``name`` with ranks between
     |      ``min`` and ``max``. Values are 0-based, ordered from smallest score
     |      to largest. Values can be negative indicating the highest scores.
     |      Returns the number of elements removed
     |
     |      For more information, see https://redis.io/commands/zremrangebyrank
     |
     |  zremrangebyscore(self, name: 'KeyT', min: 'ZScoreBoundT', max: 'ZScoreBoundT') -> 'int | Awaitable[int]'
     |      Remove all elements in the sorted set ``name`` with scores
     |      between ``min`` and ``max``. Returns the number of elements removed.
     |
     |      For more information, see https://redis.io/commands/zremrangebyscore
     |
     |  zrevrange(self, name: 'KeyT', start: 'int', end: 'int', withscores: 'bool' = False, score_cast_func: 'type | Callable' = <class 'float'>) -> 'ZSetRangeResponse | Awaitable[ZSetRangeResponse]'
     |      Return a range of values from sorted set ``name`` between
     |      ``start`` and ``end`` sorted in descending order.
     |
     |      ``start`` and ``end`` can be negative, indicating the end of the range.
     |
     |      ``withscores`` indicates to return the scores along with the values
     |      The return type is a list of (value, score) pairs
     |
     |      ``score_cast_func`` a callable used to cast the score return value
     |
     |      For more information, see https://redis.io/commands/zrevrange
     |
     |  zrevrangebylex(self, name: 'KeyT', max: 'EncodableT', min: 'EncodableT', start: 'int | None' = None, num: 'int | None' = None) -> 'list[bytes | str] | Awaitable[list[bytes | str]]'
     |      Return the reversed lexicographical range of values from sorted set
     |      ``name`` between ``max`` and ``min``.
     |
     |      If ``start`` and ``num`` are specified, then return a slice of the
     |      range.
     |
     |      For more information, see https://redis.io/commands/zrevrangebylex
     |
     |  zrevrangebyscore(self, name: 'KeyT', max: 'ZScoreBoundT', min: 'ZScoreBoundT', start: 'int | None' = None, num: 'int | None' = None, withscores: 'bool' = False, score_cast_func: 'type | Callable' = <class 'float'>) -> 'ZSetRangeResponse | Awaitable[ZSetRangeResponse]'
     |      Return a range of values from the sorted set ``name`` with scores
     |      between ``min`` and ``max`` in descending order.
     |
     |      If ``start`` and ``num`` are specified, then return a slice
     |      of the range.
     |
     |      ``withscores`` indicates to return the scores along with the values.
     |      The return type is a list of (value, score) pairs
     |
     |      ``score_cast_func`` a callable used to cast the score return value
     |
     |      For more information, see https://redis.io/commands/zrevrangebyscore
     |
     |  zrevrank(self, name: 'KeyT', value: 'EncodableT', withscore: 'bool' = False, score_cast_func: 'type | Callable' = <class 'float'>) -> 'int | list[Any] | None | Awaitable[int | list[Any] | None]'
     |      Returns a 0-based value indicating the descending rank of
     |      ``value`` in sorted set ``name``.
     |      The optional ``withscore`` argument supplements the command's
     |      reply with the score of the element returned.
     |
     |      ``score_cast_func`` a callable used to cast the score return value
     |
     |      For more information, see https://redis.io/commands/zrevrank
     |
     |  zscore(self, name: 'KeyT', value: 'EncodableT') -> 'float | None | Awaitable[float | None]'
     |      Return the score of element ``value`` in sorted set ``name``
     |
     |      For more information, see https://redis.io/commands/zscore
     |
     |  zunion(self, keys: 'Sequence[KeyT] | Mapping[AnyKeyT, float]', aggregate: 'str | None' = None, withscores: 'bool' = False, score_cast_func: 'type | Callable' = <class 'float'>) -> 'ZSetRangeResponse | Awaitable[ZSetRangeResponse]'
     |      Return the union of multiple sorted sets specified by ``keys``.
     |      ``keys`` can be provided as dictionary of keys and their weights.
     |      Scores will be aggregated based on the ``aggregate``, or SUM if
     |      none is provided.
     |
     |      Available aggregation modes:
     |
     |      - ``SUM`` (default): the score of an element is summed across the
     |        inputs where it exists.
     |        Score = SUM(score₁×weight₁, score₂×weight₂, ...)
     |      - ``MIN``: the resulting set will contain the minimum score of an
     |        element across the inputs where it exists.
     |        Score = MIN(score₁×weight₁, score₂×weight₂, ...)
     |      - ``MAX``: the resulting set will contain the maximum score of an
     |        element across the inputs where it exists.
     |        Score = MAX(score₁×weight₁, score₂×weight₂, ...)
     |      - ``COUNT``: ignores the original scores and counts weighted set
     |        membership. Each element's score is the sum of the weights of
     |        the input sets that contain it.
     |        Score = SUM(weight₁, weight₂, ...) for sets containing the element.
     |        When all weights are 1 (default), the score equals the number
     |        of input sets containing the element.
     |
     |      ``score_cast_func`` a callable used to cast the score return value
     |
     |      For more information, see https://redis.io/commands/zunion
     |
     |  zunionstore(self, dest: 'KeyT', keys: 'Sequence[KeyT] | Mapping[AnyKeyT, float]', aggregate: 'str | None' = None) -> 'int | Awaitable[int]'
     |      Union multiple sorted sets specified by ``keys`` into
     |      a new sorted set, ``dest``. Scores in the destination will be
     |      aggregated based on the ``aggregate``, or SUM if none is provided.
     |
     |      Available aggregation modes:
     |
     |      - ``SUM`` (default): the score of an element is summed across the
     |        inputs where it exists.
     |        Score = SUM(score₁×weight₁, score₂×weight₂, ...)
     |      - ``MIN``: the resulting set will contain the minimum score of an
     |        element across the inputs where it exists.
     |        Score = MIN(score₁×weight₁, score₂×weight₂, ...)
     |      - ``MAX``: the resulting set will contain the maximum score of an
     |        element across the inputs where it exists.
     |        Score = MAX(score₁×weight₁, score₂×weight₂, ...)
     |      - ``COUNT``: ignores the original scores and counts weighted set
     |        membership. Each element's score is the sum of the weights of
     |        the input sets that contain it.
     |        Score = SUM(weight₁, weight₂, ...) for sets containing the element.
     |        When all weights are 1 (default), the score equals the number
     |        of input sets containing the element.
     |
     |      For more information, see https://redis.io/commands/zunionstore
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from redis.commands.core.ManagementCommands:
     |
     |  auth(self, password: 'str', username: 'str | None' = None, **kwargs) -> 'bool | Awaitable[bool]'
     |      Authenticates the user. If you do not pass username, Redis will try to
     |      authenticate for the "default" user. If you do pass username, it will
     |      authenticate for the given user.
     |      For more information, see https://redis.io/commands/auth
     |
     |  bgrewriteaof(self, **kwargs) -> 'bool | bytes | str | Awaitable[bool | bytes | str]'
     |      Tell the Redis server to rewrite the AOF file from data in memory.
     |
     |      For more information, see https://redis.io/commands/bgrewriteaof
     |
     |  bgsave(self, schedule: 'bool' = True, **kwargs) -> 'bool | bytes | str | Awaitable[bool | bytes | str]'
     |      Tell the Redis server to save its data to disk.  Unlike save(),
     |      this method is asynchronous and returns immediately.
     |
     |      For more information, see https://redis.io/commands/bgsave
     |
     |  client_getname(self, **kwargs) -> 'bytes | str | None | Awaitable[bytes | str | None]'
     |      Returns the current connection name
     |
     |      For more information, see https://redis.io/commands/client-getname
     |
     |  client_getredir(self, **kwargs) -> 'int | Awaitable[int]'
     |      Returns the ID (an integer) of the client to whom we are
     |      redirecting tracking notifications.
     |
     |      see: https://redis.io/commands/client-getredir
     |
     |  client_id(self, **kwargs) -> 'int | Awaitable[int]'
     |      Returns the current connection id
     |
     |      For more information, see https://redis.io/commands/client-id
     |
     |  client_info(self, **kwargs) -> 'dict[str, str | int] | Awaitable[dict[str, str | int]]'
     |      Returns information and statistics about the current
     |      client connection.
     |
     |      For more information, see https://redis.io/commands/client-info
     |
     |  client_kill(self, address: 'str', **kwargs) -> 'bool | int | Awaitable[bool | int]'
     |      Disconnects the client at ``address`` (ip:port)
     |
     |      For more information, see https://redis.io/commands/client-kill
     |
     |  client_kill_filter(self, _id: 'str | None' = None, _type: 'str | None' = None, addr: 'str | None' = None, skipme: 'bool | None' = None, laddr: 'bool | None' = None, user: 'str | None' = None, maxage: 'int | None' = None, **kwargs) -> 'int | Awaitable[int]'
     |      Disconnects client(s) using a variety of filter options
     |      :param _id: Kills a client by its unique ID field
     |      :param _type: Kills a client by type where type is one of 'normal',
     |      'master', 'slave', 'replica' or 'pubsub'
     |      :param addr: Kills a client by its 'address:port'
     |      :param skipme: If True, then the client calling the command
     |      will not get killed even if it is identified by one of the filter
     |      options. If skipme is not provided, the server defaults to skipme=True
     |      :param laddr: Kills a client by its 'local (bind) address:port'
     |      :param user: Kills a client for a specific user name
     |      :param maxage: Kills clients that are older than the specified age in seconds
     |
     |  client_list(self, _type: 'str | None' = None, client_id: 'List[EncodableT]' = [], **kwargs) -> 'list[dict[str, str]] | Awaitable[list[dict[str, str]]]'
     |      Returns a list of currently connected clients.
     |      If type of client specified, only that type will be returned.
     |
     |      :param _type: optional. one of the client types (normal, master,
     |       replica, pubsub)
     |      :param client_id: optional. a list of client ids
     |
     |      For more information, see https://redis.io/commands/client-list
     |
     |  client_no_evict(self, mode: 'str') -> 'bytes | str | Awaitable[bytes | str]'
     |      Sets the client eviction mode for the current connection.
     |
     |      For more information, see https://redis.io/commands/client-no-evict
     |
     |  client_no_touch(self, mode: 'str') -> 'bytes | str | Awaitable[bytes | str]'
     |      # The command controls whether commands sent by the client will alter
     |      # the LRU/LFU of the keys they access.
     |      # When turned on, the current client will not change LFU/LRU stats,
     |      # unless it sends the TOUCH command.
     |
     |      For more information, see https://redis.io/commands/client-no-touch
     |
     |  client_pause(self, timeout: 'int', all: 'bool' = True, **kwargs) -> 'bool | Awaitable[bool]'
     |      Suspend all the Redis clients for the specified amount of time.
     |
     |
     |      For more information, see https://redis.io/commands/client-pause
     |
     |      Args:
     |          timeout: milliseconds to pause clients
     |          all: If true (default) all client commands are blocked.
     |               otherwise, clients are only blocked if they attempt to execute
     |               a write command.
     |
     |      For the WRITE mode, some commands have special behavior:
     |
     |      * EVAL/EVALSHA: Will block client for all scripts.
     |      * PUBLISH: Will block client.
     |      * PFCOUNT: Will block client.
     |      * WAIT: Acknowledgments will be delayed, so this command will
     |          appear blocked.
     |
     |  client_reply(self, reply: "Literal['ON', 'OFF', 'SKIP']", **kwargs) -> 'bytes | str | Awaitable[bytes | str]'
     |      Enable and disable redis server replies.
     |
     |      ``reply`` Must be ON OFF or SKIP,
     |      ON - The default most with server replies to commands
     |      OFF - Disable server responses to commands
     |      SKIP - Skip the response of the immediately following command.
     |
     |      Note: When setting OFF or SKIP replies, you will need a client object
     |      with a timeout specified in seconds, and will need to catch the
     |      TimeoutError.
     |      The test_client_reply unit test illustrates this, and
     |      conftest.py has a client with a timeout.
     |
     |      See https://redis.io/commands/client-reply
     |
     |  client_setinfo(self, attr: 'str', value: 'str', **kwargs) -> 'bool | Awaitable[bool]'
     |      Sets the current connection library name or version
     |      For more information see https://redis.io/commands/client-setinfo
     |
     |  client_setname(self, name: 'str', **kwargs) -> 'bool | Awaitable[bool]'
     |      Sets the current connection name
     |
     |      For more information, see https://redis.io/commands/client-setname
     |
     |      .. note::
     |         This method sets client name only for **current** connection.
     |
     |         If you want to set a common name for all connections managed
     |         by this client, use ``client_name`` constructor argument.
     |
     |  client_tracking(self, on: 'bool' = True, clientid: 'int | None' = None, prefix: 'Sequence[KeyT]' = [], bcast: 'bool' = False, optin: 'bool' = False, optout: 'bool' = False, noloop: 'bool' = False, **kwargs) -> 'bytes | str | Awaitable[bytes | str]'
     |      Enables the tracking feature of the Redis server, that is used
     |      for server assisted client side caching.
     |
     |      ``on`` indicate for tracking on or tracking off. The default is on.
     |
     |      ``clientid`` send invalidation messages to the connection with
     |      the specified ID.
     |
     |      ``bcast`` enable tracking in broadcasting mode. In this mode
     |      invalidation messages are reported for all the prefixes
     |      specified, regardless of the keys requested by the connection.
     |
     |      ``optin``  when broadcasting is NOT active, normally don't track
     |      keys in read only commands, unless they are called immediately
     |      after a CLIENT CACHING yes command.
     |
     |      ``optout`` when broadcasting is NOT active, normally track keys in
     |      read only commands, unless they are called immediately after a
     |      CLIENT CACHING no command.
     |
     |      ``noloop`` don't send notifications about keys modified by this
     |      connection itself.
     |
     |      ``prefix``  for broadcasting, register a given key prefix, so that
     |      notifications will be provided only for keys starting with this string.
     |
     |      See https://redis.io/commands/client-tracking
     |
     |  client_tracking_off(self, clientid: 'int | None' = None, prefix: 'Sequence[KeyT]' = [], bcast: 'bool' = False, optin: 'bool' = False, optout: 'bool' = False, noloop: 'bool' = False) -> 'bytes | str | Awaitable[bytes | str]'
     |      Turn off the tracking mode.
     |      For more information, about the options look at client_tracking func.
     |
     |      See https://redis.io/commands/client-tracking
     |
     |  client_tracking_on(self, clientid: 'int | None' = None, prefix: 'Sequence[KeyT]' = [], bcast: 'bool' = False, optin: 'bool' = False, optout: 'bool' = False, noloop: 'bool' = False) -> 'bytes | str | Awaitable[bytes | str]'
     |      Turn on the tracking mode.
     |      For more information, about the options look at client_tracking func.
     |
     |      See https://redis.io/commands/client-tracking
     |
     |  client_trackinginfo(self, **kwargs) -> 'ClientTrackingInfoResponse | Awaitable[ClientTrackingInfoResponse]'
     |      Returns the information about the current client connection's
     |      use of the server assisted client side cache.
     |
     |      See https://redis.io/commands/client-trackinginfo
     |
     |  client_unblock(self, client_id: 'int', error: 'bool' = False, **kwargs) -> 'bool | Awaitable[bool]'
     |      Unblocks a connection by its client id.
     |      If ``error`` is True, unblocks the client with a special error message.
     |      If ``error`` is False (default), the client is unblocked using the
     |      regular timeout mechanism.
     |
     |      For more information, see https://redis.io/commands/client-unblock
     |
     |  client_unpause(self, **kwargs) -> 'bytes | str | Awaitable[bytes | str]'
     |      Unpause all redis clients
     |
     |      For more information, see https://redis.io/commands/client-unpause
     |
     |  command(self, **kwargs) -> 'dict[str, dict[str, Any]] | Awaitable[dict[str, dict[str, Any]]]'
     |      Returns dict reply of details about all Redis commands.
     |
     |      For more information, see https://redis.io/commands/command
     |
     |  command_count(self, **kwargs) -> 'int | Awaitable[int]'
     |
     |  command_docs(self, *args)
     |      This function throws a NotImplementedError since it is intentionally
     |      not supported.
     |
     |  command_getkeysandflags(self, *args: 'str') -> 'CommandGetKeysAndFlagsResponse | Awaitable[CommandGetKeysAndFlagsResponse]'
     |      Returns array of keys from a full Redis command and their usage flags.
     |
     |      For more information, see https://redis.io/commands/command-getkeysandflags
     |
     |  command_info(self, **kwargs) -> 'None'
     |
     |  command_list(self, module: 'str | None' = None, category: 'str | None' = None, pattern: 'str | None' = None) -> 'list[bytes | str] | Awaitable[list[bytes | str]]'
     |      Return an array of the server's command names.
     |      You can use one of the following filters:
     |      ``module``: get the commands that belong to the module
     |      ``category``: get the commands in the ACL category
     |      ``pattern``: get the commands that match the given pattern
     |
     |      For more information, see https://redis.io/commands/command-list/
     |
     |  config_get(self, pattern: 'PatternT' = '*', *args: 'PatternT', **kwargs) -> 'dict[str | None, str | None] | Awaitable[dict[str | None, str | None]]'
     |      Return a dictionary of configuration based on the ``pattern``
     |
     |      For more information, see https://redis.io/commands/config-get
     |
     |  config_resetstat(self, **kwargs) -> 'bool | Awaitable[bool]'
     |      Reset runtime statistics
     |
     |      For more information, see https://redis.io/commands/config-resetstat
     |
     |  config_rewrite(self, **kwargs) -> 'bytes | str | Awaitable[bytes | str]'
     |      Rewrite config file with the minimal change to reflect running config.
     |
     |      For more information, see https://redis.io/commands/config-rewrite
     |
     |  config_set(self, name: 'KeyT', value: 'EncodableT', *args: 'Union[KeyT, EncodableT]', **kwargs) -> 'bool | Awaitable[bool]'
     |      Set config item ``name`` with ``value``
     |
     |      For more information, see https://redis.io/commands/config-set
     |
     |  dbsize(self, **kwargs) -> 'int | Awaitable[int]'
     |      Returns the number of keys in the current database
     |
     |      For more information, see https://redis.io/commands/dbsize
     |
     |  debug_object(self, key: 'KeyT', **kwargs) -> 'dict[str, str | int] | bytes | str | Awaitable[dict[str, str | int] | bytes | str]'
     |      Returns version specific meta information about a given key
     |
     |      For more information, see https://redis.io/commands/debug-object
     |
     |  debug_segfault(self, **kwargs) -> 'None'
     |
     |  echo(self, value: 'EncodableT', **kwargs) -> 'bytes | str | Awaitable[bytes | str]'
     |      Echo the string back from the server
     |
     |      For more information, see https://redis.io/commands/echo
     |
     |  failover(self)
     |      This function throws a NotImplementedError since it is intentionally
     |      not supported.
     |
     |  flushall(self, asynchronous: 'bool' = False, **kwargs) -> 'bool | Awaitable[bool]'
     |      Delete all keys in all databases on the current host.
     |
     |      ``asynchronous`` indicates whether the operation is
     |      executed asynchronously by the server.
     |
     |      For more information, see https://redis.io/commands/flushall
     |
     |  flushdb(self, asynchronous: 'bool' = False, **kwargs) -> 'bool | Awaitable[bool]'
     |      Delete all keys in the current database.
     |
     |      ``asynchronous`` indicates whether the operation is
     |      executed asynchronously by the server.
     |
     |      For more information, see https://redis.io/commands/flushdb
     |
     |  hello(self)
     |      This function throws a NotImplementedError since it is intentionally
     |      not supported.
     |
     |  hotkeys_get(self, **kwargs) -> 'Union[Awaitable[list[dict[str | bytes, Any]]], list[dict[str | bytes, Any]]]'
     |      Retrieve the result of the ongoing collection session (if any),
     |      or the last collection session (if any).
     |
     |      HOTKEYS GET response is wrapped in an array for aggregation support.
     |      Each node returns a single-element array, allowing multiple node
     |      responses to be concatenated by DMC or other aggregators.
     |
     |      For more information, see https://redis.io/commands/hotkeys-get
     |
     |  hotkeys_reset(self, **kwargs) -> 'bytes | str | Awaitable[bytes | str]'
     |      Discard the last hotkeys collection session results (in order to save memory).
     |      Error if there is an ongoing collection session.
     |
     |      For more information, see https://redis.io/commands/hotkeys-reset
     |
     |  hotkeys_start(self, metrics: 'List[HotkeysMetricsTypes]', count: 'int | None' = None, duration: 'int | None' = None, sample_ratio: 'int | None' = None, slots: 'List[int] | None' = None, **kwargs) -> 'bytes | str | Awaitable[bytes | str]'
     |      Start collecting hotkeys data.
     |      Returns an error if there is an ongoing collection session.
     |
     |      Args:
     |          count: The number of keys to collect in each criteria (CPU and network consumption)
     |          metrics: List of metrics to track. Supported values: [HotkeysMetricsTypes.CPU, HotkeysMetricsTypes.NET]
     |          duration: Automatically stop the collection after `duration` seconds
     |          sample_ratio: Commands are sampled with probability 1/ratio (1 means no sampling)
     |          slots: Only track keys on the specified hash slots
     |
     |      For more information, see https://redis.io/commands/hotkeys-start
     |
     |  hotkeys_stop(self, **kwargs) -> 'bytes | str | Awaitable[bytes | str]'
     |      Stop the ongoing hotkeys collection session (if any).
     |      The results of the last collection session are kept for consumption with HOTKEYS GET.
     |
     |      For more information, see https://redis.io/commands/hotkeys-stop
     |
     |  info(self, section: 'Optional[str]' = None, *args: 'str', **kwargs) -> 'dict[str, Any] | Awaitable[dict[str, Any]]'
     |      Returns a dictionary containing information about the Redis server
     |
     |      The ``section`` option can be used to select a specific section
     |      of information
     |
     |      The section option is not supported by older versions of Redis Server,
     |      and will generate ResponseError
     |
     |      For more information, see https://redis.io/commands/info
     |
     |  lastsave(self, **kwargs) -> 'datetime.datetime | Awaitable[datetime.datetime]'
     |      Return a Python datetime object representing the last time the
     |      Redis database was saved to disk
     |
     |      For more information, see https://redis.io/commands/lastsave
     |
     |  latency_doctor(self)
     |      Raise a NotImplementedError, as the client will not support LATENCY DOCTOR.
     |      This function is best used within the redis-cli.
     |
     |      For more information, see https://redis.io/commands/latency-doctor
     |
     |  latency_graph(self)
     |      Raise a NotImplementedError, as the client will not support LATENCY GRAPH.
     |      This function is best used within the redis-cli.
     |
     |      For more information, see https://redis.io/commands/latency-graph.
     |
     |  latency_histogram(self, *args)
     |      This function throws a NotImplementedError since it is intentionally
     |      not supported.
     |
     |  latency_history(self, event: 'str') -> 'list[list[int]] | Awaitable[list[list[int]]]'
     |      Returns the raw data of the ``event``'s latency spikes time series.
     |
     |      For more information, see https://redis.io/commands/latency-history
     |
     |  latency_latest(self) -> 'list[list[bytes | str | int]] | Awaitable[list[list[bytes | str | int]]]'
     |      Reports the latest latency events logged.
     |
     |      For more information, see https://redis.io/commands/latency-latest
     |
     |  latency_reset(self, *events: 'str') -> 'int | Awaitable[int]'
     |      Resets the latency spikes time series of all, or only some, events.
     |
     |      For more information, see https://redis.io/commands/latency-reset
     |
     |  lolwut(self, *version_numbers: 'Union[str, float]', **kwargs) -> 'bytes | str | Awaitable[bytes | str]'
     |      Get the Redis version and a piece of generative computer art
     |
     |      See: https://redis.io/commands/lolwut
     |
     |  memory_doctor(self, **kwargs) -> 'None'
     |
     |  memory_help(self, **kwargs) -> 'None'
     |
     |  memory_malloc_stats(self, **kwargs) -> 'bytes | str | Awaitable[bytes | str]'
     |      Return an internal statistics report from the memory allocator.
     |
     |      See: https://redis.io/commands/memory-malloc-stats
     |
     |  memory_purge(self, **kwargs) -> 'bool | Awaitable[bool]'
     |      Attempts to purge dirty pages for reclamation by allocator
     |
     |      For more information, see https://redis.io/commands/memory-purge
     |
     |  memory_stats(self, **kwargs) -> 'dict[str, Any] | Awaitable[dict[str, Any]]'
     |      Return a dictionary of memory stats
     |
     |      For more information, see https://redis.io/commands/memory-stats
     |
     |  memory_usage(self, key: 'KeyT', samples: 'int | None' = None, **kwargs) -> 'int | None | Awaitable[int | None]'
     |      Return the total memory usage for key, its value and associated
     |      administrative overheads.
     |
     |      For nested data structures, ``samples`` is the number of elements to
     |      sample. If left unspecified, the server's default is 5. Use 0 to sample
     |      all elements.
     |
     |      For more information, see https://redis.io/commands/memory-usage
     |
     |  migrate(self, host: 'str', port: 'int', keys: 'KeysT', destination_db: 'int', timeout: 'int', copy: 'bool' = False, replace: 'bool' = False, auth: 'str | None' = None, **kwargs) -> 'bytes | str | Awaitable[bytes | str]'
     |      Migrate 1 or more keys from the current Redis server to a different
     |      server specified by the ``host``, ``port`` and ``destination_db``.
     |
     |      The ``timeout``, specified in milliseconds, indicates the maximum
     |      time the connection between the two servers can be idle before the
     |      command is interrupted.
     |
     |      If ``copy`` is True, the specified ``keys`` are NOT deleted from
     |      the source server.
     |
     |      If ``replace`` is True, this operation will overwrite the keys
     |      on the destination server if they exist.
     |
     |      If ``auth`` is specified, authenticate to the destination server with
     |      the password provided.
     |
     |      For more information, see https://redis.io/commands/migrate
     |
     |  object(self, infotype: 'str', key: 'KeyT', **kwargs) -> 'Any | Awaitable[Any]'
     |      Return the encoding, idletime, or refcount about the key
     |
     |  ping(self, **kwargs) -> 'Union[Awaitable[bool], bool]'
     |      Ping the Redis server to test connectivity.
     |
     |      Sends a PING command to the Redis server and returns True if the server
     |      responds with "PONG".
     |
     |      This command is useful for:
     |      - Testing whether a connection is still alive
     |      - Verifying the server's ability to serve data
     |
     |      For more information on the underlying ping command see https://redis.io/commands/ping
     |
     |  psync(self, replicationid: 'str', offset: 'int') -> 'bytes | Awaitable[bytes]'
     |      Initiates a replication stream from the master.
     |      Newer version for `sync`.
     |
     |      For more information, see https://redis.io/commands/sync
     |
     |  quit(self, **kwargs) -> 'bool | Awaitable[bool]'
     |      Ask the server to close the connection.
     |
     |      For more information, see https://redis.io/commands/quit
     |
     |  replicaof(self, *args, **kwargs) -> 'bytes | str | Awaitable[bytes | str]'
     |      Update the replication settings of a redis replica, on the fly.
     |
     |      Examples of valid arguments include:
     |
     |      NO ONE (set no replication)
     |      host port (set to the host and port of a redis server)
     |
     |      For more information, see  https://redis.io/commands/replicaof
     |
     |  reset(self) -> 'bytes | str | Awaitable[bytes | str]'
     |      Perform a full reset on the connection's server-side context.
     |
     |      See: https://redis.io/commands/reset
     |
     |  role(self) -> 'list[Any] | Awaitable[list[Any]]'
     |      Provide information on the role of a Redis instance in
     |      the context of replication, by returning if the instance
     |      is currently a master, slave, or sentinel.
     |
     |      For more information, see https://redis.io/commands/role
     |
     |  save(self, **kwargs) -> 'bool | Awaitable[bool]'
     |      Tell the Redis server to save its data to disk,
     |      blocking until the save is complete
     |
     |      For more information, see https://redis.io/commands/save
     |
     |  select(self, index: 'int', **kwargs) -> 'bool | Awaitable[bool]'
     |      Select the Redis logical database at index.
     |
     |      See: https://redis.io/commands/select
     |
     |  shutdown(self, save: 'bool' = False, nosave: 'bool' = False, now: 'bool' = False, force: 'bool' = False, abort: 'bool' = False, **kwargs) -> 'None'
     |      Shutdown the Redis server.  If Redis has persistence configured,
     |      data will be flushed before shutdown.
     |      It is possible to specify modifiers to alter the behavior of the command:
     |      ``save`` will force a DB saving operation even if no save points are configured.
     |      ``nosave`` will prevent a DB saving operation even if one or more save points
     |      are configured.
     |      ``now`` skips waiting for lagging replicas, i.e. it bypasses the first step in
     |      the shutdown sequence.
     |      ``force`` ignores any errors that would normally prevent the server from exiting
     |      ``abort`` cancels an ongoing shutdown and cannot be combined with other flags.
     |
     |      For more information, see https://redis.io/commands/shutdown
     |
     |  slaveof(self, host: 'str | None' = None, port: 'int | None' = None, **kwargs) -> 'bool | Awaitable[bool]'
     |      Set the server to be a replicated slave of the instance identified
     |      by the ``host`` and ``port``. If called without arguments, the
     |      instance is promoted to a master instead.
     |
     |      For more information, see https://redis.io/commands/slaveof
     |
     |  slowlog_get(self, num: 'int | None' = None, **kwargs) -> 'list[dict[str, Any]] | Awaitable[list[dict[str, Any]]]'
     |      Get the entries from the slowlog. If ``num`` is specified, get the
     |      most recent ``num`` items.
     |
     |      For more information, see https://redis.io/commands/slowlog-get
     |
     |  slowlog_len(self, **kwargs) -> 'int | Awaitable[int]'
     |      Get the number of items in the slowlog
     |
     |      For more information, see https://redis.io/commands/slowlog-len
     |
     |  slowlog_reset(self, **kwargs) -> 'bool | Awaitable[bool]'
     |      Remove all items in the slowlog
     |
     |      For more information, see https://redis.io/commands/slowlog-reset
     |
     |  swapdb(self, first: 'int', second: 'int', **kwargs) -> 'bool | Awaitable[bool]'
     |      Swap two databases
     |
     |      For more information, see https://redis.io/commands/swapdb
     |
     |  sync(self) -> 'bytes | Awaitable[bytes]'
     |      Initiates a replication stream from the master.
     |
     |      For more information, see https://redis.io/commands/sync
     |
     |  time(self, **kwargs) -> 'tuple[int, int] | Awaitable[tuple[int, int]]'
     |      Returns the server time as a 2-item tuple of ints:
     |      (seconds since epoch, microseconds into this second).
     |
     |      For more information, see https://redis.io/commands/time
     |
     |  wait(self, num_replicas: 'int', timeout: 'int', **kwargs) -> 'int | Awaitable[int]'
     |      Redis synchronous replication
     |      That returns the number of replicas that processed the query when
     |      we finally have at least ``num_replicas``, or when the ``timeout`` was
     |      reached.
     |
     |      For more information, see https://redis.io/commands/wait
     |
     |  waitaof(self, num_local: 'int', num_replicas: 'int', timeout: 'int', **kwargs) -> 'list[int] | Awaitable[list[int]]'
     |      This command blocks the current client until all previous write
     |      commands by that client are acknowledged as having been fsynced
     |      to the AOF of the local Redis and/or at least the specified number
     |      of replicas.
     |
     |      For more information, see https://redis.io/commands/waitaof
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from redis.commands.core.ModuleCommands:
     |
     |  command_getkeys(self, *args) -> 'list[bytes | str] | Awaitable[list[bytes | str]]'
     |
     |  module_list(self) -> 'list[dict[Any, Any]] | Awaitable[list[dict[Any, Any]]]'
     |      Returns a list of dictionaries containing the name and version of
     |      all loaded modules.
     |
     |      For more information, see https://redis.io/commands/module-list
     |
     |  module_load(self, path, *args) -> 'bool | Awaitable[bool]'
     |      Loads the module from ``path``.
     |      Passes all ``*args`` to the module, during loading.
     |      Raises ``ModuleError`` if a module is not found at ``path``.
     |
     |      For more information, see https://redis.io/commands/module-load
     |
     |  module_loadex(self, path: 'str', options: 'List[str] | None' = None, args: 'List[str] | None' = None) -> 'bytes | str | Awaitable[bytes | str]'
     |      Loads a module from a dynamic library at runtime with configuration directives.
     |
     |      For more information, see https://redis.io/commands/module-loadex
     |
     |  module_unload(self, name) -> 'bool | Awaitable[bool]'
     |      Unloads the module ``name``.
     |      Raises ``ModuleError`` if ``name`` is not in loaded modules.
     |
     |      For more information, see https://redis.io/commands/module-unload
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from redis.commands.core.PubSubCommands:
     |
     |  publish(self, channel: 'ChannelT', message: 'EncodableT', **kwargs) -> 'int | Awaitable[int]'
     |      Publish ``message`` on ``channel``.
     |      Returns the number of subscribers the message was delivered to.
     |
     |      For more information, see https://redis.io/commands/publish
     |
     |  pubsub_channels(self, pattern: 'PatternT' = '*', **kwargs) -> 'list[bytes | str] | Awaitable[list[bytes | str]]'
     |      Return a list of channels that have at least one subscriber
     |
     |      For more information, see https://redis.io/commands/pubsub-channels
     |
     |  pubsub_numpat(self, **kwargs) -> 'int | Awaitable[int]'
     |      Returns the number of subscriptions to patterns
     |
     |      For more information, see https://redis.io/commands/pubsub-numpat
     |
     |  pubsub_numsub(self, *args: 'ChannelT', **kwargs) -> 'list[tuple[bytes | str, int]] | Awaitable[list[tuple[bytes | str, int]]]'
     |      Return a list of (channel, number of subscribers) tuples
     |      for each channel given in ``*args``
     |
     |      For more information, see https://redis.io/commands/pubsub-numsub
     |
     |  pubsub_shardchannels(self, pattern: 'PatternT' = '*', **kwargs) -> 'list[bytes | str] | Awaitable[list[bytes | str]]'
     |      Return a list of shard_channels that have at least one subscriber
     |
     |      For more information, see https://redis.io/commands/pubsub-shardchannels
     |
     |  pubsub_shardnumsub(self, *args: 'ChannelT', **kwargs) -> 'list[tuple[bytes | str, int]] | Awaitable[list[tuple[bytes | str, int]]]'
     |      Return a list of (shard_channel, number of subscribers) tuples
     |      for each channel given in ``*args``
     |
     |      For more information, see https://redis.io/commands/pubsub-shardnumsub
     |
     |  spublish(self, shard_channel: 'ChannelT', message: 'EncodableT') -> 'int | Awaitable[int]'
     |      Posts a message to the given shard channel.
     |      Returns the number of clients that received the message
     |
     |      For more information, see https://redis.io/commands/spublish
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from redis.commands.core.ScriptCommands:
     |
     |  eval(self, script: 'str', numkeys: 'int', *keys_and_args: 'KeyT | EncodableT') -> 'Any | Awaitable[Any]'
     |      Execute the Lua ``script``, specifying the ``numkeys`` the script
     |      will touch and the key names and argument values in ``keys_and_args``.
     |      Returns the result of the script.
     |
     |      In practice, use the object returned by ``register_script``. This
     |      function exists purely for Redis API completion.
     |
     |      For more information, see  https://redis.io/commands/eval
     |
     |  eval_ro(self, script: 'str', numkeys: 'int', *keys_and_args: 'KeyT | EncodableT') -> 'Any | Awaitable[Any]'
     |      The read-only variant of the EVAL command
     |
     |      Execute the read-only Lua ``script`` specifying the ``numkeys`` the script
     |      will touch and the key names and argument values in ``keys_and_args``.
     |      Returns the result of the script.
     |
     |      For more information, see  https://redis.io/commands/eval_ro
     |
     |  evalsha(self, sha: 'str', numkeys: 'int', *keys_and_args: 'KeyT | EncodableT') -> 'Any | Awaitable[Any]'
     |      Use the ``sha`` to execute a Lua script already registered via EVAL
     |      or SCRIPT LOAD. Specify the ``numkeys`` the script will touch and the
     |      key names and argument values in ``keys_and_args``. Returns the result
     |      of the script.
     |
     |      In practice, use the object returned by ``register_script``. This
     |      function exists purely for Redis API completion.
     |
     |      For more information, see  https://redis.io/commands/evalsha
     |
     |  evalsha_ro(self, sha: 'str', numkeys: 'int', *keys_and_args: 'KeyT | EncodableT') -> 'Any | Awaitable[Any]'
     |      The read-only variant of the EVALSHA command
     |
     |      Use the ``sha`` to execute a read-only Lua script already registered via EVAL
     |      or SCRIPT LOAD. Specify the ``numkeys`` the script will touch and the
     |      key names and argument values in ``keys_and_args``. Returns the result
     |      of the script.
     |
     |      For more information, see  https://redis.io/commands/evalsha_ro
     |
     |  register_script(self: "Union['redis.client.Redis', 'redis.cluster.RedisCluster']", script: 'ScriptTextT') -> 'Script'
     |      Register a Lua ``script`` specifying the ``keys`` it will touch.
     |      Returns a Script object that is callable and hides the complexity of
     |      deal with scripts, keys, and shas. This is the preferred way to work
     |      with Lua scripts.
     |
     |  script_debug(self, *args) -> 'None'
     |
     |  script_exists(self, *args: 'str') -> 'list[bool] | Awaitable[list[bool]]'
     |      Check if a script exists in the script cache by specifying the SHAs of
     |      each script as ``args``. Returns a list of boolean values indicating if
     |      if each already script exists in the cache_data.
     |
     |      For more information, see  https://redis.io/commands/script-exists
     |
     |  script_flush(self, sync_type: "Literal['SYNC'] | Literal['ASYNC'] | None" = None) -> 'bool | Awaitable[bool]'
     |      Flush all scripts from the script cache_data.
     |
     |      ``sync_type`` is by default SYNC (synchronous) but it can also be
     |                    ASYNC.
     |
     |      For more information, see  https://redis.io/commands/script-flush
     |
     |  script_kill(self) -> 'bool | Awaitable[bool]'
     |      Kill the currently executing Lua script
     |
     |      For more information, see https://redis.io/commands/script-kill
     |
     |  script_load(self, script: 'ScriptTextT') -> 'str | Awaitable[str]'
     |      Load a Lua ``script`` into the script cache_data. Returns the SHA.
     |
     |      For more information, see https://redis.io/commands/script-load
     |
     |  ----------------------------------------------------------------------
     |  Data and other attributes inherited from redis.typing.CommandsProtocol:
     |
     |  __protocol_attrs__ = {'_event_dispatcher', 'execute_command'}
     |
     |  ----------------------------------------------------------------------
     |  Class methods inherited from typing.Protocol:
     |
     |  __init_subclass__(*args, **kwargs)
     |      This method is called when a class is subclassed.
     |
     |      The default implementation does nothing. It may be
     |      overridden to extend subclasses.
     |
     |  ----------------------------------------------------------------------
     |  Class methods inherited from typing.Generic:
     |
     |  __class_getitem__(...)
     |      Parameterizes a generic class.
     |
     |      At least, parameterizing a generic class is the *main* thing this
     |      method does. For example, for some generic class `Foo`, this is called
     |      when we do `Foo[int]` - there, with `cls=Foo` and `params=int`.
     |
     |      However, note that this method is also called when defining generic
     |      classes in the first place with `class Foo[T]: ...`.
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from redis.commands.core.FunctionCommands:
     |
     |  fcall(self, function, numkeys: 'int', *keys_and_args: 'Any') -> 'Any | Awaitable[Any]'
     |      Invoke a function.
     |
     |      For more information, see https://redis.io/commands/fcall
     |
     |  fcall_ro(self, function, numkeys: 'int', *keys_and_args: 'Any') -> 'Any | Awaitable[Any]'
     |      This is a read-only variant of the FCALL command that cannot
     |      execute commands that modify data.
     |
     |      For more information, see https://redis.io/commands/fcall_ro
     |
     |  function_delete(self, library: 'str') -> 'bool | Awaitable[bool]'
     |      Delete the library called ``library`` and all its functions.
     |
     |      For more information, see https://redis.io/commands/function-delete
     |
     |  function_dump(self) -> 'bytes | Awaitable[bytes]'
     |      Return the serialized payload of loaded libraries.
     |
     |      For more information, see https://redis.io/commands/function-dump
     |
     |  function_flush(self, mode: 'str' = 'SYNC') -> 'bool | Awaitable[bool]'
     |      Deletes all the libraries.
     |
     |      For more information, see https://redis.io/commands/function-flush
     |
     |  function_kill(self) -> 'bytes | str | Awaitable[bytes | str]'
     |      Kill a function that is currently executing.
     |
     |      For more information, see https://redis.io/commands/function-kill
     |
     |  function_list(self, library: 'str | None' = '*', withcode: 'bool | None' = False) -> 'list[Any] | Awaitable[list[Any]]'
     |      Return information about the functions and libraries.
     |
     |      Args:
     |
     |          library: specify a pattern for matching library names
     |          withcode: cause the server to include the libraries source implementation
     |              in the reply
     |
     |  function_load(self, code: 'str', replace: 'bool | None' = False) -> 'bytes | str | Awaitable[bytes | str]'
     |      Load a library to Redis.
     |      :param code: the source code (must start with
     |      Shebang statement that provides a metadata about the library)
     |      :param replace: changes the behavior to overwrite the existing library
     |      with the new contents.
     |      Return the library name that was loaded.
     |
     |      For more information, see https://redis.io/commands/function-load
     |
     |  function_restore(self, payload: 'str', policy: 'str | None' = 'APPEND') -> 'bool | Awaitable[bool]'
     |      Restore libraries from the serialized ``payload``.
     |      You can use the optional policy argument to provide a policy
     |      for handling existing libraries.
     |
     |      For more information, see https://redis.io/commands/function-restore
     |
     |  function_stats(self) -> 'Any | Awaitable[Any]'
     |      Return information about the function that's currently running
     |      and information about the available execution engines.
     |
     |      For more information, see https://redis.io/commands/function-stats
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from redis.commands.sentinel.SentinelCommands:
     |
     |  sentinel(self, *args)
     |      Redis Sentinel's SENTINEL command.
     |
     |  sentinel_ckquorum(self, new_master_name) -> Union[bool, Awaitable[bool]]
     |      Check if the current Sentinel configuration is able to reach the
     |      quorum needed to failover a master, and the majority needed to
     |      authorize the failover.
     |
     |      This command should be used in monitoring systems to check if a
     |      Sentinel deployment is ok.
     |
     |  sentinel_failover(self, new_master_name) -> Union[bool, Awaitable[bool]]
     |      Force a failover as if the master was not reachable, and without
     |      asking for agreement to other Sentinels (however a new version of the
     |      configuration will be published so that the other Sentinels will
     |      update their configurations).
     |
     |  sentinel_flushconfig(self) -> Union[bool, Awaitable[bool]]
     |      Force Sentinel to rewrite its configuration on disk, including the
     |      current Sentinel state.
     |
     |      Normally Sentinel rewrites the configuration every time something
     |      changes in its state (in the context of the subset of the state which
     |      is persisted on disk across restart).
     |      However sometimes it is possible that the configuration file is lost
     |      because of operation errors, disk failures, package upgrade scripts or
     |      configuration managers. In those cases a way to to force Sentinel to
     |      rewrite the configuration file is handy.
     |
     |      This command works even if the previous configuration file is
     |      completely missing.
     |
     |  sentinel_get_master_addr_by_name(self, service_name, return_responses: bool = False) -> Union[tuple[bytes | str, int], NoneType, bool, Awaitable[tuple[bytes | str, int] | None | bool]]
     |      Returns a (host, port) pair for the given ``service_name`` when return_responses is True,
     |      otherwise returns a boolean value that indicates if the command was successful.
     |
     |  sentinel_master(self, service_name, return_responses: bool = False) -> Union[dict[str, Any], bool, Awaitable[dict[str, Any] | bool]]
     |      Returns a dictionary containing the specified masters state, when return_responses is True,
     |      otherwise returns a boolean value that indicates if the command was successful.
     |
     |  sentinel_masters(self) -> Union[dict[str, dict[str, Any]], list[dict[str, Any]], Awaitable[dict[str, dict[str, Any]] | list[dict[str, Any]]]]
     |      Returns a list of dictionaries containing each master's state.
     |
     |      Important: This function is called by the Sentinel implementation and is
     |      called directly on the Redis standalone client for sentinels,
     |      so it doesn't support the "once" and "return_responses" options.
     |
     |  sentinel_monitor(self, name, ip, port, quorum) -> Union[bool, Awaitable[bool]]
     |      Add a new master to Sentinel to be monitored
     |
     |  sentinel_remove(self, name) -> Union[bool, Awaitable[bool]]
     |      Remove a master from Sentinel's monitoring
     |
     |  sentinel_reset(self, pattern) -> Union[bool, Awaitable[bool]]
     |      This command will reset all the masters with matching name.
     |      The pattern argument is a glob-style pattern.
     |
     |      The reset process clears any previous state in a master (including a
     |      failover in progress), and removes every slave and sentinel already
     |      discovered and associated with the master.
     |
     |  sentinel_sentinels(self, service_name, return_responses: bool = False) -> Union[list[dict[str, Any]], bool, Awaitable[list[dict[str, Any]] | bool]]
     |      Returns a list of sentinels for ``service_name``, when return_responses is True,
     |      otherwise returns a boolean value that indicates if the command was successful.
     |
     |  sentinel_set(self, name, option, value) -> Union[bool, Awaitable[bool]]
     |      Set Sentinel monitoring parameters for a given master
     |
     |  sentinel_slaves(self, service_name) -> Union[list[dict[str, Any]], Awaitable[list[dict[str, Any]]]]
     |      Returns a list of slaves for ``service_name``
     |
     |      Important: This function is called by the Sentinel implementation and is
     |      called directly on the Redis standalone client for sentinels,
     |      so it doesn't support the "once" and "return_responses" options.

    StrictRedis = class Redis(redis.commands.redismodules.RedisModuleCommands, redis.commands.core.CoreCommands, redis.commands.sentinel.SentinelCommands)
     |  StrictRedis(host: str = 'localhost', port: int = 6379, db: int = 0, password: str | None = None, socket_timeout: float | None = 5, socket_connect_timeout: float | None = 5, socket_read_size: int = 32768, socket_keepalive: bool | None = True, socket_keepalive_options: Union[Mapping[int, int | bytes], object, NoneType] = <object object at 0x0000017B991493E0>, connection_pool: redis.connection.ConnectionPool | None = None, unix_socket_path: str | None = None, encoding: str = 'utf-8', encoding_errors: str = 'strict', decode_responses: bool = False, retry_on_timeout: bool = False, retry: redis.retry.Retry = <redis.retry.Retry object at 0x0000017B9C6BD640>, retry_on_error: Optional[List[Type[Exception]]] = None, ssl: bool = False, ssl_keyfile: str | None = None, ssl_certfile: str | None = None, ssl_cert_reqs: 'str | ssl.VerifyMode' = 'required', ssl_include_verify_flags: Optional[List[ForwardRef('ssl.VerifyFlags')]] = None, ssl_exclude_verify_flags: Optional[List[ForwardRef('ssl.VerifyFlags')]] = None, ssl_ca_certs: str | None = None, ssl_ca_path: str | None = None, ssl_ca_data: str | None = None, ssl_check_hostname: bool = True, ssl_password: str | None = None, ssl_validate_ocsp: bool = False, ssl_validate_ocsp_stapled: bool = False, ssl_ocsp_context: 'OpenSSL.SSL.Context | None' = None, ssl_ocsp_expected_cert: str | None = None, ssl_min_version: 'ssl.TLSVersion | None' = None, ssl_ciphers: str | None = None, max_connections: int | None = None, single_connection_client: bool = False, health_check_interval: int = 0, client_name: str | None = None, lib_name: str | object | None = <object object at 0x0000017B991493E0>, lib_version: str | object | None = <object object at 0x0000017B991493E0>, driver_info: redis.driver_info.DriverInfo | object | None = <object object at 0x0000017B991493E0>, username: str | None = None, redis_connect_func: Optional[Callable[[], NoneType]] = None, credential_provider: redis.credentials.CredentialProvider | None = None, protocol: int | None = None, legacy_responses: bool = True, cache: redis.cache.CacheInterface | None = None, cache_config: redis.cache.CacheConfig | None = None, event_dispatcher: redis.event.EventDispatcher | None = None, maint_notifications_config: redis.maint_notifications.MaintNotificationsConfig | None = None, oss_cluster_maint_notifications_handler: redis.maint_notifications.OSSMaintNotificationsHandler | None = None) -> None
     |
     |  Implementation of the Redis protocol.
     |
     |  This abstract class provides a Python interface to all Redis commands
     |  and an implementation of the Redis protocol.
     |
     |  Pipelines derive from this, implementing how
     |  the commands are sent and received to the Redis server. Based on
     |  configuration, an instance will either use a ConnectionPool, or
     |  Connection object to talk to redis.
     |
     |  It is not safe to pass PubSub or Pipeline objects between threads.
     |
     |  Method resolution order:
     |      Redis
     |      redis.commands.redismodules.RedisModuleCommands
     |      redis.commands.core.CoreCommands
     |      redis.commands.core.ACLCommands
     |      redis.commands.core.ClusterCommands
     |      redis.commands.core.DataAccessCommands
     |      redis.commands.core.BasicKeyCommands
     |      redis.commands.core.HyperlogCommands
     |      redis.commands.core.HashCommands
     |      redis.commands.core.GeoCommands
     |      redis.commands.core.ListCommands
     |      redis.commands.core.ArrayCommands
     |      redis.commands.core.ScanCommands
     |      redis.commands.core.SetCommands
     |      redis.commands.core.StreamCommands
     |      redis.commands.core.SortedSetCommands
     |      redis.commands.core.ManagementCommands
     |      redis.commands.core.ModuleCommands
     |      redis.commands.core.PubSubCommands
     |      redis.commands.core.ScriptCommands
     |      redis.typing.CommandsProtocol
     |      typing.Protocol
     |      typing.Generic
     |      redis.commands.core.FunctionCommands
     |      redis.commands.sentinel.SentinelCommands
     |      builtins.object
     |
     |  Methods defined here:
     |
     |  __del__(self)
     |
     |  __enter__(self)
     |
     |  __exit__(self, exc_type, exc_value, traceback)
     |
     |  __init__(self, host: str = 'localhost', port: int = 6379, db: int = 0, password: str | None = None, socket_timeout: float | None = 5, socket_connect_timeout: float | None = 5, socket_read_size: int = 32768, socket_keepalive: bool | None = True, socket_keepalive_options: Union[Mapping[int, int | bytes], object, NoneType] = <object object at 0x0000017B991493E0>, connection_pool: redis.connection.ConnectionPool | None = None, unix_socket_path: str | None = None, encoding: str = 'utf-8', encoding_errors: str = 'strict', decode_responses: bool = False, retry_on_timeout: bool = False, retry: redis.retry.Retry = <redis.retry.Retry object at 0x0000017B9C6BD640>, retry_on_error: Optional[List[Type[Exception]]] = None, ssl: bool = False, ssl_keyfile: str | None = None, ssl_certfile: str | None = None, ssl_cert_reqs: 'str | ssl.VerifyMode' = 'required', ssl_include_verify_flags: Optional[List[ForwardRef('ssl.VerifyFlags')]] = None, ssl_exclude_verify_flags: Optional[List[ForwardRef('ssl.VerifyFlags')]] = None, ssl_ca_certs: str | None = None, ssl_ca_path: str | None = None, ssl_ca_data: str | None = None, ssl_check_hostname: bool = True, ssl_password: str | None = None, ssl_validate_ocsp: bool = False, ssl_validate_ocsp_stapled: bool = False, ssl_ocsp_context: 'OpenSSL.SSL.Context | None' = None, ssl_ocsp_expected_cert: str | None = None, ssl_min_version: 'ssl.TLSVersion | None' = None, ssl_ciphers: str | None = None, max_connections: int | None = None, single_connection_client: bool = False, health_check_interval: int = 0, client_name: str | None = None, lib_name: str | object | None = <object object at 0x0000017B991493E0>, lib_version: str | object | None = <object object at 0x0000017B991493E0>, driver_info: redis.driver_info.DriverInfo | object | None = <object object at 0x0000017B991493E0>, username: str | None = None, redis_connect_func: Optional[Callable[[], NoneType]] = None, credential_provider: redis.credentials.CredentialProvider | None = None, protocol: int | None = None, legacy_responses: bool = True, cache: redis.cache.CacheInterface | None = None, cache_config: redis.cache.CacheConfig | None = None, event_dispatcher: redis.event.EventDispatcher | None = None, maint_notifications_config: redis.maint_notifications.MaintNotificationsConfig | None = None, oss_cluster_maint_notifications_handler: redis.maint_notifications.OSSMaintNotificationsHandler | None = None) -> None
     |      Initialize a new Redis client.
     |
     |      To specify a retry policy for specific errors, you have two options:
     |
     |      1. Set the `retry_on_error` to a list of the error/s to retry on, and
     |      you can also set `retry` to a valid `Retry` object(in case the default
     |      one is not appropriate) - with this approach the retries will be triggered
     |      on the default errors specified in the Retry object enriched with the
     |      errors specified in `retry_on_error`.
     |
     |      2. Define a `Retry` object with configured 'supported_errors' and set
     |      it to the `retry` parameter - with this approach you completely redefine
     |      the errors on which retries will happen.
     |
     |      `retry_on_timeout` is deprecated - please include the TimeoutError
     |      either in the Retry object or in the `retry_on_error` list.
     |
     |      When 'connection_pool' is provided - the retry configuration of the
     |      provided pool will be used.
     |
     |      Args:
     |
     |      socket_keepalive:
     |          if `True`, TCP keepalive is enabled for TCP socket connections.
     |          Argument is ignored when connection_pool is provided.
     |      socket_keepalive_options:
     |          mapping of TCP keepalive socket option constants to values, for
     |          example `{socket.TCP_KEEPIDLE: 30}`. If left unspecified, redis-py
     |          uses TCP keepalive defaults when `socket_keepalive` is enabled:
     |          idle 30 seconds, interval 5 seconds, and 3 probes. Platform-specific
     |          options that are not available are skipped. Pass `None` or `{}` to
     |          avoid setting additional TCP keepalive options. Argument is ignored
     |          when connection_pool is provided.
     |      single_connection_client:
     |          if `True`, connection pool is not used. In that case `Redis`
     |          instance use is not thread safe.
     |      decode_responses:
     |          if `True`, the response will be decoded to utf-8.
     |          Argument is ignored when connection_pool is provided.
     |      driver_info:
     |          Optional DriverInfo object to identify upstream libraries.
     |          If provided, lib_name and lib_version are ignored.
     |          If not provided, a DriverInfo will be created from lib_name and lib_version.
     |          Explicit None disables CLIENT SETINFO.
     |          Argument is ignored when connection_pool is provided.
     |      lib_name:
     |          **Deprecated.** Use driver_info instead. Library name for CLIENT SETINFO.
     |      lib_version:
     |          **Deprecated.** Use driver_info instead. Library version for CLIENT SETINFO.
     |      maint_notifications_config:
     |          configures the pool to support maintenance notifications - see
     |          `redis.maint_notifications.MaintNotificationsConfig` for details.
     |          Only supported with RESP3
     |          If not provided and protocol is RESP3, the maintenance notifications
     |          will be enabled by default (logic is included in the connection pool
     |          initialization).
     |          Argument is ignored when connection_pool is provided.
     |      oss_cluster_maint_notifications_handler:
     |          handler for OSS cluster notifications - see
     |          `redis.maint_notifications.OSSMaintNotificationsHandler` for details.
     |          Only supported with RESP3
     |          Argument is ignored when connection_pool is provided.
     |
     |  __repr__(self) -> str
     |      Return repr(self).
     |
     |  client(self)
     |
     |  close(self) -> None
     |
     |  execute_command(self, *args, **options)
     |      # COMMAND EXECUTION AND PROTOCOL PARSING
     |
     |  get_cache(self) -> Optional[redis.cache.CacheInterface]
     |
     |  get_connection_kwargs(self) -> Dict
     |      Get the connection's key-word arguments
     |
     |  get_encoder(self) -> 'Encoder'
     |      Get the connection pool's encoder
     |
     |  get_retry(self) -> Optional[redis.retry.Retry]
     |
     |  himport_discard(self, fieldset_name: str) -> int
     |      Remove a fieldset from the registry.
     |
     |      Returns ``1`` if it was registered, ``0`` otherwise. On a pooled client the
     |      server-side ``DISCARD`` is reconciled lazily when each connection is next
     |      used for ``himport_set``. On a single connection client it runs immediately
     |      on the pinned connection when it is live; while that connection is not
     |      connected there is nothing prepared on the server to discard (its tracking is
     |      reset on connect), so no server call is made.
     |
     |  himport_discard_all(self) -> int
     |      Remove all fieldsets from the registry.
     |
     |      Returns the number removed from the registry. Server-side removal follows the
     |      same live/lazy rule as :meth:`himport_discard`.
     |
     |  himport_prepare(self, fieldset_name: str, fields: Iterable[Union[bytes, bytearray, memoryview, str, int, float]]) -> bool
     |      Declare an HIMPORT fieldset for use by :meth:`himport_set`.
     |
     |      Registers ``fieldset_name`` (ordered ``fields``, verbatim) in the client's
     |      shared registry. On a pooled client the server-side ``PREPARE`` is deferred
     |      and bundled into the next ``himport_set`` per connection. On a single
     |      connection client it is run immediately when the pinned connection is live;
     |      while that connection is not connected there is no session state to prepare,
     |      so the next ``himport_set`` prepares it lazily instead.
     |
     |  keyspace_notifications(self, key_prefix: Union[str, bytes, NoneType] = None, ignore_subscribe_messages: bool = True) -> 'KeyspaceNotifications'
     |      Return a :class:`~redis.keyspace_notifications.KeyspaceNotifications`
     |      object for subscribing to keyspace and keyevent notifications.
     |
     |      Note: Keyspace notifications must be enabled on the Redis server via
     |      the ``notify-keyspace-events`` configuration option.
     |
     |      Args:
     |          key_prefix: Optional prefix to filter and strip from keys in
     |                      notifications.
     |          ignore_subscribe_messages: If True, subscribe/unsubscribe
     |                                    confirmations are not returned by
     |                                    get_message/listen.
     |
     |  load_external_module(self, funcname, func) -> None
     |      This function can be used to add externally defined redis modules,
     |      and their namespaces to the redis client.
     |
     |      funcname - A string containing the name of the function to create
     |      func - The function, being added to this class.
     |
     |      ex: Assume that one has a custom redis module named foomod that
     |      creates command named 'foo.dothing' and 'foo.anotherthing' in redis.
     |      To load function functions into this namespace:
     |
     |      from redis import Redis
     |      from foomodule import F
     |      r = Redis()
     |      r.load_external_module("foo", F)
     |      r.foo().dothing('your', 'arguments')
     |
     |      For a concrete example see the reimport of the redisjson module in
     |      tests/test_connection.py::test_loading_external_modules
     |
     |  lock(self, name: str, timeout: Optional[float] = None, sleep: float = 0.1, blocking: bool = True, blocking_timeout: Optional[float] = None, lock_class: Optional[Any] = None, thread_local: bool = True, raise_on_release_error: bool = True)
     |      Return a new Lock object using key ``name`` that mimics
     |      the behavior of threading.Lock.
     |
     |      If specified, ``timeout`` indicates a maximum life for the lock.
     |      By default, it will remain locked until release() is called.
     |
     |      ``sleep`` indicates the amount of time to sleep per loop iteration
     |      when the lock is in blocking mode and another client is currently
     |      holding the lock.
     |
     |      ``blocking`` indicates whether calling ``acquire`` should block until
     |      the lock has been acquired or to fail immediately, causing ``acquire``
     |      to return False and the lock not being acquired. Defaults to True.
     |      Note this value can be overridden by passing a ``blocking``
     |      argument to ``acquire``.
     |
     |      ``blocking_timeout`` indicates the maximum amount of time in seconds to
     |      spend trying to acquire the lock. A value of ``None`` indicates
     |      continue trying forever. ``blocking_timeout`` can be specified as a
     |      float or integer, both representing the number of seconds to wait.
     |
     |      ``lock_class`` forces the specified lock implementation. Note that as
     |      of redis-py 3.0, the only lock class we implement is ``Lock`` (which is
     |      a Lua-based lock). So, it's unlikely you'll need this parameter, unless
     |      you have created your own custom lock class.
     |
     |      ``thread_local`` indicates whether the lock token is placed in
     |      thread-local storage. By default, the token is placed in thread local
     |      storage so that a thread only sees its token, not a token set by
     |      another thread. Consider the following timeline:
     |
     |          time: 0, thread-1 acquires `my-lock`, with a timeout of 5 seconds.
     |                   thread-1 sets the token to "abc"
     |          time: 1, thread-2 blocks trying to acquire `my-lock` using the
     |                   Lock instance.
     |          time: 5, thread-1 has not yet completed. redis expires the lock
     |                   key.
     |          time: 5, thread-2 acquired `my-lock` now that it's available.
     |                   thread-2 sets the token to "xyz"
     |          time: 6, thread-1 finishes its work and calls release(). if the
     |                   token is *not* stored in thread local storage, then
     |                   thread-1 would see the token value as "xyz" and would be
     |                   able to successfully release the thread-2's lock.
     |
     |      ``raise_on_release_error`` indicates whether to raise an exception when
     |      the lock is no longer owned when exiting the context manager. By default,
     |      this is True, meaning an exception will be raised. If False, the warning
     |      will be logged and the exception will be suppressed.
     |
     |      In some use cases it's necessary to disable thread local storage. For
     |      example, if you have code where one thread acquires a lock and passes
     |      that lock instance to a worker thread to release later. If thread
     |      local storage isn't disabled in this case, the worker thread won't see
     |      the token set by the thread that acquired the lock. Our assumption
     |      is that these cases aren't common and as such default to using
     |      thread local storage.
     |
     |  monitor(self)
     |
     |  parse_response(self, connection, command_name, **options)
     |      Parses a response from the Redis server
     |
     |  pipeline(self, transaction=True, shard_hint=None) -> 'Pipeline'
     |      Return a new pipeline object that can queue multiple commands for
     |      later execution. ``transaction`` indicates whether all commands
     |      should be executed atomically. Apart from making a group of operations
     |      atomic, pipelines are useful for reducing the back-and-forth overhead
     |      between the client and server.
     |
     |  pubsub(self, **kwargs)
     |      Return a Publish/Subscribe object. With this object, you can
     |      subscribe to channels and listen for messages that get published to
     |      them.
     |
     |  set_response_callback(self, command: str, callback: Callable) -> None
     |      Set a custom Response Callback
     |
     |  set_retry(self, retry: redis.retry.Retry) -> None
     |
     |  transaction(self, func: Callable[[ForwardRef('Pipeline')], NoneType], *watches, **kwargs) -> Union[List[Any], Any, NoneType]
     |      Convenience method for executing the callable `func` as a transaction
     |      while watching all keys specified in `watches`. The 'func' callable
     |      should expect a single argument which is a Pipeline object.
     |
     |  ----------------------------------------------------------------------
     |  Class methods defined here:
     |
     |  __subclasshook__ = _proto_hook(other) from typing
     |
     |  from_pool(connection_pool: redis.connection.ConnectionPool) -> 'Redis'
     |      Return a Redis client from the given connection pool.
     |      The Redis client will take ownership of the connection pool and
     |      close it when the Redis client is closed.
     |
     |      Because the client closes (disconnects all connections in) the pool
     |      when it is closed or garbage-collected, the pool must not be shared
     |      with other clients. Constructing multiple clients from the same pool
     |      via ``from_pool`` -- for example one per request across threads -- is
     |      not thread safe: when one client is closed it will disconnect
     |      connections still in use by the others.
     |
     |      To share a single pool across clients, construct the pool explicitly
     |      and manage its lifecycle instead. Unlike ``from_pool``, the plain
     |      ``Redis(connection_pool=pool)`` constructor does not take ownership of
     |      the pool and will not close it, so a pool created this way can be
     |      safely shared across clients. ``ConnectionPool`` supports the context
     |      manager protocol for this::
     |
     |          with ConnectionPool.from_url(url) as pool:
     |              r = Redis(connection_pool=pool)
     |
     |  from_url(url: str, **kwargs) -> 'Redis'
     |      Return a Redis client object configured from the given URL
     |
     |      For example::
     |
     |          redis://[[username]:[password]]@localhost:6379/0
     |          rediss://[[username]:[password]]@localhost:6379/0
     |          unix://[username@]/path/to/socket.sock?db=0[&password=password]
     |
     |      Three URL schemes are supported:
     |
     |      - `redis://` creates a TCP socket connection. See more at:
     |        <https://www.iana.org/assignments/uri-schemes/prov/redis>
     |      - `rediss://` creates a SSL wrapped TCP socket connection. See more at:
     |        <https://www.iana.org/assignments/uri-schemes/prov/rediss>
     |      - ``unix://``: creates a Unix Domain Socket connection.
     |
     |      The username, password, hostname, path and all querystring values
     |      are passed through urllib.parse.unquote in order to replace any
     |      percent-encoded values with their corresponding characters.
     |
     |      There are several ways to specify a database number. The first value
     |      found will be used:
     |
     |          1. A ``db`` querystring option, e.g. redis://localhost?db=0
     |          2. If using the redis:// or rediss:// schemes, the path argument
     |             of the url, e.g. redis://localhost/0
     |          3. A ``db`` keyword argument to this function.
     |
     |      If none of these options are specified, the default db=0 is used.
     |
     |      All querystring options are cast to their appropriate Python types.
     |      Boolean arguments can be specified with string values "True"/"False"
     |      or "Yes"/"No". Values that cannot be properly cast cause a
     |      ``ValueError`` to be raised. Once parsed, the querystring arguments
     |      and keyword arguments are passed to the ``ConnectionPool``'s
     |      class initializer. In the case of conflicting arguments, querystring
     |      arguments always win.
     |
     |  ----------------------------------------------------------------------
     |  Readonly properties defined here:
     |
     |  himport_registry
     |      The client's HIMPORT fieldset registry (contains empty
     |      schema registry if none was declared).
     |
     |      Read-only: the registry is mutated only through the HIMPORT command methods.
     |
     |  ----------------------------------------------------------------------
     |  Data and other attributes defined here:
     |
     |  __abstractmethods__ = frozenset()
     |
     |  __annotations__ = {'_is_async_client': typing.Literal[False]}
     |
     |  __parameters__ = ()
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from redis.commands.redismodules.RedisModuleCommands:
     |
     |  bf(self) -> 'BFBloom'
     |      Access the bloom namespace.
     |
     |  cf(self) -> 'CFBloom'
     |      Access the bloom namespace.
     |
     |  cms(self) -> 'CMSBloom'
     |      Access the bloom namespace.
     |
     |  ft(self, index_name='idx') -> 'Search'
     |      Access the search namespace, providing support for redis search.
     |
     |  json(self, encoder=<json.encoder.JSONEncoder object at 0x0000017B9C588F50>, decoder=<json.decoder.JSONDecoder object at 0x0000017B9C588FB0>) -> 'JSON'
     |      Access the json namespace, providing support for redis json.
     |
     |  tdigest(self) -> 'TDigestBloom'
     |      Access the bloom namespace.
     |
     |  topk(self) -> 'TOPKBloom'
     |      Access the bloom namespace.
     |
     |  ts(self) -> 'TimeSeries'
     |      Access the timeseries namespace, providing support for
     |      redis timeseries data.
     |
     |  vset(self) -> 'VectorSet'
     |      Access the VectorSet commands namespace.
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors inherited from redis.commands.redismodules.RedisModuleCommands:
     |
     |  __dict__
     |      dictionary for instance variables
     |
     |  __weakref__
     |      list of weak references to the object
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from redis.commands.core.ACLCommands:
     |
     |  acl_cat(self, category: 'str | None' = None, **kwargs) -> 'list[bytes | str] | Awaitable[list[bytes | str]]'
     |      Returns a list of categories or commands within a category.
     |
     |      If ``category`` is not supplied, returns a list of all categories.
     |      If ``category`` is supplied, returns a list of all commands within
     |      that category.
     |
     |      For more information, see https://redis.io/commands/acl-cat
     |
     |  acl_deluser(self, *username: 'str', **kwargs) -> 'int | Awaitable[int]'
     |      Delete the ACL for the specified ``username``\s
     |
     |      For more information, see https://redis.io/commands/acl-deluser
     |
     |  acl_dryrun(self, username: 'str', *args: 'EncodableT', **kwargs) -> 'bytes | str | Awaitable[bytes | str]'
     |      Simulate the execution of a given command by a given ``username``.
     |
     |      For more information, see https://redis.io/commands/acl-dryrun
     |
     |  acl_genpass(self, bits: 'int | None' = None, **kwargs) -> 'bytes | str | Awaitable[bytes | str]'
     |      Generate a random password value.
     |      If ``bits`` is supplied then use this number of bits, rounded to
     |      the next multiple of 4.
     |      See: https://redis.io/commands/acl-genpass
     |
     |  acl_getuser(self, username: 'str', **kwargs) -> 'ACLGetUserData | Awaitable[ACLGetUserData]'
     |      Get the ACL details for the specified ``username``.
     |
     |      If ``username`` does not exist, return None
     |
     |      For more information, see https://redis.io/commands/acl-getuser
     |
     |  acl_help(self, **kwargs) -> 'list[bytes | str] | Awaitable[list[bytes | str]]'
     |      The ACL HELP command returns helpful text describing
     |      the different subcommands.
     |
     |      For more information, see https://redis.io/commands/acl-help
     |
     |  acl_list(self, **kwargs) -> 'list[bytes | str] | Awaitable[list[bytes | str]]'
     |      Return a list of all ACLs on the server
     |
     |      For more information, see https://redis.io/commands/acl-list
     |
     |  acl_load(self, **kwargs) -> 'bool | Awaitable[bool]'
     |      Load ACL rules from the configured ``aclfile``.
     |
     |      Note that the server must be configured with the ``aclfile``
     |      directive to be able to load ACL rules from an aclfile.
     |
     |      For more information, see https://redis.io/commands/acl-load
     |
     |  acl_log(self, count: 'int | None' = None, **kwargs) -> 'ACLLogData | Awaitable[ACLLogData]'
     |      Get ACL logs as a list.
     |      :param int count: Get logs[0:count].
     |      :rtype: List.
     |
     |      For more information, see https://redis.io/commands/acl-log
     |
     |  acl_log_reset(self, **kwargs) -> 'bool | Awaitable[bool]'
     |      Reset ACL logs.
     |      :rtype: Boolean.
     |
     |      For more information, see https://redis.io/commands/acl-log
     |
     |  acl_save(self, **kwargs) -> 'bool | Awaitable[bool]'
     |      Save ACL rules to the configured ``aclfile``.
     |
     |      Note that the server must be configured with the ``aclfile``
     |      directive to be able to save ACL rules to an aclfile.
     |
     |      For more information, see https://redis.io/commands/acl-save
     |
     |  acl_setuser(self, username: 'str', enabled: 'bool' = False, nopass: 'bool' = False, passwords: 'str | Iterable[str] | None' = None, hashed_passwords: 'str | Iterable[str] | None' = None, categories: 'Iterable[str] | None' = None, commands: 'Iterable[str] | None' = None, keys: 'Iterable[KeyT] | None' = None, channels: 'Iterable[ChannelT] | None' = None, selectors: 'Iterable[Tuple[str, KeyT]] | None' = None, reset: 'bool' = False, reset_keys: 'bool' = False, reset_channels: 'bool' = False, reset_passwords: 'bool' = False, **kwargs) -> 'bool | Awaitable[bool]'
     |      Create or update an ACL user.
     |
     |      Create or update the ACL for `username`. If the user already exists,
     |      the existing ACL is completely overwritten and replaced with the
     |      specified values.
     |
     |      For more information, see https://redis.io/commands/acl-setuser
     |
     |      Args:
     |          username: The name of the user whose ACL is to be created or updated.
     |          enabled: Indicates whether the user should be allowed to authenticate.
     |                   Defaults to `False`.
     |          nopass: Indicates whether the user can authenticate without a password.
     |                  This cannot be `True` if `passwords` are also specified.
     |          passwords: A list of plain text passwords to add to or remove from the user.
     |                     Each password must be prefixed with a '+' to add or a '-' to
     |                     remove. For convenience, a single prefixed string can be used
     |                     when adding or removing a single password.
     |          hashed_passwords: A list of SHA-256 hashed passwords to add to or remove
     |                            from the user. Each hashed password must be prefixed with
     |                            a '+' to add or a '-' to remove. For convenience, a single
     |                            prefixed string can be used when adding or removing a
     |                            single password.
     |          categories: A list of strings representing category permissions. Each string
     |                      must be prefixed with either a '+' to add the category
     |                      permission or a '-' to remove the category permission.
     |          commands: A list of strings representing command permissions. Each string
     |                    must be prefixed with either a '+' to add the command permission
     |                    or a '-' to remove the command permission.
     |          keys: A list of key patterns to grant the user access to. Key patterns allow
     |                ``'*'`` to support wildcard matching. For example, ``'*'`` grants
     |                access to all keys while ``'cache:*'`` grants access to all keys that
     |                are prefixed with ``cache:``.
     |                `keys` should not be prefixed with a ``'~'``.
     |          reset: Indicates whether the user should be fully reset prior to applying
     |                 the new ACL. Setting this to `True` will remove all existing
     |                 passwords, flags, and privileges from the user and then apply the
     |                 specified rules. If `False`, the user's existing passwords, flags,
     |                 and privileges will be kept and any new specified rules will be
     |                 applied on top.
     |          reset_keys: Indicates whether the user's key permissions should be reset
     |                      prior to applying any new key permissions specified in `keys`.
     |                      If `False`, the user's existing key permissions will be kept and
     |                      any new specified key permissions will be applied on top.
     |          reset_channels: Indicates whether the user's channel permissions should be
     |                          reset prior to applying any new channel permissions
     |                          specified in `channels`. If `False`, the user's existing
     |                          channel permissions will be kept and any new specified
     |                          channel permissions will be applied on top.
     |          reset_passwords: Indicates whether to remove all existing passwords and the
     |                           `nopass` flag from the user prior to applying any new
     |                           passwords specified in `passwords` or `hashed_passwords`.
     |                           If `False`, the user's existing passwords and `nopass`
     |                           status will be kept and any new specified passwords or
     |                           hashed passwords will be applied on top.
     |
     |  acl_users(self, **kwargs) -> 'list[bytes | str] | Awaitable[list[bytes | str]]'
     |      Returns a list of all registered users on the server.
     |
     |      For more information, see https://redis.io/commands/acl-users
     |
     |  acl_whoami(self, **kwargs) -> 'bytes | str | Awaitable[bytes | str]'
     |      Get the username for the current connection
     |
     |      For more information, see https://redis.io/commands/acl-whoami
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from redis.commands.core.ClusterCommands:
     |
     |  cluster(self, cluster_arg, *args, **kwargs) -> 'Any | Awaitable[Any]'
     |
     |  readonly(self, **kwargs) -> 'bool | Awaitable[bool]'
     |      Enables read queries for a connection to a Redis Cluster replica node.
     |
     |      For more information, see https://redis.io/commands/readonly
     |
     |  readwrite(self, **kwargs) -> 'bool | Awaitable[bool]'
     |      Disables read queries for a connection to a Redis Cluster slave node.
     |
     |      For more information, see https://redis.io/commands/readwrite
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from redis.commands.core.BasicKeyCommands:
     |
     |  __contains__ = exists(self, *names: 'KeyT') -> 'int | Awaitable[int]'
     |
     |  __delitem__(self, name: 'KeyT')
     |
     |  __getitem__(self, name: 'KeyT')
     |      Return the value at key ``name``, raises a KeyError if the key
     |      doesn't exist.
     |
     |  __setitem__(self, name: 'KeyT', value: 'EncodableT')
     |
     |  append(self, key: 'KeyT', value: 'EncodableT') -> 'int | Awaitable[int]'
     |      Appends the string ``value`` to the value at ``key``. If ``key``
     |      doesn't already exist, create it with a value of ``value``.
     |      Returns the new length of the value at ``key``.
     |
     |      For more information, see https://redis.io/commands/append
     |
     |  bitcount(self, key: 'KeyT', start: 'int | None' = None, end: 'int | None' = None, mode: 'str | None' = None) -> 'int | Awaitable[int]'
     |      Returns the count of set bits in the value of ``key``.  Optional
     |      ``start`` and ``end`` parameters indicate which bytes to consider
     |
     |      For more information, see https://redis.io/commands/bitcount
     |
     |  bitfield(self: "Union['redis.client.Redis', 'redis.asyncio.client.Redis']", key: 'KeyT', default_overflow: 'str | None' = None) -> 'BitFieldOperation'
     |      Return a BitFieldOperation instance to conveniently construct one or
     |      more bitfield operations on ``key``.
     |
     |      For more information, see https://redis.io/commands/bitfield
     |
     |  bitfield_ro(self: "Union['redis.client.Redis', 'redis.asyncio.client.Redis']", key: 'KeyT', encoding: 'str', offset: 'BitfieldOffsetT', items: 'list[tuple[str, BitfieldOffsetT]] | None' = None) -> 'list[int] | Awaitable[list[int]]'
     |      Return an array of the specified bitfield values
     |      where the first value is found using ``encoding`` and ``offset``
     |      parameters and remaining values are result of corresponding
     |      encoding/offset pairs in optional list ``items``
     |      Read-only variant of the BITFIELD command.
     |
     |      For more information, see https://redis.io/commands/bitfield_ro
     |
     |  bitop(self, operation: 'str', dest: 'KeyT', *keys: 'KeyT') -> 'int | Awaitable[int]'
     |      Perform a bitwise operation using ``operation`` between ``keys`` and
     |      store the result in ``dest``.
     |
     |      For more information, see https://redis.io/commands/bitop
     |
     |  bitpos(self, key: 'KeyT', bit: 'int', start: 'int | None' = None, end: 'int | None' = None, mode: 'str | None' = None) -> 'int | Awaitable[int]'
     |      Return the position of the first bit set to 1 or 0 in a string.
     |      ``start`` and ``end`` defines search range. The range is interpreted
     |      as a range of bytes and not a range of bits, so start=0 and end=2
     |      means to look at the first three bytes.
     |
     |      For more information, see https://redis.io/commands/bitpos
     |
     |  blmove(self, first_list: 'str', second_list: 'str', timeout: 'int', src: 'str' = 'LEFT', dest: 'str' = 'RIGHT') -> 'bytes | str | None | Awaitable[bytes | str | None]'
     |      Blocking version of lmove.
     |
     |      For more information, see https://redis.io/commands/blmove
     |
     |  blmovem(self, first_list: 'str', second_list: 'str', timeout: 'float', src: 'str' = 'LEFT', dest: 'str' = 'RIGHT', count: 'int | None' = None, mode: "Literal['COUNT', 'EXACTLY'] | None" = None, ordering: "Literal['OBO', 'BULK'] | None" = None) -> 'list[bytes | str] | None | Awaitable[list[bytes | str] | None]'
     |      Blocking version of lmovem.
     |
     |      Blocks until elements are available to move or ``timeout`` (in seconds)
     |      is reached; a ``timeout`` of ``0`` blocks indefinitely. With ``COUNT``
     |      the command unblocks once at least one element is available and moves
     |      ``min(count, available)``; with ``EXACTLY`` it blocks until the source
     |      holds at least ``count`` elements, then moves exactly ``count``
     |      atomically. On timeout ``None`` is returned and nothing is moved.
     |
     |      As with ``lmovem``, ``ordering`` (OBO or BULK) is required whenever
     |      ``count`` is given.
     |
     |      For more information, see https://redis.io/commands/blmovem
     |
     |  copy(self, source: 'str', destination: 'str', destination_db: 'str | None' = None, replace: 'bool' = False) -> 'bool | Awaitable[bool]'
     |      Copy the value stored in the ``source`` key to the ``destination`` key.
     |
     |      ``destination_db`` an alternative destination database. By default,
     |      the ``destination`` key is created in the source Redis database.
     |
     |      ``replace`` whether the ``destination`` key should be removed before
     |      copying the value to it. By default, the value is not copied if
     |      the ``destination`` key already exists.
     |
     |      For more information, see https://redis.io/commands/copy
     |
     |  decr = decrby(self, name: 'KeyT', amount: 'int' = 1) -> 'int | Awaitable[int]'
     |
     |  decrby(self, name: 'KeyT', amount: 'int' = 1) -> 'int | Awaitable[int]'
     |      Decrements the value of ``key`` by ``amount``.  If no key exists,
     |      the value will be initialized as 0 - ``amount``
     |
     |      For more information, see https://redis.io/commands/decrby
     |
     |  delete(self, *names: 'KeyT') -> 'int | Awaitable[int]'
     |      Delete one or more keys specified by ``names``
     |
     |  delex(self, name: 'KeyT', ifeq: 'bytes | str | None' = None, ifne: 'bytes | str | None' = None, ifdeq: 'str | None' = None, ifdne: 'str | None' = None) -> 'int | Awaitable[int]'
     |      Conditionally removes the specified key.
     |
     |      Warning:
     |      **Experimental** since 7.1.
     |      This API may change or be removed without notice.
     |      The API may change based on feedback.
     |
     |      Arguments:
     |          name: KeyT - the key to delete
     |          ifeq match-valu: Optional[Union[bytes, str]] - Delete the key only if its value is equal to match-value
     |          ifne match-value: Optional[Union[bytes, str]] - Delete the key only if its value is not equal to match-value
     |          ifdeq match-digest: Optional[str] - Delete the key only if the digest of its value is equal to match-digest
     |          ifdne match-digest: Optional[str] - Delete the key only if the digest of its value is not equal to match-digest
     |
     |      Returns:
     |          int: 1 if the key was deleted, 0 otherwise.
     |      Raises:
     |          redis.exceptions.ResponseError: if key exists but is not a string
     |                                          and a condition is specified.
     |          ValueError: if more than one condition is provided.
     |
     |
     |      Requires Redis 8.4 or greater.
     |      For more information, see https://redis.io/commands/delex
     |
     |  digest(self, name: 'KeyT') -> 'str | bytes | None | Awaitable[str | bytes | None]'
     |      Return the digest of the value stored at the specified key.
     |
     |      Warning:
     |      **Experimental** since 7.1.
     |      This API may change or be removed without notice.
     |      The API may change based on feedback.
     |
     |      Arguments:
     |        - name: KeyT - the key to get the digest of
     |
     |      Returns:
     |        - None if the key does not exist
     |        - (bulk string) the XXH3 digest of the value as a hex string
     |      Raises:
     |        - ResponseError if key exists but is not a string
     |
     |
     |      Requires Redis 8.4 or greater.
     |      For more information, see https://redis.io/commands/digest
     |
     |  digest_local(self, value: 'bytes | str') -> 'bytes | str'
     |      Compute the hexadecimal digest of the value locally, without sending it to the server.
     |
     |      This is useful for conditional operations like IFDEQ/IFDNE where you need to
     |      compute the digest client-side before sending a command.
     |
     |      Warning:
     |      **Experimental** - This API may change or be removed without notice.
     |
     |      Arguments:
     |        - value: Union[bytes, str] - the value to compute the digest of.
     |          If a string is provided, it will be encoded using UTF-8 before hashing,
     |          which matches Redis's default encoding behavior.
     |
     |      Returns:
     |        - (str | bytes) the XXH3 digest of the value as a hex string (16 hex characters).
     |          Returns bytes if decode_responses is False, otherwise returns str.
     |
     |      For more information, see https://redis.io/commands/digest
     |
     |  dump(self, name: 'KeyT') -> 'bytes | None | Awaitable[bytes | None]'
     |      Return a serialized version of the value stored at the specified key.
     |      If key does not exist a nil bulk reply is returned.
     |
     |      For more information, see https://redis.io/commands/dump
     |
     |  exists(self, *names: 'KeyT') -> 'int | Awaitable[int]'
     |      Returns the number of ``names`` that exist
     |
     |      For more information, see https://redis.io/commands/exists
     |
     |  expire(self, name: 'KeyT', time: 'ExpiryT', nx: 'bool' = False, xx: 'bool' = False, gt: 'bool' = False, lt: 'bool' = False) -> 'bool | Awaitable[bool]'
     |      Set an expire flag on key ``name`` for ``time`` seconds with given
     |      ``option``. ``time`` can be represented by an integer or a Python timedelta
     |      object.
     |
     |      Valid options are:
     |          NX -> Set expiry only when the key has no expiry
     |          XX -> Set expiry only when the key has an existing expiry
     |          GT -> Set expiry only when the new expiry is greater than current one
     |          LT -> Set expiry only when the new expiry is less than current one
     |
     |      For more information, see https://redis.io/commands/expire
     |
     |  expireat(self, name: 'KeyT', when: 'AbsExpiryT', nx: 'bool' = False, xx: 'bool' = False, gt: 'bool' = False, lt: 'bool' = False) -> 'bool | Awaitable[bool]'
     |      Set an expire flag on key ``name`` with given ``option``. ``when``
     |      can be represented as an integer indicating unix time or a Python
     |      datetime object.
     |
     |      Valid options are:
     |          -> NX -- Set expiry only when the key has no expiry
     |          -> XX -- Set expiry only when the key has an existing expiry
     |          -> GT -- Set expiry only when the new expiry is greater than current one
     |          -> LT -- Set expiry only when the new expiry is less than current one
     |
     |      For more information, see https://redis.io/commands/expireat
     |
     |  expiretime(self, key: 'str') -> 'int | Awaitable[int]'
     |      Returns the absolute Unix timestamp (since January 1, 1970) in seconds
     |      at which the given key will expire.
     |
     |      For more information, see https://redis.io/commands/expiretime
     |
     |  get(self, name: 'KeyT') -> 'bytes | str | None | Awaitable[bytes | str | None]'
     |      Return the value at key ``name``, or None if the key doesn't exist
     |
     |      For more information, see https://redis.io/commands/get
     |
     |  getbit(self, name: 'KeyT', offset: 'int') -> 'int | Awaitable[int]'
     |      Returns an integer indicating the value of ``offset`` in ``name``
     |
     |      For more information, see https://redis.io/commands/getbit
     |
     |  getdel(self, name: 'KeyT') -> 'bytes | str | None | Awaitable[bytes | str | None]'
     |      Get the value at key ``name`` and delete the key. This command
     |      is similar to GET, except for the fact that it also deletes
     |      the key on success (if and only if the key's value type
     |      is a string).
     |
     |      For more information, see https://redis.io/commands/getdel
     |
     |  getex(self, name: 'KeyT', ex: 'ExpiryT | None' = None, px: 'ExpiryT | None' = None, exat: 'AbsExpiryT | None' = None, pxat: 'AbsExpiryT | None' = None, persist: 'bool' = False) -> 'bytes | str | None | Awaitable[bytes | str | None]'
     |      Get the value of key and optionally set its expiration.
     |      GETEX is similar to GET, but is a write command with
     |      additional options. All time parameters can be given as
     |      datetime.timedelta or integers.
     |
     |      ``ex`` sets an expire flag on key ``name`` for ``ex`` seconds.
     |
     |      ``px`` sets an expire flag on key ``name`` for ``px`` milliseconds.
     |
     |      ``exat`` sets an expire flag on key ``name`` for ``ex`` seconds,
     |      specified in unix time.
     |
     |      ``pxat`` sets an expire flag on key ``name`` for ``ex`` milliseconds,
     |      specified in unix time.
     |
     |      ``persist`` remove the time to live associated with ``name``.
     |
     |      For more information, see https://redis.io/commands/getex
     |
     |  getrange(self, key: 'KeyT', start: 'int', end: 'int') -> 'bytes | str | Awaitable[bytes | str]'
     |      Returns the substring of the string value stored at ``key``,
     |      determined by the offsets ``start`` and ``end`` (both are inclusive)
     |
     |      For more information, see https://redis.io/commands/getrange
     |
     |  getset(self, name: 'KeyT', value: 'EncodableT') -> 'bytes | str | None | Awaitable[bytes | str | None]'
     |      Sets the value at key ``name`` to ``value``
     |      and returns the old value at key ``name`` atomically.
     |
     |      As per Redis 6.2, GETSET is considered deprecated.
     |      Please use SET with GET parameter in new code.
     |
     |      For more information, see https://redis.io/commands/getset
     |
     |  hrandfield(self, key: 'KeyT', count: 'int | None' = None, withvalues: 'bool' = False) -> 'HRandFieldResponse | Awaitable[HRandFieldResponse]'
     |      Return a random field from the hash value stored at key.
     |
     |      count: if the argument is positive, return an array of distinct fields.
     |      If called with a negative count, the behavior changes and the command
     |      is allowed to return the same field multiple times. In this case,
     |      the number of returned fields is the absolute value of the
     |      specified count.
     |      withvalues: The optional WITHVALUES modifier changes the reply so it
     |      includes the respective values of the randomly selected hash fields.
     |
     |      For more information, see https://redis.io/commands/hrandfield
     |
     |  incr = incrby(self, name: 'KeyT', amount: 'int' = 1) -> 'int | Awaitable[int]'
     |
     |  incrby(self, name: 'KeyT', amount: 'int' = 1) -> 'int | Awaitable[int]'
     |      Increments the value of ``key`` by ``amount``.  If no key exists,
     |      the value will be initialized as ``amount``
     |
     |      For more information, see https://redis.io/commands/incrby
     |
     |  incrbyfloat(self, name: 'KeyT', amount: 'float' = 1.0) -> 'float | Awaitable[float]'
     |      Increments the value at key ``name`` by floating ``amount``.
     |      If no key exists, the value will be initialized as ``amount``
     |
     |      For more information, see https://redis.io/commands/incrbyfloat
     |
     |  increx(self, name: 'KeyT', *, byfloat: 'EncodableT | None' = None, byint: 'EncodableT | None' = None, lbound: 'EncodableT | None' = None, ubound: 'EncodableT | None' = None, saturate: 'bool' = False, ex: 'ExpiryT | None' = None, px: 'ExpiryT | None' = None, exat: 'AbsExpiryT | None' = None, pxat: 'AbsExpiryT | None' = None, persist: 'bool' = False, enx: 'bool' = False) -> 'list[Number | bytes | str] | Awaitable[list[Number | bytes | str]]'
     |      Increment the numeric value at key ``name`` and return the new value
     |      and the actual increment.
     |
     |      ``byfloat`` increments a floating point value by the provided amount.
     |
     |      ``byint`` increments an integer value by the provided amount.
     |
     |      If neither ``byfloat`` nor ``byint`` is specified, the value is
     |      incremented by one.
     |
     |      ``lbound`` and ``ubound`` constrain the valid range of the result.
     |
     |      If ``saturate`` is True, out-of-bounds results are saturated to the
     |      specified bound, or to the type limit when no bound is specified.
     |      Otherwise, out-of-bounds results are rejected, leaving the value and
     |      TTL unchanged and returning the current value and zero as the actual
     |      increment.
     |
     |      ``enx`` applies the expiration only when the key does not already
     |      have an expiration, and requires ``ex``, ``px``, ``exat``, or ``pxat``.
     |
     |  keys(self, pattern: 'PatternT' = '*', **kwargs) -> 'list[bytes | str] | Awaitable[list[bytes | str]]'
     |      Returns a list of keys matching ``pattern``
     |
     |      For more information, see https://redis.io/commands/keys
     |
     |  lcs(self, key1: 'str', key2: 'str', len: 'bool | None' = False, idx: 'bool | None' = False, minmatchlen: 'int | None' = 0, withmatchlen: 'bool | None' = False) -> 'LCSCommandResponse | Awaitable[LCSCommandResponse]'
     |      Find the longest common subsequence between ``key1`` and ``key2``.
     |      If ``len`` is true the length of the match will be returned.
     |      If ``idx`` is true the match position in each strings will be returned.
     |      ``minmatchlen`` restrict the list of matches to the ones of
     |      the given ``minmatchlen``.
     |      If ``withmatchlen`` the length of the match also will be returned.
     |      For more information, see https://redis.io/commands/lcs
     |
     |  lmove(self, first_list: 'str', second_list: 'str', src: 'str' = 'LEFT', dest: 'str' = 'RIGHT') -> 'bytes | str | None | Awaitable[bytes | str | None]'
     |      Atomically returns and removes the first/last element of a list,
     |      pushing it as the first/last element on the destination list.
     |      Returns the element being popped and pushed.
     |
     |      For more information, see https://redis.io/commands/lmove
     |
     |  lmovem(self, first_list: 'str', second_list: 'str', src: 'str' = 'LEFT', dest: 'str' = 'RIGHT', count: 'int | None' = None, mode: "Literal['COUNT', 'EXACTLY'] | None" = None, ordering: "Literal['OBO', 'BULK'] | None" = None) -> 'list[bytes | str] | None | Awaitable[list[bytes | str] | None]'
     |      Atomically moves multiple elements from one end of the ``first_list``
     |      to one end of the ``second_list``, returning the moved elements in
     |      destination order.
     |
     |      ``src`` and ``dest`` are the ends to pop from / push to, either
     |      ``LEFT`` (head) or ``RIGHT`` (tail).
     |
     |      When ``count`` is given, ``mode`` selects how many elements to move:
     |      ``COUNT`` (the default) moves up to ``count`` elements, while
     |      ``EXACTLY`` moves exactly ``count`` elements or nothing at all. When
     |      ``count`` is not given a single element is moved.
     |
     |      ``ordering`` controls the order at the destination: ``OBO`` pushes each
     |      element as it is popped (reversing block order, stack semantics) while
     |      ``BULK`` preserves the original relative order (queue semantics). It is
     |      required whenever ``count`` is given.
     |
     |      Returns the array of moved elements, or ``None`` if nothing was moved.
     |
     |      For more information, see https://redis.io/commands/lmovem
     |
     |  mget(self, keys: 'KeysT', *args: 'EncodableT') -> 'list[bytes | str | None] | Awaitable[list[bytes | str | None]]'
     |      Returns a list of values ordered identically to ``keys``
     |
     |      ** Important ** When this method is used with Cluster clients, all keys
     |              must be in the same hash slot, otherwise a RedisClusterException
     |              will be raised.
     |
     |      For more information, see https://redis.io/commands/mget
     |
     |  move(self, name: 'KeyT', db: 'int') -> 'bool | Awaitable[bool]'
     |      Moves the key ``name`` to a different Redis database ``db``
     |
     |      For more information, see https://redis.io/commands/move
     |
     |  mset(self, mapping: 'Mapping[AnyKeyT, EncodableT]') -> 'bool | Awaitable[bool]'
     |      Sets key/values based on a mapping. Mapping is a dictionary of
     |      key/value pairs. Both keys and values should be strings or types that
     |      can be cast to a string via str().
     |
     |      ** Important ** When this method is used with Cluster clients, all keys
     |              must be in the same hash slot, otherwise a RedisClusterException
     |              will be raised.
     |
     |      For more information, see https://redis.io/commands/mset
     |
     |  msetex(self, mapping: 'Mapping[AnyKeyT, EncodableT]', data_persist_option: 'DataPersistOptions | None' = None, ex: 'ExpiryT | None' = None, px: 'ExpiryT | None' = None, exat: 'AbsExpiryT | None' = None, pxat: 'AbsExpiryT | None' = None, keepttl: 'bool' = False) -> 'int | Awaitable[int]'
     |      Sets key/values based on the provided ``mapping`` items.
     |
     |      ** Important ** When this method is used with Cluster clients, all keys
     |                      must be in the same hash slot, otherwise a RedisClusterException
     |                      will be raised.
     |
     |      ``mapping`` accepts a dict of key/value pairs that will be added to the database.
     |
     |      ``data_persist_option`` can be set to ``NX`` or ``XX`` to control the
     |          behavior of the command.
     |          ``NX`` will set the value for each provided key to each
     |              provided value only if all do not already exist.
     |          ``XX`` will set the value for each provided key to each
     |              provided value only if all already exist.
     |
     |      ``ex`` sets an expire flag on the keys in ``mapping`` for ``ex`` seconds.
     |
     |      ``px`` sets an expire flag on the keys in ``mapping`` for ``px`` milliseconds.
     |
     |      ``exat`` sets an expire flag on the keys in ``mapping`` for ``exat`` seconds,
     |          specified in unix time.
     |
     |      ``pxat`` sets an expire flag on the keys in ``mapping`` for ``pxat`` milliseconds,
     |          specified in unix time.
     |
     |      ``keepttl`` if True, retain the time to live associated with the keys.
     |
     |      Returns the number of fields that were added.
     |
     |      Available since Redis 8.4
     |      For more information, see https://redis.io/commands/msetex
     |
     |  msetnx(self, mapping: 'Mapping[AnyKeyT, EncodableT]') -> 'bool | Awaitable[bool]'
     |      Sets key/values based on a mapping if none of the keys are already set.
     |      Mapping is a dictionary of key/value pairs. Both keys and values
     |      should be strings or types that can be cast to a string via str().
     |      Returns a boolean indicating if the operation was successful.
     |
     |      ** Important ** When this method is used with Cluster clients, all keys
     |                      must be in the same hash slot, otherwise a RedisClusterException
     |                      will be raised.
     |
     |      For more information, see https://redis.io/commands/msetnx
     |
     |  persist(self, name: 'KeyT') -> 'bool | Awaitable[bool]'
     |      Removes an expiration on ``name``
     |
     |      For more information, see https://redis.io/commands/persist
     |
     |  pexpire(self, name: 'KeyT', time: 'ExpiryT', nx: 'bool' = False, xx: 'bool' = False, gt: 'bool' = False, lt: 'bool' = False) -> 'bool | Awaitable[bool]'
     |      Set an expire flag on key ``name`` for ``time`` milliseconds
     |      with given ``option``. ``time`` can be represented by an
     |      integer or a Python timedelta object.
     |
     |      Valid options are:
     |          NX -> Set expiry only when the key has no expiry
     |          XX -> Set expiry only when the key has an existing expiry
     |          GT -> Set expiry only when the new expiry is greater than current one
     |          LT -> Set expiry only when the new expiry is less than current one
     |
     |      For more information, see https://redis.io/commands/pexpire
     |
     |  pexpireat(self, name: 'KeyT', when: 'AbsExpiryT', nx: 'bool' = False, xx: 'bool' = False, gt: 'bool' = False, lt: 'bool' = False) -> 'bool | Awaitable[bool]'
     |      Set an expire flag on key ``name`` with given ``option``. ``when``
     |      can be represented as an integer representing unix time in
     |      milliseconds (unix time * 1000) or a Python datetime object.
     |
     |      Valid options are:
     |          NX -> Set expiry only when the key has no expiry
     |          XX -> Set expiry only when the key has an existing expiry
     |          GT -> Set expiry only when the new expiry is greater than current one
     |          LT -> Set expiry only when the new expiry is less than current one
     |
     |      For more information, see https://redis.io/commands/pexpireat
     |
     |  pexpiretime(self, key: 'str') -> 'int | Awaitable[int]'
     |      Returns the absolute Unix timestamp (since January 1, 1970) in milliseconds
     |      at which the given key will expire.
     |
     |      For more information, see https://redis.io/commands/pexpiretime
     |
     |  psetex(self, name: 'KeyT', time_ms: 'ExpiryT', value: 'EncodableT') -> 'bool | Awaitable[bool]'
     |      Set the value of key ``name`` to ``value`` that expires in ``time_ms``
     |      milliseconds. ``time_ms`` can be represented by an integer or a Python
     |      timedelta object
     |
     |      For more information, see https://redis.io/commands/psetex
     |
     |  pttl(self, name: 'KeyT') -> 'int | Awaitable[int]'
     |      Returns the number of milliseconds until the key ``name`` will expire
     |
     |      For more information, see https://redis.io/commands/pttl
     |
     |  randomkey(self, **kwargs) -> 'bytes | str | None | Awaitable[bytes | str | None]'
     |      Returns the name of a random key
     |
     |      For more information, see https://redis.io/commands/randomkey
     |
     |  rename(self, src: 'KeyT', dst: 'KeyT') -> 'bool | Awaitable[bool]'
     |      Rename key ``src`` to ``dst``
     |
     |      For more information, see https://redis.io/commands/rename
     |
     |  renamenx(self, src: 'KeyT', dst: 'KeyT') -> 'bool | Awaitable[bool]'
     |      Rename key ``src`` to ``dst`` if ``dst`` doesn't already exist
     |
     |      For more information, see https://redis.io/commands/renamenx
     |
     |  restore(self, name: 'KeyT', ttl: 'float', value: 'EncodableT', replace: 'bool' = False, absttl: 'bool' = False, idletime: 'int | None' = None, frequency: 'int | None' = None) -> 'bytes | str | Awaitable[bytes | str]'
     |      Create a key using the provided serialized value, previously obtained
     |      using DUMP.
     |
     |      ``replace`` allows an existing key on ``name`` to be overridden. If
     |      it's not specified an error is raised on collision.
     |
     |      ``absttl`` if True, specified ``ttl`` should represent an absolute Unix
     |      timestamp in milliseconds in which the key will expire. (Redis 5.0 or
     |      greater).
     |
     |      ``idletime`` Used for eviction, this is the number of seconds the
     |      key must be idle, prior to execution.
     |
     |      ``frequency`` Used for eviction, this is the frequency counter of
     |      the object stored at the key, prior to execution.
     |
     |      For more information, see https://redis.io/commands/restore
     |
     |  set(self, name: 'KeyT', value: 'EncodableT', ex: 'ExpiryT | None' = None, px: 'ExpiryT | None' = None, nx: 'bool' = False, xx: 'bool' = False, keepttl: 'bool' = False, get: 'bool' = False, exat: 'AbsExpiryT | None' = None, pxat: 'AbsExpiryT | None' = None, ifeq: 'bytes | str | None' = None, ifne: 'bytes | str | None' = None, ifdeq: 'str | None' = None, ifdne: 'str | None' = None) -> 'bool | str | bytes | None | Awaitable[bool | str | bytes | None]'
     |      Set the value at key ``name`` to ``value``
     |
     |      Warning:
     |      **Experimental** since 7.1.
     |      The usage of the arguments ``ifeq``, ``ifne``, ``ifdeq``, and ``ifdne``
     |      is experimental. The API or returned results when those parameters are used
     |      may change based on feedback.
     |
     |      ``ex`` sets an expire flag on key ``name`` for ``ex`` seconds.
     |
     |      ``px`` sets an expire flag on key ``name`` for ``px`` milliseconds.
     |
     |      ``nx`` if set to True, set the value at key ``name`` to ``value`` only
     |          if it does not exist.
     |
     |      ``xx`` if set to True, set the value at key ``name`` to ``value`` only
     |          if it already exists.
     |
     |      ``keepttl`` if True, retain the time to live associated with the key.
     |          (Available since Redis 6.0)
     |
     |      ``get`` if True, set the value at key ``name`` to ``value`` and return
     |          the old value stored at key, or None if the key did not exist.
     |          (Available since Redis 6.2)
     |
     |      ``exat`` sets an expire flag on key ``name`` for ``ex`` seconds,
     |          specified in unix time.
     |
     |      ``pxat`` sets an expire flag on key ``name`` for ``ex`` milliseconds,
     |          specified in unix time.
     |
     |      ``ifeq`` set the value at key ``name`` to ``value`` only if the current
     |          value exactly matches the argument.
     |          If key doesn’t exist - it won’t be created.
     |          (Requires Redis 8.4 or greater)
     |
     |      ``ifne`` set the value at key ``name`` to ``value`` only if the current
     |          value does not exactly match the argument.
     |          If key doesn’t exist - it will be created.
     |          (Requires Redis 8.4 or greater)
     |
     |      ``ifdeq`` set the value at key ``name`` to ``value`` only if the current
     |          value XXH3 hex digest exactly matches the argument.
     |          If key doesn’t exist - it won’t be created.
     |          (Requires Redis 8.4 or greater)
     |
     |      ``ifdne`` set the value at key ``name`` to ``value`` only if the current
     |          value XXH3 hex digest does not exactly match the argument.
     |          If key doesn’t exist - it will be created.
     |          (Requires Redis 8.4 or greater)
     |
     |      For more information, see https://redis.io/commands/set
     |
     |  setbit(self, name: 'KeyT', offset: 'int', value: 'int') -> 'int | Awaitable[int]'
     |      Flag the ``offset`` in ``name`` as ``value``. Returns an integer
     |      indicating the previous value of ``offset``.
     |
     |      For more information, see https://redis.io/commands/setbit
     |
     |  setex(self, name: 'KeyT', time: 'ExpiryT', value: 'EncodableT') -> 'bool | Awaitable[bool]'
     |      Set the value of key ``name`` to ``value`` that expires in ``time``
     |      seconds. ``time`` can be represented by an integer or a Python
     |      timedelta object.
     |
     |      As per Redis 2.6.12, SETEX is considered deprecated.
     |      Please use SET with EX parameter in new code.
     |
     |      For more information, see https://redis.io/commands/setex
     |
     |  setnx(self, name: 'KeyT', value: 'EncodableT') -> 'bool | Awaitable[bool]'
     |      Set the value of key ``name`` to ``value`` if key doesn't exist
     |
     |      For more information, see https://redis.io/commands/setnx
     |
     |  setrange(self, name: 'KeyT', offset: 'int', value: 'EncodableT') -> 'int | Awaitable[int]'
     |      Overwrite bytes in the value of ``name`` starting at ``offset`` with
     |      ``value``. If ``offset`` plus the length of ``value`` exceeds the
     |      length of the original value, the new value will be larger than before.
     |      If ``offset`` exceeds the length of the original value, null bytes
     |      will be used to pad between the end of the previous value and the start
     |      of what's being injected.
     |
     |      Returns the length of the new string.
     |
     |      For more information, see https://redis.io/commands/setrange
     |
     |  stralgo(self, algo: "Literal['LCS']", value1: 'KeyT', value2: 'KeyT', specific_argument: "Literal['strings'] | Literal['keys']" = 'strings', len: 'bool' = False, idx: 'bool' = False, minmatchlen: 'int | None' = None, withmatchlen: 'bool' = False, **kwargs) -> 'StralgoResponse | Awaitable[StralgoResponse]'
     |      Implements complex algorithms that operate on strings.
     |      Right now the only algorithm implemented is the LCS algorithm
     |      (longest common substring). However new algorithms could be
     |      implemented in the future.
     |
     |      ``algo`` Right now must be LCS
     |      ``value1`` and ``value2`` Can be two strings or two keys
     |      ``specific_argument`` Specifying if the arguments to the algorithm
     |      will be keys or strings. strings is the default.
     |      ``len`` Returns just the len of the match.
     |      ``idx`` Returns the match positions in each string.
     |      ``minmatchlen`` Restrict the list of matches to the ones of a given
     |      minimal length. Can be provided only when ``idx`` set to True.
     |      ``withmatchlen`` Returns the matches with the len of the match.
     |      Can be provided only when ``idx`` set to True.
     |
     |      For more information, see https://redis.io/commands/stralgo
     |
     |  strlen(self, name: 'KeyT') -> 'int | Awaitable[int]'
     |      Return the number of bytes stored in the value of ``name``
     |
     |      For more information, see https://redis.io/commands/strlen
     |
     |  substr(self, name: 'KeyT', start: 'int', end: 'int' = -1) -> 'bytes | str | Awaitable[bytes | str]'
     |      Return a substring of the string at key ``name``. ``start`` and ``end``
     |      are 0-based integers specifying the portion of the string to return.
     |
     |  touch(self, *args: 'KeyT') -> 'int | Awaitable[int]'
     |      Alters the last access time of a key(s) ``*args``. A key is ignored
     |      if it does not exist.
     |
     |      For more information, see https://redis.io/commands/touch
     |
     |  ttl(self, name: 'KeyT') -> 'int | Awaitable[int]'
     |      Returns the number of seconds until the key ``name`` will expire
     |
     |      For more information, see https://redis.io/commands/ttl
     |
     |  type(self, name: 'KeyT') -> 'bytes | str | Awaitable[bytes | str]'
     |      Returns the type of key ``name``
     |
     |      For more information, see https://redis.io/commands/type
     |
     |  unlink(self, *names: 'KeyT') -> 'int | Awaitable[int]'
     |      Unlink one or more keys specified by ``names``
     |
     |      For more information, see https://redis.io/commands/unlink
     |
     |  unwatch(self) -> 'None'
     |      Unwatches all previously watched keys for a transaction
     |
     |      For more information, see https://redis.io/commands/unwatch
     |
     |  watch(self, *names: 'KeyT') -> 'None'
     |      Watches the values at keys ``names``, or None if the key doesn't exist
     |
     |      For more information, see https://redis.io/commands/watch
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from redis.commands.core.HyperlogCommands:
     |
     |  pfadd(self, name: 'KeyT', *values: 'FieldT') -> 'int | Awaitable[int]'
     |      Adds the specified elements to the specified HyperLogLog.
     |
     |      For more information, see https://redis.io/commands/pfadd
     |
     |  pfcount(self, *sources: 'KeyT') -> 'int | Awaitable[int]'
     |      Return the approximated cardinality of
     |      the set observed by the HyperLogLog at key(s).
     |
     |      For more information, see https://redis.io/commands/pfcount
     |
     |  pfmerge(self, dest: 'KeyT', *sources: 'KeyT') -> 'bool | Awaitable[bool]'
     |      Merge N different HyperLogLogs into a single one.
     |
     |      For more information, see https://redis.io/commands/pfmerge
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from redis.commands.core.HashCommands:
     |
     |  hdel(self, name: 'KeyT', *keys: 'FieldT') -> 'int | Awaitable[int]'
     |      Delete ``keys`` from hash ``name``
     |
     |      For more information, see https://redis.io/commands/hdel
     |
     |  hexists(self, name: 'KeyT', key: 'FieldT') -> 'bool | Awaitable[bool]'
     |      Returns a boolean indicating if ``key`` exists within hash ``name``
     |
     |      For more information, see https://redis.io/commands/hexists
     |
     |  hexpire(self, name: 'KeyT', seconds: 'ExpiryT', *fields: 'FieldT', nx: 'bool' = False, xx: 'bool' = False, gt: 'bool' = False, lt: 'bool' = False) -> 'list[int] | Awaitable[list[int]]'
     |      Sets or updates the expiration time for fields within a hash key, using relative
     |      time in seconds.
     |
     |      If a field already has an expiration time, the behavior of the update can be
     |      controlled using the `nx`, `xx`, `gt`, and `lt` parameters.
     |
     |      The return value provides detailed information about the outcome for each field.
     |
     |      For more information, see https://redis.io/commands/hexpire
     |
     |      Args:
     |          name: The name of the hash key.
     |          seconds: Expiration time in seconds, relative. Can be an integer, or a
     |                   Python `timedelta` object.
     |          fields: List of fields within the hash to apply the expiration time to.
     |          nx: Set expiry only when the field has no expiry.
     |          xx: Set expiry only when the field has an existing expiry.
     |          gt: Set expiry only when the new expiry is greater than the current one.
     |          lt: Set expiry only when the new expiry is less than the current one.
     |
     |      Returns:
     |          Returns a list which contains for each field in the request:
     |              - `-2` if the field does not exist, or if the key does not exist.
     |              - `0` if the specified NX | XX | GT | LT condition was not met.
     |              - `1` if the expiration time was set or updated.
     |              - `2` if the field was deleted because the specified expiration time is
     |                in the past.
     |
     |  hexpireat(self, name: 'KeyT', unix_time_seconds: 'AbsExpiryT', *fields: 'FieldT', nx: 'bool' = False, xx: 'bool' = False, gt: 'bool' = False, lt: 'bool' = False) -> 'list[int] | Awaitable[list[int]]'
     |      Sets or updates the expiration time for fields within a hash key, using an
     |      absolute Unix timestamp in seconds.
     |
     |      If a field already has an expiration time, the behavior of the update can be
     |      controlled using the `nx`, `xx`, `gt`, and `lt` parameters.
     |
     |      The return value provides detailed information about the outcome for each field.
     |
     |      For more information, see https://redis.io/commands/hexpireat
     |
     |      Args:
     |          name: The name of the hash key.
     |          unix_time_seconds: Expiration time as Unix timestamp in seconds. Can be an
     |                             integer or a Python `datetime` object.
     |          fields: List of fields within the hash to apply the expiration time to.
     |          nx: Set expiry only when the field has no expiry.
     |          xx: Set expiry only when the field has an existing expiration time.
     |          gt: Set expiry only when the new expiry is greater than the current one.
     |          lt: Set expiry only when the new expiry is less than the current one.
     |
     |      Returns:
     |          Returns a list which contains for each field in the request:
     |              - `-2` if the field does not exist, or if the key does not exist.
     |              - `0` if the specified NX | XX | GT | LT condition was not met.
     |              - `1` if the expiration time was set or updated.
     |              - `2` if the field was deleted because the specified expiration time is
     |                in the past.
     |
     |  hexpiretime(self, key: 'KeyT', *fields: 'FieldT') -> 'list[int] | Awaitable[list[int]]'
     |      Returns the expiration times of hash fields as Unix timestamps in seconds.
     |
     |      For more information, see https://redis.io/commands/hexpiretime
     |
     |      Args:
     |          key: The hash key.
     |          fields: A list of fields within the hash for which to get the expiration
     |                  time.
     |
     |      Returns:
     |          Returns a list which contains for each field in the request:
     |              - `-2` if the field does not exist, or if the key does not exist.
     |              - `-1` if the field exists but has no associated expire time.
     |              - A positive integer representing the expiration Unix timestamp in
     |                seconds, if the field has an associated expiration time.
     |
     |  hget(self, name: 'KeyT', key: 'FieldT') -> 'bytes | str | None | Awaitable[bytes | str | None]'
     |      Return the value of ``key`` within the hash ``name``
     |
     |      For more information, see https://redis.io/commands/hget
     |
     |  hgetall(self, name: 'KeyT') -> 'dict[bytes | str, bytes | str] | Awaitable[dict[bytes | str, bytes | str]]'
     |      Return a Python dict of the hash's name/value pairs
     |
     |      For more information, see https://redis.io/commands/hgetall
     |
     |  hgetdel(self, name: 'KeyT', *keys: 'FieldT') -> 'list[bytes | str | None] | Awaitable[list[bytes | str | None]]'
     |      Return the value of ``key`` within the hash ``name`` and
     |      delete the field in the hash.
     |      This command is similar to HGET, except for the fact that it also deletes
     |      the key on success from the hash with the provided ```name```.
     |
     |      Available since Redis 8.0
     |      For more information, see https://redis.io/commands/hgetdel
     |
     |  hgetex(self, name: 'KeyT', *keys: 'FieldT', ex: 'ExpiryT | None' = None, px: 'ExpiryT | None' = None, exat: 'AbsExpiryT | None' = None, pxat: 'AbsExpiryT | None' = None, persist: 'bool' = False) -> 'list[bytes | str | None] | Awaitable[list[bytes | str | None]]'
     |      Return the values of ``key`` and ``keys`` within the hash ``name``
     |      and optionally set their expiration.
     |
     |      ``ex`` sets an expire flag on ``kyes`` for ``ex`` seconds.
     |
     |      ``px`` sets an expire flag on ``keys`` for ``px`` milliseconds.
     |
     |      ``exat`` sets an expire flag on ``keys`` for ``ex`` seconds,
     |      specified in unix time.
     |
     |      ``pxat`` sets an expire flag on ``keys`` for ``ex`` milliseconds,
     |      specified in unix time.
     |
     |      ``persist`` remove the time to live associated with the ``keys``.
     |
     |      Available since Redis 8.0
     |      For more information, see https://redis.io/commands/hgetex
     |
     |  himport_discard_all_internal(self) -> 'int | Awaitable[int]'
     |      Send ``HIMPORT DISCARDALL`` (returns the number of fieldsets removed).
     |
     |      .. warning::
     |          Internal wire mapping — not for direct use on a pooled client. It
     |          DISCARDs on a single arbitrary borrowed connection and bypasses the
     |          client's shared fieldset registry, leaving other connections and the
     |          registry out of sync. Use the client's ``himport_discard_all`` instead;
     |          call this only on a pinned single-connection client where you manage
     |          session state yourself.
     |
     |  himport_discard_internal(self, fieldset_name: 'str') -> 'int | Awaitable[int]'
     |      Send ``HIMPORT DISCARD fieldset_name`` (``1`` removed, ``0`` not found).
     |
     |      .. warning::
     |          Internal wire mapping — not for direct use on a pooled client. It
     |          DISCARDs on a single arbitrary borrowed connection and bypasses the
     |          client's shared fieldset registry, leaving other connections and the
     |          registry out of sync. Use the client's ``himport_discard`` instead; call
     |          this only on a pinned single-connection client where you manage session
     |          state yourself.
     |
     |  himport_prepare_internal(self, fieldset_name: 'str', fields: 'Iterable[FieldT]') -> 'bool | Awaitable[bool]'
     |      Send ``HIMPORT PREPARE fieldset_name field [field ...]``.
     |
     |      Registers the ordered field list under ``fieldset_name`` in the executing
     |      connection's session. Fields are sent in the caller's order, unmodified.
     |
     |      .. warning::
     |          Internal wire mapping — not for direct use on a pooled client. It
     |          PREPAREs on a single arbitrary borrowed connection and bypasses the
     |          client's shared fieldset registry, so other connections stay unaware and
     |          reintroduce the nondeterministic "no such fieldset" the HIMPORT design
     |          prevents. Use the client's ``himport_prepare`` instead; call this only
     |          on a pinned single-connection client where you manage session state
     |          yourself.
     |
     |  himport_set(self, key: 'KeyT', fieldset_name: 'str', values: 'Iterable[EncodableT]') -> 'bool | Awaitable[bool]'
     |      Create/replace ``key`` as a hash using ``fieldset_name``'s field list.
     |
     |      Values are sent in the caller's order and map positionally to the prepared
     |      fields. The fieldset is prepared on the serving connection on first use
     |      (PREPARE bundled with SET in one write) and reused on subsequent calls;
     |      runtime discards are reconciled on the next use of the connection. All of
     |      this happens inside the normal command path, so retry, disconnect-on-error
     |      and (for the cluster) routing / MOVED-ASK apply exactly as for any command.
     |
     |      .. note::
     |          Recovery from a mid-connection fieldset loss (the server dropping the
     |          prepared fieldset without dropping the socket, e.g. ``RESET`` or
     |          ``maxmemory-clients`` eviction) applies only to a standalone
     |          ``himport_set`` call: it catches the resulting ``no such fieldset`` and
     |          re-prepares on the same socket, retrying the SET once. A ``himport_set``
     |          buffered in a **pipeline or transaction** has no such per-command
     |          recovery — its fieldset is PREPAREd once as a pre-flight before the
     |          batch, and if the server loses it between that pre-flight and the batch
     |          the SET fails and surfaces as an error in the batch results. Callers who
     |          need the automatic recovery should issue those sets outside a pipeline.
     |
     |  hincrby(self, name: 'KeyT', key: 'FieldT', amount: 'int' = 1) -> 'int | Awaitable[int]'
     |      Increment the value of ``key`` in hash ``name`` by ``amount``
     |
     |      For more information, see https://redis.io/commands/hincrby
     |
     |  hincrbyfloat(self, name: 'KeyT', key: 'FieldT', amount: 'float' = 1.0) -> 'float | Awaitable[float]'
     |      Increment the value of ``key`` in hash ``name`` by floating ``amount``
     |
     |      For more information, see https://redis.io/commands/hincrbyfloat
     |
     |  hkeys(self, name: 'KeyT') -> 'list[bytes | str] | Awaitable[list[bytes | str]]'
     |      Return the list of keys within hash ``name``
     |
     |      For more information, see https://redis.io/commands/hkeys
     |
     |  hlen(self, name: 'KeyT') -> 'int | Awaitable[int]'
     |      Return the number of elements in hash ``name``
     |
     |      For more information, see https://redis.io/commands/hlen
     |
     |  hmget(self, name: 'KeyT', keys: 'FieldT | Iterable[FieldT]', *args: 'FieldT') -> 'list[bytes | str | None] | Awaitable[list[bytes | str | None]]'
     |      Returns a list of values ordered identically to ``keys``
     |
     |      For more information, see https://redis.io/commands/hmget
     |
     |  hmset(self, name: 'KeyT', mapping: 'Mapping[FieldT, EncodableT]') -> 'bool | Awaitable[bool]'
     |      Set key to value within hash ``name`` for each corresponding
     |      key and value from the ``mapping`` dict.
     |
     |      For more information, see https://redis.io/commands/hmset
     |
     |  hpersist(self, name: 'KeyT', *fields: 'FieldT') -> 'list[int] | Awaitable[list[int]]'
     |      Removes the expiration time for each specified field in a hash.
     |
     |      For more information, see https://redis.io/commands/hpersist
     |
     |      Args:
     |          name: The name of the hash key.
     |          fields: A list of fields within the hash from which to remove the
     |                  expiration time.
     |
     |      Returns:
     |          Returns a list which contains for each field in the request:
     |              - `-2` if the field does not exist, or if the key does not exist.
     |              - `-1` if the field exists but has no associated expiration time.
     |              - `1` if the expiration time was successfully removed from the field.
     |
     |  hpexpire(self, name: 'KeyT', milliseconds: 'ExpiryT', *fields: 'FieldT', nx: 'bool' = False, xx: 'bool' = False, gt: 'bool' = False, lt: 'bool' = False) -> 'list[int] | Awaitable[list[int]]'
     |      Sets or updates the expiration time for fields within a hash key, using relative
     |      time in milliseconds.
     |
     |      If a field already has an expiration time, the behavior of the update can be
     |      controlled using the `nx`, `xx`, `gt`, and `lt` parameters.
     |
     |      The return value provides detailed information about the outcome for each field.
     |
     |      For more information, see https://redis.io/commands/hpexpire
     |
     |      Args:
     |          name: The name of the hash key.
     |          milliseconds: Expiration time in milliseconds, relative. Can be an integer,
     |                        or a Python `timedelta` object.
     |          fields: List of fields within the hash to apply the expiration time to.
     |          nx: Set expiry only when the field has no expiry.
     |          xx: Set expiry only when the field has an existing expiry.
     |          gt: Set expiry only when the new expiry is greater than the current one.
     |          lt: Set expiry only when the new expiry is less than the current one.
     |
     |      Returns:
     |          Returns a list which contains for each field in the request:
     |              - `-2` if the field does not exist, or if the key does not exist.
     |              - `0` if the specified NX | XX | GT | LT condition was not met.
     |              - `1` if the expiration time was set or updated.
     |              - `2` if the field was deleted because the specified expiration time is
     |                in the past.
     |
     |  hpexpireat(self, name: 'KeyT', unix_time_milliseconds: 'AbsExpiryT', *fields: 'FieldT', nx: 'bool' = False, xx: 'bool' = False, gt: 'bool' = False, lt: 'bool' = False) -> 'list[int] | Awaitable[list[int]]'
     |      Sets or updates the expiration time for fields within a hash key, using an
     |      absolute Unix timestamp in milliseconds.
     |
     |      If a field already has an expiration time, the behavior of the update can be
     |      controlled using the `nx`, `xx`, `gt`, and `lt` parameters.
     |
     |      The return value provides detailed information about the outcome for each field.
     |
     |      For more information, see https://redis.io/commands/hpexpireat
     |
     |      Args:
     |          name: The name of the hash key.
     |          unix_time_milliseconds: Expiration time as Unix timestamp in milliseconds.
     |                                  Can be an integer or a Python `datetime` object.
     |          fields: List of fields within the hash to apply the expiry.
     |          nx: Set expiry only when the field has no expiry.
     |          xx: Set expiry only when the field has an existing expiry.
     |          gt: Set expiry only when the new expiry is greater than the current one.
     |          lt: Set expiry only when the new expiry is less than the current one.
     |
     |      Returns:
     |          Returns a list which contains for each field in the request:
     |              - `-2` if the field does not exist, or if the key does not exist.
     |              - `0` if the specified NX | XX | GT | LT condition was not met.
     |              - `1` if the expiration time was set or updated.
     |              - `2` if the field was deleted because the specified expiration time is
     |                in the past.
     |
     |  hpexpiretime(self, key: 'KeyT', *fields: 'FieldT') -> 'list[int] | Awaitable[list[int]]'
     |      Returns the expiration times of hash fields as Unix timestamps in milliseconds.
     |
     |      For more information, see https://redis.io/commands/hpexpiretime
     |
     |      Args:
     |          key: The hash key.
     |          fields: A list of fields within the hash for which to get the expiration
     |                  time.
     |
     |      Returns:
     |          Returns a list which contains for each field in the request:
     |              - `-2` if the field does not exist, or if the key does not exist.
     |              - `-1` if the field exists but has no associated expire time.
     |              - A positive integer representing the expiration Unix timestamp in
     |                milliseconds, if the field has an associated expiration time.
     |
     |  hpttl(self, key: 'KeyT', *fields: 'FieldT') -> 'list[int] | Awaitable[list[int]]'
     |      Returns the TTL (Time To Live) in milliseconds for each specified field within a
     |      hash key.
     |
     |      For more information, see https://redis.io/commands/hpttl
     |
     |      Args:
     |          key: The hash key.
     |          fields: A list of fields within the hash for which to get the TTL.
     |
     |      Returns:
     |          Returns a list which contains for each field in the request:
     |              - `-2` if the field does not exist, or if the key does not exist.
     |              - `-1` if the field exists but has no associated expire time.
     |              - A positive integer representing the TTL in milliseconds if the field
     |                has an associated expiration time.
     |
     |  hset(self, name: 'KeyT', key: 'FieldT | None' = None, value: 'EncodableT | None' = None, mapping: 'Mapping[FieldT, EncodableT] | None' = None, items: 'Sequence[EncodableT] | None' = None) -> 'int | Awaitable[int]'
     |      Set ``key`` to ``value`` within hash ``name``,
     |      ``mapping`` accepts a dict of key/value pairs that will be
     |      added to hash ``name``.
     |      ``items`` accepts a list of key/value pairs that will be
     |      added to hash ``name``.
     |      Returns the number of fields that were added.
     |
     |      For more information, see https://redis.io/commands/hset
     |
     |  hsetex(self, name: 'KeyT', key: 'FieldT | None' = None, value: 'EncodableT | None' = None, mapping: 'Mapping[FieldT, EncodableT] | None' = None, items: 'Sequence[EncodableT] | None' = None, ex: 'ExpiryT | None' = None, px: 'ExpiryT | None' = None, exat: 'AbsExpiryT | None' = None, pxat: 'AbsExpiryT | None' = None, data_persist_option: 'HashDataPersistOptions | None' = None, keepttl: 'bool' = False) -> 'int | Awaitable[int]'
     |      Set ``key`` to ``value`` within hash ``name``
     |
     |      ``mapping`` accepts a dict of key/value pairs that will be
     |      added to hash ``name``.
     |
     |      ``items`` accepts a list of key/value pairs that will be
     |      added to hash ``name``.
     |
     |      ``ex`` sets an expire flag on ``keys`` for ``ex`` seconds.
     |
     |      ``px`` sets an expire flag on ``keys`` for ``px`` milliseconds.
     |
     |      ``exat`` sets an expire flag on ``keys`` for ``ex`` seconds,
     |          specified in unix time.
     |
     |      ``pxat`` sets an expire flag on ``keys`` for ``ex`` milliseconds,
     |          specified in unix time.
     |
     |      ``data_persist_option`` can be set to ``FNX`` or ``FXX`` to control the
     |          behavior of the command.
     |          ``FNX`` will set the value for each provided key to each
     |              provided value only if all do not already exist.
     |          ``FXX`` will set the value for each provided key to each
     |              provided value only if all already exist.
     |
     |      ``keepttl`` if True, retain the time to live associated with the keys.
     |
     |      Returns the number of fields that were added.
     |
     |      Available since Redis 8.0
     |      For more information, see https://redis.io/commands/hsetex
     |
     |  hsetnx(self, name: 'KeyT', key: 'FieldT', value: 'EncodableT') -> 'int | Awaitable[int]'
     |      Set ``key`` to ``value`` within hash ``name`` if ``key`` does not
     |      exist.  Returns 1 if HSETNX created a field, otherwise 0.
     |
     |      For more information, see https://redis.io/commands/hsetnx
     |
     |  hstrlen(self, name: 'KeyT', key: 'FieldT') -> 'int | Awaitable[int]'
     |      Return the number of bytes stored in the value of ``key``
     |      within hash ``name``
     |
     |      For more information, see https://redis.io/commands/hstrlen
     |
     |  httl(self, key: 'KeyT', *fields: 'FieldT') -> 'list[int] | Awaitable[list[int]]'
     |      Returns the TTL (Time To Live) in seconds for each specified field within a hash
     |      key.
     |
     |      For more information, see https://redis.io/commands/httl
     |
     |      Args:
     |          key: The hash key.
     |          fields: A list of fields within the hash for which to get the TTL.
     |
     |      Returns:
     |          Returns a list which contains for each field in the request:
     |              - `-2` if the field does not exist, or if the key does not exist.
     |              - `-1` if the field exists but has no associated expire time.
     |              - A positive integer representing the TTL in seconds if the field has
     |                an associated expiration time.
     |
     |  hvals(self, name: 'KeyT') -> 'list[bytes | str] | Awaitable[list[bytes | str]]'
     |      Return the list of values within hash ``name``
     |
     |      For more information, see https://redis.io/commands/hvals
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from redis.commands.core.GeoCommands:
     |
     |  geoadd(self, name: 'KeyT', values: 'Sequence[EncodableT]', nx: 'bool' = False, xx: 'bool' = False, ch: 'bool' = False) -> 'int | Awaitable[int]'
     |      Add the specified geospatial items to the specified key identified
     |      by the ``name`` argument. The Geospatial items are given as ordered
     |      members of the ``values`` argument, each item or place is formed by
     |      the triad longitude, latitude and name.
     |
     |      Note: You can use ZREM to remove elements.
     |
     |      ``nx`` forces ZADD to only create new elements and not to update
     |      scores for elements that already exist.
     |
     |      ``xx`` forces ZADD to only update scores of elements that already
     |      exist. New elements will not be added.
     |
     |      ``ch`` modifies the return value to be the numbers of elements changed.
     |      Changed elements include new elements that were added and elements
     |      whose scores changed.
     |
     |      For more information, see https://redis.io/commands/geoadd
     |
     |  geodist(self, name: 'KeyT', place1: 'FieldT', place2: 'FieldT', unit: 'str | None' = None) -> 'float | None | Awaitable[float | None]'
     |      Return the distance between ``place1`` and ``place2`` members of the
     |      ``name`` key.
     |      The units must be one of the following : m, km mi, ft. By default
     |      meters are used.
     |
     |      For more information, see https://redis.io/commands/geodist
     |
     |  geohash(self, name: 'KeyT', *values: 'FieldT') -> 'list[bytes | str | None] | Awaitable[list[bytes | str | None]]'
     |      Return the geo hash string for each item of ``values`` members of
     |      the specified key identified by the ``name`` argument.
     |
     |      For more information, see https://redis.io/commands/geohash
     |
     |  geopos(self, name: 'KeyT', *values: 'FieldT') -> 'list[GeoCoordinate | None] | Awaitable[list[GeoCoordinate | None]]'
     |      Return the positions of each item of ``values`` as members of
     |      the specified key identified by the ``name`` argument. Each position
     |      is represented by the pairs lon and lat.
     |
     |      For more information, see https://redis.io/commands/geopos
     |
     |  georadius(self, name: 'KeyT', longitude: 'float', latitude: 'float', radius: 'float', unit: 'str | None' = None, withdist: 'bool' = False, withcoord: 'bool' = False, withhash: 'bool' = False, count: 'int | None' = None, sort: 'str | None' = None, store: 'KeyT | None' = None, store_dist: 'KeyT | None' = None, any: 'bool' = False) -> 'GeoRadiusResponse | Awaitable[GeoRadiusResponse]'
     |      Return the members of the specified key identified by the
     |      ``name`` argument which are within the borders of the area specified
     |      with the ``latitude`` and ``longitude`` location and the maximum
     |      distance from the center specified by the ``radius`` value.
     |
     |      The units must be one of the following : m, km mi, ft. By default
     |
     |      ``withdist`` indicates to return the distances of each place.
     |
     |      ``withcoord`` indicates to return the latitude and longitude of
     |      each place.
     |
     |      ``withhash`` indicates to return the geohash string of each place.
     |
     |      ``count`` indicates to return the number of elements up to N.
     |
     |      ``sort`` indicates to return the places in a sorted way, ASC for
     |      nearest to fairest and DESC for fairest to nearest.
     |
     |      ``store`` indicates to save the places names in a sorted set named
     |      with a specific key, each element of the destination sorted set is
     |      populated with the score got from the original geo sorted set.
     |
     |      ``store_dist`` indicates to save the places names in a sorted set
     |      named with a specific key, instead of ``store`` the sorted set
     |      destination score is set with the distance.
     |
     |      For more information, see https://redis.io/commands/georadius
     |
     |  georadiusbymember(self, name: 'KeyT', member: 'FieldT', radius: 'float', unit: 'str | None' = None, withdist: 'bool' = False, withcoord: 'bool' = False, withhash: 'bool' = False, count: 'int | None' = None, sort: 'str | None' = None, store: 'Union[KeyT, None]' = None, store_dist: 'Union[KeyT, None]' = None, any: 'bool' = False) -> 'GeoRadiusResponse | Awaitable[GeoRadiusResponse]'
     |      This command is exactly like ``georadius`` with the sole difference
     |      that instead of taking, as the center of the area to query, a longitude
     |      and latitude value, it takes the name of a member already existing
     |      inside the geospatial index represented by the sorted set.
     |
     |      For more information, see https://redis.io/commands/georadiusbymember
     |
     |  geosearch(self, name: 'KeyT', member: 'FieldT | None' = None, longitude: 'float | None' = None, latitude: 'float | None' = None, unit: 'str' = 'm', radius: 'float | None' = None, width: 'float | None' = None, height: 'float | None' = None, sort: 'str | None' = None, count: 'int | None' = None, any: 'bool' = False, withcoord: 'bool' = False, withdist: 'bool' = False, withhash: 'bool' = False) -> 'GeoSearchResponse | Awaitable[GeoSearchResponse]'
     |      Return the members of specified key identified by the
     |      ``name`` argument, which are within the borders of the
     |      area specified by a given shape. This command extends the
     |      GEORADIUS command, so in addition to searching within circular
     |      areas, it supports searching within rectangular areas.
     |
     |      This command should be used in place of the deprecated
     |      GEORADIUS and GEORADIUSBYMEMBER commands.
     |
     |      ``member`` Use the position of the given existing
     |       member in the sorted set. Can't be given with ``longitude``
     |       and ``latitude``.
     |
     |      ``longitude`` and ``latitude`` Use the position given by
     |      this coordinates. Can't be given with ``member``
     |      ``radius`` Similar to GEORADIUS, search inside circular
     |      area according the given radius. Can't be given with
     |      ``height`` and ``width``.
     |      ``height`` and ``width`` Search inside an axis-aligned
     |      rectangle, determined by the given height and width.
     |      Can't be given with ``radius``
     |
     |      ``unit`` must be one of the following : m, km, mi, ft.
     |      `m` for meters (the default value), `km` for kilometers,
     |      `mi` for miles and `ft` for feet.
     |
     |      ``sort`` indicates to return the places in a sorted way,
     |      ASC for nearest to furthest and DESC for furthest to nearest.
     |
     |      ``count`` limit the results to the first count matching items.
     |
     |      ``any`` is set to True, the command will return as soon as
     |      enough matches are found. Can't be provided without ``count``
     |
     |      ``withdist`` indicates to return the distances of each place.
     |      ``withcoord`` indicates to return the latitude and longitude of
     |      each place.
     |
     |      ``withhash`` indicates to return the geohash string of each place.
     |
     |      For more information, see https://redis.io/commands/geosearch
     |
     |  geosearchstore(self, dest: 'KeyT', name: 'KeyT', member: 'FieldT | None' = None, longitude: 'float | None' = None, latitude: 'float | None' = None, unit: 'str' = 'm', radius: 'float | None' = None, width: 'float | None' = None, height: 'float | None' = None, sort: 'str | None' = None, count: 'int | None' = None, any: 'bool' = False, storedist: 'bool' = False) -> 'int | Awaitable[int]'
     |      This command is like GEOSEARCH, but stores the result in
     |      ``dest``. By default, it stores the results in the destination
     |      sorted set with their geospatial information.
     |      if ``store_dist`` set to True, the command will stores the
     |      items in a sorted set populated with their distance from the
     |      center of the circle or box, as a floating-point number.
     |
     |      For more information, see https://redis.io/commands/geosearchstore
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from redis.commands.core.ListCommands:
     |
     |  blmpop(self, timeout: 'float', numkeys: 'int', *args: 'str', direction: 'str', count: 'int | None' = 1) -> 'ListMultiPopResponse | Awaitable[ListMultiPopResponse]'
     |      Pop ``count`` values (default 1) from first non-empty in the list
     |      of provided key names.
     |
     |      When all lists are empty this command blocks the connection until another
     |      client pushes to it or until the timeout, timeout of 0 blocks indefinitely
     |
     |      For more information, see https://redis.io/commands/blmpop
     |
     |  blpop(self, keys: 'KeysT', timeout: 'Number | None' = 0) -> 'BlockingListPopResponse | Awaitable[BlockingListPopResponse]'
     |      LPOP a value off of the first non-empty list
     |      named in ``keys``.
     |
     |      If none of the lists in ``keys`` has a value to LPOP, then block
     |      for ``timeout`` seconds, or until a value gets pushed on to one
     |      of the lists.
     |
     |      If timeout is 0, then block indefinitely.
     |
     |      For more information, see https://redis.io/commands/blpop
     |
     |  brpop(self, keys: 'KeysT', timeout: 'Number | None' = 0) -> 'BlockingListPopResponse | Awaitable[BlockingListPopResponse]'
     |      RPOP a value off of the first non-empty list
     |      named in ``keys``.
     |
     |      If none of the lists in ``keys`` has a value to RPOP, then block
     |      for ``timeout`` seconds, or until a value gets pushed on to one
     |      of the lists.
     |
     |      If timeout is 0, then block indefinitely.
     |
     |      For more information, see https://redis.io/commands/brpop
     |
     |  brpoplpush(self, src: 'KeyT', dst: 'KeyT', timeout: 'Number | None' = 0) -> 'bytes | str | None | Awaitable[bytes | str | None]'
     |      Pop a value off the tail of ``src``, push it on the head of ``dst``
     |      and then return it.
     |
     |      This command blocks until a value is in ``src`` or until ``timeout``
     |      seconds elapse, whichever is first. A ``timeout`` value of 0 blocks
     |      forever.
     |
     |      For more information, see https://redis.io/commands/brpoplpush
     |
     |  lindex(self, name: 'KeyT', index: 'int') -> 'bytes | str | None | Awaitable[bytes | str | None]'
     |      Return the item from list ``name`` at position ``index``
     |
     |      Negative indexes are supported and will return an item at the
     |      end of the list
     |
     |      For more information, see https://redis.io/commands/lindex
     |
     |  linsert(self, name: 'KeyT', where: 'str', refvalue: 'str', value: 'str') -> 'int | Awaitable[int]'
     |      Insert ``value`` in list ``name`` either immediately before or after
     |      [``where``] ``refvalue``
     |
     |      Returns the new length of the list on success or -1 if ``refvalue``
     |      is not in the list.
     |
     |      For more information, see https://redis.io/commands/linsert
     |
     |  llen(self, name: 'KeyT') -> 'int | Awaitable[int]'
     |      Return the length of the list ``name``
     |
     |      For more information, see https://redis.io/commands/llen
     |
     |  lmpop(self, num_keys: 'int', *args: 'str', direction: 'str', count: 'int | None' = 1) -> 'ListMultiPopResponse | Awaitable[ListMultiPopResponse]'
     |      Pop ``count`` values (default 1) first non-empty list key from the list
     |      of args provided key names.
     |
     |      For more information, see https://redis.io/commands/lmpop
     |
     |  lpop(self, name: 'KeyT', count: 'int | None' = None) -> 'bytes | str | list[bytes | str] | None | Awaitable[bytes | str | list[bytes | str] | None]'
     |      Removes and returns the first elements of the list ``name``.
     |
     |      By default, the command pops a single element from the beginning of
     |      the list. When provided with the optional ``count`` argument, the reply
     |      will consist of up to count elements, depending on the list's length.
     |
     |      For more information, see https://redis.io/commands/lpop
     |
     |  lpos(self, name: 'KeyT', value: 'str', rank: 'int | None' = None, count: 'int | None' = None, maxlen: 'int | None' = None) -> 'int | list[int] | None | Awaitable[int | list[int] | None]'
     |      Get position of ``value`` within the list ``name``
     |
     |       If specified, ``rank`` indicates the "rank" of the first element to
     |       return in case there are multiple copies of ``value`` in the list.
     |       By default, LPOS returns the position of the first occurrence of
     |       ``value`` in the list. When ``rank`` 2, LPOS returns the position of
     |       the second ``value`` in the list. If ``rank`` is negative, LPOS
     |       searches the list in reverse. For example, -1 would return the
     |       position of the last occurrence of ``value`` and -2 would return the
     |       position of the next to last occurrence of ``value``.
     |
     |       If specified, ``count`` indicates that LPOS should return a list of
     |       up to ``count`` positions. A ``count`` of 2 would return a list of
     |       up to 2 positions. A ``count`` of 0 returns a list of all positions
     |       matching ``value``. When ``count`` is specified and but ``value``
     |       does not exist in the list, an empty list is returned.
     |
     |       If specified, ``maxlen`` indicates the maximum number of list
     |       elements to scan. A ``maxlen`` of 1000 will only return the
     |       position(s) of items within the first 1000 entries in the list.
     |       A ``maxlen`` of 0 (the default) will scan the entire list.
     |
     |       For more information, see https://redis.io/commands/lpos
     |
     |  lpush(self, name: 'KeyT', *values: 'FieldT') -> 'int | Awaitable[int]'
     |      Push ``values`` onto the head of the list ``name``
     |
     |      For more information, see https://redis.io/commands/lpush
     |
     |  lpushx(self, name: 'KeyT', *values: 'FieldT') -> 'int | Awaitable[int]'
     |      Push ``value`` onto the head of the list ``name`` if ``name`` exists
     |
     |      For more information, see https://redis.io/commands/lpushx
     |
     |  lrange(self, name: 'KeyT', start: 'int', end: 'int') -> 'list[bytes | str] | Awaitable[list[bytes | str]]'
     |      Return a slice of the list ``name`` between
     |      position ``start`` and ``end``
     |
     |      ``start`` and ``end`` can be negative numbers just like
     |      Python slicing notation
     |
     |      For more information, see https://redis.io/commands/lrange
     |
     |  lrem(self, name: 'KeyT', count: 'int', value: 'str') -> 'int | Awaitable[int]'
     |      Remove the first ``count`` occurrences of elements equal to ``value``
     |      from the list stored at ``name``.
     |
     |      The count argument influences the operation in the following ways:
     |          count > 0: Remove elements equal to value moving from head to tail.
     |          count < 0: Remove elements equal to value moving from tail to head.
     |          count = 0: Remove all elements equal to value.
     |
     |          For more information, see https://redis.io/commands/lrem
     |
     |  lset(self, name: 'KeyT', index: 'int', value: 'str') -> 'bool | Awaitable[bool]'
     |      Set element at ``index`` of list ``name`` to ``value``
     |
     |      For more information, see https://redis.io/commands/lset
     |
     |  ltrim(self, name: 'KeyT', start: 'int', end: 'int') -> 'bool | Awaitable[bool]'
     |      Trim the list ``name``, removing all values not within the slice
     |      between ``start`` and ``end``
     |
     |      ``start`` and ``end`` can be negative numbers just like
     |      Python slicing notation
     |
     |      For more information, see https://redis.io/commands/ltrim
     |
     |  rpop(self, name: 'KeyT', count: 'int | None' = None) -> 'bytes | str | list[bytes | str] | None | Awaitable[bytes | str | list[bytes | str] | None]'
     |      Removes and returns the last elements of the list ``name``.
     |
     |      By default, the command pops a single element from the end of the list.
     |      When provided with the optional ``count`` argument, the reply will
     |      consist of up to count elements, depending on the list's length.
     |
     |      For more information, see https://redis.io/commands/rpop
     |
     |  rpoplpush(self, src: 'KeyT', dst: 'KeyT') -> 'bytes | str | None | Awaitable[bytes | str | None]'
     |      RPOP a value off of the ``src`` list and atomically LPUSH it
     |      on to the ``dst`` list.  Returns the value.
     |
     |      For more information, see https://redis.io/commands/rpoplpush
     |
     |  rpush(self, name: 'KeyT', *values: 'FieldT') -> 'int | Awaitable[int]'
     |      Push ``values`` onto the tail of the list ``name``
     |
     |      For more information, see https://redis.io/commands/rpush
     |
     |  rpushx(self, name: 'KeyT', *values: 'str') -> 'int | Awaitable[int]'
     |      Push ``value`` onto the tail of the list ``name`` if ``name`` exists
     |
     |      For more information, see https://redis.io/commands/rpushx
     |
     |  sort(self, name: 'KeyT', start: 'int | None' = None, num: 'int | None' = None, by: 'str | None' = None, get: 'list[str] | None' = None, desc: 'bool' = False, alpha: 'bool' = False, store: 'str | None' = None, groups: 'bool | None' = False) -> 'SortResponse | Awaitable[SortResponse]'
     |      Sort and return the list, set or sorted set at ``name``.
     |
     |      ``start`` and ``num`` allow for paging through the sorted data
     |
     |      ``by`` allows using an external key to weight and sort the items.
     |          Use an "*" to indicate where in the key the item value is located
     |
     |      ``get`` allows for returning items from external keys rather than the
     |          sorted data itself.  Use an "*" to indicate where in the key
     |          the item value is located
     |
     |      ``desc`` allows for reversing the sort
     |
     |      ``alpha`` allows for sorting lexicographically rather than numerically
     |
     |      ``store`` allows for storing the result of the sort into
     |          the key ``store``
     |
     |      ``groups`` if set to True and if ``get`` contains at least two
     |          elements, sort will return a list of tuples, each containing the
     |          values fetched from the arguments to ``get``.
     |
     |      For more information, see https://redis.io/commands/sort
     |
     |  sort_ro(self, key: 'str', start: 'int | None' = None, num: 'int | None' = None, by: 'str | None' = None, get: 'list[str] | None' = None, desc: 'bool' = False, alpha: 'bool' = False) -> 'list[bytes | str] | Awaitable[list[bytes | str]]'
     |      Returns the elements contained in the list, set or sorted set at key.
     |      (read-only variant of the SORT command)
     |
     |      ``start`` and ``num`` allow for paging through the sorted data
     |
     |      ``by`` allows using an external key to weight and sort the items.
     |          Use an "*" to indicate where in the key the item value is located
     |
     |      ``get`` allows for returning items from external keys rather than the
     |          sorted data itself.  Use an "*" to indicate where in the key
     |          the item value is located
     |
     |      ``desc`` allows for reversing the sort
     |
     |      ``alpha`` allows for sorting lexicographically rather than numerically
     |
     |      For more information, see https://redis.io/commands/sort_ro
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from redis.commands.core.ArrayCommands:
     |
     |  arcount(self, name: 'KeyT') -> 'int | Awaitable[int]'
     |      Return the number of non-empty elements in the array stored at
     |      ``name``. Returns 0 if ``name`` does not exist.
     |
     |      For more information, see https://redis.io/commands/arcount
     |
     |  ardel(self, name: 'KeyT', *indices: 'int') -> 'int | Awaitable[int]'
     |      Delete elements at the specified ``indices`` in the array stored at
     |      ``name``. Deleting an index that does not exist counts as zero
     |      elements deleted and does not modify the array.
     |
     |      Returns the number of elements deleted.
     |
     |      For more information, see https://redis.io/commands/ardel
     |
     |  ardelrange(self, name: 'KeyT', *ranges: 'tuple[int, int]') -> 'int | Awaitable[int]'
     |      Delete elements within one or more inclusive index ranges in the
     |      array stored at ``name``. Each range is a ``(start, end)`` tuple.
     |      If ``start`` is greater than ``end`` for a given pair, the range is
     |      processed in ascending order regardless. Multiple pairs may overlap;
     |      each element is counted at most once.
     |
     |      Returns the number of elements deleted.
     |
     |      For more information, see https://redis.io/commands/ardelrange
     |
     |  arget(self, name: 'KeyT', index: 'int') -> 'bytes | str | None | Awaitable[bytes | str | None]'
     |      Return the value at ``index`` in the array stored at ``name``.
     |
     |      Returns ``None`` if ``name`` does not exist or no value is set at
     |      ``index``.
     |
     |      For more information, see https://redis.io/commands/arget
     |
     |  argetrange(self, name: 'KeyT', start: 'int', end: 'int') -> 'list[bytes | str | None] | Awaitable[list[bytes | str | None]]'
     |      Return the values in the inclusive index range [``start``, ``end``]
     |      in the array stored at ``name``. If ``start`` is greater than ``end``,
     |      elements are returned in reverse index order.
     |
     |      For more information, see https://redis.io/commands/argetrange
     |
     |  argrep(self, name: 'KeyT', start: 'int', end: 'int', predicates: 'list[tuple[ArrayPredicateType, EncodableT]]', combinator: 'ArrayPredicateCombinator | None' = None, limit: 'int | None' = None, withvalues: 'bool' = False, nocase: 'bool' = False) -> 'list[int] | list[list[int | bytes | str]] | Awaitable[list[int] | list[list[int | bytes | str]]]'
     |      Search elements of the array stored at ``name`` within the inclusive
     |      index range [``start``, ``end``] using one or more textual
     |      ``predicates``. Each predicate is a ``(type, value)`` tuple where
     |      ``type`` is a member of ``ArrayPredicateType``
     |      (``EXACT``, ``MATCH``, ``GLOB``, ``RE``).
     |
     |      Multiple predicates are combined via ``combinator``
     |      (``ArrayPredicateCombinator.AND`` or ``OR``); the server defaults to
     |      OR when omitted. ``limit`` caps the number of matches.
     |      ``withvalues=True`` returns a list of ``[index, value]`` pairs
     |      (``[[idx, val], ...]``) instead of a flat list of indices.
     |      ``nocase=True`` makes all comparisons case-insensitive.
     |
     |      Without ``withvalues``, returns a flat list of matching indices in
     |      traversal order. With ``withvalues``, returns a list of
     |      ``[index, value]`` pairs in traversal order. Empty slots are
     |      skipped.
     |
     |      For more information, see https://redis.io/commands/argrep
     |
     |  arinfo(self, name: 'KeyT', full: 'bool' = False) -> 'dict[str, int] | Awaitable[dict[str, int]]'
     |      Return metadata about the array stored at ``name`` as a dictionary.
     |      When ``full`` is ``True``, additionally include per-slice statistics
     |      (dense/sparse slice counts, average sizes, fill rates), which makes
     |      the call O(N) instead of O(1).
     |
     |      Raises ``ResponseError`` when the key does not exist.
     |
     |      For more information, see https://redis.io/commands/arinfo
     |
     |  arinsert(self, name: 'KeyT', *values: 'FieldT') -> 'int | Awaitable[int]'
     |      Insert one or more ``values`` at consecutive indices in the array
     |      stored at ``name``, beginning at the current insert cursor position.
     |      The cursor advances by one for each value inserted. Use ``ARNEXT``
     |      to inspect the current cursor position and ``ARSEEK`` to reposition
     |      it.
     |
     |      Returns the last index where a value was inserted.
     |
     |      For more information, see https://redis.io/commands/arinsert
     |
     |  arlastitems(self, name: 'KeyT', count: 'int', rev: 'bool' = False) -> 'list[bytes | str | None] | Awaitable[list[bytes | str | None]]'
     |      Return up to ``count`` most recently inserted elements from the array
     |      stored at ``name``. If the array contains fewer elements than
     |      ``count``, all elements are returned.
     |
     |      When ``rev`` is ``True``, elements are returned in reverse
     |      chronological order (most recent first) instead of the default
     |      oldest-first order.
     |
     |      For more information, see https://redis.io/commands/arlastitems
     |
     |  arlen(self, name: 'KeyT') -> 'int | Awaitable[int]'
     |      Return the length of the array stored at ``name``, defined as the
     |      maximum set index plus one. Returns 0 if ``name`` does not exist.
     |
     |      For more information, see https://redis.io/commands/arlen
     |
     |  armget(self, name: 'KeyT', *indices: 'int') -> 'list[bytes | str | None] | Awaitable[list[bytes | str | None]]'
     |      Return the values at the specified ``indices`` in the array stored at
     |      ``name``. The reply preserves the order of the requested indices and
     |      returns ``None`` for any index that is not set or when ``name`` does
     |      not exist.
     |
     |      For more information, see https://redis.io/commands/armget
     |
     |  armset(self, name: 'KeyT', mapping: 'Mapping[int, FieldT]') -> 'int | Awaitable[int]'
     |      Set multiple index/value pairs in the array stored at ``name``.
     |      ``mapping`` is a dictionary of zero-based integer indices to values.
     |      Pairs may be non-contiguous and in any order.
     |
     |      Returns the number of new slots that were set (previously empty).
     |
     |      For more information, see https://redis.io/commands/armset
     |
     |  arnext(self, name: 'KeyT') -> 'int | None | Awaitable[int | None]'
     |      Return the next index ``ARINSERT`` would use for the array stored at
     |      ``name``. Returns 0 if ``name`` does not exist or no insert happened
     |      yet, and ``None`` when the insertion cursor is exhausted (next insert
     |      would overflow).
     |
     |      For more information, see https://redis.io/commands/arnext
     |
     |  arop(self, name: 'KeyT', start: 'int', end: 'int', operation: 'ArrayAggregateOperations', value: 'EncodableT | None' = None) -> 'bytes | str | int | None | Awaitable[bytes | str | int | None]'
     |      Perform an aggregate ``operation`` on elements of the array stored at
     |      ``name`` in the inclusive index range [``start``, ``end``]. The range
     |      is always scanned from the lower to the higher index regardless of
     |      argument order.
     |
     |      ``operation`` is one of the members of ``ArrayAggregateOperations``.
     |      ``value`` is required when ``operation`` is
     |      ``ArrayAggregateOperations.MATCH`` and specifies the value to compare
     |      against.
     |
     |      Returns a bulk string for ``SUM``, ``MIN`` and ``MAX``, an integer
     |      for ``AND``, ``OR``, ``XOR``, ``MATCH`` and ``USED``, or ``None``
     |      when no elements match the operation.
     |
     |      For more information, see https://redis.io/commands/arop
     |
     |  arring(self, name: 'KeyT', size: 'int', *values: 'FieldT') -> 'int | Awaitable[int]'
     |      Insert one or more ``values`` into the array stored at ``name`` as a
     |      fixed-size ring buffer of ``size`` slots. Each value is placed at
     |      ``insert_idx % size``, wrapping back to index 0 once the end is
     |      reached and overwriting older values when full. If ``size`` is
     |      smaller than the current window, the array is truncated to fit.
     |
     |      Returns the last index where a value was inserted.
     |
     |      For more information, see https://redis.io/commands/arring
     |
     |  arscan(self, name: 'KeyT', start: 'int', end: 'int', limit: 'int | None' = None) -> 'list[list[int | bytes | str]] | Awaitable[list[list[int | bytes | str]]]'
     |      Iterate populated elements of the array stored at ``name`` in the
     |      inclusive range [``start``, ``end``] and return a list of
     |      ``[index, value]`` pairs in traversal order:
     |      ``[[idx1, val1], [idx2, val2], ...]``. Empty slots are skipped. If
     |      ``start`` is greater than ``end``, the iteration is reversed.
     |
     |      ``limit`` caps the number of populated elements returned. When
     |      omitted, all populated elements in range are returned.
     |
     |      For more information, see https://redis.io/commands/arscan
     |
     |  arseek(self, name: 'KeyT', index: 'int') -> 'int | Awaitable[int]'
     |      Set the insert cursor of the array stored at ``name`` to ``index``.
     |      Subsequent ``ARINSERT`` and ``ARRING`` operations begin inserting at
     |      this position.
     |
     |      Returns 1 if the cursor was set, 0 if ``name`` does not exist.
     |
     |      For more information, see https://redis.io/commands/arseek
     |
     |  arset(self, name: 'KeyT', index: 'int', *values: 'FieldT') -> 'int | Awaitable[int]'
     |      Set one or more contiguous ``values`` in the array stored at ``name``
     |      starting at ``index``. When multiple values are provided, they are
     |      stored at consecutive indices beginning at ``index``.
     |
     |      Returns the number of new slots that were set (previously empty).
     |
     |      For more information, see https://redis.io/commands/arset
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from redis.commands.core.ScanCommands:
     |
     |  hscan(self, name: 'KeyT', cursor: 'int' = 0, match: 'PatternT | None' = None, count: 'int | None' = None, no_values: 'bool | None' = None) -> 'HScanResponse | Awaitable[HScanResponse]'
     |      Incrementally return key/value slices in a hash. Also return a cursor
     |      indicating the scan position.
     |
     |      ``match`` allows for filtering the keys by pattern
     |
     |      ``count`` allows for hint the minimum number of returns
     |
     |      ``no_values`` indicates to return only the keys, without values.
     |
     |      For more information, see https://redis.io/commands/hscan
     |
     |  hscan_iter(self, name: 'KeyT', match: 'Union[PatternT, None]' = None, count: 'Optional[int]' = None, no_values: 'Union[bool, None]' = None) -> 'Iterator'
     |      Make an iterator using the HSCAN command so that the client doesn't
     |      need to remember the cursor position.
     |
     |      ``match`` allows for filtering the keys by pattern
     |
     |      ``count`` allows for hint the minimum number of returns
     |
     |      ``no_values`` indicates to return only the keys, without values
     |
     |  scan(self, cursor: 'int' = 0, match: 'PatternT | None' = None, count: 'int | None' = None, _type: 'str | None' = None, **kwargs) -> 'ScanResponse | Awaitable[ScanResponse]'
     |      Incrementally return lists of key names. Also return a cursor
     |      indicating the scan position.
     |
     |      ``match`` allows for filtering the keys by pattern
     |
     |      ``count`` provides a hint to Redis about the number of keys to
     |          return per batch.
     |
     |      ``_type`` filters the returned values by a particular Redis type.
     |          Stock Redis instances allow for the following types:
     |          HASH, LIST, SET, STREAM, STRING, ZSET
     |          Additionally, Redis modules can expose other types as well.
     |
     |      For more information, see https://redis.io/commands/scan
     |
     |  scan_iter(self, match: 'Union[PatternT, None]' = None, count: 'Optional[int]' = None, _type: 'Optional[str]' = None, **kwargs) -> 'Iterator'
     |      Make an iterator using the SCAN command so that the client doesn't
     |      need to remember the cursor position.
     |
     |      ``match`` allows for filtering the keys by pattern
     |
     |      ``count`` provides a hint to Redis about the number of keys to
     |          return per batch.
     |
     |      ``_type`` filters the returned values by a particular Redis type.
     |          Stock Redis instances allow for the following types:
     |          HASH, LIST, SET, STREAM, STRING, ZSET
     |          Additionally, Redis modules can expose other types as well.
     |
     |  sscan(self, name: 'KeyT', cursor: 'int' = 0, match: 'PatternT | None' = None, count: 'int | None' = None) -> 'ScanResponse | Awaitable[ScanResponse]'
     |      Incrementally return lists of elements in a set. Also return a cursor
     |      indicating the scan position.
     |
     |      ``match`` allows for filtering the keys by pattern
     |
     |      ``count`` allows for hint the minimum number of returns
     |
     |      For more information, see https://redis.io/commands/sscan
     |
     |  sscan_iter(self, name: 'KeyT', match: 'Union[PatternT, None]' = None, count: 'Optional[int]' = None) -> 'Iterator'
     |      Make an iterator using the SSCAN command so that the client doesn't
     |      need to remember the cursor position.
     |
     |      ``match`` allows for filtering the keys by pattern
     |
     |      ``count`` allows for hint the minimum number of returns
     |
     |  zscan(self, name: 'KeyT', cursor: 'int' = 0, match: 'PatternT | None' = None, count: 'int | None' = None, score_cast_func: 'type | Callable' = <class 'float'>) -> 'ZScanResponse | Awaitable[ZScanResponse]'
     |      Incrementally return lists of elements in a sorted set. Also return a
     |      cursor indicating the scan position.
     |
     |      ``match`` allows for filtering the keys by pattern
     |
     |      ``count`` allows for hint the minimum number of returns
     |
     |      ``score_cast_func`` a callable used to cast the score return value
     |
     |      For more information, see https://redis.io/commands/zscan
     |
     |  zscan_iter(self, name: 'KeyT', match: 'Union[PatternT, None]' = None, count: 'Optional[int]' = None, score_cast_func: 'Union[type, Callable]' = <class 'float'>) -> 'Iterator'
     |      Make an iterator using the ZSCAN command so that the client doesn't
     |      need to remember the cursor position.
     |
     |      ``match`` allows for filtering the keys by pattern
     |
     |      ``count`` allows for hint the minimum number of returns
     |
     |      ``score_cast_func`` a callable used to cast the score return value
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from redis.commands.core.SetCommands:
     |
     |  sadd(self, name: 'KeyT', *values: 'FieldT') -> 'int | Awaitable[int]'
     |      Add ``value(s)`` to set ``name``
     |
     |      For more information, see https://redis.io/commands/sadd
     |
     |  scard(self, name: 'KeyT') -> 'int | Awaitable[int]'
     |      Return the number of elements in set ``name``
     |
     |      For more information, see https://redis.io/commands/scard
     |
     |  sdiff(self, keys: 'List', *args: 'List') -> 'set[bytes | str] | Awaitable[set[bytes | str]]'
     |      Return the difference of sets specified by ``keys``
     |
     |      For more information, see https://redis.io/commands/sdiff
     |
     |  sdiffcard(self, numkeys: 'int', keys: 'List[KeyT]', limit: 'int' = 0) -> 'int | Awaitable[int]'
     |      Return the cardinality of the difference between the first set and all
     |      the successive sets specified by ``keys``, without returning the
     |      difference itself.
     |
     |      When LIMIT is provided (defaults to 0 and means unlimited), the returned
     |      cardinality is capped at ``limit`` and the server may stop the
     |      computation once the capped result is known.
     |
     |      For more information, see https://redis.io/commands/sdiffcard
     |
     |  sdiffstore(self, dest: 'str', keys: 'List', *args: 'List') -> 'int | Awaitable[int]'
     |      Store the difference of sets specified by ``keys`` into a new
     |      set named ``dest``.  Returns the number of keys in the new set.
     |
     |      For more information, see https://redis.io/commands/sdiffstore
     |
     |  sinter(self, keys: 'List', *args: 'List') -> 'set[bytes | str] | Awaitable[set[bytes | str]]'
     |      Return the intersection of sets specified by ``keys``
     |
     |      For more information, see https://redis.io/commands/sinter
     |
     |  sintercard(self, numkeys: 'int', keys: 'List[KeyT]', limit: 'int' = 0) -> 'int | Awaitable[int]'
     |      Return the cardinality of the intersect of multiple sets specified by ``keys``.
     |
     |      When LIMIT provided (defaults to 0 and means unlimited), if the intersection
     |      cardinality reaches limit partway through the computation, the algorithm will
     |      exit and yield limit as the cardinality
     |
     |      For more information, see https://redis.io/commands/sintercard
     |
     |  sinterstore(self, dest: 'KeyT', keys: 'List', *args: 'List') -> 'int | Awaitable[int]'
     |      Store the intersection of sets specified by ``keys`` into a new
     |      set named ``dest``.  Returns the number of keys in the new set.
     |
     |      For more information, see https://redis.io/commands/sinterstore
     |
     |  sismember(self, name: 'KeyT', value: 'str') -> 'Literal[0] | Literal[1] | Awaitable[Literal[0] | Literal[1]]'
     |      Return whether ``value`` is a member of set ``name``:
     |      - 1 if the value is a member of the set.
     |      - 0 if the value is not a member of the set or if key does not exist.
     |
     |      For more information, see https://redis.io/commands/sismember
     |
     |  smembers(self, name: 'KeyT') -> 'set[bytes | str] | Awaitable[set[bytes | str]]'
     |      Return all members of the set ``name``
     |
     |      For more information, see https://redis.io/commands/smembers
     |
     |  smismember(self, name: 'KeyT', values: 'List', *args: 'List') -> 'list[Literal[0] | Literal[1]] | Awaitable[list[Literal[0] | Literal[1]]]'
     |      Return whether each value in ``values`` is a member of the set ``name``
     |      as a list of ``int`` in the order of ``values``:
     |      - 1 if the value is a member of the set.
     |      - 0 if the value is not a member of the set or if key does not exist.
     |
     |      For more information, see https://redis.io/commands/smismember
     |
     |  smove(self, src: 'KeyT', dst: 'KeyT', value: 'str') -> 'bool | Awaitable[bool]'
     |      Move ``value`` from set ``src`` to set ``dst`` atomically
     |
     |      For more information, see https://redis.io/commands/smove
     |
     |  spop(self, name: 'KeyT', count: 'int | None' = None) -> 'bytes | str | set[bytes | str] | None | Awaitable[bytes | str | set[bytes | str] | None]'
     |      Remove and return a random member of set ``name``
     |
     |      For more information, see https://redis.io/commands/spop
     |
     |  srandmember(self, name: 'KeyT', number: 'int | None' = None) -> 'bytes | str | list[bytes | str] | None | Awaitable[bytes | str | list[bytes | str] | None]'
     |      If ``number`` is None, returns a random member of set ``name``.
     |
     |      If ``number`` is supplied, returns a list of ``number`` random
     |      members of set ``name``. Note this is only available when running
     |      Redis 2.6+.
     |
     |      For more information, see https://redis.io/commands/srandmember
     |
     |  srem(self, name: 'KeyT', *values: 'FieldT') -> 'int | Awaitable[int]'
     |      Remove ``values`` from set ``name``
     |
     |      For more information, see https://redis.io/commands/srem
     |
     |  sunion(self, keys: 'List', *args: 'List') -> 'set[bytes | str] | Awaitable[set[bytes | str]]'
     |      Return the union of sets specified by ``keys``
     |
     |      For more information, see https://redis.io/commands/sunion
     |
     |  sunioncard(self, numkeys: 'int', keys: 'List[KeyT]', limit: 'int' = 0, approx: 'bool' = False) -> 'int | Awaitable[int]'
     |      Return the cardinality of the union of multiple sets specified by
     |      ``keys``, without returning the union itself.
     |
     |      When ``approx`` is True, the ``APPROX`` option is sent and the server
     |      returns an approximate cardinality computed using HyperLogLog.
     |
     |      When LIMIT is provided (defaults to 0 and means unlimited), the returned
     |      cardinality is capped at ``limit``. In exact mode the result equals
     |      ``limit`` when the real cardinality exceeds ``limit``; in approximate
     |      mode the result will not exceed ``limit``. Options are emitted in the
     |      canonical order ``APPROX`` before ``LIMIT``.
     |
     |      For more information, see https://redis.io/commands/sunioncard
     |
     |  sunionstore(self, dest: 'KeyT', keys: 'List', *args: 'List') -> 'int | Awaitable[int]'
     |      Store the union of sets specified by ``keys`` into a new
     |      set named ``dest``.  Returns the number of keys in the new set.
     |
     |      For more information, see https://redis.io/commands/sunionstore
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from redis.commands.core.StreamCommands:
     |
     |  xack(self, name: 'KeyT', groupname: 'GroupT', *ids: 'StreamIdT') -> 'int | Awaitable[int]'
     |      Acknowledges the successful processing of one or more messages.
     |
     |      Args:
     |          name: name of the stream.
     |          groupname: name of the consumer group.
     |          *ids: message ids to acknowledge.
     |
     |      For more information, see https://redis.io/commands/xack
     |
     |  xackdel(self, name: 'KeyT', groupname: 'GroupT', *ids: 'StreamIdT', ref_policy: "Literal['KEEPREF', 'DELREF', 'ACKED']" = 'KEEPREF') -> 'int | Awaitable[int]'
     |      Combines the functionality of XACK and XDEL. Acknowledges the specified
     |      message IDs in the given consumer group and simultaneously attempts to
     |      delete the corresponding entries from the stream.
     |
     |  xadd(self, name: 'KeyT', fields: 'Dict[FieldT, EncodableT]', id: 'StreamIdT' = '*', maxlen: 'Optional[int]' = None, approximate: 'bool' = True, nomkstream: 'bool' = False, minid: 'Union[StreamIdT, None]' = None, limit: 'int | None' = None, ref_policy: "Literal['KEEPREF', 'DELREF', 'ACKED'] | None" = None, idmpauto: 'str | None' = None, idmp: 'tuple[str, bytes] | None' = None) -> 'bytes | str | Awaitable[bytes | str]'
     |      Add to a stream.
     |      name: name of the stream
     |      fields: dict of field/value pairs to insert into the stream
     |      id: Location to insert this record. By default it is appended.
     |      maxlen: truncate old stream members beyond this size.
     |      Can't be specified with minid.
     |      approximate: actual stream length may be slightly more than maxlen
     |      nomkstream: When set to true, do not make a stream
     |      minid: the minimum id in the stream to query.
     |      Can't be specified with maxlen.
     |      limit: specifies the maximum number of entries to retrieve
     |      ref_policy: optional reference policy for consumer groups when trimming:
     |          - KEEPREF (default): When trimming, preserves references in consumer groups' PEL
     |          - DELREF: When trimming, removes all references from consumer groups' PEL
     |          - ACKED: When trimming, only removes entries acknowledged by all consumer groups
     |      idmpauto: Producer ID for automatic idempotent ID calculation.
     |          Automatically calculates an idempotent ID based on entry content to prevent
     |          duplicate entries. Can only be used with id='*'. Creates an IDMP map if it
     |          doesn't exist yet. The producer ID must be unique per producer and consistent
     |          across restarts.
     |      idmp: Tuple of (producer_id, idempotent_id) for explicit idempotent ID.
     |          Uses a specific idempotent ID to prevent duplicate entries. Can only be used
     |          with id='*'. The producer ID must be unique per producer and consistent across
     |          restarts. The idempotent ID must be unique per message and per producer.
     |          Shorter idempotent IDs require less memory and allow faster processing.
     |          Creates an IDMP map if it doesn't exist yet.
     |
     |      For more information, see https://redis.io/commands/xadd
     |
     |  xautoclaim(self, name: 'KeyT', groupname: 'GroupT', consumername: 'ConsumerT', min_idle_time: 'int', start_id: 'StreamIdT' = '0-0', count: 'int | None' = None, justid: 'bool' = False) -> 'list[Any] | Awaitable[list[Any]]'
     |      Transfers ownership of pending stream entries that match the specified
     |      criteria. Conceptually, equivalent to calling XPENDING and then XCLAIM,
     |      but provides a more straightforward way to deal with message delivery
     |      failures via SCAN-like semantics.
     |      name: name of the stream.
     |      groupname: name of the consumer group.
     |      consumername: name of a consumer that claims the message.
     |      min_idle_time: filter messages that were idle less than this amount of
     |      milliseconds.
     |      start_id: filter messages with equal or greater ID.
     |      count: optional integer, upper limit of the number of entries that the
     |      command attempts to claim. Set to 100 by default.
     |      justid: optional boolean, false by default. Return just an array of IDs
     |      of messages successfully claimed, without returning the actual message
     |
     |      For more information, see https://redis.io/commands/xautoclaim
     |
     |  xcfgset(self, name: 'KeyT', idmp_duration: 'int | None' = None, idmp_maxsize: 'int | None' = None) -> 'bytes | str | Awaitable[bytes | str]'
     |      Configure the idempotency parameters for a stream's IDMP map.
     |
     |      Sets how long Redis remembers each idempotent ID (iid) and the maximum
     |      number of iids to track. This command clears the existing IDMP map
     |      (Redis forgets all previously stored iids), but only if the configuration
     |      value actually changes.
     |
     |      Args:
     |          name: The name of the stream.
     |          idmp_duration: How long Redis remembers each iid in seconds.
     |              Default: 100 seconds (or value set by stream-idmp-duration config).
     |              Minimum: 1 second, Maximum: 300 seconds.
     |              Redis won't forget an iid for this duration (unless maxsize is reached).
     |              Should accommodate application crash recovery time.
     |          idmp_maxsize: Maximum number of iids Redis remembers per producer ID (pid).
     |              Default: 100 iids (or value set by stream-idmp-maxsize config).
     |              Minimum: 1 iid, Maximum: 1,000,000 (1M) iids.
     |              Should be set to: mark-delay [in msec] × (messages/msec) + margin.
     |              Example: 10K msgs/sec (10 msgs/msec), 80 msec mark-delay
     |              → maxsize = 10 × 80 + margin = 1000 iids.
     |
     |      Returns:
     |          OK on success.
     |
     |      For more information, see https://redis.io/commands/xcfgset
     |
     |  xclaim(self, name: 'KeyT', groupname: 'GroupT', consumername: 'ConsumerT', min_idle_time: 'int', message_ids: 'Union[List[StreamIdT], Tuple[StreamIdT]]', idle: 'int | None' = None, time: 'int | None' = None, retrycount: 'int | None' = None, force: 'bool' = False, justid: 'bool' = False) -> 'XClaimResponse | Awaitable[XClaimResponse]'
     |      Changes the ownership of a pending message.
     |
     |      name: name of the stream.
     |
     |      groupname: name of the consumer group.
     |
     |      consumername: name of a consumer that claims the message.
     |
     |      min_idle_time: filter messages that were idle less than this amount of
     |      milliseconds
     |
     |      message_ids: non-empty list or tuple of message IDs to claim
     |
     |      idle: optional. Set the idle time (last time it was delivered) of the
     |      message in ms
     |
     |      time: optional integer. This is the same as idle but instead of a
     |      relative amount of milliseconds, it sets the idle time to a specific
     |      Unix time (in milliseconds).
     |
     |      retrycount: optional integer. set the retry counter to the specified
     |      value. This counter is incremented every time a message is delivered
     |      again.
     |
     |      force: optional boolean, false by default. Creates the pending message
     |      entry in the PEL even if certain specified IDs are not already in the
     |      PEL assigned to a different client.
     |
     |      justid: optional boolean, false by default. Return just an array of IDs
     |      of messages successfully claimed, without returning the actual message
     |
     |      For more information, see https://redis.io/commands/xclaim
     |
     |  xdel(self, name: 'KeyT', *ids: 'StreamIdT') -> 'int | Awaitable[int]'
     |      Deletes one or more messages from a stream.
     |
     |      Args:
     |          name: name of the stream.
     |          *ids: message ids to delete.
     |
     |      For more information, see https://redis.io/commands/xdel
     |
     |  xdelex(self, name: 'KeyT', *ids: 'StreamIdT', ref_policy: "Literal['KEEPREF', 'DELREF', 'ACKED']" = 'KEEPREF') -> 'int | Awaitable[int]'
     |      Extended version of XDEL that provides more control over how message entries
     |      are deleted concerning consumer groups.
     |
     |  xgroup_create(self, name: 'KeyT', groupname: 'GroupT', id: 'StreamIdT' = '$', mkstream: 'bool' = False, entries_read: 'int | None' = None) -> 'bool | Awaitable[bool]'
     |      Create a new consumer group associated with a stream.
     |      name: name of the stream.
     |      groupname: name of the consumer group.
     |      id: ID of the last item in the stream to consider already delivered.
     |
     |      For more information, see https://redis.io/commands/xgroup-create
     |
     |  xgroup_createconsumer(self, name: 'KeyT', groupname: 'GroupT', consumername: 'ConsumerT') -> 'int | Awaitable[int]'
     |      Consumers in a consumer group are auto-created every time a new
     |      consumer name is mentioned by some command.
     |      They can be explicitly created by using this command.
     |      name: name of the stream.
     |      groupname: name of the consumer group.
     |      consumername: name of consumer to create.
     |
     |      See: https://redis.io/commands/xgroup-createconsumer
     |
     |  xgroup_delconsumer(self, name: 'KeyT', groupname: 'GroupT', consumername: 'ConsumerT') -> 'int | Awaitable[int]'
     |      Remove a specific consumer from a consumer group.
     |      Returns the number of pending messages that the consumer had before it
     |      was deleted.
     |      name: name of the stream.
     |      groupname: name of the consumer group.
     |      consumername: name of consumer to delete
     |
     |      For more information, see https://redis.io/commands/xgroup-delconsumer
     |
     |  xgroup_destroy(self, name: 'KeyT', groupname: 'GroupT') -> 'bool | Awaitable[bool]'
     |      Destroy a consumer group.
     |      name: name of the stream.
     |      groupname: name of the consumer group.
     |
     |      For more information, see https://redis.io/commands/xgroup-destroy
     |
     |  xgroup_setid(self, name: 'KeyT', groupname: 'GroupT', id: 'StreamIdT', entries_read: 'int | None' = None) -> 'bool | Awaitable[bool]'
     |      Set the consumer group last delivered ID to something else.
     |      name: name of the stream.
     |      groupname: name of the consumer group.
     |      id: ID of the last item in the stream to consider already delivered.
     |
     |      For more information, see https://redis.io/commands/xgroup-setid
     |
     |  xinfo_consumers(self, name: 'KeyT', groupname: 'GroupT') -> 'list[dict[str, Any]] | Awaitable[list[dict[str, Any]]]'
     |      Returns general information about the consumers in the group.
     |      name: name of the stream.
     |      groupname: name of the consumer group.
     |
     |      For more information, see https://redis.io/commands/xinfo-consumers
     |
     |  xinfo_groups(self, name: 'KeyT') -> 'list[dict[str, Any]] | Awaitable[list[dict[str, Any]]]'
     |      Returns general information about the consumer groups of the stream.
     |      name: name of the stream.
     |
     |      For more information, see https://redis.io/commands/xinfo-groups
     |
     |  xinfo_stream(self, name: 'KeyT', full: 'bool' = False) -> 'dict[str, Any] | Awaitable[dict[str, Any]]'
     |      Returns general information about the stream.
     |      name: name of the stream.
     |      full: optional boolean, false by default. Return full summary
     |
     |      For more information, see https://redis.io/commands/xinfo-stream
     |
     |  xlen(self, name: 'KeyT') -> 'int | Awaitable[int]'
     |      Returns the number of elements in a given stream.
     |
     |      For more information, see https://redis.io/commands/xlen
     |
     |  xnack(self, name: 'KeyT', groupname: 'GroupT', mode: "Literal['SILENT', 'FAIL', 'FATAL']", *ids: 'StreamIdT', retrycount: 'int | None' = None, force: 'bool' = False) -> 'int | Awaitable[int]'
     |      Negatively acknowledges one or more messages in a consumer group's
     |      Pending Entries List (PEL).
     |
     |      Args:
     |          name: name of the stream.
     |          groupname: name of the consumer group.
     |          mode: the nacking mode. One of SILENT, FAIL, or FATAL.
     |              SILENT: consumer shutting down; decrements delivery counter.
     |              FAIL: consumer unable to process; delivery counter unchanged.
     |              FATAL: invalid/malicious message; delivery counter set to max.
     |          *ids: one or more message IDs to NACK.
     |          retrycount: optional integer >= 0. Overrides the mode's implicit
     |              delivery counter adjustment with an exact value.
     |          force: if True, creates a new unowned PEL entry for any ID not
     |              already in the group's PEL.
     |
     |      Returns:
     |          The number of messages successfully NACKed.
     |
     |      For more information, see https://redis.io/commands/xnack
     |
     |  xpending(self, name: 'KeyT', groupname: 'GroupT') -> 'dict[str, Any] | Awaitable[dict[str, Any]]'
     |      Returns information about pending messages of a group.
     |      name: name of the stream.
     |      groupname: name of the consumer group.
     |
     |      For more information, see https://redis.io/commands/xpending
     |
     |  xpending_range(self, name: 'KeyT', groupname: 'GroupT', min: 'StreamIdT', max: 'StreamIdT', count: 'int', consumername: 'ConsumerT | None' = None, idle: 'int | None' = None) -> 'XPendingRangeResponse | Awaitable[XPendingRangeResponse]'
     |      Returns information about pending messages, in a range.
     |
     |      name: name of the stream.
     |      groupname: name of the consumer group.
     |      idle: available from  version 6.2. filter entries by their
     |      idle-time, given in milliseconds (optional).
     |      min: minimum stream ID.
     |      max: maximum stream ID.
     |      count: number of messages to return
     |      consumername: name of a consumer to filter by (optional).
     |
     |  xrange(self, name: 'KeyT', min: 'StreamIdT' = '-', max: 'StreamIdT' = '+', count: 'int | None' = None) -> 'StreamRangeResponse | None | Awaitable[StreamRangeResponse | None]'
     |      Read stream values within an interval.
     |
     |      name: name of the stream.
     |
     |      start: first stream ID. defaults to '-',
     |             meaning the earliest available.
     |
     |      finish: last stream ID. defaults to '+',
     |              meaning the latest available.
     |
     |      count: if set, only return this many items, beginning with the
     |             earliest available.
     |
     |      For more information, see https://redis.io/commands/xrange
     |
     |  xread(self, streams: 'Dict[KeyT, StreamIdT]', count: 'int | None' = None, block: 'int | None' = None, max_count: 'int | None' = None, max_size: 'int | None' = None) -> 'XReadResponse | Awaitable[XReadResponse]'
     |      Block and monitor multiple streams for new data.
     |
     |      streams: a dict of stream names to stream IDs, where
     |                 IDs indicate the last ID already seen.
     |
     |      count: if set, only return this many items per stream, beginning with
     |             the earliest available.
     |
     |      block: number of milliseconds to wait, if nothing already present.
     |
     |      max_count: if set, cap the total number of entries returned across all
     |                 streams combined. Unlike ``count`` (a per-stream limit),
     |                 this is a cumulative cap over the whole reply. Must be a
     |                 positive integer and, when ``count`` is also set, must be
     |                 greater than or equal to ``count``. Requires Redis >= 8.10.0.
     |
     |      max_size: if set, a soft cap on the total server reply size in bytes
     |                across all streams combined. Measured server-side including
     |                protocol overhead, so it is not an exact application-payload
     |                size guarantee; a single available entry larger than the cap
     |                may still be returned. Must be a positive integer. Requires
     |                Redis >= 8.10.0.
     |
     |      For more information, see https://redis.io/commands/xread
     |
     |  xreadgroup(self, groupname: 'str', consumername: 'str', streams: 'Dict[KeyT, StreamIdT]', count: 'int | None' = None, block: 'int | None' = None, noack: 'bool' = False, claim_min_idle_time: 'int | None' = None, max_count: 'int | None' = None, max_size: 'int | None' = None) -> 'XReadGroupResponse | Awaitable[XReadGroupResponse]'
     |      Read from a stream via a consumer group.
     |
     |      groupname: name of the consumer group.
     |
     |      consumername: name of the requesting consumer.
     |
     |      streams: a dict of stream names to stream IDs, where
     |             IDs indicate the last ID already seen.
     |
     |      count: if set, only return this many items per stream, beginning with
     |             the earliest available.
     |
     |      block: number of milliseconds to wait, if nothing already present.
     |      noack: do not add messages to the PEL
     |
     |      claim_min_idle_time: accepts an integer type and represents a
     |                           time interval in milliseconds
     |
     |      max_count: if set, cap the total number of entries returned across all
     |                 streams combined. Unlike ``count`` (a per-stream limit),
     |                 this is a cumulative cap over the whole reply. Must be a
     |                 positive integer and, when ``count`` is also set, must be
     |                 greater than or equal to ``count``. Requires Redis 8.10.0.
     |
     |      max_size: if set, a soft cap on the total server reply size in bytes
     |                across all streams combined. Measured server-side including
     |                protocol overhead, so it is not an exact application-payload
     |                size guarantee; a single available entry larger than the cap
     |                may still be returned. Must be a positive integer. Requires
     |                Redis 8.10.0.
     |
     |      For more information, see https://redis.io/commands/xreadgroup
     |
     |  xrevrange(self, name: 'KeyT', max: 'StreamIdT' = '+', min: 'StreamIdT' = '-', count: 'int | None' = None) -> 'StreamRangeResponse | None | Awaitable[StreamRangeResponse | None]'
     |      Read stream values within an interval, in reverse order.
     |
     |      name: name of the stream
     |
     |      start: first stream ID. defaults to '+',
     |             meaning the latest available.
     |
     |      finish: last stream ID. defaults to '-',
     |              meaning the earliest available.
     |
     |      count: if set, only return this many items, beginning with the
     |             latest available.
     |
     |      For more information, see https://redis.io/commands/xrevrange
     |
     |  xtrim(self, name: 'KeyT', maxlen: 'int | None' = None, approximate: 'bool' = True, minid: 'StreamIdT | None' = None, limit: 'int | None' = None, ref_policy: "Literal['KEEPREF', 'DELREF', 'ACKED'] | None" = None) -> 'int | Awaitable[int]'
     |      Trims old messages from a stream.
     |      name: name of the stream.
     |      maxlen: truncate old stream messages beyond this size
     |      Can't be specified with minid.
     |      approximate: actual stream length may be slightly more than maxlen
     |      minid: the minimum id in the stream to query
     |      Can't be specified with maxlen.
     |      limit: specifies the maximum number of entries to retrieve
     |      ref_policy: optional reference policy for consumer groups:
     |          - KEEPREF (default): Trims entries but preserves references in consumer groups' PEL
     |          - DELREF: Trims entries and removes all references from consumer groups' PEL
     |          - ACKED: Only trims entries that were read and acknowledged by all consumer groups
     |
     |      For more information, see https://redis.io/commands/xtrim
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from redis.commands.core.SortedSetCommands:
     |
     |  bzmpop(self, timeout: 'float', numkeys: 'int', keys: 'List[str]', min: 'bool | None' = False, max: 'bool | None' = False, count: 'int | None' = 1) -> 'ZMPopResponse | Awaitable[ZMPopResponse]'
     |      Pop ``count`` values (default 1) off of the first non-empty sorted set
     |      named in the ``keys`` list.
     |
     |      If none of the sorted sets in ``keys`` has a value to pop,
     |      then block for ``timeout`` seconds, or until a member gets added
     |      to one of the sorted sets.
     |
     |      If timeout is 0, then block indefinitely.
     |
     |      For more information, see https://redis.io/commands/bzmpop
     |
     |  bzpopmax(self, keys: 'KeysT', timeout: 'TimeoutSecT' = 0) -> 'BlockingZSetPopResponse | Awaitable[BlockingZSetPopResponse]'
     |      ZPOPMAX a value off of the first non-empty sorted set
     |      named in the ``keys`` list.
     |
     |      If none of the sorted sets in ``keys`` has a value to ZPOPMAX,
     |      then block for ``timeout`` seconds, or until a member gets added
     |      to one of the sorted sets.
     |
     |      If timeout is 0, then block indefinitely.
     |
     |      For more information, see https://redis.io/commands/bzpopmax
     |
     |  bzpopmin(self, keys: 'KeysT', timeout: 'TimeoutSecT' = 0) -> 'BlockingZSetPopResponse | Awaitable[BlockingZSetPopResponse]'
     |      ZPOPMIN a value off of the first non-empty sorted set
     |      named in the ``keys`` list.
     |
     |      If none of the sorted sets in ``keys`` has a value to ZPOPMIN,
     |      then block for ``timeout`` seconds, or until a member gets added
     |      to one of the sorted sets.
     |
     |      If timeout is 0, then block indefinitely.
     |
     |      For more information, see https://redis.io/commands/bzpopmin
     |
     |  zadd(self, name: 'KeyT', mapping: 'Mapping[AnyKeyT, EncodableT]', nx: 'bool' = False, xx: 'bool' = False, ch: 'bool' = False, incr: 'bool' = False, gt: 'bool' = False, lt: 'bool' = False) -> 'int | float | None | Awaitable[int | float | None]'
     |      Set any number of element-name, score pairs to the key ``name``. Pairs
     |      are specified as a dict of element-names keys to score values.
     |
     |      ``nx`` forces ZADD to only create new elements and not to update
     |      scores for elements that already exist.
     |
     |      ``xx`` forces ZADD to only update scores of elements that already
     |      exist. New elements will not be added.
     |
     |      ``ch`` modifies the return value to be the numbers of elements changed.
     |      Changed elements include new elements that were added and elements
     |      whose scores changed.
     |
     |      ``incr`` modifies ZADD to behave like ZINCRBY. In this mode only a
     |      single element/score pair can be specified and the score is the amount
     |      the existing score will be incremented by. When using this mode the
     |      return value of ZADD will be the new score of the element.
     |
     |      ``lt`` only updates existing elements if the new score is less than
     |      the current score. This flag doesn't prevent adding new elements.
     |
     |      ``gt`` only updates existing elements if the new score is greater than
     |      the current score. This flag doesn't prevent adding new elements.
     |
     |      The return value of ZADD varies based on the mode specified. With no
     |      options, ZADD returns the number of new elements added to the sorted
     |      set.
     |
     |      ``nx``, ``lt``, and ``gt`` are mutually exclusive options.
     |
     |      See: https://redis.io/commands/ZADD
     |
     |  zcard(self, name: 'KeyT') -> 'int | Awaitable[int]'
     |      Return the number of elements in the sorted set ``name``
     |
     |      For more information, see https://redis.io/commands/zcard
     |
     |  zcount(self, name: 'KeyT', min: 'ZScoreBoundT', max: 'ZScoreBoundT') -> 'int | Awaitable[int]'
     |      Returns the number of elements in the sorted set at key ``name`` with
     |      a score between ``min`` and ``max``.
     |
     |      For more information, see https://redis.io/commands/zcount
     |
     |  zdiff(self, keys: 'KeysT', withscores: 'bool' = False) -> 'ZSetRangeResponse | Awaitable[ZSetRangeResponse]'
     |      Returns the difference between the first and all successive input
     |      sorted sets provided in ``keys``.
     |
     |      For more information, see https://redis.io/commands/zdiff
     |
     |  zdiffstore(self, dest: 'KeyT', keys: 'KeysT') -> 'int | Awaitable[int]'
     |      Computes the difference between the first and all successive input
     |      sorted sets provided in ``keys`` and stores the result in ``dest``.
     |
     |      For more information, see https://redis.io/commands/zdiffstore
     |
     |  zincrby(self, name: 'KeyT', amount: 'float', value: 'EncodableT') -> 'float | None | Awaitable[float | None]'
     |      Increment the score of ``value`` in sorted set ``name`` by ``amount``
     |
     |      For more information, see https://redis.io/commands/zincrby
     |
     |  zinter(self, keys: 'KeysT', aggregate: 'str | None' = None, withscores: 'bool' = False) -> 'ZSetRangeResponse | Awaitable[ZSetRangeResponse]'
     |      Return the intersect of multiple sorted sets specified by ``keys``.
     |
     |      With the ``aggregate`` option, it is possible to specify how the
     |      results of the intersection are aggregated. Available aggregation
     |      modes:
     |
     |      - ``SUM`` (default): the score of an element is summed across the
     |        inputs where it exists.
     |        Score = SUM(score₁×weight₁, score₂×weight₂, ...)
     |      - ``MIN``: the resulting set will contain the minimum score of an
     |        element across the inputs where it exists.
     |        Score = MIN(score₁×weight₁, score₂×weight₂, ...)
     |      - ``MAX``: the resulting set will contain the maximum score of an
     |        element across the inputs where it exists.
     |        Score = MAX(score₁×weight₁, score₂×weight₂, ...)
     |      - ``COUNT``: ignores the original scores and counts weighted set
     |        membership. Each element's score is the sum of the weights of
     |        the input sets that contain it.
     |        Score = SUM(weight₁, weight₂, ...) for sets containing the element.
     |        When all weights are 1 (default), the score equals the number
     |        of input sets containing the element.
     |
     |      For more information, see https://redis.io/commands/zinter
     |
     |  zintercard(self, numkeys: 'int', keys: 'List[str]', limit: 'int' = 0) -> 'int | Awaitable[int]'
     |      Return the cardinality of the intersect of multiple sorted sets
     |      specified by ``keys``.
     |      When LIMIT provided (defaults to 0 and means unlimited), if the intersection
     |      cardinality reaches limit partway through the computation, the algorithm will
     |      exit and yield limit as the cardinality
     |
     |      For more information, see https://redis.io/commands/zintercard
     |
     |  zinterstore(self, dest: 'KeyT', keys: 'Sequence[KeyT] | Mapping[AnyKeyT, float]', aggregate: 'str | None' = None) -> 'int | Awaitable[int]'
     |      Intersect multiple sorted sets specified by ``keys`` into a new
     |      sorted set, ``dest``. Scores in the destination will be aggregated
     |      based on the ``aggregate``.
     |
     |      Available aggregation modes:
     |
     |      - ``SUM`` (default): the score of an element is summed across the
     |        inputs where it exists.
     |        Score = SUM(score₁×weight₁, score₂×weight₂, ...)
     |      - ``MIN``: the resulting set will contain the minimum score of an
     |        element across the inputs where it exists.
     |        Score = MIN(score₁×weight₁, score₂×weight₂, ...)
     |      - ``MAX``: the resulting set will contain the maximum score of an
     |        element across the inputs where it exists.
     |        Score = MAX(score₁×weight₁, score₂×weight₂, ...)
     |      - ``COUNT``: ignores the original scores and counts weighted set
     |        membership. Each element's score is the sum of the weights of
     |        the input sets that contain it.
     |        Score = SUM(weight₁, weight₂, ...) for sets containing the element.
     |        When all weights are 1 (default), the score equals the number
     |        of input sets containing the element.
     |
     |      For more information, see https://redis.io/commands/zinterstore
     |
     |  zlexcount(self, name: 'KeyT', min: 'EncodableT', max: 'EncodableT') -> 'int | Awaitable[int]'
     |      Return the number of items in the sorted set ``name`` between the
     |      lexicographical range ``min`` and ``max``.
     |
     |      For more information, see https://redis.io/commands/zlexcount
     |
     |  zmpop(self, num_keys: 'int', keys: 'List[str]', min: 'bool | None' = False, max: 'bool | None' = False, count: 'int | None' = 1) -> 'ZMPopResponse | Awaitable[ZMPopResponse]'
     |      Pop ``count`` values (default 1) off of the first non-empty sorted set
     |      named in the ``keys`` list.
     |      For more information, see https://redis.io/commands/zmpop
     |
     |  zmscore(self, key: 'KeyT', members: 'List[str]') -> 'list[float | None] | Awaitable[list[float | None]]'
     |      Returns the scores associated with the specified members
     |      in the sorted set stored at key.
     |      ``members`` should be a list of the member name.
     |      Return type is a list of score.
     |      If the member does not exist, a None will be returned
     |      in corresponding position.
     |
     |      For more information, see https://redis.io/commands/zmscore
     |
     |  zpopmax(self, name: 'KeyT', count: 'int | None' = None) -> 'ZSetRangeResponse | Awaitable[ZSetRangeResponse]'
     |      Remove and return up to ``count`` members with the highest scores
     |      from the sorted set ``name``.
     |
     |      For more information, see https://redis.io/commands/zpopmax
     |
     |  zpopmin(self, name: 'KeyT', count: 'int | None' = None) -> 'ZSetRangeResponse | Awaitable[ZSetRangeResponse]'
     |      Remove and return up to ``count`` members with the lowest scores
     |      from the sorted set ``name``.
     |
     |      For more information, see https://redis.io/commands/zpopmin
     |
     |  zrandmember(self, key: 'KeyT', count: 'int | None' = None, withscores: 'bool' = False) -> 'ZRandMemberResponse | Awaitable[ZRandMemberResponse]'
     |      Return a random element from the sorted set value stored at key.
     |
     |      ``count`` if the argument is positive, return an array of distinct
     |      fields. If called with a negative count, the behavior changes and
     |      the command is allowed to return the same field multiple times.
     |      In this case, the number of returned fields is the absolute value
     |      of the specified count.
     |
     |      ``withscores`` The optional WITHSCORES modifier changes the reply so it
     |      includes the respective scores of the randomly selected elements from
     |      the sorted set.
     |
     |      For more information, see https://redis.io/commands/zrandmember
     |
     |  zrange(self, name: 'KeyT', start: 'EncodableT', end: 'EncodableT', desc: 'bool' = False, withscores: 'bool' = False, score_cast_func: 'type | Callable' = <class 'float'>, byscore: 'bool' = False, bylex: 'bool' = False, offset: 'int | None' = None, num: 'int | None' = None) -> 'ZSetRangeResponse | Awaitable[ZSetRangeResponse]'
     |      Return a range of values from sorted set ``name`` between
     |      ``start`` and ``end`` sorted in ascending order.
     |
     |      ``start`` and ``end`` can be negative, indicating the end of the range.
     |
     |      ``desc`` a boolean indicating whether to sort the results in reversed
     |      order.
     |
     |      ``withscores`` indicates to return the scores along with the values.
     |      The return type is a list of (value, score) pairs.
     |
     |      ``score_cast_func`` a callable used to cast the score return value.
     |
     |      ``byscore`` when set to True, returns the range of elements from the
     |      sorted set having scores equal or between ``start`` and ``end``.
     |
     |      ``bylex`` when set to True, returns the range of elements from the
     |      sorted set between the ``start`` and ``end`` lexicographical closed
     |      range intervals.
     |      Valid ``start`` and ``end`` must start with ( or [, in order to specify
     |      whether the range interval is exclusive or inclusive, respectively.
     |
     |      ``offset`` and ``num`` are specified, then return a slice of the range.
     |      Can't be provided when using ``bylex``.
     |
     |      For more information, see https://redis.io/commands/zrange
     |
     |  zrangebylex(self, name: 'KeyT', min: 'EncodableT', max: 'EncodableT', start: 'int | None' = None, num: 'int | None' = None) -> 'list[bytes | str] | Awaitable[list[bytes | str]]'
     |      Return the lexicographical range of values from sorted set ``name``
     |      between ``min`` and ``max``.
     |
     |      If ``start`` and ``num`` are specified, then return a slice of the
     |      range.
     |
     |      For more information, see https://redis.io/commands/zrangebylex
     |
     |  zrangebyscore(self, name: 'KeyT', min: 'ZScoreBoundT', max: 'ZScoreBoundT', start: 'int | None' = None, num: 'int | None' = None, withscores: 'bool' = False, score_cast_func: 'type | Callable' = <class 'float'>) -> 'ZSetRangeResponse | Awaitable[ZSetRangeResponse]'
     |      Return a range of values from the sorted set ``name`` with scores
     |      between ``min`` and ``max``.
     |
     |      If ``start`` and ``num`` are specified, then return a slice
     |      of the range.
     |
     |      ``withscores`` indicates to return the scores along with the values.
     |      The return type is a list of (value, score) pairs
     |
     |      `score_cast_func`` a callable used to cast the score return value
     |
     |      For more information, see https://redis.io/commands/zrangebyscore
     |
     |  zrangestore(self, dest: 'KeyT', name: 'KeyT', start: 'EncodableT', end: 'EncodableT', byscore: 'bool' = False, bylex: 'bool' = False, desc: 'bool' = False, offset: 'int | None' = None, num: 'int | None' = None) -> 'int | Awaitable[int]'
     |      Stores in ``dest`` the result of a range of values from sorted set
     |      ``name`` between ``start`` and ``end`` sorted in ascending order.
     |
     |      ``start`` and ``end`` can be negative, indicating the end of the range.
     |
     |      ``byscore`` when set to True, returns the range of elements from the
     |      sorted set having scores equal or between ``start`` and ``end``.
     |
     |      ``bylex`` when set to True, returns the range of elements from the
     |      sorted set between the ``start`` and ``end`` lexicographical closed
     |      range intervals.
     |      Valid ``start`` and ``end`` must start with ( or [, in order to specify
     |      whether the range interval is exclusive or inclusive, respectively.
     |
     |      ``desc`` a boolean indicating whether to sort the results in reversed
     |      order.
     |
     |      ``offset`` and ``num`` are specified, then return a slice of the range.
     |      Can't be provided when using ``bylex``.
     |
     |      For more information, see https://redis.io/commands/zrangestore
     |
     |  zrank(self, name: 'KeyT', value: 'EncodableT', withscore: 'bool' = False, score_cast_func: 'type | Callable' = <class 'float'>) -> 'int | list[Any] | None | Awaitable[int | list[Any] | None]'
     |      Returns a 0-based value indicating the rank of ``value`` in sorted set
     |      ``name``.
     |      The optional WITHSCORE argument supplements the command's
     |      reply with the score of the element returned.
     |
     |      ``score_cast_func`` a callable used to cast the score return value
     |
     |      For more information, see https://redis.io/commands/zrank
     |
     |  zrem(self, name: 'KeyT', *values: 'FieldT') -> 'int | Awaitable[int]'
     |      Remove member ``values`` from sorted set ``name``
     |
     |      For more information, see https://redis.io/commands/zrem
     |
     |  zremrangebylex(self, name: 'KeyT', min: 'EncodableT', max: 'EncodableT') -> 'int | Awaitable[int]'
     |      Remove all elements in the sorted set ``name`` between the
     |      lexicographical range specified by ``min`` and ``max``.
     |
     |      Returns the number of elements removed.
     |
     |      For more information, see https://redis.io/commands/zremrangebylex
     |
     |  zremrangebyrank(self, name: 'KeyT', min: 'int', max: 'int') -> 'int | Awaitable[int]'
     |      Remove all elements in the sorted set ``name`` with ranks between
     |      ``min`` and ``max``. Values are 0-based, ordered from smallest score
     |      to largest. Values can be negative indicating the highest scores.
     |      Returns the number of elements removed
     |
     |      For more information, see https://redis.io/commands/zremrangebyrank
     |
     |  zremrangebyscore(self, name: 'KeyT', min: 'ZScoreBoundT', max: 'ZScoreBoundT') -> 'int | Awaitable[int]'
     |      Remove all elements in the sorted set ``name`` with scores
     |      between ``min`` and ``max``. Returns the number of elements removed.
     |
     |      For more information, see https://redis.io/commands/zremrangebyscore
     |
     |  zrevrange(self, name: 'KeyT', start: 'int', end: 'int', withscores: 'bool' = False, score_cast_func: 'type | Callable' = <class 'float'>) -> 'ZSetRangeResponse | Awaitable[ZSetRangeResponse]'
     |      Return a range of values from sorted set ``name`` between
     |      ``start`` and ``end`` sorted in descending order.
     |
     |      ``start`` and ``end`` can be negative, indicating the end of the range.
     |
     |      ``withscores`` indicates to return the scores along with the values
     |      The return type is a list of (value, score) pairs
     |
     |      ``score_cast_func`` a callable used to cast the score return value
     |
     |      For more information, see https://redis.io/commands/zrevrange
     |
     |  zrevrangebylex(self, name: 'KeyT', max: 'EncodableT', min: 'EncodableT', start: 'int | None' = None, num: 'int | None' = None) -> 'list[bytes | str] | Awaitable[list[bytes | str]]'
     |      Return the reversed lexicographical range of values from sorted set
     |      ``name`` between ``max`` and ``min``.
     |
     |      If ``start`` and ``num`` are specified, then return a slice of the
     |      range.
     |
     |      For more information, see https://redis.io/commands/zrevrangebylex
     |
     |  zrevrangebyscore(self, name: 'KeyT', max: 'ZScoreBoundT', min: 'ZScoreBoundT', start: 'int | None' = None, num: 'int | None' = None, withscores: 'bool' = False, score_cast_func: 'type | Callable' = <class 'float'>) -> 'ZSetRangeResponse | Awaitable[ZSetRangeResponse]'
     |      Return a range of values from the sorted set ``name`` with scores
     |      between ``min`` and ``max`` in descending order.
     |
     |      If ``start`` and ``num`` are specified, then return a slice
     |      of the range.
     |
     |      ``withscores`` indicates to return the scores along with the values.
     |      The return type is a list of (value, score) pairs
     |
     |      ``score_cast_func`` a callable used to cast the score return value
     |
     |      For more information, see https://redis.io/commands/zrevrangebyscore
     |
     |  zrevrank(self, name: 'KeyT', value: 'EncodableT', withscore: 'bool' = False, score_cast_func: 'type | Callable' = <class 'float'>) -> 'int | list[Any] | None | Awaitable[int | list[Any] | None]'
     |      Returns a 0-based value indicating the descending rank of
     |      ``value`` in sorted set ``name``.
     |      The optional ``withscore`` argument supplements the command's
     |      reply with the score of the element returned.
     |
     |      ``score_cast_func`` a callable used to cast the score return value
     |
     |      For more information, see https://redis.io/commands/zrevrank
     |
     |  zscore(self, name: 'KeyT', value: 'EncodableT') -> 'float | None | Awaitable[float | None]'
     |      Return the score of element ``value`` in sorted set ``name``
     |
     |      For more information, see https://redis.io/commands/zscore
     |
     |  zunion(self, keys: 'Sequence[KeyT] | Mapping[AnyKeyT, float]', aggregate: 'str | None' = None, withscores: 'bool' = False, score_cast_func: 'type | Callable' = <class 'float'>) -> 'ZSetRangeResponse | Awaitable[ZSetRangeResponse]'
     |      Return the union of multiple sorted sets specified by ``keys``.
     |      ``keys`` can be provided as dictionary of keys and their weights.
     |      Scores will be aggregated based on the ``aggregate``, or SUM if
     |      none is provided.
     |
     |      Available aggregation modes:
     |
     |      - ``SUM`` (default): the score of an element is summed across the
     |        inputs where it exists.
     |        Score = SUM(score₁×weight₁, score₂×weight₂, ...)
     |      - ``MIN``: the resulting set will contain the minimum score of an
     |        element across the inputs where it exists.
     |        Score = MIN(score₁×weight₁, score₂×weight₂, ...)
     |      - ``MAX``: the resulting set will contain the maximum score of an
     |        element across the inputs where it exists.
     |        Score = MAX(score₁×weight₁, score₂×weight₂, ...)
     |      - ``COUNT``: ignores the original scores and counts weighted set
     |        membership. Each element's score is the sum of the weights of
     |        the input sets that contain it.
     |        Score = SUM(weight₁, weight₂, ...) for sets containing the element.
     |        When all weights are 1 (default), the score equals the number
     |        of input sets containing the element.
     |
     |      ``score_cast_func`` a callable used to cast the score return value
     |
     |      For more information, see https://redis.io/commands/zunion
     |
     |  zunionstore(self, dest: 'KeyT', keys: 'Sequence[KeyT] | Mapping[AnyKeyT, float]', aggregate: 'str | None' = None) -> 'int | Awaitable[int]'
     |      Union multiple sorted sets specified by ``keys`` into
     |      a new sorted set, ``dest``. Scores in the destination will be
     |      aggregated based on the ``aggregate``, or SUM if none is provided.
     |
     |      Available aggregation modes:
     |
     |      - ``SUM`` (default): the score of an element is summed across the
     |        inputs where it exists.
     |        Score = SUM(score₁×weight₁, score₂×weight₂, ...)
     |      - ``MIN``: the resulting set will contain the minimum score of an
     |        element across the inputs where it exists.
     |        Score = MIN(score₁×weight₁, score₂×weight₂, ...)
     |      - ``MAX``: the resulting set will contain the maximum score of an
     |        element across the inputs where it exists.
     |        Score = MAX(score₁×weight₁, score₂×weight₂, ...)
     |      - ``COUNT``: ignores the original scores and counts weighted set
     |        membership. Each element's score is the sum of the weights of
     |        the input sets that contain it.
     |        Score = SUM(weight₁, weight₂, ...) for sets containing the element.
     |        When all weights are 1 (default), the score equals the number
     |        of input sets containing the element.
     |
     |      For more information, see https://redis.io/commands/zunionstore
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from redis.commands.core.ManagementCommands:
     |
     |  auth(self, password: 'str', username: 'str | None' = None, **kwargs) -> 'bool | Awaitable[bool]'
     |      Authenticates the user. If you do not pass username, Redis will try to
     |      authenticate for the "default" user. If you do pass username, it will
     |      authenticate for the given user.
     |      For more information, see https://redis.io/commands/auth
     |
     |  bgrewriteaof(self, **kwargs) -> 'bool | bytes | str | Awaitable[bool | bytes | str]'
     |      Tell the Redis server to rewrite the AOF file from data in memory.
     |
     |      For more information, see https://redis.io/commands/bgrewriteaof
     |
     |  bgsave(self, schedule: 'bool' = True, **kwargs) -> 'bool | bytes | str | Awaitable[bool | bytes | str]'
     |      Tell the Redis server to save its data to disk.  Unlike save(),
     |      this method is asynchronous and returns immediately.
     |
     |      For more information, see https://redis.io/commands/bgsave
     |
     |  client_getname(self, **kwargs) -> 'bytes | str | None | Awaitable[bytes | str | None]'
     |      Returns the current connection name
     |
     |      For more information, see https://redis.io/commands/client-getname
     |
     |  client_getredir(self, **kwargs) -> 'int | Awaitable[int]'
     |      Returns the ID (an integer) of the client to whom we are
     |      redirecting tracking notifications.
     |
     |      see: https://redis.io/commands/client-getredir
     |
     |  client_id(self, **kwargs) -> 'int | Awaitable[int]'
     |      Returns the current connection id
     |
     |      For more information, see https://redis.io/commands/client-id
     |
     |  client_info(self, **kwargs) -> 'dict[str, str | int] | Awaitable[dict[str, str | int]]'
     |      Returns information and statistics about the current
     |      client connection.
     |
     |      For more information, see https://redis.io/commands/client-info
     |
     |  client_kill(self, address: 'str', **kwargs) -> 'bool | int | Awaitable[bool | int]'
     |      Disconnects the client at ``address`` (ip:port)
     |
     |      For more information, see https://redis.io/commands/client-kill
     |
     |  client_kill_filter(self, _id: 'str | None' = None, _type: 'str | None' = None, addr: 'str | None' = None, skipme: 'bool | None' = None, laddr: 'bool | None' = None, user: 'str | None' = None, maxage: 'int | None' = None, **kwargs) -> 'int | Awaitable[int]'
     |      Disconnects client(s) using a variety of filter options
     |      :param _id: Kills a client by its unique ID field
     |      :param _type: Kills a client by type where type is one of 'normal',
     |      'master', 'slave', 'replica' or 'pubsub'
     |      :param addr: Kills a client by its 'address:port'
     |      :param skipme: If True, then the client calling the command
     |      will not get killed even if it is identified by one of the filter
     |      options. If skipme is not provided, the server defaults to skipme=True
     |      :param laddr: Kills a client by its 'local (bind) address:port'
     |      :param user: Kills a client for a specific user name
     |      :param maxage: Kills clients that are older than the specified age in seconds
     |
     |  client_list(self, _type: 'str | None' = None, client_id: 'List[EncodableT]' = [], **kwargs) -> 'list[dict[str, str]] | Awaitable[list[dict[str, str]]]'
     |      Returns a list of currently connected clients.
     |      If type of client specified, only that type will be returned.
     |
     |      :param _type: optional. one of the client types (normal, master,
     |       replica, pubsub)
     |      :param client_id: optional. a list of client ids
     |
     |      For more information, see https://redis.io/commands/client-list
     |
     |  client_no_evict(self, mode: 'str') -> 'bytes | str | Awaitable[bytes | str]'
     |      Sets the client eviction mode for the current connection.
     |
     |      For more information, see https://redis.io/commands/client-no-evict
     |
     |  client_no_touch(self, mode: 'str') -> 'bytes | str | Awaitable[bytes | str]'
     |      # The command controls whether commands sent by the client will alter
     |      # the LRU/LFU of the keys they access.
     |      # When turned on, the current client will not change LFU/LRU stats,
     |      # unless it sends the TOUCH command.
     |
     |      For more information, see https://redis.io/commands/client-no-touch
     |
     |  client_pause(self, timeout: 'int', all: 'bool' = True, **kwargs) -> 'bool | Awaitable[bool]'
     |      Suspend all the Redis clients for the specified amount of time.
     |
     |
     |      For more information, see https://redis.io/commands/client-pause
     |
     |      Args:
     |          timeout: milliseconds to pause clients
     |          all: If true (default) all client commands are blocked.
     |               otherwise, clients are only blocked if they attempt to execute
     |               a write command.
     |
     |      For the WRITE mode, some commands have special behavior:
     |
     |      * EVAL/EVALSHA: Will block client for all scripts.
     |      * PUBLISH: Will block client.
     |      * PFCOUNT: Will block client.
     |      * WAIT: Acknowledgments will be delayed, so this command will
     |          appear blocked.
     |
     |  client_reply(self, reply: "Literal['ON', 'OFF', 'SKIP']", **kwargs) -> 'bytes | str | Awaitable[bytes | str]'
     |      Enable and disable redis server replies.
     |
     |      ``reply`` Must be ON OFF or SKIP,
     |      ON - The default most with server replies to commands
     |      OFF - Disable server responses to commands
     |      SKIP - Skip the response of the immediately following command.
     |
     |      Note: When setting OFF or SKIP replies, you will need a client object
     |      with a timeout specified in seconds, and will need to catch the
     |      TimeoutError.
     |      The test_client_reply unit test illustrates this, and
     |      conftest.py has a client with a timeout.
     |
     |      See https://redis.io/commands/client-reply
     |
     |  client_setinfo(self, attr: 'str', value: 'str', **kwargs) -> 'bool | Awaitable[bool]'
     |      Sets the current connection library name or version
     |      For more information see https://redis.io/commands/client-setinfo
     |
     |  client_setname(self, name: 'str', **kwargs) -> 'bool | Awaitable[bool]'
     |      Sets the current connection name
     |
     |      For more information, see https://redis.io/commands/client-setname
     |
     |      .. note::
     |         This method sets client name only for **current** connection.
     |
     |         If you want to set a common name for all connections managed
     |         by this client, use ``client_name`` constructor argument.
     |
     |  client_tracking(self, on: 'bool' = True, clientid: 'int | None' = None, prefix: 'Sequence[KeyT]' = [], bcast: 'bool' = False, optin: 'bool' = False, optout: 'bool' = False, noloop: 'bool' = False, **kwargs) -> 'bytes | str | Awaitable[bytes | str]'
     |      Enables the tracking feature of the Redis server, that is used
     |      for server assisted client side caching.
     |
     |      ``on`` indicate for tracking on or tracking off. The default is on.
     |
     |      ``clientid`` send invalidation messages to the connection with
     |      the specified ID.
     |
     |      ``bcast`` enable tracking in broadcasting mode. In this mode
     |      invalidation messages are reported for all the prefixes
     |      specified, regardless of the keys requested by the connection.
     |
     |      ``optin``  when broadcasting is NOT active, normally don't track
     |      keys in read only commands, unless they are called immediately
     |      after a CLIENT CACHING yes command.
     |
     |      ``optout`` when broadcasting is NOT active, normally track keys in
     |      read only commands, unless they are called immediately after a
     |      CLIENT CACHING no command.
     |
     |      ``noloop`` don't send notifications about keys modified by this
     |      connection itself.
     |
     |      ``prefix``  for broadcasting, register a given key prefix, so that
     |      notifications will be provided only for keys starting with this string.
     |
     |      See https://redis.io/commands/client-tracking
     |
     |  client_tracking_off(self, clientid: 'int | None' = None, prefix: 'Sequence[KeyT]' = [], bcast: 'bool' = False, optin: 'bool' = False, optout: 'bool' = False, noloop: 'bool' = False) -> 'bytes | str | Awaitable[bytes | str]'
     |      Turn off the tracking mode.
     |      For more information, about the options look at client_tracking func.
     |
     |      See https://redis.io/commands/client-tracking
     |
     |  client_tracking_on(self, clientid: 'int | None' = None, prefix: 'Sequence[KeyT]' = [], bcast: 'bool' = False, optin: 'bool' = False, optout: 'bool' = False, noloop: 'bool' = False) -> 'bytes | str | Awaitable[bytes | str]'
     |      Turn on the tracking mode.
     |      For more information, about the options look at client_tracking func.
     |
     |      See https://redis.io/commands/client-tracking
     |
     |  client_trackinginfo(self, **kwargs) -> 'ClientTrackingInfoResponse | Awaitable[ClientTrackingInfoResponse]'
     |      Returns the information about the current client connection's
     |      use of the server assisted client side cache.
     |
     |      See https://redis.io/commands/client-trackinginfo
     |
     |  client_unblock(self, client_id: 'int', error: 'bool' = False, **kwargs) -> 'bool | Awaitable[bool]'
     |      Unblocks a connection by its client id.
     |      If ``error`` is True, unblocks the client with a special error message.
     |      If ``error`` is False (default), the client is unblocked using the
     |      regular timeout mechanism.
     |
     |      For more information, see https://redis.io/commands/client-unblock
     |
     |  client_unpause(self, **kwargs) -> 'bytes | str | Awaitable[bytes | str]'
     |      Unpause all redis clients
     |
     |      For more information, see https://redis.io/commands/client-unpause
     |
     |  command(self, **kwargs) -> 'dict[str, dict[str, Any]] | Awaitable[dict[str, dict[str, Any]]]'
     |      Returns dict reply of details about all Redis commands.
     |
     |      For more information, see https://redis.io/commands/command
     |
     |  command_count(self, **kwargs) -> 'int | Awaitable[int]'
     |
     |  command_docs(self, *args)
     |      This function throws a NotImplementedError since it is intentionally
     |      not supported.
     |
     |  command_getkeysandflags(self, *args: 'str') -> 'CommandGetKeysAndFlagsResponse | Awaitable[CommandGetKeysAndFlagsResponse]'
     |      Returns array of keys from a full Redis command and their usage flags.
     |
     |      For more information, see https://redis.io/commands/command-getkeysandflags
     |
     |  command_info(self, **kwargs) -> 'None'
     |
     |  command_list(self, module: 'str | None' = None, category: 'str | None' = None, pattern: 'str | None' = None) -> 'list[bytes | str] | Awaitable[list[bytes | str]]'
     |      Return an array of the server's command names.
     |      You can use one of the following filters:
     |      ``module``: get the commands that belong to the module
     |      ``category``: get the commands in the ACL category
     |      ``pattern``: get the commands that match the given pattern
     |
     |      For more information, see https://redis.io/commands/command-list/
     |
     |  config_get(self, pattern: 'PatternT' = '*', *args: 'PatternT', **kwargs) -> 'dict[str | None, str | None] | Awaitable[dict[str | None, str | None]]'
     |      Return a dictionary of configuration based on the ``pattern``
     |
     |      For more information, see https://redis.io/commands/config-get
     |
     |  config_resetstat(self, **kwargs) -> 'bool | Awaitable[bool]'
     |      Reset runtime statistics
     |
     |      For more information, see https://redis.io/commands/config-resetstat
     |
     |  config_rewrite(self, **kwargs) -> 'bytes | str | Awaitable[bytes | str]'
     |      Rewrite config file with the minimal change to reflect running config.
     |
     |      For more information, see https://redis.io/commands/config-rewrite
     |
     |  config_set(self, name: 'KeyT', value: 'EncodableT', *args: 'Union[KeyT, EncodableT]', **kwargs) -> 'bool | Awaitable[bool]'
     |      Set config item ``name`` with ``value``
     |
     |      For more information, see https://redis.io/commands/config-set
     |
     |  dbsize(self, **kwargs) -> 'int | Awaitable[int]'
     |      Returns the number of keys in the current database
     |
     |      For more information, see https://redis.io/commands/dbsize
     |
     |  debug_object(self, key: 'KeyT', **kwargs) -> 'dict[str, str | int] | bytes | str | Awaitable[dict[str, str | int] | bytes | str]'
     |      Returns version specific meta information about a given key
     |
     |      For more information, see https://redis.io/commands/debug-object
     |
     |  debug_segfault(self, **kwargs) -> 'None'
     |
     |  echo(self, value: 'EncodableT', **kwargs) -> 'bytes | str | Awaitable[bytes | str]'
     |      Echo the string back from the server
     |
     |      For more information, see https://redis.io/commands/echo
     |
     |  failover(self)
     |      This function throws a NotImplementedError since it is intentionally
     |      not supported.
     |
     |  flushall(self, asynchronous: 'bool' = False, **kwargs) -> 'bool | Awaitable[bool]'
     |      Delete all keys in all databases on the current host.
     |
     |      ``asynchronous`` indicates whether the operation is
     |      executed asynchronously by the server.
     |
     |      For more information, see https://redis.io/commands/flushall
     |
     |  flushdb(self, asynchronous: 'bool' = False, **kwargs) -> 'bool | Awaitable[bool]'
     |      Delete all keys in the current database.
     |
     |      ``asynchronous`` indicates whether the operation is
     |      executed asynchronously by the server.
     |
     |      For more information, see https://redis.io/commands/flushdb
     |
     |  hello(self)
     |      This function throws a NotImplementedError since it is intentionally
     |      not supported.
     |
     |  hotkeys_get(self, **kwargs) -> 'Union[Awaitable[list[dict[str | bytes, Any]]], list[dict[str | bytes, Any]]]'
     |      Retrieve the result of the ongoing collection session (if any),
     |      or the last collection session (if any).
     |
     |      HOTKEYS GET response is wrapped in an array for aggregation support.
     |      Each node returns a single-element array, allowing multiple node
     |      responses to be concatenated by DMC or other aggregators.
     |
     |      For more information, see https://redis.io/commands/hotkeys-get
     |
     |  hotkeys_reset(self, **kwargs) -> 'bytes | str | Awaitable[bytes | str]'
     |      Discard the last hotkeys collection session results (in order to save memory).
     |      Error if there is an ongoing collection session.
     |
     |      For more information, see https://redis.io/commands/hotkeys-reset
     |
     |  hotkeys_start(self, metrics: 'List[HotkeysMetricsTypes]', count: 'int | None' = None, duration: 'int | None' = None, sample_ratio: 'int | None' = None, slots: 'List[int] | None' = None, **kwargs) -> 'bytes | str | Awaitable[bytes | str]'
     |      Start collecting hotkeys data.
     |      Returns an error if there is an ongoing collection session.
     |
     |      Args:
     |          count: The number of keys to collect in each criteria (CPU and network consumption)
     |          metrics: List of metrics to track. Supported values: [HotkeysMetricsTypes.CPU, HotkeysMetricsTypes.NET]
     |          duration: Automatically stop the collection after `duration` seconds
     |          sample_ratio: Commands are sampled with probability 1/ratio (1 means no sampling)
     |          slots: Only track keys on the specified hash slots
     |
     |      For more information, see https://redis.io/commands/hotkeys-start
     |
     |  hotkeys_stop(self, **kwargs) -> 'bytes | str | Awaitable[bytes | str]'
     |      Stop the ongoing hotkeys collection session (if any).
     |      The results of the last collection session are kept for consumption with HOTKEYS GET.
     |
     |      For more information, see https://redis.io/commands/hotkeys-stop
     |
     |  info(self, section: 'Optional[str]' = None, *args: 'str', **kwargs) -> 'dict[str, Any] | Awaitable[dict[str, Any]]'
     |      Returns a dictionary containing information about the Redis server
     |
     |      The ``section`` option can be used to select a specific section
     |      of information
     |
     |      The section option is not supported by older versions of Redis Server,
     |      and will generate ResponseError
     |
     |      For more information, see https://redis.io/commands/info
     |
     |  lastsave(self, **kwargs) -> 'datetime.datetime | Awaitable[datetime.datetime]'
     |      Return a Python datetime object representing the last time the
     |      Redis database was saved to disk
     |
     |      For more information, see https://redis.io/commands/lastsave
     |
     |  latency_doctor(self)
     |      Raise a NotImplementedError, as the client will not support LATENCY DOCTOR.
     |      This function is best used within the redis-cli.
     |
     |      For more information, see https://redis.io/commands/latency-doctor
     |
     |  latency_graph(self)
     |      Raise a NotImplementedError, as the client will not support LATENCY GRAPH.
     |      This function is best used within the redis-cli.
     |
     |      For more information, see https://redis.io/commands/latency-graph.
     |
     |  latency_histogram(self, *args)
     |      This function throws a NotImplementedError since it is intentionally
     |      not supported.
     |
     |  latency_history(self, event: 'str') -> 'list[list[int]] | Awaitable[list[list[int]]]'
     |      Returns the raw data of the ``event``'s latency spikes time series.
     |
     |      For more information, see https://redis.io/commands/latency-history
     |
     |  latency_latest(self) -> 'list[list[bytes | str | int]] | Awaitable[list[list[bytes | str | int]]]'
     |      Reports the latest latency events logged.
     |
     |      For more information, see https://redis.io/commands/latency-latest
     |
     |  latency_reset(self, *events: 'str') -> 'int | Awaitable[int]'
     |      Resets the latency spikes time series of all, or only some, events.
     |
     |      For more information, see https://redis.io/commands/latency-reset
     |
     |  lolwut(self, *version_numbers: 'Union[str, float]', **kwargs) -> 'bytes | str | Awaitable[bytes | str]'
     |      Get the Redis version and a piece of generative computer art
     |
     |      See: https://redis.io/commands/lolwut
     |
     |  memory_doctor(self, **kwargs) -> 'None'
     |
     |  memory_help(self, **kwargs) -> 'None'
     |
     |  memory_malloc_stats(self, **kwargs) -> 'bytes | str | Awaitable[bytes | str]'
     |      Return an internal statistics report from the memory allocator.
     |
     |      See: https://redis.io/commands/memory-malloc-stats
     |
     |  memory_purge(self, **kwargs) -> 'bool | Awaitable[bool]'
     |      Attempts to purge dirty pages for reclamation by allocator
     |
     |      For more information, see https://redis.io/commands/memory-purge
     |
     |  memory_stats(self, **kwargs) -> 'dict[str, Any] | Awaitable[dict[str, Any]]'
     |      Return a dictionary of memory stats
     |
     |      For more information, see https://redis.io/commands/memory-stats
     |
     |  memory_usage(self, key: 'KeyT', samples: 'int | None' = None, **kwargs) -> 'int | None | Awaitable[int | None]'
     |      Return the total memory usage for key, its value and associated
     |      administrative overheads.
     |
     |      For nested data structures, ``samples`` is the number of elements to
     |      sample. If left unspecified, the server's default is 5. Use 0 to sample
     |      all elements.
     |
     |      For more information, see https://redis.io/commands/memory-usage
     |
     |  migrate(self, host: 'str', port: 'int', keys: 'KeysT', destination_db: 'int', timeout: 'int', copy: 'bool' = False, replace: 'bool' = False, auth: 'str | None' = None, **kwargs) -> 'bytes | str | Awaitable[bytes | str]'
     |      Migrate 1 or more keys from the current Redis server to a different
     |      server specified by the ``host``, ``port`` and ``destination_db``.
     |
     |      The ``timeout``, specified in milliseconds, indicates the maximum
     |      time the connection between the two servers can be idle before the
     |      command is interrupted.
     |
     |      If ``copy`` is True, the specified ``keys`` are NOT deleted from
     |      the source server.
     |
     |      If ``replace`` is True, this operation will overwrite the keys
     |      on the destination server if they exist.
     |
     |      If ``auth`` is specified, authenticate to the destination server with
     |      the password provided.
     |
     |      For more information, see https://redis.io/commands/migrate
     |
     |  object(self, infotype: 'str', key: 'KeyT', **kwargs) -> 'Any | Awaitable[Any]'
     |      Return the encoding, idletime, or refcount about the key
     |
     |  ping(self, **kwargs) -> 'Union[Awaitable[bool], bool]'
     |      Ping the Redis server to test connectivity.
     |
     |      Sends a PING command to the Redis server and returns True if the server
     |      responds with "PONG".
     |
     |      This command is useful for:
     |      - Testing whether a connection is still alive
     |      - Verifying the server's ability to serve data
     |
     |      For more information on the underlying ping command see https://redis.io/commands/ping
     |
     |  psync(self, replicationid: 'str', offset: 'int') -> 'bytes | Awaitable[bytes]'
     |      Initiates a replication stream from the master.
     |      Newer version for `sync`.
     |
     |      For more information, see https://redis.io/commands/sync
     |
     |  quit(self, **kwargs) -> 'bool | Awaitable[bool]'
     |      Ask the server to close the connection.
     |
     |      For more information, see https://redis.io/commands/quit
     |
     |  replicaof(self, *args, **kwargs) -> 'bytes | str | Awaitable[bytes | str]'
     |      Update the replication settings of a redis replica, on the fly.
     |
     |      Examples of valid arguments include:
     |
     |      NO ONE (set no replication)
     |      host port (set to the host and port of a redis server)
     |
     |      For more information, see  https://redis.io/commands/replicaof
     |
     |  reset(self) -> 'bytes | str | Awaitable[bytes | str]'
     |      Perform a full reset on the connection's server-side context.
     |
     |      See: https://redis.io/commands/reset
     |
     |  role(self) -> 'list[Any] | Awaitable[list[Any]]'
     |      Provide information on the role of a Redis instance in
     |      the context of replication, by returning if the instance
     |      is currently a master, slave, or sentinel.
     |
     |      For more information, see https://redis.io/commands/role
     |
     |  save(self, **kwargs) -> 'bool | Awaitable[bool]'
     |      Tell the Redis server to save its data to disk,
     |      blocking until the save is complete
     |
     |      For more information, see https://redis.io/commands/save
     |
     |  select(self, index: 'int', **kwargs) -> 'bool | Awaitable[bool]'
     |      Select the Redis logical database at index.
     |
     |      See: https://redis.io/commands/select
     |
     |  shutdown(self, save: 'bool' = False, nosave: 'bool' = False, now: 'bool' = False, force: 'bool' = False, abort: 'bool' = False, **kwargs) -> 'None'
     |      Shutdown the Redis server.  If Redis has persistence configured,
     |      data will be flushed before shutdown.
     |      It is possible to specify modifiers to alter the behavior of the command:
     |      ``save`` will force a DB saving operation even if no save points are configured.
     |      ``nosave`` will prevent a DB saving operation even if one or more save points
     |      are configured.
     |      ``now`` skips waiting for lagging replicas, i.e. it bypasses the first step in
     |      the shutdown sequence.
     |      ``force`` ignores any errors that would normally prevent the server from exiting
     |      ``abort`` cancels an ongoing shutdown and cannot be combined with other flags.
     |
     |      For more information, see https://redis.io/commands/shutdown
     |
     |  slaveof(self, host: 'str | None' = None, port: 'int | None' = None, **kwargs) -> 'bool | Awaitable[bool]'
     |      Set the server to be a replicated slave of the instance identified
     |      by the ``host`` and ``port``. If called without arguments, the
     |      instance is promoted to a master instead.
     |
     |      For more information, see https://redis.io/commands/slaveof
     |
     |  slowlog_get(self, num: 'int | None' = None, **kwargs) -> 'list[dict[str, Any]] | Awaitable[list[dict[str, Any]]]'
     |      Get the entries from the slowlog. If ``num`` is specified, get the
     |      most recent ``num`` items.
     |
     |      For more information, see https://redis.io/commands/slowlog-get
     |
     |  slowlog_len(self, **kwargs) -> 'int | Awaitable[int]'
     |      Get the number of items in the slowlog
     |
     |      For more information, see https://redis.io/commands/slowlog-len
     |
     |  slowlog_reset(self, **kwargs) -> 'bool | Awaitable[bool]'
     |      Remove all items in the slowlog
     |
     |      For more information, see https://redis.io/commands/slowlog-reset
     |
     |  swapdb(self, first: 'int', second: 'int', **kwargs) -> 'bool | Awaitable[bool]'
     |      Swap two databases
     |
     |      For more information, see https://redis.io/commands/swapdb
     |
     |  sync(self) -> 'bytes | Awaitable[bytes]'
     |      Initiates a replication stream from the master.
     |
     |      For more information, see https://redis.io/commands/sync
     |
     |  time(self, **kwargs) -> 'tuple[int, int] | Awaitable[tuple[int, int]]'
     |      Returns the server time as a 2-item tuple of ints:
     |      (seconds since epoch, microseconds into this second).
     |
     |      For more information, see https://redis.io/commands/time
     |
     |  wait(self, num_replicas: 'int', timeout: 'int', **kwargs) -> 'int | Awaitable[int]'
     |      Redis synchronous replication
     |      That returns the number of replicas that processed the query when
     |      we finally have at least ``num_replicas``, or when the ``timeout`` was
     |      reached.
     |
     |      For more information, see https://redis.io/commands/wait
     |
     |  waitaof(self, num_local: 'int', num_replicas: 'int', timeout: 'int', **kwargs) -> 'list[int] | Awaitable[list[int]]'
     |      This command blocks the current client until all previous write
     |      commands by that client are acknowledged as having been fsynced
     |      to the AOF of the local Redis and/or at least the specified number
     |      of replicas.
     |
     |      For more information, see https://redis.io/commands/waitaof
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from redis.commands.core.ModuleCommands:
     |
     |  command_getkeys(self, *args) -> 'list[bytes | str] | Awaitable[list[bytes | str]]'
     |
     |  module_list(self) -> 'list[dict[Any, Any]] | Awaitable[list[dict[Any, Any]]]'
     |      Returns a list of dictionaries containing the name and version of
     |      all loaded modules.
     |
     |      For more information, see https://redis.io/commands/module-list
     |
     |  module_load(self, path, *args) -> 'bool | Awaitable[bool]'
     |      Loads the module from ``path``.
     |      Passes all ``*args`` to the module, during loading.
     |      Raises ``ModuleError`` if a module is not found at ``path``.
     |
     |      For more information, see https://redis.io/commands/module-load
     |
     |  module_loadex(self, path: 'str', options: 'List[str] | None' = None, args: 'List[str] | None' = None) -> 'bytes | str | Awaitable[bytes | str]'
     |      Loads a module from a dynamic library at runtime with configuration directives.
     |
     |      For more information, see https://redis.io/commands/module-loadex
     |
     |  module_unload(self, name) -> 'bool | Awaitable[bool]'
     |      Unloads the module ``name``.
     |      Raises ``ModuleError`` if ``name`` is not in loaded modules.
     |
     |      For more information, see https://redis.io/commands/module-unload
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from redis.commands.core.PubSubCommands:
     |
     |  publish(self, channel: 'ChannelT', message: 'EncodableT', **kwargs) -> 'int | Awaitable[int]'
     |      Publish ``message`` on ``channel``.
     |      Returns the number of subscribers the message was delivered to.
     |
     |      For more information, see https://redis.io/commands/publish
     |
     |  pubsub_channels(self, pattern: 'PatternT' = '*', **kwargs) -> 'list[bytes | str] | Awaitable[list[bytes | str]]'
     |      Return a list of channels that have at least one subscriber
     |
     |      For more information, see https://redis.io/commands/pubsub-channels
     |
     |  pubsub_numpat(self, **kwargs) -> 'int | Awaitable[int]'
     |      Returns the number of subscriptions to patterns
     |
     |      For more information, see https://redis.io/commands/pubsub-numpat
     |
     |  pubsub_numsub(self, *args: 'ChannelT', **kwargs) -> 'list[tuple[bytes | str, int]] | Awaitable[list[tuple[bytes | str, int]]]'
     |      Return a list of (channel, number of subscribers) tuples
     |      for each channel given in ``*args``
     |
     |      For more information, see https://redis.io/commands/pubsub-numsub
     |
     |  pubsub_shardchannels(self, pattern: 'PatternT' = '*', **kwargs) -> 'list[bytes | str] | Awaitable[list[bytes | str]]'
     |      Return a list of shard_channels that have at least one subscriber
     |
     |      For more information, see https://redis.io/commands/pubsub-shardchannels
     |
     |  pubsub_shardnumsub(self, *args: 'ChannelT', **kwargs) -> 'list[tuple[bytes | str, int]] | Awaitable[list[tuple[bytes | str, int]]]'
     |      Return a list of (shard_channel, number of subscribers) tuples
     |      for each channel given in ``*args``
     |
     |      For more information, see https://redis.io/commands/pubsub-shardnumsub
     |
     |  spublish(self, shard_channel: 'ChannelT', message: 'EncodableT') -> 'int | Awaitable[int]'
     |      Posts a message to the given shard channel.
     |      Returns the number of clients that received the message
     |
     |      For more information, see https://redis.io/commands/spublish
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from redis.commands.core.ScriptCommands:
     |
     |  eval(self, script: 'str', numkeys: 'int', *keys_and_args: 'KeyT | EncodableT') -> 'Any | Awaitable[Any]'
     |      Execute the Lua ``script``, specifying the ``numkeys`` the script
     |      will touch and the key names and argument values in ``keys_and_args``.
     |      Returns the result of the script.
     |
     |      In practice, use the object returned by ``register_script``. This
     |      function exists purely for Redis API completion.
     |
     |      For more information, see  https://redis.io/commands/eval
     |
     |  eval_ro(self, script: 'str', numkeys: 'int', *keys_and_args: 'KeyT | EncodableT') -> 'Any | Awaitable[Any]'
     |      The read-only variant of the EVAL command
     |
     |      Execute the read-only Lua ``script`` specifying the ``numkeys`` the script
     |      will touch and the key names and argument values in ``keys_and_args``.
     |      Returns the result of the script.
     |
     |      For more information, see  https://redis.io/commands/eval_ro
     |
     |  evalsha(self, sha: 'str', numkeys: 'int', *keys_and_args: 'KeyT | EncodableT') -> 'Any | Awaitable[Any]'
     |      Use the ``sha`` to execute a Lua script already registered via EVAL
     |      or SCRIPT LOAD. Specify the ``numkeys`` the script will touch and the
     |      key names and argument values in ``keys_and_args``. Returns the result
     |      of the script.
     |
     |      In practice, use the object returned by ``register_script``. This
     |      function exists purely for Redis API completion.
     |
     |      For more information, see  https://redis.io/commands/evalsha
     |
     |  evalsha_ro(self, sha: 'str', numkeys: 'int', *keys_and_args: 'KeyT | EncodableT') -> 'Any | Awaitable[Any]'
     |      The read-only variant of the EVALSHA command
     |
     |      Use the ``sha`` to execute a read-only Lua script already registered via EVAL
     |      or SCRIPT LOAD. Specify the ``numkeys`` the script will touch and the
     |      key names and argument values in ``keys_and_args``. Returns the result
     |      of the script.
     |
     |      For more information, see  https://redis.io/commands/evalsha_ro
     |
     |  register_script(self: "Union['redis.client.Redis', 'redis.cluster.RedisCluster']", script: 'ScriptTextT') -> 'Script'
     |      Register a Lua ``script`` specifying the ``keys`` it will touch.
     |      Returns a Script object that is callable and hides the complexity of
     |      deal with scripts, keys, and shas. This is the preferred way to work
     |      with Lua scripts.
     |
     |  script_debug(self, *args) -> 'None'
     |
     |  script_exists(self, *args: 'str') -> 'list[bool] | Awaitable[list[bool]]'
     |      Check if a script exists in the script cache by specifying the SHAs of
     |      each script as ``args``. Returns a list of boolean values indicating if
     |      if each already script exists in the cache_data.
     |
     |      For more information, see  https://redis.io/commands/script-exists
     |
     |  script_flush(self, sync_type: "Literal['SYNC'] | Literal['ASYNC'] | None" = None) -> 'bool | Awaitable[bool]'
     |      Flush all scripts from the script cache_data.
     |
     |      ``sync_type`` is by default SYNC (synchronous) but it can also be
     |                    ASYNC.
     |
     |      For more information, see  https://redis.io/commands/script-flush
     |
     |  script_kill(self) -> 'bool | Awaitable[bool]'
     |      Kill the currently executing Lua script
     |
     |      For more information, see https://redis.io/commands/script-kill
     |
     |  script_load(self, script: 'ScriptTextT') -> 'str | Awaitable[str]'
     |      Load a Lua ``script`` into the script cache_data. Returns the SHA.
     |
     |      For more information, see https://redis.io/commands/script-load
     |
     |  ----------------------------------------------------------------------
     |  Data and other attributes inherited from redis.typing.CommandsProtocol:
     |
     |  __protocol_attrs__ = {'_event_dispatcher', 'execute_command'}
     |
     |  ----------------------------------------------------------------------
     |  Class methods inherited from typing.Protocol:
     |
     |  __init_subclass__(*args, **kwargs)
     |      This method is called when a class is subclassed.
     |
     |      The default implementation does nothing. It may be
     |      overridden to extend subclasses.
     |
     |  ----------------------------------------------------------------------
     |  Class methods inherited from typing.Generic:
     |
     |  __class_getitem__(...)
     |      Parameterizes a generic class.
     |
     |      At least, parameterizing a generic class is the *main* thing this
     |      method does. For example, for some generic class `Foo`, this is called
     |      when we do `Foo[int]` - there, with `cls=Foo` and `params=int`.
     |
     |      However, note that this method is also called when defining generic
     |      classes in the first place with `class Foo[T]: ...`.
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from redis.commands.core.FunctionCommands:
     |
     |  fcall(self, function, numkeys: 'int', *keys_and_args: 'Any') -> 'Any | Awaitable[Any]'
     |      Invoke a function.
     |
     |      For more information, see https://redis.io/commands/fcall
     |
     |  fcall_ro(self, function, numkeys: 'int', *keys_and_args: 'Any') -> 'Any | Awaitable[Any]'
     |      This is a read-only variant of the FCALL command that cannot
     |      execute commands that modify data.
     |
     |      For more information, see https://redis.io/commands/fcall_ro
     |
     |  function_delete(self, library: 'str') -> 'bool | Awaitable[bool]'
     |      Delete the library called ``library`` and all its functions.
     |
     |      For more information, see https://redis.io/commands/function-delete
     |
     |  function_dump(self) -> 'bytes | Awaitable[bytes]'
     |      Return the serialized payload of loaded libraries.
     |
     |      For more information, see https://redis.io/commands/function-dump
     |
     |  function_flush(self, mode: 'str' = 'SYNC') -> 'bool | Awaitable[bool]'
     |      Deletes all the libraries.
     |
     |      For more information, see https://redis.io/commands/function-flush
     |
     |  function_kill(self) -> 'bytes | str | Awaitable[bytes | str]'
     |      Kill a function that is currently executing.
     |
     |      For more information, see https://redis.io/commands/function-kill
     |
     |  function_list(self, library: 'str | None' = '*', withcode: 'bool | None' = False) -> 'list[Any] | Awaitable[list[Any]]'
     |      Return information about the functions and libraries.
     |
     |      Args:
     |
     |          library: specify a pattern for matching library names
     |          withcode: cause the server to include the libraries source implementation
     |              in the reply
     |
     |  function_load(self, code: 'str', replace: 'bool | None' = False) -> 'bytes | str | Awaitable[bytes | str]'
     |      Load a library to Redis.
     |      :param code: the source code (must start with
     |      Shebang statement that provides a metadata about the library)
     |      :param replace: changes the behavior to overwrite the existing library
     |      with the new contents.
     |      Return the library name that was loaded.
     |
     |      For more information, see https://redis.io/commands/function-load
     |
     |  function_restore(self, payload: 'str', policy: 'str | None' = 'APPEND') -> 'bool | Awaitable[bool]'
     |      Restore libraries from the serialized ``payload``.
     |      You can use the optional policy argument to provide a policy
     |      for handling existing libraries.
     |
     |      For more information, see https://redis.io/commands/function-restore
     |
     |  function_stats(self) -> 'Any | Awaitable[Any]'
     |      Return information about the function that's currently running
     |      and information about the available execution engines.
     |
     |      For more information, see https://redis.io/commands/function-stats
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from redis.commands.sentinel.SentinelCommands:
     |
     |  sentinel(self, *args)
     |      Redis Sentinel's SENTINEL command.
     |
     |  sentinel_ckquorum(self, new_master_name) -> Union[bool, Awaitable[bool]]
     |      Check if the current Sentinel configuration is able to reach the
     |      quorum needed to failover a master, and the majority needed to
     |      authorize the failover.
     |
     |      This command should be used in monitoring systems to check if a
     |      Sentinel deployment is ok.
     |
     |  sentinel_failover(self, new_master_name) -> Union[bool, Awaitable[bool]]
     |      Force a failover as if the master was not reachable, and without
     |      asking for agreement to other Sentinels (however a new version of the
     |      configuration will be published so that the other Sentinels will
     |      update their configurations).
     |
     |  sentinel_flushconfig(self) -> Union[bool, Awaitable[bool]]
     |      Force Sentinel to rewrite its configuration on disk, including the
     |      current Sentinel state.
     |
     |      Normally Sentinel rewrites the configuration every time something
     |      changes in its state (in the context of the subset of the state which
     |      is persisted on disk across restart).
     |      However sometimes it is possible that the configuration file is lost
     |      because of operation errors, disk failures, package upgrade scripts or
     |      configuration managers. In those cases a way to to force Sentinel to
     |      rewrite the configuration file is handy.
     |
     |      This command works even if the previous configuration file is
     |      completely missing.
     |
     |  sentinel_get_master_addr_by_name(self, service_name, return_responses: bool = False) -> Union[tuple[bytes | str, int], NoneType, bool, Awaitable[tuple[bytes | str, int] | None | bool]]
     |      Returns a (host, port) pair for the given ``service_name`` when return_responses is True,
     |      otherwise returns a boolean value that indicates if the command was successful.
     |
     |  sentinel_master(self, service_name, return_responses: bool = False) -> Union[dict[str, Any], bool, Awaitable[dict[str, Any] | bool]]
     |      Returns a dictionary containing the specified masters state, when return_responses is True,
     |      otherwise returns a boolean value that indicates if the command was successful.
     |
     |  sentinel_masters(self) -> Union[dict[str, dict[str, Any]], list[dict[str, Any]], Awaitable[dict[str, dict[str, Any]] | list[dict[str, Any]]]]
     |      Returns a list of dictionaries containing each master's state.
     |
     |      Important: This function is called by the Sentinel implementation and is
     |      called directly on the Redis standalone client for sentinels,
     |      so it doesn't support the "once" and "return_responses" options.
     |
     |  sentinel_monitor(self, name, ip, port, quorum) -> Union[bool, Awaitable[bool]]
     |      Add a new master to Sentinel to be monitored
     |
     |  sentinel_remove(self, name) -> Union[bool, Awaitable[bool]]
     |      Remove a master from Sentinel's monitoring
     |
     |  sentinel_reset(self, pattern) -> Union[bool, Awaitable[bool]]
     |      This command will reset all the masters with matching name.
     |      The pattern argument is a glob-style pattern.
     |
     |      The reset process clears any previous state in a master (including a
     |      failover in progress), and removes every slave and sentinel already
     |      discovered and associated with the master.
     |
     |  sentinel_sentinels(self, service_name, return_responses: bool = False) -> Union[list[dict[str, Any]], bool, Awaitable[list[dict[str, Any]] | bool]]
     |      Returns a list of sentinels for ``service_name``, when return_responses is True,
     |      otherwise returns a boolean value that indicates if the command was successful.
     |
     |  sentinel_set(self, name, option, value) -> Union[bool, Awaitable[bool]]
     |      Set Sentinel monitoring parameters for a given master
     |
     |  sentinel_slaves(self, service_name) -> Union[list[dict[str, Any]], Awaitable[list[dict[str, Any]]]]
     |      Returns a list of slaves for ``service_name``
     |
     |      Important: This function is called by the Sentinel implementation and is
     |      called directly on the Redis standalone client for sentinels,
     |      so it doesn't support the "once" and "return_responses" options.

FUNCTIONS
    add_debug_log_for_operation_failure(connection: 'AbstractConnection')

    is_debug_log_enabled()

DATA
    Callable = typing.Callable
        Deprecated alias to collections.abc.Callable.

        Callable[[int], str] signifies a function that takes a single
        parameter of type int and returns a str.

        The subscription syntax must always be used with exactly two
        values: the argument list and the return type.
        The argument list must be a list of types, a ParamSpec,
        Concatenate or ellipsis. The return type must be a single type.

        There is no syntax to indicate optional or keyword arguments;
        such function types are rarely used as callback types.

    ChannelT = typing.Union[bytes, str, memoryview]
    DEFAULT_RETRY_BASE = 0.01
    DEFAULT_RETRY_CAP = 1
    DEFAULT_RETRY_COUNT = 10
    DEFAULT_SOCKET_CONNECT_TIMEOUT = 5
    DEFAULT_SOCKET_READ_SIZE = 32768
    DEFAULT_SOCKET_TIMEOUT = 5
    Dict = typing.Dict
        A generic version of dict.

    EMPTY_RESPONSE = 'EMPTY_RESPONSE'
    FieldT = typing.Union[bytes, bytearray, memoryview, str, int, float]
    Iterable = typing.Iterable
        A generic version of collections.abc.Iterable.

    List = typing.List
        A generic version of list.

    Literal = typing.Literal
        Special typing form to define literal types (a.k.a. value types).

        This form can be used to indicate to type checkers that the corresponding
        variable or function parameter has a value equivalent to the provided
        literal (or one of several literals)::

            def validate_simple(data: Any) -> Literal[True]:  # always returns True
                ...

            MODE = Literal['r', 'rb', 'w', 'wb']
            def open_helper(file: str, mode: MODE) -> str:
                ...

            open_helper('/some/path', 'r')  # Passes type check
            open_helper('/other/path', 'typo')  # Error in type checker

        Literal[...] cannot be subclassed. At runtime, an arbitrary value
        is allowed as type argument to Literal[...], but type checkers may
        impose restrictions.

    Mapping = typing.Mapping
        A generic version of collections.abc.Mapping.

    NEVER_DECODE = 'NEVER_DECODE'
    Optional = typing.Optional
        Optional[X] is equivalent to Union[X, None].

    PubSubHandler = typing.Callable[[dict[str, typing.Any]], typing.Any]
    SENTINEL = <object object>
    SYM_EMPTY = b''
    Set = typing.Set
        A generic version of set.

    TYPE_CHECKING = False
    Type = typing.Type
        Deprecated alias to builtins.type.

        builtins.type or typing.Type can be used to annotate class objects.
        For example, suppose we have the following classes::

            class User: ...  # Abstract base for User classes
            class BasicUser(User): ...
            class ProUser(User): ...
            class TeamUser(User): ...

        And a function that takes a class argument that's a subclass of
        User and returns an instance of the corresponding class::

            def new_user[U](user_class: Type[U]) -> U:
                user = user_class()
                # (Here we could write the user object to a database)
                return user

            joe = new_user(BasicUser)

        At this point the type checker knows that joe has type BasicUser.

    Union = typing.Union
        Union type; Union[X, Y] means either X or Y.

        On Python 3.10 and higher, the | operator
        can also be used to denote unions;
        X | Y means the same thing to the type checker as Union[X, Y].

        To define a union, use e.g. Union[int, str]. Details:
        - The arguments must be types and there must be at least one.
        - None as an argument is a special case and is replaced by
          type(None).
        - Unions of unions are flattened, e.g.::

            assert Union[Union[int, str], float] == Union[int, str, float]

        - Unions of a single argument vanish, e.g.::

            assert Union[int] == int  # The constructor actually returns int

        - Redundant arguments are skipped, e.g.::

            assert Union[int, str, int] == Union[int, str]

        - When comparing unions, the argument order is ignored, e.g.::

            assert Union[int, str] == Union[str, int]

        - You cannot subclass or instantiate a union.
        - You can use Optional[X] as a shorthand for Union[X, None].

    logger = <Logger redis.client (WARNING)>

FILE
    c:\users\youse\appdata\local\programs\python\python312\lib\site-packages\redis\client.py

Python Library Documentation: module redis.cluster in redis

NAME
    redis.cluster

CLASSES
    abc.ABC(builtins.object)
        ExecutionStrategy
            AbstractStrategy
                PipelineStrategy
                TransactionStrategy
    builtins.object
        AbstractRedisCluster
            RedisCluster(AbstractRedisCluster, MaintNotificationsAbstractRedisCluster, redis.commands.cluster.RedisClusterCommands)
                ClusterPipeline
        ClusterNode
        LoadBalancer
        MaintNotificationsAbstractRedisCluster
        NodeCommands
        NodesManager
        PipelineCommand
    enum.Enum(builtins.object)
        LoadBalancingStrategy
    redis.client.PubSub(builtins.object)
        ClusterPubSub
    redis.event.EventListenerInterface(abc.ABC)
        ClusterPubSubSlotsCacheListener

    class AbstractRedisCluster(builtins.object)
     |  Methods defined here:
     |
     |  replace_default_node(self, target_node: 'ClusterNode' = None) -> None
     |      Replace the default cluster node.
     |      A random cluster node will be chosen if target_node isn't passed, and primaries
     |      will be prioritized. The default node will not be changed if there are no other
     |      nodes in the cluster.
     |
     |      Args:
     |          target_node (ClusterNode, optional): Target node to replace the default
     |          node. Defaults to None.
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors defined here:
     |
     |  __dict__
     |      dictionary for instance variables
     |
     |  __weakref__
     |      list of weak references to the object
     |
     |  ----------------------------------------------------------------------
     |  Data and other attributes defined here:
     |
     |  ALL_NODES = 'all'
     |
     |  CLUSTER_COMMANDS_RESPONSE_CALLBACKS = {'CLUSTER MYSHARDID': <function ...
     |
     |  COMMAND_FLAGS = {'ACL CAT': 'default-node', 'ACL DELUSER': 'default-no...
     |
     |  DEFAULT_NODE = 'default-node'
     |
     |  ERRORS_ALLOW_RETRY = (<class 'redis.exceptions.ConnectionError'>, <cla...
     |
     |  NODE_FLAGS = {'all', 'default-node', 'primaries', 'random', 'replicas'...
     |
     |  PRIMARIES = 'primaries'
     |
     |  RANDOM = 'random'
     |
     |  REPLICAS = 'replicas'
     |
     |  RESULT_CALLBACKS = {'BGSAVE': <function AbstractRedisCluster.<lambda>>...
     |
     |  RedisClusterRequestTTL = 16
     |
     |  SEARCH_COMMANDS = (['FT.CREATE', 'FT.SEARCH', 'FT.AGGREGATE', 'FT.EXPL...
     |
     |  __annotations__ = {}

    class AbstractStrategy(ExecutionStrategy)
     |  AbstractStrategy(pipe: redis.cluster.ClusterPipeline)
     |
     |  Method resolution order:
     |      AbstractStrategy
     |      ExecutionStrategy
     |      abc.ABC
     |      builtins.object
     |
     |  Methods defined here:
     |
     |  __init__(self, pipe: redis.cluster.ClusterPipeline)
     |      Initialize self.  See help(type(self)) for accurate signature.
     |
     |  annotate_exception(self, exception, number, command)
     |      Provides extra context to the exception prior to it being handled
     |
     |  eval(self)
     |
     |  execute(self, raise_on_error: bool = True) -> List[Any]
     |      Executes current execution strategy.
     |
     |      See: ClusterPipeline.execute()
     |
     |  execute_command(self, *args, **kwargs)
     |      Execution flow for current execution strategy.
     |
     |      See: ClusterPipeline.execute_command()
     |
     |  exists(self, *keys)
     |
     |  load_scripts(self)
     |
     |  pipeline_execute_command(self, *args, **options)
     |      Pipeline execution flow for current execution strategy.
     |
     |      See: ClusterPipeline.pipeline_execute_command()
     |
     |  reset(self)
     |      Resets current execution strategy.
     |
     |      See: ClusterPipeline.reset()
     |
     |  script_load_for_pipeline(self, *args, **kwargs)
     |
     |  send_cluster_commands(self, stack, raise_on_error=True, allow_redirections=True)
     |      Sends commands according to current execution strategy.
     |
     |      See: ClusterPipeline.send_cluster_commands()
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors defined here:
     |
     |  command_queue
     |
     |  ----------------------------------------------------------------------
     |  Data and other attributes defined here:
     |
     |  __abstractmethods__ = frozenset({'delete', 'discard', 'execute', 'exec...
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from ExecutionStrategy:
     |
     |  delete(self, *names)
     |      "Delete a key specified by ``names``"
     |
     |      See: ClusterPipeline.delete()
     |
     |  discard(self)
     |
     |  multi(self)
     |      Starts transactional context.
     |
     |      See: ClusterPipeline.multi()
     |
     |  unlink(self, *names)
     |      "Unlink a key specified by ``names``"
     |
     |      See: ClusterPipeline.unlink()
     |
     |  unwatch(self)
     |      Unwatches all previously specified keys
     |
     |      See: ClusterPipeline.unwatch()
     |
     |  watch(self, *names)
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors inherited from ExecutionStrategy:
     |
     |  __dict__
     |      dictionary for instance variables
     |
     |  __weakref__
     |      list of weak references to the object

    class ClusterNode(builtins.object)
     |  ClusterNode(host, port, server_type=None, redis_connection=None)
     |
     |  Methods defined here:
     |
     |  __eq__(self, obj)
     |      Return self==value.
     |
     |  __hash__(self)
     |      Return hash(self).
     |
     |  __init__(self, host, port, server_type=None, redis_connection=None)
     |      Initialize self.  See help(type(self)) for accurate signature.
     |
     |  __repr__(self)
     |      Return repr(self).
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors defined here:
     |
     |  __dict__
     |      dictionary for instance variables
     |
     |  __weakref__
     |      list of weak references to the object

    class ClusterPipeline(RedisCluster)
     |  ClusterPipeline(nodes_manager: 'NodesManager', commands_parser: 'CommandsParser', result_callbacks: Optional[Dict[str, Callable]] = None, cluster_response_callbacks: Optional[Dict[str, Callable]] = None, startup_nodes: Optional[List[ForwardRef('ClusterNode')]] = None, read_from_replicas: bool = False, load_balancing_strategy: Optional[redis.cluster.LoadBalancingStrategy] = None, cluster_error_retry_attempts: int = 10, reinitialize_steps: int = 5, retry: Optional[redis.retry.Retry] = None, lock=None, transaction=False, policy_resolver: redis.commands.policies.PolicyResolver = <redis.commands.policies.StaticPolicyResolver object at 0x0000017B9C75AA50>, event_dispatcher: Optional[ForwardRef('EventDispatcher')] = None, **kwargs)
     |
     |  Support for Redis pipeline
     |  in cluster mode
     |
     |  Method resolution order:
     |      ClusterPipeline
     |      RedisCluster
     |      AbstractRedisCluster
     |      MaintNotificationsAbstractRedisCluster
     |      redis.commands.cluster.RedisClusterCommands
     |      redis.commands.cluster.ClusterMultiKeyCommands
     |      redis.typing.ClusterCommandsProtocol
     |      redis.commands.cluster.ClusterManagementCommands
     |      redis.commands.core.ManagementCommands
     |      redis.commands.core.ACLCommands
     |      redis.commands.core.PubSubCommands
     |      redis.commands.cluster.ClusterDataAccessCommands
     |      redis.commands.core.DataAccessCommands
     |      redis.commands.core.BasicKeyCommands
     |      redis.commands.core.HyperlogCommands
     |      redis.commands.core.HashCommands
     |      redis.commands.core.GeoCommands
     |      redis.commands.core.ListCommands
     |      redis.commands.core.ArrayCommands
     |      redis.commands.core.ScanCommands
     |      redis.commands.core.SetCommands
     |      redis.commands.core.StreamCommands
     |      redis.commands.core.SortedSetCommands
     |      redis.commands.core.ScriptCommands
     |      redis.commands.core.FunctionCommands
     |      redis.commands.core.ModuleCommands
     |      redis.typing.CommandsProtocol
     |      typing.Protocol
     |      typing.Generic
     |      redis.commands.redismodules.RedisModuleCommands
     |      builtins.object
     |
     |  Methods defined here:
     |
     |  __bool__(self)
     |      Pipeline instances should  always evaluate to True on Python 3+
     |
     |  __del__(self)
     |
     |  __enter__(self)
     |
     |  __exit__(self, exc_type, exc_value, traceback)
     |
     |  __init__(self, nodes_manager: 'NodesManager', commands_parser: 'CommandsParser', result_callbacks: Optional[Dict[str, Callable]] = None, cluster_response_callbacks: Optional[Dict[str, Callable]] = None, startup_nodes: Optional[List[ForwardRef('ClusterNode')]] = None, read_from_replicas: bool = False, load_balancing_strategy: Optional[redis.cluster.LoadBalancingStrategy] = None, cluster_error_retry_attempts: int = 10, reinitialize_steps: int = 5, retry: Optional[redis.retry.Retry] = None, lock=None, transaction=False, policy_resolver: redis.commands.policies.PolicyResolver = <redis.commands.policies.StaticPolicyResolver object at 0x0000017B9C75AA50>, event_dispatcher: Optional[ForwardRef('EventDispatcher')] = None, **kwargs)
     |
     |  __len__(self)
     |
     |  __repr__(self)
     |
     |  annotate_exception(self, exception, number, command)
     |      Provides extra context to the exception prior to it being handled
     |
     |  bgrewriteaof = inner(*args, **kwargs) from block_pipeline_command.<locals>
     |
     |  bgsave = inner(*args, **kwargs) from block_pipeline_command.<locals>
     |
     |  bitop = inner(*args, **kwargs) from block_pipeline_command.<locals>
     |
     |  brpoplpush = inner(*args, **kwargs) from block_pipeline_command.<locals>
     |
     |  client = inner(*args, **kwargs) from block_pipeline_command.<locals>
     |
     |  client_getname = inner(*args, **kwargs) from block_pipeline_command.<locals>
     |
     |  client_kill = inner(*args, **kwargs) from block_pipeline_command.<locals>
     |
     |  client_list = inner(*args, **kwargs) from block_pipeline_command.<locals>
     |
     |  client_setname = inner(*args, **kwargs) from block_pipeline_command.<locals>
     |
     |  config = inner(*args, **kwargs) from block_pipeline_command.<locals>
     |
     |  config_get = inner(*args, **kwargs) from block_pipeline_command.<locals>
     |
     |  config_resetstat = inner(*args, **kwargs) from block_pipeline_command.<locals>
     |
     |  config_rewrite = inner(*args, **kwargs) from block_pipeline_command.<locals>
     |
     |  config_set = inner(*args, **kwargs) from block_pipeline_command.<locals>
     |
     |  dbsize = inner(*args, **kwargs) from block_pipeline_command.<locals>
     |
     |  delete(self, *names)
     |      Deletes the given keys in the cluster.
     |      The keys are first split up into slots
     |      and then an DEL command is sent for every slot
     |
     |      Non-existent keys are ignored.
     |      Returns the number of keys that were deleted.
     |
     |      For more information see https://redis.io/commands/del
     |
     |  discard(self)
     |
     |  echo = inner(*args, **kwargs) from block_pipeline_command.<locals>
     |
     |  eval(self)
     |
     |  evalsha = inner(*args, **kwargs) from block_pipeline_command.<locals>
     |
     |  execute(self, raise_on_error: bool = True) -> List[Any]
     |      Execute all the commands in the current pipeline
     |
     |  execute_command(self, *args, **kwargs)
     |      Wrapper function for pipeline_execute_command
     |
     |  exists(self, *keys)
     |      Returns the number of ``names`` that exist in the
     |      whole cluster. The keys are first split up into slots
     |      and then an EXISTS command is sent for every slot
     |
     |      For more information see https://redis.io/commands/exists
     |
     |  flushall = inner(*args, **kwargs) from block_pipeline_command.<locals>
     |
     |  flushdb = inner(*args, **kwargs) from block_pipeline_command.<locals>
     |
     |  info = inner(*args, **kwargs) from block_pipeline_command.<locals>
     |
     |  keys = inner(*args, **kwargs) from block_pipeline_command.<locals>
     |
     |  lastsave = inner(*args, **kwargs) from block_pipeline_command.<locals>
     |
     |  load_scripts(self)
     |
     |  mget = inner(*args, **kwargs) from block_pipeline_command.<locals>
     |
     |  mget_nonatomic = inner(*args, **kwargs) from block_pipeline_command.<locals>
     |
     |  move = inner(*args, **kwargs) from block_pipeline_command.<locals>
     |
     |  mset = inner(*args, **kwargs) from block_pipeline_command.<locals>
     |
     |  mset_nonatomic = inner(*args, **kwargs) from block_pipeline_command.<locals>
     |
     |  msetex = inner(*args, **kwargs) from block_pipeline_command.<locals>
     |
     |  msetnx = inner(*args, **kwargs) from block_pipeline_command.<locals>
     |
     |  multi(self)
     |      Start a transactional block of the pipeline after WATCH commands
     |      are issued. End the transactional block with `execute`.
     |
     |  pfcount = inner(*args, **kwargs) from block_pipeline_command.<locals>
     |
     |  pfmerge = inner(*args, **kwargs) from block_pipeline_command.<locals>
     |
     |  ping = inner(*args, **kwargs) from block_pipeline_command.<locals>
     |
     |  pipeline_execute_command(self, *args, **options)
     |      Stage a command to be executed when execute() is next called
     |
     |      Returns the current Pipeline object back so commands can be
     |      chained together, such as:
     |
     |      pipe = pipe.set('foo', 'bar').incr('baz').decr('bang')
     |
     |      At some other point, you can then run: pipe.execute(),
     |      which will execute all commands queued in the pipe.
     |
     |  publish = inner(*args, **kwargs) from block_pipeline_command.<locals>
     |
     |  randomkey = inner(*args, **kwargs) from block_pipeline_command.<locals>
     |
     |  readonly = inner(*args, **kwargs) from block_pipeline_command.<locals>
     |
     |  readwrite = inner(*args, **kwargs) from block_pipeline_command.<locals>
     |
     |  rename = inner(*args, **kwargs) from block_pipeline_command.<locals>
     |
     |  renamenx = inner(*args, **kwargs) from block_pipeline_command.<locals>
     |
     |  reset(self)
     |      Reset back to empty pipeline.
     |
     |  rpoplpush = inner(*args, **kwargs) from block_pipeline_command.<locals>
     |
     |  save = inner(*args, **kwargs) from block_pipeline_command.<locals>
     |
     |  scan = inner(*args, **kwargs) from block_pipeline_command.<locals>
     |
     |  script = inner(*args, **kwargs) from block_pipeline_command.<locals>
     |
     |  script_exists = inner(*args, **kwargs) from block_pipeline_command.<locals>
     |
     |  script_flush = inner(*args, **kwargs) from block_pipeline_command.<locals>
     |
     |  script_kill = inner(*args, **kwargs) from block_pipeline_command.<locals>
     |
     |  script_load = inner(*args, **kwargs) from block_pipeline_command.<locals>
     |
     |  script_load_for_pipeline(self, *args, **kwargs)
     |
     |  sdiff = inner(*args, **kwargs) from block_pipeline_command.<locals>
     |
     |  sdiffstore = inner(*args, **kwargs) from block_pipeline_command.<locals>
     |
     |  send_cluster_commands(self, stack, raise_on_error=True, allow_redirections=True)
     |
     |  sentinel = inner(*args, **kwargs) from block_pipeline_command.<locals>
     |
     |  sentinel_get_master_addr_by_name = inner(*args, **kwargs) from block_pipeline_command.<locals>
     |
     |  sentinel_master = inner(*args, **kwargs) from block_pipeline_command.<locals>
     |
     |  sentinel_masters = inner(*args, **kwargs) from block_pipeline_command.<locals>
     |
     |  sentinel_monitor = inner(*args, **kwargs) from block_pipeline_command.<locals>
     |
     |  sentinel_remove = inner(*args, **kwargs) from block_pipeline_command.<locals>
     |
     |  sentinel_sentinels = inner(*args, **kwargs) from block_pipeline_command.<locals>
     |
     |  sentinel_set = inner(*args, **kwargs) from block_pipeline_command.<locals>
     |
     |  sentinel_slaves = inner(*args, **kwargs) from block_pipeline_command.<locals>
     |
     |  shutdown = inner(*args, **kwargs) from block_pipeline_command.<locals>
     |
     |  sinter = inner(*args, **kwargs) from block_pipeline_command.<locals>
     |
     |  sinterstore = inner(*args, **kwargs) from block_pipeline_command.<locals>
     |
     |  slaveof = inner(*args, **kwargs) from block_pipeline_command.<locals>
     |
     |  slowlog = inner(*args, **kwargs) from block_pipeline_command.<locals>
     |
     |  slowlog_get = inner(*args, **kwargs) from block_pipeline_command.<locals>
     |
     |  slowlog_len = inner(*args, **kwargs) from block_pipeline_command.<locals>
     |
     |  slowlog_reset = inner(*args, **kwargs) from block_pipeline_command.<locals>
     |
     |  smove = inner(*args, **kwargs) from block_pipeline_command.<locals>
     |
     |  sort = inner(*args, **kwargs) from block_pipeline_command.<locals>
     |
     |  sunion = inner(*args, **kwargs) from block_pipeline_command.<locals>
     |
     |  sunionstore = inner(*args, **kwargs) from block_pipeline_command.<locals>
     |
     |  time = inner(*args, **kwargs) from block_pipeline_command.<locals>
     |
     |  unlink(self, *names)
     |      Remove the specified keys in a different thread.
     |
     |      The keys are first split up into slots
     |      and then an TOUCH command is sent for every slot
     |
     |      Non-existent keys are ignored.
     |      Returns the number of keys that were unlinked.
     |
     |      For more information see https://redis.io/commands/unlink
     |
     |  unwatch(self)
     |      Unwatches all previously specified keys
     |
     |  watch(self, *names)
     |      Watches the values at keys ``names``
     |
     |  ----------------------------------------------------------------------
     |  Class methods defined here:
     |
     |  __subclasshook__ = _proto_hook(other) from typing
     |
     |  ----------------------------------------------------------------------
     |  Data and other attributes defined here:
     |
     |  ERRORS_ALLOW_RETRY = (<class 'redis.exceptions.ConnectionError'>, <cla...
     |
     |  IMMEDIATE_EXECUTE_COMMANDS = {'UNWATCH', 'WATCH'}
     |
     |  NO_SLOTS_COMMANDS = {'UNWATCH'}
     |
     |  UNWATCH_COMMANDS = {'DISCARD', 'EXEC', 'UNWATCH'}
     |
     |  __abstractmethods__ = frozenset()
     |
     |  __annotations__ = {}
     |
     |  __parameters__ = ()
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from RedisCluster:
     |
     |  close(self) -> None
     |
     |  determine_slot(self, *args) -> Optional[int]
     |      Figure out what slot to use based on args.
     |
     |      Raises a RedisClusterException if there's a missing key and we can't
     |          determine what slots to map the command to; or, if the keys don't
     |          all map to the same key slot.
     |
     |  disconnect_connection_pools(self)
     |
     |  get_connection_kwargs(self)
     |      Get the connections' key-word arguments
     |
     |  get_default_node(self)
     |      Get the cluster's default node
     |
     |  get_encoder(self)
     |      Get the connections' encoder
     |
     |  get_node(self, host=None, port=None, node_name=None)
     |
     |  get_node_from_key(self, key, replica=False)
     |      Get the node that holds the key's slot.
     |      If replica set to True but the slot doesn't have any replicas, None is
     |      returned.
     |
     |  get_nodes(self)
     |
     |  get_nodes_from_slot(self, command: str, *args)
     |      Returns a list of nodes that hold the specified keys' slots.
     |
     |  get_primaries(self)
     |
     |  get_random_node(self)
     |
     |  get_random_primary_node(self) -> 'ClusterNode'
     |      Returns a random primary node
     |
     |  get_random_primary_or_all_nodes(self, command_name)
     |      Returns random primary or all nodes depends on READONLY mode.
     |
     |  get_redis_connection(self, node: 'ClusterNode') -> redis.client.Redis
     |
     |  get_replicas(self)
     |
     |  get_special_nodes(self) -> Optional[list['ClusterNode']]
     |      Returns a list of nodes for commands with a special policy.
     |
     |  himport_discard(self, fieldset_name: str) -> int
     |      Remove an HIMPORT fieldset cluster-wide (shared registry, applied lazily).
     |
     |  himport_discard_all(self) -> int
     |      Remove all HIMPORT fieldsets cluster-wide (shared registry, applied lazily).
     |
     |  himport_prepare(self, fieldset_name: str, fields: Iterable[Union[bytes, bytearray, memoryview, str, int, float]]) -> bool
     |      Declare an HIMPORT fieldset cluster-wide (shared registry, applied lazily).
     |
     |  keyslot(self, key)
     |      Calculate keyslot for a given key.
     |      See Keys distribution model in https://redis.io/topics/cluster-spec
     |
     |  keyspace_notifications(self, key_prefix: Union[str, bytes, NoneType] = None, ignore_subscribe_messages: bool = True) -> 'ClusterKeyspaceNotifications'
     |      Return a :class:`~redis.keyspace_notifications.ClusterKeyspaceNotifications`
     |      object for subscribing to keyspace and keyevent notifications across
     |      all primary nodes in the cluster.
     |
     |      Note: Keyspace notifications must be enabled on all Redis cluster nodes
     |      via the ``notify-keyspace-events`` configuration option.
     |
     |      Args:
     |          key_prefix: Optional prefix to filter and strip from keys in
     |                      notifications.
     |          ignore_subscribe_messages: If True, subscribe/unsubscribe
     |                                    confirmations are not returned by
     |                                    get_message/listen.
     |
     |  load_external_module(self, funcname, func)
     |      This function can be used to add externally defined redis modules,
     |      and their namespaces to the redis client.
     |
     |      ``funcname`` - A string containing the name of the function to create
     |      ``func`` - The function, being added to this class.
     |
     |  lock(self, name, timeout=None, sleep=0.1, blocking=True, blocking_timeout=None, lock_class=None, thread_local=True, raise_on_release_error: bool = True)
     |      Return a new Lock object using key ``name`` that mimics
     |      the behavior of threading.Lock.
     |
     |      If specified, ``timeout`` indicates a maximum life for the lock.
     |      By default, it will remain locked until release() is called.
     |
     |      ``sleep`` indicates the amount of time to sleep per loop iteration
     |      when the lock is in blocking mode and another client is currently
     |      holding the lock.
     |
     |      ``blocking`` indicates whether calling ``acquire`` should block until
     |      the lock has been acquired or to fail immediately, causing ``acquire``
     |      to return False and the lock not being acquired. Defaults to True.
     |      Note this value can be overridden by passing a ``blocking``
     |      argument to ``acquire``.
     |
     |      ``blocking_timeout`` indicates the maximum amount of time in seconds to
     |      spend trying to acquire the lock. A value of ``None`` indicates
     |      continue trying forever. ``blocking_timeout`` can be specified as a
     |      float or integer, both representing the number of seconds to wait.
     |
     |      ``lock_class`` forces the specified lock implementation. Note that as
     |      of redis-py 3.0, the only lock class we implement is ``Lock`` (which is
     |      a Lua-based lock). So, it's unlikely you'll need this parameter, unless
     |      you have created your own custom lock class.
     |
     |      ``thread_local`` indicates whether the lock token is placed in
     |      thread-local storage. By default, the token is placed in thread local
     |      storage so that a thread only sees its token, not a token set by
     |      another thread. Consider the following timeline:
     |
     |          time: 0, thread-1 acquires `my-lock`, with a timeout of 5 seconds.
     |                   thread-1 sets the token to "abc"
     |          time: 1, thread-2 blocks trying to acquire `my-lock` using the
     |                   Lock instance.
     |          time: 5, thread-1 has not yet completed. redis expires the lock
     |                   key.
     |          time: 5, thread-2 acquired `my-lock` now that it's available.
     |                   thread-2 sets the token to "xyz"
     |          time: 6, thread-1 finishes its work and calls release(). if the
     |                   token is *not* stored in thread local storage, then
     |                   thread-1 would see the token value as "xyz" and would be
     |                   able to successfully release the thread-2's lock.
     |
     |      ``raise_on_release_error`` indicates whether to raise an exception when
     |      the lock is no longer owned when exiting the context manager. By default,
     |      this is True, meaning an exception will be raised. If False, the warning
     |      will be logged and the exception will be suppressed.
     |
     |      In some use cases it's necessary to disable thread local storage. For
     |      example, if you have code where one thread acquires a lock and passes
     |      that lock instance to a worker thread to release later. If thread
     |      local storage isn't disabled in this case, the worker thread won't see
     |      the token set by the thread that acquired the lock. Our assumption
     |      is that these cases aren't common and as such default to using
     |      thread local storage.
     |
     |  monitor(self, target_node=None)
     |      Returns a Monitor object for the specified target node.
     |      The default cluster node will be selected if no target node was
     |      specified.
     |      Monitor is useful for handling the MONITOR command to the redis server.
     |      next_command() method returns one command from monitor
     |      listen() method yields commands from monitor.
     |
     |  on_connect(self, connection)
     |      Initialize the connection, authenticate and select a database and send
     |       READONLY if it is set during object initialization.
     |
     |  pipeline(self, transaction=None, shard_hint=None)
     |      Cluster impl:
     |          Pipelines do not work in cluster mode the same way they
     |          do in normal mode. Create a clone of this object so
     |          that simulating pipelines will work correctly. Each
     |          command will be called directly when used and
     |          when calling execute() will only return the result stack.
     |
     |  pubsub(self, node=None, host=None, port=None, **kwargs)
     |      Allows passing a ClusterNode, or host&port, to get a pubsub instance
     |      connected to the specified node
     |
     |  set_default_node(self, node)
     |      Set the default node of the cluster.
     |      :param node: 'ClusterNode'
     |      :return True if the default node was set, else False
     |
     |  set_response_callback(self, command, callback)
     |      Set a custom Response Callback
     |
     |  set_retry(self, retry: redis.retry.Retry) -> None
     |
     |  transaction(self, func, *watches, **kwargs)
     |      Convenience method for executing the callable `func` as a transaction
     |      while watching all keys specified in `watches`. The 'func' callable
     |      should expect a single argument which is a Pipeline object.
     |
     |  ----------------------------------------------------------------------
     |  Class methods inherited from RedisCluster:
     |
     |  from_url(url: str, **kwargs: Any) -> 'RedisCluster'
     |      Return a Redis client object configured from the given URL
     |
     |      For example::
     |
     |          redis://[[username]:[password]]@localhost:6379/0
     |          rediss://[[username]:[password]]@localhost:6379/0
     |          unix://[username@]/path/to/socket.sock?db=0[&password=password]
     |
     |      Three URL schemes are supported:
     |
     |      - `redis://` creates a TCP socket connection. See more at:
     |        <https://www.iana.org/assignments/uri-schemes/prov/redis>
     |      - `rediss://` creates a SSL wrapped TCP socket connection. See more at:
     |        <https://www.iana.org/assignments/uri-schemes/prov/rediss>
     |      - ``unix://``: creates a Unix Domain Socket connection.
     |
     |      The username, password, hostname, path and all querystring values
     |      are passed through urllib.parse.unquote in order to replace any
     |      percent-encoded values with their corresponding characters.
     |
     |      There are several ways to specify a database number. The first value
     |      found will be used:
     |
     |          1. A ``db`` querystring option, e.g. redis://localhost?db=0
     |          2. If using the redis:// or rediss:// schemes, the path argument
     |             of the url, e.g. redis://localhost/0
     |          3. A ``db`` keyword argument to this function.
     |
     |      If none of these options are specified, the default db=0 is used.
     |
     |      All querystring options are cast to their appropriate Python types.
     |      Boolean arguments can be specified with string values "True"/"False"
     |      or "Yes"/"No". Values that cannot be properly cast cause a
     |      ``ValueError`` to be raised. Once parsed, the querystring arguments
     |      and keyword arguments are passed to the ``ConnectionPool``'s
     |      class initializer. In the case of conflicting arguments, querystring
     |      arguments always win.
     |
     |  ----------------------------------------------------------------------
     |  Readonly properties inherited from RedisCluster:
     |
     |  himport_registry
     |      The cluster-wide HIMPORT fieldset registry (empty if none was declared).
     |
     |      Read-only: the registry is mutated only through the HIMPORT command methods.
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from AbstractRedisCluster:
     |
     |  replace_default_node(self, target_node: 'ClusterNode' = None) -> None
     |      Replace the default cluster node.
     |      A random cluster node will be chosen if target_node isn't passed, and primaries
     |      will be prioritized. The default node will not be changed if there are no other
     |      nodes in the cluster.
     |
     |      Args:
     |          target_node (ClusterNode, optional): Target node to replace the default
     |          node. Defaults to None.
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors inherited from AbstractRedisCluster:
     |
     |  __dict__
     |      dictionary for instance variables
     |
     |  __weakref__
     |      list of weak references to the object
     |
     |  ----------------------------------------------------------------------
     |  Data and other attributes inherited from AbstractRedisCluster:
     |
     |  ALL_NODES = 'all'
     |
     |  CLUSTER_COMMANDS_RESPONSE_CALLBACKS = {'CLUSTER MYSHARDID': <function ...
     |
     |  COMMAND_FLAGS = {'ACL CAT': 'default-node', 'ACL DELUSER': 'default-no...
     |
     |  DEFAULT_NODE = 'default-node'
     |
     |  NODE_FLAGS = {'all', 'default-node', 'primaries', 'random', 'replicas'...
     |
     |  PRIMARIES = 'primaries'
     |
     |  RANDOM = 'random'
     |
     |  REPLICAS = 'replicas'
     |
     |  RESULT_CALLBACKS = {'BGSAVE': <function AbstractRedisCluster.<lambda>>...
     |
     |  RedisClusterRequestTTL = 16
     |
     |  SEARCH_COMMANDS = (['FT.CREATE', 'FT.SEARCH', 'FT.AGGREGATE', 'FT.EXPL...
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from redis.commands.cluster.ClusterMultiKeyCommands:
     |
     |  touch(self, *keys: 'KeyT') -> 'int | Awaitable[int]'
     |      Updates the last access time of given keys across the
     |      cluster.
     |
     |      The keys are first split up into slots
     |      and then an TOUCH command is sent for every slot
     |
     |      Non-existent keys are ignored.
     |      Returns the number of keys that were touched.
     |
     |      For more information see https://redis.io/commands/touch
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from redis.commands.cluster.ClusterManagementCommands:
     |
     |  client_tracking_off(self, clientid: 'int | None' = None, prefix: 'Sequence[KeyT]' = [], bcast: 'bool' = False, optin: 'bool' = False, optout: 'bool' = False, noloop: 'bool' = False, target_nodes: "'TargetNodesT' | None" = 'all') -> 'ResponseT'
     |      Disables the tracking feature of the Redis server, that is used
     |      for server assisted client side caching.
     |
     |      When clientid is provided - in target_nodes only the node that owns the
     |      connection with this id should be provided.
     |      When clientid is not provided - target_nodes can be any node.
     |
     |      For more information see https://redis.io/commands/client-tracking
     |
     |  client_tracking_on(self, clientid: 'int | None' = None, prefix: 'Sequence[KeyT]' = [], bcast: 'bool' = False, optin: 'bool' = False, optout: 'bool' = False, noloop: 'bool' = False, target_nodes: "'TargetNodesT' | None" = 'all') -> 'ResponseT'
     |      Enables the tracking feature of the Redis server, that is used
     |      for server assisted client side caching.
     |
     |      When clientid is provided - in target_nodes only the node that owns the
     |      connection with this id should be provided.
     |      When clientid is not provided - target_nodes can be any node.
     |
     |      For more information see https://redis.io/commands/client-tracking
     |
     |  cluster_addslots(self, target_node: "'TargetNodesT'", *slots: 'EncodableT') -> 'bool | Awaitable[bool]'
     |      Assign new hash slots to receiving node. Sends to specified node.
     |
     |      :target_node: 'ClusterNode'
     |          The node to execute the command on
     |
     |      For more information see https://redis.io/commands/cluster-addslots
     |
     |  cluster_addslotsrange(self, target_node: "'TargetNodesT'", *slots: 'EncodableT') -> 'bool | Awaitable[bool]'
     |      Similar to the CLUSTER ADDSLOTS command.
     |      The difference between the two commands is that ADDSLOTS takes a list of slots
     |      to assign to the node, while ADDSLOTSRANGE takes a list of slot ranges
     |      (specified by start and end slots) to assign to the node.
     |
     |      :target_node: 'ClusterNode'
     |          The node to execute the command on
     |
     |      For more information see https://redis.io/commands/cluster-addslotsrange
     |
     |  cluster_bumpepoch(self, target_nodes: "'TargetNodesT' | None" = None) -> 'None'
     |
     |  cluster_count_failure_report(self, node_id: 'str') -> 'int | Awaitable[int]'
     |      Return the number of failure reports active for a given node
     |      Sends to a random node
     |
     |      For more information see https://redis.io/commands/cluster-count-failure-reports
     |
     |  cluster_countkeysinslot(self, slot_id: 'int') -> 'int | Awaitable[int]'
     |      Return the number of local keys in the specified hash slot
     |      Send to node based on specified slot_id
     |
     |      For more information see https://redis.io/commands/cluster-countkeysinslot
     |
     |  cluster_delslots(self, *slots: 'EncodableT') -> 'List[bool]'
     |      Set hash slots as unbound in the cluster.
     |      It determines by it self what node the slot is in and sends it there
     |
     |      Returns a list of the results for each processed slot.
     |
     |      For more information see https://redis.io/commands/cluster-delslots
     |
     |  cluster_delslotsrange(self, *slots: 'EncodableT') -> 'bool | Awaitable[bool]'
     |      Similar to the CLUSTER DELSLOTS command.
     |      The difference is that CLUSTER DELSLOTS takes a list of hash slots to remove
     |      from the node, while CLUSTER DELSLOTSRANGE takes a list of slot ranges to remove
     |      from the node.
     |
     |      For more information see https://redis.io/commands/cluster-delslotsrange
     |
     |  cluster_failover(self, target_node: "'TargetNodesT'", option: 'str | None' = None) -> 'bool | Awaitable[bool]'
     |      Forces a slave to perform a manual failover of its master
     |      Sends to specified node
     |
     |      :target_node: 'ClusterNode'
     |          The node to execute the command on
     |
     |      For more information see https://redis.io/commands/cluster-failover
     |
     |  cluster_flushslots(self, target_nodes: "'TargetNodesT' | None" = None) -> 'None'
     |
     |  cluster_get_keys_in_slot(self, slot: 'int', num_keys: 'int') -> 'list[bytes | str] | Awaitable[list[bytes | str]]'
     |      Returns the number of keys in the specified cluster slot
     |
     |      For more information see https://redis.io/commands/cluster-getkeysinslot
     |
     |  cluster_info(self, target_nodes: "'TargetNodesT' | None" = None) -> 'dict[str, str] | Awaitable[dict[str, str]]'
     |      Provides info about Redis Cluster node state.
     |      The command will be sent to a random node in the cluster if no target
     |      node is specified.
     |
     |      For more information see https://redis.io/commands/cluster-info
     |
     |  cluster_keyslot(self, key: 'str') -> 'int | Awaitable[int]'
     |      Returns the hash slot of the specified key
     |      Sends to random node in the cluster
     |
     |      For more information see https://redis.io/commands/cluster-keyslot
     |
     |  cluster_links(self, target_node: "'TargetNodesT'") -> 'ClusterLinksResponse | Awaitable[ClusterLinksResponse]'
     |      Each node in a Redis Cluster maintains a pair of long-lived TCP link with each
     |      peer in the cluster: One for sending outbound messages towards the peer and one
     |      for receiving inbound messages from the peer.
     |
     |      This command outputs information of all such peer links as an array.
     |
     |      For more information see https://redis.io/commands/cluster-links
     |
     |  cluster_meet(self, host: 'str', port: 'int', target_nodes: "'TargetNodesT' | None" = None) -> 'bool | Awaitable[bool]'
     |      Force a node cluster to handshake with another node.
     |      Sends to specified node.
     |
     |      For more information see https://redis.io/commands/cluster-meet
     |
     |  cluster_myid(self, target_node: "'TargetNodesT'") -> 'bytes | str | Awaitable[bytes | str]'
     |      Returns the node's id.
     |
     |      :target_node: 'ClusterNode'
     |          The node to execute the command on
     |
     |      For more information check https://redis.io/commands/cluster-myid/
     |
     |  cluster_myshardid(self, target_nodes: "'TargetNodesT' | None" = None) -> 'bytes | str | Awaitable[bytes | str]'
     |      Returns the shard ID of the node.
     |
     |      For more information see https://redis.io/commands/cluster-myshardid/
     |
     |  cluster_nodes(self) -> 'dict[str, ClusterNodeDetail] | Awaitable[dict[str, ClusterNodeDetail]]'
     |      Get Cluster config for the node.
     |      Sends to random node in the cluster
     |
     |      For more information see https://redis.io/commands/cluster-nodes
     |
     |  cluster_replicas(self, node_id: 'str', target_nodes: "'TargetNodesT' | None" = None) -> 'dict[str, ClusterNodeDetail] | Awaitable[dict[str, ClusterNodeDetail]]'
     |      Provides a list of replica nodes replicating from the specified primary
     |      target node.
     |
     |      For more information see https://redis.io/commands/cluster-replicas
     |
     |  cluster_replicate(self, target_nodes: "'TargetNodesT'", node_id: 'str') -> 'bool | Awaitable[bool]'
     |      Reconfigure a node as a slave of the specified master node
     |
     |      For more information see https://redis.io/commands/cluster-replicate
     |
     |  cluster_reset(self, soft: 'bool' = True, target_nodes: "'TargetNodesT' | None" = None) -> 'bool | Awaitable[bool]'
     |      Reset a Redis Cluster node
     |
     |      If 'soft' is True then it will send 'SOFT' argument
     |      If 'soft' is False then it will send 'HARD' argument
     |
     |      For more information see https://redis.io/commands/cluster-reset
     |
     |  cluster_save_config(self, target_nodes: "'TargetNodesT' | None" = None) -> 'bool | Awaitable[bool]'
     |      Forces the node to save cluster state on disk
     |
     |      For more information see https://redis.io/commands/cluster-saveconfig
     |
     |  cluster_set_config_epoch(self, epoch: 'int', target_nodes: "'TargetNodesT' | None" = None) -> 'bool | Awaitable[bool]'
     |      Set the configuration epoch in a new node
     |
     |      For more information see https://redis.io/commands/cluster-set-config-epoch
     |
     |  cluster_setslot(self, target_node: "'TargetNodesT'", node_id: 'str', slot_id: 'int', state: 'str') -> 'bool | Awaitable[bool]'
     |      Bind an hash slot to a specific node
     |
     |      :target_node: 'ClusterNode'
     |          The node to execute the command on
     |
     |      For more information see https://redis.io/commands/cluster-setslot
     |
     |  cluster_setslot_stable(self, slot_id: 'int') -> 'bool | Awaitable[bool]'
     |      Clears migrating / importing state from the slot.
     |      It determines by it self what node the slot is in and sends it there.
     |
     |      For more information see https://redis.io/commands/cluster-setslot
     |
     |  cluster_shards(self, target_nodes: "'TargetNodesT' | None" = None) -> 'ClusterShardsResponse | Awaitable[ClusterShardsResponse]'
     |      Returns details about the shards of the cluster.
     |
     |      For more information see https://redis.io/commands/cluster-shards
     |
     |  cluster_slots(self, target_nodes: "'TargetNodesT' | None" = None) -> 'list[Any] | Awaitable[list[Any]]'
     |      Get array of Cluster slot to node mappings
     |
     |      For more information see https://redis.io/commands/cluster-slots
     |
     |  hotkeys_get(self, **kwargs) -> 'list[dict[str | bytes, Any]]'
     |      Cluster client does not support hotkeys command. Please use the non-cluster client.
     |
     |      For more information see https://redis.io/commands/hotkeys-get
     |
     |  hotkeys_reset(self, **kwargs) -> 'str | bytes'
     |      Cluster client does not support hotkeys command. Please use the non-cluster client.
     |
     |      For more information see https://redis.io/commands/hotkeys-reset
     |
     |  hotkeys_start(self, metrics: 'List[HotkeysMetricsTypes]', count: 'int | None' = None, duration: 'int | None' = None, sample_ratio: 'int | None' = None, slots: 'List[int] | None' = None, **kwargs) -> 'str | bytes'
     |      Cluster client does not support hotkeys command. Please use the non-cluster client.
     |
     |      For more information see https://redis.io/commands/hotkeys-start
     |
     |  hotkeys_stop(self, **kwargs) -> 'str | bytes'
     |      Cluster client does not support hotkeys command. Please use the non-cluster client.
     |
     |      For more information see https://redis.io/commands/hotkeys-stop
     |
     |  replicaof(self, *args, **kwargs) -> 'NoReturn'
     |      Make the server a replica of another instance, or promote it as master.
     |
     |      For more information see https://redis.io/commands/replicaof
     |
     |  swapdb(self, *args, **kwargs) -> 'NoReturn'
     |      Swaps two Redis databases.
     |
     |      For more information see https://redis.io/commands/swapdb
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from redis.commands.core.ManagementCommands:
     |
     |  auth(self, password: 'str', username: 'str | None' = None, **kwargs) -> 'bool | Awaitable[bool]'
     |      Authenticates the user. If you do not pass username, Redis will try to
     |      authenticate for the "default" user. If you do pass username, it will
     |      authenticate for the given user.
     |      For more information, see https://redis.io/commands/auth
     |
     |  client_getredir(self, **kwargs) -> 'int | Awaitable[int]'
     |      Returns the ID (an integer) of the client to whom we are
     |      redirecting tracking notifications.
     |
     |      see: https://redis.io/commands/client-getredir
     |
     |  client_id(self, **kwargs) -> 'int | Awaitable[int]'
     |      Returns the current connection id
     |
     |      For more information, see https://redis.io/commands/client-id
     |
     |  client_info(self, **kwargs) -> 'dict[str, str | int] | Awaitable[dict[str, str | int]]'
     |      Returns information and statistics about the current
     |      client connection.
     |
     |      For more information, see https://redis.io/commands/client-info
     |
     |  client_kill_filter(self, _id: 'str | None' = None, _type: 'str | None' = None, addr: 'str | None' = None, skipme: 'bool | None' = None, laddr: 'bool | None' = None, user: 'str | None' = None, maxage: 'int | None' = None, **kwargs) -> 'int | Awaitable[int]'
     |      Disconnects client(s) using a variety of filter options
     |      :param _id: Kills a client by its unique ID field
     |      :param _type: Kills a client by type where type is one of 'normal',
     |      'master', 'slave', 'replica' or 'pubsub'
     |      :param addr: Kills a client by its 'address:port'
     |      :param skipme: If True, then the client calling the command
     |      will not get killed even if it is identified by one of the filter
     |      options. If skipme is not provided, the server defaults to skipme=True
     |      :param laddr: Kills a client by its 'local (bind) address:port'
     |      :param user: Kills a client for a specific user name
     |      :param maxage: Kills clients that are older than the specified age in seconds
     |
     |  client_no_evict(self, mode: 'str') -> 'bytes | str | Awaitable[bytes | str]'
     |      Sets the client eviction mode for the current connection.
     |
     |      For more information, see https://redis.io/commands/client-no-evict
     |
     |  client_no_touch(self, mode: 'str') -> 'bytes | str | Awaitable[bytes | str]'
     |      # The command controls whether commands sent by the client will alter
     |      # the LRU/LFU of the keys they access.
     |      # When turned on, the current client will not change LFU/LRU stats,
     |      # unless it sends the TOUCH command.
     |
     |      For more information, see https://redis.io/commands/client-no-touch
     |
     |  client_pause(self, timeout: 'int', all: 'bool' = True, **kwargs) -> 'bool | Awaitable[bool]'
     |      Suspend all the Redis clients for the specified amount of time.
     |
     |
     |      For more information, see https://redis.io/commands/client-pause
     |
     |      Args:
     |          timeout: milliseconds to pause clients
     |          all: If true (default) all client commands are blocked.
     |               otherwise, clients are only blocked if they attempt to execute
     |               a write command.
     |
     |      For the WRITE mode, some commands have special behavior:
     |
     |      * EVAL/EVALSHA: Will block client for all scripts.
     |      * PUBLISH: Will block client.
     |      * PFCOUNT: Will block client.
     |      * WAIT: Acknowledgments will be delayed, so this command will
     |          appear blocked.
     |
     |  client_reply(self, reply: "Literal['ON', 'OFF', 'SKIP']", **kwargs) -> 'bytes | str | Awaitable[bytes | str]'
     |      Enable and disable redis server replies.
     |
     |      ``reply`` Must be ON OFF or SKIP,
     |      ON - The default most with server replies to commands
     |      OFF - Disable server responses to commands
     |      SKIP - Skip the response of the immediately following command.
     |
     |      Note: When setting OFF or SKIP replies, you will need a client object
     |      with a timeout specified in seconds, and will need to catch the
     |      TimeoutError.
     |      The test_client_reply unit test illustrates this, and
     |      conftest.py has a client with a timeout.
     |
     |      See https://redis.io/commands/client-reply
     |
     |  client_setinfo(self, attr: 'str', value: 'str', **kwargs) -> 'bool | Awaitable[bool]'
     |      Sets the current connection library name or version
     |      For more information see https://redis.io/commands/client-setinfo
     |
     |  client_tracking(self, on: 'bool' = True, clientid: 'int | None' = None, prefix: 'Sequence[KeyT]' = [], bcast: 'bool' = False, optin: 'bool' = False, optout: 'bool' = False, noloop: 'bool' = False, **kwargs) -> 'bytes | str | Awaitable[bytes | str]'
     |      Enables the tracking feature of the Redis server, that is used
     |      for server assisted client side caching.
     |
     |      ``on`` indicate for tracking on or tracking off. The default is on.
     |
     |      ``clientid`` send invalidation messages to the connection with
     |      the specified ID.
     |
     |      ``bcast`` enable tracking in broadcasting mode. In this mode
     |      invalidation messages are reported for all the prefixes
     |      specified, regardless of the keys requested by the connection.
     |
     |      ``optin``  when broadcasting is NOT active, normally don't track
     |      keys in read only commands, unless they are called immediately
     |      after a CLIENT CACHING yes command.
     |
     |      ``optout`` when broadcasting is NOT active, normally track keys in
     |      read only commands, unless they are called immediately after a
     |      CLIENT CACHING no command.
     |
     |      ``noloop`` don't send notifications about keys modified by this
     |      connection itself.
     |
     |      ``prefix``  for broadcasting, register a given key prefix, so that
     |      notifications will be provided only for keys starting with this string.
     |
     |      See https://redis.io/commands/client-tracking
     |
     |  client_trackinginfo(self, **kwargs) -> 'ClientTrackingInfoResponse | Awaitable[ClientTrackingInfoResponse]'
     |      Returns the information about the current client connection's
     |      use of the server assisted client side cache.
     |
     |      See https://redis.io/commands/client-trackinginfo
     |
     |  client_unblock(self, client_id: 'int', error: 'bool' = False, **kwargs) -> 'bool | Awaitable[bool]'
     |      Unblocks a connection by its client id.
     |      If ``error`` is True, unblocks the client with a special error message.
     |      If ``error`` is False (default), the client is unblocked using the
     |      regular timeout mechanism.
     |
     |      For more information, see https://redis.io/commands/client-unblock
     |
     |  client_unpause(self, **kwargs) -> 'bytes | str | Awaitable[bytes | str]'
     |      Unpause all redis clients
     |
     |      For more information, see https://redis.io/commands/client-unpause
     |
     |  command(self, **kwargs) -> 'dict[str, dict[str, Any]] | Awaitable[dict[str, dict[str, Any]]]'
     |      Returns dict reply of details about all Redis commands.
     |
     |      For more information, see https://redis.io/commands/command
     |
     |  command_count(self, **kwargs) -> 'int | Awaitable[int]'
     |
     |  command_docs(self, *args)
     |      This function throws a NotImplementedError since it is intentionally
     |      not supported.
     |
     |  command_getkeysandflags(self, *args: 'str') -> 'CommandGetKeysAndFlagsResponse | Awaitable[CommandGetKeysAndFlagsResponse]'
     |      Returns array of keys from a full Redis command and their usage flags.
     |
     |      For more information, see https://redis.io/commands/command-getkeysandflags
     |
     |  command_info(self, **kwargs) -> 'None'
     |
     |  command_list(self, module: 'str | None' = None, category: 'str | None' = None, pattern: 'str | None' = None) -> 'list[bytes | str] | Awaitable[list[bytes | str]]'
     |      Return an array of the server's command names.
     |      You can use one of the following filters:
     |      ``module``: get the commands that belong to the module
     |      ``category``: get the commands in the ACL category
     |      ``pattern``: get the commands that match the given pattern
     |
     |      For more information, see https://redis.io/commands/command-list/
     |
     |  debug_object(self, key: 'KeyT', **kwargs) -> 'dict[str, str | int] | bytes | str | Awaitable[dict[str, str | int] | bytes | str]'
     |      Returns version specific meta information about a given key
     |
     |      For more information, see https://redis.io/commands/debug-object
     |
     |  debug_segfault(self, **kwargs) -> 'None'
     |
     |  failover(self)
     |      This function throws a NotImplementedError since it is intentionally
     |      not supported.
     |
     |  hello(self)
     |      This function throws a NotImplementedError since it is intentionally
     |      not supported.
     |
     |  latency_doctor(self)
     |      Raise a NotImplementedError, as the client will not support LATENCY DOCTOR.
     |      This function is best used within the redis-cli.
     |
     |      For more information, see https://redis.io/commands/latency-doctor
     |
     |  latency_graph(self)
     |      Raise a NotImplementedError, as the client will not support LATENCY GRAPH.
     |      This function is best used within the redis-cli.
     |
     |      For more information, see https://redis.io/commands/latency-graph.
     |
     |  latency_histogram(self, *args)
     |      This function throws a NotImplementedError since it is intentionally
     |      not supported.
     |
     |  latency_history(self, event: 'str') -> 'list[list[int]] | Awaitable[list[list[int]]]'
     |      Returns the raw data of the ``event``'s latency spikes time series.
     |
     |      For more information, see https://redis.io/commands/latency-history
     |
     |  latency_latest(self) -> 'list[list[bytes | str | int]] | Awaitable[list[list[bytes | str | int]]]'
     |      Reports the latest latency events logged.
     |
     |      For more information, see https://redis.io/commands/latency-latest
     |
     |  latency_reset(self, *events: 'str') -> 'int | Awaitable[int]'
     |      Resets the latency spikes time series of all, or only some, events.
     |
     |      For more information, see https://redis.io/commands/latency-reset
     |
     |  lolwut(self, *version_numbers: 'Union[str, float]', **kwargs) -> 'bytes | str | Awaitable[bytes | str]'
     |      Get the Redis version and a piece of generative computer art
     |
     |      See: https://redis.io/commands/lolwut
     |
     |  memory_doctor(self, **kwargs) -> 'None'
     |
     |  memory_help(self, **kwargs) -> 'None'
     |
     |  memory_malloc_stats(self, **kwargs) -> 'bytes | str | Awaitable[bytes | str]'
     |      Return an internal statistics report from the memory allocator.
     |
     |      See: https://redis.io/commands/memory-malloc-stats
     |
     |  memory_purge(self, **kwargs) -> 'bool | Awaitable[bool]'
     |      Attempts to purge dirty pages for reclamation by allocator
     |
     |      For more information, see https://redis.io/commands/memory-purge
     |
     |  memory_stats(self, **kwargs) -> 'dict[str, Any] | Awaitable[dict[str, Any]]'
     |      Return a dictionary of memory stats
     |
     |      For more information, see https://redis.io/commands/memory-stats
     |
     |  memory_usage(self, key: 'KeyT', samples: 'int | None' = None, **kwargs) -> 'int | None | Awaitable[int | None]'
     |      Return the total memory usage for key, its value and associated
     |      administrative overheads.
     |
     |      For nested data structures, ``samples`` is the number of elements to
     |      sample. If left unspecified, the server's default is 5. Use 0 to sample
     |      all elements.
     |
     |      For more information, see https://redis.io/commands/memory-usage
     |
     |  migrate(self, host: 'str', port: 'int', keys: 'KeysT', destination_db: 'int', timeout: 'int', copy: 'bool' = False, replace: 'bool' = False, auth: 'str | None' = None, **kwargs) -> 'bytes | str | Awaitable[bytes | str]'
     |      Migrate 1 or more keys from the current Redis server to a different
     |      server specified by the ``host``, ``port`` and ``destination_db``.
     |
     |      The ``timeout``, specified in milliseconds, indicates the maximum
     |      time the connection between the two servers can be idle before the
     |      command is interrupted.
     |
     |      If ``copy`` is True, the specified ``keys`` are NOT deleted from
     |      the source server.
     |
     |      If ``replace`` is True, this operation will overwrite the keys
     |      on the destination server if they exist.
     |
     |      If ``auth`` is specified, authenticate to the destination server with
     |      the password provided.
     |
     |      For more information, see https://redis.io/commands/migrate
     |
     |  object(self, infotype: 'str', key: 'KeyT', **kwargs) -> 'Any | Awaitable[Any]'
     |      Return the encoding, idletime, or refcount about the key
     |
     |  psync(self, replicationid: 'str', offset: 'int') -> 'bytes | Awaitable[bytes]'
     |      Initiates a replication stream from the master.
     |      Newer version for `sync`.
     |
     |      For more information, see https://redis.io/commands/sync
     |
     |  quit(self, **kwargs) -> 'bool | Awaitable[bool]'
     |      Ask the server to close the connection.
     |
     |      For more information, see https://redis.io/commands/quit
     |
     |  role(self) -> 'list[Any] | Awaitable[list[Any]]'
     |      Provide information on the role of a Redis instance in
     |      the context of replication, by returning if the instance
     |      is currently a master, slave, or sentinel.
     |
     |      For more information, see https://redis.io/commands/role
     |
     |  select(self, index: 'int', **kwargs) -> 'bool | Awaitable[bool]'
     |      Select the Redis logical database at index.
     |
     |      See: https://redis.io/commands/select
     |
     |  sync(self) -> 'bytes | Awaitable[bytes]'
     |      Initiates a replication stream from the master.
     |
     |      For more information, see https://redis.io/commands/sync
     |
     |  wait(self, num_replicas: 'int', timeout: 'int', **kwargs) -> 'int | Awaitable[int]'
     |      Redis synchronous replication
     |      That returns the number of replicas that processed the query when
     |      we finally have at least ``num_replicas``, or when the ``timeout`` was
     |      reached.
     |
     |      For more information, see https://redis.io/commands/wait
     |
     |  waitaof(self, num_local: 'int', num_replicas: 'int', timeout: 'int', **kwargs) -> 'list[int] | Awaitable[list[int]]'
     |      This command blocks the current client until all previous write
     |      commands by that client are acknowledged as having been fsynced
     |      to the AOF of the local Redis and/or at least the specified number
     |      of replicas.
     |
     |      For more information, see https://redis.io/commands/waitaof
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from redis.commands.core.ACLCommands:
     |
     |  acl_cat(self, category: 'str | None' = None, **kwargs) -> 'list[bytes | str] | Awaitable[list[bytes | str]]'
     |      Returns a list of categories or commands within a category.
     |
     |      If ``category`` is not supplied, returns a list of all categories.
     |      If ``category`` is supplied, returns a list of all commands within
     |      that category.
     |
     |      For more information, see https://redis.io/commands/acl-cat
     |
     |  acl_deluser(self, *username: 'str', **kwargs) -> 'int | Awaitable[int]'
     |      Delete the ACL for the specified ``username``\s
     |
     |      For more information, see https://redis.io/commands/acl-deluser
     |
     |  acl_dryrun(self, username: 'str', *args: 'EncodableT', **kwargs) -> 'bytes | str | Awaitable[bytes | str]'
     |      Simulate the execution of a given command by a given ``username``.
     |
     |      For more information, see https://redis.io/commands/acl-dryrun
     |
     |  acl_genpass(self, bits: 'int | None' = None, **kwargs) -> 'bytes | str | Awaitable[bytes | str]'
     |      Generate a random password value.
     |      If ``bits`` is supplied then use this number of bits, rounded to
     |      the next multiple of 4.
     |      See: https://redis.io/commands/acl-genpass
     |
     |  acl_getuser(self, username: 'str', **kwargs) -> 'ACLGetUserData | Awaitable[ACLGetUserData]'
     |      Get the ACL details for the specified ``username``.
     |
     |      If ``username`` does not exist, return None
     |
     |      For more information, see https://redis.io/commands/acl-getuser
     |
     |  acl_help(self, **kwargs) -> 'list[bytes | str] | Awaitable[list[bytes | str]]'
     |      The ACL HELP command returns helpful text describing
     |      the different subcommands.
     |
     |      For more information, see https://redis.io/commands/acl-help
     |
     |  acl_list(self, **kwargs) -> 'list[bytes | str] | Awaitable[list[bytes | str]]'
     |      Return a list of all ACLs on the server
     |
     |      For more information, see https://redis.io/commands/acl-list
     |
     |  acl_load(self, **kwargs) -> 'bool | Awaitable[bool]'
     |      Load ACL rules from the configured ``aclfile``.
     |
     |      Note that the server must be configured with the ``aclfile``
     |      directive to be able to load ACL rules from an aclfile.
     |
     |      For more information, see https://redis.io/commands/acl-load
     |
     |  acl_log(self, count: 'int | None' = None, **kwargs) -> 'ACLLogData | Awaitable[ACLLogData]'
     |      Get ACL logs as a list.
     |      :param int count: Get logs[0:count].
     |      :rtype: List.
     |
     |      For more information, see https://redis.io/commands/acl-log
     |
     |  acl_log_reset(self, **kwargs) -> 'bool | Awaitable[bool]'
     |      Reset ACL logs.
     |      :rtype: Boolean.
     |
     |      For more information, see https://redis.io/commands/acl-log
     |
     |  acl_save(self, **kwargs) -> 'bool | Awaitable[bool]'
     |      Save ACL rules to the configured ``aclfile``.
     |
     |      Note that the server must be configured with the ``aclfile``
     |      directive to be able to save ACL rules to an aclfile.
     |
     |      For more information, see https://redis.io/commands/acl-save
     |
     |  acl_setuser(self, username: 'str', enabled: 'bool' = False, nopass: 'bool' = False, passwords: 'str | Iterable[str] | None' = None, hashed_passwords: 'str | Iterable[str] | None' = None, categories: 'Iterable[str] | None' = None, commands: 'Iterable[str] | None' = None, keys: 'Iterable[KeyT] | None' = None, channels: 'Iterable[ChannelT] | None' = None, selectors: 'Iterable[Tuple[str, KeyT]] | None' = None, reset: 'bool' = False, reset_keys: 'bool' = False, reset_channels: 'bool' = False, reset_passwords: 'bool' = False, **kwargs) -> 'bool | Awaitable[bool]'
     |      Create or update an ACL user.
     |
     |      Create or update the ACL for `username`. If the user already exists,
     |      the existing ACL is completely overwritten and replaced with the
     |      specified values.
     |
     |      For more information, see https://redis.io/commands/acl-setuser
     |
     |      Args:
     |          username: The name of the user whose ACL is to be created or updated.
     |          enabled: Indicates whether the user should be allowed to authenticate.
     |                   Defaults to `False`.
     |          nopass: Indicates whether the user can authenticate without a password.
     |                  This cannot be `True` if `passwords` are also specified.
     |          passwords: A list of plain text passwords to add to or remove from the user.
     |                     Each password must be prefixed with a '+' to add or a '-' to
     |                     remove. For convenience, a single prefixed string can be used
     |                     when adding or removing a single password.
     |          hashed_passwords: A list of SHA-256 hashed passwords to add to or remove
     |                            from the user. Each hashed password must be prefixed with
     |                            a '+' to add or a '-' to remove. For convenience, a single
     |                            prefixed string can be used when adding or removing a
     |                            single password.
     |          categories: A list of strings representing category permissions. Each string
     |                      must be prefixed with either a '+' to add the category
     |                      permission or a '-' to remove the category permission.
     |          commands: A list of strings representing command permissions. Each string
     |                    must be prefixed with either a '+' to add the command permission
     |                    or a '-' to remove the command permission.
     |          keys: A list of key patterns to grant the user access to. Key patterns allow
     |                ``'*'`` to support wildcard matching. For example, ``'*'`` grants
     |                access to all keys while ``'cache:*'`` grants access to all keys that
     |                are prefixed with ``cache:``.
     |                `keys` should not be prefixed with a ``'~'``.
     |          reset: Indicates whether the user should be fully reset prior to applying
     |                 the new ACL. Setting this to `True` will remove all existing
     |                 passwords, flags, and privileges from the user and then apply the
     |                 specified rules. If `False`, the user's existing passwords, flags,
     |                 and privileges will be kept and any new specified rules will be
     |                 applied on top.
     |          reset_keys: Indicates whether the user's key permissions should be reset
     |                      prior to applying any new key permissions specified in `keys`.
     |                      If `False`, the user's existing key permissions will be kept and
     |                      any new specified key permissions will be applied on top.
     |          reset_channels: Indicates whether the user's channel permissions should be
     |                          reset prior to applying any new channel permissions
     |                          specified in `channels`. If `False`, the user's existing
     |                          channel permissions will be kept and any new specified
     |                          channel permissions will be applied on top.
     |          reset_passwords: Indicates whether to remove all existing passwords and the
     |                           `nopass` flag from the user prior to applying any new
     |                           passwords specified in `passwords` or `hashed_passwords`.
     |                           If `False`, the user's existing passwords and `nopass`
     |                           status will be kept and any new specified passwords or
     |                           hashed passwords will be applied on top.
     |
     |  acl_users(self, **kwargs) -> 'list[bytes | str] | Awaitable[list[bytes | str]]'
     |      Returns a list of all registered users on the server.
     |
     |      For more information, see https://redis.io/commands/acl-users
     |
     |  acl_whoami(self, **kwargs) -> 'bytes | str | Awaitable[bytes | str]'
     |      Get the username for the current connection
     |
     |      For more information, see https://redis.io/commands/acl-whoami
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from redis.commands.core.PubSubCommands:
     |
     |  pubsub_channels(self, pattern: 'PatternT' = '*', **kwargs) -> 'list[bytes | str] | Awaitable[list[bytes | str]]'
     |      Return a list of channels that have at least one subscriber
     |
     |      For more information, see https://redis.io/commands/pubsub-channels
     |
     |  pubsub_numpat(self, **kwargs) -> 'int | Awaitable[int]'
     |      Returns the number of subscriptions to patterns
     |
     |      For more information, see https://redis.io/commands/pubsub-numpat
     |
     |  pubsub_numsub(self, *args: 'ChannelT', **kwargs) -> 'list[tuple[bytes | str, int]] | Awaitable[list[tuple[bytes | str, int]]]'
     |      Return a list of (channel, number of subscribers) tuples
     |      for each channel given in ``*args``
     |
     |      For more information, see https://redis.io/commands/pubsub-numsub
     |
     |  pubsub_shardchannels(self, pattern: 'PatternT' = '*', **kwargs) -> 'list[bytes | str] | Awaitable[list[bytes | str]]'
     |      Return a list of shard_channels that have at least one subscriber
     |
     |      For more information, see https://redis.io/commands/pubsub-shardchannels
     |
     |  pubsub_shardnumsub(self, *args: 'ChannelT', **kwargs) -> 'list[tuple[bytes | str, int]] | Awaitable[list[tuple[bytes | str, int]]]'
     |      Return a list of (shard_channel, number of subscribers) tuples
     |      for each channel given in ``*args``
     |
     |      For more information, see https://redis.io/commands/pubsub-shardnumsub
     |
     |  spublish(self, shard_channel: 'ChannelT', message: 'EncodableT') -> 'int | Awaitable[int]'
     |      Posts a message to the given shard channel.
     |      Returns the number of clients that received the message
     |
     |      For more information, see https://redis.io/commands/spublish
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from redis.commands.cluster.ClusterDataAccessCommands:
     |
     |  scan_iter(self, match: 'PatternT | None' = None, count: 'int | None' = None, _type: 'str | None' = None, **kwargs) -> 'Iterator'
     |      Make an iterator using the SCAN command so that the client doesn't
     |      need to remember the cursor position.
     |
     |      ``match`` allows for filtering the keys by pattern
     |
     |      ``count`` provides a hint to Redis about the number of keys to
     |          return per batch.
     |
     |      ``_type`` filters the returned values by a particular Redis type.
     |          Stock Redis instances allow for the following types:
     |          HASH, LIST, SET, STREAM, STRING, ZSET
     |          Additionally, Redis modules can expose other types as well.
     |
     |  stralgo(self, algo: "Literal['LCS']", value1: 'KeyT', value2: 'KeyT', specific_argument: "Literal['strings'] | Literal['keys']" = 'strings', len: 'bool' = False, idx: 'bool' = False, minmatchlen: 'int | None' = None, withmatchlen: 'bool' = False, **kwargs) -> 'StralgoResponse | Awaitable[StralgoResponse]'
     |      Implements complex algorithms that operate on strings.
     |      Right now the only algorithm implemented is the LCS algorithm
     |      (longest common substring). However new algorithms could be
     |      implemented in the future.
     |
     |      ``algo`` Right now must be LCS
     |      ``value1`` and ``value2`` Can be two strings or two keys
     |      ``specific_argument`` Specifying if the arguments to the algorithm
     |      will be keys or strings. strings is the default.
     |      ``len`` Returns just the len of the match.
     |      ``idx`` Returns the match positions in each string.
     |      ``minmatchlen`` Restrict the list of matches to the ones of a given
     |      minimal length. Can be provided only when ``idx`` set to True.
     |      ``withmatchlen`` Returns the matches with the len of the match.
     |      Can be provided only when ``idx`` set to True.
     |
     |      For more information see https://redis.io/commands/stralgo
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from redis.commands.core.BasicKeyCommands:
     |
     |  __contains__ = exists(self, *names: 'KeyT') -> 'int | Awaitable[int]'
     |      Returns the number of ``names`` that exist
     |
     |      For more information, see https://redis.io/commands/exists
     |
     |  __delitem__(self, name: 'KeyT')
     |
     |  __getitem__(self, name: 'KeyT')
     |      Return the value at key ``name``, raises a KeyError if the key
     |      doesn't exist.
     |
     |  __setitem__(self, name: 'KeyT', value: 'EncodableT')
     |
     |  append(self, key: 'KeyT', value: 'EncodableT') -> 'int | Awaitable[int]'
     |      Appends the string ``value`` to the value at ``key``. If ``key``
     |      doesn't already exist, create it with a value of ``value``.
     |      Returns the new length of the value at ``key``.
     |
     |      For more information, see https://redis.io/commands/append
     |
     |  bitcount(self, key: 'KeyT', start: 'int | None' = None, end: 'int | None' = None, mode: 'str | None' = None) -> 'int | Awaitable[int]'
     |      Returns the count of set bits in the value of ``key``.  Optional
     |      ``start`` and ``end`` parameters indicate which bytes to consider
     |
     |      For more information, see https://redis.io/commands/bitcount
     |
     |  bitfield(self: "Union['redis.client.Redis', 'redis.asyncio.client.Redis']", key: 'KeyT', default_overflow: 'str | None' = None) -> 'BitFieldOperation'
     |      Return a BitFieldOperation instance to conveniently construct one or
     |      more bitfield operations on ``key``.
     |
     |      For more information, see https://redis.io/commands/bitfield
     |
     |  bitfield_ro(self: "Union['redis.client.Redis', 'redis.asyncio.client.Redis']", key: 'KeyT', encoding: 'str', offset: 'BitfieldOffsetT', items: 'list[tuple[str, BitfieldOffsetT]] | None' = None) -> 'list[int] | Awaitable[list[int]]'
     |      Return an array of the specified bitfield values
     |      where the first value is found using ``encoding`` and ``offset``
     |      parameters and remaining values are result of corresponding
     |      encoding/offset pairs in optional list ``items``
     |      Read-only variant of the BITFIELD command.
     |
     |      For more information, see https://redis.io/commands/bitfield_ro
     |
     |  bitpos(self, key: 'KeyT', bit: 'int', start: 'int | None' = None, end: 'int | None' = None, mode: 'str | None' = None) -> 'int | Awaitable[int]'
     |      Return the position of the first bit set to 1 or 0 in a string.
     |      ``start`` and ``end`` defines search range. The range is interpreted
     |      as a range of bytes and not a range of bits, so start=0 and end=2
     |      means to look at the first three bytes.
     |
     |      For more information, see https://redis.io/commands/bitpos
     |
     |  blmove(self, first_list: 'str', second_list: 'str', timeout: 'int', src: 'str' = 'LEFT', dest: 'str' = 'RIGHT') -> 'bytes | str | None | Awaitable[bytes | str | None]'
     |      Blocking version of lmove.
     |
     |      For more information, see https://redis.io/commands/blmove
     |
     |  blmovem(self, first_list: 'str', second_list: 'str', timeout: 'float', src: 'str' = 'LEFT', dest: 'str' = 'RIGHT', count: 'int | None' = None, mode: "Literal['COUNT', 'EXACTLY'] | None" = None, ordering: "Literal['OBO', 'BULK'] | None" = None) -> 'list[bytes | str] | None | Awaitable[list[bytes | str] | None]'
     |      Blocking version of lmovem.
     |
     |      Blocks until elements are available to move or ``timeout`` (in seconds)
     |      is reached; a ``timeout`` of ``0`` blocks indefinitely. With ``COUNT``
     |      the command unblocks once at least one element is available and moves
     |      ``min(count, available)``; with ``EXACTLY`` it blocks until the source
     |      holds at least ``count`` elements, then moves exactly ``count``
     |      atomically. On timeout ``None`` is returned and nothing is moved.
     |
     |      As with ``lmovem``, ``ordering`` (OBO or BULK) is required whenever
     |      ``count`` is given.
     |
     |      For more information, see https://redis.io/commands/blmovem
     |
     |  copy(self, source: 'str', destination: 'str', destination_db: 'str | None' = None, replace: 'bool' = False) -> 'bool | Awaitable[bool]'
     |      Copy the value stored in the ``source`` key to the ``destination`` key.
     |
     |      ``destination_db`` an alternative destination database. By default,
     |      the ``destination`` key is created in the source Redis database.
     |
     |      ``replace`` whether the ``destination`` key should be removed before
     |      copying the value to it. By default, the value is not copied if
     |      the ``destination`` key already exists.
     |
     |      For more information, see https://redis.io/commands/copy
     |
     |  decr = decrby(self, name: 'KeyT', amount: 'int' = 1) -> 'int | Awaitable[int]'
     |
     |  decrby(self, name: 'KeyT', amount: 'int' = 1) -> 'int | Awaitable[int]'
     |      Decrements the value of ``key`` by ``amount``.  If no key exists,
     |      the value will be initialized as 0 - ``amount``
     |
     |      For more information, see https://redis.io/commands/decrby
     |
     |  delex(self, name: 'KeyT', ifeq: 'bytes | str | None' = None, ifne: 'bytes | str | None' = None, ifdeq: 'str | None' = None, ifdne: 'str | None' = None) -> 'int | Awaitable[int]'
     |      Conditionally removes the specified key.
     |
     |      Warning:
     |      **Experimental** since 7.1.
     |      This API may change or be removed without notice.
     |      The API may change based on feedback.
     |
     |      Arguments:
     |          name: KeyT - the key to delete
     |          ifeq match-valu: Optional[Union[bytes, str]] - Delete the key only if its value is equal to match-value
     |          ifne match-value: Optional[Union[bytes, str]] - Delete the key only if its value is not equal to match-value
     |          ifdeq match-digest: Optional[str] - Delete the key only if the digest of its value is equal to match-digest
     |          ifdne match-digest: Optional[str] - Delete the key only if the digest of its value is not equal to match-digest
     |
     |      Returns:
     |          int: 1 if the key was deleted, 0 otherwise.
     |      Raises:
     |          redis.exceptions.ResponseError: if key exists but is not a string
     |                                          and a condition is specified.
     |          ValueError: if more than one condition is provided.
     |
     |
     |      Requires Redis 8.4 or greater.
     |      For more information, see https://redis.io/commands/delex
     |
     |  digest(self, name: 'KeyT') -> 'str | bytes | None | Awaitable[str | bytes | None]'
     |      Return the digest of the value stored at the specified key.
     |
     |      Warning:
     |      **Experimental** since 7.1.
     |      This API may change or be removed without notice.
     |      The API may change based on feedback.
     |
     |      Arguments:
     |        - name: KeyT - the key to get the digest of
     |
     |      Returns:
     |        - None if the key does not exist
     |        - (bulk string) the XXH3 digest of the value as a hex string
     |      Raises:
     |        - ResponseError if key exists but is not a string
     |
     |
     |      Requires Redis 8.4 or greater.
     |      For more information, see https://redis.io/commands/digest
     |
     |  digest_local(self, value: 'bytes | str') -> 'bytes | str'
     |      Compute the hexadecimal digest of the value locally, without sending it to the server.
     |
     |      This is useful for conditional operations like IFDEQ/IFDNE where you need to
     |      compute the digest client-side before sending a command.
     |
     |      Warning:
     |      **Experimental** - This API may change or be removed without notice.
     |
     |      Arguments:
     |        - value: Union[bytes, str] - the value to compute the digest of.
     |          If a string is provided, it will be encoded using UTF-8 before hashing,
     |          which matches Redis's default encoding behavior.
     |
     |      Returns:
     |        - (str | bytes) the XXH3 digest of the value as a hex string (16 hex characters).
     |          Returns bytes if decode_responses is False, otherwise returns str.
     |
     |      For more information, see https://redis.io/commands/digest
     |
     |  dump(self, name: 'KeyT') -> 'bytes | None | Awaitable[bytes | None]'
     |      Return a serialized version of the value stored at the specified key.
     |      If key does not exist a nil bulk reply is returned.
     |
     |      For more information, see https://redis.io/commands/dump
     |
     |  expire(self, name: 'KeyT', time: 'ExpiryT', nx: 'bool' = False, xx: 'bool' = False, gt: 'bool' = False, lt: 'bool' = False) -> 'bool | Awaitable[bool]'
     |      Set an expire flag on key ``name`` for ``time`` seconds with given
     |      ``option``. ``time`` can be represented by an integer or a Python timedelta
     |      object.
     |
     |      Valid options are:
     |          NX -> Set expiry only when the key has no expiry
     |          XX -> Set expiry only when the key has an existing expiry
     |          GT -> Set expiry only when the new expiry is greater than current one
     |          LT -> Set expiry only when the new expiry is less than current one
     |
     |      For more information, see https://redis.io/commands/expire
     |
     |  expireat(self, name: 'KeyT', when: 'AbsExpiryT', nx: 'bool' = False, xx: 'bool' = False, gt: 'bool' = False, lt: 'bool' = False) -> 'bool | Awaitable[bool]'
     |      Set an expire flag on key ``name`` with given ``option``. ``when``
     |      can be represented as an integer indicating unix time or a Python
     |      datetime object.
     |
     |      Valid options are:
     |          -> NX -- Set expiry only when the key has no expiry
     |          -> XX -- Set expiry only when the key has an existing expiry
     |          -> GT -- Set expiry only when the new expiry is greater than current one
     |          -> LT -- Set expiry only when the new expiry is less than current one
     |
     |      For more information, see https://redis.io/commands/expireat
     |
     |  expiretime(self, key: 'str') -> 'int | Awaitable[int]'
     |      Returns the absolute Unix timestamp (since January 1, 1970) in seconds
     |      at which the given key will expire.
     |
     |      For more information, see https://redis.io/commands/expiretime
     |
     |  get(self, name: 'KeyT') -> 'bytes | str | None | Awaitable[bytes | str | None]'
     |      Return the value at key ``name``, or None if the key doesn't exist
     |
     |      For more information, see https://redis.io/commands/get
     |
     |  getbit(self, name: 'KeyT', offset: 'int') -> 'int | Awaitable[int]'
     |      Returns an integer indicating the value of ``offset`` in ``name``
     |
     |      For more information, see https://redis.io/commands/getbit
     |
     |  getdel(self, name: 'KeyT') -> 'bytes | str | None | Awaitable[bytes | str | None]'
     |      Get the value at key ``name`` and delete the key. This command
     |      is similar to GET, except for the fact that it also deletes
     |      the key on success (if and only if the key's value type
     |      is a string).
     |
     |      For more information, see https://redis.io/commands/getdel
     |
     |  getex(self, name: 'KeyT', ex: 'ExpiryT | None' = None, px: 'ExpiryT | None' = None, exat: 'AbsExpiryT | None' = None, pxat: 'AbsExpiryT | None' = None, persist: 'bool' = False) -> 'bytes | str | None | Awaitable[bytes | str | None]'
     |      Get the value of key and optionally set its expiration.
     |      GETEX is similar to GET, but is a write command with
     |      additional options. All time parameters can be given as
     |      datetime.timedelta or integers.
     |
     |      ``ex`` sets an expire flag on key ``name`` for ``ex`` seconds.
     |
     |      ``px`` sets an expire flag on key ``name`` for ``px`` milliseconds.
     |
     |      ``exat`` sets an expire flag on key ``name`` for ``ex`` seconds,
     |      specified in unix time.
     |
     |      ``pxat`` sets an expire flag on key ``name`` for ``ex`` milliseconds,
     |      specified in unix time.
     |
     |      ``persist`` remove the time to live associated with ``name``.
     |
     |      For more information, see https://redis.io/commands/getex
     |
     |  getrange(self, key: 'KeyT', start: 'int', end: 'int') -> 'bytes | str | Awaitable[bytes | str]'
     |      Returns the substring of the string value stored at ``key``,
     |      determined by the offsets ``start`` and ``end`` (both are inclusive)
     |
     |      For more information, see https://redis.io/commands/getrange
     |
     |  getset(self, name: 'KeyT', value: 'EncodableT') -> 'bytes | str | None | Awaitable[bytes | str | None]'
     |      Sets the value at key ``name`` to ``value``
     |      and returns the old value at key ``name`` atomically.
     |
     |      As per Redis 6.2, GETSET is considered deprecated.
     |      Please use SET with GET parameter in new code.
     |
     |      For more information, see https://redis.io/commands/getset
     |
     |  hrandfield(self, key: 'KeyT', count: 'int | None' = None, withvalues: 'bool' = False) -> 'HRandFieldResponse | Awaitable[HRandFieldResponse]'
     |      Return a random field from the hash value stored at key.
     |
     |      count: if the argument is positive, return an array of distinct fields.
     |      If called with a negative count, the behavior changes and the command
     |      is allowed to return the same field multiple times. In this case,
     |      the number of returned fields is the absolute value of the
     |      specified count.
     |      withvalues: The optional WITHVALUES modifier changes the reply so it
     |      includes the respective values of the randomly selected hash fields.
     |
     |      For more information, see https://redis.io/commands/hrandfield
     |
     |  incr = incrby(self, name: 'KeyT', amount: 'int' = 1) -> 'int | Awaitable[int]'
     |
     |  incrby(self, name: 'KeyT', amount: 'int' = 1) -> 'int | Awaitable[int]'
     |      Increments the value of ``key`` by ``amount``.  If no key exists,
     |      the value will be initialized as ``amount``
     |
     |      For more information, see https://redis.io/commands/incrby
     |
     |  incrbyfloat(self, name: 'KeyT', amount: 'float' = 1.0) -> 'float | Awaitable[float]'
     |      Increments the value at key ``name`` by floating ``amount``.
     |      If no key exists, the value will be initialized as ``amount``
     |
     |      For more information, see https://redis.io/commands/incrbyfloat
     |
     |  increx(self, name: 'KeyT', *, byfloat: 'EncodableT | None' = None, byint: 'EncodableT | None' = None, lbound: 'EncodableT | None' = None, ubound: 'EncodableT | None' = None, saturate: 'bool' = False, ex: 'ExpiryT | None' = None, px: 'ExpiryT | None' = None, exat: 'AbsExpiryT | None' = None, pxat: 'AbsExpiryT | None' = None, persist: 'bool' = False, enx: 'bool' = False) -> 'list[Number | bytes | str] | Awaitable[list[Number | bytes | str]]'
     |      Increment the numeric value at key ``name`` and return the new value
     |      and the actual increment.
     |
     |      ``byfloat`` increments a floating point value by the provided amount.
     |
     |      ``byint`` increments an integer value by the provided amount.
     |
     |      If neither ``byfloat`` nor ``byint`` is specified, the value is
     |      incremented by one.
     |
     |      ``lbound`` and ``ubound`` constrain the valid range of the result.
     |
     |      If ``saturate`` is True, out-of-bounds results are saturated to the
     |      specified bound, or to the type limit when no bound is specified.
     |      Otherwise, out-of-bounds results are rejected, leaving the value and
     |      TTL unchanged and returning the current value and zero as the actual
     |      increment.
     |
     |      ``enx`` applies the expiration only when the key does not already
     |      have an expiration, and requires ``ex``, ``px``, ``exat``, or ``pxat``.
     |
     |  lcs(self, key1: 'str', key2: 'str', len: 'bool | None' = False, idx: 'bool | None' = False, minmatchlen: 'int | None' = 0, withmatchlen: 'bool | None' = False) -> 'LCSCommandResponse | Awaitable[LCSCommandResponse]'
     |      Find the longest common subsequence between ``key1`` and ``key2``.
     |      If ``len`` is true the length of the match will be returned.
     |      If ``idx`` is true the match position in each strings will be returned.
     |      ``minmatchlen`` restrict the list of matches to the ones of
     |      the given ``minmatchlen``.
     |      If ``withmatchlen`` the length of the match also will be returned.
     |      For more information, see https://redis.io/commands/lcs
     |
     |  lmove(self, first_list: 'str', second_list: 'str', src: 'str' = 'LEFT', dest: 'str' = 'RIGHT') -> 'bytes | str | None | Awaitable[bytes | str | None]'
     |      Atomically returns and removes the first/last element of a list,
     |      pushing it as the first/last element on the destination list.
     |      Returns the element being popped and pushed.
     |
     |      For more information, see https://redis.io/commands/lmove
     |
     |  lmovem(self, first_list: 'str', second_list: 'str', src: 'str' = 'LEFT', dest: 'str' = 'RIGHT', count: 'int | None' = None, mode: "Literal['COUNT', 'EXACTLY'] | None" = None, ordering: "Literal['OBO', 'BULK'] | None" = None) -> 'list[bytes | str] | None | Awaitable[list[bytes | str] | None]'
     |      Atomically moves multiple elements from one end of the ``first_list``
     |      to one end of the ``second_list``, returning the moved elements in
     |      destination order.
     |
     |      ``src`` and ``dest`` are the ends to pop from / push to, either
     |      ``LEFT`` (head) or ``RIGHT`` (tail).
     |
     |      When ``count`` is given, ``mode`` selects how many elements to move:
     |      ``COUNT`` (the default) moves up to ``count`` elements, while
     |      ``EXACTLY`` moves exactly ``count`` elements or nothing at all. When
     |      ``count`` is not given a single element is moved.
     |
     |      ``ordering`` controls the order at the destination: ``OBO`` pushes each
     |      element as it is popped (reversing block order, stack semantics) while
     |      ``BULK`` preserves the original relative order (queue semantics). It is
     |      required whenever ``count`` is given.
     |
     |      Returns the array of moved elements, or ``None`` if nothing was moved.
     |
     |      For more information, see https://redis.io/commands/lmovem
     |
     |  persist(self, name: 'KeyT') -> 'bool | Awaitable[bool]'
     |      Removes an expiration on ``name``
     |
     |      For more information, see https://redis.io/commands/persist
     |
     |  pexpire(self, name: 'KeyT', time: 'ExpiryT', nx: 'bool' = False, xx: 'bool' = False, gt: 'bool' = False, lt: 'bool' = False) -> 'bool | Awaitable[bool]'
     |      Set an expire flag on key ``name`` for ``time`` milliseconds
     |      with given ``option``. ``time`` can be represented by an
     |      integer or a Python timedelta object.
     |
     |      Valid options are:
     |          NX -> Set expiry only when the key has no expiry
     |          XX -> Set expiry only when the key has an existing expiry
     |          GT -> Set expiry only when the new expiry is greater than current one
     |          LT -> Set expiry only when the new expiry is less than current one
     |
     |      For more information, see https://redis.io/commands/pexpire
     |
     |  pexpireat(self, name: 'KeyT', when: 'AbsExpiryT', nx: 'bool' = False, xx: 'bool' = False, gt: 'bool' = False, lt: 'bool' = False) -> 'bool | Awaitable[bool]'
     |      Set an expire flag on key ``name`` with given ``option``. ``when``
     |      can be represented as an integer representing unix time in
     |      milliseconds (unix time * 1000) or a Python datetime object.
     |
     |      Valid options are:
     |          NX -> Set expiry only when the key has no expiry
     |          XX -> Set expiry only when the key has an existing expiry
     |          GT -> Set expiry only when the new expiry is greater than current one
     |          LT -> Set expiry only when the new expiry is less than current one
     |
     |      For more information, see https://redis.io/commands/pexpireat
     |
     |  pexpiretime(self, key: 'str') -> 'int | Awaitable[int]'
     |      Returns the absolute Unix timestamp (since January 1, 1970) in milliseconds
     |      at which the given key will expire.
     |
     |      For more information, see https://redis.io/commands/pexpiretime
     |
     |  psetex(self, name: 'KeyT', time_ms: 'ExpiryT', value: 'EncodableT') -> 'bool | Awaitable[bool]'
     |      Set the value of key ``name`` to ``value`` that expires in ``time_ms``
     |      milliseconds. ``time_ms`` can be represented by an integer or a Python
     |      timedelta object
     |
     |      For more information, see https://redis.io/commands/psetex
     |
     |  pttl(self, name: 'KeyT') -> 'int | Awaitable[int]'
     |      Returns the number of milliseconds until the key ``name`` will expire
     |
     |      For more information, see https://redis.io/commands/pttl
     |
     |  restore(self, name: 'KeyT', ttl: 'float', value: 'EncodableT', replace: 'bool' = False, absttl: 'bool' = False, idletime: 'int | None' = None, frequency: 'int | None' = None) -> 'bytes | str | Awaitable[bytes | str]'
     |      Create a key using the provided serialized value, previously obtained
     |      using DUMP.
     |
     |      ``replace`` allows an existing key on ``name`` to be overridden. If
     |      it's not specified an error is raised on collision.
     |
     |      ``absttl`` if True, specified ``ttl`` should represent an absolute Unix
     |      timestamp in milliseconds in which the key will expire. (Redis 5.0 or
     |      greater).
     |
     |      ``idletime`` Used for eviction, this is the number of seconds the
     |      key must be idle, prior to execution.
     |
     |      ``frequency`` Used for eviction, this is the frequency counter of
     |      the object stored at the key, prior to execution.
     |
     |      For more information, see https://redis.io/commands/restore
     |
     |  set(self, name: 'KeyT', value: 'EncodableT', ex: 'ExpiryT | None' = None, px: 'ExpiryT | None' = None, nx: 'bool' = False, xx: 'bool' = False, keepttl: 'bool' = False, get: 'bool' = False, exat: 'AbsExpiryT | None' = None, pxat: 'AbsExpiryT | None' = None, ifeq: 'bytes | str | None' = None, ifne: 'bytes | str | None' = None, ifdeq: 'str | None' = None, ifdne: 'str | None' = None) -> 'bool | str | bytes | None | Awaitable[bool | str | bytes | None]'
     |      Set the value at key ``name`` to ``value``
     |
     |      Warning:
     |      **Experimental** since 7.1.
     |      The usage of the arguments ``ifeq``, ``ifne``, ``ifdeq``, and ``ifdne``
     |      is experimental. The API or returned results when those parameters are used
     |      may change based on feedback.
     |
     |      ``ex`` sets an expire flag on key ``name`` for ``ex`` seconds.
     |
     |      ``px`` sets an expire flag on key ``name`` for ``px`` milliseconds.
     |
     |      ``nx`` if set to True, set the value at key ``name`` to ``value`` only
     |          if it does not exist.
     |
     |      ``xx`` if set to True, set the value at key ``name`` to ``value`` only
     |          if it already exists.
     |
     |      ``keepttl`` if True, retain the time to live associated with the key.
     |          (Available since Redis 6.0)
     |
     |      ``get`` if True, set the value at key ``name`` to ``value`` and return
     |          the old value stored at key, or None if the key did not exist.
     |          (Available since Redis 6.2)
     |
     |      ``exat`` sets an expire flag on key ``name`` for ``ex`` seconds,
     |          specified in unix time.
     |
     |      ``pxat`` sets an expire flag on key ``name`` for ``ex`` milliseconds,
     |          specified in unix time.
     |
     |      ``ifeq`` set the value at key ``name`` to ``value`` only if the current
     |          value exactly matches the argument.
     |          If key doesn’t exist - it won’t be created.
     |          (Requires Redis 8.4 or greater)
     |
     |      ``ifne`` set the value at key ``name`` to ``value`` only if the current
     |          value does not exactly match the argument.
     |          If key doesn’t exist - it will be created.
     |          (Requires Redis 8.4 or greater)
     |
     |      ``ifdeq`` set the value at key ``name`` to ``value`` only if the current
     |          value XXH3 hex digest exactly matches the argument.
     |          If key doesn’t exist - it won’t be created.
     |          (Requires Redis 8.4 or greater)
     |
     |      ``ifdne`` set the value at key ``name`` to ``value`` only if the current
     |          value XXH3 hex digest does not exactly match the argument.
     |          If key doesn’t exist - it will be created.
     |          (Requires Redis 8.4 or greater)
     |
     |      For more information, see https://redis.io/commands/set
     |
     |  setbit(self, name: 'KeyT', offset: 'int', value: 'int') -> 'int | Awaitable[int]'
     |      Flag the ``offset`` in ``name`` as ``value``. Returns an integer
     |      indicating the previous value of ``offset``.
     |
     |      For more information, see https://redis.io/commands/setbit
     |
     |  setex(self, name: 'KeyT', time: 'ExpiryT', value: 'EncodableT') -> 'bool | Awaitable[bool]'
     |      Set the value of key ``name`` to ``value`` that expires in ``time``
     |      seconds. ``time`` can be represented by an integer or a Python
     |      timedelta object.
     |
     |      As per Redis 2.6.12, SETEX is considered deprecated.
     |      Please use SET with EX parameter in new code.
     |
     |      For more information, see https://redis.io/commands/setex
     |
     |  setnx(self, name: 'KeyT', value: 'EncodableT') -> 'bool | Awaitable[bool]'
     |      Set the value of key ``name`` to ``value`` if key doesn't exist
     |
     |      For more information, see https://redis.io/commands/setnx
     |
     |  setrange(self, name: 'KeyT', offset: 'int', value: 'EncodableT') -> 'int | Awaitable[int]'
     |      Overwrite bytes in the value of ``name`` starting at ``offset`` with
     |      ``value``. If ``offset`` plus the length of ``value`` exceeds the
     |      length of the original value, the new value will be larger than before.
     |      If ``offset`` exceeds the length of the original value, null bytes
     |      will be used to pad between the end of the previous value and the start
     |      of what's being injected.
     |
     |      Returns the length of the new string.
     |
     |      For more information, see https://redis.io/commands/setrange
     |
     |  strlen(self, name: 'KeyT') -> 'int | Awaitable[int]'
     |      Return the number of bytes stored in the value of ``name``
     |
     |      For more information, see https://redis.io/commands/strlen
     |
     |  substr(self, name: 'KeyT', start: 'int', end: 'int' = -1) -> 'bytes | str | Awaitable[bytes | str]'
     |      Return a substring of the string at key ``name``. ``start`` and ``end``
     |      are 0-based integers specifying the portion of the string to return.
     |
     |  ttl(self, name: 'KeyT') -> 'int | Awaitable[int]'
     |      Returns the number of seconds until the key ``name`` will expire
     |
     |      For more information, see https://redis.io/commands/ttl
     |
     |  type(self, name: 'KeyT') -> 'bytes | str | Awaitable[bytes | str]'
     |      Returns the type of key ``name``
     |
     |      For more information, see https://redis.io/commands/type
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from redis.commands.core.HyperlogCommands:
     |
     |  pfadd(self, name: 'KeyT', *values: 'FieldT') -> 'int | Awaitable[int]'
     |      Adds the specified elements to the specified HyperLogLog.
     |
     |      For more information, see https://redis.io/commands/pfadd
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from redis.commands.core.HashCommands:
     |
     |  hdel(self, name: 'KeyT', *keys: 'FieldT') -> 'int | Awaitable[int]'
     |      Delete ``keys`` from hash ``name``
     |
     |      For more information, see https://redis.io/commands/hdel
     |
     |  hexists(self, name: 'KeyT', key: 'FieldT') -> 'bool | Awaitable[bool]'
     |      Returns a boolean indicating if ``key`` exists within hash ``name``
     |
     |      For more information, see https://redis.io/commands/hexists
     |
     |  hexpire(self, name: 'KeyT', seconds: 'ExpiryT', *fields: 'FieldT', nx: 'bool' = False, xx: 'bool' = False, gt: 'bool' = False, lt: 'bool' = False) -> 'list[int] | Awaitable[list[int]]'
     |      Sets or updates the expiration time for fields within a hash key, using relative
     |      time in seconds.
     |
     |      If a field already has an expiration time, the behavior of the update can be
     |      controlled using the `nx`, `xx`, `gt`, and `lt` parameters.
     |
     |      The return value provides detailed information about the outcome for each field.
     |
     |      For more information, see https://redis.io/commands/hexpire
     |
     |      Args:
     |          name: The name of the hash key.
     |          seconds: Expiration time in seconds, relative. Can be an integer, or a
     |                   Python `timedelta` object.
     |          fields: List of fields within the hash to apply the expiration time to.
     |          nx: Set expiry only when the field has no expiry.
     |          xx: Set expiry only when the field has an existing expiry.
     |          gt: Set expiry only when the new expiry is greater than the current one.
     |          lt: Set expiry only when the new expiry is less than the current one.
     |
     |      Returns:
     |          Returns a list which contains for each field in the request:
     |              - `-2` if the field does not exist, or if the key does not exist.
     |              - `0` if the specified NX | XX | GT | LT condition was not met.
     |              - `1` if the expiration time was set or updated.
     |              - `2` if the field was deleted because the specified expiration time is
     |                in the past.
     |
     |  hexpireat(self, name: 'KeyT', unix_time_seconds: 'AbsExpiryT', *fields: 'FieldT', nx: 'bool' = False, xx: 'bool' = False, gt: 'bool' = False, lt: 'bool' = False) -> 'list[int] | Awaitable[list[int]]'
     |      Sets or updates the expiration time for fields within a hash key, using an
     |      absolute Unix timestamp in seconds.
     |
     |      If a field already has an expiration time, the behavior of the update can be
     |      controlled using the `nx`, `xx`, `gt`, and `lt` parameters.
     |
     |      The return value provides detailed information about the outcome for each field.
     |
     |      For more information, see https://redis.io/commands/hexpireat
     |
     |      Args:
     |          name: The name of the hash key.
     |          unix_time_seconds: Expiration time as Unix timestamp in seconds. Can be an
     |                             integer or a Python `datetime` object.
     |          fields: List of fields within the hash to apply the expiration time to.
     |          nx: Set expiry only when the field has no expiry.
     |          xx: Set expiry only when the field has an existing expiration time.
     |          gt: Set expiry only when the new expiry is greater than the current one.
     |          lt: Set expiry only when the new expiry is less than the current one.
     |
     |      Returns:
     |          Returns a list which contains for each field in the request:
     |              - `-2` if the field does not exist, or if the key does not exist.
     |              - `0` if the specified NX | XX | GT | LT condition was not met.
     |              - `1` if the expiration time was set or updated.
     |              - `2` if the field was deleted because the specified expiration time is
     |                in the past.
     |
     |  hexpiretime(self, key: 'KeyT', *fields: 'FieldT') -> 'list[int] | Awaitable[list[int]]'
     |      Returns the expiration times of hash fields as Unix timestamps in seconds.
     |
     |      For more information, see https://redis.io/commands/hexpiretime
     |
     |      Args:
     |          key: The hash key.
     |          fields: A list of fields within the hash for which to get the expiration
     |                  time.
     |
     |      Returns:
     |          Returns a list which contains for each field in the request:
     |              - `-2` if the field does not exist, or if the key does not exist.
     |              - `-1` if the field exists but has no associated expire time.
     |              - A positive integer representing the expiration Unix timestamp in
     |                seconds, if the field has an associated expiration time.
     |
     |  hget(self, name: 'KeyT', key: 'FieldT') -> 'bytes | str | None | Awaitable[bytes | str | None]'
     |      Return the value of ``key`` within the hash ``name``
     |
     |      For more information, see https://redis.io/commands/hget
     |
     |  hgetall(self, name: 'KeyT') -> 'dict[bytes | str, bytes | str] | Awaitable[dict[bytes | str, bytes | str]]'
     |      Return a Python dict of the hash's name/value pairs
     |
     |      For more information, see https://redis.io/commands/hgetall
     |
     |  hgetdel(self, name: 'KeyT', *keys: 'FieldT') -> 'list[bytes | str | None] | Awaitable[list[bytes | str | None]]'
     |      Return the value of ``key`` within the hash ``name`` and
     |      delete the field in the hash.
     |      This command is similar to HGET, except for the fact that it also deletes
     |      the key on success from the hash with the provided ```name```.
     |
     |      Available since Redis 8.0
     |      For more information, see https://redis.io/commands/hgetdel
     |
     |  hgetex(self, name: 'KeyT', *keys: 'FieldT', ex: 'ExpiryT | None' = None, px: 'ExpiryT | None' = None, exat: 'AbsExpiryT | None' = None, pxat: 'AbsExpiryT | None' = None, persist: 'bool' = False) -> 'list[bytes | str | None] | Awaitable[list[bytes | str | None]]'
     |      Return the values of ``key`` and ``keys`` within the hash ``name``
     |      and optionally set their expiration.
     |
     |      ``ex`` sets an expire flag on ``kyes`` for ``ex`` seconds.
     |
     |      ``px`` sets an expire flag on ``keys`` for ``px`` milliseconds.
     |
     |      ``exat`` sets an expire flag on ``keys`` for ``ex`` seconds,
     |      specified in unix time.
     |
     |      ``pxat`` sets an expire flag on ``keys`` for ``ex`` milliseconds,
     |      specified in unix time.
     |
     |      ``persist`` remove the time to live associated with the ``keys``.
     |
     |      Available since Redis 8.0
     |      For more information, see https://redis.io/commands/hgetex
     |
     |  himport_discard_all_internal(self) -> 'int | Awaitable[int]'
     |      Send ``HIMPORT DISCARDALL`` (returns the number of fieldsets removed).
     |
     |      .. warning::
     |          Internal wire mapping — not for direct use on a pooled client. It
     |          DISCARDs on a single arbitrary borrowed connection and bypasses the
     |          client's shared fieldset registry, leaving other connections and the
     |          registry out of sync. Use the client's ``himport_discard_all`` instead;
     |          call this only on a pinned single-connection client where you manage
     |          session state yourself.
     |
     |  himport_discard_internal(self, fieldset_name: 'str') -> 'int | Awaitable[int]'
     |      Send ``HIMPORT DISCARD fieldset_name`` (``1`` removed, ``0`` not found).
     |
     |      .. warning::
     |          Internal wire mapping — not for direct use on a pooled client. It
     |          DISCARDs on a single arbitrary borrowed connection and bypasses the
     |          client's shared fieldset registry, leaving other connections and the
     |          registry out of sync. Use the client's ``himport_discard`` instead; call
     |          this only on a pinned single-connection client where you manage session
     |          state yourself.
     |
     |  himport_prepare_internal(self, fieldset_name: 'str', fields: 'Iterable[FieldT]') -> 'bool | Awaitable[bool]'
     |      Send ``HIMPORT PREPARE fieldset_name field [field ...]``.
     |
     |      Registers the ordered field list under ``fieldset_name`` in the executing
     |      connection's session. Fields are sent in the caller's order, unmodified.
     |
     |      .. warning::
     |          Internal wire mapping — not for direct use on a pooled client. It
     |          PREPAREs on a single arbitrary borrowed connection and bypasses the
     |          client's shared fieldset registry, so other connections stay unaware and
     |          reintroduce the nondeterministic "no such fieldset" the HIMPORT design
     |          prevents. Use the client's ``himport_prepare`` instead; call this only
     |          on a pinned single-connection client where you manage session state
     |          yourself.
     |
     |  himport_set(self, key: 'KeyT', fieldset_name: 'str', values: 'Iterable[EncodableT]') -> 'bool | Awaitable[bool]'
     |      Create/replace ``key`` as a hash using ``fieldset_name``'s field list.
     |
     |      Values are sent in the caller's order and map positionally to the prepared
     |      fields. The fieldset is prepared on the serving connection on first use
     |      (PREPARE bundled with SET in one write) and reused on subsequent calls;
     |      runtime discards are reconciled on the next use of the connection. All of
     |      this happens inside the normal command path, so retry, disconnect-on-error
     |      and (for the cluster) routing / MOVED-ASK apply exactly as for any command.
     |
     |      .. note::
     |          Recovery from a mid-connection fieldset loss (the server dropping the
     |          prepared fieldset without dropping the socket, e.g. ``RESET`` or
     |          ``maxmemory-clients`` eviction) applies only to a standalone
     |          ``himport_set`` call: it catches the resulting ``no such fieldset`` and
     |          re-prepares on the same socket, retrying the SET once. A ``himport_set``
     |          buffered in a **pipeline or transaction** has no such per-command
     |          recovery — its fieldset is PREPAREd once as a pre-flight before the
     |          batch, and if the server loses it between that pre-flight and the batch
     |          the SET fails and surfaces as an error in the batch results. Callers who
     |          need the automatic recovery should issue those sets outside a pipeline.
     |
     |  hincrby(self, name: 'KeyT', key: 'FieldT', amount: 'int' = 1) -> 'int | Awaitable[int]'
     |      Increment the value of ``key`` in hash ``name`` by ``amount``
     |
     |      For more information, see https://redis.io/commands/hincrby
     |
     |  hincrbyfloat(self, name: 'KeyT', key: 'FieldT', amount: 'float' = 1.0) -> 'float | Awaitable[float]'
     |      Increment the value of ``key`` in hash ``name`` by floating ``amount``
     |
     |      For more information, see https://redis.io/commands/hincrbyfloat
     |
     |  hkeys(self, name: 'KeyT') -> 'list[bytes | str] | Awaitable[list[bytes | str]]'
     |      Return the list of keys within hash ``name``
     |
     |      For more information, see https://redis.io/commands/hkeys
     |
     |  hlen(self, name: 'KeyT') -> 'int | Awaitable[int]'
     |      Return the number of elements in hash ``name``
     |
     |      For more information, see https://redis.io/commands/hlen
     |
     |  hmget(self, name: 'KeyT', keys: 'FieldT | Iterable[FieldT]', *args: 'FieldT') -> 'list[bytes | str | None] | Awaitable[list[bytes | str | None]]'
     |      Returns a list of values ordered identically to ``keys``
     |
     |      For more information, see https://redis.io/commands/hmget
     |
     |  hmset(self, name: 'KeyT', mapping: 'Mapping[FieldT, EncodableT]') -> 'bool | Awaitable[bool]'
     |      Set key to value within hash ``name`` for each corresponding
     |      key and value from the ``mapping`` dict.
     |
     |      For more information, see https://redis.io/commands/hmset
     |
     |  hpersist(self, name: 'KeyT', *fields: 'FieldT') -> 'list[int] | Awaitable[list[int]]'
     |      Removes the expiration time for each specified field in a hash.
     |
     |      For more information, see https://redis.io/commands/hpersist
     |
     |      Args:
     |          name: The name of the hash key.
     |          fields: A list of fields within the hash from which to remove the
     |                  expiration time.
     |
     |      Returns:
     |          Returns a list which contains for each field in the request:
     |              - `-2` if the field does not exist, or if the key does not exist.
     |              - `-1` if the field exists but has no associated expiration time.
     |              - `1` if the expiration time was successfully removed from the field.
     |
     |  hpexpire(self, name: 'KeyT', milliseconds: 'ExpiryT', *fields: 'FieldT', nx: 'bool' = False, xx: 'bool' = False, gt: 'bool' = False, lt: 'bool' = False) -> 'list[int] | Awaitable[list[int]]'
     |      Sets or updates the expiration time for fields within a hash key, using relative
     |      time in milliseconds.
     |
     |      If a field already has an expiration time, the behavior of the update can be
     |      controlled using the `nx`, `xx`, `gt`, and `lt` parameters.
     |
     |      The return value provides detailed information about the outcome for each field.
     |
     |      For more information, see https://redis.io/commands/hpexpire
     |
     |      Args:
     |          name: The name of the hash key.
     |          milliseconds: Expiration time in milliseconds, relative. Can be an integer,
     |                        or a Python `timedelta` object.
     |          fields: List of fields within the hash to apply the expiration time to.
     |          nx: Set expiry only when the field has no expiry.
     |          xx: Set expiry only when the field has an existing expiry.
     |          gt: Set expiry only when the new expiry is greater than the current one.
     |          lt: Set expiry only when the new expiry is less than the current one.
     |
     |      Returns:
     |          Returns a list which contains for each field in the request:
     |              - `-2` if the field does not exist, or if the key does not exist.
     |              - `0` if the specified NX | XX | GT | LT condition was not met.
     |              - `1` if the expiration time was set or updated.
     |              - `2` if the field was deleted because the specified expiration time is
     |                in the past.
     |
     |  hpexpireat(self, name: 'KeyT', unix_time_milliseconds: 'AbsExpiryT', *fields: 'FieldT', nx: 'bool' = False, xx: 'bool' = False, gt: 'bool' = False, lt: 'bool' = False) -> 'list[int] | Awaitable[list[int]]'
     |      Sets or updates the expiration time for fields within a hash key, using an
     |      absolute Unix timestamp in milliseconds.
     |
     |      If a field already has an expiration time, the behavior of the update can be
     |      controlled using the `nx`, `xx`, `gt`, and `lt` parameters.
     |
     |      The return value provides detailed information about the outcome for each field.
     |
     |      For more information, see https://redis.io/commands/hpexpireat
     |
     |      Args:
     |          name: The name of the hash key.
     |          unix_time_milliseconds: Expiration time as Unix timestamp in milliseconds.
     |                                  Can be an integer or a Python `datetime` object.
     |          fields: List of fields within the hash to apply the expiry.
     |          nx: Set expiry only when the field has no expiry.
     |          xx: Set expiry only when the field has an existing expiry.
     |          gt: Set expiry only when the new expiry is greater than the current one.
     |          lt: Set expiry only when the new expiry is less than the current one.
     |
     |      Returns:
     |          Returns a list which contains for each field in the request:
     |              - `-2` if the field does not exist, or if the key does not exist.
     |              - `0` if the specified NX | XX | GT | LT condition was not met.
     |              - `1` if the expiration time was set or updated.
     |              - `2` if the field was deleted because the specified expiration time is
     |                in the past.
     |
     |  hpexpiretime(self, key: 'KeyT', *fields: 'FieldT') -> 'list[int] | Awaitable[list[int]]'
     |      Returns the expiration times of hash fields as Unix timestamps in milliseconds.
     |
     |      For more information, see https://redis.io/commands/hpexpiretime
     |
     |      Args:
     |          key: The hash key.
     |          fields: A list of fields within the hash for which to get the expiration
     |                  time.
     |
     |      Returns:
     |          Returns a list which contains for each field in the request:
     |              - `-2` if the field does not exist, or if the key does not exist.
     |              - `-1` if the field exists but has no associated expire time.
     |              - A positive integer representing the expiration Unix timestamp in
     |                milliseconds, if the field has an associated expiration time.
     |
     |  hpttl(self, key: 'KeyT', *fields: 'FieldT') -> 'list[int] | Awaitable[list[int]]'
     |      Returns the TTL (Time To Live) in milliseconds for each specified field within a
     |      hash key.
     |
     |      For more information, see https://redis.io/commands/hpttl
     |
     |      Args:
     |          key: The hash key.
     |          fields: A list of fields within the hash for which to get the TTL.
     |
     |      Returns:
     |          Returns a list which contains for each field in the request:
     |              - `-2` if the field does not exist, or if the key does not exist.
     |              - `-1` if the field exists but has no associated expire time.
     |              - A positive integer representing the TTL in milliseconds if the field
     |                has an associated expiration time.
     |
     |  hset(self, name: 'KeyT', key: 'FieldT | None' = None, value: 'EncodableT | None' = None, mapping: 'Mapping[FieldT, EncodableT] | None' = None, items: 'Sequence[EncodableT] | None' = None) -> 'int | Awaitable[int]'
     |      Set ``key`` to ``value`` within hash ``name``,
     |      ``mapping`` accepts a dict of key/value pairs that will be
     |      added to hash ``name``.
     |      ``items`` accepts a list of key/value pairs that will be
     |      added to hash ``name``.
     |      Returns the number of fields that were added.
     |
     |      For more information, see https://redis.io/commands/hset
     |
     |  hsetex(self, name: 'KeyT', key: 'FieldT | None' = None, value: 'EncodableT | None' = None, mapping: 'Mapping[FieldT, EncodableT] | None' = None, items: 'Sequence[EncodableT] | None' = None, ex: 'ExpiryT | None' = None, px: 'ExpiryT | None' = None, exat: 'AbsExpiryT | None' = None, pxat: 'AbsExpiryT | None' = None, data_persist_option: 'HashDataPersistOptions | None' = None, keepttl: 'bool' = False) -> 'int | Awaitable[int]'
     |      Set ``key`` to ``value`` within hash ``name``
     |
     |      ``mapping`` accepts a dict of key/value pairs that will be
     |      added to hash ``name``.
     |
     |      ``items`` accepts a list of key/value pairs that will be
     |      added to hash ``name``.
     |
     |      ``ex`` sets an expire flag on ``keys`` for ``ex`` seconds.
     |
     |      ``px`` sets an expire flag on ``keys`` for ``px`` milliseconds.
     |
     |      ``exat`` sets an expire flag on ``keys`` for ``ex`` seconds,
     |          specified in unix time.
     |
     |      ``pxat`` sets an expire flag on ``keys`` for ``ex`` milliseconds,
     |          specified in unix time.
     |
     |      ``data_persist_option`` can be set to ``FNX`` or ``FXX`` to control the
     |          behavior of the command.
     |          ``FNX`` will set the value for each provided key to each
     |              provided value only if all do not already exist.
     |          ``FXX`` will set the value for each provided key to each
     |              provided value only if all already exist.
     |
     |      ``keepttl`` if True, retain the time to live associated with the keys.
     |
     |      Returns the number of fields that were added.
     |
     |      Available since Redis 8.0
     |      For more information, see https://redis.io/commands/hsetex
     |
     |  hsetnx(self, name: 'KeyT', key: 'FieldT', value: 'EncodableT') -> 'int | Awaitable[int]'
     |      Set ``key`` to ``value`` within hash ``name`` if ``key`` does not
     |      exist.  Returns 1 if HSETNX created a field, otherwise 0.
     |
     |      For more information, see https://redis.io/commands/hsetnx
     |
     |  hstrlen(self, name: 'KeyT', key: 'FieldT') -> 'int | Awaitable[int]'
     |      Return the number of bytes stored in the value of ``key``
     |      within hash ``name``
     |
     |      For more information, see https://redis.io/commands/hstrlen
     |
     |  httl(self, key: 'KeyT', *fields: 'FieldT') -> 'list[int] | Awaitable[list[int]]'
     |      Returns the TTL (Time To Live) in seconds for each specified field within a hash
     |      key.
     |
     |      For more information, see https://redis.io/commands/httl
     |
     |      Args:
     |          key: The hash key.
     |          fields: A list of fields within the hash for which to get the TTL.
     |
     |      Returns:
     |          Returns a list which contains for each field in the request:
     |              - `-2` if the field does not exist, or if the key does not exist.
     |              - `-1` if the field exists but has no associated expire time.
     |              - A positive integer representing the TTL in seconds if the field has
     |                an associated expiration time.
     |
     |  hvals(self, name: 'KeyT') -> 'list[bytes | str] | Awaitable[list[bytes | str]]'
     |      Return the list of values within hash ``name``
     |
     |      For more information, see https://redis.io/commands/hvals
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from redis.commands.core.GeoCommands:
     |
     |  geoadd(self, name: 'KeyT', values: 'Sequence[EncodableT]', nx: 'bool' = False, xx: 'bool' = False, ch: 'bool' = False) -> 'int | Awaitable[int]'
     |      Add the specified geospatial items to the specified key identified
     |      by the ``name`` argument. The Geospatial items are given as ordered
     |      members of the ``values`` argument, each item or place is formed by
     |      the triad longitude, latitude and name.
     |
     |      Note: You can use ZREM to remove elements.
     |
     |      ``nx`` forces ZADD to only create new elements and not to update
     |      scores for elements that already exist.
     |
     |      ``xx`` forces ZADD to only update scores of elements that already
     |      exist. New elements will not be added.
     |
     |      ``ch`` modifies the return value to be the numbers of elements changed.
     |      Changed elements include new elements that were added and elements
     |      whose scores changed.
     |
     |      For more information, see https://redis.io/commands/geoadd
     |
     |  geodist(self, name: 'KeyT', place1: 'FieldT', place2: 'FieldT', unit: 'str | None' = None) -> 'float | None | Awaitable[float | None]'
     |      Return the distance between ``place1`` and ``place2`` members of the
     |      ``name`` key.
     |      The units must be one of the following : m, km mi, ft. By default
     |      meters are used.
     |
     |      For more information, see https://redis.io/commands/geodist
     |
     |  geohash(self, name: 'KeyT', *values: 'FieldT') -> 'list[bytes | str | None] | Awaitable[list[bytes | str | None]]'
     |      Return the geo hash string for each item of ``values`` members of
     |      the specified key identified by the ``name`` argument.
     |
     |      For more information, see https://redis.io/commands/geohash
     |
     |  geopos(self, name: 'KeyT', *values: 'FieldT') -> 'list[GeoCoordinate | None] | Awaitable[list[GeoCoordinate | None]]'
     |      Return the positions of each item of ``values`` as members of
     |      the specified key identified by the ``name`` argument. Each position
     |      is represented by the pairs lon and lat.
     |
     |      For more information, see https://redis.io/commands/geopos
     |
     |  georadius(self, name: 'KeyT', longitude: 'float', latitude: 'float', radius: 'float', unit: 'str | None' = None, withdist: 'bool' = False, withcoord: 'bool' = False, withhash: 'bool' = False, count: 'int | None' = None, sort: 'str | None' = None, store: 'KeyT | None' = None, store_dist: 'KeyT | None' = None, any: 'bool' = False) -> 'GeoRadiusResponse | Awaitable[GeoRadiusResponse]'
     |      Return the members of the specified key identified by the
     |      ``name`` argument which are within the borders of the area specified
     |      with the ``latitude`` and ``longitude`` location and the maximum
     |      distance from the center specified by the ``radius`` value.
     |
     |      The units must be one of the following : m, km mi, ft. By default
     |
     |      ``withdist`` indicates to return the distances of each place.
     |
     |      ``withcoord`` indicates to return the latitude and longitude of
     |      each place.
     |
     |      ``withhash`` indicates to return the geohash string of each place.
     |
     |      ``count`` indicates to return the number of elements up to N.
     |
     |      ``sort`` indicates to return the places in a sorted way, ASC for
     |      nearest to fairest and DESC for fairest to nearest.
     |
     |      ``store`` indicates to save the places names in a sorted set named
     |      with a specific key, each element of the destination sorted set is
     |      populated with the score got from the original geo sorted set.
     |
     |      ``store_dist`` indicates to save the places names in a sorted set
     |      named with a specific key, instead of ``store`` the sorted set
     |      destination score is set with the distance.
     |
     |      For more information, see https://redis.io/commands/georadius
     |
     |  georadiusbymember(self, name: 'KeyT', member: 'FieldT', radius: 'float', unit: 'str | None' = None, withdist: 'bool' = False, withcoord: 'bool' = False, withhash: 'bool' = False, count: 'int | None' = None, sort: 'str | None' = None, store: 'Union[KeyT, None]' = None, store_dist: 'Union[KeyT, None]' = None, any: 'bool' = False) -> 'GeoRadiusResponse | Awaitable[GeoRadiusResponse]'
     |      This command is exactly like ``georadius`` with the sole difference
     |      that instead of taking, as the center of the area to query, a longitude
     |      and latitude value, it takes the name of a member already existing
     |      inside the geospatial index represented by the sorted set.
     |
     |      For more information, see https://redis.io/commands/georadiusbymember
     |
     |  geosearch(self, name: 'KeyT', member: 'FieldT | None' = None, longitude: 'float | None' = None, latitude: 'float | None' = None, unit: 'str' = 'm', radius: 'float | None' = None, width: 'float | None' = None, height: 'float | None' = None, sort: 'str | None' = None, count: 'int | None' = None, any: 'bool' = False, withcoord: 'bool' = False, withdist: 'bool' = False, withhash: 'bool' = False) -> 'GeoSearchResponse | Awaitable[GeoSearchResponse]'
     |      Return the members of specified key identified by the
     |      ``name`` argument, which are within the borders of the
     |      area specified by a given shape. This command extends the
     |      GEORADIUS command, so in addition to searching within circular
     |      areas, it supports searching within rectangular areas.
     |
     |      This command should be used in place of the deprecated
     |      GEORADIUS and GEORADIUSBYMEMBER commands.
     |
     |      ``member`` Use the position of the given existing
     |       member in the sorted set. Can't be given with ``longitude``
     |       and ``latitude``.
     |
     |      ``longitude`` and ``latitude`` Use the position given by
     |      this coordinates. Can't be given with ``member``
     |      ``radius`` Similar to GEORADIUS, search inside circular
     |      area according the given radius. Can't be given with
     |      ``height`` and ``width``.
     |      ``height`` and ``width`` Search inside an axis-aligned
     |      rectangle, determined by the given height and width.
     |      Can't be given with ``radius``
     |
     |      ``unit`` must be one of the following : m, km, mi, ft.
     |      `m` for meters (the default value), `km` for kilometers,
     |      `mi` for miles and `ft` for feet.
     |
     |      ``sort`` indicates to return the places in a sorted way,
     |      ASC for nearest to furthest and DESC for furthest to nearest.
     |
     |      ``count`` limit the results to the first count matching items.
     |
     |      ``any`` is set to True, the command will return as soon as
     |      enough matches are found. Can't be provided without ``count``
     |
     |      ``withdist`` indicates to return the distances of each place.
     |      ``withcoord`` indicates to return the latitude and longitude of
     |      each place.
     |
     |      ``withhash`` indicates to return the geohash string of each place.
     |
     |      For more information, see https://redis.io/commands/geosearch
     |
     |  geosearchstore(self, dest: 'KeyT', name: 'KeyT', member: 'FieldT | None' = None, longitude: 'float | None' = None, latitude: 'float | None' = None, unit: 'str' = 'm', radius: 'float | None' = None, width: 'float | None' = None, height: 'float | None' = None, sort: 'str | None' = None, count: 'int | None' = None, any: 'bool' = False, storedist: 'bool' = False) -> 'int | Awaitable[int]'
     |      This command is like GEOSEARCH, but stores the result in
     |      ``dest``. By default, it stores the results in the destination
     |      sorted set with their geospatial information.
     |      if ``store_dist`` set to True, the command will stores the
     |      items in a sorted set populated with their distance from the
     |      center of the circle or box, as a floating-point number.
     |
     |      For more information, see https://redis.io/commands/geosearchstore
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from redis.commands.core.ListCommands:
     |
     |  blmpop(self, timeout: 'float', numkeys: 'int', *args: 'str', direction: 'str', count: 'int | None' = 1) -> 'ListMultiPopResponse | Awaitable[ListMultiPopResponse]'
     |      Pop ``count`` values (default 1) from first non-empty in the list
     |      of provided key names.
     |
     |      When all lists are empty this command blocks the connection until another
     |      client pushes to it or until the timeout, timeout of 0 blocks indefinitely
     |
     |      For more information, see https://redis.io/commands/blmpop
     |
     |  blpop(self, keys: 'KeysT', timeout: 'Number | None' = 0) -> 'BlockingListPopResponse | Awaitable[BlockingListPopResponse]'
     |      LPOP a value off of the first non-empty list
     |      named in ``keys``.
     |
     |      If none of the lists in ``keys`` has a value to LPOP, then block
     |      for ``timeout`` seconds, or until a value gets pushed on to one
     |      of the lists.
     |
     |      If timeout is 0, then block indefinitely.
     |
     |      For more information, see https://redis.io/commands/blpop
     |
     |  brpop(self, keys: 'KeysT', timeout: 'Number | None' = 0) -> 'BlockingListPopResponse | Awaitable[BlockingListPopResponse]'
     |      RPOP a value off of the first non-empty list
     |      named in ``keys``.
     |
     |      If none of the lists in ``keys`` has a value to RPOP, then block
     |      for ``timeout`` seconds, or until a value gets pushed on to one
     |      of the lists.
     |
     |      If timeout is 0, then block indefinitely.
     |
     |      For more information, see https://redis.io/commands/brpop
     |
     |  lindex(self, name: 'KeyT', index: 'int') -> 'bytes | str | None | Awaitable[bytes | str | None]'
     |      Return the item from list ``name`` at position ``index``
     |
     |      Negative indexes are supported and will return an item at the
     |      end of the list
     |
     |      For more information, see https://redis.io/commands/lindex
     |
     |  linsert(self, name: 'KeyT', where: 'str', refvalue: 'str', value: 'str') -> 'int | Awaitable[int]'
     |      Insert ``value`` in list ``name`` either immediately before or after
     |      [``where``] ``refvalue``
     |
     |      Returns the new length of the list on success or -1 if ``refvalue``
     |      is not in the list.
     |
     |      For more information, see https://redis.io/commands/linsert
     |
     |  llen(self, name: 'KeyT') -> 'int | Awaitable[int]'
     |      Return the length of the list ``name``
     |
     |      For more information, see https://redis.io/commands/llen
     |
     |  lmpop(self, num_keys: 'int', *args: 'str', direction: 'str', count: 'int | None' = 1) -> 'ListMultiPopResponse | Awaitable[ListMultiPopResponse]'
     |      Pop ``count`` values (default 1) first non-empty list key from the list
     |      of args provided key names.
     |
     |      For more information, see https://redis.io/commands/lmpop
     |
     |  lpop(self, name: 'KeyT', count: 'int | None' = None) -> 'bytes | str | list[bytes | str] | None | Awaitable[bytes | str | list[bytes | str] | None]'
     |      Removes and returns the first elements of the list ``name``.
     |
     |      By default, the command pops a single element from the beginning of
     |      the list. When provided with the optional ``count`` argument, the reply
     |      will consist of up to count elements, depending on the list's length.
     |
     |      For more information, see https://redis.io/commands/lpop
     |
     |  lpos(self, name: 'KeyT', value: 'str', rank: 'int | None' = None, count: 'int | None' = None, maxlen: 'int | None' = None) -> 'int | list[int] | None | Awaitable[int | list[int] | None]'
     |      Get position of ``value`` within the list ``name``
     |
     |       If specified, ``rank`` indicates the "rank" of the first element to
     |       return in case there are multiple copies of ``value`` in the list.
     |       By default, LPOS returns the position of the first occurrence of
     |       ``value`` in the list. When ``rank`` 2, LPOS returns the position of
     |       the second ``value`` in the list. If ``rank`` is negative, LPOS
     |       searches the list in reverse. For example, -1 would return the
     |       position of the last occurrence of ``value`` and -2 would return the
     |       position of the next to last occurrence of ``value``.
     |
     |       If specified, ``count`` indicates that LPOS should return a list of
     |       up to ``count`` positions. A ``count`` of 2 would return a list of
     |       up to 2 positions. A ``count`` of 0 returns a list of all positions
     |       matching ``value``. When ``count`` is specified and but ``value``
     |       does not exist in the list, an empty list is returned.
     |
     |       If specified, ``maxlen`` indicates the maximum number of list
     |       elements to scan. A ``maxlen`` of 1000 will only return the
     |       position(s) of items within the first 1000 entries in the list.
     |       A ``maxlen`` of 0 (the default) will scan the entire list.
     |
     |       For more information, see https://redis.io/commands/lpos
     |
     |  lpush(self, name: 'KeyT', *values: 'FieldT') -> 'int | Awaitable[int]'
     |      Push ``values`` onto the head of the list ``name``
     |
     |      For more information, see https://redis.io/commands/lpush
     |
     |  lpushx(self, name: 'KeyT', *values: 'FieldT') -> 'int | Awaitable[int]'
     |      Push ``value`` onto the head of the list ``name`` if ``name`` exists
     |
     |      For more information, see https://redis.io/commands/lpushx
     |
     |  lrange(self, name: 'KeyT', start: 'int', end: 'int') -> 'list[bytes | str] | Awaitable[list[bytes | str]]'
     |      Return a slice of the list ``name`` between
     |      position ``start`` and ``end``
     |
     |      ``start`` and ``end`` can be negative numbers just like
     |      Python slicing notation
     |
     |      For more information, see https://redis.io/commands/lrange
     |
     |  lrem(self, name: 'KeyT', count: 'int', value: 'str') -> 'int | Awaitable[int]'
     |      Remove the first ``count`` occurrences of elements equal to ``value``
     |      from the list stored at ``name``.
     |
     |      The count argument influences the operation in the following ways:
     |          count > 0: Remove elements equal to value moving from head to tail.
     |          count < 0: Remove elements equal to value moving from tail to head.
     |          count = 0: Remove all elements equal to value.
     |
     |          For more information, see https://redis.io/commands/lrem
     |
     |  lset(self, name: 'KeyT', index: 'int', value: 'str') -> 'bool | Awaitable[bool]'
     |      Set element at ``index`` of list ``name`` to ``value``
     |
     |      For more information, see https://redis.io/commands/lset
     |
     |  ltrim(self, name: 'KeyT', start: 'int', end: 'int') -> 'bool | Awaitable[bool]'
     |      Trim the list ``name``, removing all values not within the slice
     |      between ``start`` and ``end``
     |
     |      ``start`` and ``end`` can be negative numbers just like
     |      Python slicing notation
     |
     |      For more information, see https://redis.io/commands/ltrim
     |
     |  rpop(self, name: 'KeyT', count: 'int | None' = None) -> 'bytes | str | list[bytes | str] | None | Awaitable[bytes | str | list[bytes | str] | None]'
     |      Removes and returns the last elements of the list ``name``.
     |
     |      By default, the command pops a single element from the end of the list.
     |      When provided with the optional ``count`` argument, the reply will
     |      consist of up to count elements, depending on the list's length.
     |
     |      For more information, see https://redis.io/commands/rpop
     |
     |  rpush(self, name: 'KeyT', *values: 'FieldT') -> 'int | Awaitable[int]'
     |      Push ``values`` onto the tail of the list ``name``
     |
     |      For more information, see https://redis.io/commands/rpush
     |
     |  rpushx(self, name: 'KeyT', *values: 'str') -> 'int | Awaitable[int]'
     |      Push ``value`` onto the tail of the list ``name`` if ``name`` exists
     |
     |      For more information, see https://redis.io/commands/rpushx
     |
     |  sort_ro(self, key: 'str', start: 'int | None' = None, num: 'int | None' = None, by: 'str | None' = None, get: 'list[str] | None' = None, desc: 'bool' = False, alpha: 'bool' = False) -> 'list[bytes | str] | Awaitable[list[bytes | str]]'
     |      Returns the elements contained in the list, set or sorted set at key.
     |      (read-only variant of the SORT command)
     |
     |      ``start`` and ``num`` allow for paging through the sorted data
     |
     |      ``by`` allows using an external key to weight and sort the items.
     |          Use an "*" to indicate where in the key the item value is located
     |
     |      ``get`` allows for returning items from external keys rather than the
     |          sorted data itself.  Use an "*" to indicate where in the key
     |          the item value is located
     |
     |      ``desc`` allows for reversing the sort
     |
     |      ``alpha`` allows for sorting lexicographically rather than numerically
     |
     |      For more information, see https://redis.io/commands/sort_ro
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from redis.commands.core.ArrayCommands:
     |
     |  arcount(self, name: 'KeyT') -> 'int | Awaitable[int]'
     |      Return the number of non-empty elements in the array stored at
     |      ``name``. Returns 0 if ``name`` does not exist.
     |
     |      For more information, see https://redis.io/commands/arcount
     |
     |  ardel(self, name: 'KeyT', *indices: 'int') -> 'int | Awaitable[int]'
     |      Delete elements at the specified ``indices`` in the array stored at
     |      ``name``. Deleting an index that does not exist counts as zero
     |      elements deleted and does not modify the array.
     |
     |      Returns the number of elements deleted.
     |
     |      For more information, see https://redis.io/commands/ardel
     |
     |  ardelrange(self, name: 'KeyT', *ranges: 'tuple[int, int]') -> 'int | Awaitable[int]'
     |      Delete elements within one or more inclusive index ranges in the
     |      array stored at ``name``. Each range is a ``(start, end)`` tuple.
     |      If ``start`` is greater than ``end`` for a given pair, the range is
     |      processed in ascending order regardless. Multiple pairs may overlap;
     |      each element is counted at most once.
     |
     |      Returns the number of elements deleted.
     |
     |      For more information, see https://redis.io/commands/ardelrange
     |
     |  arget(self, name: 'KeyT', index: 'int') -> 'bytes | str | None | Awaitable[bytes | str | None]'
     |      Return the value at ``index`` in the array stored at ``name``.
     |
     |      Returns ``None`` if ``name`` does not exist or no value is set at
     |      ``index``.
     |
     |      For more information, see https://redis.io/commands/arget
     |
     |  argetrange(self, name: 'KeyT', start: 'int', end: 'int') -> 'list[bytes | str | None] | Awaitable[list[bytes | str | None]]'
     |      Return the values in the inclusive index range [``start``, ``end``]
     |      in the array stored at ``name``. If ``start`` is greater than ``end``,
     |      elements are returned in reverse index order.
     |
     |      For more information, see https://redis.io/commands/argetrange
     |
     |  argrep(self, name: 'KeyT', start: 'int', end: 'int', predicates: 'list[tuple[ArrayPredicateType, EncodableT]]', combinator: 'ArrayPredicateCombinator | None' = None, limit: 'int | None' = None, withvalues: 'bool' = False, nocase: 'bool' = False) -> 'list[int] | list[list[int | bytes | str]] | Awaitable[list[int] | list[list[int | bytes | str]]]'
     |      Search elements of the array stored at ``name`` within the inclusive
     |      index range [``start``, ``end``] using one or more textual
     |      ``predicates``. Each predicate is a ``(type, value)`` tuple where
     |      ``type`` is a member of ``ArrayPredicateType``
     |      (``EXACT``, ``MATCH``, ``GLOB``, ``RE``).
     |
     |      Multiple predicates are combined via ``combinator``
     |      (``ArrayPredicateCombinator.AND`` or ``OR``); the server defaults to
     |      OR when omitted. ``limit`` caps the number of matches.
     |      ``withvalues=True`` returns a list of ``[index, value]`` pairs
     |      (``[[idx, val], ...]``) instead of a flat list of indices.
     |      ``nocase=True`` makes all comparisons case-insensitive.
     |
     |      Without ``withvalues``, returns a flat list of matching indices in
     |      traversal order. With ``withvalues``, returns a list of
     |      ``[index, value]`` pairs in traversal order. Empty slots are
     |      skipped.
     |
     |      For more information, see https://redis.io/commands/argrep
     |
     |  arinfo(self, name: 'KeyT', full: 'bool' = False) -> 'dict[str, int] | Awaitable[dict[str, int]]'
     |      Return metadata about the array stored at ``name`` as a dictionary.
     |      When ``full`` is ``True``, additionally include per-slice statistics
     |      (dense/sparse slice counts, average sizes, fill rates), which makes
     |      the call O(N) instead of O(1).
     |
     |      Raises ``ResponseError`` when the key does not exist.
     |
     |      For more information, see https://redis.io/commands/arinfo
     |
     |  arinsert(self, name: 'KeyT', *values: 'FieldT') -> 'int | Awaitable[int]'
     |      Insert one or more ``values`` at consecutive indices in the array
     |      stored at ``name``, beginning at the current insert cursor position.
     |      The cursor advances by one for each value inserted. Use ``ARNEXT``
     |      to inspect the current cursor position and ``ARSEEK`` to reposition
     |      it.
     |
     |      Returns the last index where a value was inserted.
     |
     |      For more information, see https://redis.io/commands/arinsert
     |
     |  arlastitems(self, name: 'KeyT', count: 'int', rev: 'bool' = False) -> 'list[bytes | str | None] | Awaitable[list[bytes | str | None]]'
     |      Return up to ``count`` most recently inserted elements from the array
     |      stored at ``name``. If the array contains fewer elements than
     |      ``count``, all elements are returned.
     |
     |      When ``rev`` is ``True``, elements are returned in reverse
     |      chronological order (most recent first) instead of the default
     |      oldest-first order.
     |
     |      For more information, see https://redis.io/commands/arlastitems
     |
     |  arlen(self, name: 'KeyT') -> 'int | Awaitable[int]'
     |      Return the length of the array stored at ``name``, defined as the
     |      maximum set index plus one. Returns 0 if ``name`` does not exist.
     |
     |      For more information, see https://redis.io/commands/arlen
     |
     |  armget(self, name: 'KeyT', *indices: 'int') -> 'list[bytes | str | None] | Awaitable[list[bytes | str | None]]'
     |      Return the values at the specified ``indices`` in the array stored at
     |      ``name``. The reply preserves the order of the requested indices and
     |      returns ``None`` for any index that is not set or when ``name`` does
     |      not exist.
     |
     |      For more information, see https://redis.io/commands/armget
     |
     |  armset(self, name: 'KeyT', mapping: 'Mapping[int, FieldT]') -> 'int | Awaitable[int]'
     |      Set multiple index/value pairs in the array stored at ``name``.
     |      ``mapping`` is a dictionary of zero-based integer indices to values.
     |      Pairs may be non-contiguous and in any order.
     |
     |      Returns the number of new slots that were set (previously empty).
     |
     |      For more information, see https://redis.io/commands/armset
     |
     |  arnext(self, name: 'KeyT') -> 'int | None | Awaitable[int | None]'
     |      Return the next index ``ARINSERT`` would use for the array stored at
     |      ``name``. Returns 0 if ``name`` does not exist or no insert happened
     |      yet, and ``None`` when the insertion cursor is exhausted (next insert
     |      would overflow).
     |
     |      For more information, see https://redis.io/commands/arnext
     |
     |  arop(self, name: 'KeyT', start: 'int', end: 'int', operation: 'ArrayAggregateOperations', value: 'EncodableT | None' = None) -> 'bytes | str | int | None | Awaitable[bytes | str | int | None]'
     |      Perform an aggregate ``operation`` on elements of the array stored at
     |      ``name`` in the inclusive index range [``start``, ``end``]. The range
     |      is always scanned from the lower to the higher index regardless of
     |      argument order.
     |
     |      ``operation`` is one of the members of ``ArrayAggregateOperations``.
     |      ``value`` is required when ``operation`` is
     |      ``ArrayAggregateOperations.MATCH`` and specifies the value to compare
     |      against.
     |
     |      Returns a bulk string for ``SUM``, ``MIN`` and ``MAX``, an integer
     |      for ``AND``, ``OR``, ``XOR``, ``MATCH`` and ``USED``, or ``None``
     |      when no elements match the operation.
     |
     |      For more information, see https://redis.io/commands/arop
     |
     |  arring(self, name: 'KeyT', size: 'int', *values: 'FieldT') -> 'int | Awaitable[int]'
     |      Insert one or more ``values`` into the array stored at ``name`` as a
     |      fixed-size ring buffer of ``size`` slots. Each value is placed at
     |      ``insert_idx % size``, wrapping back to index 0 once the end is
     |      reached and overwriting older values when full. If ``size`` is
     |      smaller than the current window, the array is truncated to fit.
     |
     |      Returns the last index where a value was inserted.
     |
     |      For more information, see https://redis.io/commands/arring
     |
     |  arscan(self, name: 'KeyT', start: 'int', end: 'int', limit: 'int | None' = None) -> 'list[list[int | bytes | str]] | Awaitable[list[list[int | bytes | str]]]'
     |      Iterate populated elements of the array stored at ``name`` in the
     |      inclusive range [``start``, ``end``] and return a list of
     |      ``[index, value]`` pairs in traversal order:
     |      ``[[idx1, val1], [idx2, val2], ...]``. Empty slots are skipped. If
     |      ``start`` is greater than ``end``, the iteration is reversed.
     |
     |      ``limit`` caps the number of populated elements returned. When
     |      omitted, all populated elements in range are returned.
     |
     |      For more information, see https://redis.io/commands/arscan
     |
     |  arseek(self, name: 'KeyT', index: 'int') -> 'int | Awaitable[int]'
     |      Set the insert cursor of the array stored at ``name`` to ``index``.
     |      Subsequent ``ARINSERT`` and ``ARRING`` operations begin inserting at
     |      this position.
     |
     |      Returns 1 if the cursor was set, 0 if ``name`` does not exist.
     |
     |      For more information, see https://redis.io/commands/arseek
     |
     |  arset(self, name: 'KeyT', index: 'int', *values: 'FieldT') -> 'int | Awaitable[int]'
     |      Set one or more contiguous ``values`` in the array stored at ``name``
     |      starting at ``index``. When multiple values are provided, they are
     |      stored at consecutive indices beginning at ``index``.
     |
     |      Returns the number of new slots that were set (previously empty).
     |
     |      For more information, see https://redis.io/commands/arset
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from redis.commands.core.ScanCommands:
     |
     |  hscan(self, name: 'KeyT', cursor: 'int' = 0, match: 'PatternT | None' = None, count: 'int | None' = None, no_values: 'bool | None' = None) -> 'HScanResponse | Awaitable[HScanResponse]'
     |      Incrementally return key/value slices in a hash. Also return a cursor
     |      indicating the scan position.
     |
     |      ``match`` allows for filtering the keys by pattern
     |
     |      ``count`` allows for hint the minimum number of returns
     |
     |      ``no_values`` indicates to return only the keys, without values.
     |
     |      For more information, see https://redis.io/commands/hscan
     |
     |  hscan_iter(self, name: 'KeyT', match: 'Union[PatternT, None]' = None, count: 'Optional[int]' = None, no_values: 'Union[bool, None]' = None) -> 'Iterator'
     |      Make an iterator using the HSCAN command so that the client doesn't
     |      need to remember the cursor position.
     |
     |      ``match`` allows for filtering the keys by pattern
     |
     |      ``count`` allows for hint the minimum number of returns
     |
     |      ``no_values`` indicates to return only the keys, without values
     |
     |  sscan(self, name: 'KeyT', cursor: 'int' = 0, match: 'PatternT | None' = None, count: 'int | None' = None) -> 'ScanResponse | Awaitable[ScanResponse]'
     |      Incrementally return lists of elements in a set. Also return a cursor
     |      indicating the scan position.
     |
     |      ``match`` allows for filtering the keys by pattern
     |
     |      ``count`` allows for hint the minimum number of returns
     |
     |      For more information, see https://redis.io/commands/sscan
     |
     |  sscan_iter(self, name: 'KeyT', match: 'Union[PatternT, None]' = None, count: 'Optional[int]' = None) -> 'Iterator'
     |      Make an iterator using the SSCAN command so that the client doesn't
     |      need to remember the cursor position.
     |
     |      ``match`` allows for filtering the keys by pattern
     |
     |      ``count`` allows for hint the minimum number of returns
     |
     |  zscan(self, name: 'KeyT', cursor: 'int' = 0, match: 'PatternT | None' = None, count: 'int | None' = None, score_cast_func: 'type | Callable' = <class 'float'>) -> 'ZScanResponse | Awaitable[ZScanResponse]'
     |      Incrementally return lists of elements in a sorted set. Also return a
     |      cursor indicating the scan position.
     |
     |      ``match`` allows for filtering the keys by pattern
     |
     |      ``count`` allows for hint the minimum number of returns
     |
     |      ``score_cast_func`` a callable used to cast the score return value
     |
     |      For more information, see https://redis.io/commands/zscan
     |
     |  zscan_iter(self, name: 'KeyT', match: 'Union[PatternT, None]' = None, count: 'Optional[int]' = None, score_cast_func: 'Union[type, Callable]' = <class 'float'>) -> 'Iterator'
     |      Make an iterator using the ZSCAN command so that the client doesn't
     |      need to remember the cursor position.
     |
     |      ``match`` allows for filtering the keys by pattern
     |
     |      ``count`` allows for hint the minimum number of returns
     |
     |      ``score_cast_func`` a callable used to cast the score return value
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from redis.commands.core.SetCommands:
     |
     |  sadd(self, name: 'KeyT', *values: 'FieldT') -> 'int | Awaitable[int]'
     |      Add ``value(s)`` to set ``name``
     |
     |      For more information, see https://redis.io/commands/sadd
     |
     |  scard(self, name: 'KeyT') -> 'int | Awaitable[int]'
     |      Return the number of elements in set ``name``
     |
     |      For more information, see https://redis.io/commands/scard
     |
     |  sdiffcard(self, numkeys: 'int', keys: 'List[KeyT]', limit: 'int' = 0) -> 'int | Awaitable[int]'
     |      Return the cardinality of the difference between the first set and all
     |      the successive sets specified by ``keys``, without returning the
     |      difference itself.
     |
     |      When LIMIT is provided (defaults to 0 and means unlimited), the returned
     |      cardinality is capped at ``limit`` and the server may stop the
     |      computation once the capped result is known.
     |
     |      For more information, see https://redis.io/commands/sdiffcard
     |
     |  sintercard(self, numkeys: 'int', keys: 'List[KeyT]', limit: 'int' = 0) -> 'int | Awaitable[int]'
     |      Return the cardinality of the intersect of multiple sets specified by ``keys``.
     |
     |      When LIMIT provided (defaults to 0 and means unlimited), if the intersection
     |      cardinality reaches limit partway through the computation, the algorithm will
     |      exit and yield limit as the cardinality
     |
     |      For more information, see https://redis.io/commands/sintercard
     |
     |  sismember(self, name: 'KeyT', value: 'str') -> 'Literal[0] | Literal[1] | Awaitable[Literal[0] | Literal[1]]'
     |      Return whether ``value`` is a member of set ``name``:
     |      - 1 if the value is a member of the set.
     |      - 0 if the value is not a member of the set or if key does not exist.
     |
     |      For more information, see https://redis.io/commands/sismember
     |
     |  smembers(self, name: 'KeyT') -> 'set[bytes | str] | Awaitable[set[bytes | str]]'
     |      Return all members of the set ``name``
     |
     |      For more information, see https://redis.io/commands/smembers
     |
     |  smismember(self, name: 'KeyT', values: 'List', *args: 'List') -> 'list[Literal[0] | Literal[1]] | Awaitable[list[Literal[0] | Literal[1]]]'
     |      Return whether each value in ``values`` is a member of the set ``name``
     |      as a list of ``int`` in the order of ``values``:
     |      - 1 if the value is a member of the set.
     |      - 0 if the value is not a member of the set or if key does not exist.
     |
     |      For more information, see https://redis.io/commands/smismember
     |
     |  spop(self, name: 'KeyT', count: 'int | None' = None) -> 'bytes | str | set[bytes | str] | None | Awaitable[bytes | str | set[bytes | str] | None]'
     |      Remove and return a random member of set ``name``
     |
     |      For more information, see https://redis.io/commands/spop
     |
     |  srandmember(self, name: 'KeyT', number: 'int | None' = None) -> 'bytes | str | list[bytes | str] | None | Awaitable[bytes | str | list[bytes | str] | None]'
     |      If ``number`` is None, returns a random member of set ``name``.
     |
     |      If ``number`` is supplied, returns a list of ``number`` random
     |      members of set ``name``. Note this is only available when running
     |      Redis 2.6+.
     |
     |      For more information, see https://redis.io/commands/srandmember
     |
     |  srem(self, name: 'KeyT', *values: 'FieldT') -> 'int | Awaitable[int]'
     |      Remove ``values`` from set ``name``
     |
     |      For more information, see https://redis.io/commands/srem
     |
     |  sunioncard(self, numkeys: 'int', keys: 'List[KeyT]', limit: 'int' = 0, approx: 'bool' = False) -> 'int | Awaitable[int]'
     |      Return the cardinality of the union of multiple sets specified by
     |      ``keys``, without returning the union itself.
     |
     |      When ``approx`` is True, the ``APPROX`` option is sent and the server
     |      returns an approximate cardinality computed using HyperLogLog.
     |
     |      When LIMIT is provided (defaults to 0 and means unlimited), the returned
     |      cardinality is capped at ``limit``. In exact mode the result equals
     |      ``limit`` when the real cardinality exceeds ``limit``; in approximate
     |      mode the result will not exceed ``limit``. Options are emitted in the
     |      canonical order ``APPROX`` before ``LIMIT``.
     |
     |      For more information, see https://redis.io/commands/sunioncard
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from redis.commands.core.StreamCommands:
     |
     |  xack(self, name: 'KeyT', groupname: 'GroupT', *ids: 'StreamIdT') -> 'int | Awaitable[int]'
     |      Acknowledges the successful processing of one or more messages.
     |
     |      Args:
     |          name: name of the stream.
     |          groupname: name of the consumer group.
     |          *ids: message ids to acknowledge.
     |
     |      For more information, see https://redis.io/commands/xack
     |
     |  xackdel(self, name: 'KeyT', groupname: 'GroupT', *ids: 'StreamIdT', ref_policy: "Literal['KEEPREF', 'DELREF', 'ACKED']" = 'KEEPREF') -> 'int | Awaitable[int]'
     |      Combines the functionality of XACK and XDEL. Acknowledges the specified
     |      message IDs in the given consumer group and simultaneously attempts to
     |      delete the corresponding entries from the stream.
     |
     |  xadd(self, name: 'KeyT', fields: 'Dict[FieldT, EncodableT]', id: 'StreamIdT' = '*', maxlen: 'Optional[int]' = None, approximate: 'bool' = True, nomkstream: 'bool' = False, minid: 'Union[StreamIdT, None]' = None, limit: 'int | None' = None, ref_policy: "Literal['KEEPREF', 'DELREF', 'ACKED'] | None" = None, idmpauto: 'str | None' = None, idmp: 'tuple[str, bytes] | None' = None) -> 'bytes | str | Awaitable[bytes | str]'
     |      Add to a stream.
     |      name: name of the stream
     |      fields: dict of field/value pairs to insert into the stream
     |      id: Location to insert this record. By default it is appended.
     |      maxlen: truncate old stream members beyond this size.
     |      Can't be specified with minid.
     |      approximate: actual stream length may be slightly more than maxlen
     |      nomkstream: When set to true, do not make a stream
     |      minid: the minimum id in the stream to query.
     |      Can't be specified with maxlen.
     |      limit: specifies the maximum number of entries to retrieve
     |      ref_policy: optional reference policy for consumer groups when trimming:
     |          - KEEPREF (default): When trimming, preserves references in consumer groups' PEL
     |          - DELREF: When trimming, removes all references from consumer groups' PEL
     |          - ACKED: When trimming, only removes entries acknowledged by all consumer groups
     |      idmpauto: Producer ID for automatic idempotent ID calculation.
     |          Automatically calculates an idempotent ID based on entry content to prevent
     |          duplicate entries. Can only be used with id='*'. Creates an IDMP map if it
     |          doesn't exist yet. The producer ID must be unique per producer and consistent
     |          across restarts.
     |      idmp: Tuple of (producer_id, idempotent_id) for explicit idempotent ID.
     |          Uses a specific idempotent ID to prevent duplicate entries. Can only be used
     |          with id='*'. The producer ID must be unique per producer and consistent across
     |          restarts. The idempotent ID must be unique per message and per producer.
     |          Shorter idempotent IDs require less memory and allow faster processing.
     |          Creates an IDMP map if it doesn't exist yet.
     |
     |      For more information, see https://redis.io/commands/xadd
     |
     |  xautoclaim(self, name: 'KeyT', groupname: 'GroupT', consumername: 'ConsumerT', min_idle_time: 'int', start_id: 'StreamIdT' = '0-0', count: 'int | None' = None, justid: 'bool' = False) -> 'list[Any] | Awaitable[list[Any]]'
     |      Transfers ownership of pending stream entries that match the specified
     |      criteria. Conceptually, equivalent to calling XPENDING and then XCLAIM,
     |      but provides a more straightforward way to deal with message delivery
     |      failures via SCAN-like semantics.
     |      name: name of the stream.
     |      groupname: name of the consumer group.
     |      consumername: name of a consumer that claims the message.
     |      min_idle_time: filter messages that were idle less than this amount of
     |      milliseconds.
     |      start_id: filter messages with equal or greater ID.
     |      count: optional integer, upper limit of the number of entries that the
     |      command attempts to claim. Set to 100 by default.
     |      justid: optional boolean, false by default. Return just an array of IDs
     |      of messages successfully claimed, without returning the actual message
     |
     |      For more information, see https://redis.io/commands/xautoclaim
     |
     |  xcfgset(self, name: 'KeyT', idmp_duration: 'int | None' = None, idmp_maxsize: 'int | None' = None) -> 'bytes | str | Awaitable[bytes | str]'
     |      Configure the idempotency parameters for a stream's IDMP map.
     |
     |      Sets how long Redis remembers each idempotent ID (iid) and the maximum
     |      number of iids to track. This command clears the existing IDMP map
     |      (Redis forgets all previously stored iids), but only if the configuration
     |      value actually changes.
     |
     |      Args:
     |          name: The name of the stream.
     |          idmp_duration: How long Redis remembers each iid in seconds.
     |              Default: 100 seconds (or value set by stream-idmp-duration config).
     |              Minimum: 1 second, Maximum: 300 seconds.
     |              Redis won't forget an iid for this duration (unless maxsize is reached).
     |              Should accommodate application crash recovery time.
     |          idmp_maxsize: Maximum number of iids Redis remembers per producer ID (pid).
     |              Default: 100 iids (or value set by stream-idmp-maxsize config).
     |              Minimum: 1 iid, Maximum: 1,000,000 (1M) iids.
     |              Should be set to: mark-delay [in msec] × (messages/msec) + margin.
     |              Example: 10K msgs/sec (10 msgs/msec), 80 msec mark-delay
     |              → maxsize = 10 × 80 + margin = 1000 iids.
     |
     |      Returns:
     |          OK on success.
     |
     |      For more information, see https://redis.io/commands/xcfgset
     |
     |  xclaim(self, name: 'KeyT', groupname: 'GroupT', consumername: 'ConsumerT', min_idle_time: 'int', message_ids: 'Union[List[StreamIdT], Tuple[StreamIdT]]', idle: 'int | None' = None, time: 'int | None' = None, retrycount: 'int | None' = None, force: 'bool' = False, justid: 'bool' = False) -> 'XClaimResponse | Awaitable[XClaimResponse]'
     |      Changes the ownership of a pending message.
     |
     |      name: name of the stream.
     |
     |      groupname: name of the consumer group.
     |
     |      consumername: name of a consumer that claims the message.
     |
     |      min_idle_time: filter messages that were idle less than this amount of
     |      milliseconds
     |
     |      message_ids: non-empty list or tuple of message IDs to claim
     |
     |      idle: optional. Set the idle time (last time it was delivered) of the
     |      message in ms
     |
     |      time: optional integer. This is the same as idle but instead of a
     |      relative amount of milliseconds, it sets the idle time to a specific
     |      Unix time (in milliseconds).
     |
     |      retrycount: optional integer. set the retry counter to the specified
     |      value. This counter is incremented every time a message is delivered
     |      again.
     |
     |      force: optional boolean, false by default. Creates the pending message
     |      entry in the PEL even if certain specified IDs are not already in the
     |      PEL assigned to a different client.
     |
     |      justid: optional boolean, false by default. Return just an array of IDs
     |      of messages successfully claimed, without returning the actual message
     |
     |      For more information, see https://redis.io/commands/xclaim
     |
     |  xdel(self, name: 'KeyT', *ids: 'StreamIdT') -> 'int | Awaitable[int]'
     |      Deletes one or more messages from a stream.
     |
     |      Args:
     |          name: name of the stream.
     |          *ids: message ids to delete.
     |
     |      For more information, see https://redis.io/commands/xdel
     |
     |  xdelex(self, name: 'KeyT', *ids: 'StreamIdT', ref_policy: "Literal['KEEPREF', 'DELREF', 'ACKED']" = 'KEEPREF') -> 'int | Awaitable[int]'
     |      Extended version of XDEL that provides more control over how message entries
     |      are deleted concerning consumer groups.
     |
     |  xgroup_create(self, name: 'KeyT', groupname: 'GroupT', id: 'StreamIdT' = '$', mkstream: 'bool' = False, entries_read: 'int | None' = None) -> 'bool | Awaitable[bool]'
     |      Create a new consumer group associated with a stream.
     |      name: name of the stream.
     |      groupname: name of the consumer group.
     |      id: ID of the last item in the stream to consider already delivered.
     |
     |      For more information, see https://redis.io/commands/xgroup-create
     |
     |  xgroup_createconsumer(self, name: 'KeyT', groupname: 'GroupT', consumername: 'ConsumerT') -> 'int | Awaitable[int]'
     |      Consumers in a consumer group are auto-created every time a new
     |      consumer name is mentioned by some command.
     |      They can be explicitly created by using this command.
     |      name: name of the stream.
     |      groupname: name of the consumer group.
     |      consumername: name of consumer to create.
     |
     |      See: https://redis.io/commands/xgroup-createconsumer
     |
     |  xgroup_delconsumer(self, name: 'KeyT', groupname: 'GroupT', consumername: 'ConsumerT') -> 'int | Awaitable[int]'
     |      Remove a specific consumer from a consumer group.
     |      Returns the number of pending messages that the consumer had before it
     |      was deleted.
     |      name: name of the stream.
     |      groupname: name of the consumer group.
     |      consumername: name of consumer to delete
     |
     |      For more information, see https://redis.io/commands/xgroup-delconsumer
     |
     |  xgroup_destroy(self, name: 'KeyT', groupname: 'GroupT') -> 'bool | Awaitable[bool]'
     |      Destroy a consumer group.
     |      name: name of the stream.
     |      groupname: name of the consumer group.
     |
     |      For more information, see https://redis.io/commands/xgroup-destroy
     |
     |  xgroup_setid(self, name: 'KeyT', groupname: 'GroupT', id: 'StreamIdT', entries_read: 'int | None' = None) -> 'bool | Awaitable[bool]'
     |      Set the consumer group last delivered ID to something else.
     |      name: name of the stream.
     |      groupname: name of the consumer group.
     |      id: ID of the last item in the stream to consider already delivered.
     |
     |      For more information, see https://redis.io/commands/xgroup-setid
     |
     |  xinfo_consumers(self, name: 'KeyT', groupname: 'GroupT') -> 'list[dict[str, Any]] | Awaitable[list[dict[str, Any]]]'
     |      Returns general information about the consumers in the group.
     |      name: name of the stream.
     |      groupname: name of the consumer group.
     |
     |      For more information, see https://redis.io/commands/xinfo-consumers
     |
     |  xinfo_groups(self, name: 'KeyT') -> 'list[dict[str, Any]] | Awaitable[list[dict[str, Any]]]'
     |      Returns general information about the consumer groups of the stream.
     |      name: name of the stream.
     |
     |      For more information, see https://redis.io/commands/xinfo-groups
     |
     |  xinfo_stream(self, name: 'KeyT', full: 'bool' = False) -> 'dict[str, Any] | Awaitable[dict[str, Any]]'
     |      Returns general information about the stream.
     |      name: name of the stream.
     |      full: optional boolean, false by default. Return full summary
     |
     |      For more information, see https://redis.io/commands/xinfo-stream
     |
     |  xlen(self, name: 'KeyT') -> 'int | Awaitable[int]'
     |      Returns the number of elements in a given stream.
     |
     |      For more information, see https://redis.io/commands/xlen
     |
     |  xnack(self, name: 'KeyT', groupname: 'GroupT', mode: "Literal['SILENT', 'FAIL', 'FATAL']", *ids: 'StreamIdT', retrycount: 'int | None' = None, force: 'bool' = False) -> 'int | Awaitable[int]'
     |      Negatively acknowledges one or more messages in a consumer group's
     |      Pending Entries List (PEL).
     |
     |      Args:
     |          name: name of the stream.
     |          groupname: name of the consumer group.
     |          mode: the nacking mode. One of SILENT, FAIL, or FATAL.
     |              SILENT: consumer shutting down; decrements delivery counter.
     |              FAIL: consumer unable to process; delivery counter unchanged.
     |              FATAL: invalid/malicious message; delivery counter set to max.
     |          *ids: one or more message IDs to NACK.
     |          retrycount: optional integer >= 0. Overrides the mode's implicit
     |              delivery counter adjustment with an exact value.
     |          force: if True, creates a new unowned PEL entry for any ID not
     |              already in the group's PEL.
     |
     |      Returns:
     |          The number of messages successfully NACKed.
     |
     |      For more information, see https://redis.io/commands/xnack
     |
     |  xpending(self, name: 'KeyT', groupname: 'GroupT') -> 'dict[str, Any] | Awaitable[dict[str, Any]]'
     |      Returns information about pending messages of a group.
     |      name: name of the stream.
     |      groupname: name of the consumer group.
     |
     |      For more information, see https://redis.io/commands/xpending
     |
     |  xpending_range(self, name: 'KeyT', groupname: 'GroupT', min: 'StreamIdT', max: 'StreamIdT', count: 'int', consumername: 'ConsumerT | None' = None, idle: 'int | None' = None) -> 'XPendingRangeResponse | Awaitable[XPendingRangeResponse]'
     |      Returns information about pending messages, in a range.
     |
     |      name: name of the stream.
     |      groupname: name of the consumer group.
     |      idle: available from  version 6.2. filter entries by their
     |      idle-time, given in milliseconds (optional).
     |      min: minimum stream ID.
     |      max: maximum stream ID.
     |      count: number of messages to return
     |      consumername: name of a consumer to filter by (optional).
     |
     |  xrange(self, name: 'KeyT', min: 'StreamIdT' = '-', max: 'StreamIdT' = '+', count: 'int | None' = None) -> 'StreamRangeResponse | None | Awaitable[StreamRangeResponse | None]'
     |      Read stream values within an interval.
     |
     |      name: name of the stream.
     |
     |      start: first stream ID. defaults to '-',
     |             meaning the earliest available.
     |
     |      finish: last stream ID. defaults to '+',
     |              meaning the latest available.
     |
     |      count: if set, only return this many items, beginning with the
     |             earliest available.
     |
     |      For more information, see https://redis.io/commands/xrange
     |
     |  xread(self, streams: 'Dict[KeyT, StreamIdT]', count: 'int | None' = None, block: 'int | None' = None, max_count: 'int | None' = None, max_size: 'int | None' = None) -> 'XReadResponse | Awaitable[XReadResponse]'
     |      Block and monitor multiple streams for new data.
     |
     |      streams: a dict of stream names to stream IDs, where
     |                 IDs indicate the last ID already seen.
     |
     |      count: if set, only return this many items per stream, beginning with
     |             the earliest available.
     |
     |      block: number of milliseconds to wait, if nothing already present.
     |
     |      max_count: if set, cap the total number of entries returned across all
     |                 streams combined. Unlike ``count`` (a per-stream limit),
     |                 this is a cumulative cap over the whole reply. Must be a
     |                 positive integer and, when ``count`` is also set, must be
     |                 greater than or equal to ``count``. Requires Redis >= 8.10.0.
     |
     |      max_size: if set, a soft cap on the total server reply size in bytes
     |                across all streams combined. Measured server-side including
     |                protocol overhead, so it is not an exact application-payload
     |                size guarantee; a single available entry larger than the cap
     |                may still be returned. Must be a positive integer. Requires
     |                Redis >= 8.10.0.
     |
     |      For more information, see https://redis.io/commands/xread
     |
     |  xreadgroup(self, groupname: 'str', consumername: 'str', streams: 'Dict[KeyT, StreamIdT]', count: 'int | None' = None, block: 'int | None' = None, noack: 'bool' = False, claim_min_idle_time: 'int | None' = None, max_count: 'int | None' = None, max_size: 'int | None' = None) -> 'XReadGroupResponse | Awaitable[XReadGroupResponse]'
     |      Read from a stream via a consumer group.
     |
     |      groupname: name of the consumer group.
     |
     |      consumername: name of the requesting consumer.
     |
     |      streams: a dict of stream names to stream IDs, where
     |             IDs indicate the last ID already seen.
     |
     |      count: if set, only return this many items per stream, beginning with
     |             the earliest available.
     |
     |      block: number of milliseconds to wait, if nothing already present.
     |      noack: do not add messages to the PEL
     |
     |      claim_min_idle_time: accepts an integer type and represents a
     |                           time interval in milliseconds
     |
     |      max_count: if set, cap the total number of entries returned across all
     |                 streams combined. Unlike ``count`` (a per-stream limit),
     |                 this is a cumulative cap over the whole reply. Must be a
     |                 positive integer and, when ``count`` is also set, must be
     |                 greater than or equal to ``count``. Requires Redis 8.10.0.
     |
     |      max_size: if set, a soft cap on the total server reply size in bytes
     |                across all streams combined. Measured server-side including
     |                protocol overhead, so it is not an exact application-payload
     |                size guarantee; a single available entry larger than the cap
     |                may still be returned. Must be a positive integer. Requires
     |                Redis 8.10.0.
     |
     |      For more information, see https://redis.io/commands/xreadgroup
     |
     |  xrevrange(self, name: 'KeyT', max: 'StreamIdT' = '+', min: 'StreamIdT' = '-', count: 'int | None' = None) -> 'StreamRangeResponse | None | Awaitable[StreamRangeResponse | None]'
     |      Read stream values within an interval, in reverse order.
     |
     |      name: name of the stream
     |
     |      start: first stream ID. defaults to '+',
     |             meaning the latest available.
     |
     |      finish: last stream ID. defaults to '-',
     |              meaning the earliest available.
     |
     |      count: if set, only return this many items, beginning with the
     |             latest available.
     |
     |      For more information, see https://redis.io/commands/xrevrange
     |
     |  xtrim(self, name: 'KeyT', maxlen: 'int | None' = None, approximate: 'bool' = True, minid: 'StreamIdT | None' = None, limit: 'int | None' = None, ref_policy: "Literal['KEEPREF', 'DELREF', 'ACKED'] | None" = None) -> 'int | Awaitable[int]'
     |      Trims old messages from a stream.
     |      name: name of the stream.
     |      maxlen: truncate old stream messages beyond this size
     |      Can't be specified with minid.
     |      approximate: actual stream length may be slightly more than maxlen
     |      minid: the minimum id in the stream to query
     |      Can't be specified with maxlen.
     |      limit: specifies the maximum number of entries to retrieve
     |      ref_policy: optional reference policy for consumer groups:
     |          - KEEPREF (default): Trims entries but preserves references in consumer groups' PEL
     |          - DELREF: Trims entries and removes all references from consumer groups' PEL
     |          - ACKED: Only trims entries that were read and acknowledged by all consumer groups
     |
     |      For more information, see https://redis.io/commands/xtrim
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from redis.commands.core.SortedSetCommands:
     |
     |  bzmpop(self, timeout: 'float', numkeys: 'int', keys: 'List[str]', min: 'bool | None' = False, max: 'bool | None' = False, count: 'int | None' = 1) -> 'ZMPopResponse | Awaitable[ZMPopResponse]'
     |      Pop ``count`` values (default 1) off of the first non-empty sorted set
     |      named in the ``keys`` list.
     |
     |      If none of the sorted sets in ``keys`` has a value to pop,
     |      then block for ``timeout`` seconds, or until a member gets added
     |      to one of the sorted sets.
     |
     |      If timeout is 0, then block indefinitely.
     |
     |      For more information, see https://redis.io/commands/bzmpop
     |
     |  bzpopmax(self, keys: 'KeysT', timeout: 'TimeoutSecT' = 0) -> 'BlockingZSetPopResponse | Awaitable[BlockingZSetPopResponse]'
     |      ZPOPMAX a value off of the first non-empty sorted set
     |      named in the ``keys`` list.
     |
     |      If none of the sorted sets in ``keys`` has a value to ZPOPMAX,
     |      then block for ``timeout`` seconds, or until a member gets added
     |      to one of the sorted sets.
     |
     |      If timeout is 0, then block indefinitely.
     |
     |      For more information, see https://redis.io/commands/bzpopmax
     |
     |  bzpopmin(self, keys: 'KeysT', timeout: 'TimeoutSecT' = 0) -> 'BlockingZSetPopResponse | Awaitable[BlockingZSetPopResponse]'
     |      ZPOPMIN a value off of the first non-empty sorted set
     |      named in the ``keys`` list.
     |
     |      If none of the sorted sets in ``keys`` has a value to ZPOPMIN,
     |      then block for ``timeout`` seconds, or until a member gets added
     |      to one of the sorted sets.
     |
     |      If timeout is 0, then block indefinitely.
     |
     |      For more information, see https://redis.io/commands/bzpopmin
     |
     |  zadd(self, name: 'KeyT', mapping: 'Mapping[AnyKeyT, EncodableT]', nx: 'bool' = False, xx: 'bool' = False, ch: 'bool' = False, incr: 'bool' = False, gt: 'bool' = False, lt: 'bool' = False) -> 'int | float | None | Awaitable[int | float | None]'
     |      Set any number of element-name, score pairs to the key ``name``. Pairs
     |      are specified as a dict of element-names keys to score values.
     |
     |      ``nx`` forces ZADD to only create new elements and not to update
     |      scores for elements that already exist.
     |
     |      ``xx`` forces ZADD to only update scores of elements that already
     |      exist. New elements will not be added.
     |
     |      ``ch`` modifies the return value to be the numbers of elements changed.
     |      Changed elements include new elements that were added and elements
     |      whose scores changed.
     |
     |      ``incr`` modifies ZADD to behave like ZINCRBY. In this mode only a
     |      single element/score pair can be specified and the score is the amount
     |      the existing score will be incremented by. When using this mode the
     |      return value of ZADD will be the new score of the element.
     |
     |      ``lt`` only updates existing elements if the new score is less than
     |      the current score. This flag doesn't prevent adding new elements.
     |
     |      ``gt`` only updates existing elements if the new score is greater than
     |      the current score. This flag doesn't prevent adding new elements.
     |
     |      The return value of ZADD varies based on the mode specified. With no
     |      options, ZADD returns the number of new elements added to the sorted
     |      set.
     |
     |      ``nx``, ``lt``, and ``gt`` are mutually exclusive options.
     |
     |      See: https://redis.io/commands/ZADD
     |
     |  zcard(self, name: 'KeyT') -> 'int | Awaitable[int]'
     |      Return the number of elements in the sorted set ``name``
     |
     |      For more information, see https://redis.io/commands/zcard
     |
     |  zcount(self, name: 'KeyT', min: 'ZScoreBoundT', max: 'ZScoreBoundT') -> 'int | Awaitable[int]'
     |      Returns the number of elements in the sorted set at key ``name`` with
     |      a score between ``min`` and ``max``.
     |
     |      For more information, see https://redis.io/commands/zcount
     |
     |  zdiff(self, keys: 'KeysT', withscores: 'bool' = False) -> 'ZSetRangeResponse | Awaitable[ZSetRangeResponse]'
     |      Returns the difference between the first and all successive input
     |      sorted sets provided in ``keys``.
     |
     |      For more information, see https://redis.io/commands/zdiff
     |
     |  zdiffstore(self, dest: 'KeyT', keys: 'KeysT') -> 'int | Awaitable[int]'
     |      Computes the difference between the first and all successive input
     |      sorted sets provided in ``keys`` and stores the result in ``dest``.
     |
     |      For more information, see https://redis.io/commands/zdiffstore
     |
     |  zincrby(self, name: 'KeyT', amount: 'float', value: 'EncodableT') -> 'float | None | Awaitable[float | None]'
     |      Increment the score of ``value`` in sorted set ``name`` by ``amount``
     |
     |      For more information, see https://redis.io/commands/zincrby
     |
     |  zinter(self, keys: 'KeysT', aggregate: 'str | None' = None, withscores: 'bool' = False) -> 'ZSetRangeResponse | Awaitable[ZSetRangeResponse]'
     |      Return the intersect of multiple sorted sets specified by ``keys``.
     |
     |      With the ``aggregate`` option, it is possible to specify how the
     |      results of the intersection are aggregated. Available aggregation
     |      modes:
     |
     |      - ``SUM`` (default): the score of an element is summed across the
     |        inputs where it exists.
     |        Score = SUM(score₁×weight₁, score₂×weight₂, ...)
     |      - ``MIN``: the resulting set will contain the minimum score of an
     |        element across the inputs where it exists.
     |        Score = MIN(score₁×weight₁, score₂×weight₂, ...)
     |      - ``MAX``: the resulting set will contain the maximum score of an
     |        element across the inputs where it exists.
     |        Score = MAX(score₁×weight₁, score₂×weight₂, ...)
     |      - ``COUNT``: ignores the original scores and counts weighted set
     |        membership. Each element's score is the sum of the weights of
     |        the input sets that contain it.
     |        Score = SUM(weight₁, weight₂, ...) for sets containing the element.
     |        When all weights are 1 (default), the score equals the number
     |        of input sets containing the element.
     |
     |      For more information, see https://redis.io/commands/zinter
     |
     |  zintercard(self, numkeys: 'int', keys: 'List[str]', limit: 'int' = 0) -> 'int | Awaitable[int]'
     |      Return the cardinality of the intersect of multiple sorted sets
     |      specified by ``keys``.
     |      When LIMIT provided (defaults to 0 and means unlimited), if the intersection
     |      cardinality reaches limit partway through the computation, the algorithm will
     |      exit and yield limit as the cardinality
     |
     |      For more information, see https://redis.io/commands/zintercard
     |
     |  zinterstore(self, dest: 'KeyT', keys: 'Sequence[KeyT] | Mapping[AnyKeyT, float]', aggregate: 'str | None' = None) -> 'int | Awaitable[int]'
     |      Intersect multiple sorted sets specified by ``keys`` into a new
     |      sorted set, ``dest``. Scores in the destination will be aggregated
     |      based on the ``aggregate``.
     |
     |      Available aggregation modes:
     |
     |      - ``SUM`` (default): the score of an element is summed across the
     |        inputs where it exists.
     |        Score = SUM(score₁×weight₁, score₂×weight₂, ...)
     |      - ``MIN``: the resulting set will contain the minimum score of an
     |        element across the inputs where it exists.
     |        Score = MIN(score₁×weight₁, score₂×weight₂, ...)
     |      - ``MAX``: the resulting set will contain the maximum score of an
     |        element across the inputs where it exists.
     |        Score = MAX(score₁×weight₁, score₂×weight₂, ...)
     |      - ``COUNT``: ignores the original scores and counts weighted set
     |        membership. Each element's score is the sum of the weights of
     |        the input sets that contain it.
     |        Score = SUM(weight₁, weight₂, ...) for sets containing the element.
     |        When all weights are 1 (default), the score equals the number
     |        of input sets containing the element.
     |
     |      For more information, see https://redis.io/commands/zinterstore
     |
     |  zlexcount(self, name: 'KeyT', min: 'EncodableT', max: 'EncodableT') -> 'int | Awaitable[int]'
     |      Return the number of items in the sorted set ``name`` between the
     |      lexicographical range ``min`` and ``max``.
     |
     |      For more information, see https://redis.io/commands/zlexcount
     |
     |  zmpop(self, num_keys: 'int', keys: 'List[str]', min: 'bool | None' = False, max: 'bool | None' = False, count: 'int | None' = 1) -> 'ZMPopResponse | Awaitable[ZMPopResponse]'
     |      Pop ``count`` values (default 1) off of the first non-empty sorted set
     |      named in the ``keys`` list.
     |      For more information, see https://redis.io/commands/zmpop
     |
     |  zmscore(self, key: 'KeyT', members: 'List[str]') -> 'list[float | None] | Awaitable[list[float | None]]'
     |      Returns the scores associated with the specified members
     |      in the sorted set stored at key.
     |      ``members`` should be a list of the member name.
     |      Return type is a list of score.
     |      If the member does not exist, a None will be returned
     |      in corresponding position.
     |
     |      For more information, see https://redis.io/commands/zmscore
     |
     |  zpopmax(self, name: 'KeyT', count: 'int | None' = None) -> 'ZSetRangeResponse | Awaitable[ZSetRangeResponse]'
     |      Remove and return up to ``count`` members with the highest scores
     |      from the sorted set ``name``.
     |
     |      For more information, see https://redis.io/commands/zpopmax
     |
     |  zpopmin(self, name: 'KeyT', count: 'int | None' = None) -> 'ZSetRangeResponse | Awaitable[ZSetRangeResponse]'
     |      Remove and return up to ``count`` members with the lowest scores
     |      from the sorted set ``name``.
     |
     |      For more information, see https://redis.io/commands/zpopmin
     |
     |  zrandmember(self, key: 'KeyT', count: 'int | None' = None, withscores: 'bool' = False) -> 'ZRandMemberResponse | Awaitable[ZRandMemberResponse]'
     |      Return a random element from the sorted set value stored at key.
     |
     |      ``count`` if the argument is positive, return an array of distinct
     |      fields. If called with a negative count, the behavior changes and
     |      the command is allowed to return the same field multiple times.
     |      In this case, the number of returned fields is the absolute value
     |      of the specified count.
     |
     |      ``withscores`` The optional WITHSCORES modifier changes the reply so it
     |      includes the respective scores of the randomly selected elements from
     |      the sorted set.
     |
     |      For more information, see https://redis.io/commands/zrandmember
     |
     |  zrange(self, name: 'KeyT', start: 'EncodableT', end: 'EncodableT', desc: 'bool' = False, withscores: 'bool' = False, score_cast_func: 'type | Callable' = <class 'float'>, byscore: 'bool' = False, bylex: 'bool' = False, offset: 'int | None' = None, num: 'int | None' = None) -> 'ZSetRangeResponse | Awaitable[ZSetRangeResponse]'
     |      Return a range of values from sorted set ``name`` between
     |      ``start`` and ``end`` sorted in ascending order.
     |
     |      ``start`` and ``end`` can be negative, indicating the end of the range.
     |
     |      ``desc`` a boolean indicating whether to sort the results in reversed
     |      order.
     |
     |      ``withscores`` indicates to return the scores along with the values.
     |      The return type is a list of (value, score) pairs.
     |
     |      ``score_cast_func`` a callable used to cast the score return value.
     |
     |      ``byscore`` when set to True, returns the range of elements from the
     |      sorted set having scores equal or between ``start`` and ``end``.
     |
     |      ``bylex`` when set to True, returns the range of elements from the
     |      sorted set between the ``start`` and ``end`` lexicographical closed
     |      range intervals.
     |      Valid ``start`` and ``end`` must start with ( or [, in order to specify
     |      whether the range interval is exclusive or inclusive, respectively.
     |
     |      ``offset`` and ``num`` are specified, then return a slice of the range.
     |      Can't be provided when using ``bylex``.
     |
     |      For more information, see https://redis.io/commands/zrange
     |
     |  zrangebylex(self, name: 'KeyT', min: 'EncodableT', max: 'EncodableT', start: 'int | None' = None, num: 'int | None' = None) -> 'list[bytes | str] | Awaitable[list[bytes | str]]'
     |      Return the lexicographical range of values from sorted set ``name``
     |      between ``min`` and ``max``.
     |
     |      If ``start`` and ``num`` are specified, then return a slice of the
     |      range.
     |
     |      For more information, see https://redis.io/commands/zrangebylex
     |
     |  zrangebyscore(self, name: 'KeyT', min: 'ZScoreBoundT', max: 'ZScoreBoundT', start: 'int | None' = None, num: 'int | None' = None, withscores: 'bool' = False, score_cast_func: 'type | Callable' = <class 'float'>) -> 'ZSetRangeResponse | Awaitable[ZSetRangeResponse]'
     |      Return a range of values from the sorted set ``name`` with scores
     |      between ``min`` and ``max``.
     |
     |      If ``start`` and ``num`` are specified, then return a slice
     |      of the range.
     |
     |      ``withscores`` indicates to return the scores along with the values.
     |      The return type is a list of (value, score) pairs
     |
     |      `score_cast_func`` a callable used to cast the score return value
     |
     |      For more information, see https://redis.io/commands/zrangebyscore
     |
     |  zrangestore(self, dest: 'KeyT', name: 'KeyT', start: 'EncodableT', end: 'EncodableT', byscore: 'bool' = False, bylex: 'bool' = False, desc: 'bool' = False, offset: 'int | None' = None, num: 'int | None' = None) -> 'int | Awaitable[int]'
     |      Stores in ``dest`` the result of a range of values from sorted set
     |      ``name`` between ``start`` and ``end`` sorted in ascending order.
     |
     |      ``start`` and ``end`` can be negative, indicating the end of the range.
     |
     |      ``byscore`` when set to True, returns the range of elements from the
     |      sorted set having scores equal or between ``start`` and ``end``.
     |
     |      ``bylex`` when set to True, returns the range of elements from the
     |      sorted set between the ``start`` and ``end`` lexicographical closed
     |      range intervals.
     |      Valid ``start`` and ``end`` must start with ( or [, in order to specify
     |      whether the range interval is exclusive or inclusive, respectively.
     |
     |      ``desc`` a boolean indicating whether to sort the results in reversed
     |      order.
     |
     |      ``offset`` and ``num`` are specified, then return a slice of the range.
     |      Can't be provided when using ``bylex``.
     |
     |      For more information, see https://redis.io/commands/zrangestore
     |
     |  zrank(self, name: 'KeyT', value: 'EncodableT', withscore: 'bool' = False, score_cast_func: 'type | Callable' = <class 'float'>) -> 'int | list[Any] | None | Awaitable[int | list[Any] | None]'
     |      Returns a 0-based value indicating the rank of ``value`` in sorted set
     |      ``name``.
     |      The optional WITHSCORE argument supplements the command's
     |      reply with the score of the element returned.
     |
     |      ``score_cast_func`` a callable used to cast the score return value
     |
     |      For more information, see https://redis.io/commands/zrank
     |
     |  zrem(self, name: 'KeyT', *values: 'FieldT') -> 'int | Awaitable[int]'
     |      Remove member ``values`` from sorted set ``name``
     |
     |      For more information, see https://redis.io/commands/zrem
     |
     |  zremrangebylex(self, name: 'KeyT', min: 'EncodableT', max: 'EncodableT') -> 'int | Awaitable[int]'
     |      Remove all elements in the sorted set ``name`` between the
     |      lexicographical range specified by ``min`` and ``max``.
     |
     |      Returns the number of elements removed.
     |
     |      For more information, see https://redis.io/commands/zremrangebylex
     |
     |  zremrangebyrank(self, name: 'KeyT', min: 'int', max: 'int') -> 'int | Awaitable[int]'
     |      Remove all elements in the sorted set ``name`` with ranks between
     |      ``min`` and ``max``. Values are 0-based, ordered from smallest score
     |      to largest. Values can be negative indicating the highest scores.
     |      Returns the number of elements removed
     |
     |      For more information, see https://redis.io/commands/zremrangebyrank
     |
     |  zremrangebyscore(self, name: 'KeyT', min: 'ZScoreBoundT', max: 'ZScoreBoundT') -> 'int | Awaitable[int]'
     |      Remove all elements in the sorted set ``name`` with scores
     |      between ``min`` and ``max``. Returns the number of elements removed.
     |
     |      For more information, see https://redis.io/commands/zremrangebyscore
     |
     |  zrevrange(self, name: 'KeyT', start: 'int', end: 'int', withscores: 'bool' = False, score_cast_func: 'type | Callable' = <class 'float'>) -> 'ZSetRangeResponse | Awaitable[ZSetRangeResponse]'
     |      Return a range of values from sorted set ``name`` between
     |      ``start`` and ``end`` sorted in descending order.
     |
     |      ``start`` and ``end`` can be negative, indicating the end of the range.
     |
     |      ``withscores`` indicates to return the scores along with the values
     |      The return type is a list of (value, score) pairs
     |
     |      ``score_cast_func`` a callable used to cast the score return value
     |
     |      For more information, see https://redis.io/commands/zrevrange
     |
     |  zrevrangebylex(self, name: 'KeyT', max: 'EncodableT', min: 'EncodableT', start: 'int | None' = None, num: 'int | None' = None) -> 'list[bytes | str] | Awaitable[list[bytes | str]]'
     |      Return the reversed lexicographical range of values from sorted set
     |      ``name`` between ``max`` and ``min``.
     |
     |      If ``start`` and ``num`` are specified, then return a slice of the
     |      range.
     |
     |      For more information, see https://redis.io/commands/zrevrangebylex
     |
     |  zrevrangebyscore(self, name: 'KeyT', max: 'ZScoreBoundT', min: 'ZScoreBoundT', start: 'int | None' = None, num: 'int | None' = None, withscores: 'bool' = False, score_cast_func: 'type | Callable' = <class 'float'>) -> 'ZSetRangeResponse | Awaitable[ZSetRangeResponse]'
     |      Return a range of values from the sorted set ``name`` with scores
     |      between ``min`` and ``max`` in descending order.
     |
     |      If ``start`` and ``num`` are specified, then return a slice
     |      of the range.
     |
     |      ``withscores`` indicates to return the scores along with the values.
     |      The return type is a list of (value, score) pairs
     |
     |      ``score_cast_func`` a callable used to cast the score return value
     |
     |      For more information, see https://redis.io/commands/zrevrangebyscore
     |
     |  zrevrank(self, name: 'KeyT', value: 'EncodableT', withscore: 'bool' = False, score_cast_func: 'type | Callable' = <class 'float'>) -> 'int | list[Any] | None | Awaitable[int | list[Any] | None]'
     |      Returns a 0-based value indicating the descending rank of
     |      ``value`` in sorted set ``name``.
     |      The optional ``withscore`` argument supplements the command's
     |      reply with the score of the element returned.
     |
     |      ``score_cast_func`` a callable used to cast the score return value
     |
     |      For more information, see https://redis.io/commands/zrevrank
     |
     |  zscore(self, name: 'KeyT', value: 'EncodableT') -> 'float | None | Awaitable[float | None]'
     |      Return the score of element ``value`` in sorted set ``name``
     |
     |      For more information, see https://redis.io/commands/zscore
     |
     |  zunion(self, keys: 'Sequence[KeyT] | Mapping[AnyKeyT, float]', aggregate: 'str | None' = None, withscores: 'bool' = False, score_cast_func: 'type | Callable' = <class 'float'>) -> 'ZSetRangeResponse | Awaitable[ZSetRangeResponse]'
     |      Return the union of multiple sorted sets specified by ``keys``.
     |      ``keys`` can be provided as dictionary of keys and their weights.
     |      Scores will be aggregated based on the ``aggregate``, or SUM if
     |      none is provided.
     |
     |      Available aggregation modes:
     |
     |      - ``SUM`` (default): the score of an element is summed across the
     |        inputs where it exists.
     |        Score = SUM(score₁×weight₁, score₂×weight₂, ...)
     |      - ``MIN``: the resulting set will contain the minimum score of an
     |        element across the inputs where it exists.
     |        Score = MIN(score₁×weight₁, score₂×weight₂, ...)
     |      - ``MAX``: the resulting set will contain the maximum score of an
     |        element across the inputs where it exists.
     |        Score = MAX(score₁×weight₁, score₂×weight₂, ...)
     |      - ``COUNT``: ignores the original scores and counts weighted set
     |        membership. Each element's score is the sum of the weights of
     |        the input sets that contain it.
     |        Score = SUM(weight₁, weight₂, ...) for sets containing the element.
     |        When all weights are 1 (default), the score equals the number
     |        of input sets containing the element.
     |
     |      ``score_cast_func`` a callable used to cast the score return value
     |
     |      For more information, see https://redis.io/commands/zunion
     |
     |  zunionstore(self, dest: 'KeyT', keys: 'Sequence[KeyT] | Mapping[AnyKeyT, float]', aggregate: 'str | None' = None) -> 'int | Awaitable[int]'
     |      Union multiple sorted sets specified by ``keys`` into
     |      a new sorted set, ``dest``. Scores in the destination will be
     |      aggregated based on the ``aggregate``, or SUM if none is provided.
     |
     |      Available aggregation modes:
     |
     |      - ``SUM`` (default): the score of an element is summed across the
     |        inputs where it exists.
     |        Score = SUM(score₁×weight₁, score₂×weight₂, ...)
     |      - ``MIN``: the resulting set will contain the minimum score of an
     |        element across the inputs where it exists.
     |        Score = MIN(score₁×weight₁, score₂×weight₂, ...)
     |      - ``MAX``: the resulting set will contain the maximum score of an
     |        element across the inputs where it exists.
     |        Score = MAX(score₁×weight₁, score₂×weight₂, ...)
     |      - ``COUNT``: ignores the original scores and counts weighted set
     |        membership. Each element's score is the sum of the weights of
     |        the input sets that contain it.
     |        Score = SUM(weight₁, weight₂, ...) for sets containing the element.
     |        When all weights are 1 (default), the score equals the number
     |        of input sets containing the element.
     |
     |      For more information, see https://redis.io/commands/zunionstore
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from redis.commands.core.ScriptCommands:
     |
     |  eval_ro(self, script: 'str', numkeys: 'int', *keys_and_args: 'KeyT | EncodableT') -> 'Any | Awaitable[Any]'
     |      The read-only variant of the EVAL command
     |
     |      Execute the read-only Lua ``script`` specifying the ``numkeys`` the script
     |      will touch and the key names and argument values in ``keys_and_args``.
     |      Returns the result of the script.
     |
     |      For more information, see  https://redis.io/commands/eval_ro
     |
     |  evalsha_ro(self, sha: 'str', numkeys: 'int', *keys_and_args: 'KeyT | EncodableT') -> 'Any | Awaitable[Any]'
     |      The read-only variant of the EVALSHA command
     |
     |      Use the ``sha`` to execute a read-only Lua script already registered via EVAL
     |      or SCRIPT LOAD. Specify the ``numkeys`` the script will touch and the
     |      key names and argument values in ``keys_and_args``. Returns the result
     |      of the script.
     |
     |      For more information, see  https://redis.io/commands/evalsha_ro
     |
     |  register_script(self: "Union['redis.client.Redis', 'redis.cluster.RedisCluster']", script: 'ScriptTextT') -> 'Script'
     |      Register a Lua ``script`` specifying the ``keys`` it will touch.
     |      Returns a Script object that is callable and hides the complexity of
     |      deal with scripts, keys, and shas. This is the preferred way to work
     |      with Lua scripts.
     |
     |  script_debug(self, *args) -> 'None'
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from redis.commands.core.FunctionCommands:
     |
     |  fcall(self, function, numkeys: 'int', *keys_and_args: 'Any') -> 'Any | Awaitable[Any]'
     |      Invoke a function.
     |
     |      For more information, see https://redis.io/commands/fcall
     |
     |  fcall_ro(self, function, numkeys: 'int', *keys_and_args: 'Any') -> 'Any | Awaitable[Any]'
     |      This is a read-only variant of the FCALL command that cannot
     |      execute commands that modify data.
     |
     |      For more information, see https://redis.io/commands/fcall_ro
     |
     |  function_delete(self, library: 'str') -> 'bool | Awaitable[bool]'
     |      Delete the library called ``library`` and all its functions.
     |
     |      For more information, see https://redis.io/commands/function-delete
     |
     |  function_dump(self) -> 'bytes | Awaitable[bytes]'
     |      Return the serialized payload of loaded libraries.
     |
     |      For more information, see https://redis.io/commands/function-dump
     |
     |  function_flush(self, mode: 'str' = 'SYNC') -> 'bool | Awaitable[bool]'
     |      Deletes all the libraries.
     |
     |      For more information, see https://redis.io/commands/function-flush
     |
     |  function_kill(self) -> 'bytes | str | Awaitable[bytes | str]'
     |      Kill a function that is currently executing.
     |
     |      For more information, see https://redis.io/commands/function-kill
     |
     |  function_list(self, library: 'str | None' = '*', withcode: 'bool | None' = False) -> 'list[Any] | Awaitable[list[Any]]'
     |      Return information about the functions and libraries.
     |
     |      Args:
     |
     |          library: specify a pattern for matching library names
     |          withcode: cause the server to include the libraries source implementation
     |              in the reply
     |
     |  function_load(self, code: 'str', replace: 'bool | None' = False) -> 'bytes | str | Awaitable[bytes | str]'
     |      Load a library to Redis.
     |      :param code: the source code (must start with
     |      Shebang statement that provides a metadata about the library)
     |      :param replace: changes the behavior to overwrite the existing library
     |      with the new contents.
     |      Return the library name that was loaded.
     |
     |      For more information, see https://redis.io/commands/function-load
     |
     |  function_restore(self, payload: 'str', policy: 'str | None' = 'APPEND') -> 'bool | Awaitable[bool]'
     |      Restore libraries from the serialized ``payload``.
     |      You can use the optional policy argument to provide a policy
     |      for handling existing libraries.
     |
     |      For more information, see https://redis.io/commands/function-restore
     |
     |  function_stats(self) -> 'Any | Awaitable[Any]'
     |      Return information about the function that's currently running
     |      and information about the available execution engines.
     |
     |      For more information, see https://redis.io/commands/function-stats
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from redis.commands.core.ModuleCommands:
     |
     |  command_getkeys(self, *args) -> 'list[bytes | str] | Awaitable[list[bytes | str]]'
     |
     |  module_list(self) -> 'list[dict[Any, Any]] | Awaitable[list[dict[Any, Any]]]'
     |      Returns a list of dictionaries containing the name and version of
     |      all loaded modules.
     |
     |      For more information, see https://redis.io/commands/module-list
     |
     |  module_load(self, path, *args) -> 'bool | Awaitable[bool]'
     |      Loads the module from ``path``.
     |      Passes all ``*args`` to the module, during loading.
     |      Raises ``ModuleError`` if a module is not found at ``path``.
     |
     |      For more information, see https://redis.io/commands/module-load
     |
     |  module_loadex(self, path: 'str', options: 'List[str] | None' = None, args: 'List[str] | None' = None) -> 'bytes | str | Awaitable[bytes | str]'
     |      Loads a module from a dynamic library at runtime with configuration directives.
     |
     |      For more information, see https://redis.io/commands/module-loadex
     |
     |  module_unload(self, name) -> 'bool | Awaitable[bool]'
     |      Unloads the module ``name``.
     |      Raises ``ModuleError`` if ``name`` is not in loaded modules.
     |
     |      For more information, see https://redis.io/commands/module-unload
     |
     |  ----------------------------------------------------------------------
     |  Data and other attributes inherited from redis.typing.CommandsProtocol:
     |
     |  __protocol_attrs__ = {'_event_dispatcher', 'execute_command'}
     |
     |  ----------------------------------------------------------------------
     |  Class methods inherited from typing.Protocol:
     |
     |  __init_subclass__(*args, **kwargs)
     |      This method is called when a class is subclassed.
     |
     |      The default implementation does nothing. It may be
     |      overridden to extend subclasses.
     |
     |  ----------------------------------------------------------------------
     |  Class methods inherited from typing.Generic:
     |
     |  __class_getitem__(...)
     |      Parameterizes a generic class.
     |
     |      At least, parameterizing a generic class is the *main* thing this
     |      method does. For example, for some generic class `Foo`, this is called
     |      when we do `Foo[int]` - there, with `cls=Foo` and `params=int`.
     |
     |      However, note that this method is also called when defining generic
     |      classes in the first place with `class Foo[T]: ...`.
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from redis.commands.redismodules.RedisModuleCommands:
     |
     |  bf(self) -> 'BFBloom'
     |      Access the bloom namespace.
     |
     |  cf(self) -> 'CFBloom'
     |      Access the bloom namespace.
     |
     |  cms(self) -> 'CMSBloom'
     |      Access the bloom namespace.
     |
     |  ft(self, index_name='idx') -> 'Search'
     |      Access the search namespace, providing support for redis search.
     |
     |  json(self, encoder=<json.encoder.JSONEncoder object at 0x0000017B9C588F50>, decoder=<json.decoder.JSONDecoder object at 0x0000017B9C588FB0>) -> 'JSON'
     |      Access the json namespace, providing support for redis json.
     |
     |  tdigest(self) -> 'TDigestBloom'
     |      Access the bloom namespace.
     |
     |  topk(self) -> 'TOPKBloom'
     |      Access the bloom namespace.
     |
     |  ts(self) -> 'TimeSeries'
     |      Access the timeseries namespace, providing support for
     |      redis timeseries data.
     |
     |  vset(self) -> 'VectorSet'
     |      Access the VectorSet commands namespace.

    class ClusterPubSub(redis.client.PubSub)
     |  ClusterPubSub(redis_cluster, node=None, host=None, port=None, push_handler_func=None, event_dispatcher: Optional[ForwardRef('EventDispatcher')] = None, **kwargs)
     |
     |  Wrapper for PubSub class.
     |
     |  IMPORTANT: before using ClusterPubSub, read about the known limitations
     |  with pubsub in Cluster mode and learn how to workaround them:
     |  https://redis.readthedocs.io/en/stable/clustering.html#known-pubsub-limitations
     |
     |  Method resolution order:
     |      ClusterPubSub
     |      redis.client.PubSub
     |      builtins.object
     |
     |  Methods defined here:
     |
     |  __init__(self, redis_cluster, node=None, host=None, port=None, push_handler_func=None, event_dispatcher: Optional[ForwardRef('EventDispatcher')] = None, **kwargs)
     |      When a pubsub instance is created without specifying a node, a single
     |      node will be transparently chosen for the pubsub connection on the
     |      first command execution. The node will be determined by:
     |       1. Hashing the channel name in the request to find its keyslot
     |       2. Selecting a node that handles the keyslot: If read_from_replicas is
     |          set to true or load_balancing_strategy is set, a replica can be selected.
     |
     |      :type redis_cluster: RedisCluster
     |      :type node: ClusterNode
     |      :type host: str
     |      :type port: int
     |
     |  disconnect(self)
     |      Disconnect the pubsub connection.
     |
     |  execute_command(self, *args)
     |      Execute a subscribe/unsubscribe command.
     |
     |      Taken code from redis-py and tweak to make it work within a cluster.
     |
     |  get_pubsub_node(self)
     |      Get the node that is being used as the pubsub connection
     |
     |  get_redis_connection(self)
     |      Get the Redis connection of the pubsub connected node.
     |
     |  get_sharded_message(self, ignore_subscribe_messages=False, timeout=0.0, target_node=None)
     |      Get the next message if one is available, otherwise None.
     |
     |      If timeout is specified, the system will wait for `timeout` seconds
     |      before returning. Timeout should be specified as a floating point
     |      number, or None, to wait indefinitely.
     |
     |  on_slots_changed(self)
     |
     |  reinitialize_shard_subscriptions(self)
     |      Reconcile per-node shard subscriptions against the cluster's current
     |      slot ownership map. For each tracked shard channel whose owning node
     |      has changed (e.g. after CLUSTER SETSLOT / failover), sunsubscribe on
     |      the old node's pubsub and ssubscribe on the new owner's pubsub,
     |      preserving any registered handler.
     |
     |  reset(self) -> None
     |
     |  set_pubsub_node(self, cluster, node=None, host=None, port=None)
     |      The pubsub node will be set according to the passed node, host and port
     |      When none of the node, host, or port are specified - the node is set
     |      to None and will be determined by the keyslot of the channel in the
     |      first command to be executed.
     |      RedisClusterException will be thrown if the passed node does not exist
     |      in the cluster.
     |      If host is passed without port, or vice versa, a DataError will be
     |      thrown.
     |      :type cluster: RedisCluster
     |      :type node: ClusterNode
     |      :type host: str
     |      :type port: int
     |
     |  ssubscribe(self, *args: Union[bytes, str, memoryview, redis.typing.Subscription], **kwargs: Callable[[dict[str, Any]], Any]) -> None
     |      Subscribe to shard channels.
     |
     |      Channels supplied as keyword arguments expect a channel name as the key
     |      and a callable as the value. ``Subscription`` objects can also be
     |      supplied positionally with an optional handler.
     |
     |  sunsubscribe(self, *args)
     |      Unsubscribe from the supplied shard_channels. If empty, unsubscribe from
     |      all shard_channels
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from redis.client.PubSub:
     |
     |  __del__(self) -> None
     |
     |  __enter__(self) -> 'PubSub'
     |
     |  __exit__(self, exc_type, exc_value, traceback) -> None
     |
     |  check_health(self) -> None
     |
     |  clean_health_check_responses(self) -> None
     |      If any health check responses are present, clean them
     |
     |  close(self) -> None
     |
     |  get_message(self, ignore_subscribe_messages: bool = False, timeout: float = 0.0)
     |      Get the next message if one is available, otherwise None.
     |
     |      If timeout is specified, the system will wait for `timeout` seconds
     |      before returning. Timeout should be specified as a floating point
     |      number, or None, to wait indefinitely.
     |
     |  handle_message(self, response, ignore_subscribe_messages=False)
     |      Parses a pub/sub message. If the channel or pattern was subscribed to
     |      with a message handler, the handler is invoked instead of a parsed
     |      message being returned.
     |
     |  is_health_check_response(self, response) -> bool
     |      Check if the response is a health check response.
     |      If there are no subscriptions redis responds to PING command with a
     |      bulk response, instead of a multi-bulk with "pong" and the response.
     |
     |  listen(self)
     |      Listen for messages on channels this client has been subscribed to
     |
     |  on_connect(self, connection) -> None
     |      Re-subscribe to any channels and patterns previously subscribed to
     |
     |  parse_response(self, block=True, timeout=0)
     |      Parse the response from a publish/subscribe command.
     |
     |      Args:
     |          block: If True, block indefinitely until a message is available.
     |                 If False, return immediately if no message is available.
     |                 Default: True
     |          timeout: The timeout in seconds for reading a response when block=False.
     |                   This parameter is ignored when block=True.
     |                   Default: 0 (return immediately if no data available)
     |
     |      Returns:
     |          The parsed response from the server, or None if no message is available
     |          within the timeout period (when block=False).
     |
     |      Important:
     |          The block and timeout parameters work together:
     |          - When block=True: timeout is IGNORED, method blocks indefinitely
     |          - When block=False: timeout is USED, method returns after timeout expires
     |
     |          Typically, you should use get_message(timeout=X) instead of calling
     |          parse_response() directly. The get_message() method automatically sets
     |          block=False when a timeout is provided, and block=True when timeout=None.
     |
     |      Example:
     |          # Block indefinitely (timeout is ignored)
     |          response = pubsub.parse_response(block=True, timeout=0.1)
     |
     |          # Non-blocking with 0.1 second timeout
     |          response = pubsub.parse_response(block=False, timeout=0.1)
     |
     |          # Non-blocking, return immediately
     |          response = pubsub.parse_response(block=False, timeout=0)
     |
     |          # Recommended: use get_message() instead
     |          msg = pubsub.get_message(timeout=0.1)  # automatically sets block=False
     |          msg = pubsub.get_message(timeout=None)  # automatically sets block=True
     |
     |  ping(self, message: Optional[str] = None) -> bool
     |      Ping the Redis server to test connectivity.
     |
     |      Sends a PING command to the Redis server and returns True if the server
     |      responds with "PONG".
     |
     |  psubscribe(self, *args: Union[bytes, str, memoryview, redis.typing.Subscription], **kwargs: Callable[[dict[str, Any]], Any]) -> None
     |      Subscribe to channel patterns.
     |      Patterns supplied as keyword arguments expect a pattern name as the
     |      key and a callable as the value.
     |      ``Subscription`` objects can also be supplied positionally with an
     |      optional handler.
     |      A pattern's callable will be invoked automatically
     |      when a message is received on that pattern rather than producing a
     |      message via ``listen()``.
     |
     |  punsubscribe(self, *args)
     |      Unsubscribe from the supplied patterns. If empty, unsubscribe from
     |      all patterns.
     |
     |  run_in_thread(self, sleep_time: float = 0.0, daemon: bool = False, exception_handler: Optional[Callable] = None, pubsub=None, sharded_pubsub: bool = False) -> 'PubSubWorkerThread'
     |
     |  subscribe(self, *args: Union[bytes, str, memoryview, redis.typing.Subscription], **kwargs: Callable[[dict[str, Any]], Any]) -> None
     |      Subscribe to channels.
     |      Channels supplied as keyword arguments expect
     |      a channel name as the key and a callable as the value.
     |      ``Subscription`` objects can also be supplied positionally with an
     |      optional handler.
     |      A channel's callable will be invoked automatically
     |      when a message is received on that channel rather than producing a
     |      message via ``listen()`` or ``get_message()``.
     |
     |  unsubscribe(self, *args)
     |      Unsubscribe from the supplied channels. If empty, unsubscribe from
     |      all channels
     |
     |  ----------------------------------------------------------------------
     |  Readonly properties inherited from redis.client.PubSub:
     |
     |  subscribed
     |      Indicates if there are subscriptions to any channels or patterns
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors inherited from redis.client.PubSub:
     |
     |  __dict__
     |      dictionary for instance variables
     |
     |  __weakref__
     |      list of weak references to the object
     |
     |  ----------------------------------------------------------------------
     |  Data and other attributes inherited from redis.client.PubSub:
     |
     |  HEALTH_CHECK_MESSAGE = 'redis-py-health-check'
     |
     |  PUBLISH_MESSAGE_TYPES = ('message', 'pmessage', 'smessage')
     |
     |  UNSUBSCRIBE_MESSAGE_TYPES = ('unsubscribe', 'punsubscribe', 'sunsubscr...

    class ClusterPubSubSlotsCacheListener(redis.event.EventListenerInterface)
     |  ClusterPubSubSlotsCacheListener(pubsub: 'ClusterPubSub') -> None
     |
     |  Listener that forwards AfterSlotsCacheRefreshEvent to a ClusterPubSub.
     |
     |  Holds a weak reference to the pubsub so it does not keep the instance
     |  alive. Deterministic cleanup of the dispatcher's strong reference to this
     |  listener is performed by a ``weakref.finalize`` attached to the owning
     |  ClusterPubSub in ``ClusterPubSub.__init__``.
     |
     |  Method resolution order:
     |      ClusterPubSubSlotsCacheListener
     |      redis.event.EventListenerInterface
     |      abc.ABC
     |      builtins.object
     |
     |  Methods defined here:
     |
     |  __init__(self, pubsub: 'ClusterPubSub') -> None
     |      Initialize self.  See help(type(self)) for accurate signature.
     |
     |  listen(self, event: object) -> None
     |
     |  ----------------------------------------------------------------------
     |  Data and other attributes defined here:
     |
     |  __abstractmethods__ = frozenset()
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors inherited from redis.event.EventListenerInterface:
     |
     |  __dict__
     |      dictionary for instance variables
     |
     |  __weakref__
     |      list of weak references to the object

    class ExecutionStrategy(abc.ABC)
     |  Method resolution order:
     |      ExecutionStrategy
     |      abc.ABC
     |      builtins.object
     |
     |  Methods defined here:
     |
     |  annotate_exception(self, exception, number, command)
     |      Annotate exception according to current execution strategy.
     |
     |      See: ClusterPipeline.annotate_exception()
     |
     |  delete(self, *names)
     |      "Delete a key specified by ``names``"
     |
     |      See: ClusterPipeline.delete()
     |
     |  discard(self)
     |
     |  eval(self)
     |
     |  execute(self, raise_on_error: bool = True) -> List[Any]
     |      Executes current execution strategy.
     |
     |      See: ClusterPipeline.execute()
     |
     |  execute_command(self, *args, **kwargs)
     |      Execution flow for current execution strategy.
     |
     |      See: ClusterPipeline.execute_command()
     |
     |  exists(self, *keys)
     |
     |  load_scripts(self)
     |
     |  multi(self)
     |      Starts transactional context.
     |
     |      See: ClusterPipeline.multi()
     |
     |  pipeline_execute_command(self, *args, **options)
     |      Pipeline execution flow for current execution strategy.
     |
     |      See: ClusterPipeline.pipeline_execute_command()
     |
     |  reset(self)
     |      Resets current execution strategy.
     |
     |      See: ClusterPipeline.reset()
     |
     |  script_load_for_pipeline(self, *args, **kwargs)
     |
     |  send_cluster_commands(self, stack, raise_on_error=True, allow_redirections=True)
     |      Sends commands according to current execution strategy.
     |
     |      See: ClusterPipeline.send_cluster_commands()
     |
     |  unlink(self, *names)
     |      "Unlink a key specified by ``names``"
     |
     |      See: ClusterPipeline.unlink()
     |
     |  unwatch(self)
     |      Unwatches all previously specified keys
     |
     |      See: ClusterPipeline.unwatch()
     |
     |  watch(self, *names)
     |
     |  ----------------------------------------------------------------------
     |  Readonly properties defined here:
     |
     |  command_queue
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors defined here:
     |
     |  __dict__
     |      dictionary for instance variables
     |
     |  __weakref__
     |      list of weak references to the object
     |
     |  ----------------------------------------------------------------------
     |  Data and other attributes defined here:
     |
     |  __abstractmethods__ = frozenset({'annotate_exception', 'command_queue'...

    class LoadBalancer(builtins.object)
     |  LoadBalancer(start_index: int = 0) -> None
     |
     |  Round-Robin Load Balancing
     |
     |  Methods defined here:
     |
     |  __init__(self, start_index: int = 0) -> None
     |      Initialize self.  See help(type(self)) for accurate signature.
     |
     |  get_server_index(self, primary: str, list_size: int, load_balancing_strategy: redis.cluster.LoadBalancingStrategy = <LoadBalancingStrategy.ROUND_ROBIN: 'round_robin'>) -> int
     |
     |  reset(self) -> None
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors defined here:
     |
     |  __dict__
     |      dictionary for instance variables
     |
     |  __weakref__
     |      list of weak references to the object

    class LoadBalancingStrategy(enum.Enum)
     |  LoadBalancingStrategy(*values)
     |
     |  Method resolution order:
     |      LoadBalancingStrategy
     |      enum.Enum
     |      builtins.object
     |
     |  Data and other attributes defined here:
     |
     |  RANDOM = <LoadBalancingStrategy.RANDOM: 'random'>
     |
     |  RANDOM_REPLICA = <LoadBalancingStrategy.RANDOM_REPLICA: 'random_replic...
     |
     |  ROUND_ROBIN = <LoadBalancingStrategy.ROUND_ROBIN: 'round_robin'>
     |
     |  ROUND_ROBIN_REPLICAS = <LoadBalancingStrategy.ROUND_ROBIN_REPLICAS: 'r...
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors inherited from enum.Enum:
     |
     |  name
     |      The name of the Enum member.
     |
     |  value
     |      The value of the Enum member.
     |
     |  ----------------------------------------------------------------------
     |  Static methods inherited from enum.EnumType:
     |
     |  __contains__(value)
     |      Return True if `value` is in `cls`.
     |
     |      `value` is in `cls` if:
     |      1) `value` is a member of `cls`, or
     |      2) `value` is the value of one of the `cls`'s members.
     |
     |  __getitem__(name)
     |      Return the member matching `name`.
     |
     |  __iter__()
     |      Return members in definition order.
     |
     |  __len__()
     |      Return the number of members (no aliases)
     |
     |  ----------------------------------------------------------------------
     |  Readonly properties inherited from enum.EnumType:
     |
     |  __members__
     |      Returns a mapping of member name->value.
     |
     |      This mapping lists all enum members, including aliases. Note that this
     |      is a read-only view of the internal mapping.

    class MaintNotificationsAbstractRedisCluster(builtins.object)
     |  MaintNotificationsAbstractRedisCluster(maint_notifications_config: Optional[redis.maint_notifications.MaintNotificationsConfig], **kwargs)
     |
     |  Abstract class for handling maintenance notifications logic.
     |  This class is expected to be used as base class together with RedisCluster.
     |
     |  This class is intended to be used with multiple inheritance!
     |
     |  All logic related to maintenance notifications is encapsulated in this class.
     |
     |  Methods defined here:
     |
     |  __init__(self, maint_notifications_config: Optional[redis.maint_notifications.MaintNotificationsConfig], **kwargs)
     |      Initialize self.  See help(type(self)) for accurate signature.
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors defined here:
     |
     |  __dict__
     |      dictionary for instance variables
     |
     |  __weakref__
     |      list of weak references to the object
     |
     |  ----------------------------------------------------------------------
     |  Data and other attributes defined here:
     |
     |  __annotations__ = {}

    class NodeCommands(builtins.object)
     |  NodeCommands(parse_response, connection_pool: redis.connection.ConnectionPool, connection: redis.connection.Connection)
     |
     |  Methods defined here:
     |
     |  __init__(self, parse_response, connection_pool: redis.connection.ConnectionPool, connection: redis.connection.Connection)
     |
     |  append(self, c)
     |
     |  read(self)
     |
     |  write(self)
     |      Code borrowed from Redis so it can be fixed
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors defined here:
     |
     |  __dict__
     |      dictionary for instance variables
     |
     |  __weakref__
     |      list of weak references to the object

    class NodesManager(builtins.object)
     |  NodesManager(startup_nodes: list[redis.cluster.ClusterNode], from_url=False, require_full_coverage=False, lock: Optional[RLock] = None, dynamic_startup_nodes=True, connection_pool_class=<class 'redis.connection.ConnectionPool'>, address_remap: Optional[Callable[[Tuple[str, int]], Tuple[str, int]]] = None, cache: Optional[redis.cache.CacheInterface] = None, cache_config: Optional[redis.cache.CacheConfig] = None, cache_factory: Optional[redis.cache.CacheFactoryInterface] = None, event_dispatcher: Optional[redis.event.EventDispatcher] = None, maint_notifications_config: Optional[redis.maint_notifications.MaintNotificationsConfig] = None, himport_registry: redis.himport.HImportRegistry | None = None, **kwargs)
     |
     |  Methods defined here:
     |
     |  __init__(self, startup_nodes: list[redis.cluster.ClusterNode], from_url=False, require_full_coverage=False, lock: Optional[RLock] = None, dynamic_startup_nodes=True, connection_pool_class=<class 'redis.connection.ConnectionPool'>, address_remap: Optional[Callable[[Tuple[str, int]], Tuple[str, int]]] = None, cache: Optional[redis.cache.CacheInterface] = None, cache_config: Optional[redis.cache.CacheConfig] = None, cache_factory: Optional[redis.cache.CacheFactoryInterface] = None, event_dispatcher: Optional[redis.event.EventDispatcher] = None, maint_notifications_config: Optional[redis.maint_notifications.MaintNotificationsConfig] = None, himport_registry: redis.himport.HImportRegistry | None = None, **kwargs)
     |      Initialize self.  See help(type(self)) for accurate signature.
     |
     |  check_slots_coverage(self, slots_cache)
     |
     |  close(self) -> None
     |
     |  create_redis_connections(self, nodes)
     |      This function will create a redis connection to all nodes in :nodes:
     |
     |  create_redis_node(self, host, port, **kwargs)
     |
     |  find_connection_owner(self, connection: redis.connection.Connection) -> Optional[redis.cluster.ClusterNode]
     |
     |  get_node(self, host: Optional[str] = None, port: Optional[int] = None, node_name: Optional[str] = None) -> Optional[redis.cluster.ClusterNode]
     |      Get the requested node from the cluster's nodes.
     |      nodes.
     |      :return: ClusterNode if the node exists, else None
     |
     |  get_node_from_slot(self, slot: int, read_from_replicas: bool = False, load_balancing_strategy: Optional[redis.cluster.LoadBalancingStrategy] = None, server_type: Optional[Literal['primary', 'replica']] = None) -> redis.cluster.ClusterNode
     |      Gets a node that servers this hash slot
     |
     |  get_nodes_by_server_type(self, server_type: Literal['primary', 'replica'])
     |      Get all nodes with the specified server type
     |      :param server_type: 'primary' or 'replica'
     |      :return: list of ClusterNode
     |
     |  initialize(self, additional_startup_nodes_info: Optional[List[Tuple[str, int]]] = None, disconnect_startup_nodes_pools: bool = True, last_failed_node_name: Optional[str] = None)
     |      Initializes the nodes cache, slots cache and redis connections.
     |      :startup_nodes:
     |          Responsible for discovering other nodes in the cluster
     |      :disconnect_startup_nodes_pools:
     |          Whether to disconnect the connection pool of the startup nodes
     |          after the initialization is complete. This is useful when the
     |          startup nodes are not part of the cluster and we want to avoid
     |          keeping the connection open.
     |      :additional_startup_nodes_info:
     |          Additional nodes to add temporarily to the startup nodes.
     |          The additional nodes will be used just in the process of extraction of the slots
     |          and nodes information from the cluster.
     |          This is useful when we want to add new nodes to the cluster
     |          and initialize the client
     |          with them.
     |          The format of the list is a list of tuples, where each tuple contains
     |          the host and port of the node.
     |      :last_failed_node_name:
     |          Name of the node that just failed and should be tried only after
     |          other startup and additional startup nodes during this refresh.
     |
     |  move_node_to_end_of_cached_nodes(self, node_name: str) -> None
     |      Move a failing node to the end of startup_nodes and nodes_cache so it's
     |      tried last during reinitialization and when selecting the default node.
     |      If the node is not in the respective list, nothing is done.
     |
     |  move_slot(self, e: Union[redis.exceptions.AskError, redis.exceptions.MovedError])
     |      Update the slot's node with the redirected one
     |
     |  populate_startup_nodes(self, nodes)
     |      Populate all startup nodes and filters out any duplicates
     |
     |  remap_host_port(self, host: str, port: int) -> Tuple[str, int]
     |      Remap the host and port returned from the cluster to a different
     |      internal value.  Useful if the client is not connecting directly
     |      to the cluster.
     |
     |  reset(self)
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors defined here:
     |
     |  __dict__
     |      dictionary for instance variables
     |
     |  __weakref__
     |      list of weak references to the object

    class PipelineCommand(builtins.object)
     |  PipelineCommand(args, options=None, position=None)
     |
     |  Methods defined here:
     |
     |  __init__(self, args, options=None, position=None)
     |      Initialize self.  See help(type(self)) for accurate signature.
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors defined here:
     |
     |  __dict__
     |      dictionary for instance variables
     |
     |  __weakref__
     |      list of weak references to the object

    class PipelineStrategy(AbstractStrategy)
     |  PipelineStrategy(pipe: redis.cluster.ClusterPipeline)
     |
     |  Method resolution order:
     |      PipelineStrategy
     |      AbstractStrategy
     |      ExecutionStrategy
     |      abc.ABC
     |      builtins.object
     |
     |  Methods defined here:
     |
     |  __init__(self, pipe: redis.cluster.ClusterPipeline)
     |      Initialize self.  See help(type(self)) for accurate signature.
     |
     |  delete(self, *names)
     |      "Delete a key specified by ``names``"
     |
     |      See: ClusterPipeline.delete()
     |
     |  discard(self)
     |
     |  execute(self, raise_on_error: bool = True) -> List[Any]
     |      Executes current execution strategy.
     |
     |      See: ClusterPipeline.execute()
     |
     |  execute_command(self, *args, **kwargs)
     |      Execution flow for current execution strategy.
     |
     |      See: ClusterPipeline.execute_command()
     |
     |  multi(self)
     |      Starts transactional context.
     |
     |      See: ClusterPipeline.multi()
     |
     |  reset(self)
     |      Reset back to empty pipeline.
     |
     |  send_cluster_commands(self, stack, raise_on_error=True, allow_redirections=True)
     |      Wrapper for RedisCluster.ERRORS_ALLOW_RETRY errors handling.
     |
     |      If one of the retryable exceptions has been thrown we assume that:
     |       - connection_pool was disconnected
     |       - connection_pool was reset
     |       - refresh_table_asap set to True
     |
     |      It will try the number of times specified by
     |      the retries in config option "self.retry"
     |      which defaults to 10 unless manually configured.
     |
     |      If it reaches the number of times, the command will
     |      raises ClusterDownException.
     |
     |  unlink(self, *names)
     |      "Unlink a key specified by ``names``"
     |
     |      See: ClusterPipeline.unlink()
     |
     |  unwatch(self, *names)
     |      Unwatches all previously specified keys
     |
     |      See: ClusterPipeline.unwatch()
     |
     |  watch(self, *names)
     |
     |  ----------------------------------------------------------------------
     |  Data and other attributes defined here:
     |
     |  __abstractmethods__ = frozenset()
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from AbstractStrategy:
     |
     |  annotate_exception(self, exception, number, command)
     |      Provides extra context to the exception prior to it being handled
     |
     |  eval(self)
     |
     |  exists(self, *keys)
     |
     |  load_scripts(self)
     |
     |  pipeline_execute_command(self, *args, **options)
     |      Pipeline execution flow for current execution strategy.
     |
     |      See: ClusterPipeline.pipeline_execute_command()
     |
     |  script_load_for_pipeline(self, *args, **kwargs)
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors inherited from AbstractStrategy:
     |
     |  command_queue
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors inherited from ExecutionStrategy:
     |
     |  __dict__
     |      dictionary for instance variables
     |
     |  __weakref__
     |      list of weak references to the object

    class RedisCluster(AbstractRedisCluster, MaintNotificationsAbstractRedisCluster, redis.commands.cluster.RedisClusterCommands)
     |  RedisCluster(host: Optional[str] = None, port: int = 6379, startup_nodes: Optional[List[ForwardRef('ClusterNode')]] = None, cluster_error_retry_attempts: int = 10, retry: Optional[ForwardRef('Retry')] = None, require_full_coverage: bool = True, reinitialize_steps: int = 5, read_from_replicas: bool = False, load_balancing_strategy: Optional[ForwardRef('LoadBalancingStrategy')] = None, dynamic_startup_nodes: bool = True, url: Optional[str] = None, address_remap: Optional[Callable[[Tuple[str, int]], Tuple[str, int]]] = None, cache: Optional[redis.cache.CacheInterface] = None, cache_config: Optional[redis.cache.CacheConfig] = None, event_dispatcher: Optional[redis.event.EventDispatcher] = None, policy_resolver: redis.commands.policies.PolicyResolver = <redis.commands.policies.StaticPolicyResolver object at 0x0000017B9C759D90>, maint_notifications_config: Optional[redis.maint_notifications.MaintNotificationsConfig] = None, **kwargs)
     |
     |  Method resolution order:
     |      RedisCluster
     |      AbstractRedisCluster
     |      MaintNotificationsAbstractRedisCluster
     |      redis.commands.cluster.RedisClusterCommands
     |      redis.commands.cluster.ClusterMultiKeyCommands
     |      redis.typing.ClusterCommandsProtocol
     |      redis.commands.cluster.ClusterManagementCommands
     |      redis.commands.core.ManagementCommands
     |      redis.commands.core.ACLCommands
     |      redis.commands.core.PubSubCommands
     |      redis.commands.cluster.ClusterDataAccessCommands
     |      redis.commands.core.DataAccessCommands
     |      redis.commands.core.BasicKeyCommands
     |      redis.commands.core.HyperlogCommands
     |      redis.commands.core.HashCommands
     |      redis.commands.core.GeoCommands
     |      redis.commands.core.ListCommands
     |      redis.commands.core.ArrayCommands
     |      redis.commands.core.ScanCommands
     |      redis.commands.core.SetCommands
     |      redis.commands.core.StreamCommands
     |      redis.commands.core.SortedSetCommands
     |      redis.commands.core.ScriptCommands
     |      redis.commands.core.FunctionCommands
     |      redis.commands.core.ModuleCommands
     |      redis.typing.CommandsProtocol
     |      typing.Protocol
     |      typing.Generic
     |      redis.commands.redismodules.RedisModuleCommands
     |      builtins.object
     |
     |  Methods defined here:
     |
     |  __del__(self)
     |
     |  __enter__(self)
     |
     |  __exit__(self, exc_type, exc_value, traceback)
     |
     |  __init__(self, host: Optional[str] = None, port: int = 6379, startup_nodes: Optional[List[ForwardRef('ClusterNode')]] = None, cluster_error_retry_attempts: int = 10, retry: Optional[ForwardRef('Retry')] = None, require_full_coverage: bool = True, reinitialize_steps: int = 5, read_from_replicas: bool = False, load_balancing_strategy: Optional[ForwardRef('LoadBalancingStrategy')] = None, dynamic_startup_nodes: bool = True, url: Optional[str] = None, address_remap: Optional[Callable[[Tuple[str, int]], Tuple[str, int]]] = None, cache: Optional[redis.cache.CacheInterface] = None, cache_config: Optional[redis.cache.CacheConfig] = None, event_dispatcher: Optional[redis.event.EventDispatcher] = None, policy_resolver: redis.commands.policies.PolicyResolver = <redis.commands.policies.StaticPolicyResolver object at 0x0000017B9C759D90>, maint_notifications_config: Optional[redis.maint_notifications.MaintNotificationsConfig] = None, **kwargs)
     |      Initialize a new RedisCluster client.
     |
     |      :param startup_nodes:
     |          List of nodes from which initial bootstrapping can be done
     |      :param host:
     |          Can be used to point to a startup node
     |      :param port:
     |          Can be used to point to a startup node
     |      :param require_full_coverage:
     |          When set to False (default value): the client will not require a
     |          full coverage of the slots. However, if not all slots are covered,
     |          and at least one node has 'cluster-require-full-coverage' set to
     |          'yes,' the server will throw a ClusterDownError for some key-based
     |          commands. See -
     |          https://redis.io/topics/cluster-tutorial#redis-cluster-configuration-parameters
     |          When set to True: all slots must be covered to construct the
     |          cluster client. If not all slots are covered, RedisClusterException
     |          will be thrown.
     |      :param read_from_replicas:
     |          @deprecated - please use load_balancing_strategy instead
     |          Enable read from replicas in READONLY mode. You can read possibly
     |          stale data.
     |          When set to true, read commands will be assigned between the
     |          primary and its replications in a Round-Robin manner.
     |      :param load_balancing_strategy:
     |          Enable read from replicas in READONLY mode and defines the load balancing
     |          strategy that will be used for cluster node selection.
     |          The data read from replicas is eventually consistent with the data in primary nodes.
     |      :param dynamic_startup_nodes:
     |          Set the RedisCluster's startup nodes to all of the discovered nodes.
     |          If true (default value), the cluster's discovered nodes will be used to
     |          determine the cluster nodes-slots mapping in the next topology refresh.
     |          It will remove the initial passed startup nodes if their endpoints aren't
     |          listed in the CLUSTER SLOTS output.
     |          If you use dynamic DNS endpoints for startup nodes but CLUSTER SLOTS lists
     |          specific IP addresses, it is best to set it to false.
     |      :param cluster_error_retry_attempts:
     |          @deprecated - Please configure the 'retry' object instead
     |          In case 'retry' object is set - this argument is ignored!
     |
     |          Number of times to retry before raising an error when
     |          :class:`~.TimeoutError` or :class:`~.ConnectionError`, :class:`~.SlotNotCoveredError` or
     |          :class:`~.ClusterDownError` are encountered
     |      :param retry:
     |          A retry object that defines the retry strategy and the number of
     |          retries for the cluster client.
     |          In current implementation for the cluster client (starting form redis-py version 6.0.0)
     |          the retry object is not yet fully utilized, instead it is used just to determine
     |          the number of retries for the cluster client.
     |          In the future releases the retry object will be used to handle the cluster client retries!
     |      :param reinitialize_steps:
     |          Specifies the number of MOVED errors that need to occur before
     |          reinitializing the whole cluster topology. If a MOVED error occurs
     |          and the cluster does not need to be reinitialized on this current
     |          error handling, only the MOVED slot will be patched with the
     |          redirected node.
     |          To reinitialize the cluster on every MOVED error, set
     |          reinitialize_steps to 1.
     |          To avoid reinitializing the cluster on moved errors, set
     |          reinitialize_steps to 0.
     |      :param address_remap:
     |          An optional callable which, when provided with an internal network
     |          address of a node, e.g. a `(host, port)` tuple, will return the address
     |          where the node is reachable.  This can be used to map the addresses at
     |          which the nodes _think_ they are, to addresses at which a client may
     |          reach them, such as when they sit behind a proxy.
     |
     |      :param maint_notifications_config:
     |          Configures the nodes connections to support maintenance notifications - see
     |          `redis.maint_notifications.MaintNotificationsConfig` for details.
     |          Only supported with RESP3.
     |          If not provided and protocol is RESP3, the maintenance notifications
     |          will be enabled by default (logic is included in the NodesManager
     |          initialization).
     |      :**kwargs:
     |          Extra arguments that will be sent into Redis instance when created
     |          (See Official redis-py doc for supported kwargs - the only limitation
     |          is that you can't provide 'retry' object as part of kwargs.
     |          [https://github.com/andymccurdy/redis-py/blob/master/redis/client.py])
     |          Some kwargs are not supported and will raise a
     |          RedisClusterException:
     |              - db (Redis do not support database SELECT in cluster mode)
     |
     |  close(self) -> None
     |
     |  determine_slot(self, *args) -> Optional[int]
     |      Figure out what slot to use based on args.
     |
     |      Raises a RedisClusterException if there's a missing key and we can't
     |          determine what slots to map the command to; or, if the keys don't
     |          all map to the same key slot.
     |
     |  disconnect_connection_pools(self)
     |
     |  execute_command(self, *args, **kwargs)
     |
     |  get_connection_kwargs(self)
     |      Get the connections' key-word arguments
     |
     |  get_default_node(self)
     |      Get the cluster's default node
     |
     |  get_encoder(self)
     |      Get the connections' encoder
     |
     |  get_node(self, host=None, port=None, node_name=None)
     |
     |  get_node_from_key(self, key, replica=False)
     |      Get the node that holds the key's slot.
     |      If replica set to True but the slot doesn't have any replicas, None is
     |      returned.
     |
     |  get_nodes(self)
     |
     |  get_nodes_from_slot(self, command: str, *args)
     |      Returns a list of nodes that hold the specified keys' slots.
     |
     |  get_primaries(self)
     |
     |  get_random_node(self)
     |
     |  get_random_primary_node(self) -> 'ClusterNode'
     |      Returns a random primary node
     |
     |  get_random_primary_or_all_nodes(self, command_name)
     |      Returns random primary or all nodes depends on READONLY mode.
     |
     |  get_redis_connection(self, node: 'ClusterNode') -> redis.client.Redis
     |
     |  get_replicas(self)
     |
     |  get_special_nodes(self) -> Optional[list['ClusterNode']]
     |      Returns a list of nodes for commands with a special policy.
     |
     |  himport_discard(self, fieldset_name: str) -> int
     |      Remove an HIMPORT fieldset cluster-wide (shared registry, applied lazily).
     |
     |  himport_discard_all(self) -> int
     |      Remove all HIMPORT fieldsets cluster-wide (shared registry, applied lazily).
     |
     |  himport_prepare(self, fieldset_name: str, fields: Iterable[Union[bytes, bytearray, memoryview, str, int, float]]) -> bool
     |      Declare an HIMPORT fieldset cluster-wide (shared registry, applied lazily).
     |
     |  keyslot(self, key)
     |      Calculate keyslot for a given key.
     |      See Keys distribution model in https://redis.io/topics/cluster-spec
     |
     |  keyspace_notifications(self, key_prefix: Union[str, bytes, NoneType] = None, ignore_subscribe_messages: bool = True) -> 'ClusterKeyspaceNotifications'
     |      Return a :class:`~redis.keyspace_notifications.ClusterKeyspaceNotifications`
     |      object for subscribing to keyspace and keyevent notifications across
     |      all primary nodes in the cluster.
     |
     |      Note: Keyspace notifications must be enabled on all Redis cluster nodes
     |      via the ``notify-keyspace-events`` configuration option.
     |
     |      Args:
     |          key_prefix: Optional prefix to filter and strip from keys in
     |                      notifications.
     |          ignore_subscribe_messages: If True, subscribe/unsubscribe
     |                                    confirmations are not returned by
     |                                    get_message/listen.
     |
     |  load_external_module(self, funcname, func)
     |      This function can be used to add externally defined redis modules,
     |      and their namespaces to the redis client.
     |
     |      ``funcname`` - A string containing the name of the function to create
     |      ``func`` - The function, being added to this class.
     |
     |  lock(self, name, timeout=None, sleep=0.1, blocking=True, blocking_timeout=None, lock_class=None, thread_local=True, raise_on_release_error: bool = True)
     |      Return a new Lock object using key ``name`` that mimics
     |      the behavior of threading.Lock.
     |
     |      If specified, ``timeout`` indicates a maximum life for the lock.
     |      By default, it will remain locked until release() is called.
     |
     |      ``sleep`` indicates the amount of time to sleep per loop iteration
     |      when the lock is in blocking mode and another client is currently
     |      holding the lock.
     |
     |      ``blocking`` indicates whether calling ``acquire`` should block until
     |      the lock has been acquired or to fail immediately, causing ``acquire``
     |      to return False and the lock not being acquired. Defaults to True.
     |      Note this value can be overridden by passing a ``blocking``
     |      argument to ``acquire``.
     |
     |      ``blocking_timeout`` indicates the maximum amount of time in seconds to
     |      spend trying to acquire the lock. A value of ``None`` indicates
     |      continue trying forever. ``blocking_timeout`` can be specified as a
     |      float or integer, both representing the number of seconds to wait.
     |
     |      ``lock_class`` forces the specified lock implementation. Note that as
     |      of redis-py 3.0, the only lock class we implement is ``Lock`` (which is
     |      a Lua-based lock). So, it's unlikely you'll need this parameter, unless
     |      you have created your own custom lock class.
     |
     |      ``thread_local`` indicates whether the lock token is placed in
     |      thread-local storage. By default, the token is placed in thread local
     |      storage so that a thread only sees its token, not a token set by
     |      another thread. Consider the following timeline:
     |
     |          time: 0, thread-1 acquires `my-lock`, with a timeout of 5 seconds.
     |                   thread-1 sets the token to "abc"
     |          time: 1, thread-2 blocks trying to acquire `my-lock` using the
     |                   Lock instance.
     |          time: 5, thread-1 has not yet completed. redis expires the lock
     |                   key.
     |          time: 5, thread-2 acquired `my-lock` now that it's available.
     |                   thread-2 sets the token to "xyz"
     |          time: 6, thread-1 finishes its work and calls release(). if the
     |                   token is *not* stored in thread local storage, then
     |                   thread-1 would see the token value as "xyz" and would be
     |                   able to successfully release the thread-2's lock.
     |
     |      ``raise_on_release_error`` indicates whether to raise an exception when
     |      the lock is no longer owned when exiting the context manager. By default,
     |      this is True, meaning an exception will be raised. If False, the warning
     |      will be logged and the exception will be suppressed.
     |
     |      In some use cases it's necessary to disable thread local storage. For
     |      example, if you have code where one thread acquires a lock and passes
     |      that lock instance to a worker thread to release later. If thread
     |      local storage isn't disabled in this case, the worker thread won't see
     |      the token set by the thread that acquired the lock. Our assumption
     |      is that these cases aren't common and as such default to using
     |      thread local storage.
     |
     |  monitor(self, target_node=None)
     |      Returns a Monitor object for the specified target node.
     |      The default cluster node will be selected if no target node was
     |      specified.
     |      Monitor is useful for handling the MONITOR command to the redis server.
     |      next_command() method returns one command from monitor
     |      listen() method yields commands from monitor.
     |
     |  on_connect(self, connection)
     |      Initialize the connection, authenticate and select a database and send
     |       READONLY if it is set during object initialization.
     |
     |  pipeline(self, transaction=None, shard_hint=None)
     |      Cluster impl:
     |          Pipelines do not work in cluster mode the same way they
     |          do in normal mode. Create a clone of this object so
     |          that simulating pipelines will work correctly. Each
     |          command will be called directly when used and
     |          when calling execute() will only return the result stack.
     |
     |  pubsub(self, node=None, host=None, port=None, **kwargs)
     |      Allows passing a ClusterNode, or host&port, to get a pubsub instance
     |      connected to the specified node
     |
     |  set_default_node(self, node)
     |      Set the default node of the cluster.
     |      :param node: 'ClusterNode'
     |      :return True if the default node was set, else False
     |
     |  set_response_callback(self, command, callback)
     |      Set a custom Response Callback
     |
     |  set_retry(self, retry: redis.retry.Retry) -> None
     |
     |  transaction(self, func, *watches, **kwargs)
     |      Convenience method for executing the callable `func` as a transaction
     |      while watching all keys specified in `watches`. The 'func' callable
     |      should expect a single argument which is a Pipeline object.
     |
     |  ----------------------------------------------------------------------
     |  Class methods defined here:
     |
     |  __subclasshook__ = _proto_hook(other) from typing
     |
     |  from_url(url: str, **kwargs: Any) -> 'RedisCluster'
     |      Return a Redis client object configured from the given URL
     |
     |      For example::
     |
     |          redis://[[username]:[password]]@localhost:6379/0
     |          rediss://[[username]:[password]]@localhost:6379/0
     |          unix://[username@]/path/to/socket.sock?db=0[&password=password]
     |
     |      Three URL schemes are supported:
     |
     |      - `redis://` creates a TCP socket connection. See more at:
     |        <https://www.iana.org/assignments/uri-schemes/prov/redis>
     |      - `rediss://` creates a SSL wrapped TCP socket connection. See more at:
     |        <https://www.iana.org/assignments/uri-schemes/prov/rediss>
     |      - ``unix://``: creates a Unix Domain Socket connection.
     |
     |      The username, password, hostname, path and all querystring values
     |      are passed through urllib.parse.unquote in order to replace any
     |      percent-encoded values with their corresponding characters.
     |
     |      There are several ways to specify a database number. The first value
     |      found will be used:
     |
     |          1. A ``db`` querystring option, e.g. redis://localhost?db=0
     |          2. If using the redis:// or rediss:// schemes, the path argument
     |             of the url, e.g. redis://localhost/0
     |          3. A ``db`` keyword argument to this function.
     |
     |      If none of these options are specified, the default db=0 is used.
     |
     |      All querystring options are cast to their appropriate Python types.
     |      Boolean arguments can be specified with string values "True"/"False"
     |      or "Yes"/"No". Values that cannot be properly cast cause a
     |      ``ValueError`` to be raised. Once parsed, the querystring arguments
     |      and keyword arguments are passed to the ``ConnectionPool``'s
     |      class initializer. In the case of conflicting arguments, querystring
     |      arguments always win.
     |
     |  ----------------------------------------------------------------------
     |  Readonly properties defined here:
     |
     |  himport_registry
     |      The cluster-wide HIMPORT fieldset registry (empty if none was declared).
     |
     |      Read-only: the registry is mutated only through the HIMPORT command methods.
     |
     |  ----------------------------------------------------------------------
     |  Data and other attributes defined here:
     |
     |  __abstractmethods__ = frozenset()
     |
     |  __annotations__ = {'_is_async_client': typing.Literal[False]}
     |
     |  __parameters__ = ()
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from AbstractRedisCluster:
     |
     |  replace_default_node(self, target_node: 'ClusterNode' = None) -> None
     |      Replace the default cluster node.
     |      A random cluster node will be chosen if target_node isn't passed, and primaries
     |      will be prioritized. The default node will not be changed if there are no other
     |      nodes in the cluster.
     |
     |      Args:
     |          target_node (ClusterNode, optional): Target node to replace the default
     |          node. Defaults to None.
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors inherited from AbstractRedisCluster:
     |
     |  __dict__
     |      dictionary for instance variables
     |
     |  __weakref__
     |      list of weak references to the object
     |
     |  ----------------------------------------------------------------------
     |  Data and other attributes inherited from AbstractRedisCluster:
     |
     |  ALL_NODES = 'all'
     |
     |  CLUSTER_COMMANDS_RESPONSE_CALLBACKS = {'CLUSTER MYSHARDID': <function ...
     |
     |  COMMAND_FLAGS = {'ACL CAT': 'default-node', 'ACL DELUSER': 'default-no...
     |
     |  DEFAULT_NODE = 'default-node'
     |
     |  ERRORS_ALLOW_RETRY = (<class 'redis.exceptions.ConnectionError'>, <cla...
     |
     |  NODE_FLAGS = {'all', 'default-node', 'primaries', 'random', 'replicas'...
     |
     |  PRIMARIES = 'primaries'
     |
     |  RANDOM = 'random'
     |
     |  REPLICAS = 'replicas'
     |
     |  RESULT_CALLBACKS = {'BGSAVE': <function AbstractRedisCluster.<lambda>>...
     |
     |  RedisClusterRequestTTL = 16
     |
     |  SEARCH_COMMANDS = (['FT.CREATE', 'FT.SEARCH', 'FT.AGGREGATE', 'FT.EXPL...
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from redis.commands.cluster.ClusterMultiKeyCommands:
     |
     |  delete(self, *keys: 'KeyT') -> 'int | Awaitable[int]'
     |      Deletes the given keys in the cluster.
     |      The keys are first split up into slots
     |      and then an DEL command is sent for every slot
     |
     |      Non-existent keys are ignored.
     |      Returns the number of keys that were deleted.
     |
     |      For more information see https://redis.io/commands/del
     |
     |  exists(self, *keys: 'KeyT') -> 'int | Awaitable[int]'
     |      Returns the number of ``names`` that exist in the
     |      whole cluster. The keys are first split up into slots
     |      and then an EXISTS command is sent for every slot
     |
     |      For more information see https://redis.io/commands/exists
     |
     |  mget_nonatomic(self, keys: 'KeysT', *args: 'KeyT') -> 'List[Any | None]'
     |      Splits the keys into different slots and then calls MGET
     |      for the keys of every slot. This operation will not be atomic
     |      if keys belong to more than one slot.
     |
     |      Returns a list of values ordered identically to ``keys``
     |
     |      For more information see https://redis.io/commands/mget
     |
     |  mset_nonatomic(self, mapping: 'Mapping[AnyKeyT, EncodableT]') -> 'List[bool]'
     |      Sets key/values based on a mapping. Mapping is a dictionary of
     |      key/value pairs. Both keys and values should be strings or types that
     |      can be cast to a string via str().
     |
     |      Splits the keys into different slots and then calls MSET
     |      for the keys of every slot. This operation will not be atomic
     |      if keys belong to more than one slot.
     |
     |      For more information see https://redis.io/commands/mset
     |
     |  touch(self, *keys: 'KeyT') -> 'int | Awaitable[int]'
     |      Updates the last access time of given keys across the
     |      cluster.
     |
     |      The keys are first split up into slots
     |      and then an TOUCH command is sent for every slot
     |
     |      Non-existent keys are ignored.
     |      Returns the number of keys that were touched.
     |
     |      For more information see https://redis.io/commands/touch
     |
     |  unlink(self, *keys: 'KeyT') -> 'int | Awaitable[int]'
     |      Remove the specified keys in a different thread.
     |
     |      The keys are first split up into slots
     |      and then an TOUCH command is sent for every slot
     |
     |      Non-existent keys are ignored.
     |      Returns the number of keys that were unlinked.
     |
     |      For more information see https://redis.io/commands/unlink
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from redis.commands.cluster.ClusterManagementCommands:
     |
     |  client_tracking_off(self, clientid: 'int | None' = None, prefix: 'Sequence[KeyT]' = [], bcast: 'bool' = False, optin: 'bool' = False, optout: 'bool' = False, noloop: 'bool' = False, target_nodes: "'TargetNodesT' | None" = 'all') -> 'ResponseT'
     |      Disables the tracking feature of the Redis server, that is used
     |      for server assisted client side caching.
     |
     |      When clientid is provided - in target_nodes only the node that owns the
     |      connection with this id should be provided.
     |      When clientid is not provided - target_nodes can be any node.
     |
     |      For more information see https://redis.io/commands/client-tracking
     |
     |  client_tracking_on(self, clientid: 'int | None' = None, prefix: 'Sequence[KeyT]' = [], bcast: 'bool' = False, optin: 'bool' = False, optout: 'bool' = False, noloop: 'bool' = False, target_nodes: "'TargetNodesT' | None" = 'all') -> 'ResponseT'
     |      Enables the tracking feature of the Redis server, that is used
     |      for server assisted client side caching.
     |
     |      When clientid is provided - in target_nodes only the node that owns the
     |      connection with this id should be provided.
     |      When clientid is not provided - target_nodes can be any node.
     |
     |      For more information see https://redis.io/commands/client-tracking
     |
     |  cluster_addslots(self, target_node: "'TargetNodesT'", *slots: 'EncodableT') -> 'bool | Awaitable[bool]'
     |      Assign new hash slots to receiving node. Sends to specified node.
     |
     |      :target_node: 'ClusterNode'
     |          The node to execute the command on
     |
     |      For more information see https://redis.io/commands/cluster-addslots
     |
     |  cluster_addslotsrange(self, target_node: "'TargetNodesT'", *slots: 'EncodableT') -> 'bool | Awaitable[bool]'
     |      Similar to the CLUSTER ADDSLOTS command.
     |      The difference between the two commands is that ADDSLOTS takes a list of slots
     |      to assign to the node, while ADDSLOTSRANGE takes a list of slot ranges
     |      (specified by start and end slots) to assign to the node.
     |
     |      :target_node: 'ClusterNode'
     |          The node to execute the command on
     |
     |      For more information see https://redis.io/commands/cluster-addslotsrange
     |
     |  cluster_bumpepoch(self, target_nodes: "'TargetNodesT' | None" = None) -> 'None'
     |
     |  cluster_count_failure_report(self, node_id: 'str') -> 'int | Awaitable[int]'
     |      Return the number of failure reports active for a given node
     |      Sends to a random node
     |
     |      For more information see https://redis.io/commands/cluster-count-failure-reports
     |
     |  cluster_countkeysinslot(self, slot_id: 'int') -> 'int | Awaitable[int]'
     |      Return the number of local keys in the specified hash slot
     |      Send to node based on specified slot_id
     |
     |      For more information see https://redis.io/commands/cluster-countkeysinslot
     |
     |  cluster_delslots(self, *slots: 'EncodableT') -> 'List[bool]'
     |      Set hash slots as unbound in the cluster.
     |      It determines by it self what node the slot is in and sends it there
     |
     |      Returns a list of the results for each processed slot.
     |
     |      For more information see https://redis.io/commands/cluster-delslots
     |
     |  cluster_delslotsrange(self, *slots: 'EncodableT') -> 'bool | Awaitable[bool]'
     |      Similar to the CLUSTER DELSLOTS command.
     |      The difference is that CLUSTER DELSLOTS takes a list of hash slots to remove
     |      from the node, while CLUSTER DELSLOTSRANGE takes a list of slot ranges to remove
     |      from the node.
     |
     |      For more information see https://redis.io/commands/cluster-delslotsrange
     |
     |  cluster_failover(self, target_node: "'TargetNodesT'", option: 'str | None' = None) -> 'bool | Awaitable[bool]'
     |      Forces a slave to perform a manual failover of its master
     |      Sends to specified node
     |
     |      :target_node: 'ClusterNode'
     |          The node to execute the command on
     |
     |      For more information see https://redis.io/commands/cluster-failover
     |
     |  cluster_flushslots(self, target_nodes: "'TargetNodesT' | None" = None) -> 'None'
     |
     |  cluster_get_keys_in_slot(self, slot: 'int', num_keys: 'int') -> 'list[bytes | str] | Awaitable[list[bytes | str]]'
     |      Returns the number of keys in the specified cluster slot
     |
     |      For more information see https://redis.io/commands/cluster-getkeysinslot
     |
     |  cluster_info(self, target_nodes: "'TargetNodesT' | None" = None) -> 'dict[str, str] | Awaitable[dict[str, str]]'
     |      Provides info about Redis Cluster node state.
     |      The command will be sent to a random node in the cluster if no target
     |      node is specified.
     |
     |      For more information see https://redis.io/commands/cluster-info
     |
     |  cluster_keyslot(self, key: 'str') -> 'int | Awaitable[int]'
     |      Returns the hash slot of the specified key
     |      Sends to random node in the cluster
     |
     |      For more information see https://redis.io/commands/cluster-keyslot
     |
     |  cluster_links(self, target_node: "'TargetNodesT'") -> 'ClusterLinksResponse | Awaitable[ClusterLinksResponse]'
     |      Each node in a Redis Cluster maintains a pair of long-lived TCP link with each
     |      peer in the cluster: One for sending outbound messages towards the peer and one
     |      for receiving inbound messages from the peer.
     |
     |      This command outputs information of all such peer links as an array.
     |
     |      For more information see https://redis.io/commands/cluster-links
     |
     |  cluster_meet(self, host: 'str', port: 'int', target_nodes: "'TargetNodesT' | None" = None) -> 'bool | Awaitable[bool]'
     |      Force a node cluster to handshake with another node.
     |      Sends to specified node.
     |
     |      For more information see https://redis.io/commands/cluster-meet
     |
     |  cluster_myid(self, target_node: "'TargetNodesT'") -> 'bytes | str | Awaitable[bytes | str]'
     |      Returns the node's id.
     |
     |      :target_node: 'ClusterNode'
     |          The node to execute the command on
     |
     |      For more information check https://redis.io/commands/cluster-myid/
     |
     |  cluster_myshardid(self, target_nodes: "'TargetNodesT' | None" = None) -> 'bytes | str | Awaitable[bytes | str]'
     |      Returns the shard ID of the node.
     |
     |      For more information see https://redis.io/commands/cluster-myshardid/
     |
     |  cluster_nodes(self) -> 'dict[str, ClusterNodeDetail] | Awaitable[dict[str, ClusterNodeDetail]]'
     |      Get Cluster config for the node.
     |      Sends to random node in the cluster
     |
     |      For more information see https://redis.io/commands/cluster-nodes
     |
     |  cluster_replicas(self, node_id: 'str', target_nodes: "'TargetNodesT' | None" = None) -> 'dict[str, ClusterNodeDetail] | Awaitable[dict[str, ClusterNodeDetail]]'
     |      Provides a list of replica nodes replicating from the specified primary
     |      target node.
     |
     |      For more information see https://redis.io/commands/cluster-replicas
     |
     |  cluster_replicate(self, target_nodes: "'TargetNodesT'", node_id: 'str') -> 'bool | Awaitable[bool]'
     |      Reconfigure a node as a slave of the specified master node
     |
     |      For more information see https://redis.io/commands/cluster-replicate
     |
     |  cluster_reset(self, soft: 'bool' = True, target_nodes: "'TargetNodesT' | None" = None) -> 'bool | Awaitable[bool]'
     |      Reset a Redis Cluster node
     |
     |      If 'soft' is True then it will send 'SOFT' argument
     |      If 'soft' is False then it will send 'HARD' argument
     |
     |      For more information see https://redis.io/commands/cluster-reset
     |
     |  cluster_save_config(self, target_nodes: "'TargetNodesT' | None" = None) -> 'bool | Awaitable[bool]'
     |      Forces the node to save cluster state on disk
     |
     |      For more information see https://redis.io/commands/cluster-saveconfig
     |
     |  cluster_set_config_epoch(self, epoch: 'int', target_nodes: "'TargetNodesT' | None" = None) -> 'bool | Awaitable[bool]'
     |      Set the configuration epoch in a new node
     |
     |      For more information see https://redis.io/commands/cluster-set-config-epoch
     |
     |  cluster_setslot(self, target_node: "'TargetNodesT'", node_id: 'str', slot_id: 'int', state: 'str') -> 'bool | Awaitable[bool]'
     |      Bind an hash slot to a specific node
     |
     |      :target_node: 'ClusterNode'
     |          The node to execute the command on
     |
     |      For more information see https://redis.io/commands/cluster-setslot
     |
     |  cluster_setslot_stable(self, slot_id: 'int') -> 'bool | Awaitable[bool]'
     |      Clears migrating / importing state from the slot.
     |      It determines by it self what node the slot is in and sends it there.
     |
     |      For more information see https://redis.io/commands/cluster-setslot
     |
     |  cluster_shards(self, target_nodes: "'TargetNodesT' | None" = None) -> 'ClusterShardsResponse | Awaitable[ClusterShardsResponse]'
     |      Returns details about the shards of the cluster.
     |
     |      For more information see https://redis.io/commands/cluster-shards
     |
     |  cluster_slots(self, target_nodes: "'TargetNodesT' | None" = None) -> 'list[Any] | Awaitable[list[Any]]'
     |      Get array of Cluster slot to node mappings
     |
     |      For more information see https://redis.io/commands/cluster-slots
     |
     |  hotkeys_get(self, **kwargs) -> 'list[dict[str | bytes, Any]]'
     |      Cluster client does not support hotkeys command. Please use the non-cluster client.
     |
     |      For more information see https://redis.io/commands/hotkeys-get
     |
     |  hotkeys_reset(self, **kwargs) -> 'str | bytes'
     |      Cluster client does not support hotkeys command. Please use the non-cluster client.
     |
     |      For more information see https://redis.io/commands/hotkeys-reset
     |
     |  hotkeys_start(self, metrics: 'List[HotkeysMetricsTypes]', count: 'int | None' = None, duration: 'int | None' = None, sample_ratio: 'int | None' = None, slots: 'List[int] | None' = None, **kwargs) -> 'str | bytes'
     |      Cluster client does not support hotkeys command. Please use the non-cluster client.
     |
     |      For more information see https://redis.io/commands/hotkeys-start
     |
     |  hotkeys_stop(self, **kwargs) -> 'str | bytes'
     |      Cluster client does not support hotkeys command. Please use the non-cluster client.
     |
     |      For more information see https://redis.io/commands/hotkeys-stop
     |
     |  readonly(self, target_nodes: "'TargetNodesT' | None" = None) -> 'ResponseT'
     |      Enables read queries.
     |      The command will be sent to the default cluster node if target_nodes is
     |      not specified.
     |
     |      For more information see https://redis.io/commands/readonly
     |
     |  readwrite(self, target_nodes: "'TargetNodesT' | None" = None) -> 'ResponseT'
     |      Disables read queries.
     |      The command will be sent to the default cluster node if target_nodes is
     |      not specified.
     |
     |      For more information see https://redis.io/commands/readwrite
     |
     |  replicaof(self, *args, **kwargs) -> 'NoReturn'
     |      Make the server a replica of another instance, or promote it as master.
     |
     |      For more information see https://redis.io/commands/replicaof
     |
     |  slaveof(self, *args, **kwargs) -> 'NoReturn'
     |      Make the server a replica of another instance, or promote it as master.
     |
     |      For more information see https://redis.io/commands/slaveof
     |
     |  swapdb(self, *args, **kwargs) -> 'NoReturn'
     |      Swaps two Redis databases.
     |
     |      For more information see https://redis.io/commands/swapdb
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from redis.commands.core.ManagementCommands:
     |
     |  auth(self, password: 'str', username: 'str | None' = None, **kwargs) -> 'bool | Awaitable[bool]'
     |      Authenticates the user. If you do not pass username, Redis will try to
     |      authenticate for the "default" user. If you do pass username, it will
     |      authenticate for the given user.
     |      For more information, see https://redis.io/commands/auth
     |
     |  bgrewriteaof(self, **kwargs) -> 'bool | bytes | str | Awaitable[bool | bytes | str]'
     |      Tell the Redis server to rewrite the AOF file from data in memory.
     |
     |      For more information, see https://redis.io/commands/bgrewriteaof
     |
     |  bgsave(self, schedule: 'bool' = True, **kwargs) -> 'bool | bytes | str | Awaitable[bool | bytes | str]'
     |      Tell the Redis server to save its data to disk.  Unlike save(),
     |      this method is asynchronous and returns immediately.
     |
     |      For more information, see https://redis.io/commands/bgsave
     |
     |  client_getname(self, **kwargs) -> 'bytes | str | None | Awaitable[bytes | str | None]'
     |      Returns the current connection name
     |
     |      For more information, see https://redis.io/commands/client-getname
     |
     |  client_getredir(self, **kwargs) -> 'int | Awaitable[int]'
     |      Returns the ID (an integer) of the client to whom we are
     |      redirecting tracking notifications.
     |
     |      see: https://redis.io/commands/client-getredir
     |
     |  client_id(self, **kwargs) -> 'int | Awaitable[int]'
     |      Returns the current connection id
     |
     |      For more information, see https://redis.io/commands/client-id
     |
     |  client_info(self, **kwargs) -> 'dict[str, str | int] | Awaitable[dict[str, str | int]]'
     |      Returns information and statistics about the current
     |      client connection.
     |
     |      For more information, see https://redis.io/commands/client-info
     |
     |  client_kill(self, address: 'str', **kwargs) -> 'bool | int | Awaitable[bool | int]'
     |      Disconnects the client at ``address`` (ip:port)
     |
     |      For more information, see https://redis.io/commands/client-kill
     |
     |  client_kill_filter(self, _id: 'str | None' = None, _type: 'str | None' = None, addr: 'str | None' = None, skipme: 'bool | None' = None, laddr: 'bool | None' = None, user: 'str | None' = None, maxage: 'int | None' = None, **kwargs) -> 'int | Awaitable[int]'
     |      Disconnects client(s) using a variety of filter options
     |      :param _id: Kills a client by its unique ID field
     |      :param _type: Kills a client by type where type is one of 'normal',
     |      'master', 'slave', 'replica' or 'pubsub'
     |      :param addr: Kills a client by its 'address:port'
     |      :param skipme: If True, then the client calling the command
     |      will not get killed even if it is identified by one of the filter
     |      options. If skipme is not provided, the server defaults to skipme=True
     |      :param laddr: Kills a client by its 'local (bind) address:port'
     |      :param user: Kills a client for a specific user name
     |      :param maxage: Kills clients that are older than the specified age in seconds
     |
     |  client_list(self, _type: 'str | None' = None, client_id: 'List[EncodableT]' = [], **kwargs) -> 'list[dict[str, str]] | Awaitable[list[dict[str, str]]]'
     |      Returns a list of currently connected clients.
     |      If type of client specified, only that type will be returned.
     |
     |      :param _type: optional. one of the client types (normal, master,
     |       replica, pubsub)
     |      :param client_id: optional. a list of client ids
     |
     |      For more information, see https://redis.io/commands/client-list
     |
     |  client_no_evict(self, mode: 'str') -> 'bytes | str | Awaitable[bytes | str]'
     |      Sets the client eviction mode for the current connection.
     |
     |      For more information, see https://redis.io/commands/client-no-evict
     |
     |  client_no_touch(self, mode: 'str') -> 'bytes | str | Awaitable[bytes | str]'
     |      # The command controls whether commands sent by the client will alter
     |      # the LRU/LFU of the keys they access.
     |      # When turned on, the current client will not change LFU/LRU stats,
     |      # unless it sends the TOUCH command.
     |
     |      For more information, see https://redis.io/commands/client-no-touch
     |
     |  client_pause(self, timeout: 'int', all: 'bool' = True, **kwargs) -> 'bool | Awaitable[bool]'
     |      Suspend all the Redis clients for the specified amount of time.
     |
     |
     |      For more information, see https://redis.io/commands/client-pause
     |
     |      Args:
     |          timeout: milliseconds to pause clients
     |          all: If true (default) all client commands are blocked.
     |               otherwise, clients are only blocked if they attempt to execute
     |               a write command.
     |
     |      For the WRITE mode, some commands have special behavior:
     |
     |      * EVAL/EVALSHA: Will block client for all scripts.
     |      * PUBLISH: Will block client.
     |      * PFCOUNT: Will block client.
     |      * WAIT: Acknowledgments will be delayed, so this command will
     |          appear blocked.
     |
     |  client_reply(self, reply: "Literal['ON', 'OFF', 'SKIP']", **kwargs) -> 'bytes | str | Awaitable[bytes | str]'
     |      Enable and disable redis server replies.
     |
     |      ``reply`` Must be ON OFF or SKIP,
     |      ON - The default most with server replies to commands
     |      OFF - Disable server responses to commands
     |      SKIP - Skip the response of the immediately following command.
     |
     |      Note: When setting OFF or SKIP replies, you will need a client object
     |      with a timeout specified in seconds, and will need to catch the
     |      TimeoutError.
     |      The test_client_reply unit test illustrates this, and
     |      conftest.py has a client with a timeout.
     |
     |      See https://redis.io/commands/client-reply
     |
     |  client_setinfo(self, attr: 'str', value: 'str', **kwargs) -> 'bool | Awaitable[bool]'
     |      Sets the current connection library name or version
     |      For more information see https://redis.io/commands/client-setinfo
     |
     |  client_setname(self, name: 'str', **kwargs) -> 'bool | Awaitable[bool]'
     |      Sets the current connection name
     |
     |      For more information, see https://redis.io/commands/client-setname
     |
     |      .. note::
     |         This method sets client name only for **current** connection.
     |
     |         If you want to set a common name for all connections managed
     |         by this client, use ``client_name`` constructor argument.
     |
     |  client_tracking(self, on: 'bool' = True, clientid: 'int | None' = None, prefix: 'Sequence[KeyT]' = [], bcast: 'bool' = False, optin: 'bool' = False, optout: 'bool' = False, noloop: 'bool' = False, **kwargs) -> 'bytes | str | Awaitable[bytes | str]'
     |      Enables the tracking feature of the Redis server, that is used
     |      for server assisted client side caching.
     |
     |      ``on`` indicate for tracking on or tracking off. The default is on.
     |
     |      ``clientid`` send invalidation messages to the connection with
     |      the specified ID.
     |
     |      ``bcast`` enable tracking in broadcasting mode. In this mode
     |      invalidation messages are reported for all the prefixes
     |      specified, regardless of the keys requested by the connection.
     |
     |      ``optin``  when broadcasting is NOT active, normally don't track
     |      keys in read only commands, unless they are called immediately
     |      after a CLIENT CACHING yes command.
     |
     |      ``optout`` when broadcasting is NOT active, normally track keys in
     |      read only commands, unless they are called immediately after a
     |      CLIENT CACHING no command.
     |
     |      ``noloop`` don't send notifications about keys modified by this
     |      connection itself.
     |
     |      ``prefix``  for broadcasting, register a given key prefix, so that
     |      notifications will be provided only for keys starting with this string.
     |
     |      See https://redis.io/commands/client-tracking
     |
     |  client_trackinginfo(self, **kwargs) -> 'ClientTrackingInfoResponse | Awaitable[ClientTrackingInfoResponse]'
     |      Returns the information about the current client connection's
     |      use of the server assisted client side cache.
     |
     |      See https://redis.io/commands/client-trackinginfo
     |
     |  client_unblock(self, client_id: 'int', error: 'bool' = False, **kwargs) -> 'bool | Awaitable[bool]'
     |      Unblocks a connection by its client id.
     |      If ``error`` is True, unblocks the client with a special error message.
     |      If ``error`` is False (default), the client is unblocked using the
     |      regular timeout mechanism.
     |
     |      For more information, see https://redis.io/commands/client-unblock
     |
     |  client_unpause(self, **kwargs) -> 'bytes | str | Awaitable[bytes | str]'
     |      Unpause all redis clients
     |
     |      For more information, see https://redis.io/commands/client-unpause
     |
     |  command(self, **kwargs) -> 'dict[str, dict[str, Any]] | Awaitable[dict[str, dict[str, Any]]]'
     |      Returns dict reply of details about all Redis commands.
     |
     |      For more information, see https://redis.io/commands/command
     |
     |  command_count(self, **kwargs) -> 'int | Awaitable[int]'
     |
     |  command_docs(self, *args)
     |      This function throws a NotImplementedError since it is intentionally
     |      not supported.
     |
     |  command_getkeysandflags(self, *args: 'str') -> 'CommandGetKeysAndFlagsResponse | Awaitable[CommandGetKeysAndFlagsResponse]'
     |      Returns array of keys from a full Redis command and their usage flags.
     |
     |      For more information, see https://redis.io/commands/command-getkeysandflags
     |
     |  command_info(self, **kwargs) -> 'None'
     |
     |  command_list(self, module: 'str | None' = None, category: 'str | None' = None, pattern: 'str | None' = None) -> 'list[bytes | str] | Awaitable[list[bytes | str]]'
     |      Return an array of the server's command names.
     |      You can use one of the following filters:
     |      ``module``: get the commands that belong to the module
     |      ``category``: get the commands in the ACL category
     |      ``pattern``: get the commands that match the given pattern
     |
     |      For more information, see https://redis.io/commands/command-list/
     |
     |  config_get(self, pattern: 'PatternT' = '*', *args: 'PatternT', **kwargs) -> 'dict[str | None, str | None] | Awaitable[dict[str | None, str | None]]'
     |      Return a dictionary of configuration based on the ``pattern``
     |
     |      For more information, see https://redis.io/commands/config-get
     |
     |  config_resetstat(self, **kwargs) -> 'bool | Awaitable[bool]'
     |      Reset runtime statistics
     |
     |      For more information, see https://redis.io/commands/config-resetstat
     |
     |  config_rewrite(self, **kwargs) -> 'bytes | str | Awaitable[bytes | str]'
     |      Rewrite config file with the minimal change to reflect running config.
     |
     |      For more information, see https://redis.io/commands/config-rewrite
     |
     |  config_set(self, name: 'KeyT', value: 'EncodableT', *args: 'Union[KeyT, EncodableT]', **kwargs) -> 'bool | Awaitable[bool]'
     |      Set config item ``name`` with ``value``
     |
     |      For more information, see https://redis.io/commands/config-set
     |
     |  dbsize(self, **kwargs) -> 'int | Awaitable[int]'
     |      Returns the number of keys in the current database
     |
     |      For more information, see https://redis.io/commands/dbsize
     |
     |  debug_object(self, key: 'KeyT', **kwargs) -> 'dict[str, str | int] | bytes | str | Awaitable[dict[str, str | int] | bytes | str]'
     |      Returns version specific meta information about a given key
     |
     |      For more information, see https://redis.io/commands/debug-object
     |
     |  debug_segfault(self, **kwargs) -> 'None'
     |
     |  echo(self, value: 'EncodableT', **kwargs) -> 'bytes | str | Awaitable[bytes | str]'
     |      Echo the string back from the server
     |
     |      For more information, see https://redis.io/commands/echo
     |
     |  failover(self)
     |      This function throws a NotImplementedError since it is intentionally
     |      not supported.
     |
     |  flushall(self, asynchronous: 'bool' = False, **kwargs) -> 'bool | Awaitable[bool]'
     |      Delete all keys in all databases on the current host.
     |
     |      ``asynchronous`` indicates whether the operation is
     |      executed asynchronously by the server.
     |
     |      For more information, see https://redis.io/commands/flushall
     |
     |  flushdb(self, asynchronous: 'bool' = False, **kwargs) -> 'bool | Awaitable[bool]'
     |      Delete all keys in the current database.
     |
     |      ``asynchronous`` indicates whether the operation is
     |      executed asynchronously by the server.
     |
     |      For more information, see https://redis.io/commands/flushdb
     |
     |  hello(self)
     |      This function throws a NotImplementedError since it is intentionally
     |      not supported.
     |
     |  info(self, section: 'Optional[str]' = None, *args: 'str', **kwargs) -> 'dict[str, Any] | Awaitable[dict[str, Any]]'
     |      Returns a dictionary containing information about the Redis server
     |
     |      The ``section`` option can be used to select a specific section
     |      of information
     |
     |      The section option is not supported by older versions of Redis Server,
     |      and will generate ResponseError
     |
     |      For more information, see https://redis.io/commands/info
     |
     |  lastsave(self, **kwargs) -> 'datetime.datetime | Awaitable[datetime.datetime]'
     |      Return a Python datetime object representing the last time the
     |      Redis database was saved to disk
     |
     |      For more information, see https://redis.io/commands/lastsave
     |
     |  latency_doctor(self)
     |      Raise a NotImplementedError, as the client will not support LATENCY DOCTOR.
     |      This function is best used within the redis-cli.
     |
     |      For more information, see https://redis.io/commands/latency-doctor
     |
     |  latency_graph(self)
     |      Raise a NotImplementedError, as the client will not support LATENCY GRAPH.
     |      This function is best used within the redis-cli.
     |
     |      For more information, see https://redis.io/commands/latency-graph.
     |
     |  latency_histogram(self, *args)
     |      This function throws a NotImplementedError since it is intentionally
     |      not supported.
     |
     |  latency_history(self, event: 'str') -> 'list[list[int]] | Awaitable[list[list[int]]]'
     |      Returns the raw data of the ``event``'s latency spikes time series.
     |
     |      For more information, see https://redis.io/commands/latency-history
     |
     |  latency_latest(self) -> 'list[list[bytes | str | int]] | Awaitable[list[list[bytes | str | int]]]'
     |      Reports the latest latency events logged.
     |
     |      For more information, see https://redis.io/commands/latency-latest
     |
     |  latency_reset(self, *events: 'str') -> 'int | Awaitable[int]'
     |      Resets the latency spikes time series of all, or only some, events.
     |
     |      For more information, see https://redis.io/commands/latency-reset
     |
     |  lolwut(self, *version_numbers: 'Union[str, float]', **kwargs) -> 'bytes | str | Awaitable[bytes | str]'
     |      Get the Redis version and a piece of generative computer art
     |
     |      See: https://redis.io/commands/lolwut
     |
     |  memory_doctor(self, **kwargs) -> 'None'
     |
     |  memory_help(self, **kwargs) -> 'None'
     |
     |  memory_malloc_stats(self, **kwargs) -> 'bytes | str | Awaitable[bytes | str]'
     |      Return an internal statistics report from the memory allocator.
     |
     |      See: https://redis.io/commands/memory-malloc-stats
     |
     |  memory_purge(self, **kwargs) -> 'bool | Awaitable[bool]'
     |      Attempts to purge dirty pages for reclamation by allocator
     |
     |      For more information, see https://redis.io/commands/memory-purge
     |
     |  memory_stats(self, **kwargs) -> 'dict[str, Any] | Awaitable[dict[str, Any]]'
     |      Return a dictionary of memory stats
     |
     |      For more information, see https://redis.io/commands/memory-stats
     |
     |  memory_usage(self, key: 'KeyT', samples: 'int | None' = None, **kwargs) -> 'int | None | Awaitable[int | None]'
     |      Return the total memory usage for key, its value and associated
     |      administrative overheads.
     |
     |      For nested data structures, ``samples`` is the number of elements to
     |      sample. If left unspecified, the server's default is 5. Use 0 to sample
     |      all elements.
     |
     |      For more information, see https://redis.io/commands/memory-usage
     |
     |  migrate(self, host: 'str', port: 'int', keys: 'KeysT', destination_db: 'int', timeout: 'int', copy: 'bool' = False, replace: 'bool' = False, auth: 'str | None' = None, **kwargs) -> 'bytes | str | Awaitable[bytes | str]'
     |      Migrate 1 or more keys from the current Redis server to a different
     |      server specified by the ``host``, ``port`` and ``destination_db``.
     |
     |      The ``timeout``, specified in milliseconds, indicates the maximum
     |      time the connection between the two servers can be idle before the
     |      command is interrupted.
     |
     |      If ``copy`` is True, the specified ``keys`` are NOT deleted from
     |      the source server.
     |
     |      If ``replace`` is True, this operation will overwrite the keys
     |      on the destination server if they exist.
     |
     |      If ``auth`` is specified, authenticate to the destination server with
     |      the password provided.
     |
     |      For more information, see https://redis.io/commands/migrate
     |
     |  object(self, infotype: 'str', key: 'KeyT', **kwargs) -> 'Any | Awaitable[Any]'
     |      Return the encoding, idletime, or refcount about the key
     |
     |  ping(self, **kwargs) -> 'Union[Awaitable[bool], bool]'
     |      Ping the Redis server to test connectivity.
     |
     |      Sends a PING command to the Redis server and returns True if the server
     |      responds with "PONG".
     |
     |      This command is useful for:
     |      - Testing whether a connection is still alive
     |      - Verifying the server's ability to serve data
     |
     |      For more information on the underlying ping command see https://redis.io/commands/ping
     |
     |  psync(self, replicationid: 'str', offset: 'int') -> 'bytes | Awaitable[bytes]'
     |      Initiates a replication stream from the master.
     |      Newer version for `sync`.
     |
     |      For more information, see https://redis.io/commands/sync
     |
     |  quit(self, **kwargs) -> 'bool | Awaitable[bool]'
     |      Ask the server to close the connection.
     |
     |      For more information, see https://redis.io/commands/quit
     |
     |  reset(self) -> 'bytes | str | Awaitable[bytes | str]'
     |      Perform a full reset on the connection's server-side context.
     |
     |      See: https://redis.io/commands/reset
     |
     |  role(self) -> 'list[Any] | Awaitable[list[Any]]'
     |      Provide information on the role of a Redis instance in
     |      the context of replication, by returning if the instance
     |      is currently a master, slave, or sentinel.
     |
     |      For more information, see https://redis.io/commands/role
     |
     |  save(self, **kwargs) -> 'bool | Awaitable[bool]'
     |      Tell the Redis server to save its data to disk,
     |      blocking until the save is complete
     |
     |      For more information, see https://redis.io/commands/save
     |
     |  select(self, index: 'int', **kwargs) -> 'bool | Awaitable[bool]'
     |      Select the Redis logical database at index.
     |
     |      See: https://redis.io/commands/select
     |
     |  shutdown(self, save: 'bool' = False, nosave: 'bool' = False, now: 'bool' = False, force: 'bool' = False, abort: 'bool' = False, **kwargs) -> 'None'
     |      Shutdown the Redis server.  If Redis has persistence configured,
     |      data will be flushed before shutdown.
     |      It is possible to specify modifiers to alter the behavior of the command:
     |      ``save`` will force a DB saving operation even if no save points are configured.
     |      ``nosave`` will prevent a DB saving operation even if one or more save points
     |      are configured.
     |      ``now`` skips waiting for lagging replicas, i.e. it bypasses the first step in
     |      the shutdown sequence.
     |      ``force`` ignores any errors that would normally prevent the server from exiting
     |      ``abort`` cancels an ongoing shutdown and cannot be combined with other flags.
     |
     |      For more information, see https://redis.io/commands/shutdown
     |
     |  slowlog_get(self, num: 'int | None' = None, **kwargs) -> 'list[dict[str, Any]] | Awaitable[list[dict[str, Any]]]'
     |      Get the entries from the slowlog. If ``num`` is specified, get the
     |      most recent ``num`` items.
     |
     |      For more information, see https://redis.io/commands/slowlog-get
     |
     |  slowlog_len(self, **kwargs) -> 'int | Awaitable[int]'
     |      Get the number of items in the slowlog
     |
     |      For more information, see https://redis.io/commands/slowlog-len
     |
     |  slowlog_reset(self, **kwargs) -> 'bool | Awaitable[bool]'
     |      Remove all items in the slowlog
     |
     |      For more information, see https://redis.io/commands/slowlog-reset
     |
     |  sync(self) -> 'bytes | Awaitable[bytes]'
     |      Initiates a replication stream from the master.
     |
     |      For more information, see https://redis.io/commands/sync
     |
     |  time(self, **kwargs) -> 'tuple[int, int] | Awaitable[tuple[int, int]]'
     |      Returns the server time as a 2-item tuple of ints:
     |      (seconds since epoch, microseconds into this second).
     |
     |      For more information, see https://redis.io/commands/time
     |
     |  wait(self, num_replicas: 'int', timeout: 'int', **kwargs) -> 'int | Awaitable[int]'
     |      Redis synchronous replication
     |      That returns the number of replicas that processed the query when
     |      we finally have at least ``num_replicas``, or when the ``timeout`` was
     |      reached.
     |
     |      For more information, see https://redis.io/commands/wait
     |
     |  waitaof(self, num_local: 'int', num_replicas: 'int', timeout: 'int', **kwargs) -> 'list[int] | Awaitable[list[int]]'
     |      This command blocks the current client until all previous write
     |      commands by that client are acknowledged as having been fsynced
     |      to the AOF of the local Redis and/or at least the specified number
     |      of replicas.
     |
     |      For more information, see https://redis.io/commands/waitaof
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from redis.commands.core.ACLCommands:
     |
     |  acl_cat(self, category: 'str | None' = None, **kwargs) -> 'list[bytes | str] | Awaitable[list[bytes | str]]'
     |      Returns a list of categories or commands within a category.
     |
     |      If ``category`` is not supplied, returns a list of all categories.
     |      If ``category`` is supplied, returns a list of all commands within
     |      that category.
     |
     |      For more information, see https://redis.io/commands/acl-cat
     |
     |  acl_deluser(self, *username: 'str', **kwargs) -> 'int | Awaitable[int]'
     |      Delete the ACL for the specified ``username``\s
     |
     |      For more information, see https://redis.io/commands/acl-deluser
     |
     |  acl_dryrun(self, username: 'str', *args: 'EncodableT', **kwargs) -> 'bytes | str | Awaitable[bytes | str]'
     |      Simulate the execution of a given command by a given ``username``.
     |
     |      For more information, see https://redis.io/commands/acl-dryrun
     |
     |  acl_genpass(self, bits: 'int | None' = None, **kwargs) -> 'bytes | str | Awaitable[bytes | str]'
     |      Generate a random password value.
     |      If ``bits`` is supplied then use this number of bits, rounded to
     |      the next multiple of 4.
     |      See: https://redis.io/commands/acl-genpass
     |
     |  acl_getuser(self, username: 'str', **kwargs) -> 'ACLGetUserData | Awaitable[ACLGetUserData]'
     |      Get the ACL details for the specified ``username``.
     |
     |      If ``username`` does not exist, return None
     |
     |      For more information, see https://redis.io/commands/acl-getuser
     |
     |  acl_help(self, **kwargs) -> 'list[bytes | str] | Awaitable[list[bytes | str]]'
     |      The ACL HELP command returns helpful text describing
     |      the different subcommands.
     |
     |      For more information, see https://redis.io/commands/acl-help
     |
     |  acl_list(self, **kwargs) -> 'list[bytes | str] | Awaitable[list[bytes | str]]'
     |      Return a list of all ACLs on the server
     |
     |      For more information, see https://redis.io/commands/acl-list
     |
     |  acl_load(self, **kwargs) -> 'bool | Awaitable[bool]'
     |      Load ACL rules from the configured ``aclfile``.
     |
     |      Note that the server must be configured with the ``aclfile``
     |      directive to be able to load ACL rules from an aclfile.
     |
     |      For more information, see https://redis.io/commands/acl-load
     |
     |  acl_log(self, count: 'int | None' = None, **kwargs) -> 'ACLLogData | Awaitable[ACLLogData]'
     |      Get ACL logs as a list.
     |      :param int count: Get logs[0:count].
     |      :rtype: List.
     |
     |      For more information, see https://redis.io/commands/acl-log
     |
     |  acl_log_reset(self, **kwargs) -> 'bool | Awaitable[bool]'
     |      Reset ACL logs.
     |      :rtype: Boolean.
     |
     |      For more information, see https://redis.io/commands/acl-log
     |
     |  acl_save(self, **kwargs) -> 'bool | Awaitable[bool]'
     |      Save ACL rules to the configured ``aclfile``.
     |
     |      Note that the server must be configured with the ``aclfile``
     |      directive to be able to save ACL rules to an aclfile.
     |
     |      For more information, see https://redis.io/commands/acl-save
     |
     |  acl_setuser(self, username: 'str', enabled: 'bool' = False, nopass: 'bool' = False, passwords: 'str | Iterable[str] | None' = None, hashed_passwords: 'str | Iterable[str] | None' = None, categories: 'Iterable[str] | None' = None, commands: 'Iterable[str] | None' = None, keys: 'Iterable[KeyT] | None' = None, channels: 'Iterable[ChannelT] | None' = None, selectors: 'Iterable[Tuple[str, KeyT]] | None' = None, reset: 'bool' = False, reset_keys: 'bool' = False, reset_channels: 'bool' = False, reset_passwords: 'bool' = False, **kwargs) -> 'bool | Awaitable[bool]'
     |      Create or update an ACL user.
     |
     |      Create or update the ACL for `username`. If the user already exists,
     |      the existing ACL is completely overwritten and replaced with the
     |      specified values.
     |
     |      For more information, see https://redis.io/commands/acl-setuser
     |
     |      Args:
     |          username: The name of the user whose ACL is to be created or updated.
     |          enabled: Indicates whether the user should be allowed to authenticate.
     |                   Defaults to `False`.
     |          nopass: Indicates whether the user can authenticate without a password.
     |                  This cannot be `True` if `passwords` are also specified.
     |          passwords: A list of plain text passwords to add to or remove from the user.
     |                     Each password must be prefixed with a '+' to add or a '-' to
     |                     remove. For convenience, a single prefixed string can be used
     |                     when adding or removing a single password.
     |          hashed_passwords: A list of SHA-256 hashed passwords to add to or remove
     |                            from the user. Each hashed password must be prefixed with
     |                            a '+' to add or a '-' to remove. For convenience, a single
     |                            prefixed string can be used when adding or removing a
     |                            single password.
     |          categories: A list of strings representing category permissions. Each string
     |                      must be prefixed with either a '+' to add the category
     |                      permission or a '-' to remove the category permission.
     |          commands: A list of strings representing command permissions. Each string
     |                    must be prefixed with either a '+' to add the command permission
     |                    or a '-' to remove the command permission.
     |          keys: A list of key patterns to grant the user access to. Key patterns allow
     |                ``'*'`` to support wildcard matching. For example, ``'*'`` grants
     |                access to all keys while ``'cache:*'`` grants access to all keys that
     |                are prefixed with ``cache:``.
     |                `keys` should not be prefixed with a ``'~'``.
     |          reset: Indicates whether the user should be fully reset prior to applying
     |                 the new ACL. Setting this to `True` will remove all existing
     |                 passwords, flags, and privileges from the user and then apply the
     |                 specified rules. If `False`, the user's existing passwords, flags,
     |                 and privileges will be kept and any new specified rules will be
     |                 applied on top.
     |          reset_keys: Indicates whether the user's key permissions should be reset
     |                      prior to applying any new key permissions specified in `keys`.
     |                      If `False`, the user's existing key permissions will be kept and
     |                      any new specified key permissions will be applied on top.
     |          reset_channels: Indicates whether the user's channel permissions should be
     |                          reset prior to applying any new channel permissions
     |                          specified in `channels`. If `False`, the user's existing
     |                          channel permissions will be kept and any new specified
     |                          channel permissions will be applied on top.
     |          reset_passwords: Indicates whether to remove all existing passwords and the
     |                           `nopass` flag from the user prior to applying any new
     |                           passwords specified in `passwords` or `hashed_passwords`.
     |                           If `False`, the user's existing passwords and `nopass`
     |                           status will be kept and any new specified passwords or
     |                           hashed passwords will be applied on top.
     |
     |  acl_users(self, **kwargs) -> 'list[bytes | str] | Awaitable[list[bytes | str]]'
     |      Returns a list of all registered users on the server.
     |
     |      For more information, see https://redis.io/commands/acl-users
     |
     |  acl_whoami(self, **kwargs) -> 'bytes | str | Awaitable[bytes | str]'
     |      Get the username for the current connection
     |
     |      For more information, see https://redis.io/commands/acl-whoami
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from redis.commands.core.PubSubCommands:
     |
     |  publish(self, channel: 'ChannelT', message: 'EncodableT', **kwargs) -> 'int | Awaitable[int]'
     |      Publish ``message`` on ``channel``.
     |      Returns the number of subscribers the message was delivered to.
     |
     |      For more information, see https://redis.io/commands/publish
     |
     |  pubsub_channels(self, pattern: 'PatternT' = '*', **kwargs) -> 'list[bytes | str] | Awaitable[list[bytes | str]]'
     |      Return a list of channels that have at least one subscriber
     |
     |      For more information, see https://redis.io/commands/pubsub-channels
     |
     |  pubsub_numpat(self, **kwargs) -> 'int | Awaitable[int]'
     |      Returns the number of subscriptions to patterns
     |
     |      For more information, see https://redis.io/commands/pubsub-numpat
     |
     |  pubsub_numsub(self, *args: 'ChannelT', **kwargs) -> 'list[tuple[bytes | str, int]] | Awaitable[list[tuple[bytes | str, int]]]'
     |      Return a list of (channel, number of subscribers) tuples
     |      for each channel given in ``*args``
     |
     |      For more information, see https://redis.io/commands/pubsub-numsub
     |
     |  pubsub_shardchannels(self, pattern: 'PatternT' = '*', **kwargs) -> 'list[bytes | str] | Awaitable[list[bytes | str]]'
     |      Return a list of shard_channels that have at least one subscriber
     |
     |      For more information, see https://redis.io/commands/pubsub-shardchannels
     |
     |  pubsub_shardnumsub(self, *args: 'ChannelT', **kwargs) -> 'list[tuple[bytes | str, int]] | Awaitable[list[tuple[bytes | str, int]]]'
     |      Return a list of (shard_channel, number of subscribers) tuples
     |      for each channel given in ``*args``
     |
     |      For more information, see https://redis.io/commands/pubsub-shardnumsub
     |
     |  spublish(self, shard_channel: 'ChannelT', message: 'EncodableT') -> 'int | Awaitable[int]'
     |      Posts a message to the given shard channel.
     |      Returns the number of clients that received the message
     |
     |      For more information, see https://redis.io/commands/spublish
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from redis.commands.cluster.ClusterDataAccessCommands:
     |
     |  scan_iter(self, match: 'PatternT | None' = None, count: 'int | None' = None, _type: 'str | None' = None, **kwargs) -> 'Iterator'
     |      Make an iterator using the SCAN command so that the client doesn't
     |      need to remember the cursor position.
     |
     |      ``match`` allows for filtering the keys by pattern
     |
     |      ``count`` provides a hint to Redis about the number of keys to
     |          return per batch.
     |
     |      ``_type`` filters the returned values by a particular Redis type.
     |          Stock Redis instances allow for the following types:
     |          HASH, LIST, SET, STREAM, STRING, ZSET
     |          Additionally, Redis modules can expose other types as well.
     |
     |  stralgo(self, algo: "Literal['LCS']", value1: 'KeyT', value2: 'KeyT', specific_argument: "Literal['strings'] | Literal['keys']" = 'strings', len: 'bool' = False, idx: 'bool' = False, minmatchlen: 'int | None' = None, withmatchlen: 'bool' = False, **kwargs) -> 'StralgoResponse | Awaitable[StralgoResponse]'
     |      Implements complex algorithms that operate on strings.
     |      Right now the only algorithm implemented is the LCS algorithm
     |      (longest common substring). However new algorithms could be
     |      implemented in the future.
     |
     |      ``algo`` Right now must be LCS
     |      ``value1`` and ``value2`` Can be two strings or two keys
     |      ``specific_argument`` Specifying if the arguments to the algorithm
     |      will be keys or strings. strings is the default.
     |      ``len`` Returns just the len of the match.
     |      ``idx`` Returns the match positions in each string.
     |      ``minmatchlen`` Restrict the list of matches to the ones of a given
     |      minimal length. Can be provided only when ``idx`` set to True.
     |      ``withmatchlen`` Returns the matches with the len of the match.
     |      Can be provided only when ``idx`` set to True.
     |
     |      For more information see https://redis.io/commands/stralgo
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from redis.commands.core.BasicKeyCommands:
     |
     |  __contains__ = exists(self, *names: 'KeyT') -> 'int | Awaitable[int]'
     |      Returns the number of ``names`` that exist
     |
     |      For more information, see https://redis.io/commands/exists
     |
     |  __delitem__(self, name: 'KeyT')
     |
     |  __getitem__(self, name: 'KeyT')
     |      Return the value at key ``name``, raises a KeyError if the key
     |      doesn't exist.
     |
     |  __setitem__(self, name: 'KeyT', value: 'EncodableT')
     |
     |  append(self, key: 'KeyT', value: 'EncodableT') -> 'int | Awaitable[int]'
     |      Appends the string ``value`` to the value at ``key``. If ``key``
     |      doesn't already exist, create it with a value of ``value``.
     |      Returns the new length of the value at ``key``.
     |
     |      For more information, see https://redis.io/commands/append
     |
     |  bitcount(self, key: 'KeyT', start: 'int | None' = None, end: 'int | None' = None, mode: 'str | None' = None) -> 'int | Awaitable[int]'
     |      Returns the count of set bits in the value of ``key``.  Optional
     |      ``start`` and ``end`` parameters indicate which bytes to consider
     |
     |      For more information, see https://redis.io/commands/bitcount
     |
     |  bitfield(self: "Union['redis.client.Redis', 'redis.asyncio.client.Redis']", key: 'KeyT', default_overflow: 'str | None' = None) -> 'BitFieldOperation'
     |      Return a BitFieldOperation instance to conveniently construct one or
     |      more bitfield operations on ``key``.
     |
     |      For more information, see https://redis.io/commands/bitfield
     |
     |  bitfield_ro(self: "Union['redis.client.Redis', 'redis.asyncio.client.Redis']", key: 'KeyT', encoding: 'str', offset: 'BitfieldOffsetT', items: 'list[tuple[str, BitfieldOffsetT]] | None' = None) -> 'list[int] | Awaitable[list[int]]'
     |      Return an array of the specified bitfield values
     |      where the first value is found using ``encoding`` and ``offset``
     |      parameters and remaining values are result of corresponding
     |      encoding/offset pairs in optional list ``items``
     |      Read-only variant of the BITFIELD command.
     |
     |      For more information, see https://redis.io/commands/bitfield_ro
     |
     |  bitop(self, operation: 'str', dest: 'KeyT', *keys: 'KeyT') -> 'int | Awaitable[int]'
     |      Perform a bitwise operation using ``operation`` between ``keys`` and
     |      store the result in ``dest``.
     |
     |      For more information, see https://redis.io/commands/bitop
     |
     |  bitpos(self, key: 'KeyT', bit: 'int', start: 'int | None' = None, end: 'int | None' = None, mode: 'str | None' = None) -> 'int | Awaitable[int]'
     |      Return the position of the first bit set to 1 or 0 in a string.
     |      ``start`` and ``end`` defines search range. The range is interpreted
     |      as a range of bytes and not a range of bits, so start=0 and end=2
     |      means to look at the first three bytes.
     |
     |      For more information, see https://redis.io/commands/bitpos
     |
     |  blmove(self, first_list: 'str', second_list: 'str', timeout: 'int', src: 'str' = 'LEFT', dest: 'str' = 'RIGHT') -> 'bytes | str | None | Awaitable[bytes | str | None]'
     |      Blocking version of lmove.
     |
     |      For more information, see https://redis.io/commands/blmove
     |
     |  blmovem(self, first_list: 'str', second_list: 'str', timeout: 'float', src: 'str' = 'LEFT', dest: 'str' = 'RIGHT', count: 'int | None' = None, mode: "Literal['COUNT', 'EXACTLY'] | None" = None, ordering: "Literal['OBO', 'BULK'] | None" = None) -> 'list[bytes | str] | None | Awaitable[list[bytes | str] | None]'
     |      Blocking version of lmovem.
     |
     |      Blocks until elements are available to move or ``timeout`` (in seconds)
     |      is reached; a ``timeout`` of ``0`` blocks indefinitely. With ``COUNT``
     |      the command unblocks once at least one element is available and moves
     |      ``min(count, available)``; with ``EXACTLY`` it blocks until the source
     |      holds at least ``count`` elements, then moves exactly ``count``
     |      atomically. On timeout ``None`` is returned and nothing is moved.
     |
     |      As with ``lmovem``, ``ordering`` (OBO or BULK) is required whenever
     |      ``count`` is given.
     |
     |      For more information, see https://redis.io/commands/blmovem
     |
     |  copy(self, source: 'str', destination: 'str', destination_db: 'str | None' = None, replace: 'bool' = False) -> 'bool | Awaitable[bool]'
     |      Copy the value stored in the ``source`` key to the ``destination`` key.
     |
     |      ``destination_db`` an alternative destination database. By default,
     |      the ``destination`` key is created in the source Redis database.
     |
     |      ``replace`` whether the ``destination`` key should be removed before
     |      copying the value to it. By default, the value is not copied if
     |      the ``destination`` key already exists.
     |
     |      For more information, see https://redis.io/commands/copy
     |
     |  decr = decrby(self, name: 'KeyT', amount: 'int' = 1) -> 'int | Awaitable[int]'
     |
     |  decrby(self, name: 'KeyT', amount: 'int' = 1) -> 'int | Awaitable[int]'
     |      Decrements the value of ``key`` by ``amount``.  If no key exists,
     |      the value will be initialized as 0 - ``amount``
     |
     |      For more information, see https://redis.io/commands/decrby
     |
     |  delex(self, name: 'KeyT', ifeq: 'bytes | str | None' = None, ifne: 'bytes | str | None' = None, ifdeq: 'str | None' = None, ifdne: 'str | None' = None) -> 'int | Awaitable[int]'
     |      Conditionally removes the specified key.
     |
     |      Warning:
     |      **Experimental** since 7.1.
     |      This API may change or be removed without notice.
     |      The API may change based on feedback.
     |
     |      Arguments:
     |          name: KeyT - the key to delete
     |          ifeq match-valu: Optional[Union[bytes, str]] - Delete the key only if its value is equal to match-value
     |          ifne match-value: Optional[Union[bytes, str]] - Delete the key only if its value is not equal to match-value
     |          ifdeq match-digest: Optional[str] - Delete the key only if the digest of its value is equal to match-digest
     |          ifdne match-digest: Optional[str] - Delete the key only if the digest of its value is not equal to match-digest
     |
     |      Returns:
     |          int: 1 if the key was deleted, 0 otherwise.
     |      Raises:
     |          redis.exceptions.ResponseError: if key exists but is not a string
     |                                          and a condition is specified.
     |          ValueError: if more than one condition is provided.
     |
     |
     |      Requires Redis 8.4 or greater.
     |      For more information, see https://redis.io/commands/delex
     |
     |  digest(self, name: 'KeyT') -> 'str | bytes | None | Awaitable[str | bytes | None]'
     |      Return the digest of the value stored at the specified key.
     |
     |      Warning:
     |      **Experimental** since 7.1.
     |      This API may change or be removed without notice.
     |      The API may change based on feedback.
     |
     |      Arguments:
     |        - name: KeyT - the key to get the digest of
     |
     |      Returns:
     |        - None if the key does not exist
     |        - (bulk string) the XXH3 digest of the value as a hex string
     |      Raises:
     |        - ResponseError if key exists but is not a string
     |
     |
     |      Requires Redis 8.4 or greater.
     |      For more information, see https://redis.io/commands/digest
     |
     |  digest_local(self, value: 'bytes | str') -> 'bytes | str'
     |      Compute the hexadecimal digest of the value locally, without sending it to the server.
     |
     |      This is useful for conditional operations like IFDEQ/IFDNE where you need to
     |      compute the digest client-side before sending a command.
     |
     |      Warning:
     |      **Experimental** - This API may change or be removed without notice.
     |
     |      Arguments:
     |        - value: Union[bytes, str] - the value to compute the digest of.
     |          If a string is provided, it will be encoded using UTF-8 before hashing,
     |          which matches Redis's default encoding behavior.
     |
     |      Returns:
     |        - (str | bytes) the XXH3 digest of the value as a hex string (16 hex characters).
     |          Returns bytes if decode_responses is False, otherwise returns str.
     |
     |      For more information, see https://redis.io/commands/digest
     |
     |  dump(self, name: 'KeyT') -> 'bytes | None | Awaitable[bytes | None]'
     |      Return a serialized version of the value stored at the specified key.
     |      If key does not exist a nil bulk reply is returned.
     |
     |      For more information, see https://redis.io/commands/dump
     |
     |  expire(self, name: 'KeyT', time: 'ExpiryT', nx: 'bool' = False, xx: 'bool' = False, gt: 'bool' = False, lt: 'bool' = False) -> 'bool | Awaitable[bool]'
     |      Set an expire flag on key ``name`` for ``time`` seconds with given
     |      ``option``. ``time`` can be represented by an integer or a Python timedelta
     |      object.
     |
     |      Valid options are:
     |          NX -> Set expiry only when the key has no expiry
     |          XX -> Set expiry only when the key has an existing expiry
     |          GT -> Set expiry only when the new expiry is greater than current one
     |          LT -> Set expiry only when the new expiry is less than current one
     |
     |      For more information, see https://redis.io/commands/expire
     |
     |  expireat(self, name: 'KeyT', when: 'AbsExpiryT', nx: 'bool' = False, xx: 'bool' = False, gt: 'bool' = False, lt: 'bool' = False) -> 'bool | Awaitable[bool]'
     |      Set an expire flag on key ``name`` with given ``option``. ``when``
     |      can be represented as an integer indicating unix time or a Python
     |      datetime object.
     |
     |      Valid options are:
     |          -> NX -- Set expiry only when the key has no expiry
     |          -> XX -- Set expiry only when the key has an existing expiry
     |          -> GT -- Set expiry only when the new expiry is greater than current one
     |          -> LT -- Set expiry only when the new expiry is less than current one
     |
     |      For more information, see https://redis.io/commands/expireat
     |
     |  expiretime(self, key: 'str') -> 'int | Awaitable[int]'
     |      Returns the absolute Unix timestamp (since January 1, 1970) in seconds
     |      at which the given key will expire.
     |
     |      For more information, see https://redis.io/commands/expiretime
     |
     |  get(self, name: 'KeyT') -> 'bytes | str | None | Awaitable[bytes | str | None]'
     |      Return the value at key ``name``, or None if the key doesn't exist
     |
     |      For more information, see https://redis.io/commands/get
     |
     |  getbit(self, name: 'KeyT', offset: 'int') -> 'int | Awaitable[int]'
     |      Returns an integer indicating the value of ``offset`` in ``name``
     |
     |      For more information, see https://redis.io/commands/getbit
     |
     |  getdel(self, name: 'KeyT') -> 'bytes | str | None | Awaitable[bytes | str | None]'
     |      Get the value at key ``name`` and delete the key. This command
     |      is similar to GET, except for the fact that it also deletes
     |      the key on success (if and only if the key's value type
     |      is a string).
     |
     |      For more information, see https://redis.io/commands/getdel
     |
     |  getex(self, name: 'KeyT', ex: 'ExpiryT | None' = None, px: 'ExpiryT | None' = None, exat: 'AbsExpiryT | None' = None, pxat: 'AbsExpiryT | None' = None, persist: 'bool' = False) -> 'bytes | str | None | Awaitable[bytes | str | None]'
     |      Get the value of key and optionally set its expiration.
     |      GETEX is similar to GET, but is a write command with
     |      additional options. All time parameters can be given as
     |      datetime.timedelta or integers.
     |
     |      ``ex`` sets an expire flag on key ``name`` for ``ex`` seconds.
     |
     |      ``px`` sets an expire flag on key ``name`` for ``px`` milliseconds.
     |
     |      ``exat`` sets an expire flag on key ``name`` for ``ex`` seconds,
     |      specified in unix time.
     |
     |      ``pxat`` sets an expire flag on key ``name`` for ``ex`` milliseconds,
     |      specified in unix time.
     |
     |      ``persist`` remove the time to live associated with ``name``.
     |
     |      For more information, see https://redis.io/commands/getex
     |
     |  getrange(self, key: 'KeyT', start: 'int', end: 'int') -> 'bytes | str | Awaitable[bytes | str]'
     |      Returns the substring of the string value stored at ``key``,
     |      determined by the offsets ``start`` and ``end`` (both are inclusive)
     |
     |      For more information, see https://redis.io/commands/getrange
     |
     |  getset(self, name: 'KeyT', value: 'EncodableT') -> 'bytes | str | None | Awaitable[bytes | str | None]'
     |      Sets the value at key ``name`` to ``value``
     |      and returns the old value at key ``name`` atomically.
     |
     |      As per Redis 6.2, GETSET is considered deprecated.
     |      Please use SET with GET parameter in new code.
     |
     |      For more information, see https://redis.io/commands/getset
     |
     |  hrandfield(self, key: 'KeyT', count: 'int | None' = None, withvalues: 'bool' = False) -> 'HRandFieldResponse | Awaitable[HRandFieldResponse]'
     |      Return a random field from the hash value stored at key.
     |
     |      count: if the argument is positive, return an array of distinct fields.
     |      If called with a negative count, the behavior changes and the command
     |      is allowed to return the same field multiple times. In this case,
     |      the number of returned fields is the absolute value of the
     |      specified count.
     |      withvalues: The optional WITHVALUES modifier changes the reply so it
     |      includes the respective values of the randomly selected hash fields.
     |
     |      For more information, see https://redis.io/commands/hrandfield
     |
     |  incr = incrby(self, name: 'KeyT', amount: 'int' = 1) -> 'int | Awaitable[int]'
     |
     |  incrby(self, name: 'KeyT', amount: 'int' = 1) -> 'int | Awaitable[int]'
     |      Increments the value of ``key`` by ``amount``.  If no key exists,
     |      the value will be initialized as ``amount``
     |
     |      For more information, see https://redis.io/commands/incrby
     |
     |  incrbyfloat(self, name: 'KeyT', amount: 'float' = 1.0) -> 'float | Awaitable[float]'
     |      Increments the value at key ``name`` by floating ``amount``.
     |      If no key exists, the value will be initialized as ``amount``
     |
     |      For more information, see https://redis.io/commands/incrbyfloat
     |
     |  increx(self, name: 'KeyT', *, byfloat: 'EncodableT | None' = None, byint: 'EncodableT | None' = None, lbound: 'EncodableT | None' = None, ubound: 'EncodableT | None' = None, saturate: 'bool' = False, ex: 'ExpiryT | None' = None, px: 'ExpiryT | None' = None, exat: 'AbsExpiryT | None' = None, pxat: 'AbsExpiryT | None' = None, persist: 'bool' = False, enx: 'bool' = False) -> 'list[Number | bytes | str] | Awaitable[list[Number | bytes | str]]'
     |      Increment the numeric value at key ``name`` and return the new value
     |      and the actual increment.
     |
     |      ``byfloat`` increments a floating point value by the provided amount.
     |
     |      ``byint`` increments an integer value by the provided amount.
     |
     |      If neither ``byfloat`` nor ``byint`` is specified, the value is
     |      incremented by one.
     |
     |      ``lbound`` and ``ubound`` constrain the valid range of the result.
     |
     |      If ``saturate`` is True, out-of-bounds results are saturated to the
     |      specified bound, or to the type limit when no bound is specified.
     |      Otherwise, out-of-bounds results are rejected, leaving the value and
     |      TTL unchanged and returning the current value and zero as the actual
     |      increment.
     |
     |      ``enx`` applies the expiration only when the key does not already
     |      have an expiration, and requires ``ex``, ``px``, ``exat``, or ``pxat``.
     |
     |  keys(self, pattern: 'PatternT' = '*', **kwargs) -> 'list[bytes | str] | Awaitable[list[bytes | str]]'
     |      Returns a list of keys matching ``pattern``
     |
     |      For more information, see https://redis.io/commands/keys
     |
     |  lcs(self, key1: 'str', key2: 'str', len: 'bool | None' = False, idx: 'bool | None' = False, minmatchlen: 'int | None' = 0, withmatchlen: 'bool | None' = False) -> 'LCSCommandResponse | Awaitable[LCSCommandResponse]'
     |      Find the longest common subsequence between ``key1`` and ``key2``.
     |      If ``len`` is true the length of the match will be returned.
     |      If ``idx`` is true the match position in each strings will be returned.
     |      ``minmatchlen`` restrict the list of matches to the ones of
     |      the given ``minmatchlen``.
     |      If ``withmatchlen`` the length of the match also will be returned.
     |      For more information, see https://redis.io/commands/lcs
     |
     |  lmove(self, first_list: 'str', second_list: 'str', src: 'str' = 'LEFT', dest: 'str' = 'RIGHT') -> 'bytes | str | None | Awaitable[bytes | str | None]'
     |      Atomically returns and removes the first/last element of a list,
     |      pushing it as the first/last element on the destination list.
     |      Returns the element being popped and pushed.
     |
     |      For more information, see https://redis.io/commands/lmove
     |
     |  lmovem(self, first_list: 'str', second_list: 'str', src: 'str' = 'LEFT', dest: 'str' = 'RIGHT', count: 'int | None' = None, mode: "Literal['COUNT', 'EXACTLY'] | None" = None, ordering: "Literal['OBO', 'BULK'] | None" = None) -> 'list[bytes | str] | None | Awaitable[list[bytes | str] | None]'
     |      Atomically moves multiple elements from one end of the ``first_list``
     |      to one end of the ``second_list``, returning the moved elements in
     |      destination order.
     |
     |      ``src`` and ``dest`` are the ends to pop from / push to, either
     |      ``LEFT`` (head) or ``RIGHT`` (tail).
     |
     |      When ``count`` is given, ``mode`` selects how many elements to move:
     |      ``COUNT`` (the default) moves up to ``count`` elements, while
     |      ``EXACTLY`` moves exactly ``count`` elements or nothing at all. When
     |      ``count`` is not given a single element is moved.
     |
     |      ``ordering`` controls the order at the destination: ``OBO`` pushes each
     |      element as it is popped (reversing block order, stack semantics) while
     |      ``BULK`` preserves the original relative order (queue semantics). It is
     |      required whenever ``count`` is given.
     |
     |      Returns the array of moved elements, or ``None`` if nothing was moved.
     |
     |      For more information, see https://redis.io/commands/lmovem
     |
     |  mget(self, keys: 'KeysT', *args: 'EncodableT') -> 'list[bytes | str | None] | Awaitable[list[bytes | str | None]]'
     |      Returns a list of values ordered identically to ``keys``
     |
     |      ** Important ** When this method is used with Cluster clients, all keys
     |              must be in the same hash slot, otherwise a RedisClusterException
     |              will be raised.
     |
     |      For more information, see https://redis.io/commands/mget
     |
     |  move(self, name: 'KeyT', db: 'int') -> 'bool | Awaitable[bool]'
     |      Moves the key ``name`` to a different Redis database ``db``
     |
     |      For more information, see https://redis.io/commands/move
     |
     |  mset(self, mapping: 'Mapping[AnyKeyT, EncodableT]') -> 'bool | Awaitable[bool]'
     |      Sets key/values based on a mapping. Mapping is a dictionary of
     |      key/value pairs. Both keys and values should be strings or types that
     |      can be cast to a string via str().
     |
     |      ** Important ** When this method is used with Cluster clients, all keys
     |              must be in the same hash slot, otherwise a RedisClusterException
     |              will be raised.
     |
     |      For more information, see https://redis.io/commands/mset
     |
     |  msetex(self, mapping: 'Mapping[AnyKeyT, EncodableT]', data_persist_option: 'DataPersistOptions | None' = None, ex: 'ExpiryT | None' = None, px: 'ExpiryT | None' = None, exat: 'AbsExpiryT | None' = None, pxat: 'AbsExpiryT | None' = None, keepttl: 'bool' = False) -> 'int | Awaitable[int]'
     |      Sets key/values based on the provided ``mapping`` items.
     |
     |      ** Important ** When this method is used with Cluster clients, all keys
     |                      must be in the same hash slot, otherwise a RedisClusterException
     |                      will be raised.
     |
     |      ``mapping`` accepts a dict of key/value pairs that will be added to the database.
     |
     |      ``data_persist_option`` can be set to ``NX`` or ``XX`` to control the
     |          behavior of the command.
     |          ``NX`` will set the value for each provided key to each
     |              provided value only if all do not already exist.
     |          ``XX`` will set the value for each provided key to each
     |              provided value only if all already exist.
     |
     |      ``ex`` sets an expire flag on the keys in ``mapping`` for ``ex`` seconds.
     |
     |      ``px`` sets an expire flag on the keys in ``mapping`` for ``px`` milliseconds.
     |
     |      ``exat`` sets an expire flag on the keys in ``mapping`` for ``exat`` seconds,
     |          specified in unix time.
     |
     |      ``pxat`` sets an expire flag on the keys in ``mapping`` for ``pxat`` milliseconds,
     |          specified in unix time.
     |
     |      ``keepttl`` if True, retain the time to live associated with the keys.
     |
     |      Returns the number of fields that were added.
     |
     |      Available since Redis 8.4
     |      For more information, see https://redis.io/commands/msetex
     |
     |  msetnx(self, mapping: 'Mapping[AnyKeyT, EncodableT]') -> 'bool | Awaitable[bool]'
     |      Sets key/values based on a mapping if none of the keys are already set.
     |      Mapping is a dictionary of key/value pairs. Both keys and values
     |      should be strings or types that can be cast to a string via str().
     |      Returns a boolean indicating if the operation was successful.
     |
     |      ** Important ** When this method is used with Cluster clients, all keys
     |                      must be in the same hash slot, otherwise a RedisClusterException
     |                      will be raised.
     |
     |      For more information, see https://redis.io/commands/msetnx
     |
     |  persist(self, name: 'KeyT') -> 'bool | Awaitable[bool]'
     |      Removes an expiration on ``name``
     |
     |      For more information, see https://redis.io/commands/persist
     |
     |  pexpire(self, name: 'KeyT', time: 'ExpiryT', nx: 'bool' = False, xx: 'bool' = False, gt: 'bool' = False, lt: 'bool' = False) -> 'bool | Awaitable[bool]'
     |      Set an expire flag on key ``name`` for ``time`` milliseconds
     |      with given ``option``. ``time`` can be represented by an
     |      integer or a Python timedelta object.
     |
     |      Valid options are:
     |          NX -> Set expiry only when the key has no expiry
     |          XX -> Set expiry only when the key has an existing expiry
     |          GT -> Set expiry only when the new expiry is greater than current one
     |          LT -> Set expiry only when the new expiry is less than current one
     |
     |      For more information, see https://redis.io/commands/pexpire
     |
     |  pexpireat(self, name: 'KeyT', when: 'AbsExpiryT', nx: 'bool' = False, xx: 'bool' = False, gt: 'bool' = False, lt: 'bool' = False) -> 'bool | Awaitable[bool]'
     |      Set an expire flag on key ``name`` with given ``option``. ``when``
     |      can be represented as an integer representing unix time in
     |      milliseconds (unix time * 1000) or a Python datetime object.
     |
     |      Valid options are:
     |          NX -> Set expiry only when the key has no expiry
     |          XX -> Set expiry only when the key has an existing expiry
     |          GT -> Set expiry only when the new expiry is greater than current one
     |          LT -> Set expiry only when the new expiry is less than current one
     |
     |      For more information, see https://redis.io/commands/pexpireat
     |
     |  pexpiretime(self, key: 'str') -> 'int | Awaitable[int]'
     |      Returns the absolute Unix timestamp (since January 1, 1970) in milliseconds
     |      at which the given key will expire.
     |
     |      For more information, see https://redis.io/commands/pexpiretime
     |
     |  psetex(self, name: 'KeyT', time_ms: 'ExpiryT', value: 'EncodableT') -> 'bool | Awaitable[bool]'
     |      Set the value of key ``name`` to ``value`` that expires in ``time_ms``
     |      milliseconds. ``time_ms`` can be represented by an integer or a Python
     |      timedelta object
     |
     |      For more information, see https://redis.io/commands/psetex
     |
     |  pttl(self, name: 'KeyT') -> 'int | Awaitable[int]'
     |      Returns the number of milliseconds until the key ``name`` will expire
     |
     |      For more information, see https://redis.io/commands/pttl
     |
     |  randomkey(self, **kwargs) -> 'bytes | str | None | Awaitable[bytes | str | None]'
     |      Returns the name of a random key
     |
     |      For more information, see https://redis.io/commands/randomkey
     |
     |  rename(self, src: 'KeyT', dst: 'KeyT') -> 'bool | Awaitable[bool]'
     |      Rename key ``src`` to ``dst``
     |
     |      For more information, see https://redis.io/commands/rename
     |
     |  renamenx(self, src: 'KeyT', dst: 'KeyT') -> 'bool | Awaitable[bool]'
     |      Rename key ``src`` to ``dst`` if ``dst`` doesn't already exist
     |
     |      For more information, see https://redis.io/commands/renamenx
     |
     |  restore(self, name: 'KeyT', ttl: 'float', value: 'EncodableT', replace: 'bool' = False, absttl: 'bool' = False, idletime: 'int | None' = None, frequency: 'int | None' = None) -> 'bytes | str | Awaitable[bytes | str]'
     |      Create a key using the provided serialized value, previously obtained
     |      using DUMP.
     |
     |      ``replace`` allows an existing key on ``name`` to be overridden. If
     |      it's not specified an error is raised on collision.
     |
     |      ``absttl`` if True, specified ``ttl`` should represent an absolute Unix
     |      timestamp in milliseconds in which the key will expire. (Redis 5.0 or
     |      greater).
     |
     |      ``idletime`` Used for eviction, this is the number of seconds the
     |      key must be idle, prior to execution.
     |
     |      ``frequency`` Used for eviction, this is the frequency counter of
     |      the object stored at the key, prior to execution.
     |
     |      For more information, see https://redis.io/commands/restore
     |
     |  set(self, name: 'KeyT', value: 'EncodableT', ex: 'ExpiryT | None' = None, px: 'ExpiryT | None' = None, nx: 'bool' = False, xx: 'bool' = False, keepttl: 'bool' = False, get: 'bool' = False, exat: 'AbsExpiryT | None' = None, pxat: 'AbsExpiryT | None' = None, ifeq: 'bytes | str | None' = None, ifne: 'bytes | str | None' = None, ifdeq: 'str | None' = None, ifdne: 'str | None' = None) -> 'bool | str | bytes | None | Awaitable[bool | str | bytes | None]'
     |      Set the value at key ``name`` to ``value``
     |
     |      Warning:
     |      **Experimental** since 7.1.
     |      The usage of the arguments ``ifeq``, ``ifne``, ``ifdeq``, and ``ifdne``
     |      is experimental. The API or returned results when those parameters are used
     |      may change based on feedback.
     |
     |      ``ex`` sets an expire flag on key ``name`` for ``ex`` seconds.
     |
     |      ``px`` sets an expire flag on key ``name`` for ``px`` milliseconds.
     |
     |      ``nx`` if set to True, set the value at key ``name`` to ``value`` only
     |          if it does not exist.
     |
     |      ``xx`` if set to True, set the value at key ``name`` to ``value`` only
     |          if it already exists.
     |
     |      ``keepttl`` if True, retain the time to live associated with the key.
     |          (Available since Redis 6.0)
     |
     |      ``get`` if True, set the value at key ``name`` to ``value`` and return
     |          the old value stored at key, or None if the key did not exist.
     |          (Available since Redis 6.2)
     |
     |      ``exat`` sets an expire flag on key ``name`` for ``ex`` seconds,
     |          specified in unix time.
     |
     |      ``pxat`` sets an expire flag on key ``name`` for ``ex`` milliseconds,
     |          specified in unix time.
     |
     |      ``ifeq`` set the value at key ``name`` to ``value`` only if the current
     |          value exactly matches the argument.
     |          If key doesn’t exist - it won’t be created.
     |          (Requires Redis 8.4 or greater)
     |
     |      ``ifne`` set the value at key ``name`` to ``value`` only if the current
     |          value does not exactly match the argument.
     |          If key doesn’t exist - it will be created.
     |          (Requires Redis 8.4 or greater)
     |
     |      ``ifdeq`` set the value at key ``name`` to ``value`` only if the current
     |          value XXH3 hex digest exactly matches the argument.
     |          If key doesn’t exist - it won’t be created.
     |          (Requires Redis 8.4 or greater)
     |
     |      ``ifdne`` set the value at key ``name`` to ``value`` only if the current
     |          value XXH3 hex digest does not exactly match the argument.
     |          If key doesn’t exist - it will be created.
     |          (Requires Redis 8.4 or greater)
     |
     |      For more information, see https://redis.io/commands/set
     |
     |  setbit(self, name: 'KeyT', offset: 'int', value: 'int') -> 'int | Awaitable[int]'
     |      Flag the ``offset`` in ``name`` as ``value``. Returns an integer
     |      indicating the previous value of ``offset``.
     |
     |      For more information, see https://redis.io/commands/setbit
     |
     |  setex(self, name: 'KeyT', time: 'ExpiryT', value: 'EncodableT') -> 'bool | Awaitable[bool]'
     |      Set the value of key ``name`` to ``value`` that expires in ``time``
     |      seconds. ``time`` can be represented by an integer or a Python
     |      timedelta object.
     |
     |      As per Redis 2.6.12, SETEX is considered deprecated.
     |      Please use SET with EX parameter in new code.
     |
     |      For more information, see https://redis.io/commands/setex
     |
     |  setnx(self, name: 'KeyT', value: 'EncodableT') -> 'bool | Awaitable[bool]'
     |      Set the value of key ``name`` to ``value`` if key doesn't exist
     |
     |      For more information, see https://redis.io/commands/setnx
     |
     |  setrange(self, name: 'KeyT', offset: 'int', value: 'EncodableT') -> 'int | Awaitable[int]'
     |      Overwrite bytes in the value of ``name`` starting at ``offset`` with
     |      ``value``. If ``offset`` plus the length of ``value`` exceeds the
     |      length of the original value, the new value will be larger than before.
     |      If ``offset`` exceeds the length of the original value, null bytes
     |      will be used to pad between the end of the previous value and the start
     |      of what's being injected.
     |
     |      Returns the length of the new string.
     |
     |      For more information, see https://redis.io/commands/setrange
     |
     |  strlen(self, name: 'KeyT') -> 'int | Awaitable[int]'
     |      Return the number of bytes stored in the value of ``name``
     |
     |      For more information, see https://redis.io/commands/strlen
     |
     |  substr(self, name: 'KeyT', start: 'int', end: 'int' = -1) -> 'bytes | str | Awaitable[bytes | str]'
     |      Return a substring of the string at key ``name``. ``start`` and ``end``
     |      are 0-based integers specifying the portion of the string to return.
     |
     |  ttl(self, name: 'KeyT') -> 'int | Awaitable[int]'
     |      Returns the number of seconds until the key ``name`` will expire
     |
     |      For more information, see https://redis.io/commands/ttl
     |
     |  type(self, name: 'KeyT') -> 'bytes | str | Awaitable[bytes | str]'
     |      Returns the type of key ``name``
     |
     |      For more information, see https://redis.io/commands/type
     |
     |  unwatch(self) -> 'None'
     |      Unwatches all previously watched keys for a transaction
     |
     |      For more information, see https://redis.io/commands/unwatch
     |
     |  watch(self, *names: 'KeyT') -> 'None'
     |      Watches the values at keys ``names``, or None if the key doesn't exist
     |
     |      For more information, see https://redis.io/commands/watch
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from redis.commands.core.HyperlogCommands:
     |
     |  pfadd(self, name: 'KeyT', *values: 'FieldT') -> 'int | Awaitable[int]'
     |      Adds the specified elements to the specified HyperLogLog.
     |
     |      For more information, see https://redis.io/commands/pfadd
     |
     |  pfcount(self, *sources: 'KeyT') -> 'int | Awaitable[int]'
     |      Return the approximated cardinality of
     |      the set observed by the HyperLogLog at key(s).
     |
     |      For more information, see https://redis.io/commands/pfcount
     |
     |  pfmerge(self, dest: 'KeyT', *sources: 'KeyT') -> 'bool | Awaitable[bool]'
     |      Merge N different HyperLogLogs into a single one.
     |
     |      For more information, see https://redis.io/commands/pfmerge
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from redis.commands.core.HashCommands:
     |
     |  hdel(self, name: 'KeyT', *keys: 'FieldT') -> 'int | Awaitable[int]'
     |      Delete ``keys`` from hash ``name``
     |
     |      For more information, see https://redis.io/commands/hdel
     |
     |  hexists(self, name: 'KeyT', key: 'FieldT') -> 'bool | Awaitable[bool]'
     |      Returns a boolean indicating if ``key`` exists within hash ``name``
     |
     |      For more information, see https://redis.io/commands/hexists
     |
     |  hexpire(self, name: 'KeyT', seconds: 'ExpiryT', *fields: 'FieldT', nx: 'bool' = False, xx: 'bool' = False, gt: 'bool' = False, lt: 'bool' = False) -> 'list[int] | Awaitable[list[int]]'
     |      Sets or updates the expiration time for fields within a hash key, using relative
     |      time in seconds.
     |
     |      If a field already has an expiration time, the behavior of the update can be
     |      controlled using the `nx`, `xx`, `gt`, and `lt` parameters.
     |
     |      The return value provides detailed information about the outcome for each field.
     |
     |      For more information, see https://redis.io/commands/hexpire
     |
     |      Args:
     |          name: The name of the hash key.
     |          seconds: Expiration time in seconds, relative. Can be an integer, or a
     |                   Python `timedelta` object.
     |          fields: List of fields within the hash to apply the expiration time to.
     |          nx: Set expiry only when the field has no expiry.
     |          xx: Set expiry only when the field has an existing expiry.
     |          gt: Set expiry only when the new expiry is greater than the current one.
     |          lt: Set expiry only when the new expiry is less than the current one.
     |
     |      Returns:
     |          Returns a list which contains for each field in the request:
     |              - `-2` if the field does not exist, or if the key does not exist.
     |              - `0` if the specified NX | XX | GT | LT condition was not met.
     |              - `1` if the expiration time was set or updated.
     |              - `2` if the field was deleted because the specified expiration time is
     |                in the past.
     |
     |  hexpireat(self, name: 'KeyT', unix_time_seconds: 'AbsExpiryT', *fields: 'FieldT', nx: 'bool' = False, xx: 'bool' = False, gt: 'bool' = False, lt: 'bool' = False) -> 'list[int] | Awaitable[list[int]]'
     |      Sets or updates the expiration time for fields within a hash key, using an
     |      absolute Unix timestamp in seconds.
     |
     |      If a field already has an expiration time, the behavior of the update can be
     |      controlled using the `nx`, `xx`, `gt`, and `lt` parameters.
     |
     |      The return value provides detailed information about the outcome for each field.
     |
     |      For more information, see https://redis.io/commands/hexpireat
     |
     |      Args:
     |          name: The name of the hash key.
     |          unix_time_seconds: Expiration time as Unix timestamp in seconds. Can be an
     |                             integer or a Python `datetime` object.
     |          fields: List of fields within the hash to apply the expiration time to.
     |          nx: Set expiry only when the field has no expiry.
     |          xx: Set expiry only when the field has an existing expiration time.
     |          gt: Set expiry only when the new expiry is greater than the current one.
     |          lt: Set expiry only when the new expiry is less than the current one.
     |
     |      Returns:
     |          Returns a list which contains for each field in the request:
     |              - `-2` if the field does not exist, or if the key does not exist.
     |              - `0` if the specified NX | XX | GT | LT condition was not met.
     |              - `1` if the expiration time was set or updated.
     |              - `2` if the field was deleted because the specified expiration time is
     |                in the past.
     |
     |  hexpiretime(self, key: 'KeyT', *fields: 'FieldT') -> 'list[int] | Awaitable[list[int]]'
     |      Returns the expiration times of hash fields as Unix timestamps in seconds.
     |
     |      For more information, see https://redis.io/commands/hexpiretime
     |
     |      Args:
     |          key: The hash key.
     |          fields: A list of fields within the hash for which to get the expiration
     |                  time.
     |
     |      Returns:
     |          Returns a list which contains for each field in the request:
     |              - `-2` if the field does not exist, or if the key does not exist.
     |              - `-1` if the field exists but has no associated expire time.
     |              - A positive integer representing the expiration Unix timestamp in
     |                seconds, if the field has an associated expiration time.
     |
     |  hget(self, name: 'KeyT', key: 'FieldT') -> 'bytes | str | None | Awaitable[bytes | str | None]'
     |      Return the value of ``key`` within the hash ``name``
     |
     |      For more information, see https://redis.io/commands/hget
     |
     |  hgetall(self, name: 'KeyT') -> 'dict[bytes | str, bytes | str] | Awaitable[dict[bytes | str, bytes | str]]'
     |      Return a Python dict of the hash's name/value pairs
     |
     |      For more information, see https://redis.io/commands/hgetall
     |
     |  hgetdel(self, name: 'KeyT', *keys: 'FieldT') -> 'list[bytes | str | None] | Awaitable[list[bytes | str | None]]'
     |      Return the value of ``key`` within the hash ``name`` and
     |      delete the field in the hash.
     |      This command is similar to HGET, except for the fact that it also deletes
     |      the key on success from the hash with the provided ```name```.
     |
     |      Available since Redis 8.0
     |      For more information, see https://redis.io/commands/hgetdel
     |
     |  hgetex(self, name: 'KeyT', *keys: 'FieldT', ex: 'ExpiryT | None' = None, px: 'ExpiryT | None' = None, exat: 'AbsExpiryT | None' = None, pxat: 'AbsExpiryT | None' = None, persist: 'bool' = False) -> 'list[bytes | str | None] | Awaitable[list[bytes | str | None]]'
     |      Return the values of ``key`` and ``keys`` within the hash ``name``
     |      and optionally set their expiration.
     |
     |      ``ex`` sets an expire flag on ``kyes`` for ``ex`` seconds.
     |
     |      ``px`` sets an expire flag on ``keys`` for ``px`` milliseconds.
     |
     |      ``exat`` sets an expire flag on ``keys`` for ``ex`` seconds,
     |      specified in unix time.
     |
     |      ``pxat`` sets an expire flag on ``keys`` for ``ex`` milliseconds,
     |      specified in unix time.
     |
     |      ``persist`` remove the time to live associated with the ``keys``.
     |
     |      Available since Redis 8.0
     |      For more information, see https://redis.io/commands/hgetex
     |
     |  himport_discard_all_internal(self) -> 'int | Awaitable[int]'
     |      Send ``HIMPORT DISCARDALL`` (returns the number of fieldsets removed).
     |
     |      .. warning::
     |          Internal wire mapping — not for direct use on a pooled client. It
     |          DISCARDs on a single arbitrary borrowed connection and bypasses the
     |          client's shared fieldset registry, leaving other connections and the
     |          registry out of sync. Use the client's ``himport_discard_all`` instead;
     |          call this only on a pinned single-connection client where you manage
     |          session state yourself.
     |
     |  himport_discard_internal(self, fieldset_name: 'str') -> 'int | Awaitable[int]'
     |      Send ``HIMPORT DISCARD fieldset_name`` (``1`` removed, ``0`` not found).
     |
     |      .. warning::
     |          Internal wire mapping — not for direct use on a pooled client. It
     |          DISCARDs on a single arbitrary borrowed connection and bypasses the
     |          client's shared fieldset registry, leaving other connections and the
     |          registry out of sync. Use the client's ``himport_discard`` instead; call
     |          this only on a pinned single-connection client where you manage session
     |          state yourself.
     |
     |  himport_prepare_internal(self, fieldset_name: 'str', fields: 'Iterable[FieldT]') -> 'bool | Awaitable[bool]'
     |      Send ``HIMPORT PREPARE fieldset_name field [field ...]``.
     |
     |      Registers the ordered field list under ``fieldset_name`` in the executing
     |      connection's session. Fields are sent in the caller's order, unmodified.
     |
     |      .. warning::
     |          Internal wire mapping — not for direct use on a pooled client. It
     |          PREPAREs on a single arbitrary borrowed connection and bypasses the
     |          client's shared fieldset registry, so other connections stay unaware and
     |          reintroduce the nondeterministic "no such fieldset" the HIMPORT design
     |          prevents. Use the client's ``himport_prepare`` instead; call this only
     |          on a pinned single-connection client where you manage session state
     |          yourself.
     |
     |  himport_set(self, key: 'KeyT', fieldset_name: 'str', values: 'Iterable[EncodableT]') -> 'bool | Awaitable[bool]'
     |      Create/replace ``key`` as a hash using ``fieldset_name``'s field list.
     |
     |      Values are sent in the caller's order and map positionally to the prepared
     |      fields. The fieldset is prepared on the serving connection on first use
     |      (PREPARE bundled with SET in one write) and reused on subsequent calls;
     |      runtime discards are reconciled on the next use of the connection. All of
     |      this happens inside the normal command path, so retry, disconnect-on-error
     |      and (for the cluster) routing / MOVED-ASK apply exactly as for any command.
     |
     |      .. note::
     |          Recovery from a mid-connection fieldset loss (the server dropping the
     |          prepared fieldset without dropping the socket, e.g. ``RESET`` or
     |          ``maxmemory-clients`` eviction) applies only to a standalone
     |          ``himport_set`` call: it catches the resulting ``no such fieldset`` and
     |          re-prepares on the same socket, retrying the SET once. A ``himport_set``
     |          buffered in a **pipeline or transaction** has no such per-command
     |          recovery — its fieldset is PREPAREd once as a pre-flight before the
     |          batch, and if the server loses it between that pre-flight and the batch
     |          the SET fails and surfaces as an error in the batch results. Callers who
     |          need the automatic recovery should issue those sets outside a pipeline.
     |
     |  hincrby(self, name: 'KeyT', key: 'FieldT', amount: 'int' = 1) -> 'int | Awaitable[int]'
     |      Increment the value of ``key`` in hash ``name`` by ``amount``
     |
     |      For more information, see https://redis.io/commands/hincrby
     |
     |  hincrbyfloat(self, name: 'KeyT', key: 'FieldT', amount: 'float' = 1.0) -> 'float | Awaitable[float]'
     |      Increment the value of ``key`` in hash ``name`` by floating ``amount``
     |
     |      For more information, see https://redis.io/commands/hincrbyfloat
     |
     |  hkeys(self, name: 'KeyT') -> 'list[bytes | str] | Awaitable[list[bytes | str]]'
     |      Return the list of keys within hash ``name``
     |
     |      For more information, see https://redis.io/commands/hkeys
     |
     |  hlen(self, name: 'KeyT') -> 'int | Awaitable[int]'
     |      Return the number of elements in hash ``name``
     |
     |      For more information, see https://redis.io/commands/hlen
     |
     |  hmget(self, name: 'KeyT', keys: 'FieldT | Iterable[FieldT]', *args: 'FieldT') -> 'list[bytes | str | None] | Awaitable[list[bytes | str | None]]'
     |      Returns a list of values ordered identically to ``keys``
     |
     |      For more information, see https://redis.io/commands/hmget
     |
     |  hmset(self, name: 'KeyT', mapping: 'Mapping[FieldT, EncodableT]') -> 'bool | Awaitable[bool]'
     |      Set key to value within hash ``name`` for each corresponding
     |      key and value from the ``mapping`` dict.
     |
     |      For more information, see https://redis.io/commands/hmset
     |
     |  hpersist(self, name: 'KeyT', *fields: 'FieldT') -> 'list[int] | Awaitable[list[int]]'
     |      Removes the expiration time for each specified field in a hash.
     |
     |      For more information, see https://redis.io/commands/hpersist
     |
     |      Args:
     |          name: The name of the hash key.
     |          fields: A list of fields within the hash from which to remove the
     |                  expiration time.
     |
     |      Returns:
     |          Returns a list which contains for each field in the request:
     |              - `-2` if the field does not exist, or if the key does not exist.
     |              - `-1` if the field exists but has no associated expiration time.
     |              - `1` if the expiration time was successfully removed from the field.
     |
     |  hpexpire(self, name: 'KeyT', milliseconds: 'ExpiryT', *fields: 'FieldT', nx: 'bool' = False, xx: 'bool' = False, gt: 'bool' = False, lt: 'bool' = False) -> 'list[int] | Awaitable[list[int]]'
     |      Sets or updates the expiration time for fields within a hash key, using relative
     |      time in milliseconds.
     |
     |      If a field already has an expiration time, the behavior of the update can be
     |      controlled using the `nx`, `xx`, `gt`, and `lt` parameters.
     |
     |      The return value provides detailed information about the outcome for each field.
     |
     |      For more information, see https://redis.io/commands/hpexpire
     |
     |      Args:
     |          name: The name of the hash key.
     |          milliseconds: Expiration time in milliseconds, relative. Can be an integer,
     |                        or a Python `timedelta` object.
     |          fields: List of fields within the hash to apply the expiration time to.
     |          nx: Set expiry only when the field has no expiry.
     |          xx: Set expiry only when the field has an existing expiry.
     |          gt: Set expiry only when the new expiry is greater than the current one.
     |          lt: Set expiry only when the new expiry is less than the current one.
     |
     |      Returns:
     |          Returns a list which contains for each field in the request:
     |              - `-2` if the field does not exist, or if the key does not exist.
     |              - `0` if the specified NX | XX | GT | LT condition was not met.
     |              - `1` if the expiration time was set or updated.
     |              - `2` if the field was deleted because the specified expiration time is
     |                in the past.
     |
     |  hpexpireat(self, name: 'KeyT', unix_time_milliseconds: 'AbsExpiryT', *fields: 'FieldT', nx: 'bool' = False, xx: 'bool' = False, gt: 'bool' = False, lt: 'bool' = False) -> 'list[int] | Awaitable[list[int]]'
     |      Sets or updates the expiration time for fields within a hash key, using an
     |      absolute Unix timestamp in milliseconds.
     |
     |      If a field already has an expiration time, the behavior of the update can be
     |      controlled using the `nx`, `xx`, `gt`, and `lt` parameters.
     |
     |      The return value provides detailed information about the outcome for each field.
     |
     |      For more information, see https://redis.io/commands/hpexpireat
     |
     |      Args:
     |          name: The name of the hash key.
     |          unix_time_milliseconds: Expiration time as Unix timestamp in milliseconds.
     |                                  Can be an integer or a Python `datetime` object.
     |          fields: List of fields within the hash to apply the expiry.
     |          nx: Set expiry only when the field has no expiry.
     |          xx: Set expiry only when the field has an existing expiry.
     |          gt: Set expiry only when the new expiry is greater than the current one.
     |          lt: Set expiry only when the new expiry is less than the current one.
     |
     |      Returns:
     |          Returns a list which contains for each field in the request:
     |              - `-2` if the field does not exist, or if the key does not exist.
     |              - `0` if the specified NX | XX | GT | LT condition was not met.
     |              - `1` if the expiration time was set or updated.
     |              - `2` if the field was deleted because the specified expiration time is
     |                in the past.
     |
     |  hpexpiretime(self, key: 'KeyT', *fields: 'FieldT') -> 'list[int] | Awaitable[list[int]]'
     |      Returns the expiration times of hash fields as Unix timestamps in milliseconds.
     |
     |      For more information, see https://redis.io/commands/hpexpiretime
     |
     |      Args:
     |          key: The hash key.
     |          fields: A list of fields within the hash for which to get the expiration
     |                  time.
     |
     |      Returns:
     |          Returns a list which contains for each field in the request:
     |              - `-2` if the field does not exist, or if the key does not exist.
     |              - `-1` if the field exists but has no associated expire time.
     |              - A positive integer representing the expiration Unix timestamp in
     |                milliseconds, if the field has an associated expiration time.
     |
     |  hpttl(self, key: 'KeyT', *fields: 'FieldT') -> 'list[int] | Awaitable[list[int]]'
     |      Returns the TTL (Time To Live) in milliseconds for each specified field within a
     |      hash key.
     |
     |      For more information, see https://redis.io/commands/hpttl
     |
     |      Args:
     |          key: The hash key.
     |          fields: A list of fields within the hash for which to get the TTL.
     |
     |      Returns:
     |          Returns a list which contains for each field in the request:
     |              - `-2` if the field does not exist, or if the key does not exist.
     |              - `-1` if the field exists but has no associated expire time.
     |              - A positive integer representing the TTL in milliseconds if the field
     |                has an associated expiration time.
     |
     |  hset(self, name: 'KeyT', key: 'FieldT | None' = None, value: 'EncodableT | None' = None, mapping: 'Mapping[FieldT, EncodableT] | None' = None, items: 'Sequence[EncodableT] | None' = None) -> 'int | Awaitable[int]'
     |      Set ``key`` to ``value`` within hash ``name``,
     |      ``mapping`` accepts a dict of key/value pairs that will be
     |      added to hash ``name``.
     |      ``items`` accepts a list of key/value pairs that will be
     |      added to hash ``name``.
     |      Returns the number of fields that were added.
     |
     |      For more information, see https://redis.io/commands/hset
     |
     |  hsetex(self, name: 'KeyT', key: 'FieldT | None' = None, value: 'EncodableT | None' = None, mapping: 'Mapping[FieldT, EncodableT] | None' = None, items: 'Sequence[EncodableT] | None' = None, ex: 'ExpiryT | None' = None, px: 'ExpiryT | None' = None, exat: 'AbsExpiryT | None' = None, pxat: 'AbsExpiryT | None' = None, data_persist_option: 'HashDataPersistOptions | None' = None, keepttl: 'bool' = False) -> 'int | Awaitable[int]'
     |      Set ``key`` to ``value`` within hash ``name``
     |
     |      ``mapping`` accepts a dict of key/value pairs that will be
     |      added to hash ``name``.
     |
     |      ``items`` accepts a list of key/value pairs that will be
     |      added to hash ``name``.
     |
     |      ``ex`` sets an expire flag on ``keys`` for ``ex`` seconds.
     |
     |      ``px`` sets an expire flag on ``keys`` for ``px`` milliseconds.
     |
     |      ``exat`` sets an expire flag on ``keys`` for ``ex`` seconds,
     |          specified in unix time.
     |
     |      ``pxat`` sets an expire flag on ``keys`` for ``ex`` milliseconds,
     |          specified in unix time.
     |
     |      ``data_persist_option`` can be set to ``FNX`` or ``FXX`` to control the
     |          behavior of the command.
     |          ``FNX`` will set the value for each provided key to each
     |              provided value only if all do not already exist.
     |          ``FXX`` will set the value for each provided key to each
     |              provided value only if all already exist.
     |
     |      ``keepttl`` if True, retain the time to live associated with the keys.
     |
     |      Returns the number of fields that were added.
     |
     |      Available since Redis 8.0
     |      For more information, see https://redis.io/commands/hsetex
     |
     |  hsetnx(self, name: 'KeyT', key: 'FieldT', value: 'EncodableT') -> 'int | Awaitable[int]'
     |      Set ``key`` to ``value`` within hash ``name`` if ``key`` does not
     |      exist.  Returns 1 if HSETNX created a field, otherwise 0.
     |
     |      For more information, see https://redis.io/commands/hsetnx
     |
     |  hstrlen(self, name: 'KeyT', key: 'FieldT') -> 'int | Awaitable[int]'
     |      Return the number of bytes stored in the value of ``key``
     |      within hash ``name``
     |
     |      For more information, see https://redis.io/commands/hstrlen
     |
     |  httl(self, key: 'KeyT', *fields: 'FieldT') -> 'list[int] | Awaitable[list[int]]'
     |      Returns the TTL (Time To Live) in seconds for each specified field within a hash
     |      key.
     |
     |      For more information, see https://redis.io/commands/httl
     |
     |      Args:
     |          key: The hash key.
     |          fields: A list of fields within the hash for which to get the TTL.
     |
     |      Returns:
     |          Returns a list which contains for each field in the request:
     |              - `-2` if the field does not exist, or if the key does not exist.
     |              - `-1` if the field exists but has no associated expire time.
     |              - A positive integer representing the TTL in seconds if the field has
     |                an associated expiration time.
     |
     |  hvals(self, name: 'KeyT') -> 'list[bytes | str] | Awaitable[list[bytes | str]]'
     |      Return the list of values within hash ``name``
     |
     |      For more information, see https://redis.io/commands/hvals
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from redis.commands.core.GeoCommands:
     |
     |  geoadd(self, name: 'KeyT', values: 'Sequence[EncodableT]', nx: 'bool' = False, xx: 'bool' = False, ch: 'bool' = False) -> 'int | Awaitable[int]'
     |      Add the specified geospatial items to the specified key identified
     |      by the ``name`` argument. The Geospatial items are given as ordered
     |      members of the ``values`` argument, each item or place is formed by
     |      the triad longitude, latitude and name.
     |
     |      Note: You can use ZREM to remove elements.
     |
     |      ``nx`` forces ZADD to only create new elements and not to update
     |      scores for elements that already exist.
     |
     |      ``xx`` forces ZADD to only update scores of elements that already
     |      exist. New elements will not be added.
     |
     |      ``ch`` modifies the return value to be the numbers of elements changed.
     |      Changed elements include new elements that were added and elements
     |      whose scores changed.
     |
     |      For more information, see https://redis.io/commands/geoadd
     |
     |  geodist(self, name: 'KeyT', place1: 'FieldT', place2: 'FieldT', unit: 'str | None' = None) -> 'float | None | Awaitable[float | None]'
     |      Return the distance between ``place1`` and ``place2`` members of the
     |      ``name`` key.
     |      The units must be one of the following : m, km mi, ft. By default
     |      meters are used.
     |
     |      For more information, see https://redis.io/commands/geodist
     |
     |  geohash(self, name: 'KeyT', *values: 'FieldT') -> 'list[bytes | str | None] | Awaitable[list[bytes | str | None]]'
     |      Return the geo hash string for each item of ``values`` members of
     |      the specified key identified by the ``name`` argument.
     |
     |      For more information, see https://redis.io/commands/geohash
     |
     |  geopos(self, name: 'KeyT', *values: 'FieldT') -> 'list[GeoCoordinate | None] | Awaitable[list[GeoCoordinate | None]]'
     |      Return the positions of each item of ``values`` as members of
     |      the specified key identified by the ``name`` argument. Each position
     |      is represented by the pairs lon and lat.
     |
     |      For more information, see https://redis.io/commands/geopos
     |
     |  georadius(self, name: 'KeyT', longitude: 'float', latitude: 'float', radius: 'float', unit: 'str | None' = None, withdist: 'bool' = False, withcoord: 'bool' = False, withhash: 'bool' = False, count: 'int | None' = None, sort: 'str | None' = None, store: 'KeyT | None' = None, store_dist: 'KeyT | None' = None, any: 'bool' = False) -> 'GeoRadiusResponse | Awaitable[GeoRadiusResponse]'
     |      Return the members of the specified key identified by the
     |      ``name`` argument which are within the borders of the area specified
     |      with the ``latitude`` and ``longitude`` location and the maximum
     |      distance from the center specified by the ``radius`` value.
     |
     |      The units must be one of the following : m, km mi, ft. By default
     |
     |      ``withdist`` indicates to return the distances of each place.
     |
     |      ``withcoord`` indicates to return the latitude and longitude of
     |      each place.
     |
     |      ``withhash`` indicates to return the geohash string of each place.
     |
     |      ``count`` indicates to return the number of elements up to N.
     |
     |      ``sort`` indicates to return the places in a sorted way, ASC for
     |      nearest to fairest and DESC for fairest to nearest.
     |
     |      ``store`` indicates to save the places names in a sorted set named
     |      with a specific key, each element of the destination sorted set is
     |      populated with the score got from the original geo sorted set.
     |
     |      ``store_dist`` indicates to save the places names in a sorted set
     |      named with a specific key, instead of ``store`` the sorted set
     |      destination score is set with the distance.
     |
     |      For more information, see https://redis.io/commands/georadius
     |
     |  georadiusbymember(self, name: 'KeyT', member: 'FieldT', radius: 'float', unit: 'str | None' = None, withdist: 'bool' = False, withcoord: 'bool' = False, withhash: 'bool' = False, count: 'int | None' = None, sort: 'str | None' = None, store: 'Union[KeyT, None]' = None, store_dist: 'Union[KeyT, None]' = None, any: 'bool' = False) -> 'GeoRadiusResponse | Awaitable[GeoRadiusResponse]'
     |      This command is exactly like ``georadius`` with the sole difference
     |      that instead of taking, as the center of the area to query, a longitude
     |      and latitude value, it takes the name of a member already existing
     |      inside the geospatial index represented by the sorted set.
     |
     |      For more information, see https://redis.io/commands/georadiusbymember
     |
     |  geosearch(self, name: 'KeyT', member: 'FieldT | None' = None, longitude: 'float | None' = None, latitude: 'float | None' = None, unit: 'str' = 'm', radius: 'float | None' = None, width: 'float | None' = None, height: 'float | None' = None, sort: 'str | None' = None, count: 'int | None' = None, any: 'bool' = False, withcoord: 'bool' = False, withdist: 'bool' = False, withhash: 'bool' = False) -> 'GeoSearchResponse | Awaitable[GeoSearchResponse]'
     |      Return the members of specified key identified by the
     |      ``name`` argument, which are within the borders of the
     |      area specified by a given shape. This command extends the
     |      GEORADIUS command, so in addition to searching within circular
     |      areas, it supports searching within rectangular areas.
     |
     |      This command should be used in place of the deprecated
     |      GEORADIUS and GEORADIUSBYMEMBER commands.
     |
     |      ``member`` Use the position of the given existing
     |       member in the sorted set. Can't be given with ``longitude``
     |       and ``latitude``.
     |
     |      ``longitude`` and ``latitude`` Use the position given by
     |      this coordinates. Can't be given with ``member``
     |      ``radius`` Similar to GEORADIUS, search inside circular
     |      area according the given radius. Can't be given with
     |      ``height`` and ``width``.
     |      ``height`` and ``width`` Search inside an axis-aligned
     |      rectangle, determined by the given height and width.
     |      Can't be given with ``radius``
     |
     |      ``unit`` must be one of the following : m, km, mi, ft.
     |      `m` for meters (the default value), `km` for kilometers,
     |      `mi` for miles and `ft` for feet.
     |
     |      ``sort`` indicates to return the places in a sorted way,
     |      ASC for nearest to furthest and DESC for furthest to nearest.
     |
     |      ``count`` limit the results to the first count matching items.
     |
     |      ``any`` is set to True, the command will return as soon as
     |      enough matches are found. Can't be provided without ``count``
     |
     |      ``withdist`` indicates to return the distances of each place.
     |      ``withcoord`` indicates to return the latitude and longitude of
     |      each place.
     |
     |      ``withhash`` indicates to return the geohash string of each place.
     |
     |      For more information, see https://redis.io/commands/geosearch
     |
     |  geosearchstore(self, dest: 'KeyT', name: 'KeyT', member: 'FieldT | None' = None, longitude: 'float | None' = None, latitude: 'float | None' = None, unit: 'str' = 'm', radius: 'float | None' = None, width: 'float | None' = None, height: 'float | None' = None, sort: 'str | None' = None, count: 'int | None' = None, any: 'bool' = False, storedist: 'bool' = False) -> 'int | Awaitable[int]'
     |      This command is like GEOSEARCH, but stores the result in
     |      ``dest``. By default, it stores the results in the destination
     |      sorted set with their geospatial information.
     |      if ``store_dist`` set to True, the command will stores the
     |      items in a sorted set populated with their distance from the
     |      center of the circle or box, as a floating-point number.
     |
     |      For more information, see https://redis.io/commands/geosearchstore
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from redis.commands.core.ListCommands:
     |
     |  blmpop(self, timeout: 'float', numkeys: 'int', *args: 'str', direction: 'str', count: 'int | None' = 1) -> 'ListMultiPopResponse | Awaitable[ListMultiPopResponse]'
     |      Pop ``count`` values (default 1) from first non-empty in the list
     |      of provided key names.
     |
     |      When all lists are empty this command blocks the connection until another
     |      client pushes to it or until the timeout, timeout of 0 blocks indefinitely
     |
     |      For more information, see https://redis.io/commands/blmpop
     |
     |  blpop(self, keys: 'KeysT', timeout: 'Number | None' = 0) -> 'BlockingListPopResponse | Awaitable[BlockingListPopResponse]'
     |      LPOP a value off of the first non-empty list
     |      named in ``keys``.
     |
     |      If none of the lists in ``keys`` has a value to LPOP, then block
     |      for ``timeout`` seconds, or until a value gets pushed on to one
     |      of the lists.
     |
     |      If timeout is 0, then block indefinitely.
     |
     |      For more information, see https://redis.io/commands/blpop
     |
     |  brpop(self, keys: 'KeysT', timeout: 'Number | None' = 0) -> 'BlockingListPopResponse | Awaitable[BlockingListPopResponse]'
     |      RPOP a value off of the first non-empty list
     |      named in ``keys``.
     |
     |      If none of the lists in ``keys`` has a value to RPOP, then block
     |      for ``timeout`` seconds, or until a value gets pushed on to one
     |      of the lists.
     |
     |      If timeout is 0, then block indefinitely.
     |
     |      For more information, see https://redis.io/commands/brpop
     |
     |  brpoplpush(self, src: 'KeyT', dst: 'KeyT', timeout: 'Number | None' = 0) -> 'bytes | str | None | Awaitable[bytes | str | None]'
     |      Pop a value off the tail of ``src``, push it on the head of ``dst``
     |      and then return it.
     |
     |      This command blocks until a value is in ``src`` or until ``timeout``
     |      seconds elapse, whichever is first. A ``timeout`` value of 0 blocks
     |      forever.
     |
     |      For more information, see https://redis.io/commands/brpoplpush
     |
     |  lindex(self, name: 'KeyT', index: 'int') -> 'bytes | str | None | Awaitable[bytes | str | None]'
     |      Return the item from list ``name`` at position ``index``
     |
     |      Negative indexes are supported and will return an item at the
     |      end of the list
     |
     |      For more information, see https://redis.io/commands/lindex
     |
     |  linsert(self, name: 'KeyT', where: 'str', refvalue: 'str', value: 'str') -> 'int | Awaitable[int]'
     |      Insert ``value`` in list ``name`` either immediately before or after
     |      [``where``] ``refvalue``
     |
     |      Returns the new length of the list on success or -1 if ``refvalue``
     |      is not in the list.
     |
     |      For more information, see https://redis.io/commands/linsert
     |
     |  llen(self, name: 'KeyT') -> 'int | Awaitable[int]'
     |      Return the length of the list ``name``
     |
     |      For more information, see https://redis.io/commands/llen
     |
     |  lmpop(self, num_keys: 'int', *args: 'str', direction: 'str', count: 'int | None' = 1) -> 'ListMultiPopResponse | Awaitable[ListMultiPopResponse]'
     |      Pop ``count`` values (default 1) first non-empty list key from the list
     |      of args provided key names.
     |
     |      For more information, see https://redis.io/commands/lmpop
     |
     |  lpop(self, name: 'KeyT', count: 'int | None' = None) -> 'bytes | str | list[bytes | str] | None | Awaitable[bytes | str | list[bytes | str] | None]'
     |      Removes and returns the first elements of the list ``name``.
     |
     |      By default, the command pops a single element from the beginning of
     |      the list. When provided with the optional ``count`` argument, the reply
     |      will consist of up to count elements, depending on the list's length.
     |
     |      For more information, see https://redis.io/commands/lpop
     |
     |  lpos(self, name: 'KeyT', value: 'str', rank: 'int | None' = None, count: 'int | None' = None, maxlen: 'int | None' = None) -> 'int | list[int] | None | Awaitable[int | list[int] | None]'
     |      Get position of ``value`` within the list ``name``
     |
     |       If specified, ``rank`` indicates the "rank" of the first element to
     |       return in case there are multiple copies of ``value`` in the list.
     |       By default, LPOS returns the position of the first occurrence of
     |       ``value`` in the list. When ``rank`` 2, LPOS returns the position of
     |       the second ``value`` in the list. If ``rank`` is negative, LPOS
     |       searches the list in reverse. For example, -1 would return the
     |       position of the last occurrence of ``value`` and -2 would return the
     |       position of the next to last occurrence of ``value``.
     |
     |       If specified, ``count`` indicates that LPOS should return a list of
     |       up to ``count`` positions. A ``count`` of 2 would return a list of
     |       up to 2 positions. A ``count`` of 0 returns a list of all positions
     |       matching ``value``. When ``count`` is specified and but ``value``
     |       does not exist in the list, an empty list is returned.
     |
     |       If specified, ``maxlen`` indicates the maximum number of list
     |       elements to scan. A ``maxlen`` of 1000 will only return the
     |       position(s) of items within the first 1000 entries in the list.
     |       A ``maxlen`` of 0 (the default) will scan the entire list.
     |
     |       For more information, see https://redis.io/commands/lpos
     |
     |  lpush(self, name: 'KeyT', *values: 'FieldT') -> 'int | Awaitable[int]'
     |      Push ``values`` onto the head of the list ``name``
     |
     |      For more information, see https://redis.io/commands/lpush
     |
     |  lpushx(self, name: 'KeyT', *values: 'FieldT') -> 'int | Awaitable[int]'
     |      Push ``value`` onto the head of the list ``name`` if ``name`` exists
     |
     |      For more information, see https://redis.io/commands/lpushx
     |
     |  lrange(self, name: 'KeyT', start: 'int', end: 'int') -> 'list[bytes | str] | Awaitable[list[bytes | str]]'
     |      Return a slice of the list ``name`` between
     |      position ``start`` and ``end``
     |
     |      ``start`` and ``end`` can be negative numbers just like
     |      Python slicing notation
     |
     |      For more information, see https://redis.io/commands/lrange
     |
     |  lrem(self, name: 'KeyT', count: 'int', value: 'str') -> 'int | Awaitable[int]'
     |      Remove the first ``count`` occurrences of elements equal to ``value``
     |      from the list stored at ``name``.
     |
     |      The count argument influences the operation in the following ways:
     |          count > 0: Remove elements equal to value moving from head to tail.
     |          count < 0: Remove elements equal to value moving from tail to head.
     |          count = 0: Remove all elements equal to value.
     |
     |          For more information, see https://redis.io/commands/lrem
     |
     |  lset(self, name: 'KeyT', index: 'int', value: 'str') -> 'bool | Awaitable[bool]'
     |      Set element at ``index`` of list ``name`` to ``value``
     |
     |      For more information, see https://redis.io/commands/lset
     |
     |  ltrim(self, name: 'KeyT', start: 'int', end: 'int') -> 'bool | Awaitable[bool]'
     |      Trim the list ``name``, removing all values not within the slice
     |      between ``start`` and ``end``
     |
     |      ``start`` and ``end`` can be negative numbers just like
     |      Python slicing notation
     |
     |      For more information, see https://redis.io/commands/ltrim
     |
     |  rpop(self, name: 'KeyT', count: 'int | None' = None) -> 'bytes | str | list[bytes | str] | None | Awaitable[bytes | str | list[bytes | str] | None]'
     |      Removes and returns the last elements of the list ``name``.
     |
     |      By default, the command pops a single element from the end of the list.
     |      When provided with the optional ``count`` argument, the reply will
     |      consist of up to count elements, depending on the list's length.
     |
     |      For more information, see https://redis.io/commands/rpop
     |
     |  rpoplpush(self, src: 'KeyT', dst: 'KeyT') -> 'bytes | str | None | Awaitable[bytes | str | None]'
     |      RPOP a value off of the ``src`` list and atomically LPUSH it
     |      on to the ``dst`` list.  Returns the value.
     |
     |      For more information, see https://redis.io/commands/rpoplpush
     |
     |  rpush(self, name: 'KeyT', *values: 'FieldT') -> 'int | Awaitable[int]'
     |      Push ``values`` onto the tail of the list ``name``
     |
     |      For more information, see https://redis.io/commands/rpush
     |
     |  rpushx(self, name: 'KeyT', *values: 'str') -> 'int | Awaitable[int]'
     |      Push ``value`` onto the tail of the list ``name`` if ``name`` exists
     |
     |      For more information, see https://redis.io/commands/rpushx
     |
     |  sort(self, name: 'KeyT', start: 'int | None' = None, num: 'int | None' = None, by: 'str | None' = None, get: 'list[str] | None' = None, desc: 'bool' = False, alpha: 'bool' = False, store: 'str | None' = None, groups: 'bool | None' = False) -> 'SortResponse | Awaitable[SortResponse]'
     |      Sort and return the list, set or sorted set at ``name``.
     |
     |      ``start`` and ``num`` allow for paging through the sorted data
     |
     |      ``by`` allows using an external key to weight and sort the items.
     |          Use an "*" to indicate where in the key the item value is located
     |
     |      ``get`` allows for returning items from external keys rather than the
     |          sorted data itself.  Use an "*" to indicate where in the key
     |          the item value is located
     |
     |      ``desc`` allows for reversing the sort
     |
     |      ``alpha`` allows for sorting lexicographically rather than numerically
     |
     |      ``store`` allows for storing the result of the sort into
     |          the key ``store``
     |
     |      ``groups`` if set to True and if ``get`` contains at least two
     |          elements, sort will return a list of tuples, each containing the
     |          values fetched from the arguments to ``get``.
     |
     |      For more information, see https://redis.io/commands/sort
     |
     |  sort_ro(self, key: 'str', start: 'int | None' = None, num: 'int | None' = None, by: 'str | None' = None, get: 'list[str] | None' = None, desc: 'bool' = False, alpha: 'bool' = False) -> 'list[bytes | str] | Awaitable[list[bytes | str]]'
     |      Returns the elements contained in the list, set or sorted set at key.
     |      (read-only variant of the SORT command)
     |
     |      ``start`` and ``num`` allow for paging through the sorted data
     |
     |      ``by`` allows using an external key to weight and sort the items.
     |          Use an "*" to indicate where in the key the item value is located
     |
     |      ``get`` allows for returning items from external keys rather than the
     |          sorted data itself.  Use an "*" to indicate where in the key
     |          the item value is located
     |
     |      ``desc`` allows for reversing the sort
     |
     |      ``alpha`` allows for sorting lexicographically rather than numerically
     |
     |      For more information, see https://redis.io/commands/sort_ro
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from redis.commands.core.ArrayCommands:
     |
     |  arcount(self, name: 'KeyT') -> 'int | Awaitable[int]'
     |      Return the number of non-empty elements in the array stored at
     |      ``name``. Returns 0 if ``name`` does not exist.
     |
     |      For more information, see https://redis.io/commands/arcount
     |
     |  ardel(self, name: 'KeyT', *indices: 'int') -> 'int | Awaitable[int]'
     |      Delete elements at the specified ``indices`` in the array stored at
     |      ``name``. Deleting an index that does not exist counts as zero
     |      elements deleted and does not modify the array.
     |
     |      Returns the number of elements deleted.
     |
     |      For more information, see https://redis.io/commands/ardel
     |
     |  ardelrange(self, name: 'KeyT', *ranges: 'tuple[int, int]') -> 'int | Awaitable[int]'
     |      Delete elements within one or more inclusive index ranges in the
     |      array stored at ``name``. Each range is a ``(start, end)`` tuple.
     |      If ``start`` is greater than ``end`` for a given pair, the range is
     |      processed in ascending order regardless. Multiple pairs may overlap;
     |      each element is counted at most once.
     |
     |      Returns the number of elements deleted.
     |
     |      For more information, see https://redis.io/commands/ardelrange
     |
     |  arget(self, name: 'KeyT', index: 'int') -> 'bytes | str | None | Awaitable[bytes | str | None]'
     |      Return the value at ``index`` in the array stored at ``name``.
     |
     |      Returns ``None`` if ``name`` does not exist or no value is set at
     |      ``index``.
     |
     |      For more information, see https://redis.io/commands/arget
     |
     |  argetrange(self, name: 'KeyT', start: 'int', end: 'int') -> 'list[bytes | str | None] | Awaitable[list[bytes | str | None]]'
     |      Return the values in the inclusive index range [``start``, ``end``]
     |      in the array stored at ``name``. If ``start`` is greater than ``end``,
     |      elements are returned in reverse index order.
     |
     |      For more information, see https://redis.io/commands/argetrange
     |
     |  argrep(self, name: 'KeyT', start: 'int', end: 'int', predicates: 'list[tuple[ArrayPredicateType, EncodableT]]', combinator: 'ArrayPredicateCombinator | None' = None, limit: 'int | None' = None, withvalues: 'bool' = False, nocase: 'bool' = False) -> 'list[int] | list[list[int | bytes | str]] | Awaitable[list[int] | list[list[int | bytes | str]]]'
     |      Search elements of the array stored at ``name`` within the inclusive
     |      index range [``start``, ``end``] using one or more textual
     |      ``predicates``. Each predicate is a ``(type, value)`` tuple where
     |      ``type`` is a member of ``ArrayPredicateType``
     |      (``EXACT``, ``MATCH``, ``GLOB``, ``RE``).
     |
     |      Multiple predicates are combined via ``combinator``
     |      (``ArrayPredicateCombinator.AND`` or ``OR``); the server defaults to
     |      OR when omitted. ``limit`` caps the number of matches.
     |      ``withvalues=True`` returns a list of ``[index, value]`` pairs
     |      (``[[idx, val], ...]``) instead of a flat list of indices.
     |      ``nocase=True`` makes all comparisons case-insensitive.
     |
     |      Without ``withvalues``, returns a flat list of matching indices in
     |      traversal order. With ``withvalues``, returns a list of
     |      ``[index, value]`` pairs in traversal order. Empty slots are
     |      skipped.
     |
     |      For more information, see https://redis.io/commands/argrep
     |
     |  arinfo(self, name: 'KeyT', full: 'bool' = False) -> 'dict[str, int] | Awaitable[dict[str, int]]'
     |      Return metadata about the array stored at ``name`` as a dictionary.
     |      When ``full`` is ``True``, additionally include per-slice statistics
     |      (dense/sparse slice counts, average sizes, fill rates), which makes
     |      the call O(N) instead of O(1).
     |
     |      Raises ``ResponseError`` when the key does not exist.
     |
     |      For more information, see https://redis.io/commands/arinfo
     |
     |  arinsert(self, name: 'KeyT', *values: 'FieldT') -> 'int | Awaitable[int]'
     |      Insert one or more ``values`` at consecutive indices in the array
     |      stored at ``name``, beginning at the current insert cursor position.
     |      The cursor advances by one for each value inserted. Use ``ARNEXT``
     |      to inspect the current cursor position and ``ARSEEK`` to reposition
     |      it.
     |
     |      Returns the last index where a value was inserted.
     |
     |      For more information, see https://redis.io/commands/arinsert
     |
     |  arlastitems(self, name: 'KeyT', count: 'int', rev: 'bool' = False) -> 'list[bytes | str | None] | Awaitable[list[bytes | str | None]]'
     |      Return up to ``count`` most recently inserted elements from the array
     |      stored at ``name``. If the array contains fewer elements than
     |      ``count``, all elements are returned.
     |
     |      When ``rev`` is ``True``, elements are returned in reverse
     |      chronological order (most recent first) instead of the default
     |      oldest-first order.
     |
     |      For more information, see https://redis.io/commands/arlastitems
     |
     |  arlen(self, name: 'KeyT') -> 'int | Awaitable[int]'
     |      Return the length of the array stored at ``name``, defined as the
     |      maximum set index plus one. Returns 0 if ``name`` does not exist.
     |
     |      For more information, see https://redis.io/commands/arlen
     |
     |  armget(self, name: 'KeyT', *indices: 'int') -> 'list[bytes | str | None] | Awaitable[list[bytes | str | None]]'
     |      Return the values at the specified ``indices`` in the array stored at
     |      ``name``. The reply preserves the order of the requested indices and
     |      returns ``None`` for any index that is not set or when ``name`` does
     |      not exist.
     |
     |      For more information, see https://redis.io/commands/armget
     |
     |  armset(self, name: 'KeyT', mapping: 'Mapping[int, FieldT]') -> 'int | Awaitable[int]'
     |      Set multiple index/value pairs in the array stored at ``name``.
     |      ``mapping`` is a dictionary of zero-based integer indices to values.
     |      Pairs may be non-contiguous and in any order.
     |
     |      Returns the number of new slots that were set (previously empty).
     |
     |      For more information, see https://redis.io/commands/armset
     |
     |  arnext(self, name: 'KeyT') -> 'int | None | Awaitable[int | None]'
     |      Return the next index ``ARINSERT`` would use for the array stored at
     |      ``name``. Returns 0 if ``name`` does not exist or no insert happened
     |      yet, and ``None`` when the insertion cursor is exhausted (next insert
     |      would overflow).
     |
     |      For more information, see https://redis.io/commands/arnext
     |
     |  arop(self, name: 'KeyT', start: 'int', end: 'int', operation: 'ArrayAggregateOperations', value: 'EncodableT | None' = None) -> 'bytes | str | int | None | Awaitable[bytes | str | int | None]'
     |      Perform an aggregate ``operation`` on elements of the array stored at
     |      ``name`` in the inclusive index range [``start``, ``end``]. The range
     |      is always scanned from the lower to the higher index regardless of
     |      argument order.
     |
     |      ``operation`` is one of the members of ``ArrayAggregateOperations``.
     |      ``value`` is required when ``operation`` is
     |      ``ArrayAggregateOperations.MATCH`` and specifies the value to compare
     |      against.
     |
     |      Returns a bulk string for ``SUM``, ``MIN`` and ``MAX``, an integer
     |      for ``AND``, ``OR``, ``XOR``, ``MATCH`` and ``USED``, or ``None``
     |      when no elements match the operation.
     |
     |      For more information, see https://redis.io/commands/arop
     |
     |  arring(self, name: 'KeyT', size: 'int', *values: 'FieldT') -> 'int | Awaitable[int]'
     |      Insert one or more ``values`` into the array stored at ``name`` as a
     |      fixed-size ring buffer of ``size`` slots. Each value is placed at
     |      ``insert_idx % size``, wrapping back to index 0 once the end is
     |      reached and overwriting older values when full. If ``size`` is
     |      smaller than the current window, the array is truncated to fit.
     |
     |      Returns the last index where a value was inserted.
     |
     |      For more information, see https://redis.io/commands/arring
     |
     |  arscan(self, name: 'KeyT', start: 'int', end: 'int', limit: 'int | None' = None) -> 'list[list[int | bytes | str]] | Awaitable[list[list[int | bytes | str]]]'
     |      Iterate populated elements of the array stored at ``name`` in the
     |      inclusive range [``start``, ``end``] and return a list of
     |      ``[index, value]`` pairs in traversal order:
     |      ``[[idx1, val1], [idx2, val2], ...]``. Empty slots are skipped. If
     |      ``start`` is greater than ``end``, the iteration is reversed.
     |
     |      ``limit`` caps the number of populated elements returned. When
     |      omitted, all populated elements in range are returned.
     |
     |      For more information, see https://redis.io/commands/arscan
     |
     |  arseek(self, name: 'KeyT', index: 'int') -> 'int | Awaitable[int]'
     |      Set the insert cursor of the array stored at ``name`` to ``index``.
     |      Subsequent ``ARINSERT`` and ``ARRING`` operations begin inserting at
     |      this position.
     |
     |      Returns 1 if the cursor was set, 0 if ``name`` does not exist.
     |
     |      For more information, see https://redis.io/commands/arseek
     |
     |  arset(self, name: 'KeyT', index: 'int', *values: 'FieldT') -> 'int | Awaitable[int]'
     |      Set one or more contiguous ``values`` in the array stored at ``name``
     |      starting at ``index``. When multiple values are provided, they are
     |      stored at consecutive indices beginning at ``index``.
     |
     |      Returns the number of new slots that were set (previously empty).
     |
     |      For more information, see https://redis.io/commands/arset
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from redis.commands.core.ScanCommands:
     |
     |  hscan(self, name: 'KeyT', cursor: 'int' = 0, match: 'PatternT | None' = None, count: 'int | None' = None, no_values: 'bool | None' = None) -> 'HScanResponse | Awaitable[HScanResponse]'
     |      Incrementally return key/value slices in a hash. Also return a cursor
     |      indicating the scan position.
     |
     |      ``match`` allows for filtering the keys by pattern
     |
     |      ``count`` allows for hint the minimum number of returns
     |
     |      ``no_values`` indicates to return only the keys, without values.
     |
     |      For more information, see https://redis.io/commands/hscan
     |
     |  hscan_iter(self, name: 'KeyT', match: 'Union[PatternT, None]' = None, count: 'Optional[int]' = None, no_values: 'Union[bool, None]' = None) -> 'Iterator'
     |      Make an iterator using the HSCAN command so that the client doesn't
     |      need to remember the cursor position.
     |
     |      ``match`` allows for filtering the keys by pattern
     |
     |      ``count`` allows for hint the minimum number of returns
     |
     |      ``no_values`` indicates to return only the keys, without values
     |
     |  scan(self, cursor: 'int' = 0, match: 'PatternT | None' = None, count: 'int | None' = None, _type: 'str | None' = None, **kwargs) -> 'ScanResponse | Awaitable[ScanResponse]'
     |      Incrementally return lists of key names. Also return a cursor
     |      indicating the scan position.
     |
     |      ``match`` allows for filtering the keys by pattern
     |
     |      ``count`` provides a hint to Redis about the number of keys to
     |          return per batch.
     |
     |      ``_type`` filters the returned values by a particular Redis type.
     |          Stock Redis instances allow for the following types:
     |          HASH, LIST, SET, STREAM, STRING, ZSET
     |          Additionally, Redis modules can expose other types as well.
     |
     |      For more information, see https://redis.io/commands/scan
     |
     |  sscan(self, name: 'KeyT', cursor: 'int' = 0, match: 'PatternT | None' = None, count: 'int | None' = None) -> 'ScanResponse | Awaitable[ScanResponse]'
     |      Incrementally return lists of elements in a set. Also return a cursor
     |      indicating the scan position.
     |
     |      ``match`` allows for filtering the keys by pattern
     |
     |      ``count`` allows for hint the minimum number of returns
     |
     |      For more information, see https://redis.io/commands/sscan
     |
     |  sscan_iter(self, name: 'KeyT', match: 'Union[PatternT, None]' = None, count: 'Optional[int]' = None) -> 'Iterator'
     |      Make an iterator using the SSCAN command so that the client doesn't
     |      need to remember the cursor position.
     |
     |      ``match`` allows for filtering the keys by pattern
     |
     |      ``count`` allows for hint the minimum number of returns
     |
     |  zscan(self, name: 'KeyT', cursor: 'int' = 0, match: 'PatternT | None' = None, count: 'int | None' = None, score_cast_func: 'type | Callable' = <class 'float'>) -> 'ZScanResponse | Awaitable[ZScanResponse]'
     |      Incrementally return lists of elements in a sorted set. Also return a
     |      cursor indicating the scan position.
     |
     |      ``match`` allows for filtering the keys by pattern
     |
     |      ``count`` allows for hint the minimum number of returns
     |
     |      ``score_cast_func`` a callable used to cast the score return value
     |
     |      For more information, see https://redis.io/commands/zscan
     |
     |  zscan_iter(self, name: 'KeyT', match: 'Union[PatternT, None]' = None, count: 'Optional[int]' = None, score_cast_func: 'Union[type, Callable]' = <class 'float'>) -> 'Iterator'
     |      Make an iterator using the ZSCAN command so that the client doesn't
     |      need to remember the cursor position.
     |
     |      ``match`` allows for filtering the keys by pattern
     |
     |      ``count`` allows for hint the minimum number of returns
     |
     |      ``score_cast_func`` a callable used to cast the score return value
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from redis.commands.core.SetCommands:
     |
     |  sadd(self, name: 'KeyT', *values: 'FieldT') -> 'int | Awaitable[int]'
     |      Add ``value(s)`` to set ``name``
     |
     |      For more information, see https://redis.io/commands/sadd
     |
     |  scard(self, name: 'KeyT') -> 'int | Awaitable[int]'
     |      Return the number of elements in set ``name``
     |
     |      For more information, see https://redis.io/commands/scard
     |
     |  sdiff(self, keys: 'List', *args: 'List') -> 'set[bytes | str] | Awaitable[set[bytes | str]]'
     |      Return the difference of sets specified by ``keys``
     |
     |      For more information, see https://redis.io/commands/sdiff
     |
     |  sdiffcard(self, numkeys: 'int', keys: 'List[KeyT]', limit: 'int' = 0) -> 'int | Awaitable[int]'
     |      Return the cardinality of the difference between the first set and all
     |      the successive sets specified by ``keys``, without returning the
     |      difference itself.
     |
     |      When LIMIT is provided (defaults to 0 and means unlimited), the returned
     |      cardinality is capped at ``limit`` and the server may stop the
     |      computation once the capped result is known.
     |
     |      For more information, see https://redis.io/commands/sdiffcard
     |
     |  sdiffstore(self, dest: 'str', keys: 'List', *args: 'List') -> 'int | Awaitable[int]'
     |      Store the difference of sets specified by ``keys`` into a new
     |      set named ``dest``.  Returns the number of keys in the new set.
     |
     |      For more information, see https://redis.io/commands/sdiffstore
     |
     |  sinter(self, keys: 'List', *args: 'List') -> 'set[bytes | str] | Awaitable[set[bytes | str]]'
     |      Return the intersection of sets specified by ``keys``
     |
     |      For more information, see https://redis.io/commands/sinter
     |
     |  sintercard(self, numkeys: 'int', keys: 'List[KeyT]', limit: 'int' = 0) -> 'int | Awaitable[int]'
     |      Return the cardinality of the intersect of multiple sets specified by ``keys``.
     |
     |      When LIMIT provided (defaults to 0 and means unlimited), if the intersection
     |      cardinality reaches limit partway through the computation, the algorithm will
     |      exit and yield limit as the cardinality
     |
     |      For more information, see https://redis.io/commands/sintercard
     |
     |  sinterstore(self, dest: 'KeyT', keys: 'List', *args: 'List') -> 'int | Awaitable[int]'
     |      Store the intersection of sets specified by ``keys`` into a new
     |      set named ``dest``.  Returns the number of keys in the new set.
     |
     |      For more information, see https://redis.io/commands/sinterstore
     |
     |  sismember(self, name: 'KeyT', value: 'str') -> 'Literal[0] | Literal[1] | Awaitable[Literal[0] | Literal[1]]'
     |      Return whether ``value`` is a member of set ``name``:
     |      - 1 if the value is a member of the set.
     |      - 0 if the value is not a member of the set or if key does not exist.
     |
     |      For more information, see https://redis.io/commands/sismember
     |
     |  smembers(self, name: 'KeyT') -> 'set[bytes | str] | Awaitable[set[bytes | str]]'
     |      Return all members of the set ``name``
     |
     |      For more information, see https://redis.io/commands/smembers
     |
     |  smismember(self, name: 'KeyT', values: 'List', *args: 'List') -> 'list[Literal[0] | Literal[1]] | Awaitable[list[Literal[0] | Literal[1]]]'
     |      Return whether each value in ``values`` is a member of the set ``name``
     |      as a list of ``int`` in the order of ``values``:
     |      - 1 if the value is a member of the set.
     |      - 0 if the value is not a member of the set or if key does not exist.
     |
     |      For more information, see https://redis.io/commands/smismember
     |
     |  smove(self, src: 'KeyT', dst: 'KeyT', value: 'str') -> 'bool | Awaitable[bool]'
     |      Move ``value`` from set ``src`` to set ``dst`` atomically
     |
     |      For more information, see https://redis.io/commands/smove
     |
     |  spop(self, name: 'KeyT', count: 'int | None' = None) -> 'bytes | str | set[bytes | str] | None | Awaitable[bytes | str | set[bytes | str] | None]'
     |      Remove and return a random member of set ``name``
     |
     |      For more information, see https://redis.io/commands/spop
     |
     |  srandmember(self, name: 'KeyT', number: 'int | None' = None) -> 'bytes | str | list[bytes | str] | None | Awaitable[bytes | str | list[bytes | str] | None]'
     |      If ``number`` is None, returns a random member of set ``name``.
     |
     |      If ``number`` is supplied, returns a list of ``number`` random
     |      members of set ``name``. Note this is only available when running
     |      Redis 2.6+.
     |
     |      For more information, see https://redis.io/commands/srandmember
     |
     |  srem(self, name: 'KeyT', *values: 'FieldT') -> 'int | Awaitable[int]'
     |      Remove ``values`` from set ``name``
     |
     |      For more information, see https://redis.io/commands/srem
     |
     |  sunion(self, keys: 'List', *args: 'List') -> 'set[bytes | str] | Awaitable[set[bytes | str]]'
     |      Return the union of sets specified by ``keys``
     |
     |      For more information, see https://redis.io/commands/sunion
     |
     |  sunioncard(self, numkeys: 'int', keys: 'List[KeyT]', limit: 'int' = 0, approx: 'bool' = False) -> 'int | Awaitable[int]'
     |      Return the cardinality of the union of multiple sets specified by
     |      ``keys``, without returning the union itself.
     |
     |      When ``approx`` is True, the ``APPROX`` option is sent and the server
     |      returns an approximate cardinality computed using HyperLogLog.
     |
     |      When LIMIT is provided (defaults to 0 and means unlimited), the returned
     |      cardinality is capped at ``limit``. In exact mode the result equals
     |      ``limit`` when the real cardinality exceeds ``limit``; in approximate
     |      mode the result will not exceed ``limit``. Options are emitted in the
     |      canonical order ``APPROX`` before ``LIMIT``.
     |
     |      For more information, see https://redis.io/commands/sunioncard
     |
     |  sunionstore(self, dest: 'KeyT', keys: 'List', *args: 'List') -> 'int | Awaitable[int]'
     |      Store the union of sets specified by ``keys`` into a new
     |      set named ``dest``.  Returns the number of keys in the new set.
     |
     |      For more information, see https://redis.io/commands/sunionstore
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from redis.commands.core.StreamCommands:
     |
     |  xack(self, name: 'KeyT', groupname: 'GroupT', *ids: 'StreamIdT') -> 'int | Awaitable[int]'
     |      Acknowledges the successful processing of one or more messages.
     |
     |      Args:
     |          name: name of the stream.
     |          groupname: name of the consumer group.
     |          *ids: message ids to acknowledge.
     |
     |      For more information, see https://redis.io/commands/xack
     |
     |  xackdel(self, name: 'KeyT', groupname: 'GroupT', *ids: 'StreamIdT', ref_policy: "Literal['KEEPREF', 'DELREF', 'ACKED']" = 'KEEPREF') -> 'int | Awaitable[int]'
     |      Combines the functionality of XACK and XDEL. Acknowledges the specified
     |      message IDs in the given consumer group and simultaneously attempts to
     |      delete the corresponding entries from the stream.
     |
     |  xadd(self, name: 'KeyT', fields: 'Dict[FieldT, EncodableT]', id: 'StreamIdT' = '*', maxlen: 'Optional[int]' = None, approximate: 'bool' = True, nomkstream: 'bool' = False, minid: 'Union[StreamIdT, None]' = None, limit: 'int | None' = None, ref_policy: "Literal['KEEPREF', 'DELREF', 'ACKED'] | None" = None, idmpauto: 'str | None' = None, idmp: 'tuple[str, bytes] | None' = None) -> 'bytes | str | Awaitable[bytes | str]'
     |      Add to a stream.
     |      name: name of the stream
     |      fields: dict of field/value pairs to insert into the stream
     |      id: Location to insert this record. By default it is appended.
     |      maxlen: truncate old stream members beyond this size.
     |      Can't be specified with minid.
     |      approximate: actual stream length may be slightly more than maxlen
     |      nomkstream: When set to true, do not make a stream
     |      minid: the minimum id in the stream to query.
     |      Can't be specified with maxlen.
     |      limit: specifies the maximum number of entries to retrieve
     |      ref_policy: optional reference policy for consumer groups when trimming:
     |          - KEEPREF (default): When trimming, preserves references in consumer groups' PEL
     |          - DELREF: When trimming, removes all references from consumer groups' PEL
     |          - ACKED: When trimming, only removes entries acknowledged by all consumer groups
     |      idmpauto: Producer ID for automatic idempotent ID calculation.
     |          Automatically calculates an idempotent ID based on entry content to prevent
     |          duplicate entries. Can only be used with id='*'. Creates an IDMP map if it
     |          doesn't exist yet. The producer ID must be unique per producer and consistent
     |          across restarts.
     |      idmp: Tuple of (producer_id, idempotent_id) for explicit idempotent ID.
     |          Uses a specific idempotent ID to prevent duplicate entries. Can only be used
     |          with id='*'. The producer ID must be unique per producer and consistent across
     |          restarts. The idempotent ID must be unique per message and per producer.
     |          Shorter idempotent IDs require less memory and allow faster processing.
     |          Creates an IDMP map if it doesn't exist yet.
     |
     |      For more information, see https://redis.io/commands/xadd
     |
     |  xautoclaim(self, name: 'KeyT', groupname: 'GroupT', consumername: 'ConsumerT', min_idle_time: 'int', start_id: 'StreamIdT' = '0-0', count: 'int | None' = None, justid: 'bool' = False) -> 'list[Any] | Awaitable[list[Any]]'
     |      Transfers ownership of pending stream entries that match the specified
     |      criteria. Conceptually, equivalent to calling XPENDING and then XCLAIM,
     |      but provides a more straightforward way to deal with message delivery
     |      failures via SCAN-like semantics.
     |      name: name of the stream.
     |      groupname: name of the consumer group.
     |      consumername: name of a consumer that claims the message.
     |      min_idle_time: filter messages that were idle less than this amount of
     |      milliseconds.
     |      start_id: filter messages with equal or greater ID.
     |      count: optional integer, upper limit of the number of entries that the
     |      command attempts to claim. Set to 100 by default.
     |      justid: optional boolean, false by default. Return just an array of IDs
     |      of messages successfully claimed, without returning the actual message
     |
     |      For more information, see https://redis.io/commands/xautoclaim
     |
     |  xcfgset(self, name: 'KeyT', idmp_duration: 'int | None' = None, idmp_maxsize: 'int | None' = None) -> 'bytes | str | Awaitable[bytes | str]'
     |      Configure the idempotency parameters for a stream's IDMP map.
     |
     |      Sets how long Redis remembers each idempotent ID (iid) and the maximum
     |      number of iids to track. This command clears the existing IDMP map
     |      (Redis forgets all previously stored iids), but only if the configuration
     |      value actually changes.
     |
     |      Args:
     |          name: The name of the stream.
     |          idmp_duration: How long Redis remembers each iid in seconds.
     |              Default: 100 seconds (or value set by stream-idmp-duration config).
     |              Minimum: 1 second, Maximum: 300 seconds.
     |              Redis won't forget an iid for this duration (unless maxsize is reached).
     |              Should accommodate application crash recovery time.
     |          idmp_maxsize: Maximum number of iids Redis remembers per producer ID (pid).
     |              Default: 100 iids (or value set by stream-idmp-maxsize config).
     |              Minimum: 1 iid, Maximum: 1,000,000 (1M) iids.
     |              Should be set to: mark-delay [in msec] × (messages/msec) + margin.
     |              Example: 10K msgs/sec (10 msgs/msec), 80 msec mark-delay
     |              → maxsize = 10 × 80 + margin = 1000 iids.
     |
     |      Returns:
     |          OK on success.
     |
     |      For more information, see https://redis.io/commands/xcfgset
     |
     |  xclaim(self, name: 'KeyT', groupname: 'GroupT', consumername: 'ConsumerT', min_idle_time: 'int', message_ids: 'Union[List[StreamIdT], Tuple[StreamIdT]]', idle: 'int | None' = None, time: 'int | None' = None, retrycount: 'int | None' = None, force: 'bool' = False, justid: 'bool' = False) -> 'XClaimResponse | Awaitable[XClaimResponse]'
     |      Changes the ownership of a pending message.
     |
     |      name: name of the stream.
     |
     |      groupname: name of the consumer group.
     |
     |      consumername: name of a consumer that claims the message.
     |
     |      min_idle_time: filter messages that were idle less than this amount of
     |      milliseconds
     |
     |      message_ids: non-empty list or tuple of message IDs to claim
     |
     |      idle: optional. Set the idle time (last time it was delivered) of the
     |      message in ms
     |
     |      time: optional integer. This is the same as idle but instead of a
     |      relative amount of milliseconds, it sets the idle time to a specific
     |      Unix time (in milliseconds).
     |
     |      retrycount: optional integer. set the retry counter to the specified
     |      value. This counter is incremented every time a message is delivered
     |      again.
     |
     |      force: optional boolean, false by default. Creates the pending message
     |      entry in the PEL even if certain specified IDs are not already in the
     |      PEL assigned to a different client.
     |
     |      justid: optional boolean, false by default. Return just an array of IDs
     |      of messages successfully claimed, without returning the actual message
     |
     |      For more information, see https://redis.io/commands/xclaim
     |
     |  xdel(self, name: 'KeyT', *ids: 'StreamIdT') -> 'int | Awaitable[int]'
     |      Deletes one or more messages from a stream.
     |
     |      Args:
     |          name: name of the stream.
     |          *ids: message ids to delete.
     |
     |      For more information, see https://redis.io/commands/xdel
     |
     |  xdelex(self, name: 'KeyT', *ids: 'StreamIdT', ref_policy: "Literal['KEEPREF', 'DELREF', 'ACKED']" = 'KEEPREF') -> 'int | Awaitable[int]'
     |      Extended version of XDEL that provides more control over how message entries
     |      are deleted concerning consumer groups.
     |
     |  xgroup_create(self, name: 'KeyT', groupname: 'GroupT', id: 'StreamIdT' = '$', mkstream: 'bool' = False, entries_read: 'int | None' = None) -> 'bool | Awaitable[bool]'
     |      Create a new consumer group associated with a stream.
     |      name: name of the stream.
     |      groupname: name of the consumer group.
     |      id: ID of the last item in the stream to consider already delivered.
     |
     |      For more information, see https://redis.io/commands/xgroup-create
     |
     |  xgroup_createconsumer(self, name: 'KeyT', groupname: 'GroupT', consumername: 'ConsumerT') -> 'int | Awaitable[int]'
     |      Consumers in a consumer group are auto-created every time a new
     |      consumer name is mentioned by some command.
     |      They can be explicitly created by using this command.
     |      name: name of the stream.
     |      groupname: name of the consumer group.
     |      consumername: name of consumer to create.
     |
     |      See: https://redis.io/commands/xgroup-createconsumer
     |
     |  xgroup_delconsumer(self, name: 'KeyT', groupname: 'GroupT', consumername: 'ConsumerT') -> 'int | Awaitable[int]'
     |      Remove a specific consumer from a consumer group.
     |      Returns the number of pending messages that the consumer had before it
     |      was deleted.
     |      name: name of the stream.
     |      groupname: name of the consumer group.
     |      consumername: name of consumer to delete
     |
     |      For more information, see https://redis.io/commands/xgroup-delconsumer
     |
     |  xgroup_destroy(self, name: 'KeyT', groupname: 'GroupT') -> 'bool | Awaitable[bool]'
     |      Destroy a consumer group.
     |      name: name of the stream.
     |      groupname: name of the consumer group.
     |
     |      For more information, see https://redis.io/commands/xgroup-destroy
     |
     |  xgroup_setid(self, name: 'KeyT', groupname: 'GroupT', id: 'StreamIdT', entries_read: 'int | None' = None) -> 'bool | Awaitable[bool]'
     |      Set the consumer group last delivered ID to something else.
     |      name: name of the stream.
     |      groupname: name of the consumer group.
     |      id: ID of the last item in the stream to consider already delivered.
     |
     |      For more information, see https://redis.io/commands/xgroup-setid
     |
     |  xinfo_consumers(self, name: 'KeyT', groupname: 'GroupT') -> 'list[dict[str, Any]] | Awaitable[list[dict[str, Any]]]'
     |      Returns general information about the consumers in the group.
     |      name: name of the stream.
     |      groupname: name of the consumer group.
     |
     |      For more information, see https://redis.io/commands/xinfo-consumers
     |
     |  xinfo_groups(self, name: 'KeyT') -> 'list[dict[str, Any]] | Awaitable[list[dict[str, Any]]]'
     |      Returns general information about the consumer groups of the stream.
     |      name: name of the stream.
     |
     |      For more information, see https://redis.io/commands/xinfo-groups
     |
     |  xinfo_stream(self, name: 'KeyT', full: 'bool' = False) -> 'dict[str, Any] | Awaitable[dict[str, Any]]'
     |      Returns general information about the stream.
     |      name: name of the stream.
     |      full: optional boolean, false by default. Return full summary
     |
     |      For more information, see https://redis.io/commands/xinfo-stream
     |
     |  xlen(self, name: 'KeyT') -> 'int | Awaitable[int]'
     |      Returns the number of elements in a given stream.
     |
     |      For more information, see https://redis.io/commands/xlen
     |
     |  xnack(self, name: 'KeyT', groupname: 'GroupT', mode: "Literal['SILENT', 'FAIL', 'FATAL']", *ids: 'StreamIdT', retrycount: 'int | None' = None, force: 'bool' = False) -> 'int | Awaitable[int]'
     |      Negatively acknowledges one or more messages in a consumer group's
     |      Pending Entries List (PEL).
     |
     |      Args:
     |          name: name of the stream.
     |          groupname: name of the consumer group.
     |          mode: the nacking mode. One of SILENT, FAIL, or FATAL.
     |              SILENT: consumer shutting down; decrements delivery counter.
     |              FAIL: consumer unable to process; delivery counter unchanged.
     |              FATAL: invalid/malicious message; delivery counter set to max.
     |          *ids: one or more message IDs to NACK.
     |          retrycount: optional integer >= 0. Overrides the mode's implicit
     |              delivery counter adjustment with an exact value.
     |          force: if True, creates a new unowned PEL entry for any ID not
     |              already in the group's PEL.
     |
     |      Returns:
     |          The number of messages successfully NACKed.
     |
     |      For more information, see https://redis.io/commands/xnack
     |
     |  xpending(self, name: 'KeyT', groupname: 'GroupT') -> 'dict[str, Any] | Awaitable[dict[str, Any]]'
     |      Returns information about pending messages of a group.
     |      name: name of the stream.
     |      groupname: name of the consumer group.
     |
     |      For more information, see https://redis.io/commands/xpending
     |
     |  xpending_range(self, name: 'KeyT', groupname: 'GroupT', min: 'StreamIdT', max: 'StreamIdT', count: 'int', consumername: 'ConsumerT | None' = None, idle: 'int | None' = None) -> 'XPendingRangeResponse | Awaitable[XPendingRangeResponse]'
     |      Returns information about pending messages, in a range.
     |
     |      name: name of the stream.
     |      groupname: name of the consumer group.
     |      idle: available from  version 6.2. filter entries by their
     |      idle-time, given in milliseconds (optional).
     |      min: minimum stream ID.
     |      max: maximum stream ID.
     |      count: number of messages to return
     |      consumername: name of a consumer to filter by (optional).
     |
     |  xrange(self, name: 'KeyT', min: 'StreamIdT' = '-', max: 'StreamIdT' = '+', count: 'int | None' = None) -> 'StreamRangeResponse | None | Awaitable[StreamRangeResponse | None]'
     |      Read stream values within an interval.
     |
     |      name: name of the stream.
     |
     |      start: first stream ID. defaults to '-',
     |             meaning the earliest available.
     |
     |      finish: last stream ID. defaults to '+',
     |              meaning the latest available.
     |
     |      count: if set, only return this many items, beginning with the
     |             earliest available.
     |
     |      For more information, see https://redis.io/commands/xrange
     |
     |  xread(self, streams: 'Dict[KeyT, StreamIdT]', count: 'int | None' = None, block: 'int | None' = None, max_count: 'int | None' = None, max_size: 'int | None' = None) -> 'XReadResponse | Awaitable[XReadResponse]'
     |      Block and monitor multiple streams for new data.
     |
     |      streams: a dict of stream names to stream IDs, where
     |                 IDs indicate the last ID already seen.
     |
     |      count: if set, only return this many items per stream, beginning with
     |             the earliest available.
     |
     |      block: number of milliseconds to wait, if nothing already present.
     |
     |      max_count: if set, cap the total number of entries returned across all
     |                 streams combined. Unlike ``count`` (a per-stream limit),
     |                 this is a cumulative cap over the whole reply. Must be a
     |                 positive integer and, when ``count`` is also set, must be
     |                 greater than or equal to ``count``. Requires Redis >= 8.10.0.
     |
     |      max_size: if set, a soft cap on the total server reply size in bytes
     |                across all streams combined. Measured server-side including
     |                protocol overhead, so it is not an exact application-payload
     |                size guarantee; a single available entry larger than the cap
     |                may still be returned. Must be a positive integer. Requires
     |                Redis >= 8.10.0.
     |
     |      For more information, see https://redis.io/commands/xread
     |
     |  xreadgroup(self, groupname: 'str', consumername: 'str', streams: 'Dict[KeyT, StreamIdT]', count: 'int | None' = None, block: 'int | None' = None, noack: 'bool' = False, claim_min_idle_time: 'int | None' = None, max_count: 'int | None' = None, max_size: 'int | None' = None) -> 'XReadGroupResponse | Awaitable[XReadGroupResponse]'
     |      Read from a stream via a consumer group.
     |
     |      groupname: name of the consumer group.
     |
     |      consumername: name of the requesting consumer.
     |
     |      streams: a dict of stream names to stream IDs, where
     |             IDs indicate the last ID already seen.
     |
     |      count: if set, only return this many items per stream, beginning with
     |             the earliest available.
     |
     |      block: number of milliseconds to wait, if nothing already present.
     |      noack: do not add messages to the PEL
     |
     |      claim_min_idle_time: accepts an integer type and represents a
     |                           time interval in milliseconds
     |
     |      max_count: if set, cap the total number of entries returned across all
     |                 streams combined. Unlike ``count`` (a per-stream limit),
     |                 this is a cumulative cap over the whole reply. Must be a
     |                 positive integer and, when ``count`` is also set, must be
     |                 greater than or equal to ``count``. Requires Redis 8.10.0.
     |
     |      max_size: if set, a soft cap on the total server reply size in bytes
     |                across all streams combined. Measured server-side including
     |                protocol overhead, so it is not an exact application-payload
     |                size guarantee; a single available entry larger than the cap
     |                may still be returned. Must be a positive integer. Requires
     |                Redis 8.10.0.
     |
     |      For more information, see https://redis.io/commands/xreadgroup
     |
     |  xrevrange(self, name: 'KeyT', max: 'StreamIdT' = '+', min: 'StreamIdT' = '-', count: 'int | None' = None) -> 'StreamRangeResponse | None | Awaitable[StreamRangeResponse | None]'
     |      Read stream values within an interval, in reverse order.
     |
     |      name: name of the stream
     |
     |      start: first stream ID. defaults to '+',
     |             meaning the latest available.
     |
     |      finish: last stream ID. defaults to '-',
     |              meaning the earliest available.
     |
     |      count: if set, only return this many items, beginning with the
     |             latest available.
     |
     |      For more information, see https://redis.io/commands/xrevrange
     |
     |  xtrim(self, name: 'KeyT', maxlen: 'int | None' = None, approximate: 'bool' = True, minid: 'StreamIdT | None' = None, limit: 'int | None' = None, ref_policy: "Literal['KEEPREF', 'DELREF', 'ACKED'] | None" = None) -> 'int | Awaitable[int]'
     |      Trims old messages from a stream.
     |      name: name of the stream.
     |      maxlen: truncate old stream messages beyond this size
     |      Can't be specified with minid.
     |      approximate: actual stream length may be slightly more than maxlen
     |      minid: the minimum id in the stream to query
     |      Can't be specified with maxlen.
     |      limit: specifies the maximum number of entries to retrieve
     |      ref_policy: optional reference policy for consumer groups:
     |          - KEEPREF (default): Trims entries but preserves references in consumer groups' PEL
     |          - DELREF: Trims entries and removes all references from consumer groups' PEL
     |          - ACKED: Only trims entries that were read and acknowledged by all consumer groups
     |
     |      For more information, see https://redis.io/commands/xtrim
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from redis.commands.core.SortedSetCommands:
     |
     |  bzmpop(self, timeout: 'float', numkeys: 'int', keys: 'List[str]', min: 'bool | None' = False, max: 'bool | None' = False, count: 'int | None' = 1) -> 'ZMPopResponse | Awaitable[ZMPopResponse]'
     |      Pop ``count`` values (default 1) off of the first non-empty sorted set
     |      named in the ``keys`` list.
     |
     |      If none of the sorted sets in ``keys`` has a value to pop,
     |      then block for ``timeout`` seconds, or until a member gets added
     |      to one of the sorted sets.
     |
     |      If timeout is 0, then block indefinitely.
     |
     |      For more information, see https://redis.io/commands/bzmpop
     |
     |  bzpopmax(self, keys: 'KeysT', timeout: 'TimeoutSecT' = 0) -> 'BlockingZSetPopResponse | Awaitable[BlockingZSetPopResponse]'
     |      ZPOPMAX a value off of the first non-empty sorted set
     |      named in the ``keys`` list.
     |
     |      If none of the sorted sets in ``keys`` has a value to ZPOPMAX,
     |      then block for ``timeout`` seconds, or until a member gets added
     |      to one of the sorted sets.
     |
     |      If timeout is 0, then block indefinitely.
     |
     |      For more information, see https://redis.io/commands/bzpopmax
     |
     |  bzpopmin(self, keys: 'KeysT', timeout: 'TimeoutSecT' = 0) -> 'BlockingZSetPopResponse | Awaitable[BlockingZSetPopResponse]'
     |      ZPOPMIN a value off of the first non-empty sorted set
     |      named in the ``keys`` list.
     |
     |      If none of the sorted sets in ``keys`` has a value to ZPOPMIN,
     |      then block for ``timeout`` seconds, or until a member gets added
     |      to one of the sorted sets.
     |
     |      If timeout is 0, then block indefinitely.
     |
     |      For more information, see https://redis.io/commands/bzpopmin
     |
     |  zadd(self, name: 'KeyT', mapping: 'Mapping[AnyKeyT, EncodableT]', nx: 'bool' = False, xx: 'bool' = False, ch: 'bool' = False, incr: 'bool' = False, gt: 'bool' = False, lt: 'bool' = False) -> 'int | float | None | Awaitable[int | float | None]'
     |      Set any number of element-name, score pairs to the key ``name``. Pairs
     |      are specified as a dict of element-names keys to score values.
     |
     |      ``nx`` forces ZADD to only create new elements and not to update
     |      scores for elements that already exist.
     |
     |      ``xx`` forces ZADD to only update scores of elements that already
     |      exist. New elements will not be added.
     |
     |      ``ch`` modifies the return value to be the numbers of elements changed.
     |      Changed elements include new elements that were added and elements
     |      whose scores changed.
     |
     |      ``incr`` modifies ZADD to behave like ZINCRBY. In this mode only a
     |      single element/score pair can be specified and the score is the amount
     |      the existing score will be incremented by. When using this mode the
     |      return value of ZADD will be the new score of the element.
     |
     |      ``lt`` only updates existing elements if the new score is less than
     |      the current score. This flag doesn't prevent adding new elements.
     |
     |      ``gt`` only updates existing elements if the new score is greater than
     |      the current score. This flag doesn't prevent adding new elements.
     |
     |      The return value of ZADD varies based on the mode specified. With no
     |      options, ZADD returns the number of new elements added to the sorted
     |      set.
     |
     |      ``nx``, ``lt``, and ``gt`` are mutually exclusive options.
     |
     |      See: https://redis.io/commands/ZADD
     |
     |  zcard(self, name: 'KeyT') -> 'int | Awaitable[int]'
     |      Return the number of elements in the sorted set ``name``
     |
     |      For more information, see https://redis.io/commands/zcard
     |
     |  zcount(self, name: 'KeyT', min: 'ZScoreBoundT', max: 'ZScoreBoundT') -> 'int | Awaitable[int]'
     |      Returns the number of elements in the sorted set at key ``name`` with
     |      a score between ``min`` and ``max``.
     |
     |      For more information, see https://redis.io/commands/zcount
     |
     |  zdiff(self, keys: 'KeysT', withscores: 'bool' = False) -> 'ZSetRangeResponse | Awaitable[ZSetRangeResponse]'
     |      Returns the difference between the first and all successive input
     |      sorted sets provided in ``keys``.
     |
     |      For more information, see https://redis.io/commands/zdiff
     |
     |  zdiffstore(self, dest: 'KeyT', keys: 'KeysT') -> 'int | Awaitable[int]'
     |      Computes the difference between the first and all successive input
     |      sorted sets provided in ``keys`` and stores the result in ``dest``.
     |
     |      For more information, see https://redis.io/commands/zdiffstore
     |
     |  zincrby(self, name: 'KeyT', amount: 'float', value: 'EncodableT') -> 'float | None | Awaitable[float | None]'
     |      Increment the score of ``value`` in sorted set ``name`` by ``amount``
     |
     |      For more information, see https://redis.io/commands/zincrby
     |
     |  zinter(self, keys: 'KeysT', aggregate: 'str | None' = None, withscores: 'bool' = False) -> 'ZSetRangeResponse | Awaitable[ZSetRangeResponse]'
     |      Return the intersect of multiple sorted sets specified by ``keys``.
     |
     |      With the ``aggregate`` option, it is possible to specify how the
     |      results of the intersection are aggregated. Available aggregation
     |      modes:
     |
     |      - ``SUM`` (default): the score of an element is summed across the
     |        inputs where it exists.
     |        Score = SUM(score₁×weight₁, score₂×weight₂, ...)
     |      - ``MIN``: the resulting set will contain the minimum score of an
     |        element across the inputs where it exists.
     |        Score = MIN(score₁×weight₁, score₂×weight₂, ...)
     |      - ``MAX``: the resulting set will contain the maximum score of an
     |        element across the inputs where it exists.
     |        Score = MAX(score₁×weight₁, score₂×weight₂, ...)
     |      - ``COUNT``: ignores the original scores and counts weighted set
     |        membership. Each element's score is the sum of the weights of
     |        the input sets that contain it.
     |        Score = SUM(weight₁, weight₂, ...) for sets containing the element.
     |        When all weights are 1 (default), the score equals the number
     |        of input sets containing the element.
     |
     |      For more information, see https://redis.io/commands/zinter
     |
     |  zintercard(self, numkeys: 'int', keys: 'List[str]', limit: 'int' = 0) -> 'int | Awaitable[int]'
     |      Return the cardinality of the intersect of multiple sorted sets
     |      specified by ``keys``.
     |      When LIMIT provided (defaults to 0 and means unlimited), if the intersection
     |      cardinality reaches limit partway through the computation, the algorithm will
     |      exit and yield limit as the cardinality
     |
     |      For more information, see https://redis.io/commands/zintercard
     |
     |  zinterstore(self, dest: 'KeyT', keys: 'Sequence[KeyT] | Mapping[AnyKeyT, float]', aggregate: 'str | None' = None) -> 'int | Awaitable[int]'
     |      Intersect multiple sorted sets specified by ``keys`` into a new
     |      sorted set, ``dest``. Scores in the destination will be aggregated
     |      based on the ``aggregate``.
     |
     |      Available aggregation modes:
     |
     |      - ``SUM`` (default): the score of an element is summed across the
     |        inputs where it exists.
     |        Score = SUM(score₁×weight₁, score₂×weight₂, ...)
     |      - ``MIN``: the resulting set will contain the minimum score of an
     |        element across the inputs where it exists.
     |        Score = MIN(score₁×weight₁, score₂×weight₂, ...)
     |      - ``MAX``: the resulting set will contain the maximum score of an
     |        element across the inputs where it exists.
     |        Score = MAX(score₁×weight₁, score₂×weight₂, ...)
     |      - ``COUNT``: ignores the original scores and counts weighted set
     |        membership. Each element's score is the sum of the weights of
     |        the input sets that contain it.
     |        Score = SUM(weight₁, weight₂, ...) for sets containing the element.
     |        When all weights are 1 (default), the score equals the number
     |        of input sets containing the element.
     |
     |      For more information, see https://redis.io/commands/zinterstore
     |
     |  zlexcount(self, name: 'KeyT', min: 'EncodableT', max: 'EncodableT') -> 'int | Awaitable[int]'
     |      Return the number of items in the sorted set ``name`` between the
     |      lexicographical range ``min`` and ``max``.
     |
     |      For more information, see https://redis.io/commands/zlexcount
     |
     |  zmpop(self, num_keys: 'int', keys: 'List[str]', min: 'bool | None' = False, max: 'bool | None' = False, count: 'int | None' = 1) -> 'ZMPopResponse | Awaitable[ZMPopResponse]'
     |      Pop ``count`` values (default 1) off of the first non-empty sorted set
     |      named in the ``keys`` list.
     |      For more information, see https://redis.io/commands/zmpop
     |
     |  zmscore(self, key: 'KeyT', members: 'List[str]') -> 'list[float | None] | Awaitable[list[float | None]]'
     |      Returns the scores associated with the specified members
     |      in the sorted set stored at key.
     |      ``members`` should be a list of the member name.
     |      Return type is a list of score.
     |      If the member does not exist, a None will be returned
     |      in corresponding position.
     |
     |      For more information, see https://redis.io/commands/zmscore
     |
     |  zpopmax(self, name: 'KeyT', count: 'int | None' = None) -> 'ZSetRangeResponse | Awaitable[ZSetRangeResponse]'
     |      Remove and return up to ``count`` members with the highest scores
     |      from the sorted set ``name``.
     |
     |      For more information, see https://redis.io/commands/zpopmax
     |
     |  zpopmin(self, name: 'KeyT', count: 'int | None' = None) -> 'ZSetRangeResponse | Awaitable[ZSetRangeResponse]'
     |      Remove and return up to ``count`` members with the lowest scores
     |      from the sorted set ``name``.
     |
     |      For more information, see https://redis.io/commands/zpopmin
     |
     |  zrandmember(self, key: 'KeyT', count: 'int | None' = None, withscores: 'bool' = False) -> 'ZRandMemberResponse | Awaitable[ZRandMemberResponse]'
     |      Return a random element from the sorted set value stored at key.
     |
     |      ``count`` if the argument is positive, return an array of distinct
     |      fields. If called with a negative count, the behavior changes and
     |      the command is allowed to return the same field multiple times.
     |      In this case, the number of returned fields is the absolute value
     |      of the specified count.
     |
     |      ``withscores`` The optional WITHSCORES modifier changes the reply so it
     |      includes the respective scores of the randomly selected elements from
     |      the sorted set.
     |
     |      For more information, see https://redis.io/commands/zrandmember
     |
     |  zrange(self, name: 'KeyT', start: 'EncodableT', end: 'EncodableT', desc: 'bool' = False, withscores: 'bool' = False, score_cast_func: 'type | Callable' = <class 'float'>, byscore: 'bool' = False, bylex: 'bool' = False, offset: 'int | None' = None, num: 'int | None' = None) -> 'ZSetRangeResponse | Awaitable[ZSetRangeResponse]'
     |      Return a range of values from sorted set ``name`` between
     |      ``start`` and ``end`` sorted in ascending order.
     |
     |      ``start`` and ``end`` can be negative, indicating the end of the range.
     |
     |      ``desc`` a boolean indicating whether to sort the results in reversed
     |      order.
     |
     |      ``withscores`` indicates to return the scores along with the values.
     |      The return type is a list of (value, score) pairs.
     |
     |      ``score_cast_func`` a callable used to cast the score return value.
     |
     |      ``byscore`` when set to True, returns the range of elements from the
     |      sorted set having scores equal or between ``start`` and ``end``.
     |
     |      ``bylex`` when set to True, returns the range of elements from the
     |      sorted set between the ``start`` and ``end`` lexicographical closed
     |      range intervals.
     |      Valid ``start`` and ``end`` must start with ( or [, in order to specify
     |      whether the range interval is exclusive or inclusive, respectively.
     |
     |      ``offset`` and ``num`` are specified, then return a slice of the range.
     |      Can't be provided when using ``bylex``.
     |
     |      For more information, see https://redis.io/commands/zrange
     |
     |  zrangebylex(self, name: 'KeyT', min: 'EncodableT', max: 'EncodableT', start: 'int | None' = None, num: 'int | None' = None) -> 'list[bytes | str] | Awaitable[list[bytes | str]]'
     |      Return the lexicographical range of values from sorted set ``name``
     |      between ``min`` and ``max``.
     |
     |      If ``start`` and ``num`` are specified, then return a slice of the
     |      range.
     |
     |      For more information, see https://redis.io/commands/zrangebylex
     |
     |  zrangebyscore(self, name: 'KeyT', min: 'ZScoreBoundT', max: 'ZScoreBoundT', start: 'int | None' = None, num: 'int | None' = None, withscores: 'bool' = False, score_cast_func: 'type | Callable' = <class 'float'>) -> 'ZSetRangeResponse | Awaitable[ZSetRangeResponse]'
     |      Return a range of values from the sorted set ``name`` with scores
     |      between ``min`` and ``max``.
     |
     |      If ``start`` and ``num`` are specified, then return a slice
     |      of the range.
     |
     |      ``withscores`` indicates to return the scores along with the values.
     |      The return type is a list of (value, score) pairs
     |
     |      `score_cast_func`` a callable used to cast the score return value
     |
     |      For more information, see https://redis.io/commands/zrangebyscore
     |
     |  zrangestore(self, dest: 'KeyT', name: 'KeyT', start: 'EncodableT', end: 'EncodableT', byscore: 'bool' = False, bylex: 'bool' = False, desc: 'bool' = False, offset: 'int | None' = None, num: 'int | None' = None) -> 'int | Awaitable[int]'
     |      Stores in ``dest`` the result of a range of values from sorted set
     |      ``name`` between ``start`` and ``end`` sorted in ascending order.
     |
     |      ``start`` and ``end`` can be negative, indicating the end of the range.
     |
     |      ``byscore`` when set to True, returns the range of elements from the
     |      sorted set having scores equal or between ``start`` and ``end``.
     |
     |      ``bylex`` when set to True, returns the range of elements from the
     |      sorted set between the ``start`` and ``end`` lexicographical closed
     |      range intervals.
     |      Valid ``start`` and ``end`` must start with ( or [, in order to specify
     |      whether the range interval is exclusive or inclusive, respectively.
     |
     |      ``desc`` a boolean indicating whether to sort the results in reversed
     |      order.
     |
     |      ``offset`` and ``num`` are specified, then return a slice of the range.
     |      Can't be provided when using ``bylex``.
     |
     |      For more information, see https://redis.io/commands/zrangestore
     |
     |  zrank(self, name: 'KeyT', value: 'EncodableT', withscore: 'bool' = False, score_cast_func: 'type | Callable' = <class 'float'>) -> 'int | list[Any] | None | Awaitable[int | list[Any] | None]'
     |      Returns a 0-based value indicating the rank of ``value`` in sorted set
     |      ``name``.
     |      The optional WITHSCORE argument supplements the command's
     |      reply with the score of the element returned.
     |
     |      ``score_cast_func`` a callable used to cast the score return value
     |
     |      For more information, see https://redis.io/commands/zrank
     |
     |  zrem(self, name: 'KeyT', *values: 'FieldT') -> 'int | Awaitable[int]'
     |      Remove member ``values`` from sorted set ``name``
     |
     |      For more information, see https://redis.io/commands/zrem
     |
     |  zremrangebylex(self, name: 'KeyT', min: 'EncodableT', max: 'EncodableT') -> 'int | Awaitable[int]'
     |      Remove all elements in the sorted set ``name`` between the
     |      lexicographical range specified by ``min`` and ``max``.
     |
     |      Returns the number of elements removed.
     |
     |      For more information, see https://redis.io/commands/zremrangebylex
     |
     |  zremrangebyrank(self, name: 'KeyT', min: 'int', max: 'int') -> 'int | Awaitable[int]'
     |      Remove all elements in the sorted set ``name`` with ranks between
     |      ``min`` and ``max``. Values are 0-based, ordered from smallest score
     |      to largest. Values can be negative indicating the highest scores.
     |      Returns the number of elements removed
     |
     |      For more information, see https://redis.io/commands/zremrangebyrank
     |
     |  zremrangebyscore(self, name: 'KeyT', min: 'ZScoreBoundT', max: 'ZScoreBoundT') -> 'int | Awaitable[int]'
     |      Remove all elements in the sorted set ``name`` with scores
     |      between ``min`` and ``max``. Returns the number of elements removed.
     |
     |      For more information, see https://redis.io/commands/zremrangebyscore
     |
     |  zrevrange(self, name: 'KeyT', start: 'int', end: 'int', withscores: 'bool' = False, score_cast_func: 'type | Callable' = <class 'float'>) -> 'ZSetRangeResponse | Awaitable[ZSetRangeResponse]'
     |      Return a range of values from sorted set ``name`` between
     |      ``start`` and ``end`` sorted in descending order.
     |
     |      ``start`` and ``end`` can be negative, indicating the end of the range.
     |
     |      ``withscores`` indicates to return the scores along with the values
     |      The return type is a list of (value, score) pairs
     |
     |      ``score_cast_func`` a callable used to cast the score return value
     |
     |      For more information, see https://redis.io/commands/zrevrange
     |
     |  zrevrangebylex(self, name: 'KeyT', max: 'EncodableT', min: 'EncodableT', start: 'int | None' = None, num: 'int | None' = None) -> 'list[bytes | str] | Awaitable[list[bytes | str]]'
     |      Return the reversed lexicographical range of values from sorted set
     |      ``name`` between ``max`` and ``min``.
     |
     |      If ``start`` and ``num`` are specified, then return a slice of the
     |      range.
     |
     |      For more information, see https://redis.io/commands/zrevrangebylex
     |
     |  zrevrangebyscore(self, name: 'KeyT', max: 'ZScoreBoundT', min: 'ZScoreBoundT', start: 'int | None' = None, num: 'int | None' = None, withscores: 'bool' = False, score_cast_func: 'type | Callable' = <class 'float'>) -> 'ZSetRangeResponse | Awaitable[ZSetRangeResponse]'
     |      Return a range of values from the sorted set ``name`` with scores
     |      between ``min`` and ``max`` in descending order.
     |
     |      If ``start`` and ``num`` are specified, then return a slice
     |      of the range.
     |
     |      ``withscores`` indicates to return the scores along with the values.
     |      The return type is a list of (value, score) pairs
     |
     |      ``score_cast_func`` a callable used to cast the score return value
     |
     |      For more information, see https://redis.io/commands/zrevrangebyscore
     |
     |  zrevrank(self, name: 'KeyT', value: 'EncodableT', withscore: 'bool' = False, score_cast_func: 'type | Callable' = <class 'float'>) -> 'int | list[Any] | None | Awaitable[int | list[Any] | None]'
     |      Returns a 0-based value indicating the descending rank of
     |      ``value`` in sorted set ``name``.
     |      The optional ``withscore`` argument supplements the command's
     |      reply with the score of the element returned.
     |
     |      ``score_cast_func`` a callable used to cast the score return value
     |
     |      For more information, see https://redis.io/commands/zrevrank
     |
     |  zscore(self, name: 'KeyT', value: 'EncodableT') -> 'float | None | Awaitable[float | None]'
     |      Return the score of element ``value`` in sorted set ``name``
     |
     |      For more information, see https://redis.io/commands/zscore
     |
     |  zunion(self, keys: 'Sequence[KeyT] | Mapping[AnyKeyT, float]', aggregate: 'str | None' = None, withscores: 'bool' = False, score_cast_func: 'type | Callable' = <class 'float'>) -> 'ZSetRangeResponse | Awaitable[ZSetRangeResponse]'
     |      Return the union of multiple sorted sets specified by ``keys``.
     |      ``keys`` can be provided as dictionary of keys and their weights.
     |      Scores will be aggregated based on the ``aggregate``, or SUM if
     |      none is provided.
     |
     |      Available aggregation modes:
     |
     |      - ``SUM`` (default): the score of an element is summed across the
     |        inputs where it exists.
     |        Score = SUM(score₁×weight₁, score₂×weight₂, ...)
     |      - ``MIN``: the resulting set will contain the minimum score of an
     |        element across the inputs where it exists.
     |        Score = MIN(score₁×weight₁, score₂×weight₂, ...)
     |      - ``MAX``: the resulting set will contain the maximum score of an
     |        element across the inputs where it exists.
     |        Score = MAX(score₁×weight₁, score₂×weight₂, ...)
     |      - ``COUNT``: ignores the original scores and counts weighted set
     |        membership. Each element's score is the sum of the weights of
     |        the input sets that contain it.
     |        Score = SUM(weight₁, weight₂, ...) for sets containing the element.
     |        When all weights are 1 (default), the score equals the number
     |        of input sets containing the element.
     |
     |      ``score_cast_func`` a callable used to cast the score return value
     |
     |      For more information, see https://redis.io/commands/zunion
     |
     |  zunionstore(self, dest: 'KeyT', keys: 'Sequence[KeyT] | Mapping[AnyKeyT, float]', aggregate: 'str | None' = None) -> 'int | Awaitable[int]'
     |      Union multiple sorted sets specified by ``keys`` into
     |      a new sorted set, ``dest``. Scores in the destination will be
     |      aggregated based on the ``aggregate``, or SUM if none is provided.
     |
     |      Available aggregation modes:
     |
     |      - ``SUM`` (default): the score of an element is summed across the
     |        inputs where it exists.
     |        Score = SUM(score₁×weight₁, score₂×weight₂, ...)
     |      - ``MIN``: the resulting set will contain the minimum score of an
     |        element across the inputs where it exists.
     |        Score = MIN(score₁×weight₁, score₂×weight₂, ...)
     |      - ``MAX``: the resulting set will contain the maximum score of an
     |        element across the inputs where it exists.
     |        Score = MAX(score₁×weight₁, score₂×weight₂, ...)
     |      - ``COUNT``: ignores the original scores and counts weighted set
     |        membership. Each element's score is the sum of the weights of
     |        the input sets that contain it.
     |        Score = SUM(weight₁, weight₂, ...) for sets containing the element.
     |        When all weights are 1 (default), the score equals the number
     |        of input sets containing the element.
     |
     |      For more information, see https://redis.io/commands/zunionstore
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from redis.commands.core.ScriptCommands:
     |
     |  eval(self, script: 'str', numkeys: 'int', *keys_and_args: 'KeyT | EncodableT') -> 'Any | Awaitable[Any]'
     |      Execute the Lua ``script``, specifying the ``numkeys`` the script
     |      will touch and the key names and argument values in ``keys_and_args``.
     |      Returns the result of the script.
     |
     |      In practice, use the object returned by ``register_script``. This
     |      function exists purely for Redis API completion.
     |
     |      For more information, see  https://redis.io/commands/eval
     |
     |  eval_ro(self, script: 'str', numkeys: 'int', *keys_and_args: 'KeyT | EncodableT') -> 'Any | Awaitable[Any]'
     |      The read-only variant of the EVAL command
     |
     |      Execute the read-only Lua ``script`` specifying the ``numkeys`` the script
     |      will touch and the key names and argument values in ``keys_and_args``.
     |      Returns the result of the script.
     |
     |      For more information, see  https://redis.io/commands/eval_ro
     |
     |  evalsha(self, sha: 'str', numkeys: 'int', *keys_and_args: 'KeyT | EncodableT') -> 'Any | Awaitable[Any]'
     |      Use the ``sha`` to execute a Lua script already registered via EVAL
     |      or SCRIPT LOAD. Specify the ``numkeys`` the script will touch and the
     |      key names and argument values in ``keys_and_args``. Returns the result
     |      of the script.
     |
     |      In practice, use the object returned by ``register_script``. This
     |      function exists purely for Redis API completion.
     |
     |      For more information, see  https://redis.io/commands/evalsha
     |
     |  evalsha_ro(self, sha: 'str', numkeys: 'int', *keys_and_args: 'KeyT | EncodableT') -> 'Any | Awaitable[Any]'
     |      The read-only variant of the EVALSHA command
     |
     |      Use the ``sha`` to execute a read-only Lua script already registered via EVAL
     |      or SCRIPT LOAD. Specify the ``numkeys`` the script will touch and the
     |      key names and argument values in ``keys_and_args``. Returns the result
     |      of the script.
     |
     |      For more information, see  https://redis.io/commands/evalsha_ro
     |
     |  register_script(self: "Union['redis.client.Redis', 'redis.cluster.RedisCluster']", script: 'ScriptTextT') -> 'Script'
     |      Register a Lua ``script`` specifying the ``keys`` it will touch.
     |      Returns a Script object that is callable and hides the complexity of
     |      deal with scripts, keys, and shas. This is the preferred way to work
     |      with Lua scripts.
     |
     |  script_debug(self, *args) -> 'None'
     |
     |  script_exists(self, *args: 'str') -> 'list[bool] | Awaitable[list[bool]]'
     |      Check if a script exists in the script cache by specifying the SHAs of
     |      each script as ``args``. Returns a list of boolean values indicating if
     |      if each already script exists in the cache_data.
     |
     |      For more information, see  https://redis.io/commands/script-exists
     |
     |  script_flush(self, sync_type: "Literal['SYNC'] | Literal['ASYNC'] | None" = None) -> 'bool | Awaitable[bool]'
     |      Flush all scripts from the script cache_data.
     |
     |      ``sync_type`` is by default SYNC (synchronous) but it can also be
     |                    ASYNC.
     |
     |      For more information, see  https://redis.io/commands/script-flush
     |
     |  script_kill(self) -> 'bool | Awaitable[bool]'
     |      Kill the currently executing Lua script
     |
     |      For more information, see https://redis.io/commands/script-kill
     |
     |  script_load(self, script: 'ScriptTextT') -> 'str | Awaitable[str]'
     |      Load a Lua ``script`` into the script cache_data. Returns the SHA.
     |
     |      For more information, see https://redis.io/commands/script-load
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from redis.commands.core.FunctionCommands:
     |
     |  fcall(self, function, numkeys: 'int', *keys_and_args: 'Any') -> 'Any | Awaitable[Any]'
     |      Invoke a function.
     |
     |      For more information, see https://redis.io/commands/fcall
     |
     |  fcall_ro(self, function, numkeys: 'int', *keys_and_args: 'Any') -> 'Any | Awaitable[Any]'
     |      This is a read-only variant of the FCALL command that cannot
     |      execute commands that modify data.
     |
     |      For more information, see https://redis.io/commands/fcall_ro
     |
     |  function_delete(self, library: 'str') -> 'bool | Awaitable[bool]'
     |      Delete the library called ``library`` and all its functions.
     |
     |      For more information, see https://redis.io/commands/function-delete
     |
     |  function_dump(self) -> 'bytes | Awaitable[bytes]'
     |      Return the serialized payload of loaded libraries.
     |
     |      For more information, see https://redis.io/commands/function-dump
     |
     |  function_flush(self, mode: 'str' = 'SYNC') -> 'bool | Awaitable[bool]'
     |      Deletes all the libraries.
     |
     |      For more information, see https://redis.io/commands/function-flush
     |
     |  function_kill(self) -> 'bytes | str | Awaitable[bytes | str]'
     |      Kill a function that is currently executing.
     |
     |      For more information, see https://redis.io/commands/function-kill
     |
     |  function_list(self, library: 'str | None' = '*', withcode: 'bool | None' = False) -> 'list[Any] | Awaitable[list[Any]]'
     |      Return information about the functions and libraries.
     |
     |      Args:
     |
     |          library: specify a pattern for matching library names
     |          withcode: cause the server to include the libraries source implementation
     |              in the reply
     |
     |  function_load(self, code: 'str', replace: 'bool | None' = False) -> 'bytes | str | Awaitable[bytes | str]'
     |      Load a library to Redis.
     |      :param code: the source code (must start with
     |      Shebang statement that provides a metadata about the library)
     |      :param replace: changes the behavior to overwrite the existing library
     |      with the new contents.
     |      Return the library name that was loaded.
     |
     |      For more information, see https://redis.io/commands/function-load
     |
     |  function_restore(self, payload: 'str', policy: 'str | None' = 'APPEND') -> 'bool | Awaitable[bool]'
     |      Restore libraries from the serialized ``payload``.
     |      You can use the optional policy argument to provide a policy
     |      for handling existing libraries.
     |
     |      For more information, see https://redis.io/commands/function-restore
     |
     |  function_stats(self) -> 'Any | Awaitable[Any]'
     |      Return information about the function that's currently running
     |      and information about the available execution engines.
     |
     |      For more information, see https://redis.io/commands/function-stats
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from redis.commands.core.ModuleCommands:
     |
     |  command_getkeys(self, *args) -> 'list[bytes | str] | Awaitable[list[bytes | str]]'
     |
     |  module_list(self) -> 'list[dict[Any, Any]] | Awaitable[list[dict[Any, Any]]]'
     |      Returns a list of dictionaries containing the name and version of
     |      all loaded modules.
     |
     |      For more information, see https://redis.io/commands/module-list
     |
     |  module_load(self, path, *args) -> 'bool | Awaitable[bool]'
     |      Loads the module from ``path``.
     |      Passes all ``*args`` to the module, during loading.
     |      Raises ``ModuleError`` if a module is not found at ``path``.
     |
     |      For more information, see https://redis.io/commands/module-load
     |
     |  module_loadex(self, path: 'str', options: 'List[str] | None' = None, args: 'List[str] | None' = None) -> 'bytes | str | Awaitable[bytes | str]'
     |      Loads a module from a dynamic library at runtime with configuration directives.
     |
     |      For more information, see https://redis.io/commands/module-loadex
     |
     |  module_unload(self, name) -> 'bool | Awaitable[bool]'
     |      Unloads the module ``name``.
     |      Raises ``ModuleError`` if ``name`` is not in loaded modules.
     |
     |      For more information, see https://redis.io/commands/module-unload
     |
     |  ----------------------------------------------------------------------
     |  Data and other attributes inherited from redis.typing.CommandsProtocol:
     |
     |  __protocol_attrs__ = {'_event_dispatcher', 'execute_command'}
     |
     |  ----------------------------------------------------------------------
     |  Class methods inherited from typing.Protocol:
     |
     |  __init_subclass__(*args, **kwargs)
     |      This method is called when a class is subclassed.
     |
     |      The default implementation does nothing. It may be
     |      overridden to extend subclasses.
     |
     |  ----------------------------------------------------------------------
     |  Class methods inherited from typing.Generic:
     |
     |  __class_getitem__(...)
     |      Parameterizes a generic class.
     |
     |      At least, parameterizing a generic class is the *main* thing this
     |      method does. For example, for some generic class `Foo`, this is called
     |      when we do `Foo[int]` - there, with `cls=Foo` and `params=int`.
     |
     |      However, note that this method is also called when defining generic
     |      classes in the first place with `class Foo[T]: ...`.
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from redis.commands.redismodules.RedisModuleCommands:
     |
     |  bf(self) -> 'BFBloom'
     |      Access the bloom namespace.
     |
     |  cf(self) -> 'CFBloom'
     |      Access the bloom namespace.
     |
     |  cms(self) -> 'CMSBloom'
     |      Access the bloom namespace.
     |
     |  ft(self, index_name='idx') -> 'Search'
     |      Access the search namespace, providing support for redis search.
     |
     |  json(self, encoder=<json.encoder.JSONEncoder object at 0x0000017B9C588F50>, decoder=<json.decoder.JSONDecoder object at 0x0000017B9C588FB0>) -> 'JSON'
     |      Access the json namespace, providing support for redis json.
     |
     |  tdigest(self) -> 'TDigestBloom'
     |      Access the bloom namespace.
     |
     |  topk(self) -> 'TOPKBloom'
     |      Access the bloom namespace.
     |
     |  ts(self) -> 'TimeSeries'
     |      Access the timeseries namespace, providing support for
     |      redis timeseries data.
     |
     |  vset(self) -> 'VectorSet'
     |      Access the VectorSet commands namespace.

    class TransactionStrategy(AbstractStrategy)
     |  TransactionStrategy(pipe: redis.cluster.ClusterPipeline)
     |
     |  Method resolution order:
     |      TransactionStrategy
     |      AbstractStrategy
     |      ExecutionStrategy
     |      abc.ABC
     |      builtins.object
     |
     |  Methods defined here:
     |
     |  __init__(self, pipe: redis.cluster.ClusterPipeline)
     |      Initialize self.  See help(type(self)) for accurate signature.
     |
     |  delete(self, *names)
     |      "Delete a key specified by ``names``"
     |
     |      See: ClusterPipeline.delete()
     |
     |  discard(self)
     |
     |  execute(self, raise_on_error: bool = True) -> List[Any]
     |      Executes current execution strategy.
     |
     |      See: ClusterPipeline.execute()
     |
     |  execute_command(self, *args, **kwargs)
     |      Execution flow for current execution strategy.
     |
     |      See: ClusterPipeline.execute_command()
     |
     |  multi(self)
     |      Starts transactional context.
     |
     |      See: ClusterPipeline.multi()
     |
     |  reset(self)
     |      Resets current execution strategy.
     |
     |      See: ClusterPipeline.reset()
     |
     |  send_cluster_commands(self, stack, raise_on_error=True, allow_redirections=True)
     |      Sends commands according to current execution strategy.
     |
     |      See: ClusterPipeline.send_cluster_commands()
     |
     |  unlink(self, *names)
     |      "Unlink a key specified by ``names``"
     |
     |      See: ClusterPipeline.unlink()
     |
     |  unwatch(self)
     |      Unwatches all previously specified keys
     |
     |      See: ClusterPipeline.unwatch()
     |
     |  watch(self, *names)
     |
     |  ----------------------------------------------------------------------
     |  Data and other attributes defined here:
     |
     |  CONNECTION_ERRORS = (<class 'redis.exceptions.ConnectionError'>, <clas...
     |
     |  IMMEDIATE_EXECUTE_COMMANDS = {'UNWATCH', 'WATCH'}
     |
     |  NO_SLOTS_COMMANDS = {'UNWATCH'}
     |
     |  SLOT_REDIRECT_ERRORS = (<class 'redis.exceptions.AskError'>, <class 'r...
     |
     |  UNWATCH_COMMANDS = {'DISCARD', 'EXEC', 'UNWATCH'}
     |
     |  __abstractmethods__ = frozenset()
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from AbstractStrategy:
     |
     |  annotate_exception(self, exception, number, command)
     |      Provides extra context to the exception prior to it being handled
     |
     |  eval(self)
     |
     |  exists(self, *keys)
     |
     |  load_scripts(self)
     |
     |  pipeline_execute_command(self, *args, **options)
     |      Pipeline execution flow for current execution strategy.
     |
     |      See: ClusterPipeline.pipeline_execute_command()
     |
     |  script_load_for_pipeline(self, *args, **kwargs)
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors inherited from AbstractStrategy:
     |
     |  command_queue
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors inherited from ExecutionStrategy:
     |
     |  __dict__
     |      dictionary for instance variables
     |
     |  __weakref__
     |      list of weak references to the object

FUNCTIONS
    block_pipeline_command(name: str) -> Callable[..., Any]
        Prints error because some pipelined commands should
        be blocked when running in cluster-mode

    cleanup_kwargs(**kwargs)
        Remove unsupported or disabled keys from kwargs

    get_connection(redis_node: redis.client.Redis, *args, **options) -> redis.connection.Connection

    get_node_name(host: str, port: Union[str, int]) -> str

    is_debug_log_enabled()

    parse_cluster_myshardid(resp, **options)
        Parse CLUSTER MYSHARDID response.

    parse_cluster_shards(resp, **options)
        Parse CLUSTER SHARDS response.

    parse_cluster_shards_unified(resp, **options)
        Parse CLUSTER SHARDS into the approved unified shape.

        Top-level shard keys and nested node attribute keys are strings for both
        RESP2 and RESP3 wire responses.

    parse_cluster_shards_with_str_keys(resp, **options)
        Parse CLUSTER SHARDS with string top-level structural keys.

        RESP2 parsing exposes top-level shard keys as ``"slots"``/``"nodes"``
        while node attribute keys keep the connection's decoded/raw form. RESP3 can
        return top-level shard dictionaries directly, so normalize only the
        structural shard keys and preserve nested node dictionaries as delivered.

    parse_cluster_slots(resp: Any, **options: Any) -> Dict[Tuple[int, int], Dict[str, Any]]

    parse_pubsub_numsub(command, res, **options)

    parse_scan_result(command, res, **options)

DATA
    Callable = typing.Callable
        Deprecated alias to collections.abc.Callable.

        Callable[[int], str] signifies a function that takes a single
        parameter of type int and returns a str.

        The subscription syntax must always be used with exactly two
        values: the argument list and the return type.
        The argument list must be a list of types, a ParamSpec,
        Concatenate or ellipsis. The return type must be a single type.

        There is no syntax to indicate optional or keyword arguments;
        such function types are rarely used as callback types.

    ChannelT = typing.Union[bytes, str, memoryview]
    DEFAULT_RETRY_BASE = 0.01
    DEFAULT_RETRY_CAP = 1
    DEFAULT_RETRY_COUNT = 10
    Dict = typing.Dict
        A generic version of dict.

    EMPTY_RESPONSE = 'EMPTY_RESPONSE'
    FieldT = typing.Union[bytes, bytearray, memoryview, str, int, float]
    Iterable = typing.Iterable
        A generic version of collections.abc.Iterable.

    KWARGS_DISABLED_KEYS = ('host', 'port', 'retry')
    List = typing.List
        A generic version of list.

    Literal = typing.Literal
        Special typing form to define literal types (a.k.a. value types).

        This form can be used to indicate to type checkers that the corresponding
        variable or function parameter has a value equivalent to the provided
        literal (or one of several literals)::

            def validate_simple(data: Any) -> Literal[True]:  # always returns True
                ...

            MODE = Literal['r', 'rb', 'w', 'wb']
            def open_helper(file: str, mode: MODE) -> str:
                ...

            open_helper('/some/path', 'r')  # Passes type check
            open_helper('/other/path', 'typo')  # Error in type checker

        Literal[...] cannot be subclassed. At runtime, an arbitrary value
        is allowed as type argument to Literal[...], but type checkers may
        impose restrictions.

    Optional = typing.Optional
        Optional[X] is equivalent to Union[X, None].

    PIPELINE_BLOCKED_COMMANDS = ('BGREWRITEAOF', 'BGSAVE', 'BITOP', 'BRPOP...
    PRIMARY = 'primary'
    PubSubHandler = typing.Callable[[dict[str, typing.Any]], typing.Any]
    READ_COMMANDS = frozenset({'BITCOUNT', 'BITFIELD_RO', 'BITPOS', 'DBSIZ...
    REDIS_ALLOWED_KEYS = ('connection_class', 'connection_pool', 'connecti...
    REDIS_CLUSTER_HASH_SLOTS = 16384
    REPLICA = 'replica'
    SLOT_ID = 'slot-id'
    Set = typing.Set
        A generic version of set.

    TYPE_CHECKING = False
    Tuple = typing.Tuple
        Deprecated alias to builtins.tuple.

        Tuple[X, Y] is the cross-product type of X and Y.

        Example: Tuple[T1, T2] is a tuple of two elements corresponding
        to type variables T1 and T2.  Tuple[int, float, str] is a tuple
        of an int, a float and a string.

        To specify a variable-length tuple of homogeneous type, use Tuple[T, ...].

    Type = typing.Type
        Deprecated alias to builtins.type.

        builtins.type or typing.Type can be used to annotate class objects.
        For example, suppose we have the following classes::

            class User: ...  # Abstract base for User classes
            class BasicUser(User): ...
            class ProUser(User): ...
            class TeamUser(User): ...

        And a function that takes a class argument that's a subclass of
        User and returns an instance of the corresponding class::

            def new_user[U](user_class: Type[U]) -> U:
                user = user_class()
                # (Here we could write the user object to a database)
                return user

            joe = new_user(BasicUser)

        At this point the type checker knows that joe has type BasicUser.

    Union = typing.Union
        Union type; Union[X, Y] means either X or Y.

        On Python 3.10 and higher, the | operator
        can also be used to denote unions;
        X | Y means the same thing to the type checker as Union[X, Y].

        To define a union, use e.g. Union[int, str]. Details:
        - The arguments must be types and there must be at least one.
        - None as an argument is a special case and is replaced by
          type(None).
        - Unions of unions are flattened, e.g.::

            assert Union[Union[int, str], float] == Union[int, str, float]

        - Unions of a single argument vanish, e.g.::

            assert Union[int] == int  # The constructor actually returns int

        - Redundant arguments are skipped, e.g.::

            assert Union[int, str, int] == Union[int, str]

        - When comparing unions, the argument order is ignored, e.g.::

            assert Union[int, str] == Union[str, int]

        - You cannot subclass or instantiate a union.
        - You can use Optional[X] as a shorthand for Union[X, None].

    command = 'time'
    logger = <Logger redis.cluster (WARNING)>

FILE
    c:\users\youse\appdata\local\programs\python\python312\lib\site-packages\redis\cluster.py

Python Library Documentation: package redis.commands in redis

NAME
    redis.commands

PACKAGE CONTENTS
    bf (package)
    cluster
    core
    helpers
    json (package)
    policies
    redismodules
    search (package)
    sentinel
    timeseries (package)
    vectorset (package)

CLASSES
    builtins.object
        redis.commands.redismodules.RedisModuleCommands
            redis.commands.cluster.RedisClusterCommands(redis.commands.cluster.ClusterMultiKeyCommands, redis.commands.cluster.ClusterManagementCommands, redis.commands.core.ACLCommands, redis.commands.core.PubSubCommands, redis.commands.cluster.ClusterDataAccessCommands, redis.commands.core.ScriptCommands, redis.commands.core.FunctionCommands, redis.commands.core.ModuleCommands, redis.commands.redismodules.RedisModuleCommands)
            redis.commands.redismodules.AsyncRedisModuleCommands
                redis.commands.cluster.AsyncRedisClusterCommands(redis.commands.cluster.AsyncClusterMultiKeyCommands, redis.commands.cluster.AsyncClusterManagementCommands, redis.commands.core.ACLCommands, redis.commands.core.PubSubCommands, redis.commands.cluster.AsyncClusterDataAccessCommands, redis.commands.core.AsyncScriptCommands, redis.commands.core.FunctionCommands, redis.commands.core.AsyncModuleCommands, redis.commands.redismodules.AsyncRedisModuleCommands)
        redis.commands.sentinel.SentinelCommands
            redis.commands.sentinel.AsyncSentinelCommands
    redis.commands.cluster.AsyncClusterDataAccessCommands(redis.commands.cluster.ClusterDataAccessCommands, redis.commands.core.AsyncDataAccessCommands)
        redis.commands.cluster.AsyncRedisClusterCommands(redis.commands.cluster.AsyncClusterMultiKeyCommands, redis.commands.cluster.AsyncClusterManagementCommands, redis.commands.core.ACLCommands, redis.commands.core.PubSubCommands, redis.commands.cluster.AsyncClusterDataAccessCommands, redis.commands.core.AsyncScriptCommands, redis.commands.core.FunctionCommands, redis.commands.core.AsyncModuleCommands, redis.commands.redismodules.AsyncRedisModuleCommands)
    redis.commands.cluster.AsyncClusterManagementCommands(redis.commands.cluster.ClusterManagementCommands, redis.commands.core.AsyncManagementCommands)
        redis.commands.cluster.AsyncRedisClusterCommands(redis.commands.cluster.AsyncClusterMultiKeyCommands, redis.commands.cluster.AsyncClusterManagementCommands, redis.commands.core.ACLCommands, redis.commands.core.PubSubCommands, redis.commands.cluster.AsyncClusterDataAccessCommands, redis.commands.core.AsyncScriptCommands, redis.commands.core.FunctionCommands, redis.commands.core.AsyncModuleCommands, redis.commands.redismodules.AsyncRedisModuleCommands)
    redis.commands.cluster.AsyncClusterMultiKeyCommands(redis.commands.cluster.ClusterMultiKeyCommands)
        redis.commands.cluster.AsyncRedisClusterCommands(redis.commands.cluster.AsyncClusterMultiKeyCommands, redis.commands.cluster.AsyncClusterManagementCommands, redis.commands.core.ACLCommands, redis.commands.core.PubSubCommands, redis.commands.cluster.AsyncClusterDataAccessCommands, redis.commands.core.AsyncScriptCommands, redis.commands.core.FunctionCommands, redis.commands.core.AsyncModuleCommands, redis.commands.redismodules.AsyncRedisModuleCommands)
    redis.commands.cluster.ClusterDataAccessCommands(redis.commands.core.DataAccessCommands)
        redis.commands.cluster.RedisClusterCommands(redis.commands.cluster.ClusterMultiKeyCommands, redis.commands.cluster.ClusterManagementCommands, redis.commands.core.ACLCommands, redis.commands.core.PubSubCommands, redis.commands.cluster.ClusterDataAccessCommands, redis.commands.core.ScriptCommands, redis.commands.core.FunctionCommands, redis.commands.core.ModuleCommands, redis.commands.redismodules.RedisModuleCommands)
    redis.commands.cluster.ClusterManagementCommands(redis.commands.core.ManagementCommands)
        redis.commands.cluster.RedisClusterCommands(redis.commands.cluster.ClusterMultiKeyCommands, redis.commands.cluster.ClusterManagementCommands, redis.commands.core.ACLCommands, redis.commands.core.PubSubCommands, redis.commands.cluster.ClusterDataAccessCommands, redis.commands.core.ScriptCommands, redis.commands.core.FunctionCommands, redis.commands.core.ModuleCommands, redis.commands.redismodules.RedisModuleCommands)
    redis.commands.cluster.ClusterMultiKeyCommands(redis.typing.ClusterCommandsProtocol)
        redis.commands.cluster.RedisClusterCommands(redis.commands.cluster.ClusterMultiKeyCommands, redis.commands.cluster.ClusterManagementCommands, redis.commands.core.ACLCommands, redis.commands.core.PubSubCommands, redis.commands.cluster.ClusterDataAccessCommands, redis.commands.core.ScriptCommands, redis.commands.core.FunctionCommands, redis.commands.core.ModuleCommands, redis.commands.redismodules.RedisModuleCommands)
    redis.commands.core.ACLCommands(redis.typing.CommandsProtocol)
        redis.commands.cluster.AsyncRedisClusterCommands(redis.commands.cluster.AsyncClusterMultiKeyCommands, redis.commands.cluster.AsyncClusterManagementCommands, redis.commands.core.ACLCommands, redis.commands.core.PubSubCommands, redis.commands.cluster.AsyncClusterDataAccessCommands, redis.commands.core.AsyncScriptCommands, redis.commands.core.FunctionCommands, redis.commands.core.AsyncModuleCommands, redis.commands.redismodules.AsyncRedisModuleCommands)
        redis.commands.cluster.RedisClusterCommands(redis.commands.cluster.ClusterMultiKeyCommands, redis.commands.cluster.ClusterManagementCommands, redis.commands.core.ACLCommands, redis.commands.core.PubSubCommands, redis.commands.cluster.ClusterDataAccessCommands, redis.commands.core.ScriptCommands, redis.commands.core.FunctionCommands, redis.commands.core.ModuleCommands, redis.commands.redismodules.RedisModuleCommands)
        redis.commands.core.AsyncCoreCommands(redis.commands.core.ACLCommands, redis.commands.core.ClusterCommands, redis.commands.core.AsyncDataAccessCommands, redis.commands.core.AsyncManagementCommands, redis.commands.core.AsyncModuleCommands, redis.commands.core.PubSubCommands, redis.commands.core.AsyncScriptCommands, redis.commands.core.FunctionCommands)
        redis.commands.core.CoreCommands(redis.commands.core.ACLCommands, redis.commands.core.ClusterCommands, redis.commands.core.DataAccessCommands, redis.commands.core.ManagementCommands, redis.commands.core.ModuleCommands, redis.commands.core.PubSubCommands, redis.commands.core.ScriptCommands, redis.commands.core.FunctionCommands)
    redis.commands.core.AsyncDataAccessCommands(redis.commands.core.AsyncBasicKeyCommands, redis.commands.core.HyperlogCommands, redis.commands.core.HashCommands, redis.commands.core.GeoCommands, redis.commands.core.ListCommands, redis.commands.core.ArrayCommands, redis.commands.core.AsyncScanCommands, redis.commands.core.SetCommands, redis.commands.core.StreamCommands, redis.commands.core.SortedSetCommands)
        redis.commands.core.AsyncCoreCommands(redis.commands.core.ACLCommands, redis.commands.core.ClusterCommands, redis.commands.core.AsyncDataAccessCommands, redis.commands.core.AsyncManagementCommands, redis.commands.core.AsyncModuleCommands, redis.commands.core.PubSubCommands, redis.commands.core.AsyncScriptCommands, redis.commands.core.FunctionCommands)
    redis.commands.core.AsyncManagementCommands(redis.commands.core.ManagementCommands)
        redis.commands.core.AsyncCoreCommands(redis.commands.core.ACLCommands, redis.commands.core.ClusterCommands, redis.commands.core.AsyncDataAccessCommands, redis.commands.core.AsyncManagementCommands, redis.commands.core.AsyncModuleCommands, redis.commands.core.PubSubCommands, redis.commands.core.AsyncScriptCommands, redis.commands.core.FunctionCommands)
    redis.commands.core.AsyncModuleCommands(redis.commands.core.ModuleCommands)
        redis.commands.cluster.AsyncRedisClusterCommands(redis.commands.cluster.AsyncClusterMultiKeyCommands, redis.commands.cluster.AsyncClusterManagementCommands, redis.commands.core.ACLCommands, redis.commands.core.PubSubCommands, redis.commands.cluster.AsyncClusterDataAccessCommands, redis.commands.core.AsyncScriptCommands, redis.commands.core.FunctionCommands, redis.commands.core.AsyncModuleCommands, redis.commands.redismodules.AsyncRedisModuleCommands)
        redis.commands.core.AsyncCoreCommands(redis.commands.core.ACLCommands, redis.commands.core.ClusterCommands, redis.commands.core.AsyncDataAccessCommands, redis.commands.core.AsyncManagementCommands, redis.commands.core.AsyncModuleCommands, redis.commands.core.PubSubCommands, redis.commands.core.AsyncScriptCommands, redis.commands.core.FunctionCommands)
    redis.commands.core.AsyncScriptCommands(redis.commands.core.ScriptCommands)
        redis.commands.cluster.AsyncRedisClusterCommands(redis.commands.cluster.AsyncClusterMultiKeyCommands, redis.commands.cluster.AsyncClusterManagementCommands, redis.commands.core.ACLCommands, redis.commands.core.PubSubCommands, redis.commands.cluster.AsyncClusterDataAccessCommands, redis.commands.core.AsyncScriptCommands, redis.commands.core.FunctionCommands, redis.commands.core.AsyncModuleCommands, redis.commands.redismodules.AsyncRedisModuleCommands)
        redis.commands.core.AsyncCoreCommands(redis.commands.core.ACLCommands, redis.commands.core.ClusterCommands, redis.commands.core.AsyncDataAccessCommands, redis.commands.core.AsyncManagementCommands, redis.commands.core.AsyncModuleCommands, redis.commands.core.PubSubCommands, redis.commands.core.AsyncScriptCommands, redis.commands.core.FunctionCommands)
    redis.commands.core.ClusterCommands(redis.typing.CommandsProtocol)
        redis.commands.core.AsyncCoreCommands(redis.commands.core.ACLCommands, redis.commands.core.ClusterCommands, redis.commands.core.AsyncDataAccessCommands, redis.commands.core.AsyncManagementCommands, redis.commands.core.AsyncModuleCommands, redis.commands.core.PubSubCommands, redis.commands.core.AsyncScriptCommands, redis.commands.core.FunctionCommands)
        redis.commands.core.CoreCommands(redis.commands.core.ACLCommands, redis.commands.core.ClusterCommands, redis.commands.core.DataAccessCommands, redis.commands.core.ManagementCommands, redis.commands.core.ModuleCommands, redis.commands.core.PubSubCommands, redis.commands.core.ScriptCommands, redis.commands.core.FunctionCommands)
    redis.commands.core.DataAccessCommands(redis.commands.core.BasicKeyCommands, redis.commands.core.HyperlogCommands, redis.commands.core.HashCommands, redis.commands.core.GeoCommands, redis.commands.core.ListCommands, redis.commands.core.ArrayCommands, redis.commands.core.ScanCommands, redis.commands.core.SetCommands, redis.commands.core.StreamCommands, redis.commands.core.SortedSetCommands)
        redis.commands.core.CoreCommands(redis.commands.core.ACLCommands, redis.commands.core.ClusterCommands, redis.commands.core.DataAccessCommands, redis.commands.core.ManagementCommands, redis.commands.core.ModuleCommands, redis.commands.core.PubSubCommands, redis.commands.core.ScriptCommands, redis.commands.core.FunctionCommands)
    redis.commands.core.FunctionCommands(builtins.object)
        redis.commands.cluster.AsyncRedisClusterCommands(redis.commands.cluster.AsyncClusterMultiKeyCommands, redis.commands.cluster.AsyncClusterManagementCommands, redis.commands.core.ACLCommands, redis.commands.core.PubSubCommands, redis.commands.cluster.AsyncClusterDataAccessCommands, redis.commands.core.AsyncScriptCommands, redis.commands.core.FunctionCommands, redis.commands.core.AsyncModuleCommands, redis.commands.redismodules.AsyncRedisModuleCommands)
        redis.commands.cluster.RedisClusterCommands(redis.commands.cluster.ClusterMultiKeyCommands, redis.commands.cluster.ClusterManagementCommands, redis.commands.core.ACLCommands, redis.commands.core.PubSubCommands, redis.commands.cluster.ClusterDataAccessCommands, redis.commands.core.ScriptCommands, redis.commands.core.FunctionCommands, redis.commands.core.ModuleCommands, redis.commands.redismodules.RedisModuleCommands)
        redis.commands.core.AsyncCoreCommands(redis.commands.core.ACLCommands, redis.commands.core.ClusterCommands, redis.commands.core.AsyncDataAccessCommands, redis.commands.core.AsyncManagementCommands, redis.commands.core.AsyncModuleCommands, redis.commands.core.PubSubCommands, redis.commands.core.AsyncScriptCommands, redis.commands.core.FunctionCommands)
        redis.commands.core.CoreCommands(redis.commands.core.ACLCommands, redis.commands.core.ClusterCommands, redis.commands.core.DataAccessCommands, redis.commands.core.ManagementCommands, redis.commands.core.ModuleCommands, redis.commands.core.PubSubCommands, redis.commands.core.ScriptCommands, redis.commands.core.FunctionCommands)
    redis.commands.core.ManagementCommands(redis.typing.CommandsProtocol)
        redis.commands.core.CoreCommands(redis.commands.core.ACLCommands, redis.commands.core.ClusterCommands, redis.commands.core.DataAccessCommands, redis.commands.core.ManagementCommands, redis.commands.core.ModuleCommands, redis.commands.core.PubSubCommands, redis.commands.core.ScriptCommands, redis.commands.core.FunctionCommands)
    redis.commands.core.ModuleCommands(redis.typing.CommandsProtocol)
        redis.commands.cluster.RedisClusterCommands(redis.commands.cluster.ClusterMultiKeyCommands, redis.commands.cluster.ClusterManagementCommands, redis.commands.core.ACLCommands, redis.commands.core.PubSubCommands, redis.commands.cluster.ClusterDataAccessCommands, redis.commands.core.ScriptCommands, redis.commands.core.FunctionCommands, redis.commands.core.ModuleCommands, redis.commands.redismodules.RedisModuleCommands)
        redis.commands.core.CoreCommands(redis.commands.core.ACLCommands, redis.commands.core.ClusterCommands, redis.commands.core.DataAccessCommands, redis.commands.core.ManagementCommands, redis.commands.core.ModuleCommands, redis.commands.core.PubSubCommands, redis.commands.core.ScriptCommands, redis.commands.core.FunctionCommands)
    redis.commands.core.PubSubCommands(redis.typing.CommandsProtocol)
        redis.commands.cluster.AsyncRedisClusterCommands(redis.commands.cluster.AsyncClusterMultiKeyCommands, redis.commands.cluster.AsyncClusterManagementCommands, redis.commands.core.ACLCommands, redis.commands.core.PubSubCommands, redis.commands.cluster.AsyncClusterDataAccessCommands, redis.commands.core.AsyncScriptCommands, redis.commands.core.FunctionCommands, redis.commands.core.AsyncModuleCommands, redis.commands.redismodules.AsyncRedisModuleCommands)
        redis.commands.cluster.RedisClusterCommands(redis.commands.cluster.ClusterMultiKeyCommands, redis.commands.cluster.ClusterManagementCommands, redis.commands.core.ACLCommands, redis.commands.core.PubSubCommands, redis.commands.cluster.ClusterDataAccessCommands, redis.commands.core.ScriptCommands, redis.commands.core.FunctionCommands, redis.commands.core.ModuleCommands, redis.commands.redismodules.RedisModuleCommands)
        redis.commands.core.AsyncCoreCommands(redis.commands.core.ACLCommands, redis.commands.core.ClusterCommands, redis.commands.core.AsyncDataAccessCommands, redis.commands.core.AsyncManagementCommands, redis.commands.core.AsyncModuleCommands, redis.commands.core.PubSubCommands, redis.commands.core.AsyncScriptCommands, redis.commands.core.FunctionCommands)
        redis.commands.core.CoreCommands(redis.commands.core.ACLCommands, redis.commands.core.ClusterCommands, redis.commands.core.DataAccessCommands, redis.commands.core.ManagementCommands, redis.commands.core.ModuleCommands, redis.commands.core.PubSubCommands, redis.commands.core.ScriptCommands, redis.commands.core.FunctionCommands)
    redis.commands.core.ScriptCommands(redis.typing.CommandsProtocol)
        redis.commands.cluster.RedisClusterCommands(redis.commands.cluster.ClusterMultiKeyCommands, redis.commands.cluster.ClusterManagementCommands, redis.commands.core.ACLCommands, redis.commands.core.PubSubCommands, redis.commands.cluster.ClusterDataAccessCommands, redis.commands.core.ScriptCommands, redis.commands.core.FunctionCommands, redis.commands.core.ModuleCommands, redis.commands.redismodules.RedisModuleCommands)
        redis.commands.core.CoreCommands(redis.commands.core.ACLCommands, redis.commands.core.ClusterCommands, redis.commands.core.DataAccessCommands, redis.commands.core.ManagementCommands, redis.commands.core.ModuleCommands, redis.commands.core.PubSubCommands, redis.commands.core.ScriptCommands, redis.commands.core.FunctionCommands)

    class AsyncCoreCommands(ACLCommands, ClusterCommands, AsyncDataAccessCommands, AsyncManagementCommands, AsyncModuleCommands, PubSubCommands, AsyncScriptCommands, FunctionCommands)
     |  AsyncCoreCommands(*args, **kwargs)
     |
     |  A class containing all of the implemented redis commands. This class is
     |  to be used as a mixin for asynchronous Redis clients.
     |
     |  Method resolution order:
     |      AsyncCoreCommands
     |      ACLCommands
     |      ClusterCommands
     |      AsyncDataAccessCommands
     |      AsyncBasicKeyCommands
     |      BasicKeyCommands
     |      HyperlogCommands
     |      HashCommands
     |      GeoCommands
     |      ListCommands
     |      ArrayCommands
     |      AsyncScanCommands
     |      ScanCommands
     |      SetCommands
     |      StreamCommands
     |      SortedSetCommands
     |      AsyncManagementCommands
     |      ManagementCommands
     |      AsyncModuleCommands
     |      ModuleCommands
     |      PubSubCommands
     |      AsyncScriptCommands
     |      ScriptCommands
     |      redis.typing.CommandsProtocol
     |      typing.Protocol
     |      typing.Generic
     |      FunctionCommands
     |      builtins.object
     |
     |  Class methods defined here:
     |
     |  __subclasshook__ = _proto_hook(other) from typing
     |
     |  ----------------------------------------------------------------------
     |  Data and other attributes defined here:
     |
     |  __abstractmethods__ = frozenset()
     |
     |  __annotations__ = {}
     |
     |  __parameters__ = ()
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from ACLCommands:
     |
     |  acl_cat(self, category: 'str | None' = None, **kwargs) -> 'list[bytes | str] | Awaitable[list[bytes | str]]'
     |      Returns a list of categories or commands within a category.
     |
     |      If ``category`` is not supplied, returns a list of all categories.
     |      If ``category`` is supplied, returns a list of all commands within
     |      that category.
     |
     |      For more information, see https://redis.io/commands/acl-cat
     |
     |  acl_deluser(self, *username: 'str', **kwargs) -> 'int | Awaitable[int]'
     |      Delete the ACL for the specified ``username``\s
     |
     |      For more information, see https://redis.io/commands/acl-deluser
     |
     |  acl_dryrun(self, username: 'str', *args: 'EncodableT', **kwargs) -> 'bytes | str | Awaitable[bytes | str]'
     |      Simulate the execution of a given command by a given ``username``.
     |
     |      For more information, see https://redis.io/commands/acl-dryrun
     |
     |  acl_genpass(self, bits: 'int | None' = None, **kwargs) -> 'bytes | str | Awaitable[bytes | str]'
     |      Generate a random password value.
     |      If ``bits`` is supplied then use this number of bits, rounded to
     |      the next multiple of 4.
     |      See: https://redis.io/commands/acl-genpass
     |
     |  acl_getuser(self, username: 'str', **kwargs) -> 'ACLGetUserData | Awaitable[ACLGetUserData]'
     |      Get the ACL details for the specified ``username``.
     |
     |      If ``username`` does not exist, return None
     |
     |      For more information, see https://redis.io/commands/acl-getuser
     |
     |  acl_help(self, **kwargs) -> 'list[bytes | str] | Awaitable[list[bytes | str]]'
     |      The ACL HELP command returns helpful text describing
     |      the different subcommands.
     |
     |      For more information, see https://redis.io/commands/acl-help
     |
     |  acl_list(self, **kwargs) -> 'list[bytes | str] | Awaitable[list[bytes | str]]'
     |      Return a list of all ACLs on the server
     |
     |      For more information, see https://redis.io/commands/acl-list
     |
     |  acl_load(self, **kwargs) -> 'bool | Awaitable[bool]'
     |      Load ACL rules from the configured ``aclfile``.
     |
     |      Note that the server must be configured with the ``aclfile``
     |      directive to be able to load ACL rules from an aclfile.
     |
     |      For more information, see https://redis.io/commands/acl-load
     |
     |  acl_log(self, count: 'int | None' = None, **kwargs) -> 'ACLLogData | Awaitable[ACLLogData]'
     |      Get ACL logs as a list.
     |      :param int count: Get logs[0:count].
     |      :rtype: List.
     |
     |      For more information, see https://redis.io/commands/acl-log
     |
     |  acl_log_reset(self, **kwargs) -> 'bool | Awaitable[bool]'
     |      Reset ACL logs.
     |      :rtype: Boolean.
     |
     |      For more information, see https://redis.io/commands/acl-log
     |
     |  acl_save(self, **kwargs) -> 'bool | Awaitable[bool]'
     |      Save ACL rules to the configured ``aclfile``.
     |
     |      Note that the server must be configured with the ``aclfile``
     |      directive to be able to save ACL rules to an aclfile.
     |
     |      For more information, see https://redis.io/commands/acl-save
     |
     |  acl_setuser(self, username: 'str', enabled: 'bool' = False, nopass: 'bool' = False, passwords: 'str | Iterable[str] | None' = None, hashed_passwords: 'str | Iterable[str] | None' = None, categories: 'Iterable[str] | None' = None, commands: 'Iterable[str] | None' = None, keys: 'Iterable[KeyT] | None' = None, channels: 'Iterable[ChannelT] | None' = None, selectors: 'Iterable[Tuple[str, KeyT]] | None' = None, reset: 'bool' = False, reset_keys: 'bool' = False, reset_channels: 'bool' = False, reset_passwords: 'bool' = False, **kwargs) -> 'bool | Awaitable[bool]'
     |      Create or update an ACL user.
     |
     |      Create or update the ACL for `username`. If the user already exists,
     |      the existing ACL is completely overwritten and replaced with the
     |      specified values.
     |
     |      For more information, see https://redis.io/commands/acl-setuser
     |
     |      Args:
     |          username: The name of the user whose ACL is to be created or updated.
     |          enabled: Indicates whether the user should be allowed to authenticate.
     |                   Defaults to `False`.
     |          nopass: Indicates whether the user can authenticate without a password.
     |                  This cannot be `True` if `passwords` are also specified.
     |          passwords: A list of plain text passwords to add to or remove from the user.
     |                     Each password must be prefixed with a '+' to add or a '-' to
     |                     remove. For convenience, a single prefixed string can be used
     |                     when adding or removing a single password.
     |          hashed_passwords: A list of SHA-256 hashed passwords to add to or remove
     |                            from the user. Each hashed password must be prefixed with
     |                            a '+' to add or a '-' to remove. For convenience, a single
     |                            prefixed string can be used when adding or removing a
     |                            single password.
     |          categories: A list of strings representing category permissions. Each string
     |                      must be prefixed with either a '+' to add the category
     |                      permission or a '-' to remove the category permission.
     |          commands: A list of strings representing command permissions. Each string
     |                    must be prefixed with either a '+' to add the command permission
     |                    or a '-' to remove the command permission.
     |          keys: A list of key patterns to grant the user access to. Key patterns allow
     |                ``'*'`` to support wildcard matching. For example, ``'*'`` grants
     |                access to all keys while ``'cache:*'`` grants access to all keys that
     |                are prefixed with ``cache:``.
     |                `keys` should not be prefixed with a ``'~'``.
     |          reset: Indicates whether the user should be fully reset prior to applying
     |                 the new ACL. Setting this to `True` will remove all existing
     |                 passwords, flags, and privileges from the user and then apply the
     |                 specified rules. If `False`, the user's existing passwords, flags,
     |                 and privileges will be kept and any new specified rules will be
     |                 applied on top.
     |          reset_keys: Indicates whether the user's key permissions should be reset
     |                      prior to applying any new key permissions specified in `keys`.
     |                      If `False`, the user's existing key permissions will be kept and
     |                      any new specified key permissions will be applied on top.
     |          reset_channels: Indicates whether the user's channel permissions should be
     |                          reset prior to applying any new channel permissions
     |                          specified in `channels`. If `False`, the user's existing
     |                          channel permissions will be kept and any new specified
     |                          channel permissions will be applied on top.
     |          reset_passwords: Indicates whether to remove all existing passwords and the
     |                           `nopass` flag from the user prior to applying any new
     |                           passwords specified in `passwords` or `hashed_passwords`.
     |                           If `False`, the user's existing passwords and `nopass`
     |                           status will be kept and any new specified passwords or
     |                           hashed passwords will be applied on top.
     |
     |  acl_users(self, **kwargs) -> 'list[bytes | str] | Awaitable[list[bytes | str]]'
     |      Returns a list of all registered users on the server.
     |
     |      For more information, see https://redis.io/commands/acl-users
     |
     |  acl_whoami(self, **kwargs) -> 'bytes | str | Awaitable[bytes | str]'
     |      Get the username for the current connection
     |
     |      For more information, see https://redis.io/commands/acl-whoami
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from ClusterCommands:
     |
     |  cluster(self, cluster_arg, *args, **kwargs) -> 'Any | Awaitable[Any]'
     |
     |  readonly(self, **kwargs) -> 'bool | Awaitable[bool]'
     |      Enables read queries for a connection to a Redis Cluster replica node.
     |
     |      For more information, see https://redis.io/commands/readonly
     |
     |  readwrite(self, **kwargs) -> 'bool | Awaitable[bool]'
     |      Disables read queries for a connection to a Redis Cluster slave node.
     |
     |      For more information, see https://redis.io/commands/readwrite
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from AsyncBasicKeyCommands:
     |
     |  __contains__(self, name: 'KeyT')
     |      Returns the number of ``names`` that exist
     |
     |      For more information, see https://redis.io/commands/exists
     |
     |  __delitem__(self, name: 'KeyT')
     |
     |  __getitem__(self, name: 'KeyT')
     |      Return the value at key ``name``, raises a KeyError if the key
     |      doesn't exist.
     |
     |  __setitem__(self, name: 'KeyT', value: 'EncodableT')
     |
     |  async unwatch(self) -> 'None'
     |      Unwatches all previously watched keys for a transaction
     |
     |      For more information, see https://redis.io/commands/unwatch
     |
     |  async watch(self, *names: 'KeyT') -> 'None'
     |      Watches the values at keys ``names``, or None if the key doesn't exist
     |
     |      For more information, see https://redis.io/commands/watch
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from BasicKeyCommands:
     |
     |  append(self, key: 'KeyT', value: 'EncodableT') -> 'int | Awaitable[int]'
     |      Appends the string ``value`` to the value at ``key``. If ``key``
     |      doesn't already exist, create it with a value of ``value``.
     |      Returns the new length of the value at ``key``.
     |
     |      For more information, see https://redis.io/commands/append
     |
     |  bitcount(self, key: 'KeyT', start: 'int | None' = None, end: 'int | None' = None, mode: 'str | None' = None) -> 'int | Awaitable[int]'
     |      Returns the count of set bits in the value of ``key``.  Optional
     |      ``start`` and ``end`` parameters indicate which bytes to consider
     |
     |      For more information, see https://redis.io/commands/bitcount
     |
     |  bitfield(self: "Union['redis.client.Redis', 'redis.asyncio.client.Redis']", key: 'KeyT', default_overflow: 'str | None' = None) -> 'BitFieldOperation'
     |      Return a BitFieldOperation instance to conveniently construct one or
     |      more bitfield operations on ``key``.
     |
     |      For more information, see https://redis.io/commands/bitfield
     |
     |  bitfield_ro(self: "Union['redis.client.Redis', 'redis.asyncio.client.Redis']", key: 'KeyT', encoding: 'str', offset: 'BitfieldOffsetT', items: 'list[tuple[str, BitfieldOffsetT]] | None' = None) -> 'list[int] | Awaitable[list[int]]'
     |      Return an array of the specified bitfield values
     |      where the first value is found using ``encoding`` and ``offset``
     |      parameters and remaining values are result of corresponding
     |      encoding/offset pairs in optional list ``items``
     |      Read-only variant of the BITFIELD command.
     |
     |      For more information, see https://redis.io/commands/bitfield_ro
     |
     |  bitop(self, operation: 'str', dest: 'KeyT', *keys: 'KeyT') -> 'int | Awaitable[int]'
     |      Perform a bitwise operation using ``operation`` between ``keys`` and
     |      store the result in ``dest``.
     |
     |      For more information, see https://redis.io/commands/bitop
     |
     |  bitpos(self, key: 'KeyT', bit: 'int', start: 'int | None' = None, end: 'int | None' = None, mode: 'str | None' = None) -> 'int | Awaitable[int]'
     |      Return the position of the first bit set to 1 or 0 in a string.
     |      ``start`` and ``end`` defines search range. The range is interpreted
     |      as a range of bytes and not a range of bits, so start=0 and end=2
     |      means to look at the first three bytes.
     |
     |      For more information, see https://redis.io/commands/bitpos
     |
     |  blmove(self, first_list: 'str', second_list: 'str', timeout: 'int', src: 'str' = 'LEFT', dest: 'str' = 'RIGHT') -> 'bytes | str | None | Awaitable[bytes | str | None]'
     |      Blocking version of lmove.
     |
     |      For more information, see https://redis.io/commands/blmove
     |
     |  blmovem(self, first_list: 'str', second_list: 'str', timeout: 'float', src: 'str' = 'LEFT', dest: 'str' = 'RIGHT', count: 'int | None' = None, mode: "Literal['COUNT', 'EXACTLY'] | None" = None, ordering: "Literal['OBO', 'BULK'] | None" = None) -> 'list[bytes | str] | None | Awaitable[list[bytes | str] | None]'
     |      Blocking version of lmovem.
     |
     |      Blocks until elements are available to move or ``timeout`` (in seconds)
     |      is reached; a ``timeout`` of ``0`` blocks indefinitely. With ``COUNT``
     |      the command unblocks once at least one element is available and moves
     |      ``min(count, available)``; with ``EXACTLY`` it blocks until the source
     |      holds at least ``count`` elements, then moves exactly ``count``
     |      atomically. On timeout ``None`` is returned and nothing is moved.
     |
     |      As with ``lmovem``, ``ordering`` (OBO or BULK) is required whenever
     |      ``count`` is given.
     |
     |      For more information, see https://redis.io/commands/blmovem
     |
     |  copy(self, source: 'str', destination: 'str', destination_db: 'str | None' = None, replace: 'bool' = False) -> 'bool | Awaitable[bool]'
     |      Copy the value stored in the ``source`` key to the ``destination`` key.
     |
     |      ``destination_db`` an alternative destination database. By default,
     |      the ``destination`` key is created in the source Redis database.
     |
     |      ``replace`` whether the ``destination`` key should be removed before
     |      copying the value to it. By default, the value is not copied if
     |      the ``destination`` key already exists.
     |
     |      For more information, see https://redis.io/commands/copy
     |
     |  decr = decrby(self, name: 'KeyT', amount: 'int' = 1) -> 'int | Awaitable[int]'
     |
     |  decrby(self, name: 'KeyT', amount: 'int' = 1) -> 'int | Awaitable[int]'
     |      Decrements the value of ``key`` by ``amount``.  If no key exists,
     |      the value will be initialized as 0 - ``amount``
     |
     |      For more information, see https://redis.io/commands/decrby
     |
     |  delete(self, *names: 'KeyT') -> 'int | Awaitable[int]'
     |      Delete one or more keys specified by ``names``
     |
     |  delex(self, name: 'KeyT', ifeq: 'bytes | str | None' = None, ifne: 'bytes | str | None' = None, ifdeq: 'str | None' = None, ifdne: 'str | None' = None) -> 'int | Awaitable[int]'
     |      Conditionally removes the specified key.
     |
     |      Warning:
     |      **Experimental** since 7.1.
     |      This API may change or be removed without notice.
     |      The API may change based on feedback.
     |
     |      Arguments:
     |          name: KeyT - the key to delete
     |          ifeq match-valu: Optional[Union[bytes, str]] - Delete the key only if its value is equal to match-value
     |          ifne match-value: Optional[Union[bytes, str]] - Delete the key only if its value is not equal to match-value
     |          ifdeq match-digest: Optional[str] - Delete the key only if the digest of its value is equal to match-digest
     |          ifdne match-digest: Optional[str] - Delete the key only if the digest of its value is not equal to match-digest
     |
     |      Returns:
     |          int: 1 if the key was deleted, 0 otherwise.
     |      Raises:
     |          redis.exceptions.ResponseError: if key exists but is not a string
     |                                          and a condition is specified.
     |          ValueError: if more than one condition is provided.
     |
     |
     |      Requires Redis 8.4 or greater.
     |      For more information, see https://redis.io/commands/delex
     |
     |  digest(self, name: 'KeyT') -> 'str | bytes | None | Awaitable[str | bytes | None]'
     |      Return the digest of the value stored at the specified key.
     |
     |      Warning:
     |      **Experimental** since 7.1.
     |      This API may change or be removed without notice.
     |      The API may change based on feedback.
     |
     |      Arguments:
     |        - name: KeyT - the key to get the digest of
     |
     |      Returns:
     |        - None if the key does not exist
     |        - (bulk string) the XXH3 digest of the value as a hex string
     |      Raises:
     |        - ResponseError if key exists but is not a string
     |
     |
     |      Requires Redis 8.4 or greater.
     |      For more information, see https://redis.io/commands/digest
     |
     |  digest_local(self, value: 'bytes | str') -> 'bytes | str'
     |      Compute the hexadecimal digest of the value locally, without sending it to the server.
     |
     |      This is useful for conditional operations like IFDEQ/IFDNE where you need to
     |      compute the digest client-side before sending a command.
     |
     |      Warning:
     |      **Experimental** - This API may change or be removed without notice.
     |
     |      Arguments:
     |        - value: Union[bytes, str] - the value to compute the digest of.
     |          If a string is provided, it will be encoded using UTF-8 before hashing,
     |          which matches Redis's default encoding behavior.
     |
     |      Returns:
     |        - (str | bytes) the XXH3 digest of the value as a hex string (16 hex characters).
     |          Returns bytes if decode_responses is False, otherwise returns str.
     |
     |      For more information, see https://redis.io/commands/digest
     |
     |  dump(self, name: 'KeyT') -> 'bytes | None | Awaitable[bytes | None]'
     |      Return a serialized version of the value stored at the specified key.
     |      If key does not exist a nil bulk reply is returned.
     |
     |      For more information, see https://redis.io/commands/dump
     |
     |  exists(self, *names: 'KeyT') -> 'int | Awaitable[int]'
     |      Returns the number of ``names`` that exist
     |
     |      For more information, see https://redis.io/commands/exists
     |
     |  expire(self, name: 'KeyT', time: 'ExpiryT', nx: 'bool' = False, xx: 'bool' = False, gt: 'bool' = False, lt: 'bool' = False) -> 'bool | Awaitable[bool]'
     |      Set an expire flag on key ``name`` for ``time`` seconds with given
     |      ``option``. ``time`` can be represented by an integer or a Python timedelta
     |      object.
     |
     |      Valid options are:
     |          NX -> Set expiry only when the key has no expiry
     |          XX -> Set expiry only when the key has an existing expiry
     |          GT -> Set expiry only when the new expiry is greater than current one
     |          LT -> Set expiry only when the new expiry is less than current one
     |
     |      For more information, see https://redis.io/commands/expire
     |
     |  expireat(self, name: 'KeyT', when: 'AbsExpiryT', nx: 'bool' = False, xx: 'bool' = False, gt: 'bool' = False, lt: 'bool' = False) -> 'bool | Awaitable[bool]'
     |      Set an expire flag on key ``name`` with given ``option``. ``when``
     |      can be represented as an integer indicating unix time or a Python
     |      datetime object.
     |
     |      Valid options are:
     |          -> NX -- Set expiry only when the key has no expiry
     |          -> XX -- Set expiry only when the key has an existing expiry
     |          -> GT -- Set expiry only when the new expiry is greater than current one
     |          -> LT -- Set expiry only when the new expiry is less than current one
     |
     |      For more information, see https://redis.io/commands/expireat
     |
     |  expiretime(self, key: 'str') -> 'int | Awaitable[int]'
     |      Returns the absolute Unix timestamp (since January 1, 1970) in seconds
     |      at which the given key will expire.
     |
     |      For more information, see https://redis.io/commands/expiretime
     |
     |  get(self, name: 'KeyT') -> 'bytes | str | None | Awaitable[bytes | str | None]'
     |      Return the value at key ``name``, or None if the key doesn't exist
     |
     |      For more information, see https://redis.io/commands/get
     |
     |  getbit(self, name: 'KeyT', offset: 'int') -> 'int | Awaitable[int]'
     |      Returns an integer indicating the value of ``offset`` in ``name``
     |
     |      For more information, see https://redis.io/commands/getbit
     |
     |  getdel(self, name: 'KeyT') -> 'bytes | str | None | Awaitable[bytes | str | None]'
     |      Get the value at key ``name`` and delete the key. This command
     |      is similar to GET, except for the fact that it also deletes
     |      the key on success (if and only if the key's value type
     |      is a string).
     |
     |      For more information, see https://redis.io/commands/getdel
     |
     |  getex(self, name: 'KeyT', ex: 'ExpiryT | None' = None, px: 'ExpiryT | None' = None, exat: 'AbsExpiryT | None' = None, pxat: 'AbsExpiryT | None' = None, persist: 'bool' = False) -> 'bytes | str | None | Awaitable[bytes | str | None]'
     |      Get the value of key and optionally set its expiration.
     |      GETEX is similar to GET, but is a write command with
     |      additional options. All time parameters can be given as
     |      datetime.timedelta or integers.
     |
     |      ``ex`` sets an expire flag on key ``name`` for ``ex`` seconds.
     |
     |      ``px`` sets an expire flag on key ``name`` for ``px`` milliseconds.
     |
     |      ``exat`` sets an expire flag on key ``name`` for ``ex`` seconds,
     |      specified in unix time.
     |
     |      ``pxat`` sets an expire flag on key ``name`` for ``ex`` milliseconds,
     |      specified in unix time.
     |
     |      ``persist`` remove the time to live associated with ``name``.
     |
     |      For more information, see https://redis.io/commands/getex
     |
     |  getrange(self, key: 'KeyT', start: 'int', end: 'int') -> 'bytes | str | Awaitable[bytes | str]'
     |      Returns the substring of the string value stored at ``key``,
     |      determined by the offsets ``start`` and ``end`` (both are inclusive)
     |
     |      For more information, see https://redis.io/commands/getrange
     |
     |  getset(self, name: 'KeyT', value: 'EncodableT') -> 'bytes | str | None | Awaitable[bytes | str | None]'
     |      Sets the value at key ``name`` to ``value``
     |      and returns the old value at key ``name`` atomically.
     |
     |      As per Redis 6.2, GETSET is considered deprecated.
     |      Please use SET with GET parameter in new code.
     |
     |      For more information, see https://redis.io/commands/getset
     |
     |  hrandfield(self, key: 'KeyT', count: 'int | None' = None, withvalues: 'bool' = False) -> 'HRandFieldResponse | Awaitable[HRandFieldResponse]'
     |      Return a random field from the hash value stored at key.
     |
     |      count: if the argument is positive, return an array of distinct fields.
     |      If called with a negative count, the behavior changes and the command
     |      is allowed to return the same field multiple times. In this case,
     |      the number of returned fields is the absolute value of the
     |      specified count.
     |      withvalues: The optional WITHVALUES modifier changes the reply so it
     |      includes the respective values of the randomly selected hash fields.
     |
     |      For more information, see https://redis.io/commands/hrandfield
     |
     |  incr = incrby(self, name: 'KeyT', amount: 'int' = 1) -> 'int | Awaitable[int]'
     |
     |  incrby(self, name: 'KeyT', amount: 'int' = 1) -> 'int | Awaitable[int]'
     |      Increments the value of ``key`` by ``amount``.  If no key exists,
     |      the value will be initialized as ``amount``
     |
     |      For more information, see https://redis.io/commands/incrby
     |
     |  incrbyfloat(self, name: 'KeyT', amount: 'float' = 1.0) -> 'float | Awaitable[float]'
     |      Increments the value at key ``name`` by floating ``amount``.
     |      If no key exists, the value will be initialized as ``amount``
     |
     |      For more information, see https://redis.io/commands/incrbyfloat
     |
     |  increx(self, name: 'KeyT', *, byfloat: 'EncodableT | None' = None, byint: 'EncodableT | None' = None, lbound: 'EncodableT | None' = None, ubound: 'EncodableT | None' = None, saturate: 'bool' = False, ex: 'ExpiryT | None' = None, px: 'ExpiryT | None' = None, exat: 'AbsExpiryT | None' = None, pxat: 'AbsExpiryT | None' = None, persist: 'bool' = False, enx: 'bool' = False) -> 'list[Number | bytes | str] | Awaitable[list[Number | bytes | str]]'
     |      Increment the numeric value at key ``name`` and return the new value
     |      and the actual increment.
     |
     |      ``byfloat`` increments a floating point value by the provided amount.
     |
     |      ``byint`` increments an integer value by the provided amount.
     |
     |      If neither ``byfloat`` nor ``byint`` is specified, the value is
     |      incremented by one.
     |
     |      ``lbound`` and ``ubound`` constrain the valid range of the result.
     |
     |      If ``saturate`` is True, out-of-bounds results are saturated to the
     |      specified bound, or to the type limit when no bound is specified.
     |      Otherwise, out-of-bounds results are rejected, leaving the value and
     |      TTL unchanged and returning the current value and zero as the actual
     |      increment.
     |
     |      ``enx`` applies the expiration only when the key does not already
     |      have an expiration, and requires ``ex``, ``px``, ``exat``, or ``pxat``.
     |
     |  keys(self, pattern: 'PatternT' = '*', **kwargs) -> 'list[bytes | str] | Awaitable[list[bytes | str]]'
     |      Returns a list of keys matching ``pattern``
     |
     |      For more information, see https://redis.io/commands/keys
     |
     |  lcs(self, key1: 'str', key2: 'str', len: 'bool | None' = False, idx: 'bool | None' = False, minmatchlen: 'int | None' = 0, withmatchlen: 'bool | None' = False) -> 'LCSCommandResponse | Awaitable[LCSCommandResponse]'
     |      Find the longest common subsequence between ``key1`` and ``key2``.
     |      If ``len`` is true the length of the match will be returned.
     |      If ``idx`` is true the match position in each strings will be returned.
     |      ``minmatchlen`` restrict the list of matches to the ones of
     |      the given ``minmatchlen``.
     |      If ``withmatchlen`` the length of the match also will be returned.
     |      For more information, see https://redis.io/commands/lcs
     |
     |  lmove(self, first_list: 'str', second_list: 'str', src: 'str' = 'LEFT', dest: 'str' = 'RIGHT') -> 'bytes | str | None | Awaitable[bytes | str | None]'
     |      Atomically returns and removes the first/last element of a list,
     |      pushing it as the first/last element on the destination list.
     |      Returns the element being popped and pushed.
     |
     |      For more information, see https://redis.io/commands/lmove
     |
     |  lmovem(self, first_list: 'str', second_list: 'str', src: 'str' = 'LEFT', dest: 'str' = 'RIGHT', count: 'int | None' = None, mode: "Literal['COUNT', 'EXACTLY'] | None" = None, ordering: "Literal['OBO', 'BULK'] | None" = None) -> 'list[bytes | str] | None | Awaitable[list[bytes | str] | None]'
     |      Atomically moves multiple elements from one end of the ``first_list``
     |      to one end of the ``second_list``, returning the moved elements in
     |      destination order.
     |
     |      ``src`` and ``dest`` are the ends to pop from / push to, either
     |      ``LEFT`` (head) or ``RIGHT`` (tail).
     |
     |      When ``count`` is given, ``mode`` selects how many elements to move:
     |      ``COUNT`` (the default) moves up to ``count`` elements, while
     |      ``EXACTLY`` moves exactly ``count`` elements or nothing at all. When
     |      ``count`` is not given a single element is moved.
     |
     |      ``ordering`` controls the order at the destination: ``OBO`` pushes each
     |      element as it is popped (reversing block order, stack semantics) while
     |      ``BULK`` preserves the original relative order (queue semantics). It is
     |      required whenever ``count`` is given.
     |
     |      Returns the array of moved elements, or ``None`` if nothing was moved.
     |
     |      For more information, see https://redis.io/commands/lmovem
     |
     |  mget(self, keys: 'KeysT', *args: 'EncodableT') -> 'list[bytes | str | None] | Awaitable[list[bytes | str | None]]'
     |      Returns a list of values ordered identically to ``keys``
     |
     |      ** Important ** When this method is used with Cluster clients, all keys
     |              must be in the same hash slot, otherwise a RedisClusterException
     |              will be raised.
     |
     |      For more information, see https://redis.io/commands/mget
     |
     |  move(self, name: 'KeyT', db: 'int') -> 'bool | Awaitable[bool]'
     |      Moves the key ``name`` to a different Redis database ``db``
     |
     |      For more information, see https://redis.io/commands/move
     |
     |  mset(self, mapping: 'Mapping[AnyKeyT, EncodableT]') -> 'bool | Awaitable[bool]'
     |      Sets key/values based on a mapping. Mapping is a dictionary of
     |      key/value pairs. Both keys and values should be strings or types that
     |      can be cast to a string via str().
     |
     |      ** Important ** When this method is used with Cluster clients, all keys
     |              must be in the same hash slot, otherwise a RedisClusterException
     |              will be raised.
     |
     |      For more information, see https://redis.io/commands/mset
     |
     |  msetex(self, mapping: 'Mapping[AnyKeyT, EncodableT]', data_persist_option: 'DataPersistOptions | None' = None, ex: 'ExpiryT | None' = None, px: 'ExpiryT | None' = None, exat: 'AbsExpiryT | None' = None, pxat: 'AbsExpiryT | None' = None, keepttl: 'bool' = False) -> 'int | Awaitable[int]'
     |      Sets key/values based on the provided ``mapping`` items.
     |
     |      ** Important ** When this method is used with Cluster clients, all keys
     |                      must be in the same hash slot, otherwise a RedisClusterException
     |                      will be raised.
     |
     |      ``mapping`` accepts a dict of key/value pairs that will be added to the database.
     |
     |      ``data_persist_option`` can be set to ``NX`` or ``XX`` to control the
     |          behavior of the command.
     |          ``NX`` will set the value for each provided key to each
     |              provided value only if all do not already exist.
     |          ``XX`` will set the value for each provided key to each
     |              provided value only if all already exist.
     |
     |      ``ex`` sets an expire flag on the keys in ``mapping`` for ``ex`` seconds.
     |
     |      ``px`` sets an expire flag on the keys in ``mapping`` for ``px`` milliseconds.
     |
     |      ``exat`` sets an expire flag on the keys in ``mapping`` for ``exat`` seconds,
     |          specified in unix time.
     |
     |      ``pxat`` sets an expire flag on the keys in ``mapping`` for ``pxat`` milliseconds,
     |          specified in unix time.
     |
     |      ``keepttl`` if True, retain the time to live associated with the keys.
     |
     |      Returns the number of fields that were added.
     |
     |      Available since Redis 8.4
     |      For more information, see https://redis.io/commands/msetex
     |
     |  msetnx(self, mapping: 'Mapping[AnyKeyT, EncodableT]') -> 'bool | Awaitable[bool]'
     |      Sets key/values based on a mapping if none of the keys are already set.
     |      Mapping is a dictionary of key/value pairs. Both keys and values
     |      should be strings or types that can be cast to a string via str().
     |      Returns a boolean indicating if the operation was successful.
     |
     |      ** Important ** When this method is used with Cluster clients, all keys
     |                      must be in the same hash slot, otherwise a RedisClusterException
     |                      will be raised.
     |
     |      For more information, see https://redis.io/commands/msetnx
     |
     |  persist(self, name: 'KeyT') -> 'bool | Awaitable[bool]'
     |      Removes an expiration on ``name``
     |
     |      For more information, see https://redis.io/commands/persist
     |
     |  pexpire(self, name: 'KeyT', time: 'ExpiryT', nx: 'bool' = False, xx: 'bool' = False, gt: 'bool' = False, lt: 'bool' = False) -> 'bool | Awaitable[bool]'
     |      Set an expire flag on key ``name`` for ``time`` milliseconds
     |      with given ``option``. ``time`` can be represented by an
     |      integer or a Python timedelta object.
     |
     |      Valid options are:
     |          NX -> Set expiry only when the key has no expiry
     |          XX -> Set expiry only when the key has an existing expiry
     |          GT -> Set expiry only when the new expiry is greater than current one
     |          LT -> Set expiry only when the new expiry is less than current one
     |
     |      For more information, see https://redis.io/commands/pexpire
     |
     |  pexpireat(self, name: 'KeyT', when: 'AbsExpiryT', nx: 'bool' = False, xx: 'bool' = False, gt: 'bool' = False, lt: 'bool' = False) -> 'bool | Awaitable[bool]'
     |      Set an expire flag on key ``name`` with given ``option``. ``when``
     |      can be represented as an integer representing unix time in
     |      milliseconds (unix time * 1000) or a Python datetime object.
     |
     |      Valid options are:
     |          NX -> Set expiry only when the key has no expiry
     |          XX -> Set expiry only when the key has an existing expiry
     |          GT -> Set expiry only when the new expiry is greater than current one
     |          LT -> Set expiry only when the new expiry is less than current one
     |
     |      For more information, see https://redis.io/commands/pexpireat
     |
     |  pexpiretime(self, key: 'str') -> 'int | Awaitable[int]'
     |      Returns the absolute Unix timestamp (since January 1, 1970) in milliseconds
     |      at which the given key will expire.
     |
     |      For more information, see https://redis.io/commands/pexpiretime
     |
     |  psetex(self, name: 'KeyT', time_ms: 'ExpiryT', value: 'EncodableT') -> 'bool | Awaitable[bool]'
     |      Set the value of key ``name`` to ``value`` that expires in ``time_ms``
     |      milliseconds. ``time_ms`` can be represented by an integer or a Python
     |      timedelta object
     |
     |      For more information, see https://redis.io/commands/psetex
     |
     |  pttl(self, name: 'KeyT') -> 'int | Awaitable[int]'
     |      Returns the number of milliseconds until the key ``name`` will expire
     |
     |      For more information, see https://redis.io/commands/pttl
     |
     |  randomkey(self, **kwargs) -> 'bytes | str | None | Awaitable[bytes | str | None]'
     |      Returns the name of a random key
     |
     |      For more information, see https://redis.io/commands/randomkey
     |
     |  rename(self, src: 'KeyT', dst: 'KeyT') -> 'bool | Awaitable[bool]'
     |      Rename key ``src`` to ``dst``
     |
     |      For more information, see https://redis.io/commands/rename
     |
     |  renamenx(self, src: 'KeyT', dst: 'KeyT') -> 'bool | Awaitable[bool]'
     |      Rename key ``src`` to ``dst`` if ``dst`` doesn't already exist
     |
     |      For more information, see https://redis.io/commands/renamenx
     |
     |  restore(self, name: 'KeyT', ttl: 'float', value: 'EncodableT', replace: 'bool' = False, absttl: 'bool' = False, idletime: 'int | None' = None, frequency: 'int | None' = None) -> 'bytes | str | Awaitable[bytes | str]'
     |      Create a key using the provided serialized value, previously obtained
     |      using DUMP.
     |
     |      ``replace`` allows an existing key on ``name`` to be overridden. If
     |      it's not specified an error is raised on collision.
     |
     |      ``absttl`` if True, specified ``ttl`` should represent an absolute Unix
     |      timestamp in milliseconds in which the key will expire. (Redis 5.0 or
     |      greater).
     |
     |      ``idletime`` Used for eviction, this is the number of seconds the
     |      key must be idle, prior to execution.
     |
     |      ``frequency`` Used for eviction, this is the frequency counter of
     |      the object stored at the key, prior to execution.
     |
     |      For more information, see https://redis.io/commands/restore
     |
     |  set(self, name: 'KeyT', value: 'EncodableT', ex: 'ExpiryT | None' = None, px: 'ExpiryT | None' = None, nx: 'bool' = False, xx: 'bool' = False, keepttl: 'bool' = False, get: 'bool' = False, exat: 'AbsExpiryT | None' = None, pxat: 'AbsExpiryT | None' = None, ifeq: 'bytes | str | None' = None, ifne: 'bytes | str | None' = None, ifdeq: 'str | None' = None, ifdne: 'str | None' = None) -> 'bool | str | bytes | None | Awaitable[bool | str | bytes | None]'
     |      Set the value at key ``name`` to ``value``
     |
     |      Warning:
     |      **Experimental** since 7.1.
     |      The usage of the arguments ``ifeq``, ``ifne``, ``ifdeq``, and ``ifdne``
     |      is experimental. The API or returned results when those parameters are used
     |      may change based on feedback.
     |
     |      ``ex`` sets an expire flag on key ``name`` for ``ex`` seconds.
     |
     |      ``px`` sets an expire flag on key ``name`` for ``px`` milliseconds.
     |
     |      ``nx`` if set to True, set the value at key ``name`` to ``value`` only
     |          if it does not exist.
     |
     |      ``xx`` if set to True, set the value at key ``name`` to ``value`` only
     |          if it already exists.
     |
     |      ``keepttl`` if True, retain the time to live associated with the key.
     |          (Available since Redis 6.0)
     |
     |      ``get`` if True, set the value at key ``name`` to ``value`` and return
     |          the old value stored at key, or None if the key did not exist.
     |          (Available since Redis 6.2)
     |
     |      ``exat`` sets an expire flag on key ``name`` for ``ex`` seconds,
     |          specified in unix time.
     |
     |      ``pxat`` sets an expire flag on key ``name`` for ``ex`` milliseconds,
     |          specified in unix time.
     |
     |      ``ifeq`` set the value at key ``name`` to ``value`` only if the current
     |          value exactly matches the argument.
     |          If key doesn’t exist - it won’t be created.
     |          (Requires Redis 8.4 or greater)
     |
     |      ``ifne`` set the value at key ``name`` to ``value`` only if the current
     |          value does not exactly match the argument.
     |          If key doesn’t exist - it will be created.
     |          (Requires Redis 8.4 or greater)
     |
     |      ``ifdeq`` set the value at key ``name`` to ``value`` only if the current
     |          value XXH3 hex digest exactly matches the argument.
     |          If key doesn’t exist - it won’t be created.
     |          (Requires Redis 8.4 or greater)
     |
     |      ``ifdne`` set the value at key ``name`` to ``value`` only if the current
     |          value XXH3 hex digest does not exactly match the argument.
     |          If key doesn’t exist - it will be created.
     |          (Requires Redis 8.4 or greater)
     |
     |      For more information, see https://redis.io/commands/set
     |
     |  setbit(self, name: 'KeyT', offset: 'int', value: 'int') -> 'int | Awaitable[int]'
     |      Flag the ``offset`` in ``name`` as ``value``. Returns an integer
     |      indicating the previous value of ``offset``.
     |
     |      For more information, see https://redis.io/commands/setbit
     |
     |  setex(self, name: 'KeyT', time: 'ExpiryT', value: 'EncodableT') -> 'bool | Awaitable[bool]'
     |      Set the value of key ``name`` to ``value`` that expires in ``time``
     |      seconds. ``time`` can be represented by an integer or a Python
     |      timedelta object.
     |
     |      As per Redis 2.6.12, SETEX is considered deprecated.
     |      Please use SET with EX parameter in new code.
     |
     |      For more information, see https://redis.io/commands/setex
     |
     |  setnx(self, name: 'KeyT', value: 'EncodableT') -> 'bool | Awaitable[bool]'
     |      Set the value of key ``name`` to ``value`` if key doesn't exist
     |
     |      For more information, see https://redis.io/commands/setnx
     |
     |  setrange(self, name: 'KeyT', offset: 'int', value: 'EncodableT') -> 'int | Awaitable[int]'
     |      Overwrite bytes in the value of ``name`` starting at ``offset`` with
     |      ``value``. If ``offset`` plus the length of ``value`` exceeds the
     |      length of the original value, the new value will be larger than before.
     |      If ``offset`` exceeds the length of the original value, null bytes
     |      will be used to pad between the end of the previous value and the start
     |      of what's being injected.
     |
     |      Returns the length of the new string.
     |
     |      For more information, see https://redis.io/commands/setrange
     |
     |  stralgo(self, algo: "Literal['LCS']", value1: 'KeyT', value2: 'KeyT', specific_argument: "Literal['strings'] | Literal['keys']" = 'strings', len: 'bool' = False, idx: 'bool' = False, minmatchlen: 'int | None' = None, withmatchlen: 'bool' = False, **kwargs) -> 'StralgoResponse | Awaitable[StralgoResponse]'
     |      Implements complex algorithms that operate on strings.
     |      Right now the only algorithm implemented is the LCS algorithm
     |      (longest common substring). However new algorithms could be
     |      implemented in the future.
     |
     |      ``algo`` Right now must be LCS
     |      ``value1`` and ``value2`` Can be two strings or two keys
     |      ``specific_argument`` Specifying if the arguments to the algorithm
     |      will be keys or strings. strings is the default.
     |      ``len`` Returns just the len of the match.
     |      ``idx`` Returns the match positions in each string.
     |      ``minmatchlen`` Restrict the list of matches to the ones of a given
     |      minimal length. Can be provided only when ``idx`` set to True.
     |      ``withmatchlen`` Returns the matches with the len of the match.
     |      Can be provided only when ``idx`` set to True.
     |
     |      For more information, see https://redis.io/commands/stralgo
     |
     |  strlen(self, name: 'KeyT') -> 'int | Awaitable[int]'
     |      Return the number of bytes stored in the value of ``name``
     |
     |      For more information, see https://redis.io/commands/strlen
     |
     |  substr(self, name: 'KeyT', start: 'int', end: 'int' = -1) -> 'bytes | str | Awaitable[bytes | str]'
     |      Return a substring of the string at key ``name``. ``start`` and ``end``
     |      are 0-based integers specifying the portion of the string to return.
     |
     |  touch(self, *args: 'KeyT') -> 'int | Awaitable[int]'
     |      Alters the last access time of a key(s) ``*args``. A key is ignored
     |      if it does not exist.
     |
     |      For more information, see https://redis.io/commands/touch
     |
     |  ttl(self, name: 'KeyT') -> 'int | Awaitable[int]'
     |      Returns the number of seconds until the key ``name`` will expire
     |
     |      For more information, see https://redis.io/commands/ttl
     |
     |  type(self, name: 'KeyT') -> 'bytes | str | Awaitable[bytes | str]'
     |      Returns the type of key ``name``
     |
     |      For more information, see https://redis.io/commands/type
     |
     |  unlink(self, *names: 'KeyT') -> 'int | Awaitable[int]'
     |      Unlink one or more keys specified by ``names``
     |
     |      For more information, see https://redis.io/commands/unlink
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from HyperlogCommands:
     |
     |  pfadd(self, name: 'KeyT', *values: 'FieldT') -> 'int | Awaitable[int]'
     |      Adds the specified elements to the specified HyperLogLog.
     |
     |      For more information, see https://redis.io/commands/pfadd
     |
     |  pfcount(self, *sources: 'KeyT') -> 'int | Awaitable[int]'
     |      Return the approximated cardinality of
     |      the set observed by the HyperLogLog at key(s).
     |
     |      For more information, see https://redis.io/commands/pfcount
     |
     |  pfmerge(self, dest: 'KeyT', *sources: 'KeyT') -> 'bool | Awaitable[bool]'
     |      Merge N different HyperLogLogs into a single one.
     |
     |      For more information, see https://redis.io/commands/pfmerge
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from HashCommands:
     |
     |  hdel(self, name: 'KeyT', *keys: 'FieldT') -> 'int | Awaitable[int]'
     |      Delete ``keys`` from hash ``name``
     |
     |      For more information, see https://redis.io/commands/hdel
     |
     |  hexists(self, name: 'KeyT', key: 'FieldT') -> 'bool | Awaitable[bool]'
     |      Returns a boolean indicating if ``key`` exists within hash ``name``
     |
     |      For more information, see https://redis.io/commands/hexists
     |
     |  hexpire(self, name: 'KeyT', seconds: 'ExpiryT', *fields: 'FieldT', nx: 'bool' = False, xx: 'bool' = False, gt: 'bool' = False, lt: 'bool' = False) -> 'list[int] | Awaitable[list[int]]'
     |      Sets or updates the expiration time for fields within a hash key, using relative
     |      time in seconds.
     |
     |      If a field already has an expiration time, the behavior of the update can be
     |      controlled using the `nx`, `xx`, `gt`, and `lt` parameters.
     |
     |      The return value provides detailed information about the outcome for each field.
     |
     |      For more information, see https://redis.io/commands/hexpire
     |
     |      Args:
     |          name: The name of the hash key.
     |          seconds: Expiration time in seconds, relative. Can be an integer, or a
     |                   Python `timedelta` object.
     |          fields: List of fields within the hash to apply the expiration time to.
     |          nx: Set expiry only when the field has no expiry.
     |          xx: Set expiry only when the field has an existing expiry.
     |          gt: Set expiry only when the new expiry is greater than the current one.
     |          lt: Set expiry only when the new expiry is less than the current one.
     |
     |      Returns:
     |          Returns a list which contains for each field in the request:
     |              - `-2` if the field does not exist, or if the key does not exist.
     |              - `0` if the specified NX | XX | GT | LT condition was not met.
     |              - `1` if the expiration time was set or updated.
     |              - `2` if the field was deleted because the specified expiration time is
     |                in the past.
     |
     |  hexpireat(self, name: 'KeyT', unix_time_seconds: 'AbsExpiryT', *fields: 'FieldT', nx: 'bool' = False, xx: 'bool' = False, gt: 'bool' = False, lt: 'bool' = False) -> 'list[int] | Awaitable[list[int]]'
     |      Sets or updates the expiration time for fields within a hash key, using an
     |      absolute Unix timestamp in seconds.
     |
     |      If a field already has an expiration time, the behavior of the update can be
     |      controlled using the `nx`, `xx`, `gt`, and `lt` parameters.
     |
     |      The return value provides detailed information about the outcome for each field.
     |
     |      For more information, see https://redis.io/commands/hexpireat
     |
     |      Args:
     |          name: The name of the hash key.
     |          unix_time_seconds: Expiration time as Unix timestamp in seconds. Can be an
     |                             integer or a Python `datetime` object.
     |          fields: List of fields within the hash to apply the expiration time to.
     |          nx: Set expiry only when the field has no expiry.
     |          xx: Set expiry only when the field has an existing expiration time.
     |          gt: Set expiry only when the new expiry is greater than the current one.
     |          lt: Set expiry only when the new expiry is less than the current one.
     |
     |      Returns:
     |          Returns a list which contains for each field in the request:
     |              - `-2` if the field does not exist, or if the key does not exist.
     |              - `0` if the specified NX | XX | GT | LT condition was not met.
     |              - `1` if the expiration time was set or updated.
     |              - `2` if the field was deleted because the specified expiration time is
     |                in the past.
     |
     |  hexpiretime(self, key: 'KeyT', *fields: 'FieldT') -> 'list[int] | Awaitable[list[int]]'
     |      Returns the expiration times of hash fields as Unix timestamps in seconds.
     |
     |      For more information, see https://redis.io/commands/hexpiretime
     |
     |      Args:
     |          key: The hash key.
     |          fields: A list of fields within the hash for which to get the expiration
     |                  time.
     |
     |      Returns:
     |          Returns a list which contains for each field in the request:
     |              - `-2` if the field does not exist, or if the key does not exist.
     |              - `-1` if the field exists but has no associated expire time.
     |              - A positive integer representing the expiration Unix timestamp in
     |                seconds, if the field has an associated expiration time.
     |
     |  hget(self, name: 'KeyT', key: 'FieldT') -> 'bytes | str | None | Awaitable[bytes | str | None]'
     |      Return the value of ``key`` within the hash ``name``
     |
     |      For more information, see https://redis.io/commands/hget
     |
     |  hgetall(self, name: 'KeyT') -> 'dict[bytes | str, bytes | str] | Awaitable[dict[bytes | str, bytes | str]]'
     |      Return a Python dict of the hash's name/value pairs
     |
     |      For more information, see https://redis.io/commands/hgetall
     |
     |  hgetdel(self, name: 'KeyT', *keys: 'FieldT') -> 'list[bytes | str | None] | Awaitable[list[bytes | str | None]]'
     |      Return the value of ``key`` within the hash ``name`` and
     |      delete the field in the hash.
     |      This command is similar to HGET, except for the fact that it also deletes
     |      the key on success from the hash with the provided ```name```.
     |
     |      Available since Redis 8.0
     |      For more information, see https://redis.io/commands/hgetdel
     |
     |  hgetex(self, name: 'KeyT', *keys: 'FieldT', ex: 'ExpiryT | None' = None, px: 'ExpiryT | None' = None, exat: 'AbsExpiryT | None' = None, pxat: 'AbsExpiryT | None' = None, persist: 'bool' = False) -> 'list[bytes | str | None] | Awaitable[list[bytes | str | None]]'
     |      Return the values of ``key`` and ``keys`` within the hash ``name``
     |      and optionally set their expiration.
     |
     |      ``ex`` sets an expire flag on ``kyes`` for ``ex`` seconds.
     |
     |      ``px`` sets an expire flag on ``keys`` for ``px`` milliseconds.
     |
     |      ``exat`` sets an expire flag on ``keys`` for ``ex`` seconds,
     |      specified in unix time.
     |
     |      ``pxat`` sets an expire flag on ``keys`` for ``ex`` milliseconds,
     |      specified in unix time.
     |
     |      ``persist`` remove the time to live associated with the ``keys``.
     |
     |      Available since Redis 8.0
     |      For more information, see https://redis.io/commands/hgetex
     |
     |  himport_discard_all_internal(self) -> 'int | Awaitable[int]'
     |      Send ``HIMPORT DISCARDALL`` (returns the number of fieldsets removed).
     |
     |      .. warning::
     |          Internal wire mapping — not for direct use on a pooled client. It
     |          DISCARDs on a single arbitrary borrowed connection and bypasses the
     |          client's shared fieldset registry, leaving other connections and the
     |          registry out of sync. Use the client's ``himport_discard_all`` instead;
     |          call this only on a pinned single-connection client where you manage
     |          session state yourself.
     |
     |  himport_discard_internal(self, fieldset_name: 'str') -> 'int | Awaitable[int]'
     |      Send ``HIMPORT DISCARD fieldset_name`` (``1`` removed, ``0`` not found).
     |
     |      .. warning::
     |          Internal wire mapping — not for direct use on a pooled client. It
     |          DISCARDs on a single arbitrary borrowed connection and bypasses the
     |          client's shared fieldset registry, leaving other connections and the
     |          registry out of sync. Use the client's ``himport_discard`` instead; call
     |          this only on a pinned single-connection client where you manage session
     |          state yourself.
     |
     |  himport_prepare_internal(self, fieldset_name: 'str', fields: 'Iterable[FieldT]') -> 'bool | Awaitable[bool]'
     |      Send ``HIMPORT PREPARE fieldset_name field [field ...]``.
     |
     |      Registers the ordered field list under ``fieldset_name`` in the executing
     |      connection's session. Fields are sent in the caller's order, unmodified.
     |
     |      .. warning::
     |          Internal wire mapping — not for direct use on a pooled client. It
     |          PREPAREs on a single arbitrary borrowed connection and bypasses the
     |          client's shared fieldset registry, so other connections stay unaware and
     |          reintroduce the nondeterministic "no such fieldset" the HIMPORT design
     |          prevents. Use the client's ``himport_prepare`` instead; call this only
     |          on a pinned single-connection client where you manage session state
     |          yourself.
     |
     |  himport_set(self, key: 'KeyT', fieldset_name: 'str', values: 'Iterable[EncodableT]') -> 'bool | Awaitable[bool]'
     |      Create/replace ``key`` as a hash using ``fieldset_name``'s field list.
     |
     |      Values are sent in the caller's order and map positionally to the prepared
     |      fields. The fieldset is prepared on the serving connection on first use
     |      (PREPARE bundled with SET in one write) and reused on subsequent calls;
     |      runtime discards are reconciled on the next use of the connection. All of
     |      this happens inside the normal command path, so retry, disconnect-on-error
     |      and (for the cluster) routing / MOVED-ASK apply exactly as for any command.
     |
     |      .. note::
     |          Recovery from a mid-connection fieldset loss (the server dropping the
     |          prepared fieldset without dropping the socket, e.g. ``RESET`` or
     |          ``maxmemory-clients`` eviction) applies only to a standalone
     |          ``himport_set`` call: it catches the resulting ``no such fieldset`` and
     |          re-prepares on the same socket, retrying the SET once. A ``himport_set``
     |          buffered in a **pipeline or transaction** has no such per-command
     |          recovery — its fieldset is PREPAREd once as a pre-flight before the
     |          batch, and if the server loses it between that pre-flight and the batch
     |          the SET fails and surfaces as an error in the batch results. Callers who
     |          need the automatic recovery should issue those sets outside a pipeline.
     |
     |  hincrby(self, name: 'KeyT', key: 'FieldT', amount: 'int' = 1) -> 'int | Awaitable[int]'
     |      Increment the value of ``key`` in hash ``name`` by ``amount``
     |
     |      For more information, see https://redis.io/commands/hincrby
     |
     |  hincrbyfloat(self, name: 'KeyT', key: 'FieldT', amount: 'float' = 1.0) -> 'float | Awaitable[float]'
     |      Increment the value of ``key`` in hash ``name`` by floating ``amount``
     |
     |      For more information, see https://redis.io/commands/hincrbyfloat
     |
     |  hkeys(self, name: 'KeyT') -> 'list[bytes | str] | Awaitable[list[bytes | str]]'
     |      Return the list of keys within hash ``name``
     |
     |      For more information, see https://redis.io/commands/hkeys
     |
     |  hlen(self, name: 'KeyT') -> 'int | Awaitable[int]'
     |      Return the number of elements in hash ``name``
     |
     |      For more information, see https://redis.io/commands/hlen
     |
     |  hmget(self, name: 'KeyT', keys: 'FieldT | Iterable[FieldT]', *args: 'FieldT') -> 'list[bytes | str | None] | Awaitable[list[bytes | str | None]]'
     |      Returns a list of values ordered identically to ``keys``
     |
     |      For more information, see https://redis.io/commands/hmget
     |
     |  hmset(self, name: 'KeyT', mapping: 'Mapping[FieldT, EncodableT]') -> 'bool | Awaitable[bool]'
     |      Set key to value within hash ``name`` for each corresponding
     |      key and value from the ``mapping`` dict.
     |
     |      For more information, see https://redis.io/commands/hmset
     |
     |  hpersist(self, name: 'KeyT', *fields: 'FieldT') -> 'list[int] | Awaitable[list[int]]'
     |      Removes the expiration time for each specified field in a hash.
     |
     |      For more information, see https://redis.io/commands/hpersist
     |
     |      Args:
     |          name: The name of the hash key.
     |          fields: A list of fields within the hash from which to remove the
     |                  expiration time.
     |
     |      Returns:
     |          Returns a list which contains for each field in the request:
     |              - `-2` if the field does not exist, or if the key does not exist.
     |              - `-1` if the field exists but has no associated expiration time.
     |              - `1` if the expiration time was successfully removed from the field.
     |
     |  hpexpire(self, name: 'KeyT', milliseconds: 'ExpiryT', *fields: 'FieldT', nx: 'bool' = False, xx: 'bool' = False, gt: 'bool' = False, lt: 'bool' = False) -> 'list[int] | Awaitable[list[int]]'
     |      Sets or updates the expiration time for fields within a hash key, using relative
     |      time in milliseconds.
     |
     |      If a field already has an expiration time, the behavior of the update can be
     |      controlled using the `nx`, `xx`, `gt`, and `lt` parameters.
     |
     |      The return value provides detailed information about the outcome for each field.
     |
     |      For more information, see https://redis.io/commands/hpexpire
     |
     |      Args:
     |          name: The name of the hash key.
     |          milliseconds: Expiration time in milliseconds, relative. Can be an integer,
     |                        or a Python `timedelta` object.
     |          fields: List of fields within the hash to apply the expiration time to.
     |          nx: Set expiry only when the field has no expiry.
     |          xx: Set expiry only when the field has an existing expiry.
     |          gt: Set expiry only when the new expiry is greater than the current one.
     |          lt: Set expiry only when the new expiry is less than the current one.
     |
     |      Returns:
     |          Returns a list which contains for each field in the request:
     |              - `-2` if the field does not exist, or if the key does not exist.
     |              - `0` if the specified NX | XX | GT | LT condition was not met.
     |              - `1` if the expiration time was set or updated.
     |              - `2` if the field was deleted because the specified expiration time is
     |                in the past.
     |
     |  hpexpireat(self, name: 'KeyT', unix_time_milliseconds: 'AbsExpiryT', *fields: 'FieldT', nx: 'bool' = False, xx: 'bool' = False, gt: 'bool' = False, lt: 'bool' = False) -> 'list[int] | Awaitable[list[int]]'
     |      Sets or updates the expiration time for fields within a hash key, using an
     |      absolute Unix timestamp in milliseconds.
     |
     |      If a field already has an expiration time, the behavior of the update can be
     |      controlled using the `nx`, `xx`, `gt`, and `lt` parameters.
     |
     |      The return value provides detailed information about the outcome for each field.
     |
     |      For more information, see https://redis.io/commands/hpexpireat
     |
     |      Args:
     |          name: The name of the hash key.
     |          unix_time_milliseconds: Expiration time as Unix timestamp in milliseconds.
     |                                  Can be an integer or a Python `datetime` object.
     |          fields: List of fields within the hash to apply the expiry.
     |          nx: Set expiry only when the field has no expiry.
     |          xx: Set expiry only when the field has an existing expiry.
     |          gt: Set expiry only when the new expiry is greater than the current one.
     |          lt: Set expiry only when the new expiry is less than the current one.
     |
     |      Returns:
     |          Returns a list which contains for each field in the request:
     |              - `-2` if the field does not exist, or if the key does not exist.
     |              - `0` if the specified NX | XX | GT | LT condition was not met.
     |              - `1` if the expiration time was set or updated.
     |              - `2` if the field was deleted because the specified expiration time is
     |                in the past.
     |
     |  hpexpiretime(self, key: 'KeyT', *fields: 'FieldT') -> 'list[int] | Awaitable[list[int]]'
     |      Returns the expiration times of hash fields as Unix timestamps in milliseconds.
     |
     |      For more information, see https://redis.io/commands/hpexpiretime
     |
     |      Args:
     |          key: The hash key.
     |          fields: A list of fields within the hash for which to get the expiration
     |                  time.
     |
     |      Returns:
     |          Returns a list which contains for each field in the request:
     |              - `-2` if the field does not exist, or if the key does not exist.
     |              - `-1` if the field exists but has no associated expire time.
     |              - A positive integer representing the expiration Unix timestamp in
     |                milliseconds, if the field has an associated expiration time.
     |
     |  hpttl(self, key: 'KeyT', *fields: 'FieldT') -> 'list[int] | Awaitable[list[int]]'
     |      Returns the TTL (Time To Live) in milliseconds for each specified field within a
     |      hash key.
     |
     |      For more information, see https://redis.io/commands/hpttl
     |
     |      Args:
     |          key: The hash key.
     |          fields: A list of fields within the hash for which to get the TTL.
     |
     |      Returns:
     |          Returns a list which contains for each field in the request:
     |              - `-2` if the field does not exist, or if the key does not exist.
     |              - `-1` if the field exists but has no associated expire time.
     |              - A positive integer representing the TTL in milliseconds if the field
     |                has an associated expiration time.
     |
     |  hset(self, name: 'KeyT', key: 'FieldT | None' = None, value: 'EncodableT | None' = None, mapping: 'Mapping[FieldT, EncodableT] | None' = None, items: 'Sequence[EncodableT] | None' = None) -> 'int | Awaitable[int]'
     |      Set ``key`` to ``value`` within hash ``name``,
     |      ``mapping`` accepts a dict of key/value pairs that will be
     |      added to hash ``name``.
     |      ``items`` accepts a list of key/value pairs that will be
     |      added to hash ``name``.
     |      Returns the number of fields that were added.
     |
     |      For more information, see https://redis.io/commands/hset
     |
     |  hsetex(self, name: 'KeyT', key: 'FieldT | None' = None, value: 'EncodableT | None' = None, mapping: 'Mapping[FieldT, EncodableT] | None' = None, items: 'Sequence[EncodableT] | None' = None, ex: 'ExpiryT | None' = None, px: 'ExpiryT | None' = None, exat: 'AbsExpiryT | None' = None, pxat: 'AbsExpiryT | None' = None, data_persist_option: 'HashDataPersistOptions | None' = None, keepttl: 'bool' = False) -> 'int | Awaitable[int]'
     |      Set ``key`` to ``value`` within hash ``name``
     |
     |      ``mapping`` accepts a dict of key/value pairs that will be
     |      added to hash ``name``.
     |
     |      ``items`` accepts a list of key/value pairs that will be
     |      added to hash ``name``.
     |
     |      ``ex`` sets an expire flag on ``keys`` for ``ex`` seconds.
     |
     |      ``px`` sets an expire flag on ``keys`` for ``px`` milliseconds.
     |
     |      ``exat`` sets an expire flag on ``keys`` for ``ex`` seconds,
     |          specified in unix time.
     |
     |      ``pxat`` sets an expire flag on ``keys`` for ``ex`` milliseconds,
     |          specified in unix time.
     |
     |      ``data_persist_option`` can be set to ``FNX`` or ``FXX`` to control the
     |          behavior of the command.
     |          ``FNX`` will set the value for each provided key to each
     |              provided value only if all do not already exist.
     |          ``FXX`` will set the value for each provided key to each
     |              provided value only if all already exist.
     |
     |      ``keepttl`` if True, retain the time to live associated with the keys.
     |
     |      Returns the number of fields that were added.
     |
     |      Available since Redis 8.0
     |      For more information, see https://redis.io/commands/hsetex
     |
     |  hsetnx(self, name: 'KeyT', key: 'FieldT', value: 'EncodableT') -> 'int | Awaitable[int]'
     |      Set ``key`` to ``value`` within hash ``name`` if ``key`` does not
     |      exist.  Returns 1 if HSETNX created a field, otherwise 0.
     |
     |      For more information, see https://redis.io/commands/hsetnx
     |
     |  hstrlen(self, name: 'KeyT', key: 'FieldT') -> 'int | Awaitable[int]'
     |      Return the number of bytes stored in the value of ``key``
     |      within hash ``name``
     |
     |      For more information, see https://redis.io/commands/hstrlen
     |
     |  httl(self, key: 'KeyT', *fields: 'FieldT') -> 'list[int] | Awaitable[list[int]]'
     |      Returns the TTL (Time To Live) in seconds for each specified field within a hash
     |      key.
     |
     |      For more information, see https://redis.io/commands/httl
     |
     |      Args:
     |          key: The hash key.
     |          fields: A list of fields within the hash for which to get the TTL.
     |
     |      Returns:
     |          Returns a list which contains for each field in the request:
     |              - `-2` if the field does not exist, or if the key does not exist.
     |              - `-1` if the field exists but has no associated expire time.
     |              - A positive integer representing the TTL in seconds if the field has
     |                an associated expiration time.
     |
     |  hvals(self, name: 'KeyT') -> 'list[bytes | str] | Awaitable[list[bytes | str]]'
     |      Return the list of values within hash ``name``
     |
     |      For more information, see https://redis.io/commands/hvals
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from GeoCommands:
     |
     |  geoadd(self, name: 'KeyT', values: 'Sequence[EncodableT]', nx: 'bool' = False, xx: 'bool' = False, ch: 'bool' = False) -> 'int | Awaitable[int]'
     |      Add the specified geospatial items to the specified key identified
     |      by the ``name`` argument. The Geospatial items are given as ordered
     |      members of the ``values`` argument, each item or place is formed by
     |      the triad longitude, latitude and name.
     |
     |      Note: You can use ZREM to remove elements.
     |
     |      ``nx`` forces ZADD to only create new elements and not to update
     |      scores for elements that already exist.
     |
     |      ``xx`` forces ZADD to only update scores of elements that already
     |      exist. New elements will not be added.
     |
     |      ``ch`` modifies the return value to be the numbers of elements changed.
     |      Changed elements include new elements that were added and elements
     |      whose scores changed.
     |
     |      For more information, see https://redis.io/commands/geoadd
     |
     |  geodist(self, name: 'KeyT', place1: 'FieldT', place2: 'FieldT', unit: 'str | None' = None) -> 'float | None | Awaitable[float | None]'
     |      Return the distance between ``place1`` and ``place2`` members of the
     |      ``name`` key.
     |      The units must be one of the following : m, km mi, ft. By default
     |      meters are used.
     |
     |      For more information, see https://redis.io/commands/geodist
     |
     |  geohash(self, name: 'KeyT', *values: 'FieldT') -> 'list[bytes | str | None] | Awaitable[list[bytes | str | None]]'
     |      Return the geo hash string for each item of ``values`` members of
     |      the specified key identified by the ``name`` argument.
     |
     |      For more information, see https://redis.io/commands/geohash
     |
     |  geopos(self, name: 'KeyT', *values: 'FieldT') -> 'list[GeoCoordinate | None] | Awaitable[list[GeoCoordinate | None]]'
     |      Return the positions of each item of ``values`` as members of
     |      the specified key identified by the ``name`` argument. Each position
     |      is represented by the pairs lon and lat.
     |
     |      For more information, see https://redis.io/commands/geopos
     |
     |  georadius(self, name: 'KeyT', longitude: 'float', latitude: 'float', radius: 'float', unit: 'str | None' = None, withdist: 'bool' = False, withcoord: 'bool' = False, withhash: 'bool' = False, count: 'int | None' = None, sort: 'str | None' = None, store: 'KeyT | None' = None, store_dist: 'KeyT | None' = None, any: 'bool' = False) -> 'GeoRadiusResponse | Awaitable[GeoRadiusResponse]'
     |      Return the members of the specified key identified by the
     |      ``name`` argument which are within the borders of the area specified
     |      with the ``latitude`` and ``longitude`` location and the maximum
     |      distance from the center specified by the ``radius`` value.
     |
     |      The units must be one of the following : m, km mi, ft. By default
     |
     |      ``withdist`` indicates to return the distances of each place.
     |
     |      ``withcoord`` indicates to return the latitude and longitude of
     |      each place.
     |
     |      ``withhash`` indicates to return the geohash string of each place.
     |
     |      ``count`` indicates to return the number of elements up to N.
     |
     |      ``sort`` indicates to return the places in a sorted way, ASC for
     |      nearest to fairest and DESC for fairest to nearest.
     |
     |      ``store`` indicates to save the places names in a sorted set named
     |      with a specific key, each element of the destination sorted set is
     |      populated with the score got from the original geo sorted set.
     |
     |      ``store_dist`` indicates to save the places names in a sorted set
     |      named with a specific key, instead of ``store`` the sorted set
     |      destination score is set with the distance.
     |
     |      For more information, see https://redis.io/commands/georadius
     |
     |  georadiusbymember(self, name: 'KeyT', member: 'FieldT', radius: 'float', unit: 'str | None' = None, withdist: 'bool' = False, withcoord: 'bool' = False, withhash: 'bool' = False, count: 'int | None' = None, sort: 'str | None' = None, store: 'Union[KeyT, None]' = None, store_dist: 'Union[KeyT, None]' = None, any: 'bool' = False) -> 'GeoRadiusResponse | Awaitable[GeoRadiusResponse]'
     |      This command is exactly like ``georadius`` with the sole difference
     |      that instead of taking, as the center of the area to query, a longitude
     |      and latitude value, it takes the name of a member already existing
     |      inside the geospatial index represented by the sorted set.
     |
     |      For more information, see https://redis.io/commands/georadiusbymember
     |
     |  geosearch(self, name: 'KeyT', member: 'FieldT | None' = None, longitude: 'float | None' = None, latitude: 'float | None' = None, unit: 'str' = 'm', radius: 'float | None' = None, width: 'float | None' = None, height: 'float | None' = None, sort: 'str | None' = None, count: 'int | None' = None, any: 'bool' = False, withcoord: 'bool' = False, withdist: 'bool' = False, withhash: 'bool' = False) -> 'GeoSearchResponse | Awaitable[GeoSearchResponse]'
     |      Return the members of specified key identified by the
     |      ``name`` argument, which are within the borders of the
     |      area specified by a given shape. This command extends the
     |      GEORADIUS command, so in addition to searching within circular
     |      areas, it supports searching within rectangular areas.
     |
     |      This command should be used in place of the deprecated
     |      GEORADIUS and GEORADIUSBYMEMBER commands.
     |
     |      ``member`` Use the position of the given existing
     |       member in the sorted set. Can't be given with ``longitude``
     |       and ``latitude``.
     |
     |      ``longitude`` and ``latitude`` Use the position given by
     |      this coordinates. Can't be given with ``member``
     |      ``radius`` Similar to GEORADIUS, search inside circular
     |      area according the given radius. Can't be given with
     |      ``height`` and ``width``.
     |      ``height`` and ``width`` Search inside an axis-aligned
     |      rectangle, determined by the given height and width.
     |      Can't be given with ``radius``
     |
     |      ``unit`` must be one of the following : m, km, mi, ft.
     |      `m` for meters (the default value), `km` for kilometers,
     |      `mi` for miles and `ft` for feet.
     |
     |      ``sort`` indicates to return the places in a sorted way,
     |      ASC for nearest to furthest and DESC for furthest to nearest.
     |
     |      ``count`` limit the results to the first count matching items.
     |
     |      ``any`` is set to True, the command will return as soon as
     |      enough matches are found. Can't be provided without ``count``
     |
     |      ``withdist`` indicates to return the distances of each place.
     |      ``withcoord`` indicates to return the latitude and longitude of
     |      each place.
     |
     |      ``withhash`` indicates to return the geohash string of each place.
     |
     |      For more information, see https://redis.io/commands/geosearch
     |
     |  geosearchstore(self, dest: 'KeyT', name: 'KeyT', member: 'FieldT | None' = None, longitude: 'float | None' = None, latitude: 'float | None' = None, unit: 'str' = 'm', radius: 'float | None' = None, width: 'float | None' = None, height: 'float | None' = None, sort: 'str | None' = None, count: 'int | None' = None, any: 'bool' = False, storedist: 'bool' = False) -> 'int | Awaitable[int]'
     |      This command is like GEOSEARCH, but stores the result in
     |      ``dest``. By default, it stores the results in the destination
     |      sorted set with their geospatial information.
     |      if ``store_dist`` set to True, the command will stores the
     |      items in a sorted set populated with their distance from the
     |      center of the circle or box, as a floating-point number.
     |
     |      For more information, see https://redis.io/commands/geosearchstore
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from ListCommands:
     |
     |  blmpop(self, timeout: 'float', numkeys: 'int', *args: 'str', direction: 'str', count: 'int | None' = 1) -> 'ListMultiPopResponse | Awaitable[ListMultiPopResponse]'
     |      Pop ``count`` values (default 1) from first non-empty in the list
     |      of provided key names.
     |
     |      When all lists are empty this command blocks the connection until another
     |      client pushes to it or until the timeout, timeout of 0 blocks indefinitely
     |
     |      For more information, see https://redis.io/commands/blmpop
     |
     |  blpop(self, keys: 'KeysT', timeout: 'Number | None' = 0) -> 'BlockingListPopResponse | Awaitable[BlockingListPopResponse]'
     |      LPOP a value off of the first non-empty list
     |      named in ``keys``.
     |
     |      If none of the lists in ``keys`` has a value to LPOP, then block
     |      for ``timeout`` seconds, or until a value gets pushed on to one
     |      of the lists.
     |
     |      If timeout is 0, then block indefinitely.
     |
     |      For more information, see https://redis.io/commands/blpop
     |
     |  brpop(self, keys: 'KeysT', timeout: 'Number | None' = 0) -> 'BlockingListPopResponse | Awaitable[BlockingListPopResponse]'
     |      RPOP a value off of the first non-empty list
     |      named in ``keys``.
     |
     |      If none of the lists in ``keys`` has a value to RPOP, then block
     |      for ``timeout`` seconds, or until a value gets pushed on to one
     |      of the lists.
     |
     |      If timeout is 0, then block indefinitely.
     |
     |      For more information, see https://redis.io/commands/brpop
     |
     |  brpoplpush(self, src: 'KeyT', dst: 'KeyT', timeout: 'Number | None' = 0) -> 'bytes | str | None | Awaitable[bytes | str | None]'
     |      Pop a value off the tail of ``src``, push it on the head of ``dst``
     |      and then return it.
     |
     |      This command blocks until a value is in ``src`` or until ``timeout``
     |      seconds elapse, whichever is first. A ``timeout`` value of 0 blocks
     |      forever.
     |
     |      For more information, see https://redis.io/commands/brpoplpush
     |
     |  lindex(self, name: 'KeyT', index: 'int') -> 'bytes | str | None | Awaitable[bytes | str | None]'
     |      Return the item from list ``name`` at position ``index``
     |
     |      Negative indexes are supported and will return an item at the
     |      end of the list
     |
     |      For more information, see https://redis.io/commands/lindex
     |
     |  linsert(self, name: 'KeyT', where: 'str', refvalue: 'str', value: 'str') -> 'int | Awaitable[int]'
     |      Insert ``value`` in list ``name`` either immediately before or after
     |      [``where``] ``refvalue``
     |
     |      Returns the new length of the list on success or -1 if ``refvalue``
     |      is not in the list.
     |
     |      For more information, see https://redis.io/commands/linsert
     |
     |  llen(self, name: 'KeyT') -> 'int | Awaitable[int]'
     |      Return the length of the list ``name``
     |
     |      For more information, see https://redis.io/commands/llen
     |
     |  lmpop(self, num_keys: 'int', *args: 'str', direction: 'str', count: 'int | None' = 1) -> 'ListMultiPopResponse | Awaitable[ListMultiPopResponse]'
     |      Pop ``count`` values (default 1) first non-empty list key from the list
     |      of args provided key names.
     |
     |      For more information, see https://redis.io/commands/lmpop
     |
     |  lpop(self, name: 'KeyT', count: 'int | None' = None) -> 'bytes | str | list[bytes | str] | None | Awaitable[bytes | str | list[bytes | str] | None]'
     |      Removes and returns the first elements of the list ``name``.
     |
     |      By default, the command pops a single element from the beginning of
     |      the list. When provided with the optional ``count`` argument, the reply
     |      will consist of up to count elements, depending on the list's length.
     |
     |      For more information, see https://redis.io/commands/lpop
     |
     |  lpos(self, name: 'KeyT', value: 'str', rank: 'int | None' = None, count: 'int | None' = None, maxlen: 'int | None' = None) -> 'int | list[int] | None | Awaitable[int | list[int] | None]'
     |      Get position of ``value`` within the list ``name``
     |
     |       If specified, ``rank`` indicates the "rank" of the first element to
     |       return in case there are multiple copies of ``value`` in the list.
     |       By default, LPOS returns the position of the first occurrence of
     |       ``value`` in the list. When ``rank`` 2, LPOS returns the position of
     |       the second ``value`` in the list. If ``rank`` is negative, LPOS
     |       searches the list in reverse. For example, -1 would return the
     |       position of the last occurrence of ``value`` and -2 would return the
     |       position of the next to last occurrence of ``value``.
     |
     |       If specified, ``count`` indicates that LPOS should return a list of
     |       up to ``count`` positions. A ``count`` of 2 would return a list of
     |       up to 2 positions. A ``count`` of 0 returns a list of all positions
     |       matching ``value``. When ``count`` is specified and but ``value``
     |       does not exist in the list, an empty list is returned.
     |
     |       If specified, ``maxlen`` indicates the maximum number of list
     |       elements to scan. A ``maxlen`` of 1000 will only return the
     |       position(s) of items within the first 1000 entries in the list.
     |       A ``maxlen`` of 0 (the default) will scan the entire list.
     |
     |       For more information, see https://redis.io/commands/lpos
     |
     |  lpush(self, name: 'KeyT', *values: 'FieldT') -> 'int | Awaitable[int]'
     |      Push ``values`` onto the head of the list ``name``
     |
     |      For more information, see https://redis.io/commands/lpush
     |
     |  lpushx(self, name: 'KeyT', *values: 'FieldT') -> 'int | Awaitable[int]'
     |      Push ``value`` onto the head of the list ``name`` if ``name`` exists
     |
     |      For more information, see https://redis.io/commands/lpushx
     |
     |  lrange(self, name: 'KeyT', start: 'int', end: 'int') -> 'list[bytes | str] | Awaitable[list[bytes | str]]'
     |      Return a slice of the list ``name`` between
     |      position ``start`` and ``end``
     |
     |      ``start`` and ``end`` can be negative numbers just like
     |      Python slicing notation
     |
     |      For more information, see https://redis.io/commands/lrange
     |
     |  lrem(self, name: 'KeyT', count: 'int', value: 'str') -> 'int | Awaitable[int]'
     |      Remove the first ``count`` occurrences of elements equal to ``value``
     |      from the list stored at ``name``.
     |
     |      The count argument influences the operation in the following ways:
     |          count > 0: Remove elements equal to value moving from head to tail.
     |          count < 0: Remove elements equal to value moving from tail to head.
     |          count = 0: Remove all elements equal to value.
     |
     |          For more information, see https://redis.io/commands/lrem
     |
     |  lset(self, name: 'KeyT', index: 'int', value: 'str') -> 'bool | Awaitable[bool]'
     |      Set element at ``index`` of list ``name`` to ``value``
     |
     |      For more information, see https://redis.io/commands/lset
     |
     |  ltrim(self, name: 'KeyT', start: 'int', end: 'int') -> 'bool | Awaitable[bool]'
     |      Trim the list ``name``, removing all values not within the slice
     |      between ``start`` and ``end``
     |
     |      ``start`` and ``end`` can be negative numbers just like
     |      Python slicing notation
     |
     |      For more information, see https://redis.io/commands/ltrim
     |
     |  rpop(self, name: 'KeyT', count: 'int | None' = None) -> 'bytes | str | list[bytes | str] | None | Awaitable[bytes | str | list[bytes | str] | None]'
     |      Removes and returns the last elements of the list ``name``.
     |
     |      By default, the command pops a single element from the end of the list.
     |      When provided with the optional ``count`` argument, the reply will
     |      consist of up to count elements, depending on the list's length.
     |
     |      For more information, see https://redis.io/commands/rpop
     |
     |  rpoplpush(self, src: 'KeyT', dst: 'KeyT') -> 'bytes | str | None | Awaitable[bytes | str | None]'
     |      RPOP a value off of the ``src`` list and atomically LPUSH it
     |      on to the ``dst`` list.  Returns the value.
     |
     |      For more information, see https://redis.io/commands/rpoplpush
     |
     |  rpush(self, name: 'KeyT', *values: 'FieldT') -> 'int | Awaitable[int]'
     |      Push ``values`` onto the tail of the list ``name``
     |
     |      For more information, see https://redis.io/commands/rpush
     |
     |  rpushx(self, name: 'KeyT', *values: 'str') -> 'int | Awaitable[int]'
     |      Push ``value`` onto the tail of the list ``name`` if ``name`` exists
     |
     |      For more information, see https://redis.io/commands/rpushx
     |
     |  sort(self, name: 'KeyT', start: 'int | None' = None, num: 'int | None' = None, by: 'str | None' = None, get: 'list[str] | None' = None, desc: 'bool' = False, alpha: 'bool' = False, store: 'str | None' = None, groups: 'bool | None' = False) -> 'SortResponse | Awaitable[SortResponse]'
     |      Sort and return the list, set or sorted set at ``name``.
     |
     |      ``start`` and ``num`` allow for paging through the sorted data
     |
     |      ``by`` allows using an external key to weight and sort the items.
     |          Use an "*" to indicate where in the key the item value is located
     |
     |      ``get`` allows for returning items from external keys rather than the
     |          sorted data itself.  Use an "*" to indicate where in the key
     |          the item value is located
     |
     |      ``desc`` allows for reversing the sort
     |
     |      ``alpha`` allows for sorting lexicographically rather than numerically
     |
     |      ``store`` allows for storing the result of the sort into
     |          the key ``store``
     |
     |      ``groups`` if set to True and if ``get`` contains at least two
     |          elements, sort will return a list of tuples, each containing the
     |          values fetched from the arguments to ``get``.
     |
     |      For more information, see https://redis.io/commands/sort
     |
     |  sort_ro(self, key: 'str', start: 'int | None' = None, num: 'int | None' = None, by: 'str | None' = None, get: 'list[str] | None' = None, desc: 'bool' = False, alpha: 'bool' = False) -> 'list[bytes | str] | Awaitable[list[bytes | str]]'
     |      Returns the elements contained in the list, set or sorted set at key.
     |      (read-only variant of the SORT command)
     |
     |      ``start`` and ``num`` allow for paging through the sorted data
     |
     |      ``by`` allows using an external key to weight and sort the items.
     |          Use an "*" to indicate where in the key the item value is located
     |
     |      ``get`` allows for returning items from external keys rather than the
     |          sorted data itself.  Use an "*" to indicate where in the key
     |          the item value is located
     |
     |      ``desc`` allows for reversing the sort
     |
     |      ``alpha`` allows for sorting lexicographically rather than numerically
     |
     |      For more information, see https://redis.io/commands/sort_ro
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from ArrayCommands:
     |
     |  arcount(self, name: 'KeyT') -> 'int | Awaitable[int]'
     |      Return the number of non-empty elements in the array stored at
     |      ``name``. Returns 0 if ``name`` does not exist.
     |
     |      For more information, see https://redis.io/commands/arcount
     |
     |  ardel(self, name: 'KeyT', *indices: 'int') -> 'int | Awaitable[int]'
     |      Delete elements at the specified ``indices`` in the array stored at
     |      ``name``. Deleting an index that does not exist counts as zero
     |      elements deleted and does not modify the array.
     |
     |      Returns the number of elements deleted.
     |
     |      For more information, see https://redis.io/commands/ardel
     |
     |  ardelrange(self, name: 'KeyT', *ranges: 'tuple[int, int]') -> 'int | Awaitable[int]'
     |      Delete elements within one or more inclusive index ranges in the
     |      array stored at ``name``. Each range is a ``(start, end)`` tuple.
     |      If ``start`` is greater than ``end`` for a given pair, the range is
     |      processed in ascending order regardless. Multiple pairs may overlap;
     |      each element is counted at most once.
     |
     |      Returns the number of elements deleted.
     |
     |      For more information, see https://redis.io/commands/ardelrange
     |
     |  arget(self, name: 'KeyT', index: 'int') -> 'bytes | str | None | Awaitable[bytes | str | None]'
     |      Return the value at ``index`` in the array stored at ``name``.
     |
     |      Returns ``None`` if ``name`` does not exist or no value is set at
     |      ``index``.
     |
     |      For more information, see https://redis.io/commands/arget
     |
     |  argetrange(self, name: 'KeyT', start: 'int', end: 'int') -> 'list[bytes | str | None] | Awaitable[list[bytes | str | None]]'
     |      Return the values in the inclusive index range [``start``, ``end``]
     |      in the array stored at ``name``. If ``start`` is greater than ``end``,
     |      elements are returned in reverse index order.
     |
     |      For more information, see https://redis.io/commands/argetrange
     |
     |  argrep(self, name: 'KeyT', start: 'int', end: 'int', predicates: 'list[tuple[ArrayPredicateType, EncodableT]]', combinator: 'ArrayPredicateCombinator | None' = None, limit: 'int | None' = None, withvalues: 'bool' = False, nocase: 'bool' = False) -> 'list[int] | list[list[int | bytes | str]] | Awaitable[list[int] | list[list[int | bytes | str]]]'
     |      Search elements of the array stored at ``name`` within the inclusive
     |      index range [``start``, ``end``] using one or more textual
     |      ``predicates``. Each predicate is a ``(type, value)`` tuple where
     |      ``type`` is a member of ``ArrayPredicateType``
     |      (``EXACT``, ``MATCH``, ``GLOB``, ``RE``).
     |
     |      Multiple predicates are combined via ``combinator``
     |      (``ArrayPredicateCombinator.AND`` or ``OR``); the server defaults to
     |      OR when omitted. ``limit`` caps the number of matches.
     |      ``withvalues=True`` returns a list of ``[index, value]`` pairs
     |      (``[[idx, val], ...]``) instead of a flat list of indices.
     |      ``nocase=True`` makes all comparisons case-insensitive.
     |
     |      Without ``withvalues``, returns a flat list of matching indices in
     |      traversal order. With ``withvalues``, returns a list of
     |      ``[index, value]`` pairs in traversal order. Empty slots are
     |      skipped.
     |
     |      For more information, see https://redis.io/commands/argrep
     |
     |  arinfo(self, name: 'KeyT', full: 'bool' = False) -> 'dict[str, int] | Awaitable[dict[str, int]]'
     |      Return metadata about the array stored at ``name`` as a dictionary.
     |      When ``full`` is ``True``, additionally include per-slice statistics
     |      (dense/sparse slice counts, average sizes, fill rates), which makes
     |      the call O(N) instead of O(1).
     |
     |      Raises ``ResponseError`` when the key does not exist.
     |
     |      For more information, see https://redis.io/commands/arinfo
     |
     |  arinsert(self, name: 'KeyT', *values: 'FieldT') -> 'int | Awaitable[int]'
     |      Insert one or more ``values`` at consecutive indices in the array
     |      stored at ``name``, beginning at the current insert cursor position.
     |      The cursor advances by one for each value inserted. Use ``ARNEXT``
     |      to inspect the current cursor position and ``ARSEEK`` to reposition
     |      it.
     |
     |      Returns the last index where a value was inserted.
     |
     |      For more information, see https://redis.io/commands/arinsert
     |
     |  arlastitems(self, name: 'KeyT', count: 'int', rev: 'bool' = False) -> 'list[bytes | str | None] | Awaitable[list[bytes | str | None]]'
     |      Return up to ``count`` most recently inserted elements from the array
     |      stored at ``name``. If the array contains fewer elements than
     |      ``count``, all elements are returned.
     |
     |      When ``rev`` is ``True``, elements are returned in reverse
     |      chronological order (most recent first) instead of the default
     |      oldest-first order.
     |
     |      For more information, see https://redis.io/commands/arlastitems
     |
     |  arlen(self, name: 'KeyT') -> 'int | Awaitable[int]'
     |      Return the length of the array stored at ``name``, defined as the
     |      maximum set index plus one. Returns 0 if ``name`` does not exist.
     |
     |      For more information, see https://redis.io/commands/arlen
     |
     |  armget(self, name: 'KeyT', *indices: 'int') -> 'list[bytes | str | None] | Awaitable[list[bytes | str | None]]'
     |      Return the values at the specified ``indices`` in the array stored at
     |      ``name``. The reply preserves the order of the requested indices and
     |      returns ``None`` for any index that is not set or when ``name`` does
     |      not exist.
     |
     |      For more information, see https://redis.io/commands/armget
     |
     |  armset(self, name: 'KeyT', mapping: 'Mapping[int, FieldT]') -> 'int | Awaitable[int]'
     |      Set multiple index/value pairs in the array stored at ``name``.
     |      ``mapping`` is a dictionary of zero-based integer indices to values.
     |      Pairs may be non-contiguous and in any order.
     |
     |      Returns the number of new slots that were set (previously empty).
     |
     |      For more information, see https://redis.io/commands/armset
     |
     |  arnext(self, name: 'KeyT') -> 'int | None | Awaitable[int | None]'
     |      Return the next index ``ARINSERT`` would use for the array stored at
     |      ``name``. Returns 0 if ``name`` does not exist or no insert happened
     |      yet, and ``None`` when the insertion cursor is exhausted (next insert
     |      would overflow).
     |
     |      For more information, see https://redis.io/commands/arnext
     |
     |  arop(self, name: 'KeyT', start: 'int', end: 'int', operation: 'ArrayAggregateOperations', value: 'EncodableT | None' = None) -> 'bytes | str | int | None | Awaitable[bytes | str | int | None]'
     |      Perform an aggregate ``operation`` on elements of the array stored at
     |      ``name`` in the inclusive index range [``start``, ``end``]. The range
     |      is always scanned from the lower to the higher index regardless of
     |      argument order.
     |
     |      ``operation`` is one of the members of ``ArrayAggregateOperations``.
     |      ``value`` is required when ``operation`` is
     |      ``ArrayAggregateOperations.MATCH`` and specifies the value to compare
     |      against.
     |
     |      Returns a bulk string for ``SUM``, ``MIN`` and ``MAX``, an integer
     |      for ``AND``, ``OR``, ``XOR``, ``MATCH`` and ``USED``, or ``None``
     |      when no elements match the operation.
     |
     |      For more information, see https://redis.io/commands/arop
     |
     |  arring(self, name: 'KeyT', size: 'int', *values: 'FieldT') -> 'int | Awaitable[int]'
     |      Insert one or more ``values`` into the array stored at ``name`` as a
     |      fixed-size ring buffer of ``size`` slots. Each value is placed at
     |      ``insert_idx % size``, wrapping back to index 0 once the end is
     |      reached and overwriting older values when full. If ``size`` is
     |      smaller than the current window, the array is truncated to fit.
     |
     |      Returns the last index where a value was inserted.
     |
     |      For more information, see https://redis.io/commands/arring
     |
     |  arscan(self, name: 'KeyT', start: 'int', end: 'int', limit: 'int | None' = None) -> 'list[list[int | bytes | str]] | Awaitable[list[list[int | bytes | str]]]'
     |      Iterate populated elements of the array stored at ``name`` in the
     |      inclusive range [``start``, ``end``] and return a list of
     |      ``[index, value]`` pairs in traversal order:
     |      ``[[idx1, val1], [idx2, val2], ...]``. Empty slots are skipped. If
     |      ``start`` is greater than ``end``, the iteration is reversed.
     |
     |      ``limit`` caps the number of populated elements returned. When
     |      omitted, all populated elements in range are returned.
     |
     |      For more information, see https://redis.io/commands/arscan
     |
     |  arseek(self, name: 'KeyT', index: 'int') -> 'int | Awaitable[int]'
     |      Set the insert cursor of the array stored at ``name`` to ``index``.
     |      Subsequent ``ARINSERT`` and ``ARRING`` operations begin inserting at
     |      this position.
     |
     |      Returns 1 if the cursor was set, 0 if ``name`` does not exist.
     |
     |      For more information, see https://redis.io/commands/arseek
     |
     |  arset(self, name: 'KeyT', index: 'int', *values: 'FieldT') -> 'int | Awaitable[int]'
     |      Set one or more contiguous ``values`` in the array stored at ``name``
     |      starting at ``index``. When multiple values are provided, they are
     |      stored at consecutive indices beginning at ``index``.
     |
     |      Returns the number of new slots that were set (previously empty).
     |
     |      For more information, see https://redis.io/commands/arset
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from AsyncScanCommands:
     |
     |  async hscan_iter(self, name: 'KeyT', match: 'Union[PatternT, None]' = None, count: 'Optional[int]' = None, no_values: 'Union[bool, None]' = None) -> 'AsyncIterator'
     |      Make an iterator using the HSCAN command so that the client doesn't
     |      need to remember the cursor position.
     |
     |      ``match`` allows for filtering the keys by pattern
     |
     |      ``count`` allows for hint the minimum number of returns
     |
     |      ``no_values`` indicates to return only the keys, without values
     |
     |  async scan_iter(self, match: 'Union[PatternT, None]' = None, count: 'Optional[int]' = None, _type: 'Optional[str]' = None, **kwargs) -> 'AsyncIterator'
     |      Make an iterator using the SCAN command so that the client doesn't
     |      need to remember the cursor position.
     |
     |      ``match`` allows for filtering the keys by pattern
     |
     |      ``count`` provides a hint to Redis about the number of keys to
     |          return per batch.
     |
     |      ``_type`` filters the returned values by a particular Redis type.
     |          Stock Redis instances allow for the following types:
     |          HASH, LIST, SET, STREAM, STRING, ZSET
     |          Additionally, Redis modules can expose other types as well.
     |
     |  async sscan_iter(self, name: 'KeyT', match: 'Union[PatternT, None]' = None, count: 'Optional[int]' = None) -> 'AsyncIterator'
     |      Make an iterator using the SSCAN command so that the client doesn't
     |      need to remember the cursor position.
     |
     |      ``match`` allows for filtering the keys by pattern
     |
     |      ``count`` allows for hint the minimum number of returns
     |
     |  async zscan_iter(self, name: 'KeyT', match: 'Union[PatternT, None]' = None, count: 'Optional[int]' = None, score_cast_func: 'Union[type, Callable]' = <class 'float'>) -> 'AsyncIterator'
     |      Make an iterator using the ZSCAN command so that the client doesn't
     |      need to remember the cursor position.
     |
     |      ``match`` allows for filtering the keys by pattern
     |
     |      ``count`` allows for hint the minimum number of returns
     |
     |      ``score_cast_func`` a callable used to cast the score return value
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from ScanCommands:
     |
     |  hscan(self, name: 'KeyT', cursor: 'int' = 0, match: 'PatternT | None' = None, count: 'int | None' = None, no_values: 'bool | None' = None) -> 'HScanResponse | Awaitable[HScanResponse]'
     |      Incrementally return key/value slices in a hash. Also return a cursor
     |      indicating the scan position.
     |
     |      ``match`` allows for filtering the keys by pattern
     |
     |      ``count`` allows for hint the minimum number of returns
     |
     |      ``no_values`` indicates to return only the keys, without values.
     |
     |      For more information, see https://redis.io/commands/hscan
     |
     |  scan(self, cursor: 'int' = 0, match: 'PatternT | None' = None, count: 'int | None' = None, _type: 'str | None' = None, **kwargs) -> 'ScanResponse | Awaitable[ScanResponse]'
     |      Incrementally return lists of key names. Also return a cursor
     |      indicating the scan position.
     |
     |      ``match`` allows for filtering the keys by pattern
     |
     |      ``count`` provides a hint to Redis about the number of keys to
     |          return per batch.
     |
     |      ``_type`` filters the returned values by a particular Redis type.
     |          Stock Redis instances allow for the following types:
     |          HASH, LIST, SET, STREAM, STRING, ZSET
     |          Additionally, Redis modules can expose other types as well.
     |
     |      For more information, see https://redis.io/commands/scan
     |
     |  sscan(self, name: 'KeyT', cursor: 'int' = 0, match: 'PatternT | None' = None, count: 'int | None' = None) -> 'ScanResponse | Awaitable[ScanResponse]'
     |      Incrementally return lists of elements in a set. Also return a cursor
     |      indicating the scan position.
     |
     |      ``match`` allows for filtering the keys by pattern
     |
     |      ``count`` allows for hint the minimum number of returns
     |
     |      For more information, see https://redis.io/commands/sscan
     |
     |  zscan(self, name: 'KeyT', cursor: 'int' = 0, match: 'PatternT | None' = None, count: 'int | None' = None, score_cast_func: 'type | Callable' = <class 'float'>) -> 'ZScanResponse | Awaitable[ZScanResponse]'
     |      Incrementally return lists of elements in a sorted set. Also return a
     |      cursor indicating the scan position.
     |
     |      ``match`` allows for filtering the keys by pattern
     |
     |      ``count`` allows for hint the minimum number of returns
     |
     |      ``score_cast_func`` a callable used to cast the score return value
     |
     |      For more information, see https://redis.io/commands/zscan
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from SetCommands:
     |
     |  sadd(self, name: 'KeyT', *values: 'FieldT') -> 'int | Awaitable[int]'
     |      Add ``value(s)`` to set ``name``
     |
     |      For more information, see https://redis.io/commands/sadd
     |
     |  scard(self, name: 'KeyT') -> 'int | Awaitable[int]'
     |      Return the number of elements in set ``name``
     |
     |      For more information, see https://redis.io/commands/scard
     |
     |  sdiff(self, keys: 'List', *args: 'List') -> 'set[bytes | str] | Awaitable[set[bytes | str]]'
     |      Return the difference of sets specified by ``keys``
     |
     |      For more information, see https://redis.io/commands/sdiff
     |
     |  sdiffcard(self, numkeys: 'int', keys: 'List[KeyT]', limit: 'int' = 0) -> 'int | Awaitable[int]'
     |      Return the cardinality of the difference between the first set and all
     |      the successive sets specified by ``keys``, without returning the
     |      difference itself.
     |
     |      When LIMIT is provided (defaults to 0 and means unlimited), the returned
     |      cardinality is capped at ``limit`` and the server may stop the
     |      computation once the capped result is known.
     |
     |      For more information, see https://redis.io/commands/sdiffcard
     |
     |  sdiffstore(self, dest: 'str', keys: 'List', *args: 'List') -> 'int | Awaitable[int]'
     |      Store the difference of sets specified by ``keys`` into a new
     |      set named ``dest``.  Returns the number of keys in the new set.
     |
     |      For more information, see https://redis.io/commands/sdiffstore
     |
     |  sinter(self, keys: 'List', *args: 'List') -> 'set[bytes | str] | Awaitable[set[bytes | str]]'
     |      Return the intersection of sets specified by ``keys``
     |
     |      For more information, see https://redis.io/commands/sinter
     |
     |  sintercard(self, numkeys: 'int', keys: 'List[KeyT]', limit: 'int' = 0) -> 'int | Awaitable[int]'
     |      Return the cardinality of the intersect of multiple sets specified by ``keys``.
     |
     |      When LIMIT provided (defaults to 0 and means unlimited), if the intersection
     |      cardinality reaches limit partway through the computation, the algorithm will
     |      exit and yield limit as the cardinality
     |
     |      For more information, see https://redis.io/commands/sintercard
     |
     |  sinterstore(self, dest: 'KeyT', keys: 'List', *args: 'List') -> 'int | Awaitable[int]'
     |      Store the intersection of sets specified by ``keys`` into a new
     |      set named ``dest``.  Returns the number of keys in the new set.
     |
     |      For more information, see https://redis.io/commands/sinterstore
     |
     |  sismember(self, name: 'KeyT', value: 'str') -> 'Literal[0] | Literal[1] | Awaitable[Literal[0] | Literal[1]]'
     |      Return whether ``value`` is a member of set ``name``:
     |      - 1 if the value is a member of the set.
     |      - 0 if the value is not a member of the set or if key does not exist.
     |
     |      For more information, see https://redis.io/commands/sismember
     |
     |  smembers(self, name: 'KeyT') -> 'set[bytes | str] | Awaitable[set[bytes | str]]'
     |      Return all members of the set ``name``
     |
     |      For more information, see https://redis.io/commands/smembers
     |
     |  smismember(self, name: 'KeyT', values: 'List', *args: 'List') -> 'list[Literal[0] | Literal[1]] | Awaitable[list[Literal[0] | Literal[1]]]'
     |      Return whether each value in ``values`` is a member of the set ``name``
     |      as a list of ``int`` in the order of ``values``:
     |      - 1 if the value is a member of the set.
     |      - 0 if the value is not a member of the set or if key does not exist.
     |
     |      For more information, see https://redis.io/commands/smismember
     |
     |  smove(self, src: 'KeyT', dst: 'KeyT', value: 'str') -> 'bool | Awaitable[bool]'
     |      Move ``value`` from set ``src`` to set ``dst`` atomically
     |
     |      For more information, see https://redis.io/commands/smove
     |
     |  spop(self, name: 'KeyT', count: 'int | None' = None) -> 'bytes | str | set[bytes | str] | None | Awaitable[bytes | str | set[bytes | str] | None]'
     |      Remove and return a random member of set ``name``
     |
     |      For more information, see https://redis.io/commands/spop
     |
     |  srandmember(self, name: 'KeyT', number: 'int | None' = None) -> 'bytes | str | list[bytes | str] | None | Awaitable[bytes | str | list[bytes | str] | None]'
     |      If ``number`` is None, returns a random member of set ``name``.
     |
     |      If ``number`` is supplied, returns a list of ``number`` random
     |      members of set ``name``. Note this is only available when running
     |      Redis 2.6+.
     |
     |      For more information, see https://redis.io/commands/srandmember
     |
     |  srem(self, name: 'KeyT', *values: 'FieldT') -> 'int | Awaitable[int]'
     |      Remove ``values`` from set ``name``
     |
     |      For more information, see https://redis.io/commands/srem
     |
     |  sunion(self, keys: 'List', *args: 'List') -> 'set[bytes | str] | Awaitable[set[bytes | str]]'
     |      Return the union of sets specified by ``keys``
     |
     |      For more information, see https://redis.io/commands/sunion
     |
     |  sunioncard(self, numkeys: 'int', keys: 'List[KeyT]', limit: 'int' = 0, approx: 'bool' = False) -> 'int | Awaitable[int]'
     |      Return the cardinality of the union of multiple sets specified by
     |      ``keys``, without returning the union itself.
     |
     |      When ``approx`` is True, the ``APPROX`` option is sent and the server
     |      returns an approximate cardinality computed using HyperLogLog.
     |
     |      When LIMIT is provided (defaults to 0 and means unlimited), the returned
     |      cardinality is capped at ``limit``. In exact mode the result equals
     |      ``limit`` when the real cardinality exceeds ``limit``; in approximate
     |      mode the result will not exceed ``limit``. Options are emitted in the
     |      canonical order ``APPROX`` before ``LIMIT``.
     |
     |      For more information, see https://redis.io/commands/sunioncard
     |
     |  sunionstore(self, dest: 'KeyT', keys: 'List', *args: 'List') -> 'int | Awaitable[int]'
     |      Store the union of sets specified by ``keys`` into a new
     |      set named ``dest``.  Returns the number of keys in the new set.
     |
     |      For more information, see https://redis.io/commands/sunionstore
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from StreamCommands:
     |
     |  xack(self, name: 'KeyT', groupname: 'GroupT', *ids: 'StreamIdT') -> 'int | Awaitable[int]'
     |      Acknowledges the successful processing of one or more messages.
     |
     |      Args:
     |          name: name of the stream.
     |          groupname: name of the consumer group.
     |          *ids: message ids to acknowledge.
     |
     |      For more information, see https://redis.io/commands/xack
     |
     |  xackdel(self, name: 'KeyT', groupname: 'GroupT', *ids: 'StreamIdT', ref_policy: "Literal['KEEPREF', 'DELREF', 'ACKED']" = 'KEEPREF') -> 'int | Awaitable[int]'
     |      Combines the functionality of XACK and XDEL. Acknowledges the specified
     |      message IDs in the given consumer group and simultaneously attempts to
     |      delete the corresponding entries from the stream.
     |
     |  xadd(self, name: 'KeyT', fields: 'Dict[FieldT, EncodableT]', id: 'StreamIdT' = '*', maxlen: 'Optional[int]' = None, approximate: 'bool' = True, nomkstream: 'bool' = False, minid: 'Union[StreamIdT, None]' = None, limit: 'int | None' = None, ref_policy: "Literal['KEEPREF', 'DELREF', 'ACKED'] | None" = None, idmpauto: 'str | None' = None, idmp: 'tuple[str, bytes] | None' = None) -> 'bytes | str | Awaitable[bytes | str]'
     |      Add to a stream.
     |      name: name of the stream
     |      fields: dict of field/value pairs to insert into the stream
     |      id: Location to insert this record. By default it is appended.
     |      maxlen: truncate old stream members beyond this size.
     |      Can't be specified with minid.
     |      approximate: actual stream length may be slightly more than maxlen
     |      nomkstream: When set to true, do not make a stream
     |      minid: the minimum id in the stream to query.
     |      Can't be specified with maxlen.
     |      limit: specifies the maximum number of entries to retrieve
     |      ref_policy: optional reference policy for consumer groups when trimming:
     |          - KEEPREF (default): When trimming, preserves references in consumer groups' PEL
     |          - DELREF: When trimming, removes all references from consumer groups' PEL
     |          - ACKED: When trimming, only removes entries acknowledged by all consumer groups
     |      idmpauto: Producer ID for automatic idempotent ID calculation.
     |          Automatically calculates an idempotent ID based on entry content to prevent
     |          duplicate entries. Can only be used with id='*'. Creates an IDMP map if it
     |          doesn't exist yet. The producer ID must be unique per producer and consistent
     |          across restarts.
     |      idmp: Tuple of (producer_id, idempotent_id) for explicit idempotent ID.
     |          Uses a specific idempotent ID to prevent duplicate entries. Can only be used
     |          with id='*'. The producer ID must be unique per producer and consistent across
     |          restarts. The idempotent ID must be unique per message and per producer.
     |          Shorter idempotent IDs require less memory and allow faster processing.
     |          Creates an IDMP map if it doesn't exist yet.
     |
     |      For more information, see https://redis.io/commands/xadd
     |
     |  xautoclaim(self, name: 'KeyT', groupname: 'GroupT', consumername: 'ConsumerT', min_idle_time: 'int', start_id: 'StreamIdT' = '0-0', count: 'int | None' = None, justid: 'bool' = False) -> 'list[Any] | Awaitable[list[Any]]'
     |      Transfers ownership of pending stream entries that match the specified
     |      criteria. Conceptually, equivalent to calling XPENDING and then XCLAIM,
     |      but provides a more straightforward way to deal with message delivery
     |      failures via SCAN-like semantics.
     |      name: name of the stream.
     |      groupname: name of the consumer group.
     |      consumername: name of a consumer that claims the message.
     |      min_idle_time: filter messages that were idle less than this amount of
     |      milliseconds.
     |      start_id: filter messages with equal or greater ID.
     |      count: optional integer, upper limit of the number of entries that the
     |      command attempts to claim. Set to 100 by default.
     |      justid: optional boolean, false by default. Return just an array of IDs
     |      of messages successfully claimed, without returning the actual message
     |
     |      For more information, see https://redis.io/commands/xautoclaim
     |
     |  xcfgset(self, name: 'KeyT', idmp_duration: 'int | None' = None, idmp_maxsize: 'int | None' = None) -> 'bytes | str | Awaitable[bytes | str]'
     |      Configure the idempotency parameters for a stream's IDMP map.
     |
     |      Sets how long Redis remembers each idempotent ID (iid) and the maximum
     |      number of iids to track. This command clears the existing IDMP map
     |      (Redis forgets all previously stored iids), but only if the configuration
     |      value actually changes.
     |
     |      Args:
     |          name: The name of the stream.
     |          idmp_duration: How long Redis remembers each iid in seconds.
     |              Default: 100 seconds (or value set by stream-idmp-duration config).
     |              Minimum: 1 second, Maximum: 300 seconds.
     |              Redis won't forget an iid for this duration (unless maxsize is reached).
     |              Should accommodate application crash recovery time.
     |          idmp_maxsize: Maximum number of iids Redis remembers per producer ID (pid).
     |              Default: 100 iids (or value set by stream-idmp-maxsize config).
     |              Minimum: 1 iid, Maximum: 1,000,000 (1M) iids.
     |              Should be set to: mark-delay [in msec] × (messages/msec) + margin.
     |              Example: 10K msgs/sec (10 msgs/msec), 80 msec mark-delay
     |              → maxsize = 10 × 80 + margin = 1000 iids.
     |
     |      Returns:
     |          OK on success.
     |
     |      For more information, see https://redis.io/commands/xcfgset
     |
     |  xclaim(self, name: 'KeyT', groupname: 'GroupT', consumername: 'ConsumerT', min_idle_time: 'int', message_ids: 'Union[List[StreamIdT], Tuple[StreamIdT]]', idle: 'int | None' = None, time: 'int | None' = None, retrycount: 'int | None' = None, force: 'bool' = False, justid: 'bool' = False) -> 'XClaimResponse | Awaitable[XClaimResponse]'
     |      Changes the ownership of a pending message.
     |
     |      name: name of the stream.
     |
     |      groupname: name of the consumer group.
     |
     |      consumername: name of a consumer that claims the message.
     |
     |      min_idle_time: filter messages that were idle less than this amount of
     |      milliseconds
     |
     |      message_ids: non-empty list or tuple of message IDs to claim
     |
     |      idle: optional. Set the idle time (last time it was delivered) of the
     |      message in ms
     |
     |      time: optional integer. This is the same as idle but instead of a
     |      relative amount of milliseconds, it sets the idle time to a specific
     |      Unix time (in milliseconds).
     |
     |      retrycount: optional integer. set the retry counter to the specified
     |      value. This counter is incremented every time a message is delivered
     |      again.
     |
     |      force: optional boolean, false by default. Creates the pending message
     |      entry in the PEL even if certain specified IDs are not already in the
     |      PEL assigned to a different client.
     |
     |      justid: optional boolean, false by default. Return just an array of IDs
     |      of messages successfully claimed, without returning the actual message
     |
     |      For more information, see https://redis.io/commands/xclaim
     |
     |  xdel(self, name: 'KeyT', *ids: 'StreamIdT') -> 'int | Awaitable[int]'
     |      Deletes one or more messages from a stream.
     |
     |      Args:
     |          name: name of the stream.
     |          *ids: message ids to delete.
     |
     |      For more information, see https://redis.io/commands/xdel
     |
     |  xdelex(self, name: 'KeyT', *ids: 'StreamIdT', ref_policy: "Literal['KEEPREF', 'DELREF', 'ACKED']" = 'KEEPREF') -> 'int | Awaitable[int]'
     |      Extended version of XDEL that provides more control over how message entries
     |      are deleted concerning consumer groups.
     |
     |  xgroup_create(self, name: 'KeyT', groupname: 'GroupT', id: 'StreamIdT' = '$', mkstream: 'bool' = False, entries_read: 'int | None' = None) -> 'bool | Awaitable[bool]'
     |      Create a new consumer group associated with a stream.
     |      name: name of the stream.
     |      groupname: name of the consumer group.
     |      id: ID of the last item in the stream to consider already delivered.
     |
     |      For more information, see https://redis.io/commands/xgroup-create
     |
     |  xgroup_createconsumer(self, name: 'KeyT', groupname: 'GroupT', consumername: 'ConsumerT') -> 'int | Awaitable[int]'
     |      Consumers in a consumer group are auto-created every time a new
     |      consumer name is mentioned by some command.
     |      They can be explicitly created by using this command.
     |      name: name of the stream.
     |      groupname: name of the consumer group.
     |      consumername: name of consumer to create.
     |
     |      See: https://redis.io/commands/xgroup-createconsumer
     |
     |  xgroup_delconsumer(self, name: 'KeyT', groupname: 'GroupT', consumername: 'ConsumerT') -> 'int | Awaitable[int]'
     |      Remove a specific consumer from a consumer group.
     |      Returns the number of pending messages that the consumer had before it
     |      was deleted.
     |      name: name of the stream.
     |      groupname: name of the consumer group.
     |      consumername: name of consumer to delete
     |
     |      For more information, see https://redis.io/commands/xgroup-delconsumer
     |
     |  xgroup_destroy(self, name: 'KeyT', groupname: 'GroupT') -> 'bool | Awaitable[bool]'
     |      Destroy a consumer group.
     |      name: name of the stream.
     |      groupname: name of the consumer group.
     |
     |      For more information, see https://redis.io/commands/xgroup-destroy
     |
     |  xgroup_setid(self, name: 'KeyT', groupname: 'GroupT', id: 'StreamIdT', entries_read: 'int | None' = None) -> 'bool | Awaitable[bool]'
     |      Set the consumer group last delivered ID to something else.
     |      name: name of the stream.
     |      groupname: name of the consumer group.
     |      id: ID of the last item in the stream to consider already delivered.
     |
     |      For more information, see https://redis.io/commands/xgroup-setid
     |
     |  xinfo_consumers(self, name: 'KeyT', groupname: 'GroupT') -> 'list[dict[str, Any]] | Awaitable[list[dict[str, Any]]]'
     |      Returns general information about the consumers in the group.
     |      name: name of the stream.
     |      groupname: name of the consumer group.
     |
     |      For more information, see https://redis.io/commands/xinfo-consumers
     |
     |  xinfo_groups(self, name: 'KeyT') -> 'list[dict[str, Any]] | Awaitable[list[dict[str, Any]]]'
     |      Returns general information about the consumer groups of the stream.
     |      name: name of the stream.
     |
     |      For more information, see https://redis.io/commands/xinfo-groups
     |
     |  xinfo_stream(self, name: 'KeyT', full: 'bool' = False) -> 'dict[str, Any] | Awaitable[dict[str, Any]]'
     |      Returns general information about the stream.
     |      name: name of the stream.
     |      full: optional boolean, false by default. Return full summary
     |
     |      For more information, see https://redis.io/commands/xinfo-stream
     |
     |  xlen(self, name: 'KeyT') -> 'int | Awaitable[int]'
     |      Returns the number of elements in a given stream.
     |
     |      For more information, see https://redis.io/commands/xlen
     |
     |  xnack(self, name: 'KeyT', groupname: 'GroupT', mode: "Literal['SILENT', 'FAIL', 'FATAL']", *ids: 'StreamIdT', retrycount: 'int | None' = None, force: 'bool' = False) -> 'int | Awaitable[int]'
     |      Negatively acknowledges one or more messages in a consumer group's
     |      Pending Entries List (PEL).
     |
     |      Args:
     |          name: name of the stream.
     |          groupname: name of the consumer group.
     |          mode: the nacking mode. One of SILENT, FAIL, or FATAL.
     |              SILENT: consumer shutting down; decrements delivery counter.
     |              FAIL: consumer unable to process; delivery counter unchanged.
     |              FATAL: invalid/malicious message; delivery counter set to max.
     |          *ids: one or more message IDs to NACK.
     |          retrycount: optional integer >= 0. Overrides the mode's implicit
     |              delivery counter adjustment with an exact value.
     |          force: if True, creates a new unowned PEL entry for any ID not
     |              already in the group's PEL.
     |
     |      Returns:
     |          The number of messages successfully NACKed.
     |
     |      For more information, see https://redis.io/commands/xnack
     |
     |  xpending(self, name: 'KeyT', groupname: 'GroupT') -> 'dict[str, Any] | Awaitable[dict[str, Any]]'
     |      Returns information about pending messages of a group.
     |      name: name of the stream.
     |      groupname: name of the consumer group.
     |
     |      For more information, see https://redis.io/commands/xpending
     |
     |  xpending_range(self, name: 'KeyT', groupname: 'GroupT', min: 'StreamIdT', max: 'StreamIdT', count: 'int', consumername: 'ConsumerT | None' = None, idle: 'int | None' = None) -> 'XPendingRangeResponse | Awaitable[XPendingRangeResponse]'
     |      Returns information about pending messages, in a range.
     |
     |      name: name of the stream.
     |      groupname: name of the consumer group.
     |      idle: available from  version 6.2. filter entries by their
     |      idle-time, given in milliseconds (optional).
     |      min: minimum stream ID.
     |      max: maximum stream ID.
     |      count: number of messages to return
     |      consumername: name of a consumer to filter by (optional).
     |
     |  xrange(self, name: 'KeyT', min: 'StreamIdT' = '-', max: 'StreamIdT' = '+', count: 'int | None' = None) -> 'StreamRangeResponse | None | Awaitable[StreamRangeResponse | None]'
     |      Read stream values within an interval.
     |
     |      name: name of the stream.
     |
     |      start: first stream ID. defaults to '-',
     |             meaning the earliest available.
     |
     |      finish: last stream ID. defaults to '+',
     |              meaning the latest available.
     |
     |      count: if set, only return this many items, beginning with the
     |             earliest available.
     |
     |      For more information, see https://redis.io/commands/xrange
     |
     |  xread(self, streams: 'Dict[KeyT, StreamIdT]', count: 'int | None' = None, block: 'int | None' = None, max_count: 'int | None' = None, max_size: 'int | None' = None) -> 'XReadResponse | Awaitable[XReadResponse]'
     |      Block and monitor multiple streams for new data.
     |
     |      streams: a dict of stream names to stream IDs, where
     |                 IDs indicate the last ID already seen.
     |
     |      count: if set, only return this many items per stream, beginning with
     |             the earliest available.
     |
     |      block: number of milliseconds to wait, if nothing already present.
     |
     |      max_count: if set, cap the total number of entries returned across all
     |                 streams combined. Unlike ``count`` (a per-stream limit),
     |                 this is a cumulative cap over the whole reply. Must be a
     |                 positive integer and, when ``count`` is also set, must be
     |                 greater than or equal to ``count``. Requires Redis >= 8.10.0.
     |
     |      max_size: if set, a soft cap on the total server reply size in bytes
     |                across all streams combined. Measured server-side including
     |                protocol overhead, so it is not an exact application-payload
     |                size guarantee; a single available entry larger than the cap
     |                may still be returned. Must be a positive integer. Requires
     |                Redis >= 8.10.0.
     |
     |      For more information, see https://redis.io/commands/xread
     |
     |  xreadgroup(self, groupname: 'str', consumername: 'str', streams: 'Dict[KeyT, StreamIdT]', count: 'int | None' = None, block: 'int | None' = None, noack: 'bool' = False, claim_min_idle_time: 'int | None' = None, max_count: 'int | None' = None, max_size: 'int | None' = None) -> 'XReadGroupResponse | Awaitable[XReadGroupResponse]'
     |      Read from a stream via a consumer group.
     |
     |      groupname: name of the consumer group.
     |
     |      consumername: name of the requesting consumer.
     |
     |      streams: a dict of stream names to stream IDs, where
     |             IDs indicate the last ID already seen.
     |
     |      count: if set, only return this many items per stream, beginning with
     |             the earliest available.
     |
     |      block: number of milliseconds to wait, if nothing already present.
     |      noack: do not add messages to the PEL
     |
     |      claim_min_idle_time: accepts an integer type and represents a
     |                           time interval in milliseconds
     |
     |      max_count: if set, cap the total number of entries returned across all
     |                 streams combined. Unlike ``count`` (a per-stream limit),
     |                 this is a cumulative cap over the whole reply. Must be a
     |                 positive integer and, when ``count`` is also set, must be
     |                 greater than or equal to ``count``. Requires Redis 8.10.0.
     |
     |      max_size: if set, a soft cap on the total server reply size in bytes
     |                across all streams combined. Measured server-side including
     |                protocol overhead, so it is not an exact application-payload
     |                size guarantee; a single available entry larger than the cap
     |                may still be returned. Must be a positive integer. Requires
     |                Redis 8.10.0.
     |
     |      For more information, see https://redis.io/commands/xreadgroup
     |
     |  xrevrange(self, name: 'KeyT', max: 'StreamIdT' = '+', min: 'StreamIdT' = '-', count: 'int | None' = None) -> 'StreamRangeResponse | None | Awaitable[StreamRangeResponse | None]'
     |      Read stream values within an interval, in reverse order.
     |
     |      name: name of the stream
     |
     |      start: first stream ID. defaults to '+',
     |             meaning the latest available.
     |
     |      finish: last stream ID. defaults to '-',
     |              meaning the earliest available.
     |
     |      count: if set, only return this many items, beginning with the
     |             latest available.
     |
     |      For more information, see https://redis.io/commands/xrevrange
     |
     |  xtrim(self, name: 'KeyT', maxlen: 'int | None' = None, approximate: 'bool' = True, minid: 'StreamIdT | None' = None, limit: 'int | None' = None, ref_policy: "Literal['KEEPREF', 'DELREF', 'ACKED'] | None" = None) -> 'int | Awaitable[int]'
     |      Trims old messages from a stream.
     |      name: name of the stream.
     |      maxlen: truncate old stream messages beyond this size
     |      Can't be specified with minid.
     |      approximate: actual stream length may be slightly more than maxlen
     |      minid: the minimum id in the stream to query
     |      Can't be specified with maxlen.
     |      limit: specifies the maximum number of entries to retrieve
     |      ref_policy: optional reference policy for consumer groups:
     |          - KEEPREF (default): Trims entries but preserves references in consumer groups' PEL
     |          - DELREF: Trims entries and removes all references from consumer groups' PEL
     |          - ACKED: Only trims entries that were read and acknowledged by all consumer groups
     |
     |      For more information, see https://redis.io/commands/xtrim
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from SortedSetCommands:
     |
     |  bzmpop(self, timeout: 'float', numkeys: 'int', keys: 'List[str]', min: 'bool | None' = False, max: 'bool | None' = False, count: 'int | None' = 1) -> 'ZMPopResponse | Awaitable[ZMPopResponse]'
     |      Pop ``count`` values (default 1) off of the first non-empty sorted set
     |      named in the ``keys`` list.
     |
     |      If none of the sorted sets in ``keys`` has a value to pop,
     |      then block for ``timeout`` seconds, or until a member gets added
     |      to one of the sorted sets.
     |
     |      If timeout is 0, then block indefinitely.
     |
     |      For more information, see https://redis.io/commands/bzmpop
     |
     |  bzpopmax(self, keys: 'KeysT', timeout: 'TimeoutSecT' = 0) -> 'BlockingZSetPopResponse | Awaitable[BlockingZSetPopResponse]'
     |      ZPOPMAX a value off of the first non-empty sorted set
     |      named in the ``keys`` list.
     |
     |      If none of the sorted sets in ``keys`` has a value to ZPOPMAX,
     |      then block for ``timeout`` seconds, or until a member gets added
     |      to one of the sorted sets.
     |
     |      If timeout is 0, then block indefinitely.
     |
     |      For more information, see https://redis.io/commands/bzpopmax
     |
     |  bzpopmin(self, keys: 'KeysT', timeout: 'TimeoutSecT' = 0) -> 'BlockingZSetPopResponse | Awaitable[BlockingZSetPopResponse]'
     |      ZPOPMIN a value off of the first non-empty sorted set
     |      named in the ``keys`` list.
     |
     |      If none of the sorted sets in ``keys`` has a value to ZPOPMIN,
     |      then block for ``timeout`` seconds, or until a member gets added
     |      to one of the sorted sets.
     |
     |      If timeout is 0, then block indefinitely.
     |
     |      For more information, see https://redis.io/commands/bzpopmin
     |
     |  zadd(self, name: 'KeyT', mapping: 'Mapping[AnyKeyT, EncodableT]', nx: 'bool' = False, xx: 'bool' = False, ch: 'bool' = False, incr: 'bool' = False, gt: 'bool' = False, lt: 'bool' = False) -> 'int | float | None | Awaitable[int | float | None]'
     |      Set any number of element-name, score pairs to the key ``name``. Pairs
     |      are specified as a dict of element-names keys to score values.
     |
     |      ``nx`` forces ZADD to only create new elements and not to update
     |      scores for elements that already exist.
     |
     |      ``xx`` forces ZADD to only update scores of elements that already
     |      exist. New elements will not be added.
     |
     |      ``ch`` modifies the return value to be the numbers of elements changed.
     |      Changed elements include new elements that were added and elements
     |      whose scores changed.
     |
     |      ``incr`` modifies ZADD to behave like ZINCRBY. In this mode only a
     |      single element/score pair can be specified and the score is the amount
     |      the existing score will be incremented by. When using this mode the
     |      return value of ZADD will be the new score of the element.
     |
     |      ``lt`` only updates existing elements if the new score is less than
     |      the current score. This flag doesn't prevent adding new elements.
     |
     |      ``gt`` only updates existing elements if the new score is greater than
     |      the current score. This flag doesn't prevent adding new elements.
     |
     |      The return value of ZADD varies based on the mode specified. With no
     |      options, ZADD returns the number of new elements added to the sorted
     |      set.
     |
     |      ``nx``, ``lt``, and ``gt`` are mutually exclusive options.
     |
     |      See: https://redis.io/commands/ZADD
     |
     |  zcard(self, name: 'KeyT') -> 'int | Awaitable[int]'
     |      Return the number of elements in the sorted set ``name``
     |
     |      For more information, see https://redis.io/commands/zcard
     |
     |  zcount(self, name: 'KeyT', min: 'ZScoreBoundT', max: 'ZScoreBoundT') -> 'int | Awaitable[int]'
     |      Returns the number of elements in the sorted set at key ``name`` with
     |      a score between ``min`` and ``max``.
     |
     |      For more information, see https://redis.io/commands/zcount
     |
     |  zdiff(self, keys: 'KeysT', withscores: 'bool' = False) -> 'ZSetRangeResponse | Awaitable[ZSetRangeResponse]'
     |      Returns the difference between the first and all successive input
     |      sorted sets provided in ``keys``.
     |
     |      For more information, see https://redis.io/commands/zdiff
     |
     |  zdiffstore(self, dest: 'KeyT', keys: 'KeysT') -> 'int | Awaitable[int]'
     |      Computes the difference between the first and all successive input
     |      sorted sets provided in ``keys`` and stores the result in ``dest``.
     |
     |      For more information, see https://redis.io/commands/zdiffstore
     |
     |  zincrby(self, name: 'KeyT', amount: 'float', value: 'EncodableT') -> 'float | None | Awaitable[float | None]'
     |      Increment the score of ``value`` in sorted set ``name`` by ``amount``
     |
     |      For more information, see https://redis.io/commands/zincrby
     |
     |  zinter(self, keys: 'KeysT', aggregate: 'str | None' = None, withscores: 'bool' = False) -> 'ZSetRangeResponse | Awaitable[ZSetRangeResponse]'
     |      Return the intersect of multiple sorted sets specified by ``keys``.
     |
     |      With the ``aggregate`` option, it is possible to specify how the
     |      results of the intersection are aggregated. Available aggregation
     |      modes:
     |
     |      - ``SUM`` (default): the score of an element is summed across the
     |        inputs where it exists.
     |        Score = SUM(score₁×weight₁, score₂×weight₂, ...)
     |      - ``MIN``: the resulting set will contain the minimum score of an
     |        element across the inputs where it exists.
     |        Score = MIN(score₁×weight₁, score₂×weight₂, ...)
     |      - ``MAX``: the resulting set will contain the maximum score of an
     |        element across the inputs where it exists.
     |        Score = MAX(score₁×weight₁, score₂×weight₂, ...)
     |      - ``COUNT``: ignores the original scores and counts weighted set
     |        membership. Each element's score is the sum of the weights of
     |        the input sets that contain it.
     |        Score = SUM(weight₁, weight₂, ...) for sets containing the element.
     |        When all weights are 1 (default), the score equals the number
     |        of input sets containing the element.
     |
     |      For more information, see https://redis.io/commands/zinter
     |
     |  zintercard(self, numkeys: 'int', keys: 'List[str]', limit: 'int' = 0) -> 'int | Awaitable[int]'
     |      Return the cardinality of the intersect of multiple sorted sets
     |      specified by ``keys``.
     |      When LIMIT provided (defaults to 0 and means unlimited), if the intersection
     |      cardinality reaches limit partway through the computation, the algorithm will
     |      exit and yield limit as the cardinality
     |
     |      For more information, see https://redis.io/commands/zintercard
     |
     |  zinterstore(self, dest: 'KeyT', keys: 'Sequence[KeyT] | Mapping[AnyKeyT, float]', aggregate: 'str | None' = None) -> 'int | Awaitable[int]'
     |      Intersect multiple sorted sets specified by ``keys`` into a new
     |      sorted set, ``dest``. Scores in the destination will be aggregated
     |      based on the ``aggregate``.
     |
     |      Available aggregation modes:
     |
     |      - ``SUM`` (default): the score of an element is summed across the
     |        inputs where it exists.
     |        Score = SUM(score₁×weight₁, score₂×weight₂, ...)
     |      - ``MIN``: the resulting set will contain the minimum score of an
     |        element across the inputs where it exists.
     |        Score = MIN(score₁×weight₁, score₂×weight₂, ...)
     |      - ``MAX``: the resulting set will contain the maximum score of an
     |        element across the inputs where it exists.
     |        Score = MAX(score₁×weight₁, score₂×weight₂, ...)
     |      - ``COUNT``: ignores the original scores and counts weighted set
     |        membership. Each element's score is the sum of the weights of
     |        the input sets that contain it.
     |        Score = SUM(weight₁, weight₂, ...) for sets containing the element.
     |        When all weights are 1 (default), the score equals the number
     |        of input sets containing the element.
     |
     |      For more information, see https://redis.io/commands/zinterstore
     |
     |  zlexcount(self, name: 'KeyT', min: 'EncodableT', max: 'EncodableT') -> 'int | Awaitable[int]'
     |      Return the number of items in the sorted set ``name`` between the
     |      lexicographical range ``min`` and ``max``.
     |
     |      For more information, see https://redis.io/commands/zlexcount
     |
     |  zmpop(self, num_keys: 'int', keys: 'List[str]', min: 'bool | None' = False, max: 'bool | None' = False, count: 'int | None' = 1) -> 'ZMPopResponse | Awaitable[ZMPopResponse]'
     |      Pop ``count`` values (default 1) off of the first non-empty sorted set
     |      named in the ``keys`` list.
     |      For more information, see https://redis.io/commands/zmpop
     |
     |  zmscore(self, key: 'KeyT', members: 'List[str]') -> 'list[float | None] | Awaitable[list[float | None]]'
     |      Returns the scores associated with the specified members
     |      in the sorted set stored at key.
     |      ``members`` should be a list of the member name.
     |      Return type is a list of score.
     |      If the member does not exist, a None will be returned
     |      in corresponding position.
     |
     |      For more information, see https://redis.io/commands/zmscore
     |
     |  zpopmax(self, name: 'KeyT', count: 'int | None' = None) -> 'ZSetRangeResponse | Awaitable[ZSetRangeResponse]'
     |      Remove and return up to ``count`` members with the highest scores
     |      from the sorted set ``name``.
     |
     |      For more information, see https://redis.io/commands/zpopmax
     |
     |  zpopmin(self, name: 'KeyT', count: 'int | None' = None) -> 'ZSetRangeResponse | Awaitable[ZSetRangeResponse]'
     |      Remove and return up to ``count`` members with the lowest scores
     |      from the sorted set ``name``.
     |
     |      For more information, see https://redis.io/commands/zpopmin
     |
     |  zrandmember(self, key: 'KeyT', count: 'int | None' = None, withscores: 'bool' = False) -> 'ZRandMemberResponse | Awaitable[ZRandMemberResponse]'
     |      Return a random element from the sorted set value stored at key.
     |
     |      ``count`` if the argument is positive, return an array of distinct
     |      fields. If called with a negative count, the behavior changes and
     |      the command is allowed to return the same field multiple times.
     |      In this case, the number of returned fields is the absolute value
     |      of the specified count.
     |
     |      ``withscores`` The optional WITHSCORES modifier changes the reply so it
     |      includes the respective scores of the randomly selected elements from
     |      the sorted set.
     |
     |      For more information, see https://redis.io/commands/zrandmember
     |
     |  zrange(self, name: 'KeyT', start: 'EncodableT', end: 'EncodableT', desc: 'bool' = False, withscores: 'bool' = False, score_cast_func: 'type | Callable' = <class 'float'>, byscore: 'bool' = False, bylex: 'bool' = False, offset: 'int | None' = None, num: 'int | None' = None) -> 'ZSetRangeResponse | Awaitable[ZSetRangeResponse]'
     |      Return a range of values from sorted set ``name`` between
     |      ``start`` and ``end`` sorted in ascending order.
     |
     |      ``start`` and ``end`` can be negative, indicating the end of the range.
     |
     |      ``desc`` a boolean indicating whether to sort the results in reversed
     |      order.
     |
     |      ``withscores`` indicates to return the scores along with the values.
     |      The return type is a list of (value, score) pairs.
     |
     |      ``score_cast_func`` a callable used to cast the score return value.
     |
     |      ``byscore`` when set to True, returns the range of elements from the
     |      sorted set having scores equal or between ``start`` and ``end``.
     |
     |      ``bylex`` when set to True, returns the range of elements from the
     |      sorted set between the ``start`` and ``end`` lexicographical closed
     |      range intervals.
     |      Valid ``start`` and ``end`` must start with ( or [, in order to specify
     |      whether the range interval is exclusive or inclusive, respectively.
     |
     |      ``offset`` and ``num`` are specified, then return a slice of the range.
     |      Can't be provided when using ``bylex``.
     |
     |      For more information, see https://redis.io/commands/zrange
     |
     |  zrangebylex(self, name: 'KeyT', min: 'EncodableT', max: 'EncodableT', start: 'int | None' = None, num: 'int | None' = None) -> 'list[bytes | str] | Awaitable[list[bytes | str]]'
     |      Return the lexicographical range of values from sorted set ``name``
     |      between ``min`` and ``max``.
     |
     |      If ``start`` and ``num`` are specified, then return a slice of the
     |      range.
     |
     |      For more information, see https://redis.io/commands/zrangebylex
     |
     |  zrangebyscore(self, name: 'KeyT', min: 'ZScoreBoundT', max: 'ZScoreBoundT', start: 'int | None' = None, num: 'int | None' = None, withscores: 'bool' = False, score_cast_func: 'type | Callable' = <class 'float'>) -> 'ZSetRangeResponse | Awaitable[ZSetRangeResponse]'
     |      Return a range of values from the sorted set ``name`` with scores
     |      between ``min`` and ``max``.
     |
     |      If ``start`` and ``num`` are specified, then return a slice
     |      of the range.
     |
     |      ``withscores`` indicates to return the scores along with the values.
     |      The return type is a list of (value, score) pairs
     |
     |      `score_cast_func`` a callable used to cast the score return value
     |
     |      For more information, see https://redis.io/commands/zrangebyscore
     |
     |  zrangestore(self, dest: 'KeyT', name: 'KeyT', start: 'EncodableT', end: 'EncodableT', byscore: 'bool' = False, bylex: 'bool' = False, desc: 'bool' = False, offset: 'int | None' = None, num: 'int | None' = None) -> 'int | Awaitable[int]'
     |      Stores in ``dest`` the result of a range of values from sorted set
     |      ``name`` between ``start`` and ``end`` sorted in ascending order.
     |
     |      ``start`` and ``end`` can be negative, indicating the end of the range.
     |
     |      ``byscore`` when set to True, returns the range of elements from the
     |      sorted set having scores equal or between ``start`` and ``end``.
     |
     |      ``bylex`` when set to True, returns the range of elements from the
     |      sorted set between the ``start`` and ``end`` lexicographical closed
     |      range intervals.
     |      Valid ``start`` and ``end`` must start with ( or [, in order to specify
     |      whether the range interval is exclusive or inclusive, respectively.
     |
     |      ``desc`` a boolean indicating whether to sort the results in reversed
     |      order.
     |
     |      ``offset`` and ``num`` are specified, then return a slice of the range.
     |      Can't be provided when using ``bylex``.
     |
     |      For more information, see https://redis.io/commands/zrangestore
     |
     |  zrank(self, name: 'KeyT', value: 'EncodableT', withscore: 'bool' = False, score_cast_func: 'type | Callable' = <class 'float'>) -> 'int | list[Any] | None | Awaitable[int | list[Any] | None]'
     |      Returns a 0-based value indicating the rank of ``value`` in sorted set
     |      ``name``.
     |      The optional WITHSCORE argument supplements the command's
     |      reply with the score of the element returned.
     |
     |      ``score_cast_func`` a callable used to cast the score return value
     |
     |      For more information, see https://redis.io/commands/zrank
     |
     |  zrem(self, name: 'KeyT', *values: 'FieldT') -> 'int | Awaitable[int]'
     |      Remove member ``values`` from sorted set ``name``
     |
     |      For more information, see https://redis.io/commands/zrem
     |
     |  zremrangebylex(self, name: 'KeyT', min: 'EncodableT', max: 'EncodableT') -> 'int | Awaitable[int]'
     |      Remove all elements in the sorted set ``name`` between the
     |      lexicographical range specified by ``min`` and ``max``.
     |
     |      Returns the number of elements removed.
     |
     |      For more information, see https://redis.io/commands/zremrangebylex
     |
     |  zremrangebyrank(self, name: 'KeyT', min: 'int', max: 'int') -> 'int | Awaitable[int]'
     |      Remove all elements in the sorted set ``name`` with ranks between
     |      ``min`` and ``max``. Values are 0-based, ordered from smallest score
     |      to largest. Values can be negative indicating the highest scores.
     |      Returns the number of elements removed
     |
     |      For more information, see https://redis.io/commands/zremrangebyrank
     |
     |  zremrangebyscore(self, name: 'KeyT', min: 'ZScoreBoundT', max: 'ZScoreBoundT') -> 'int | Awaitable[int]'
     |      Remove all elements in the sorted set ``name`` with scores
     |      between ``min`` and ``max``. Returns the number of elements removed.
     |
     |      For more information, see https://redis.io/commands/zremrangebyscore
     |
     |  zrevrange(self, name: 'KeyT', start: 'int', end: 'int', withscores: 'bool' = False, score_cast_func: 'type | Callable' = <class 'float'>) -> 'ZSetRangeResponse | Awaitable[ZSetRangeResponse]'
     |      Return a range of values from sorted set ``name`` between
     |      ``start`` and ``end`` sorted in descending order.
     |
     |      ``start`` and ``end`` can be negative, indicating the end of the range.
     |
     |      ``withscores`` indicates to return the scores along with the values
     |      The return type is a list of (value, score) pairs
     |
     |      ``score_cast_func`` a callable used to cast the score return value
     |
     |      For more information, see https://redis.io/commands/zrevrange
     |
     |  zrevrangebylex(self, name: 'KeyT', max: 'EncodableT', min: 'EncodableT', start: 'int | None' = None, num: 'int | None' = None) -> 'list[bytes | str] | Awaitable[list[bytes | str]]'
     |      Return the reversed lexicographical range of values from sorted set
     |      ``name`` between ``max`` and ``min``.
     |
     |      If ``start`` and ``num`` are specified, then return a slice of the
     |      range.
     |
     |      For more information, see https://redis.io/commands/zrevrangebylex
     |
     |  zrevrangebyscore(self, name: 'KeyT', max: 'ZScoreBoundT', min: 'ZScoreBoundT', start: 'int | None' = None, num: 'int | None' = None, withscores: 'bool' = False, score_cast_func: 'type | Callable' = <class 'float'>) -> 'ZSetRangeResponse | Awaitable[ZSetRangeResponse]'
     |      Return a range of values from the sorted set ``name`` with scores
     |      between ``min`` and ``max`` in descending order.
     |
     |      If ``start`` and ``num`` are specified, then return a slice
     |      of the range.
     |
     |      ``withscores`` indicates to return the scores along with the values.
     |      The return type is a list of (value, score) pairs
     |
     |      ``score_cast_func`` a callable used to cast the score return value
     |
     |      For more information, see https://redis.io/commands/zrevrangebyscore
     |
     |  zrevrank(self, name: 'KeyT', value: 'EncodableT', withscore: 'bool' = False, score_cast_func: 'type | Callable' = <class 'float'>) -> 'int | list[Any] | None | Awaitable[int | list[Any] | None]'
     |      Returns a 0-based value indicating the descending rank of
     |      ``value`` in sorted set ``name``.
     |      The optional ``withscore`` argument supplements the command's
     |      reply with the score of the element returned.
     |
     |      ``score_cast_func`` a callable used to cast the score return value
     |
     |      For more information, see https://redis.io/commands/zrevrank
     |
     |  zscore(self, name: 'KeyT', value: 'EncodableT') -> 'float | None | Awaitable[float | None]'
     |      Return the score of element ``value`` in sorted set ``name``
     |
     |      For more information, see https://redis.io/commands/zscore
     |
     |  zunion(self, keys: 'Sequence[KeyT] | Mapping[AnyKeyT, float]', aggregate: 'str | None' = None, withscores: 'bool' = False, score_cast_func: 'type | Callable' = <class 'float'>) -> 'ZSetRangeResponse | Awaitable[ZSetRangeResponse]'
     |      Return the union of multiple sorted sets specified by ``keys``.
     |      ``keys`` can be provided as dictionary of keys and their weights.
     |      Scores will be aggregated based on the ``aggregate``, or SUM if
     |      none is provided.
     |
     |      Available aggregation modes:
     |
     |      - ``SUM`` (default): the score of an element is summed across the
     |        inputs where it exists.
     |        Score = SUM(score₁×weight₁, score₂×weight₂, ...)
     |      - ``MIN``: the resulting set will contain the minimum score of an
     |        element across the inputs where it exists.
     |        Score = MIN(score₁×weight₁, score₂×weight₂, ...)
     |      - ``MAX``: the resulting set will contain the maximum score of an
     |        element across the inputs where it exists.
     |        Score = MAX(score₁×weight₁, score₂×weight₂, ...)
     |      - ``COUNT``: ignores the original scores and counts weighted set
     |        membership. Each element's score is the sum of the weights of
     |        the input sets that contain it.
     |        Score = SUM(weight₁, weight₂, ...) for sets containing the element.
     |        When all weights are 1 (default), the score equals the number
     |        of input sets containing the element.
     |
     |      ``score_cast_func`` a callable used to cast the score return value
     |
     |      For more information, see https://redis.io/commands/zunion
     |
     |  zunionstore(self, dest: 'KeyT', keys: 'Sequence[KeyT] | Mapping[AnyKeyT, float]', aggregate: 'str | None' = None) -> 'int | Awaitable[int]'
     |      Union multiple sorted sets specified by ``keys`` into
     |      a new sorted set, ``dest``. Scores in the destination will be
     |      aggregated based on the ``aggregate``, or SUM if none is provided.
     |
     |      Available aggregation modes:
     |
     |      - ``SUM`` (default): the score of an element is summed across the
     |        inputs where it exists.
     |        Score = SUM(score₁×weight₁, score₂×weight₂, ...)
     |      - ``MIN``: the resulting set will contain the minimum score of an
     |        element across the inputs where it exists.
     |        Score = MIN(score₁×weight₁, score₂×weight₂, ...)
     |      - ``MAX``: the resulting set will contain the maximum score of an
     |        element across the inputs where it exists.
     |        Score = MAX(score₁×weight₁, score₂×weight₂, ...)
     |      - ``COUNT``: ignores the original scores and counts weighted set
     |        membership. Each element's score is the sum of the weights of
     |        the input sets that contain it.
     |        Score = SUM(weight₁, weight₂, ...) for sets containing the element.
     |        When all weights are 1 (default), the score equals the number
     |        of input sets containing the element.
     |
     |      For more information, see https://redis.io/commands/zunionstore
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from AsyncManagementCommands:
     |
     |  async command_info(self, **kwargs) -> 'None'
     |
     |  async debug_segfault(self, **kwargs) -> 'None'
     |
     |  async memory_doctor(self, **kwargs) -> 'None'
     |
     |  async memory_help(self, **kwargs) -> 'None'
     |
     |  async shutdown(self, save: 'bool' = False, nosave: 'bool' = False, now: 'bool' = False, force: 'bool' = False, abort: 'bool' = False, **kwargs) -> 'None'
     |      Shutdown the Redis server.  If Redis has persistence configured,
     |      data will be flushed before shutdown.  If the "save" option is set,
     |      a data flush will be attempted even if there is no persistence
     |      configured.  If the "nosave" option is set, no data flush will be
     |      attempted.  The "save" and "nosave" options cannot both be set.
     |
     |      For more information, see https://redis.io/commands/shutdown
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from ManagementCommands:
     |
     |  auth(self, password: 'str', username: 'str | None' = None, **kwargs) -> 'bool | Awaitable[bool]'
     |      Authenticates the user. If you do not pass username, Redis will try to
     |      authenticate for the "default" user. If you do pass username, it will
     |      authenticate for the given user.
     |      For more information, see https://redis.io/commands/auth
     |
     |  bgrewriteaof(self, **kwargs) -> 'bool | bytes | str | Awaitable[bool | bytes | str]'
     |      Tell the Redis server to rewrite the AOF file from data in memory.
     |
     |      For more information, see https://redis.io/commands/bgrewriteaof
     |
     |  bgsave(self, schedule: 'bool' = True, **kwargs) -> 'bool | bytes | str | Awaitable[bool | bytes | str]'
     |      Tell the Redis server to save its data to disk.  Unlike save(),
     |      this method is asynchronous and returns immediately.
     |
     |      For more information, see https://redis.io/commands/bgsave
     |
     |  client_getname(self, **kwargs) -> 'bytes | str | None | Awaitable[bytes | str | None]'
     |      Returns the current connection name
     |
     |      For more information, see https://redis.io/commands/client-getname
     |
     |  client_getredir(self, **kwargs) -> 'int | Awaitable[int]'
     |      Returns the ID (an integer) of the client to whom we are
     |      redirecting tracking notifications.
     |
     |      see: https://redis.io/commands/client-getredir
     |
     |  client_id(self, **kwargs) -> 'int | Awaitable[int]'
     |      Returns the current connection id
     |
     |      For more information, see https://redis.io/commands/client-id
     |
     |  client_info(self, **kwargs) -> 'dict[str, str | int] | Awaitable[dict[str, str | int]]'
     |      Returns information and statistics about the current
     |      client connection.
     |
     |      For more information, see https://redis.io/commands/client-info
     |
     |  client_kill(self, address: 'str', **kwargs) -> 'bool | int | Awaitable[bool | int]'
     |      Disconnects the client at ``address`` (ip:port)
     |
     |      For more information, see https://redis.io/commands/client-kill
     |
     |  client_kill_filter(self, _id: 'str | None' = None, _type: 'str | None' = None, addr: 'str | None' = None, skipme: 'bool | None' = None, laddr: 'bool | None' = None, user: 'str | None' = None, maxage: 'int | None' = None, **kwargs) -> 'int | Awaitable[int]'
     |      Disconnects client(s) using a variety of filter options
     |      :param _id: Kills a client by its unique ID field
     |      :param _type: Kills a client by type where type is one of 'normal',
     |      'master', 'slave', 'replica' or 'pubsub'
     |      :param addr: Kills a client by its 'address:port'
     |      :param skipme: If True, then the client calling the command
     |      will not get killed even if it is identified by one of the filter
     |      options. If skipme is not provided, the server defaults to skipme=True
     |      :param laddr: Kills a client by its 'local (bind) address:port'
     |      :param user: Kills a client for a specific user name
     |      :param maxage: Kills clients that are older than the specified age in seconds
     |
     |  client_list(self, _type: 'str | None' = None, client_id: 'List[EncodableT]' = [], **kwargs) -> 'list[dict[str, str]] | Awaitable[list[dict[str, str]]]'
     |      Returns a list of currently connected clients.
     |      If type of client specified, only that type will be returned.
     |
     |      :param _type: optional. one of the client types (normal, master,
     |       replica, pubsub)
     |      :param client_id: optional. a list of client ids
     |
     |      For more information, see https://redis.io/commands/client-list
     |
     |  client_no_evict(self, mode: 'str') -> 'bytes | str | Awaitable[bytes | str]'
     |      Sets the client eviction mode for the current connection.
     |
     |      For more information, see https://redis.io/commands/client-no-evict
     |
     |  client_no_touch(self, mode: 'str') -> 'bytes | str | Awaitable[bytes | str]'
     |      # The command controls whether commands sent by the client will alter
     |      # the LRU/LFU of the keys they access.
     |      # When turned on, the current client will not change LFU/LRU stats,
     |      # unless it sends the TOUCH command.
     |
     |      For more information, see https://redis.io/commands/client-no-touch
     |
     |  client_pause(self, timeout: 'int', all: 'bool' = True, **kwargs) -> 'bool | Awaitable[bool]'
     |      Suspend all the Redis clients for the specified amount of time.
     |
     |
     |      For more information, see https://redis.io/commands/client-pause
     |
     |      Args:
     |          timeout: milliseconds to pause clients
     |          all: If true (default) all client commands are blocked.
     |               otherwise, clients are only blocked if they attempt to execute
     |               a write command.
     |
     |      For the WRITE mode, some commands have special behavior:
     |
     |      * EVAL/EVALSHA: Will block client for all scripts.
     |      * PUBLISH: Will block client.
     |      * PFCOUNT: Will block client.
     |      * WAIT: Acknowledgments will be delayed, so this command will
     |          appear blocked.
     |
     |  client_reply(self, reply: "Literal['ON', 'OFF', 'SKIP']", **kwargs) -> 'bytes | str | Awaitable[bytes | str]'
     |      Enable and disable redis server replies.
     |
     |      ``reply`` Must be ON OFF or SKIP,
     |      ON - The default most with server replies to commands
     |      OFF - Disable server responses to commands
     |      SKIP - Skip the response of the immediately following command.
     |
     |      Note: When setting OFF or SKIP replies, you will need a client object
     |      with a timeout specified in seconds, and will need to catch the
     |      TimeoutError.
     |      The test_client_reply unit test illustrates this, and
     |      conftest.py has a client with a timeout.
     |
     |      See https://redis.io/commands/client-reply
     |
     |  client_setinfo(self, attr: 'str', value: 'str', **kwargs) -> 'bool | Awaitable[bool]'
     |      Sets the current connection library name or version
     |      For more information see https://redis.io/commands/client-setinfo
     |
     |  client_setname(self, name: 'str', **kwargs) -> 'bool | Awaitable[bool]'
     |      Sets the current connection name
     |
     |      For more information, see https://redis.io/commands/client-setname
     |
     |      .. note::
     |         This method sets client name only for **current** connection.
     |
     |         If you want to set a common name for all connections managed
     |         by this client, use ``client_name`` constructor argument.
     |
     |  client_tracking(self, on: 'bool' = True, clientid: 'int | None' = None, prefix: 'Sequence[KeyT]' = [], bcast: 'bool' = False, optin: 'bool' = False, optout: 'bool' = False, noloop: 'bool' = False, **kwargs) -> 'bytes | str | Awaitable[bytes | str]'
     |      Enables the tracking feature of the Redis server, that is used
     |      for server assisted client side caching.
     |
     |      ``on`` indicate for tracking on or tracking off. The default is on.
     |
     |      ``clientid`` send invalidation messages to the connection with
     |      the specified ID.
     |
     |      ``bcast`` enable tracking in broadcasting mode. In this mode
     |      invalidation messages are reported for all the prefixes
     |      specified, regardless of the keys requested by the connection.
     |
     |      ``optin``  when broadcasting is NOT active, normally don't track
     |      keys in read only commands, unless they are called immediately
     |      after a CLIENT CACHING yes command.
     |
     |      ``optout`` when broadcasting is NOT active, normally track keys in
     |      read only commands, unless they are called immediately after a
     |      CLIENT CACHING no command.
     |
     |      ``noloop`` don't send notifications about keys modified by this
     |      connection itself.
     |
     |      ``prefix``  for broadcasting, register a given key prefix, so that
     |      notifications will be provided only for keys starting with this string.
     |
     |      See https://redis.io/commands/client-tracking
     |
     |  client_tracking_off(self, clientid: 'int | None' = None, prefix: 'Sequence[KeyT]' = [], bcast: 'bool' = False, optin: 'bool' = False, optout: 'bool' = False, noloop: 'bool' = False) -> 'bytes | str | Awaitable[bytes | str]'
     |      Turn off the tracking mode.
     |      For more information, about the options look at client_tracking func.
     |
     |      See https://redis.io/commands/client-tracking
     |
     |  client_tracking_on(self, clientid: 'int | None' = None, prefix: 'Sequence[KeyT]' = [], bcast: 'bool' = False, optin: 'bool' = False, optout: 'bool' = False, noloop: 'bool' = False) -> 'bytes | str | Awaitable[bytes | str]'
     |      Turn on the tracking mode.
     |      For more information, about the options look at client_tracking func.
     |
     |      See https://redis.io/commands/client-tracking
     |
     |  client_trackinginfo(self, **kwargs) -> 'ClientTrackingInfoResponse | Awaitable[ClientTrackingInfoResponse]'
     |      Returns the information about the current client connection's
     |      use of the server assisted client side cache.
     |
     |      See https://redis.io/commands/client-trackinginfo
     |
     |  client_unblock(self, client_id: 'int', error: 'bool' = False, **kwargs) -> 'bool | Awaitable[bool]'
     |      Unblocks a connection by its client id.
     |      If ``error`` is True, unblocks the client with a special error message.
     |      If ``error`` is False (default), the client is unblocked using the
     |      regular timeout mechanism.
     |
     |      For more information, see https://redis.io/commands/client-unblock
     |
     |  client_unpause(self, **kwargs) -> 'bytes | str | Awaitable[bytes | str]'
     |      Unpause all redis clients
     |
     |      For more information, see https://redis.io/commands/client-unpause
     |
     |  command(self, **kwargs) -> 'dict[str, dict[str, Any]] | Awaitable[dict[str, dict[str, Any]]]'
     |      Returns dict reply of details about all Redis commands.
     |
     |      For more information, see https://redis.io/commands/command
     |
     |  command_count(self, **kwargs) -> 'int | Awaitable[int]'
     |
     |  command_docs(self, *args)
     |      This function throws a NotImplementedError since it is intentionally
     |      not supported.
     |
     |  command_getkeysandflags(self, *args: 'str') -> 'CommandGetKeysAndFlagsResponse | Awaitable[CommandGetKeysAndFlagsResponse]'
     |      Returns array of keys from a full Redis command and their usage flags.
     |
     |      For more information, see https://redis.io/commands/command-getkeysandflags
     |
     |  command_list(self, module: 'str | None' = None, category: 'str | None' = None, pattern: 'str | None' = None) -> 'list[bytes | str] | Awaitable[list[bytes | str]]'
     |      Return an array of the server's command names.
     |      You can use one of the following filters:
     |      ``module``: get the commands that belong to the module
     |      ``category``: get the commands in the ACL category
     |      ``pattern``: get the commands that match the given pattern
     |
     |      For more information, see https://redis.io/commands/command-list/
     |
     |  config_get(self, pattern: 'PatternT' = '*', *args: 'PatternT', **kwargs) -> 'dict[str | None, str | None] | Awaitable[dict[str | None, str | None]]'
     |      Return a dictionary of configuration based on the ``pattern``
     |
     |      For more information, see https://redis.io/commands/config-get
     |
     |  config_resetstat(self, **kwargs) -> 'bool | Awaitable[bool]'
     |      Reset runtime statistics
     |
     |      For more information, see https://redis.io/commands/config-resetstat
     |
     |  config_rewrite(self, **kwargs) -> 'bytes | str | Awaitable[bytes | str]'
     |      Rewrite config file with the minimal change to reflect running config.
     |
     |      For more information, see https://redis.io/commands/config-rewrite
     |
     |  config_set(self, name: 'KeyT', value: 'EncodableT', *args: 'Union[KeyT, EncodableT]', **kwargs) -> 'bool | Awaitable[bool]'
     |      Set config item ``name`` with ``value``
     |
     |      For more information, see https://redis.io/commands/config-set
     |
     |  dbsize(self, **kwargs) -> 'int | Awaitable[int]'
     |      Returns the number of keys in the current database
     |
     |      For more information, see https://redis.io/commands/dbsize
     |
     |  debug_object(self, key: 'KeyT', **kwargs) -> 'dict[str, str | int] | bytes | str | Awaitable[dict[str, str | int] | bytes | str]'
     |      Returns version specific meta information about a given key
     |
     |      For more information, see https://redis.io/commands/debug-object
     |
     |  echo(self, value: 'EncodableT', **kwargs) -> 'bytes | str | Awaitable[bytes | str]'
     |      Echo the string back from the server
     |
     |      For more information, see https://redis.io/commands/echo
     |
     |  failover(self)
     |      This function throws a NotImplementedError since it is intentionally
     |      not supported.
     |
     |  flushall(self, asynchronous: 'bool' = False, **kwargs) -> 'bool | Awaitable[bool]'
     |      Delete all keys in all databases on the current host.
     |
     |      ``asynchronous`` indicates whether the operation is
     |      executed asynchronously by the server.
     |
     |      For more information, see https://redis.io/commands/flushall
     |
     |  flushdb(self, asynchronous: 'bool' = False, **kwargs) -> 'bool | Awaitable[bool]'
     |      Delete all keys in the current database.
     |
     |      ``asynchronous`` indicates whether the operation is
     |      executed asynchronously by the server.
     |
     |      For more information, see https://redis.io/commands/flushdb
     |
     |  hello(self)
     |      This function throws a NotImplementedError since it is intentionally
     |      not supported.
     |
     |  hotkeys_get(self, **kwargs) -> 'Union[Awaitable[list[dict[str | bytes, Any]]], list[dict[str | bytes, Any]]]'
     |      Retrieve the result of the ongoing collection session (if any),
     |      or the last collection session (if any).
     |
     |      HOTKEYS GET response is wrapped in an array for aggregation support.
     |      Each node returns a single-element array, allowing multiple node
     |      responses to be concatenated by DMC or other aggregators.
     |
     |      For more information, see https://redis.io/commands/hotkeys-get
     |
     |  hotkeys_reset(self, **kwargs) -> 'bytes | str | Awaitable[bytes | str]'
     |      Discard the last hotkeys collection session results (in order to save memory).
     |      Error if there is an ongoing collection session.
     |
     |      For more information, see https://redis.io/commands/hotkeys-reset
     |
     |  hotkeys_start(self, metrics: 'List[HotkeysMetricsTypes]', count: 'int | None' = None, duration: 'int | None' = None, sample_ratio: 'int | None' = None, slots: 'List[int] | None' = None, **kwargs) -> 'bytes | str | Awaitable[bytes | str]'
     |      Start collecting hotkeys data.
     |      Returns an error if there is an ongoing collection session.
     |
     |      Args:
     |          count: The number of keys to collect in each criteria (CPU and network consumption)
     |          metrics: List of metrics to track. Supported values: [HotkeysMetricsTypes.CPU, HotkeysMetricsTypes.NET]
     |          duration: Automatically stop the collection after `duration` seconds
     |          sample_ratio: Commands are sampled with probability 1/ratio (1 means no sampling)
     |          slots: Only track keys on the specified hash slots
     |
     |      For more information, see https://redis.io/commands/hotkeys-start
     |
     |  hotkeys_stop(self, **kwargs) -> 'bytes | str | Awaitable[bytes | str]'
     |      Stop the ongoing hotkeys collection session (if any).
     |      The results of the last collection session are kept for consumption with HOTKEYS GET.
     |
     |      For more information, see https://redis.io/commands/hotkeys-stop
     |
     |  info(self, section: 'Optional[str]' = None, *args: 'str', **kwargs) -> 'dict[str, Any] | Awaitable[dict[str, Any]]'
     |      Returns a dictionary containing information about the Redis server
     |
     |      The ``section`` option can be used to select a specific section
     |      of information
     |
     |      The section option is not supported by older versions of Redis Server,
     |      and will generate ResponseError
     |
     |      For more information, see https://redis.io/commands/info
     |
     |  lastsave(self, **kwargs) -> 'datetime.datetime | Awaitable[datetime.datetime]'
     |      Return a Python datetime object representing the last time the
     |      Redis database was saved to disk
     |
     |      For more information, see https://redis.io/commands/lastsave
     |
     |  latency_doctor(self)
     |      Raise a NotImplementedError, as the client will not support LATENCY DOCTOR.
     |      This function is best used within the redis-cli.
     |
     |      For more information, see https://redis.io/commands/latency-doctor
     |
     |  latency_graph(self)
     |      Raise a NotImplementedError, as the client will not support LATENCY GRAPH.
     |      This function is best used within the redis-cli.
     |
     |      For more information, see https://redis.io/commands/latency-graph.
     |
     |  latency_histogram(self, *args)
     |      This function throws a NotImplementedError since it is intentionally
     |      not supported.
     |
     |  latency_history(self, event: 'str') -> 'list[list[int]] | Awaitable[list[list[int]]]'
     |      Returns the raw data of the ``event``'s latency spikes time series.
     |
     |      For more information, see https://redis.io/commands/latency-history
     |
     |  latency_latest(self) -> 'list[list[bytes | str | int]] | Awaitable[list[list[bytes | str | int]]]'
     |      Reports the latest latency events logged.
     |
     |      For more information, see https://redis.io/commands/latency-latest
     |
     |  latency_reset(self, *events: 'str') -> 'int | Awaitable[int]'
     |      Resets the latency spikes time series of all, or only some, events.
     |
     |      For more information, see https://redis.io/commands/latency-reset
     |
     |  lolwut(self, *version_numbers: 'Union[str, float]', **kwargs) -> 'bytes | str | Awaitable[bytes | str]'
     |      Get the Redis version and a piece of generative computer art
     |
     |      See: https://redis.io/commands/lolwut
     |
     |  memory_malloc_stats(self, **kwargs) -> 'bytes | str | Awaitable[bytes | str]'
     |      Return an internal statistics report from the memory allocator.
     |
     |      See: https://redis.io/commands/memory-malloc-stats
     |
     |  memory_purge(self, **kwargs) -> 'bool | Awaitable[bool]'
     |      Attempts to purge dirty pages for reclamation by allocator
     |
     |      For more information, see https://redis.io/commands/memory-purge
     |
     |  memory_stats(self, **kwargs) -> 'dict[str, Any] | Awaitable[dict[str, Any]]'
     |      Return a dictionary of memory stats
     |
     |      For more information, see https://redis.io/commands/memory-stats
     |
     |  memory_usage(self, key: 'KeyT', samples: 'int | None' = None, **kwargs) -> 'int | None | Awaitable[int | None]'
     |      Return the total memory usage for key, its value and associated
     |      administrative overheads.
     |
     |      For nested data structures, ``samples`` is the number of elements to
     |      sample. If left unspecified, the server's default is 5. Use 0 to sample
     |      all elements.
     |
     |      For more information, see https://redis.io/commands/memory-usage
     |
     |  migrate(self, host: 'str', port: 'int', keys: 'KeysT', destination_db: 'int', timeout: 'int', copy: 'bool' = False, replace: 'bool' = False, auth: 'str | None' = None, **kwargs) -> 'bytes | str | Awaitable[bytes | str]'
     |      Migrate 1 or more keys from the current Redis server to a different
     |      server specified by the ``host``, ``port`` and ``destination_db``.
     |
     |      The ``timeout``, specified in milliseconds, indicates the maximum
     |      time the connection between the two servers can be idle before the
     |      command is interrupted.
     |
     |      If ``copy`` is True, the specified ``keys`` are NOT deleted from
     |      the source server.
     |
     |      If ``replace`` is True, this operation will overwrite the keys
     |      on the destination server if they exist.
     |
     |      If ``auth`` is specified, authenticate to the destination server with
     |      the password provided.
     |
     |      For more information, see https://redis.io/commands/migrate
     |
     |  object(self, infotype: 'str', key: 'KeyT', **kwargs) -> 'Any | Awaitable[Any]'
     |      Return the encoding, idletime, or refcount about the key
     |
     |  ping(self, **kwargs) -> 'Union[Awaitable[bool], bool]'
     |      Ping the Redis server to test connectivity.
     |
     |      Sends a PING command to the Redis server and returns True if the server
     |      responds with "PONG".
     |
     |      This command is useful for:
     |      - Testing whether a connection is still alive
     |      - Verifying the server's ability to serve data
     |
     |      For more information on the underlying ping command see https://redis.io/commands/ping
     |
     |  psync(self, replicationid: 'str', offset: 'int') -> 'bytes | Awaitable[bytes]'
     |      Initiates a replication stream from the master.
     |      Newer version for `sync`.
     |
     |      For more information, see https://redis.io/commands/sync
     |
     |  quit(self, **kwargs) -> 'bool | Awaitable[bool]'
     |      Ask the server to close the connection.
     |
     |      For more information, see https://redis.io/commands/quit
     |
     |  replicaof(self, *args, **kwargs) -> 'bytes | str | Awaitable[bytes | str]'
     |      Update the replication settings of a redis replica, on the fly.
     |
     |      Examples of valid arguments include:
     |
     |      NO ONE (set no replication)
     |      host port (set to the host and port of a redis server)
     |
     |      For more information, see  https://redis.io/commands/replicaof
     |
     |  reset(self) -> 'bytes | str | Awaitable[bytes | str]'
     |      Perform a full reset on the connection's server-side context.
     |
     |      See: https://redis.io/commands/reset
     |
     |  role(self) -> 'list[Any] | Awaitable[list[Any]]'
     |      Provide information on the role of a Redis instance in
     |      the context of replication, by returning if the instance
     |      is currently a master, slave, or sentinel.
     |
     |      For more information, see https://redis.io/commands/role
     |
     |  save(self, **kwargs) -> 'bool | Awaitable[bool]'
     |      Tell the Redis server to save its data to disk,
     |      blocking until the save is complete
     |
     |      For more information, see https://redis.io/commands/save
     |
     |  select(self, index: 'int', **kwargs) -> 'bool | Awaitable[bool]'
     |      Select the Redis logical database at index.
     |
     |      See: https://redis.io/commands/select
     |
     |  slaveof(self, host: 'str | None' = None, port: 'int | None' = None, **kwargs) -> 'bool | Awaitable[bool]'
     |      Set the server to be a replicated slave of the instance identified
     |      by the ``host`` and ``port``. If called without arguments, the
     |      instance is promoted to a master instead.
     |
     |      For more information, see https://redis.io/commands/slaveof
     |
     |  slowlog_get(self, num: 'int | None' = None, **kwargs) -> 'list[dict[str, Any]] | Awaitable[list[dict[str, Any]]]'
     |      Get the entries from the slowlog. If ``num`` is specified, get the
     |      most recent ``num`` items.
     |
     |      For more information, see https://redis.io/commands/slowlog-get
     |
     |  slowlog_len(self, **kwargs) -> 'int | Awaitable[int]'
     |      Get the number of items in the slowlog
     |
     |      For more information, see https://redis.io/commands/slowlog-len
     |
     |  slowlog_reset(self, **kwargs) -> 'bool | Awaitable[bool]'
     |      Remove all items in the slowlog
     |
     |      For more information, see https://redis.io/commands/slowlog-reset
     |
     |  swapdb(self, first: 'int', second: 'int', **kwargs) -> 'bool | Awaitable[bool]'
     |      Swap two databases
     |
     |      For more information, see https://redis.io/commands/swapdb
     |
     |  sync(self) -> 'bytes | Awaitable[bytes]'
     |      Initiates a replication stream from the master.
     |
     |      For more information, see https://redis.io/commands/sync
     |
     |  time(self, **kwargs) -> 'tuple[int, int] | Awaitable[tuple[int, int]]'
     |      Returns the server time as a 2-item tuple of ints:
     |      (seconds since epoch, microseconds into this second).
     |
     |      For more information, see https://redis.io/commands/time
     |
     |  wait(self, num_replicas: 'int', timeout: 'int', **kwargs) -> 'int | Awaitable[int]'
     |      Redis synchronous replication
     |      That returns the number of replicas that processed the query when
     |      we finally have at least ``num_replicas``, or when the ``timeout`` was
     |      reached.
     |
     |      For more information, see https://redis.io/commands/wait
     |
     |  waitaof(self, num_local: 'int', num_replicas: 'int', timeout: 'int', **kwargs) -> 'list[int] | Awaitable[list[int]]'
     |      This command blocks the current client until all previous write
     |      commands by that client are acknowledged as having been fsynced
     |      to the AOF of the local Redis and/or at least the specified number
     |      of replicas.
     |
     |      For more information, see https://redis.io/commands/waitaof
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from ModuleCommands:
     |
     |  command_getkeys(self, *args) -> 'list[bytes | str] | Awaitable[list[bytes | str]]'
     |
     |  module_list(self) -> 'list[dict[Any, Any]] | Awaitable[list[dict[Any, Any]]]'
     |      Returns a list of dictionaries containing the name and version of
     |      all loaded modules.
     |
     |      For more information, see https://redis.io/commands/module-list
     |
     |  module_load(self, path, *args) -> 'bool | Awaitable[bool]'
     |      Loads the module from ``path``.
     |      Passes all ``*args`` to the module, during loading.
     |      Raises ``ModuleError`` if a module is not found at ``path``.
     |
     |      For more information, see https://redis.io/commands/module-load
     |
     |  module_loadex(self, path: 'str', options: 'List[str] | None' = None, args: 'List[str] | None' = None) -> 'bytes | str | Awaitable[bytes | str]'
     |      Loads a module from a dynamic library at runtime with configuration directives.
     |
     |      For more information, see https://redis.io/commands/module-loadex
     |
     |  module_unload(self, name) -> 'bool | Awaitable[bool]'
     |      Unloads the module ``name``.
     |      Raises ``ModuleError`` if ``name`` is not in loaded modules.
     |
     |      For more information, see https://redis.io/commands/module-unload
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from PubSubCommands:
     |
     |  publish(self, channel: 'ChannelT', message: 'EncodableT', **kwargs) -> 'int | Awaitable[int]'
     |      Publish ``message`` on ``channel``.
     |      Returns the number of subscribers the message was delivered to.
     |
     |      For more information, see https://redis.io/commands/publish
     |
     |  pubsub_channels(self, pattern: 'PatternT' = '*', **kwargs) -> 'list[bytes | str] | Awaitable[list[bytes | str]]'
     |      Return a list of channels that have at least one subscriber
     |
     |      For more information, see https://redis.io/commands/pubsub-channels
     |
     |  pubsub_numpat(self, **kwargs) -> 'int | Awaitable[int]'
     |      Returns the number of subscriptions to patterns
     |
     |      For more information, see https://redis.io/commands/pubsub-numpat
     |
     |  pubsub_numsub(self, *args: 'ChannelT', **kwargs) -> 'list[tuple[bytes | str, int]] | Awaitable[list[tuple[bytes | str, int]]]'
     |      Return a list of (channel, number of subscribers) tuples
     |      for each channel given in ``*args``
     |
     |      For more information, see https://redis.io/commands/pubsub-numsub
     |
     |  pubsub_shardchannels(self, pattern: 'PatternT' = '*', **kwargs) -> 'list[bytes | str] | Awaitable[list[bytes | str]]'
     |      Return a list of shard_channels that have at least one subscriber
     |
     |      For more information, see https://redis.io/commands/pubsub-shardchannels
     |
     |  pubsub_shardnumsub(self, *args: 'ChannelT', **kwargs) -> 'list[tuple[bytes | str, int]] | Awaitable[list[tuple[bytes | str, int]]]'
     |      Return a list of (shard_channel, number of subscribers) tuples
     |      for each channel given in ``*args``
     |
     |      For more information, see https://redis.io/commands/pubsub-shardnumsub
     |
     |  spublish(self, shard_channel: 'ChannelT', message: 'EncodableT') -> 'int | Awaitable[int]'
     |      Posts a message to the given shard channel.
     |      Returns the number of clients that received the message
     |
     |      For more information, see https://redis.io/commands/spublish
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from AsyncScriptCommands:
     |
     |  register_script(self: "Union['redis.asyncio.client.Redis', 'redis.asyncio.cluster.RedisCluster']", script: 'ScriptTextT') -> 'AsyncScript'
     |      Register a Lua ``script`` specifying the ``keys`` it will touch.
     |      Returns a Script object that is callable and hides the complexity of
     |      deal with scripts, keys, and shas. This is the preferred way to work
     |      with Lua scripts.
     |
     |  async script_debug(self, *args) -> 'None'
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from ScriptCommands:
     |
     |  eval(self, script: 'str', numkeys: 'int', *keys_and_args: 'KeyT | EncodableT') -> 'Any | Awaitable[Any]'
     |      Execute the Lua ``script``, specifying the ``numkeys`` the script
     |      will touch and the key names and argument values in ``keys_and_args``.
     |      Returns the result of the script.
     |
     |      In practice, use the object returned by ``register_script``. This
     |      function exists purely for Redis API completion.
     |
     |      For more information, see  https://redis.io/commands/eval
     |
     |  eval_ro(self, script: 'str', numkeys: 'int', *keys_and_args: 'KeyT | EncodableT') -> 'Any | Awaitable[Any]'
     |      The read-only variant of the EVAL command
     |
     |      Execute the read-only Lua ``script`` specifying the ``numkeys`` the script
     |      will touch and the key names and argument values in ``keys_and_args``.
     |      Returns the result of the script.
     |
     |      For more information, see  https://redis.io/commands/eval_ro
     |
     |  evalsha(self, sha: 'str', numkeys: 'int', *keys_and_args: 'KeyT | EncodableT') -> 'Any | Awaitable[Any]'
     |      Use the ``sha`` to execute a Lua script already registered via EVAL
     |      or SCRIPT LOAD. Specify the ``numkeys`` the script will touch and the
     |      key names and argument values in ``keys_and_args``. Returns the result
     |      of the script.
     |
     |      In practice, use the object returned by ``register_script``. This
     |      function exists purely for Redis API completion.
     |
     |      For more information, see  https://redis.io/commands/evalsha
     |
     |  evalsha_ro(self, sha: 'str', numkeys: 'int', *keys_and_args: 'KeyT | EncodableT') -> 'Any | Awaitable[Any]'
     |      The read-only variant of the EVALSHA command
     |
     |      Use the ``sha`` to execute a read-only Lua script already registered via EVAL
     |      or SCRIPT LOAD. Specify the ``numkeys`` the script will touch and the
     |      key names and argument values in ``keys_and_args``. Returns the result
     |      of the script.
     |
     |      For more information, see  https://redis.io/commands/evalsha_ro
     |
     |  script_exists(self, *args: 'str') -> 'list[bool] | Awaitable[list[bool]]'
     |      Check if a script exists in the script cache by specifying the SHAs of
     |      each script as ``args``. Returns a list of boolean values indicating if
     |      if each already script exists in the cache_data.
     |
     |      For more information, see  https://redis.io/commands/script-exists
     |
     |  script_flush(self, sync_type: "Literal['SYNC'] | Literal['ASYNC'] | None" = None) -> 'bool | Awaitable[bool]'
     |      Flush all scripts from the script cache_data.
     |
     |      ``sync_type`` is by default SYNC (synchronous) but it can also be
     |                    ASYNC.
     |
     |      For more information, see  https://redis.io/commands/script-flush
     |
     |  script_kill(self) -> 'bool | Awaitable[bool]'
     |      Kill the currently executing Lua script
     |
     |      For more information, see https://redis.io/commands/script-kill
     |
     |  script_load(self, script: 'ScriptTextT') -> 'str | Awaitable[str]'
     |      Load a Lua ``script`` into the script cache_data. Returns the SHA.
     |
     |      For more information, see https://redis.io/commands/script-load
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from redis.typing.CommandsProtocol:
     |
     |  __init__ = _no_init_or_replace_init(self, *args, **kwargs) from typing
     |
     |  execute_command(self, *args, **options) -> Union[Awaitable[Any], Any]
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors inherited from redis.typing.CommandsProtocol:
     |
     |  __dict__
     |      dictionary for instance variables
     |
     |  __weakref__
     |      list of weak references to the object
     |
     |  ----------------------------------------------------------------------
     |  Data and other attributes inherited from redis.typing.CommandsProtocol:
     |
     |  __protocol_attrs__ = {'_event_dispatcher', 'execute_command'}
     |
     |  ----------------------------------------------------------------------
     |  Class methods inherited from typing.Protocol:
     |
     |  __init_subclass__(*args, **kwargs)
     |      Function to initialize subclasses.
     |
     |  ----------------------------------------------------------------------
     |  Class methods inherited from typing.Generic:
     |
     |  __class_getitem__(...)
     |      Parameterizes a generic class.
     |
     |      At least, parameterizing a generic class is the *main* thing this
     |      method does. For example, for some generic class `Foo`, this is called
     |      when we do `Foo[int]` - there, with `cls=Foo` and `params=int`.
     |
     |      However, note that this method is also called when defining generic
     |      classes in the first place with `class Foo[T]: ...`.
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from FunctionCommands:
     |
     |  fcall(self, function, numkeys: 'int', *keys_and_args: 'Any') -> 'Any | Awaitable[Any]'
     |      Invoke a function.
     |
     |      For more information, see https://redis.io/commands/fcall
     |
     |  fcall_ro(self, function, numkeys: 'int', *keys_and_args: 'Any') -> 'Any | Awaitable[Any]'
     |      This is a read-only variant of the FCALL command that cannot
     |      execute commands that modify data.
     |
     |      For more information, see https://redis.io/commands/fcall_ro
     |
     |  function_delete(self, library: 'str') -> 'bool | Awaitable[bool]'
     |      Delete the library called ``library`` and all its functions.
     |
     |      For more information, see https://redis.io/commands/function-delete
     |
     |  function_dump(self) -> 'bytes | Awaitable[bytes]'
     |      Return the serialized payload of loaded libraries.
     |
     |      For more information, see https://redis.io/commands/function-dump
     |
     |  function_flush(self, mode: 'str' = 'SYNC') -> 'bool | Awaitable[bool]'
     |      Deletes all the libraries.
     |
     |      For more information, see https://redis.io/commands/function-flush
     |
     |  function_kill(self) -> 'bytes | str | Awaitable[bytes | str]'
     |      Kill a function that is currently executing.
     |
     |      For more information, see https://redis.io/commands/function-kill
     |
     |  function_list(self, library: 'str | None' = '*', withcode: 'bool | None' = False) -> 'list[Any] | Awaitable[list[Any]]'
     |      Return information about the functions and libraries.
     |
     |      Args:
     |
     |          library: specify a pattern for matching library names
     |          withcode: cause the server to include the libraries source implementation
     |              in the reply
     |
     |  function_load(self, code: 'str', replace: 'bool | None' = False) -> 'bytes | str | Awaitable[bytes | str]'
     |      Load a library to Redis.
     |      :param code: the source code (must start with
     |      Shebang statement that provides a metadata about the library)
     |      :param replace: changes the behavior to overwrite the existing library
     |      with the new contents.
     |      Return the library name that was loaded.
     |
     |      For more information, see https://redis.io/commands/function-load
     |
     |  function_restore(self, payload: 'str', policy: 'str | None' = 'APPEND') -> 'bool | Awaitable[bool]'
     |      Restore libraries from the serialized ``payload``.
     |      You can use the optional policy argument to provide a policy
     |      for handling existing libraries.
     |
     |      For more information, see https://redis.io/commands/function-restore
     |
     |  function_stats(self) -> 'Any | Awaitable[Any]'
     |      Return information about the function that's currently running
     |      and information about the available execution engines.
     |
     |      For more information, see https://redis.io/commands/function-stats

    class AsyncRedisClusterCommands(AsyncClusterMultiKeyCommands, AsyncClusterManagementCommands, redis.commands.core.ACLCommands, redis.commands.core.PubSubCommands, AsyncClusterDataAccessCommands, redis.commands.core.AsyncScriptCommands, redis.commands.core.FunctionCommands, redis.commands.core.AsyncModuleCommands, redis.commands.redismodules.AsyncRedisModuleCommands)
     |  AsyncRedisClusterCommands(*args, **kwargs)
     |
     |  A class for all Redis Cluster commands
     |
     |  For key-based commands, the target node(s) will be internally determined
     |  by the keys' hash slot.
     |  Non-key-based commands can be executed with the 'target_nodes' argument to
     |  target specific nodes. By default, if target_nodes is not specified, the
     |  command will be executed on the default cluster node.
     |
     |  :param :target_nodes: type can be one of the followings:
     |      - nodes flag: ALL_NODES, PRIMARIES, REPLICAS, RANDOM
     |      - 'ClusterNode'
     |      - 'list(ClusterNodes)'
     |      - 'dict(any:clusterNodes)'
     |
     |  for example:
     |      r.cluster_info(target_nodes=RedisCluster.ALL_NODES)
     |
     |  Method resolution order:
     |      AsyncRedisClusterCommands
     |      AsyncClusterMultiKeyCommands
     |      ClusterMultiKeyCommands
     |      redis.typing.ClusterCommandsProtocol
     |      AsyncClusterManagementCommands
     |      ClusterManagementCommands
     |      redis.commands.core.AsyncManagementCommands
     |      redis.commands.core.ManagementCommands
     |      redis.commands.core.ACLCommands
     |      redis.commands.core.PubSubCommands
     |      AsyncClusterDataAccessCommands
     |      ClusterDataAccessCommands
     |      redis.commands.core.DataAccessCommands
     |      redis.commands.core.AsyncDataAccessCommands
     |      redis.commands.core.AsyncBasicKeyCommands
     |      redis.commands.core.BasicKeyCommands
     |      redis.commands.core.HyperlogCommands
     |      redis.commands.core.HashCommands
     |      redis.commands.core.GeoCommands
     |      redis.commands.core.ListCommands
     |      redis.commands.core.ArrayCommands
     |      redis.commands.core.AsyncScanCommands
     |      redis.commands.core.ScanCommands
     |      redis.commands.core.SetCommands
     |      redis.commands.core.StreamCommands
     |      redis.commands.core.SortedSetCommands
     |      redis.commands.core.AsyncScriptCommands
     |      redis.commands.core.ScriptCommands
     |      redis.commands.core.FunctionCommands
     |      redis.commands.core.AsyncModuleCommands
     |      redis.commands.core.ModuleCommands
     |      redis.typing.CommandsProtocol
     |      typing.Protocol
     |      typing.Generic
     |      redis.commands.redismodules.AsyncRedisModuleCommands
     |      redis.commands.redismodules.RedisModuleCommands
     |      builtins.object
     |
     |  Class methods defined here:
     |
     |  __subclasshook__ = _proto_hook(other) from typing
     |
     |  ----------------------------------------------------------------------
     |  Data and other attributes defined here:
     |
     |  __abstractmethods__ = frozenset()
     |
     |  __annotations__ = {}
     |
     |  __parameters__ = ()
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from AsyncClusterMultiKeyCommands:
     |
     |  async mget_nonatomic(self, keys: 'KeysT', *args: 'KeyT') -> 'List[Any | None]'
     |      Splits the keys into different slots and then calls MGET
     |      for the keys of every slot. This operation will not be atomic
     |      if keys belong to more than one slot.
     |
     |      Returns a list of values ordered identically to ``keys``
     |
     |      For more information see https://redis.io/commands/mget
     |
     |  async mset_nonatomic(self, mapping: 'Mapping[AnyKeyT, EncodableT]') -> 'List[bool]'
     |      Sets key/values based on a mapping. Mapping is a dictionary of
     |      key/value pairs. Both keys and values should be strings or types that
     |      can be cast to a string via str().
     |
     |      Splits the keys into different slots and then calls MSET
     |      for the keys of every slot. This operation will not be atomic
     |      if keys belong to more than one slot.
     |
     |      For more information see https://redis.io/commands/mset
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from ClusterMultiKeyCommands:
     |
     |  delete(self, *keys: 'KeyT') -> 'int | Awaitable[int]'
     |      Deletes the given keys in the cluster.
     |      The keys are first split up into slots
     |      and then an DEL command is sent for every slot
     |
     |      Non-existent keys are ignored.
     |      Returns the number of keys that were deleted.
     |
     |      For more information see https://redis.io/commands/del
     |
     |  exists(self, *keys: 'KeyT') -> 'int | Awaitable[int]'
     |      Returns the number of ``names`` that exist in the
     |      whole cluster. The keys are first split up into slots
     |      and then an EXISTS command is sent for every slot
     |
     |      For more information see https://redis.io/commands/exists
     |
     |  touch(self, *keys: 'KeyT') -> 'int | Awaitable[int]'
     |      Updates the last access time of given keys across the
     |      cluster.
     |
     |      The keys are first split up into slots
     |      and then an TOUCH command is sent for every slot
     |
     |      Non-existent keys are ignored.
     |      Returns the number of keys that were touched.
     |
     |      For more information see https://redis.io/commands/touch
     |
     |  unlink(self, *keys: 'KeyT') -> 'int | Awaitable[int]'
     |      Remove the specified keys in a different thread.
     |
     |      The keys are first split up into slots
     |      and then an TOUCH command is sent for every slot
     |
     |      Non-existent keys are ignored.
     |      Returns the number of keys that were unlinked.
     |
     |      For more information see https://redis.io/commands/unlink
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from AsyncClusterManagementCommands:
     |
     |  async client_tracking_off(self, clientid: 'int | None' = None, prefix: 'Sequence[KeyT]' = [], bcast: 'bool' = False, optin: 'bool' = False, optout: 'bool' = False, noloop: 'bool' = False, target_nodes: "'TargetNodesT' | None" = 'all') -> 'ResponseT'
     |      Disables the tracking feature of the Redis server, that is used
     |      for server assisted client side caching.
     |
     |      When clientid is provided - in target_nodes only the node that owns the
     |      connection with this id should be provided.
     |      When clientid is not provided - target_nodes can be any node.
     |
     |      For more information see https://redis.io/commands/client-tracking
     |
     |  async client_tracking_on(self, clientid: 'int | None' = None, prefix: 'Sequence[KeyT]' = [], bcast: 'bool' = False, optin: 'bool' = False, optout: 'bool' = False, noloop: 'bool' = False, target_nodes: "'TargetNodesT' | None" = 'all') -> 'ResponseT'
     |      Enables the tracking feature of the Redis server, that is used
     |      for server assisted client side caching.
     |
     |      When clientid is provided - in target_nodes only the node that owns the
     |      connection with this id should be provided.
     |      When clientid is not provided - target_nodes can be any node.
     |
     |      For more information see https://redis.io/commands/client-tracking
     |
     |  async cluster_delslots(self, *slots: 'EncodableT') -> 'List[bool]'
     |      Set hash slots as unbound in the cluster.
     |      It determines by it self what node the slot is in and sends it there
     |
     |      Returns a list of the results for each processed slot.
     |
     |      For more information see https://redis.io/commands/cluster-delslots
     |
     |  async hotkeys_get(self, **kwargs) -> 'Awaitable[list[dict[str | bytes, Any]]]'
     |      Cluster client does not support hotkeys command. Please use the non-cluster client.
     |
     |      For more information see https://redis.io/commands/hotkeys-get
     |
     |  async hotkeys_reset(self, **kwargs) -> 'Awaitable[str | bytes]'
     |      Cluster client does not support hotkeys command. Please use the non-cluster client.
     |
     |      For more information see https://redis.io/commands/hotkeys-reset
     |
     |  async hotkeys_start(self, metrics: 'List[HotkeysMetricsTypes]', count: 'int | None' = None, duration: 'int | None' = None, sample_ratio: 'int | None' = None, slots: 'List[int] | None' = None, **kwargs) -> 'Awaitable[str | bytes]'
     |      Cluster client does not support hotkeys command. Please use the non-cluster client.
     |
     |      For more information see https://redis.io/commands/hotkeys-start
     |
     |  async hotkeys_stop(self, **kwargs) -> 'Awaitable[str | bytes]'
     |      Cluster client does not support hotkeys command. Please use the non-cluster client.
     |
     |      For more information see https://redis.io/commands/hotkeys-stop
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from ClusterManagementCommands:
     |
     |  cluster_addslots(self, target_node: "'TargetNodesT'", *slots: 'EncodableT') -> 'bool | Awaitable[bool]'
     |      Assign new hash slots to receiving node. Sends to specified node.
     |
     |      :target_node: 'ClusterNode'
     |          The node to execute the command on
     |
     |      For more information see https://redis.io/commands/cluster-addslots
     |
     |  cluster_addslotsrange(self, target_node: "'TargetNodesT'", *slots: 'EncodableT') -> 'bool | Awaitable[bool]'
     |      Similar to the CLUSTER ADDSLOTS command.
     |      The difference between the two commands is that ADDSLOTS takes a list of slots
     |      to assign to the node, while ADDSLOTSRANGE takes a list of slot ranges
     |      (specified by start and end slots) to assign to the node.
     |
     |      :target_node: 'ClusterNode'
     |          The node to execute the command on
     |
     |      For more information see https://redis.io/commands/cluster-addslotsrange
     |
     |  cluster_bumpepoch(self, target_nodes: "'TargetNodesT' | None" = None) -> 'None'
     |
     |  cluster_count_failure_report(self, node_id: 'str') -> 'int | Awaitable[int]'
     |      Return the number of failure reports active for a given node
     |      Sends to a random node
     |
     |      For more information see https://redis.io/commands/cluster-count-failure-reports
     |
     |  cluster_countkeysinslot(self, slot_id: 'int') -> 'int | Awaitable[int]'
     |      Return the number of local keys in the specified hash slot
     |      Send to node based on specified slot_id
     |
     |      For more information see https://redis.io/commands/cluster-countkeysinslot
     |
     |  cluster_delslotsrange(self, *slots: 'EncodableT') -> 'bool | Awaitable[bool]'
     |      Similar to the CLUSTER DELSLOTS command.
     |      The difference is that CLUSTER DELSLOTS takes a list of hash slots to remove
     |      from the node, while CLUSTER DELSLOTSRANGE takes a list of slot ranges to remove
     |      from the node.
     |
     |      For more information see https://redis.io/commands/cluster-delslotsrange
     |
     |  cluster_failover(self, target_node: "'TargetNodesT'", option: 'str | None' = None) -> 'bool | Awaitable[bool]'
     |      Forces a slave to perform a manual failover of its master
     |      Sends to specified node
     |
     |      :target_node: 'ClusterNode'
     |          The node to execute the command on
     |
     |      For more information see https://redis.io/commands/cluster-failover
     |
     |  cluster_flushslots(self, target_nodes: "'TargetNodesT' | None" = None) -> 'None'
     |
     |  cluster_get_keys_in_slot(self, slot: 'int', num_keys: 'int') -> 'list[bytes | str] | Awaitable[list[bytes | str]]'
     |      Returns the number of keys in the specified cluster slot
     |
     |      For more information see https://redis.io/commands/cluster-getkeysinslot
     |
     |  cluster_info(self, target_nodes: "'TargetNodesT' | None" = None) -> 'dict[str, str] | Awaitable[dict[str, str]]'
     |      Provides info about Redis Cluster node state.
     |      The command will be sent to a random node in the cluster if no target
     |      node is specified.
     |
     |      For more information see https://redis.io/commands/cluster-info
     |
     |  cluster_keyslot(self, key: 'str') -> 'int | Awaitable[int]'
     |      Returns the hash slot of the specified key
     |      Sends to random node in the cluster
     |
     |      For more information see https://redis.io/commands/cluster-keyslot
     |
     |  cluster_links(self, target_node: "'TargetNodesT'") -> 'ClusterLinksResponse | Awaitable[ClusterLinksResponse]'
     |      Each node in a Redis Cluster maintains a pair of long-lived TCP link with each
     |      peer in the cluster: One for sending outbound messages towards the peer and one
     |      for receiving inbound messages from the peer.
     |
     |      This command outputs information of all such peer links as an array.
     |
     |      For more information see https://redis.io/commands/cluster-links
     |
     |  cluster_meet(self, host: 'str', port: 'int', target_nodes: "'TargetNodesT' | None" = None) -> 'bool | Awaitable[bool]'
     |      Force a node cluster to handshake with another node.
     |      Sends to specified node.
     |
     |      For more information see https://redis.io/commands/cluster-meet
     |
     |  cluster_myid(self, target_node: "'TargetNodesT'") -> 'bytes | str | Awaitable[bytes | str]'
     |      Returns the node's id.
     |
     |      :target_node: 'ClusterNode'
     |          The node to execute the command on
     |
     |      For more information check https://redis.io/commands/cluster-myid/
     |
     |  cluster_myshardid(self, target_nodes: "'TargetNodesT' | None" = None) -> 'bytes | str | Awaitable[bytes | str]'
     |      Returns the shard ID of the node.
     |
     |      For more information see https://redis.io/commands/cluster-myshardid/
     |
     |  cluster_nodes(self) -> 'dict[str, ClusterNodeDetail] | Awaitable[dict[str, ClusterNodeDetail]]'
     |      Get Cluster config for the node.
     |      Sends to random node in the cluster
     |
     |      For more information see https://redis.io/commands/cluster-nodes
     |
     |  cluster_replicas(self, node_id: 'str', target_nodes: "'TargetNodesT' | None" = None) -> 'dict[str, ClusterNodeDetail] | Awaitable[dict[str, ClusterNodeDetail]]'
     |      Provides a list of replica nodes replicating from the specified primary
     |      target node.
     |
     |      For more information see https://redis.io/commands/cluster-replicas
     |
     |  cluster_replicate(self, target_nodes: "'TargetNodesT'", node_id: 'str') -> 'bool | Awaitable[bool]'
     |      Reconfigure a node as a slave of the specified master node
     |
     |      For more information see https://redis.io/commands/cluster-replicate
     |
     |  cluster_reset(self, soft: 'bool' = True, target_nodes: "'TargetNodesT' | None" = None) -> 'bool | Awaitable[bool]'
     |      Reset a Redis Cluster node
     |
     |      If 'soft' is True then it will send 'SOFT' argument
     |      If 'soft' is False then it will send 'HARD' argument
     |
     |      For more information see https://redis.io/commands/cluster-reset
     |
     |  cluster_save_config(self, target_nodes: "'TargetNodesT' | None" = None) -> 'bool | Awaitable[bool]'
     |      Forces the node to save cluster state on disk
     |
     |      For more information see https://redis.io/commands/cluster-saveconfig
     |
     |  cluster_set_config_epoch(self, epoch: 'int', target_nodes: "'TargetNodesT' | None" = None) -> 'bool | Awaitable[bool]'
     |      Set the configuration epoch in a new node
     |
     |      For more information see https://redis.io/commands/cluster-set-config-epoch
     |
     |  cluster_setslot(self, target_node: "'TargetNodesT'", node_id: 'str', slot_id: 'int', state: 'str') -> 'bool | Awaitable[bool]'
     |      Bind an hash slot to a specific node
     |
     |      :target_node: 'ClusterNode'
     |          The node to execute the command on
     |
     |      For more information see https://redis.io/commands/cluster-setslot
     |
     |  cluster_setslot_stable(self, slot_id: 'int') -> 'bool | Awaitable[bool]'
     |      Clears migrating / importing state from the slot.
     |      It determines by it self what node the slot is in and sends it there.
     |
     |      For more information see https://redis.io/commands/cluster-setslot
     |
     |  cluster_shards(self, target_nodes: "'TargetNodesT' | None" = None) -> 'ClusterShardsResponse | Awaitable[ClusterShardsResponse]'
     |      Returns details about the shards of the cluster.
     |
     |      For more information see https://redis.io/commands/cluster-shards
     |
     |  cluster_slots(self, target_nodes: "'TargetNodesT' | None" = None) -> 'list[Any] | Awaitable[list[Any]]'
     |      Get array of Cluster slot to node mappings
     |
     |      For more information see https://redis.io/commands/cluster-slots
     |
     |  readonly(self, target_nodes: "'TargetNodesT' | None" = None) -> 'ResponseT'
     |      Enables read queries.
     |      The command will be sent to the default cluster node if target_nodes is
     |      not specified.
     |
     |      For more information see https://redis.io/commands/readonly
     |
     |  readwrite(self, target_nodes: "'TargetNodesT' | None" = None) -> 'ResponseT'
     |      Disables read queries.
     |      The command will be sent to the default cluster node if target_nodes is
     |      not specified.
     |
     |      For more information see https://redis.io/commands/readwrite
     |
     |  replicaof(self, *args, **kwargs) -> 'NoReturn'
     |      Make the server a replica of another instance, or promote it as master.
     |
     |      For more information see https://redis.io/commands/replicaof
     |
     |  slaveof(self, *args, **kwargs) -> 'NoReturn'
     |      Make the server a replica of another instance, or promote it as master.
     |
     |      For more information see https://redis.io/commands/slaveof
     |
     |  swapdb(self, *args, **kwargs) -> 'NoReturn'
     |      Swaps two Redis databases.
     |
     |      For more information see https://redis.io/commands/swapdb
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from redis.commands.core.AsyncManagementCommands:
     |
     |  async command_info(self, **kwargs) -> 'None'
     |
     |  async debug_segfault(self, **kwargs) -> 'None'
     |
     |  async memory_doctor(self, **kwargs) -> 'None'
     |
     |  async memory_help(self, **kwargs) -> 'None'
     |
     |  async shutdown(self, save: 'bool' = False, nosave: 'bool' = False, now: 'bool' = False, force: 'bool' = False, abort: 'bool' = False, **kwargs) -> 'None'
     |      Shutdown the Redis server.  If Redis has persistence configured,
     |      data will be flushed before shutdown.  If the "save" option is set,
     |      a data flush will be attempted even if there is no persistence
     |      configured.  If the "nosave" option is set, no data flush will be
     |      attempted.  The "save" and "nosave" options cannot both be set.
     |
     |      For more information, see https://redis.io/commands/shutdown
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from redis.commands.core.ManagementCommands:
     |
     |  auth(self, password: 'str', username: 'str | None' = None, **kwargs) -> 'bool | Awaitable[bool]'
     |      Authenticates the user. If you do not pass username, Redis will try to
     |      authenticate for the "default" user. If you do pass username, it will
     |      authenticate for the given user.
     |      For more information, see https://redis.io/commands/auth
     |
     |  bgrewriteaof(self, **kwargs) -> 'bool | bytes | str | Awaitable[bool | bytes | str]'
     |      Tell the Redis server to rewrite the AOF file from data in memory.
     |
     |      For more information, see https://redis.io/commands/bgrewriteaof
     |
     |  bgsave(self, schedule: 'bool' = True, **kwargs) -> 'bool | bytes | str | Awaitable[bool | bytes | str]'
     |      Tell the Redis server to save its data to disk.  Unlike save(),
     |      this method is asynchronous and returns immediately.
     |
     |      For more information, see https://redis.io/commands/bgsave
     |
     |  client_getname(self, **kwargs) -> 'bytes | str | None | Awaitable[bytes | str | None]'
     |      Returns the current connection name
     |
     |      For more information, see https://redis.io/commands/client-getname
     |
     |  client_getredir(self, **kwargs) -> 'int | Awaitable[int]'
     |      Returns the ID (an integer) of the client to whom we are
     |      redirecting tracking notifications.
     |
     |      see: https://redis.io/commands/client-getredir
     |
     |  client_id(self, **kwargs) -> 'int | Awaitable[int]'
     |      Returns the current connection id
     |
     |      For more information, see https://redis.io/commands/client-id
     |
     |  client_info(self, **kwargs) -> 'dict[str, str | int] | Awaitable[dict[str, str | int]]'
     |      Returns information and statistics about the current
     |      client connection.
     |
     |      For more information, see https://redis.io/commands/client-info
     |
     |  client_kill(self, address: 'str', **kwargs) -> 'bool | int | Awaitable[bool | int]'
     |      Disconnects the client at ``address`` (ip:port)
     |
     |      For more information, see https://redis.io/commands/client-kill
     |
     |  client_kill_filter(self, _id: 'str | None' = None, _type: 'str | None' = None, addr: 'str | None' = None, skipme: 'bool | None' = None, laddr: 'bool | None' = None, user: 'str | None' = None, maxage: 'int | None' = None, **kwargs) -> 'int | Awaitable[int]'
     |      Disconnects client(s) using a variety of filter options
     |      :param _id: Kills a client by its unique ID field
     |      :param _type: Kills a client by type where type is one of 'normal',
     |      'master', 'slave', 'replica' or 'pubsub'
     |      :param addr: Kills a client by its 'address:port'
     |      :param skipme: If True, then the client calling the command
     |      will not get killed even if it is identified by one of the filter
     |      options. If skipme is not provided, the server defaults to skipme=True
     |      :param laddr: Kills a client by its 'local (bind) address:port'
     |      :param user: Kills a client for a specific user name
     |      :param maxage: Kills clients that are older than the specified age in seconds
     |
     |  client_list(self, _type: 'str | None' = None, client_id: 'List[EncodableT]' = [], **kwargs) -> 'list[dict[str, str]] | Awaitable[list[dict[str, str]]]'
     |      Returns a list of currently connected clients.
     |      If type of client specified, only that type will be returned.
     |
     |      :param _type: optional. one of the client types (normal, master,
     |       replica, pubsub)
     |      :param client_id: optional. a list of client ids
     |
     |      For more information, see https://redis.io/commands/client-list
     |
     |  client_no_evict(self, mode: 'str') -> 'bytes | str | Awaitable[bytes | str]'
     |      Sets the client eviction mode for the current connection.
     |
     |      For more information, see https://redis.io/commands/client-no-evict
     |
     |  client_no_touch(self, mode: 'str') -> 'bytes | str | Awaitable[bytes | str]'
     |      # The command controls whether commands sent by the client will alter
     |      # the LRU/LFU of the keys they access.
     |      # When turned on, the current client will not change LFU/LRU stats,
     |      # unless it sends the TOUCH command.
     |
     |      For more information, see https://redis.io/commands/client-no-touch
     |
     |  client_pause(self, timeout: 'int', all: 'bool' = True, **kwargs) -> 'bool | Awaitable[bool]'
     |      Suspend all the Redis clients for the specified amount of time.
     |
     |
     |      For more information, see https://redis.io/commands/client-pause
     |
     |      Args:
     |          timeout: milliseconds to pause clients
     |          all: If true (default) all client commands are blocked.
     |               otherwise, clients are only blocked if they attempt to execute
     |               a write command.
     |
     |      For the WRITE mode, some commands have special behavior:
     |
     |      * EVAL/EVALSHA: Will block client for all scripts.
     |      * PUBLISH: Will block client.
     |      * PFCOUNT: Will block client.
     |      * WAIT: Acknowledgments will be delayed, so this command will
     |          appear blocked.
     |
     |  client_reply(self, reply: "Literal['ON', 'OFF', 'SKIP']", **kwargs) -> 'bytes | str | Awaitable[bytes | str]'
     |      Enable and disable redis server replies.
     |
     |      ``reply`` Must be ON OFF or SKIP,
     |      ON - The default most with server replies to commands
     |      OFF - Disable server responses to commands
     |      SKIP - Skip the response of the immediately following command.
     |
     |      Note: When setting OFF or SKIP replies, you will need a client object
     |      with a timeout specified in seconds, and will need to catch the
     |      TimeoutError.
     |      The test_client_reply unit test illustrates this, and
     |      conftest.py has a client with a timeout.
     |
     |      See https://redis.io/commands/client-reply
     |
     |  client_setinfo(self, attr: 'str', value: 'str', **kwargs) -> 'bool | Awaitable[bool]'
     |      Sets the current connection library name or version
     |      For more information see https://redis.io/commands/client-setinfo
     |
     |  client_setname(self, name: 'str', **kwargs) -> 'bool | Awaitable[bool]'
     |      Sets the current connection name
     |
     |      For more information, see https://redis.io/commands/client-setname
     |
     |      .. note::
     |         This method sets client name only for **current** connection.
     |
     |         If you want to set a common name for all connections managed
     |         by this client, use ``client_name`` constructor argument.
     |
     |  client_tracking(self, on: 'bool' = True, clientid: 'int | None' = None, prefix: 'Sequence[KeyT]' = [], bcast: 'bool' = False, optin: 'bool' = False, optout: 'bool' = False, noloop: 'bool' = False, **kwargs) -> 'bytes | str | Awaitable[bytes | str]'
     |      Enables the tracking feature of the Redis server, that is used
     |      for server assisted client side caching.
     |
     |      ``on`` indicate for tracking on or tracking off. The default is on.
     |
     |      ``clientid`` send invalidation messages to the connection with
     |      the specified ID.
     |
     |      ``bcast`` enable tracking in broadcasting mode. In this mode
     |      invalidation messages are reported for all the prefixes
     |      specified, regardless of the keys requested by the connection.
     |
     |      ``optin``  when broadcasting is NOT active, normally don't track
     |      keys in read only commands, unless they are called immediately
     |      after a CLIENT CACHING yes command.
     |
     |      ``optout`` when broadcasting is NOT active, normally track keys in
     |      read only commands, unless they are called immediately after a
     |      CLIENT CACHING no command.
     |
     |      ``noloop`` don't send notifications about keys modified by this
     |      connection itself.
     |
     |      ``prefix``  for broadcasting, register a given key prefix, so that
     |      notifications will be provided only for keys starting with this string.
     |
     |      See https://redis.io/commands/client-tracking
     |
     |  client_trackinginfo(self, **kwargs) -> 'ClientTrackingInfoResponse | Awaitable[ClientTrackingInfoResponse]'
     |      Returns the information about the current client connection's
     |      use of the server assisted client side cache.
     |
     |      See https://redis.io/commands/client-trackinginfo
     |
     |  client_unblock(self, client_id: 'int', error: 'bool' = False, **kwargs) -> 'bool | Awaitable[bool]'
     |      Unblocks a connection by its client id.
     |      If ``error`` is True, unblocks the client with a special error message.
     |      If ``error`` is False (default), the client is unblocked using the
     |      regular timeout mechanism.
     |
     |      For more information, see https://redis.io/commands/client-unblock
     |
     |  client_unpause(self, **kwargs) -> 'bytes | str | Awaitable[bytes | str]'
     |      Unpause all redis clients
     |
     |      For more information, see https://redis.io/commands/client-unpause
     |
     |  command(self, **kwargs) -> 'dict[str, dict[str, Any]] | Awaitable[dict[str, dict[str, Any]]]'
     |      Returns dict reply of details about all Redis commands.
     |
     |      For more information, see https://redis.io/commands/command
     |
     |  command_count(self, **kwargs) -> 'int | Awaitable[int]'
     |
     |  command_docs(self, *args)
     |      This function throws a NotImplementedError since it is intentionally
     |      not supported.
     |
     |  command_getkeysandflags(self, *args: 'str') -> 'CommandGetKeysAndFlagsResponse | Awaitable[CommandGetKeysAndFlagsResponse]'
     |      Returns array of keys from a full Redis command and their usage flags.
     |
     |      For more information, see https://redis.io/commands/command-getkeysandflags
     |
     |  command_list(self, module: 'str | None' = None, category: 'str | None' = None, pattern: 'str | None' = None) -> 'list[bytes | str] | Awaitable[list[bytes | str]]'
     |      Return an array of the server's command names.
     |      You can use one of the following filters:
     |      ``module``: get the commands that belong to the module
     |      ``category``: get the commands in the ACL category
     |      ``pattern``: get the commands that match the given pattern
     |
     |      For more information, see https://redis.io/commands/command-list/
     |
     |  config_get(self, pattern: 'PatternT' = '*', *args: 'PatternT', **kwargs) -> 'dict[str | None, str | None] | Awaitable[dict[str | None, str | None]]'
     |      Return a dictionary of configuration based on the ``pattern``
     |
     |      For more information, see https://redis.io/commands/config-get
     |
     |  config_resetstat(self, **kwargs) -> 'bool | Awaitable[bool]'
     |      Reset runtime statistics
     |
     |      For more information, see https://redis.io/commands/config-resetstat
     |
     |  config_rewrite(self, **kwargs) -> 'bytes | str | Awaitable[bytes | str]'
     |      Rewrite config file with the minimal change to reflect running config.
     |
     |      For more information, see https://redis.io/commands/config-rewrite
     |
     |  config_set(self, name: 'KeyT', value: 'EncodableT', *args: 'Union[KeyT, EncodableT]', **kwargs) -> 'bool | Awaitable[bool]'
     |      Set config item ``name`` with ``value``
     |
     |      For more information, see https://redis.io/commands/config-set
     |
     |  dbsize(self, **kwargs) -> 'int | Awaitable[int]'
     |      Returns the number of keys in the current database
     |
     |      For more information, see https://redis.io/commands/dbsize
     |
     |  debug_object(self, key: 'KeyT', **kwargs) -> 'dict[str, str | int] | bytes | str | Awaitable[dict[str, str | int] | bytes | str]'
     |      Returns version specific meta information about a given key
     |
     |      For more information, see https://redis.io/commands/debug-object
     |
     |  echo(self, value: 'EncodableT', **kwargs) -> 'bytes | str | Awaitable[bytes | str]'
     |      Echo the string back from the server
     |
     |      For more information, see https://redis.io/commands/echo
     |
     |  failover(self)
     |      This function throws a NotImplementedError since it is intentionally
     |      not supported.
     |
     |  flushall(self, asynchronous: 'bool' = False, **kwargs) -> 'bool | Awaitable[bool]'
     |      Delete all keys in all databases on the current host.
     |
     |      ``asynchronous`` indicates whether the operation is
     |      executed asynchronously by the server.
     |
     |      For more information, see https://redis.io/commands/flushall
     |
     |  flushdb(self, asynchronous: 'bool' = False, **kwargs) -> 'bool | Awaitable[bool]'
     |      Delete all keys in the current database.
     |
     |      ``asynchronous`` indicates whether the operation is
     |      executed asynchronously by the server.
     |
     |      For more information, see https://redis.io/commands/flushdb
     |
     |  hello(self)
     |      This function throws a NotImplementedError since it is intentionally
     |      not supported.
     |
     |  info(self, section: 'Optional[str]' = None, *args: 'str', **kwargs) -> 'dict[str, Any] | Awaitable[dict[str, Any]]'
     |      Returns a dictionary containing information about the Redis server
     |
     |      The ``section`` option can be used to select a specific section
     |      of information
     |
     |      The section option is not supported by older versions of Redis Server,
     |      and will generate ResponseError
     |
     |      For more information, see https://redis.io/commands/info
     |
     |  lastsave(self, **kwargs) -> 'datetime.datetime | Awaitable[datetime.datetime]'
     |      Return a Python datetime object representing the last time the
     |      Redis database was saved to disk
     |
     |      For more information, see https://redis.io/commands/lastsave
     |
     |  latency_doctor(self)
     |      Raise a NotImplementedError, as the client will not support LATENCY DOCTOR.
     |      This function is best used within the redis-cli.
     |
     |      For more information, see https://redis.io/commands/latency-doctor
     |
     |  latency_graph(self)
     |      Raise a NotImplementedError, as the client will not support LATENCY GRAPH.
     |      This function is best used within the redis-cli.
     |
     |      For more information, see https://redis.io/commands/latency-graph.
     |
     |  latency_histogram(self, *args)
     |      This function throws a NotImplementedError since it is intentionally
     |      not supported.
     |
     |  latency_history(self, event: 'str') -> 'list[list[int]] | Awaitable[list[list[int]]]'
     |      Returns the raw data of the ``event``'s latency spikes time series.
     |
     |      For more information, see https://redis.io/commands/latency-history
     |
     |  latency_latest(self) -> 'list[list[bytes | str | int]] | Awaitable[list[list[bytes | str | int]]]'
     |      Reports the latest latency events logged.
     |
     |      For more information, see https://redis.io/commands/latency-latest
     |
     |  latency_reset(self, *events: 'str') -> 'int | Awaitable[int]'
     |      Resets the latency spikes time series of all, or only some, events.
     |
     |      For more information, see https://redis.io/commands/latency-reset
     |
     |  lolwut(self, *version_numbers: 'Union[str, float]', **kwargs) -> 'bytes | str | Awaitable[bytes | str]'
     |      Get the Redis version and a piece of generative computer art
     |
     |      See: https://redis.io/commands/lolwut
     |
     |  memory_malloc_stats(self, **kwargs) -> 'bytes | str | Awaitable[bytes | str]'
     |      Return an internal statistics report from the memory allocator.
     |
     |      See: https://redis.io/commands/memory-malloc-stats
     |
     |  memory_purge(self, **kwargs) -> 'bool | Awaitable[bool]'
     |      Attempts to purge dirty pages for reclamation by allocator
     |
     |      For more information, see https://redis.io/commands/memory-purge
     |
     |  memory_stats(self, **kwargs) -> 'dict[str, Any] | Awaitable[dict[str, Any]]'
     |      Return a dictionary of memory stats
     |
     |      For more information, see https://redis.io/commands/memory-stats
     |
     |  memory_usage(self, key: 'KeyT', samples: 'int | None' = None, **kwargs) -> 'int | None | Awaitable[int | None]'
     |      Return the total memory usage for key, its value and associated
     |      administrative overheads.
     |
     |      For nested data structures, ``samples`` is the number of elements to
     |      sample. If left unspecified, the server's default is 5. Use 0 to sample
     |      all elements.
     |
     |      For more information, see https://redis.io/commands/memory-usage
     |
     |  migrate(self, host: 'str', port: 'int', keys: 'KeysT', destination_db: 'int', timeout: 'int', copy: 'bool' = False, replace: 'bool' = False, auth: 'str | None' = None, **kwargs) -> 'bytes | str | Awaitable[bytes | str]'
     |      Migrate 1 or more keys from the current Redis server to a different
     |      server specified by the ``host``, ``port`` and ``destination_db``.
     |
     |      The ``timeout``, specified in milliseconds, indicates the maximum
     |      time the connection between the two servers can be idle before the
     |      command is interrupted.
     |
     |      If ``copy`` is True, the specified ``keys`` are NOT deleted from
     |      the source server.
     |
     |      If ``replace`` is True, this operation will overwrite the keys
     |      on the destination server if they exist.
     |
     |      If ``auth`` is specified, authenticate to the destination server with
     |      the password provided.
     |
     |      For more information, see https://redis.io/commands/migrate
     |
     |  object(self, infotype: 'str', key: 'KeyT', **kwargs) -> 'Any | Awaitable[Any]'
     |      Return the encoding, idletime, or refcount about the key
     |
     |  ping(self, **kwargs) -> 'Union[Awaitable[bool], bool]'
     |      Ping the Redis server to test connectivity.
     |
     |      Sends a PING command to the Redis server and returns True if the server
     |      responds with "PONG".
     |
     |      This command is useful for:
     |      - Testing whether a connection is still alive
     |      - Verifying the server's ability to serve data
     |
     |      For more information on the underlying ping command see https://redis.io/commands/ping
     |
     |  psync(self, replicationid: 'str', offset: 'int') -> 'bytes | Awaitable[bytes]'
     |      Initiates a replication stream from the master.
     |      Newer version for `sync`.
     |
     |      For more information, see https://redis.io/commands/sync
     |
     |  quit(self, **kwargs) -> 'bool | Awaitable[bool]'
     |      Ask the server to close the connection.
     |
     |      For more information, see https://redis.io/commands/quit
     |
     |  reset(self) -> 'bytes | str | Awaitable[bytes | str]'
     |      Perform a full reset on the connection's server-side context.
     |
     |      See: https://redis.io/commands/reset
     |
     |  role(self) -> 'list[Any] | Awaitable[list[Any]]'
     |      Provide information on the role of a Redis instance in
     |      the context of replication, by returning if the instance
     |      is currently a master, slave, or sentinel.
     |
     |      For more information, see https://redis.io/commands/role
     |
     |  save(self, **kwargs) -> 'bool | Awaitable[bool]'
     |      Tell the Redis server to save its data to disk,
     |      blocking until the save is complete
     |
     |      For more information, see https://redis.io/commands/save
     |
     |  select(self, index: 'int', **kwargs) -> 'bool | Awaitable[bool]'
     |      Select the Redis logical database at index.
     |
     |      See: https://redis.io/commands/select
     |
     |  slowlog_get(self, num: 'int | None' = None, **kwargs) -> 'list[dict[str, Any]] | Awaitable[list[dict[str, Any]]]'
     |      Get the entries from the slowlog. If ``num`` is specified, get the
     |      most recent ``num`` items.
     |
     |      For more information, see https://redis.io/commands/slowlog-get
     |
     |  slowlog_len(self, **kwargs) -> 'int | Awaitable[int]'
     |      Get the number of items in the slowlog
     |
     |      For more information, see https://redis.io/commands/slowlog-len
     |
     |  slowlog_reset(self, **kwargs) -> 'bool | Awaitable[bool]'
     |      Remove all items in the slowlog
     |
     |      For more information, see https://redis.io/commands/slowlog-reset
     |
     |  sync(self) -> 'bytes | Awaitable[bytes]'
     |      Initiates a replication stream from the master.
     |
     |      For more information, see https://redis.io/commands/sync
     |
     |  time(self, **kwargs) -> 'tuple[int, int] | Awaitable[tuple[int, int]]'
     |      Returns the server time as a 2-item tuple of ints:
     |      (seconds since epoch, microseconds into this second).
     |
     |      For more information, see https://redis.io/commands/time
     |
     |  wait(self, num_replicas: 'int', timeout: 'int', **kwargs) -> 'int | Awaitable[int]'
     |      Redis synchronous replication
     |      That returns the number of replicas that processed the query when
     |      we finally have at least ``num_replicas``, or when the ``timeout`` was
     |      reached.
     |
     |      For more information, see https://redis.io/commands/wait
     |
     |  waitaof(self, num_local: 'int', num_replicas: 'int', timeout: 'int', **kwargs) -> 'list[int] | Awaitable[list[int]]'
     |      This command blocks the current client until all previous write
     |      commands by that client are acknowledged as having been fsynced
     |      to the AOF of the local Redis and/or at least the specified number
     |      of replicas.
     |
     |      For more information, see https://redis.io/commands/waitaof
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from redis.commands.core.ACLCommands:
     |
     |  acl_cat(self, category: 'str | None' = None, **kwargs) -> 'list[bytes | str] | Awaitable[list[bytes | str]]'
     |      Returns a list of categories or commands within a category.
     |
     |      If ``category`` is not supplied, returns a list of all categories.
     |      If ``category`` is supplied, returns a list of all commands within
     |      that category.
     |
     |      For more information, see https://redis.io/commands/acl-cat
     |
     |  acl_deluser(self, *username: 'str', **kwargs) -> 'int | Awaitable[int]'
     |      Delete the ACL for the specified ``username``\s
     |
     |      For more information, see https://redis.io/commands/acl-deluser
     |
     |  acl_dryrun(self, username: 'str', *args: 'EncodableT', **kwargs) -> 'bytes | str | Awaitable[bytes | str]'
     |      Simulate the execution of a given command by a given ``username``.
     |
     |      For more information, see https://redis.io/commands/acl-dryrun
     |
     |  acl_genpass(self, bits: 'int | None' = None, **kwargs) -> 'bytes | str | Awaitable[bytes | str]'
     |      Generate a random password value.
     |      If ``bits`` is supplied then use this number of bits, rounded to
     |      the next multiple of 4.
     |      See: https://redis.io/commands/acl-genpass
     |
     |  acl_getuser(self, username: 'str', **kwargs) -> 'ACLGetUserData | Awaitable[ACLGetUserData]'
     |      Get the ACL details for the specified ``username``.
     |
     |      If ``username`` does not exist, return None
     |
     |      For more information, see https://redis.io/commands/acl-getuser
     |
     |  acl_help(self, **kwargs) -> 'list[bytes | str] | Awaitable[list[bytes | str]]'
     |      The ACL HELP command returns helpful text describing
     |      the different subcommands.
     |
     |      For more information, see https://redis.io/commands/acl-help
     |
     |  acl_list(self, **kwargs) -> 'list[bytes | str] | Awaitable[list[bytes | str]]'
     |      Return a list of all ACLs on the server
     |
     |      For more information, see https://redis.io/commands/acl-list
     |
     |  acl_load(self, **kwargs) -> 'bool | Awaitable[bool]'
     |      Load ACL rules from the configured ``aclfile``.
     |
     |      Note that the server must be configured with the ``aclfile``
     |      directive to be able to load ACL rules from an aclfile.
     |
     |      For more information, see https://redis.io/commands/acl-load
     |
     |  acl_log(self, count: 'int | None' = None, **kwargs) -> 'ACLLogData | Awaitable[ACLLogData]'
     |      Get ACL logs as a list.
     |      :param int count: Get logs[0:count].
     |      :rtype: List.
     |
     |      For more information, see https://redis.io/commands/acl-log
     |
     |  acl_log_reset(self, **kwargs) -> 'bool | Awaitable[bool]'
     |      Reset ACL logs.
     |      :rtype: Boolean.
     |
     |      For more information, see https://redis.io/commands/acl-log
     |
     |  acl_save(self, **kwargs) -> 'bool | Awaitable[bool]'
     |      Save ACL rules to the configured ``aclfile``.
     |
     |      Note that the server must be configured with the ``aclfile``
     |      directive to be able to save ACL rules to an aclfile.
     |
     |      For more information, see https://redis.io/commands/acl-save
     |
     |  acl_setuser(self, username: 'str', enabled: 'bool' = False, nopass: 'bool' = False, passwords: 'str | Iterable[str] | None' = None, hashed_passwords: 'str | Iterable[str] | None' = None, categories: 'Iterable[str] | None' = None, commands: 'Iterable[str] | None' = None, keys: 'Iterable[KeyT] | None' = None, channels: 'Iterable[ChannelT] | None' = None, selectors: 'Iterable[Tuple[str, KeyT]] | None' = None, reset: 'bool' = False, reset_keys: 'bool' = False, reset_channels: 'bool' = False, reset_passwords: 'bool' = False, **kwargs) -> 'bool | Awaitable[bool]'
     |      Create or update an ACL user.
     |
     |      Create or update the ACL for `username`. If the user already exists,
     |      the existing ACL is completely overwritten and replaced with the
     |      specified values.
     |
     |      For more information, see https://redis.io/commands/acl-setuser
     |
     |      Args:
     |          username: The name of the user whose ACL is to be created or updated.
     |          enabled: Indicates whether the user should be allowed to authenticate.
     |                   Defaults to `False`.
     |          nopass: Indicates whether the user can authenticate without a password.
     |                  This cannot be `True` if `passwords` are also specified.
     |          passwords: A list of plain text passwords to add to or remove from the user.
     |                     Each password must be prefixed with a '+' to add or a '-' to
     |                     remove. For convenience, a single prefixed string can be used
     |                     when adding or removing a single password.
     |          hashed_passwords: A list of SHA-256 hashed passwords to add to or remove
     |                            from the user. Each hashed password must be prefixed with
     |                            a '+' to add or a '-' to remove. For convenience, a single
     |                            prefixed string can be used when adding or removing a
     |                            single password.
     |          categories: A list of strings representing category permissions. Each string
     |                      must be prefixed with either a '+' to add the category
     |                      permission or a '-' to remove the category permission.
     |          commands: A list of strings representing command permissions. Each string
     |                    must be prefixed with either a '+' to add the command permission
     |                    or a '-' to remove the command permission.
     |          keys: A list of key patterns to grant the user access to. Key patterns allow
     |                ``'*'`` to support wildcard matching. For example, ``'*'`` grants
     |                access to all keys while ``'cache:*'`` grants access to all keys that
     |                are prefixed with ``cache:``.
     |                `keys` should not be prefixed with a ``'~'``.
     |          reset: Indicates whether the user should be fully reset prior to applying
     |                 the new ACL. Setting this to `True` will remove all existing
     |                 passwords, flags, and privileges from the user and then apply the
     |                 specified rules. If `False`, the user's existing passwords, flags,
     |                 and privileges will be kept and any new specified rules will be
     |                 applied on top.
     |          reset_keys: Indicates whether the user's key permissions should be reset
     |                      prior to applying any new key permissions specified in `keys`.
     |                      If `False`, the user's existing key permissions will be kept and
     |                      any new specified key permissions will be applied on top.
     |          reset_channels: Indicates whether the user's channel permissions should be
     |                          reset prior to applying any new channel permissions
     |                          specified in `channels`. If `False`, the user's existing
     |                          channel permissions will be kept and any new specified
     |                          channel permissions will be applied on top.
     |          reset_passwords: Indicates whether to remove all existing passwords and the
     |                           `nopass` flag from the user prior to applying any new
     |                           passwords specified in `passwords` or `hashed_passwords`.
     |                           If `False`, the user's existing passwords and `nopass`
     |                           status will be kept and any new specified passwords or
     |                           hashed passwords will be applied on top.
     |
     |  acl_users(self, **kwargs) -> 'list[bytes | str] | Awaitable[list[bytes | str]]'
     |      Returns a list of all registered users on the server.
     |
     |      For more information, see https://redis.io/commands/acl-users
     |
     |  acl_whoami(self, **kwargs) -> 'bytes | str | Awaitable[bytes | str]'
     |      Get the username for the current connection
     |
     |      For more information, see https://redis.io/commands/acl-whoami
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from redis.commands.core.PubSubCommands:
     |
     |  publish(self, channel: 'ChannelT', message: 'EncodableT', **kwargs) -> 'int | Awaitable[int]'
     |      Publish ``message`` on ``channel``.
     |      Returns the number of subscribers the message was delivered to.
     |
     |      For more information, see https://redis.io/commands/publish
     |
     |  pubsub_channels(self, pattern: 'PatternT' = '*', **kwargs) -> 'list[bytes | str] | Awaitable[list[bytes | str]]'
     |      Return a list of channels that have at least one subscriber
     |
     |      For more information, see https://redis.io/commands/pubsub-channels
     |
     |  pubsub_numpat(self, **kwargs) -> 'int | Awaitable[int]'
     |      Returns the number of subscriptions to patterns
     |
     |      For more information, see https://redis.io/commands/pubsub-numpat
     |
     |  pubsub_numsub(self, *args: 'ChannelT', **kwargs) -> 'list[tuple[bytes | str, int]] | Awaitable[list[tuple[bytes | str, int]]]'
     |      Return a list of (channel, number of subscribers) tuples
     |      for each channel given in ``*args``
     |
     |      For more information, see https://redis.io/commands/pubsub-numsub
     |
     |  pubsub_shardchannels(self, pattern: 'PatternT' = '*', **kwargs) -> 'list[bytes | str] | Awaitable[list[bytes | str]]'
     |      Return a list of shard_channels that have at least one subscriber
     |
     |      For more information, see https://redis.io/commands/pubsub-shardchannels
     |
     |  pubsub_shardnumsub(self, *args: 'ChannelT', **kwargs) -> 'list[tuple[bytes | str, int]] | Awaitable[list[tuple[bytes | str, int]]]'
     |      Return a list of (shard_channel, number of subscribers) tuples
     |      for each channel given in ``*args``
     |
     |      For more information, see https://redis.io/commands/pubsub-shardnumsub
     |
     |  spublish(self, shard_channel: 'ChannelT', message: 'EncodableT') -> 'int | Awaitable[int]'
     |      Posts a message to the given shard channel.
     |      Returns the number of clients that received the message
     |
     |      For more information, see https://redis.io/commands/spublish
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from AsyncClusterDataAccessCommands:
     |
     |  async scan_iter(self, match: 'PatternT | None' = None, count: 'int | None' = None, _type: 'str | None' = None, **kwargs) -> 'AsyncIterator'
     |      Make an iterator using the SCAN command so that the client doesn't
     |      need to remember the cursor position.
     |
     |      ``match`` allows for filtering the keys by pattern
     |
     |      ``count`` provides a hint to Redis about the number of keys to
     |          return per batch.
     |
     |      ``_type`` filters the returned values by a particular Redis type.
     |          Stock Redis instances allow for the following types:
     |          HASH, LIST, SET, STREAM, STRING, ZSET
     |          Additionally, Redis modules can expose other types as well.
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from ClusterDataAccessCommands:
     |
     |  stralgo(self, algo: "Literal['LCS']", value1: 'KeyT', value2: 'KeyT', specific_argument: "Literal['strings'] | Literal['keys']" = 'strings', len: 'bool' = False, idx: 'bool' = False, minmatchlen: 'int | None' = None, withmatchlen: 'bool' = False, **kwargs) -> 'StralgoResponse | Awaitable[StralgoResponse]'
     |      Implements complex algorithms that operate on strings.
     |      Right now the only algorithm implemented is the LCS algorithm
     |      (longest common substring). However new algorithms could be
     |      implemented in the future.
     |
     |      ``algo`` Right now must be LCS
     |      ``value1`` and ``value2`` Can be two strings or two keys
     |      ``specific_argument`` Specifying if the arguments to the algorithm
     |      will be keys or strings. strings is the default.
     |      ``len`` Returns just the len of the match.
     |      ``idx`` Returns the match positions in each string.
     |      ``minmatchlen`` Restrict the list of matches to the ones of a given
     |      minimal length. Can be provided only when ``idx`` set to True.
     |      ``withmatchlen`` Returns the matches with the len of the match.
     |      Can be provided only when ``idx`` set to True.
     |
     |      For more information see https://redis.io/commands/stralgo
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from redis.commands.core.AsyncBasicKeyCommands:
     |
     |  __contains__(self, name: 'KeyT')
     |      Returns the number of ``names`` that exist
     |
     |      For more information, see https://redis.io/commands/exists
     |
     |  __delitem__(self, name: 'KeyT')
     |
     |  __getitem__(self, name: 'KeyT')
     |      Return the value at key ``name``, raises a KeyError if the key
     |      doesn't exist.
     |
     |  __setitem__(self, name: 'KeyT', value: 'EncodableT')
     |
     |  async unwatch(self) -> 'None'
     |      Unwatches all previously watched keys for a transaction
     |
     |      For more information, see https://redis.io/commands/unwatch
     |
     |  async watch(self, *names: 'KeyT') -> 'None'
     |      Watches the values at keys ``names``, or None if the key doesn't exist
     |
     |      For more information, see https://redis.io/commands/watch
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from redis.commands.core.BasicKeyCommands:
     |
     |  append(self, key: 'KeyT', value: 'EncodableT') -> 'int | Awaitable[int]'
     |      Appends the string ``value`` to the value at ``key``. If ``key``
     |      doesn't already exist, create it with a value of ``value``.
     |      Returns the new length of the value at ``key``.
     |
     |      For more information, see https://redis.io/commands/append
     |
     |  bitcount(self, key: 'KeyT', start: 'int | None' = None, end: 'int | None' = None, mode: 'str | None' = None) -> 'int | Awaitable[int]'
     |      Returns the count of set bits in the value of ``key``.  Optional
     |      ``start`` and ``end`` parameters indicate which bytes to consider
     |
     |      For more information, see https://redis.io/commands/bitcount
     |
     |  bitfield(self: "Union['redis.client.Redis', 'redis.asyncio.client.Redis']", key: 'KeyT', default_overflow: 'str | None' = None) -> 'BitFieldOperation'
     |      Return a BitFieldOperation instance to conveniently construct one or
     |      more bitfield operations on ``key``.
     |
     |      For more information, see https://redis.io/commands/bitfield
     |
     |  bitfield_ro(self: "Union['redis.client.Redis', 'redis.asyncio.client.Redis']", key: 'KeyT', encoding: 'str', offset: 'BitfieldOffsetT', items: 'list[tuple[str, BitfieldOffsetT]] | None' = None) -> 'list[int] | Awaitable[list[int]]'
     |      Return an array of the specified bitfield values
     |      where the first value is found using ``encoding`` and ``offset``
     |      parameters and remaining values are result of corresponding
     |      encoding/offset pairs in optional list ``items``
     |      Read-only variant of the BITFIELD command.
     |
     |      For more information, see https://redis.io/commands/bitfield_ro
     |
     |  bitop(self, operation: 'str', dest: 'KeyT', *keys: 'KeyT') -> 'int | Awaitable[int]'
     |      Perform a bitwise operation using ``operation`` between ``keys`` and
     |      store the result in ``dest``.
     |
     |      For more information, see https://redis.io/commands/bitop
     |
     |  bitpos(self, key: 'KeyT', bit: 'int', start: 'int | None' = None, end: 'int | None' = None, mode: 'str | None' = None) -> 'int | Awaitable[int]'
     |      Return the position of the first bit set to 1 or 0 in a string.
     |      ``start`` and ``end`` defines search range. The range is interpreted
     |      as a range of bytes and not a range of bits, so start=0 and end=2
     |      means to look at the first three bytes.
     |
     |      For more information, see https://redis.io/commands/bitpos
     |
     |  blmove(self, first_list: 'str', second_list: 'str', timeout: 'int', src: 'str' = 'LEFT', dest: 'str' = 'RIGHT') -> 'bytes | str | None | Awaitable[bytes | str | None]'
     |      Blocking version of lmove.
     |
     |      For more information, see https://redis.io/commands/blmove
     |
     |  blmovem(self, first_list: 'str', second_list: 'str', timeout: 'float', src: 'str' = 'LEFT', dest: 'str' = 'RIGHT', count: 'int | None' = None, mode: "Literal['COUNT', 'EXACTLY'] | None" = None, ordering: "Literal['OBO', 'BULK'] | None" = None) -> 'list[bytes | str] | None | Awaitable[list[bytes | str] | None]'
     |      Blocking version of lmovem.
     |
     |      Blocks until elements are available to move or ``timeout`` (in seconds)
     |      is reached; a ``timeout`` of ``0`` blocks indefinitely. With ``COUNT``
     |      the command unblocks once at least one element is available and moves
     |      ``min(count, available)``; with ``EXACTLY`` it blocks until the source
     |      holds at least ``count`` elements, then moves exactly ``count``
     |      atomically. On timeout ``None`` is returned and nothing is moved.
     |
     |      As with ``lmovem``, ``ordering`` (OBO or BULK) is required whenever
     |      ``count`` is given.
     |
     |      For more information, see https://redis.io/commands/blmovem
     |
     |  copy(self, source: 'str', destination: 'str', destination_db: 'str | None' = None, replace: 'bool' = False) -> 'bool | Awaitable[bool]'
     |      Copy the value stored in the ``source`` key to the ``destination`` key.
     |
     |      ``destination_db`` an alternative destination database. By default,
     |      the ``destination`` key is created in the source Redis database.
     |
     |      ``replace`` whether the ``destination`` key should be removed before
     |      copying the value to it. By default, the value is not copied if
     |      the ``destination`` key already exists.
     |
     |      For more information, see https://redis.io/commands/copy
     |
     |  decr = decrby(self, name: 'KeyT', amount: 'int' = 1) -> 'int | Awaitable[int]'
     |
     |  decrby(self, name: 'KeyT', amount: 'int' = 1) -> 'int | Awaitable[int]'
     |      Decrements the value of ``key`` by ``amount``.  If no key exists,
     |      the value will be initialized as 0 - ``amount``
     |
     |      For more information, see https://redis.io/commands/decrby
     |
     |  delex(self, name: 'KeyT', ifeq: 'bytes | str | None' = None, ifne: 'bytes | str | None' = None, ifdeq: 'str | None' = None, ifdne: 'str | None' = None) -> 'int | Awaitable[int]'
     |      Conditionally removes the specified key.
     |
     |      Warning:
     |      **Experimental** since 7.1.
     |      This API may change or be removed without notice.
     |      The API may change based on feedback.
     |
     |      Arguments:
     |          name: KeyT - the key to delete
     |          ifeq match-valu: Optional[Union[bytes, str]] - Delete the key only if its value is equal to match-value
     |          ifne match-value: Optional[Union[bytes, str]] - Delete the key only if its value is not equal to match-value
     |          ifdeq match-digest: Optional[str] - Delete the key only if the digest of its value is equal to match-digest
     |          ifdne match-digest: Optional[str] - Delete the key only if the digest of its value is not equal to match-digest
     |
     |      Returns:
     |          int: 1 if the key was deleted, 0 otherwise.
     |      Raises:
     |          redis.exceptions.ResponseError: if key exists but is not a string
     |                                          and a condition is specified.
     |          ValueError: if more than one condition is provided.
     |
     |
     |      Requires Redis 8.4 or greater.
     |      For more information, see https://redis.io/commands/delex
     |
     |  digest(self, name: 'KeyT') -> 'str | bytes | None | Awaitable[str | bytes | None]'
     |      Return the digest of the value stored at the specified key.
     |
     |      Warning:
     |      **Experimental** since 7.1.
     |      This API may change or be removed without notice.
     |      The API may change based on feedback.
     |
     |      Arguments:
     |        - name: KeyT - the key to get the digest of
     |
     |      Returns:
     |        - None if the key does not exist
     |        - (bulk string) the XXH3 digest of the value as a hex string
     |      Raises:
     |        - ResponseError if key exists but is not a string
     |
     |
     |      Requires Redis 8.4 or greater.
     |      For more information, see https://redis.io/commands/digest
     |
     |  digest_local(self, value: 'bytes | str') -> 'bytes | str'
     |      Compute the hexadecimal digest of the value locally, without sending it to the server.
     |
     |      This is useful for conditional operations like IFDEQ/IFDNE where you need to
     |      compute the digest client-side before sending a command.
     |
     |      Warning:
     |      **Experimental** - This API may change or be removed without notice.
     |
     |      Arguments:
     |        - value: Union[bytes, str] - the value to compute the digest of.
     |          If a string is provided, it will be encoded using UTF-8 before hashing,
     |          which matches Redis's default encoding behavior.
     |
     |      Returns:
     |        - (str | bytes) the XXH3 digest of the value as a hex string (16 hex characters).
     |          Returns bytes if decode_responses is False, otherwise returns str.
     |
     |      For more information, see https://redis.io/commands/digest
     |
     |  dump(self, name: 'KeyT') -> 'bytes | None | Awaitable[bytes | None]'
     |      Return a serialized version of the value stored at the specified key.
     |      If key does not exist a nil bulk reply is returned.
     |
     |      For more information, see https://redis.io/commands/dump
     |
     |  expire(self, name: 'KeyT', time: 'ExpiryT', nx: 'bool' = False, xx: 'bool' = False, gt: 'bool' = False, lt: 'bool' = False) -> 'bool | Awaitable[bool]'
     |      Set an expire flag on key ``name`` for ``time`` seconds with given
     |      ``option``. ``time`` can be represented by an integer or a Python timedelta
     |      object.
     |
     |      Valid options are:
     |          NX -> Set expiry only when the key has no expiry
     |          XX -> Set expiry only when the key has an existing expiry
     |          GT -> Set expiry only when the new expiry is greater than current one
     |          LT -> Set expiry only when the new expiry is less than current one
     |
     |      For more information, see https://redis.io/commands/expire
     |
     |  expireat(self, name: 'KeyT', when: 'AbsExpiryT', nx: 'bool' = False, xx: 'bool' = False, gt: 'bool' = False, lt: 'bool' = False) -> 'bool | Awaitable[bool]'
     |      Set an expire flag on key ``name`` with given ``option``. ``when``
     |      can be represented as an integer indicating unix time or a Python
     |      datetime object.
     |
     |      Valid options are:
     |          -> NX -- Set expiry only when the key has no expiry
     |          -> XX -- Set expiry only when the key has an existing expiry
     |          -> GT -- Set expiry only when the new expiry is greater than current one
     |          -> LT -- Set expiry only when the new expiry is less than current one
     |
     |      For more information, see https://redis.io/commands/expireat
     |
     |  expiretime(self, key: 'str') -> 'int | Awaitable[int]'
     |      Returns the absolute Unix timestamp (since January 1, 1970) in seconds
     |      at which the given key will expire.
     |
     |      For more information, see https://redis.io/commands/expiretime
     |
     |  get(self, name: 'KeyT') -> 'bytes | str | None | Awaitable[bytes | str | None]'
     |      Return the value at key ``name``, or None if the key doesn't exist
     |
     |      For more information, see https://redis.io/commands/get
     |
     |  getbit(self, name: 'KeyT', offset: 'int') -> 'int | Awaitable[int]'
     |      Returns an integer indicating the value of ``offset`` in ``name``
     |
     |      For more information, see https://redis.io/commands/getbit
     |
     |  getdel(self, name: 'KeyT') -> 'bytes | str | None | Awaitable[bytes | str | None]'
     |      Get the value at key ``name`` and delete the key. This command
     |      is similar to GET, except for the fact that it also deletes
     |      the key on success (if and only if the key's value type
     |      is a string).
     |
     |      For more information, see https://redis.io/commands/getdel
     |
     |  getex(self, name: 'KeyT', ex: 'ExpiryT | None' = None, px: 'ExpiryT | None' = None, exat: 'AbsExpiryT | None' = None, pxat: 'AbsExpiryT | None' = None, persist: 'bool' = False) -> 'bytes | str | None | Awaitable[bytes | str | None]'
     |      Get the value of key and optionally set its expiration.
     |      GETEX is similar to GET, but is a write command with
     |      additional options. All time parameters can be given as
     |      datetime.timedelta or integers.
     |
     |      ``ex`` sets an expire flag on key ``name`` for ``ex`` seconds.
     |
     |      ``px`` sets an expire flag on key ``name`` for ``px`` milliseconds.
     |
     |      ``exat`` sets an expire flag on key ``name`` for ``ex`` seconds,
     |      specified in unix time.
     |
     |      ``pxat`` sets an expire flag on key ``name`` for ``ex`` milliseconds,
     |      specified in unix time.
     |
     |      ``persist`` remove the time to live associated with ``name``.
     |
     |      For more information, see https://redis.io/commands/getex
     |
     |  getrange(self, key: 'KeyT', start: 'int', end: 'int') -> 'bytes | str | Awaitable[bytes | str]'
     |      Returns the substring of the string value stored at ``key``,
     |      determined by the offsets ``start`` and ``end`` (both are inclusive)
     |
     |      For more information, see https://redis.io/commands/getrange
     |
     |  getset(self, name: 'KeyT', value: 'EncodableT') -> 'bytes | str | None | Awaitable[bytes | str | None]'
     |      Sets the value at key ``name`` to ``value``
     |      and returns the old value at key ``name`` atomically.
     |
     |      As per Redis 6.2, GETSET is considered deprecated.
     |      Please use SET with GET parameter in new code.
     |
     |      For more information, see https://redis.io/commands/getset
     |
     |  hrandfield(self, key: 'KeyT', count: 'int | None' = None, withvalues: 'bool' = False) -> 'HRandFieldResponse | Awaitable[HRandFieldResponse]'
     |      Return a random field from the hash value stored at key.
     |
     |      count: if the argument is positive, return an array of distinct fields.
     |      If called with a negative count, the behavior changes and the command
     |      is allowed to return the same field multiple times. In this case,
     |      the number of returned fields is the absolute value of the
     |      specified count.
     |      withvalues: The optional WITHVALUES modifier changes the reply so it
     |      includes the respective values of the randomly selected hash fields.
     |
     |      For more information, see https://redis.io/commands/hrandfield
     |
     |  incr = incrby(self, name: 'KeyT', amount: 'int' = 1) -> 'int | Awaitable[int]'
     |
     |  incrby(self, name: 'KeyT', amount: 'int' = 1) -> 'int | Awaitable[int]'
     |      Increments the value of ``key`` by ``amount``.  If no key exists,
     |      the value will be initialized as ``amount``
     |
     |      For more information, see https://redis.io/commands/incrby
     |
     |  incrbyfloat(self, name: 'KeyT', amount: 'float' = 1.0) -> 'float | Awaitable[float]'
     |      Increments the value at key ``name`` by floating ``amount``.
     |      If no key exists, the value will be initialized as ``amount``
     |
     |      For more information, see https://redis.io/commands/incrbyfloat
     |
     |  increx(self, name: 'KeyT', *, byfloat: 'EncodableT | None' = None, byint: 'EncodableT | None' = None, lbound: 'EncodableT | None' = None, ubound: 'EncodableT | None' = None, saturate: 'bool' = False, ex: 'ExpiryT | None' = None, px: 'ExpiryT | None' = None, exat: 'AbsExpiryT | None' = None, pxat: 'AbsExpiryT | None' = None, persist: 'bool' = False, enx: 'bool' = False) -> 'list[Number | bytes | str] | Awaitable[list[Number | bytes | str]]'
     |      Increment the numeric value at key ``name`` and return the new value
     |      and the actual increment.
     |
     |      ``byfloat`` increments a floating point value by the provided amount.
     |
     |      ``byint`` increments an integer value by the provided amount.
     |
     |      If neither ``byfloat`` nor ``byint`` is specified, the value is
     |      incremented by one.
     |
     |      ``lbound`` and ``ubound`` constrain the valid range of the result.
     |
     |      If ``saturate`` is True, out-of-bounds results are saturated to the
     |      specified bound, or to the type limit when no bound is specified.
     |      Otherwise, out-of-bounds results are rejected, leaving the value and
     |      TTL unchanged and returning the current value and zero as the actual
     |      increment.
     |
     |      ``enx`` applies the expiration only when the key does not already
     |      have an expiration, and requires ``ex``, ``px``, ``exat``, or ``pxat``.
     |
     |  keys(self, pattern: 'PatternT' = '*', **kwargs) -> 'list[bytes | str] | Awaitable[list[bytes | str]]'
     |      Returns a list of keys matching ``pattern``
     |
     |      For more information, see https://redis.io/commands/keys
     |
     |  lcs(self, key1: 'str', key2: 'str', len: 'bool | None' = False, idx: 'bool | None' = False, minmatchlen: 'int | None' = 0, withmatchlen: 'bool | None' = False) -> 'LCSCommandResponse | Awaitable[LCSCommandResponse]'
     |      Find the longest common subsequence between ``key1`` and ``key2``.
     |      If ``len`` is true the length of the match will be returned.
     |      If ``idx`` is true the match position in each strings will be returned.
     |      ``minmatchlen`` restrict the list of matches to the ones of
     |      the given ``minmatchlen``.
     |      If ``withmatchlen`` the length of the match also will be returned.
     |      For more information, see https://redis.io/commands/lcs
     |
     |  lmove(self, first_list: 'str', second_list: 'str', src: 'str' = 'LEFT', dest: 'str' = 'RIGHT') -> 'bytes | str | None | Awaitable[bytes | str | None]'
     |      Atomically returns and removes the first/last element of a list,
     |      pushing it as the first/last element on the destination list.
     |      Returns the element being popped and pushed.
     |
     |      For more information, see https://redis.io/commands/lmove
     |
     |  lmovem(self, first_list: 'str', second_list: 'str', src: 'str' = 'LEFT', dest: 'str' = 'RIGHT', count: 'int | None' = None, mode: "Literal['COUNT', 'EXACTLY'] | None" = None, ordering: "Literal['OBO', 'BULK'] | None" = None) -> 'list[bytes | str] | None | Awaitable[list[bytes | str] | None]'
     |      Atomically moves multiple elements from one end of the ``first_list``
     |      to one end of the ``second_list``, returning the moved elements in
     |      destination order.
     |
     |      ``src`` and ``dest`` are the ends to pop from / push to, either
     |      ``LEFT`` (head) or ``RIGHT`` (tail).
     |
     |      When ``count`` is given, ``mode`` selects how many elements to move:
     |      ``COUNT`` (the default) moves up to ``count`` elements, while
     |      ``EXACTLY`` moves exactly ``count`` elements or nothing at all. When
     |      ``count`` is not given a single element is moved.
     |
     |      ``ordering`` controls the order at the destination: ``OBO`` pushes each
     |      element as it is popped (reversing block order, stack semantics) while
     |      ``BULK`` preserves the original relative order (queue semantics). It is
     |      required whenever ``count`` is given.
     |
     |      Returns the array of moved elements, or ``None`` if nothing was moved.
     |
     |      For more information, see https://redis.io/commands/lmovem
     |
     |  mget(self, keys: 'KeysT', *args: 'EncodableT') -> 'list[bytes | str | None] | Awaitable[list[bytes | str | None]]'
     |      Returns a list of values ordered identically to ``keys``
     |
     |      ** Important ** When this method is used with Cluster clients, all keys
     |              must be in the same hash slot, otherwise a RedisClusterException
     |              will be raised.
     |
     |      For more information, see https://redis.io/commands/mget
     |
     |  move(self, name: 'KeyT', db: 'int') -> 'bool | Awaitable[bool]'
     |      Moves the key ``name`` to a different Redis database ``db``
     |
     |      For more information, see https://redis.io/commands/move
     |
     |  mset(self, mapping: 'Mapping[AnyKeyT, EncodableT]') -> 'bool | Awaitable[bool]'
     |      Sets key/values based on a mapping. Mapping is a dictionary of
     |      key/value pairs. Both keys and values should be strings or types that
     |      can be cast to a string via str().
     |
     |      ** Important ** When this method is used with Cluster clients, all keys
     |              must be in the same hash slot, otherwise a RedisClusterException
     |              will be raised.
     |
     |      For more information, see https://redis.io/commands/mset
     |
     |  msetex(self, mapping: 'Mapping[AnyKeyT, EncodableT]', data_persist_option: 'DataPersistOptions | None' = None, ex: 'ExpiryT | None' = None, px: 'ExpiryT | None' = None, exat: 'AbsExpiryT | None' = None, pxat: 'AbsExpiryT | None' = None, keepttl: 'bool' = False) -> 'int | Awaitable[int]'
     |      Sets key/values based on the provided ``mapping`` items.
     |
     |      ** Important ** When this method is used with Cluster clients, all keys
     |                      must be in the same hash slot, otherwise a RedisClusterException
     |                      will be raised.
     |
     |      ``mapping`` accepts a dict of key/value pairs that will be added to the database.
     |
     |      ``data_persist_option`` can be set to ``NX`` or ``XX`` to control the
     |          behavior of the command.
     |          ``NX`` will set the value for each provided key to each
     |              provided value only if all do not already exist.
     |          ``XX`` will set the value for each provided key to each
     |              provided value only if all already exist.
     |
     |      ``ex`` sets an expire flag on the keys in ``mapping`` for ``ex`` seconds.
     |
     |      ``px`` sets an expire flag on the keys in ``mapping`` for ``px`` milliseconds.
     |
     |      ``exat`` sets an expire flag on the keys in ``mapping`` for ``exat`` seconds,
     |          specified in unix time.
     |
     |      ``pxat`` sets an expire flag on the keys in ``mapping`` for ``pxat`` milliseconds,
     |          specified in unix time.
     |
     |      ``keepttl`` if True, retain the time to live associated with the keys.
     |
     |      Returns the number of fields that were added.
     |
     |      Available since Redis 8.4
     |      For more information, see https://redis.io/commands/msetex
     |
     |  msetnx(self, mapping: 'Mapping[AnyKeyT, EncodableT]') -> 'bool | Awaitable[bool]'
     |      Sets key/values based on a mapping if none of the keys are already set.
     |      Mapping is a dictionary of key/value pairs. Both keys and values
     |      should be strings or types that can be cast to a string via str().
     |      Returns a boolean indicating if the operation was successful.
     |
     |      ** Important ** When this method is used with Cluster clients, all keys
     |                      must be in the same hash slot, otherwise a RedisClusterException
     |                      will be raised.
     |
     |      For more information, see https://redis.io/commands/msetnx
     |
     |  persist(self, name: 'KeyT') -> 'bool | Awaitable[bool]'
     |      Removes an expiration on ``name``
     |
     |      For more information, see https://redis.io/commands/persist
     |
     |  pexpire(self, name: 'KeyT', time: 'ExpiryT', nx: 'bool' = False, xx: 'bool' = False, gt: 'bool' = False, lt: 'bool' = False) -> 'bool | Awaitable[bool]'
     |      Set an expire flag on key ``name`` for ``time`` milliseconds
     |      with given ``option``. ``time`` can be represented by an
     |      integer or a Python timedelta object.
     |
     |      Valid options are:
     |          NX -> Set expiry only when the key has no expiry
     |          XX -> Set expiry only when the key has an existing expiry
     |          GT -> Set expiry only when the new expiry is greater than current one
     |          LT -> Set expiry only when the new expiry is less than current one
     |
     |      For more information, see https://redis.io/commands/pexpire
     |
     |  pexpireat(self, name: 'KeyT', when: 'AbsExpiryT', nx: 'bool' = False, xx: 'bool' = False, gt: 'bool' = False, lt: 'bool' = False) -> 'bool | Awaitable[bool]'
     |      Set an expire flag on key ``name`` with given ``option``. ``when``
     |      can be represented as an integer representing unix time in
     |      milliseconds (unix time * 1000) or a Python datetime object.
     |
     |      Valid options are:
     |          NX -> Set expiry only when the key has no expiry
     |          XX -> Set expiry only when the key has an existing expiry
     |          GT -> Set expiry only when the new expiry is greater than current one
     |          LT -> Set expiry only when the new expiry is less than current one
     |
     |      For more information, see https://redis.io/commands/pexpireat
     |
     |  pexpiretime(self, key: 'str') -> 'int | Awaitable[int]'
     |      Returns the absolute Unix timestamp (since January 1, 1970) in milliseconds
     |      at which the given key will expire.
     |
     |      For more information, see https://redis.io/commands/pexpiretime
     |
     |  psetex(self, name: 'KeyT', time_ms: 'ExpiryT', value: 'EncodableT') -> 'bool | Awaitable[bool]'
     |      Set the value of key ``name`` to ``value`` that expires in ``time_ms``
     |      milliseconds. ``time_ms`` can be represented by an integer or a Python
     |      timedelta object
     |
     |      For more information, see https://redis.io/commands/psetex
     |
     |  pttl(self, name: 'KeyT') -> 'int | Awaitable[int]'
     |      Returns the number of milliseconds until the key ``name`` will expire
     |
     |      For more information, see https://redis.io/commands/pttl
     |
     |  randomkey(self, **kwargs) -> 'bytes | str | None | Awaitable[bytes | str | None]'
     |      Returns the name of a random key
     |
     |      For more information, see https://redis.io/commands/randomkey
     |
     |  rename(self, src: 'KeyT', dst: 'KeyT') -> 'bool | Awaitable[bool]'
     |      Rename key ``src`` to ``dst``
     |
     |      For more information, see https://redis.io/commands/rename
     |
     |  renamenx(self, src: 'KeyT', dst: 'KeyT') -> 'bool | Awaitable[bool]'
     |      Rename key ``src`` to ``dst`` if ``dst`` doesn't already exist
     |
     |      For more information, see https://redis.io/commands/renamenx
     |
     |  restore(self, name: 'KeyT', ttl: 'float', value: 'EncodableT', replace: 'bool' = False, absttl: 'bool' = False, idletime: 'int | None' = None, frequency: 'int | None' = None) -> 'bytes | str | Awaitable[bytes | str]'
     |      Create a key using the provided serialized value, previously obtained
     |      using DUMP.
     |
     |      ``replace`` allows an existing key on ``name`` to be overridden. If
     |      it's not specified an error is raised on collision.
     |
     |      ``absttl`` if True, specified ``ttl`` should represent an absolute Unix
     |      timestamp in milliseconds in which the key will expire. (Redis 5.0 or
     |      greater).
     |
     |      ``idletime`` Used for eviction, this is the number of seconds the
     |      key must be idle, prior to execution.
     |
     |      ``frequency`` Used for eviction, this is the frequency counter of
     |      the object stored at the key, prior to execution.
     |
     |      For more information, see https://redis.io/commands/restore
     |
     |  set(self, name: 'KeyT', value: 'EncodableT', ex: 'ExpiryT | None' = None, px: 'ExpiryT | None' = None, nx: 'bool' = False, xx: 'bool' = False, keepttl: 'bool' = False, get: 'bool' = False, exat: 'AbsExpiryT | None' = None, pxat: 'AbsExpiryT | None' = None, ifeq: 'bytes | str | None' = None, ifne: 'bytes | str | None' = None, ifdeq: 'str | None' = None, ifdne: 'str | None' = None) -> 'bool | str | bytes | None | Awaitable[bool | str | bytes | None]'
     |      Set the value at key ``name`` to ``value``
     |
     |      Warning:
     |      **Experimental** since 7.1.
     |      The usage of the arguments ``ifeq``, ``ifne``, ``ifdeq``, and ``ifdne``
     |      is experimental. The API or returned results when those parameters are used
     |      may change based on feedback.
     |
     |      ``ex`` sets an expire flag on key ``name`` for ``ex`` seconds.
     |
     |      ``px`` sets an expire flag on key ``name`` for ``px`` milliseconds.
     |
     |      ``nx`` if set to True, set the value at key ``name`` to ``value`` only
     |          if it does not exist.
     |
     |      ``xx`` if set to True, set the value at key ``name`` to ``value`` only
     |          if it already exists.
     |
     |      ``keepttl`` if True, retain the time to live associated with the key.
     |          (Available since Redis 6.0)
     |
     |      ``get`` if True, set the value at key ``name`` to ``value`` and return
     |          the old value stored at key, or None if the key did not exist.
     |          (Available since Redis 6.2)
     |
     |      ``exat`` sets an expire flag on key ``name`` for ``ex`` seconds,
     |          specified in unix time.
     |
     |      ``pxat`` sets an expire flag on key ``name`` for ``ex`` milliseconds,
     |          specified in unix time.
     |
     |      ``ifeq`` set the value at key ``name`` to ``value`` only if the current
     |          value exactly matches the argument.
     |          If key doesn’t exist - it won’t be created.
     |          (Requires Redis 8.4 or greater)
     |
     |      ``ifne`` set the value at key ``name`` to ``value`` only if the current
     |          value does not exactly match the argument.
     |          If key doesn’t exist - it will be created.
     |          (Requires Redis 8.4 or greater)
     |
     |      ``ifdeq`` set the value at key ``name`` to ``value`` only if the current
     |          value XXH3 hex digest exactly matches the argument.
     |          If key doesn’t exist - it won’t be created.
     |          (Requires Redis 8.4 or greater)
     |
     |      ``ifdne`` set the value at key ``name`` to ``value`` only if the current
     |          value XXH3 hex digest does not exactly match the argument.
     |          If key doesn’t exist - it will be created.
     |          (Requires Redis 8.4 or greater)
     |
     |      For more information, see https://redis.io/commands/set
     |
     |  setbit(self, name: 'KeyT', offset: 'int', value: 'int') -> 'int | Awaitable[int]'
     |      Flag the ``offset`` in ``name`` as ``value``. Returns an integer
     |      indicating the previous value of ``offset``.
     |
     |      For more information, see https://redis.io/commands/setbit
     |
     |  setex(self, name: 'KeyT', time: 'ExpiryT', value: 'EncodableT') -> 'bool | Awaitable[bool]'
     |      Set the value of key ``name`` to ``value`` that expires in ``time``
     |      seconds. ``time`` can be represented by an integer or a Python
     |      timedelta object.
     |
     |      As per Redis 2.6.12, SETEX is considered deprecated.
     |      Please use SET with EX parameter in new code.
     |
     |      For more information, see https://redis.io/commands/setex
     |
     |  setnx(self, name: 'KeyT', value: 'EncodableT') -> 'bool | Awaitable[bool]'
     |      Set the value of key ``name`` to ``value`` if key doesn't exist
     |
     |      For more information, see https://redis.io/commands/setnx
     |
     |  setrange(self, name: 'KeyT', offset: 'int', value: 'EncodableT') -> 'int | Awaitable[int]'
     |      Overwrite bytes in the value of ``name`` starting at ``offset`` with
     |      ``value``. If ``offset`` plus the length of ``value`` exceeds the
     |      length of the original value, the new value will be larger than before.
     |      If ``offset`` exceeds the length of the original value, null bytes
     |      will be used to pad between the end of the previous value and the start
     |      of what's being injected.
     |
     |      Returns the length of the new string.
     |
     |      For more information, see https://redis.io/commands/setrange
     |
     |  strlen(self, name: 'KeyT') -> 'int | Awaitable[int]'
     |      Return the number of bytes stored in the value of ``name``
     |
     |      For more information, see https://redis.io/commands/strlen
     |
     |  substr(self, name: 'KeyT', start: 'int', end: 'int' = -1) -> 'bytes | str | Awaitable[bytes | str]'
     |      Return a substring of the string at key ``name``. ``start`` and ``end``
     |      are 0-based integers specifying the portion of the string to return.
     |
     |  ttl(self, name: 'KeyT') -> 'int | Awaitable[int]'
     |      Returns the number of seconds until the key ``name`` will expire
     |
     |      For more information, see https://redis.io/commands/ttl
     |
     |  type(self, name: 'KeyT') -> 'bytes | str | Awaitable[bytes | str]'
     |      Returns the type of key ``name``
     |
     |      For more information, see https://redis.io/commands/type
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from redis.commands.core.HyperlogCommands:
     |
     |  pfadd(self, name: 'KeyT', *values: 'FieldT') -> 'int | Awaitable[int]'
     |      Adds the specified elements to the specified HyperLogLog.
     |
     |      For more information, see https://redis.io/commands/pfadd
     |
     |  pfcount(self, *sources: 'KeyT') -> 'int | Awaitable[int]'
     |      Return the approximated cardinality of
     |      the set observed by the HyperLogLog at key(s).
     |
     |      For more information, see https://redis.io/commands/pfcount
     |
     |  pfmerge(self, dest: 'KeyT', *sources: 'KeyT') -> 'bool | Awaitable[bool]'
     |      Merge N different HyperLogLogs into a single one.
     |
     |      For more information, see https://redis.io/commands/pfmerge
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from redis.commands.core.HashCommands:
     |
     |  hdel(self, name: 'KeyT', *keys: 'FieldT') -> 'int | Awaitable[int]'
     |      Delete ``keys`` from hash ``name``
     |
     |      For more information, see https://redis.io/commands/hdel
     |
     |  hexists(self, name: 'KeyT', key: 'FieldT') -> 'bool | Awaitable[bool]'
     |      Returns a boolean indicating if ``key`` exists within hash ``name``
     |
     |      For more information, see https://redis.io/commands/hexists
     |
     |  hexpire(self, name: 'KeyT', seconds: 'ExpiryT', *fields: 'FieldT', nx: 'bool' = False, xx: 'bool' = False, gt: 'bool' = False, lt: 'bool' = False) -> 'list[int] | Awaitable[list[int]]'
     |      Sets or updates the expiration time for fields within a hash key, using relative
     |      time in seconds.
     |
     |      If a field already has an expiration time, the behavior of the update can be
     |      controlled using the `nx`, `xx`, `gt`, and `lt` parameters.
     |
     |      The return value provides detailed information about the outcome for each field.
     |
     |      For more information, see https://redis.io/commands/hexpire
     |
     |      Args:
     |          name: The name of the hash key.
     |          seconds: Expiration time in seconds, relative. Can be an integer, or a
     |                   Python `timedelta` object.
     |          fields: List of fields within the hash to apply the expiration time to.
     |          nx: Set expiry only when the field has no expiry.
     |          xx: Set expiry only when the field has an existing expiry.
     |          gt: Set expiry only when the new expiry is greater than the current one.
     |          lt: Set expiry only when the new expiry is less than the current one.
     |
     |      Returns:
     |          Returns a list which contains for each field in the request:
     |              - `-2` if the field does not exist, or if the key does not exist.
     |              - `0` if the specified NX | XX | GT | LT condition was not met.
     |              - `1` if the expiration time was set or updated.
     |              - `2` if the field was deleted because the specified expiration time is
     |                in the past.
     |
     |  hexpireat(self, name: 'KeyT', unix_time_seconds: 'AbsExpiryT', *fields: 'FieldT', nx: 'bool' = False, xx: 'bool' = False, gt: 'bool' = False, lt: 'bool' = False) -> 'list[int] | Awaitable[list[int]]'
     |      Sets or updates the expiration time for fields within a hash key, using an
     |      absolute Unix timestamp in seconds.
     |
     |      If a field already has an expiration time, the behavior of the update can be
     |      controlled using the `nx`, `xx`, `gt`, and `lt` parameters.
     |
     |      The return value provides detailed information about the outcome for each field.
     |
     |      For more information, see https://redis.io/commands/hexpireat
     |
     |      Args:
     |          name: The name of the hash key.
     |          unix_time_seconds: Expiration time as Unix timestamp in seconds. Can be an
     |                             integer or a Python `datetime` object.
     |          fields: List of fields within the hash to apply the expiration time to.
     |          nx: Set expiry only when the field has no expiry.
     |          xx: Set expiry only when the field has an existing expiration time.
     |          gt: Set expiry only when the new expiry is greater than the current one.
     |          lt: Set expiry only when the new expiry is less than the current one.
     |
     |      Returns:
     |          Returns a list which contains for each field in the request:
     |              - `-2` if the field does not exist, or if the key does not exist.
     |              - `0` if the specified NX | XX | GT | LT condition was not met.
     |              - `1` if the expiration time was set or updated.
     |              - `2` if the field was deleted because the specified expiration time is
     |                in the past.
     |
     |  hexpiretime(self, key: 'KeyT', *fields: 'FieldT') -> 'list[int] | Awaitable[list[int]]'
     |      Returns the expiration times of hash fields as Unix timestamps in seconds.
     |
     |      For more information, see https://redis.io/commands/hexpiretime
     |
     |      Args:
     |          key: The hash key.
     |          fields: A list of fields within the hash for which to get the expiration
     |                  time.
     |
     |      Returns:
     |          Returns a list which contains for each field in the request:
     |              - `-2` if the field does not exist, or if the key does not exist.
     |              - `-1` if the field exists but has no associated expire time.
     |              - A positive integer representing the expiration Unix timestamp in
     |                seconds, if the field has an associated expiration time.
     |
     |  hget(self, name: 'KeyT', key: 'FieldT') -> 'bytes | str | None | Awaitable[bytes | str | None]'
     |      Return the value of ``key`` within the hash ``name``
     |
     |      For more information, see https://redis.io/commands/hget
     |
     |  hgetall(self, name: 'KeyT') -> 'dict[bytes | str, bytes | str] | Awaitable[dict[bytes | str, bytes | str]]'
     |      Return a Python dict of the hash's name/value pairs
     |
     |      For more information, see https://redis.io/commands/hgetall
     |
     |  hgetdel(self, name: 'KeyT', *keys: 'FieldT') -> 'list[bytes | str | None] | Awaitable[list[bytes | str | None]]'
     |      Return the value of ``key`` within the hash ``name`` and
     |      delete the field in the hash.
     |      This command is similar to HGET, except for the fact that it also deletes
     |      the key on success from the hash with the provided ```name```.
     |
     |      Available since Redis 8.0
     |      For more information, see https://redis.io/commands/hgetdel
     |
     |  hgetex(self, name: 'KeyT', *keys: 'FieldT', ex: 'ExpiryT | None' = None, px: 'ExpiryT | None' = None, exat: 'AbsExpiryT | None' = None, pxat: 'AbsExpiryT | None' = None, persist: 'bool' = False) -> 'list[bytes | str | None] | Awaitable[list[bytes | str | None]]'
     |      Return the values of ``key`` and ``keys`` within the hash ``name``
     |      and optionally set their expiration.
     |
     |      ``ex`` sets an expire flag on ``kyes`` for ``ex`` seconds.
     |
     |      ``px`` sets an expire flag on ``keys`` for ``px`` milliseconds.
     |
     |      ``exat`` sets an expire flag on ``keys`` for ``ex`` seconds,
     |      specified in unix time.
     |
     |      ``pxat`` sets an expire flag on ``keys`` for ``ex`` milliseconds,
     |      specified in unix time.
     |
     |      ``persist`` remove the time to live associated with the ``keys``.
     |
     |      Available since Redis 8.0
     |      For more information, see https://redis.io/commands/hgetex
     |
     |  himport_discard_all_internal(self) -> 'int | Awaitable[int]'
     |      Send ``HIMPORT DISCARDALL`` (returns the number of fieldsets removed).
     |
     |      .. warning::
     |          Internal wire mapping — not for direct use on a pooled client. It
     |          DISCARDs on a single arbitrary borrowed connection and bypasses the
     |          client's shared fieldset registry, leaving other connections and the
     |          registry out of sync. Use the client's ``himport_discard_all`` instead;
     |          call this only on a pinned single-connection client where you manage
     |          session state yourself.
     |
     |  himport_discard_internal(self, fieldset_name: 'str') -> 'int | Awaitable[int]'
     |      Send ``HIMPORT DISCARD fieldset_name`` (``1`` removed, ``0`` not found).
     |
     |      .. warning::
     |          Internal wire mapping — not for direct use on a pooled client. It
     |          DISCARDs on a single arbitrary borrowed connection and bypasses the
     |          client's shared fieldset registry, leaving other connections and the
     |          registry out of sync. Use the client's ``himport_discard`` instead; call
     |          this only on a pinned single-connection client where you manage session
     |          state yourself.
     |
     |  himport_prepare_internal(self, fieldset_name: 'str', fields: 'Iterable[FieldT]') -> 'bool | Awaitable[bool]'
     |      Send ``HIMPORT PREPARE fieldset_name field [field ...]``.
     |
     |      Registers the ordered field list under ``fieldset_name`` in the executing
     |      connection's session. Fields are sent in the caller's order, unmodified.
     |
     |      .. warning::
     |          Internal wire mapping — not for direct use on a pooled client. It
     |          PREPAREs on a single arbitrary borrowed connection and bypasses the
     |          client's shared fieldset registry, so other connections stay unaware and
     |          reintroduce the nondeterministic "no such fieldset" the HIMPORT design
     |          prevents. Use the client's ``himport_prepare`` instead; call this only
     |          on a pinned single-connection client where you manage session state
     |          yourself.
     |
     |  himport_set(self, key: 'KeyT', fieldset_name: 'str', values: 'Iterable[EncodableT]') -> 'bool | Awaitable[bool]'
     |      Create/replace ``key`` as a hash using ``fieldset_name``'s field list.
     |
     |      Values are sent in the caller's order and map positionally to the prepared
     |      fields. The fieldset is prepared on the serving connection on first use
     |      (PREPARE bundled with SET in one write) and reused on subsequent calls;
     |      runtime discards are reconciled on the next use of the connection. All of
     |      this happens inside the normal command path, so retry, disconnect-on-error
     |      and (for the cluster) routing / MOVED-ASK apply exactly as for any command.
     |
     |      .. note::
     |          Recovery from a mid-connection fieldset loss (the server dropping the
     |          prepared fieldset without dropping the socket, e.g. ``RESET`` or
     |          ``maxmemory-clients`` eviction) applies only to a standalone
     |          ``himport_set`` call: it catches the resulting ``no such fieldset`` and
     |          re-prepares on the same socket, retrying the SET once. A ``himport_set``
     |          buffered in a **pipeline or transaction** has no such per-command
     |          recovery — its fieldset is PREPAREd once as a pre-flight before the
     |          batch, and if the server loses it between that pre-flight and the batch
     |          the SET fails and surfaces as an error in the batch results. Callers who
     |          need the automatic recovery should issue those sets outside a pipeline.
     |
     |  hincrby(self, name: 'KeyT', key: 'FieldT', amount: 'int' = 1) -> 'int | Awaitable[int]'
     |      Increment the value of ``key`` in hash ``name`` by ``amount``
     |
     |      For more information, see https://redis.io/commands/hincrby
     |
     |  hincrbyfloat(self, name: 'KeyT', key: 'FieldT', amount: 'float' = 1.0) -> 'float | Awaitable[float]'
     |      Increment the value of ``key`` in hash ``name`` by floating ``amount``
     |
     |      For more information, see https://redis.io/commands/hincrbyfloat
     |
     |  hkeys(self, name: 'KeyT') -> 'list[bytes | str] | Awaitable[list[bytes | str]]'
     |      Return the list of keys within hash ``name``
     |
     |      For more information, see https://redis.io/commands/hkeys
     |
     |  hlen(self, name: 'KeyT') -> 'int | Awaitable[int]'
     |      Return the number of elements in hash ``name``
     |
     |      For more information, see https://redis.io/commands/hlen
     |
     |  hmget(self, name: 'KeyT', keys: 'FieldT | Iterable[FieldT]', *args: 'FieldT') -> 'list[bytes | str | None] | Awaitable[list[bytes | str | None]]'
     |      Returns a list of values ordered identically to ``keys``
     |
     |      For more information, see https://redis.io/commands/hmget
     |
     |  hmset(self, name: 'KeyT', mapping: 'Mapping[FieldT, EncodableT]') -> 'bool | Awaitable[bool]'
     |      Set key to value within hash ``name`` for each corresponding
     |      key and value from the ``mapping`` dict.
     |
     |      For more information, see https://redis.io/commands/hmset
     |
     |  hpersist(self, name: 'KeyT', *fields: 'FieldT') -> 'list[int] | Awaitable[list[int]]'
     |      Removes the expiration time for each specified field in a hash.
     |
     |      For more information, see https://redis.io/commands/hpersist
     |
     |      Args:
     |          name: The name of the hash key.
     |          fields: A list of fields within the hash from which to remove the
     |                  expiration time.
     |
     |      Returns:
     |          Returns a list which contains for each field in the request:
     |              - `-2` if the field does not exist, or if the key does not exist.
     |              - `-1` if the field exists but has no associated expiration time.
     |              - `1` if the expiration time was successfully removed from the field.
     |
     |  hpexpire(self, name: 'KeyT', milliseconds: 'ExpiryT', *fields: 'FieldT', nx: 'bool' = False, xx: 'bool' = False, gt: 'bool' = False, lt: 'bool' = False) -> 'list[int] | Awaitable[list[int]]'
     |      Sets or updates the expiration time for fields within a hash key, using relative
     |      time in milliseconds.
     |
     |      If a field already has an expiration time, the behavior of the update can be
     |      controlled using the `nx`, `xx`, `gt`, and `lt` parameters.
     |
     |      The return value provides detailed information about the outcome for each field.
     |
     |      For more information, see https://redis.io/commands/hpexpire
     |
     |      Args:
     |          name: The name of the hash key.
     |          milliseconds: Expiration time in milliseconds, relative. Can be an integer,
     |                        or a Python `timedelta` object.
     |          fields: List of fields within the hash to apply the expiration time to.
     |          nx: Set expiry only when the field has no expiry.
     |          xx: Set expiry only when the field has an existing expiry.
     |          gt: Set expiry only when the new expiry is greater than the current one.
     |          lt: Set expiry only when the new expiry is less than the current one.
     |
     |      Returns:
     |          Returns a list which contains for each field in the request:
     |              - `-2` if the field does not exist, or if the key does not exist.
     |              - `0` if the specified NX | XX | GT | LT condition was not met.
     |              - `1` if the expiration time was set or updated.
     |              - `2` if the field was deleted because the specified expiration time is
     |                in the past.
     |
     |  hpexpireat(self, name: 'KeyT', unix_time_milliseconds: 'AbsExpiryT', *fields: 'FieldT', nx: 'bool' = False, xx: 'bool' = False, gt: 'bool' = False, lt: 'bool' = False) -> 'list[int] | Awaitable[list[int]]'
     |      Sets or updates the expiration time for fields within a hash key, using an
     |      absolute Unix timestamp in milliseconds.
     |
     |      If a field already has an expiration time, the behavior of the update can be
     |      controlled using the `nx`, `xx`, `gt`, and `lt` parameters.
     |
     |      The return value provides detailed information about the outcome for each field.
     |
     |      For more information, see https://redis.io/commands/hpexpireat
     |
     |      Args:
     |          name: The name of the hash key.
     |          unix_time_milliseconds: Expiration time as Unix timestamp in milliseconds.
     |                                  Can be an integer or a Python `datetime` object.
     |          fields: List of fields within the hash to apply the expiry.
     |          nx: Set expiry only when the field has no expiry.
     |          xx: Set expiry only when the field has an existing expiry.
     |          gt: Set expiry only when the new expiry is greater than the current one.
     |          lt: Set expiry only when the new expiry is less than the current one.
     |
     |      Returns:
     |          Returns a list which contains for each field in the request:
     |              - `-2` if the field does not exist, or if the key does not exist.
     |              - `0` if the specified NX | XX | GT | LT condition was not met.
     |              - `1` if the expiration time was set or updated.
     |              - `2` if the field was deleted because the specified expiration time is
     |                in the past.
     |
     |  hpexpiretime(self, key: 'KeyT', *fields: 'FieldT') -> 'list[int] | Awaitable[list[int]]'
     |      Returns the expiration times of hash fields as Unix timestamps in milliseconds.
     |
     |      For more information, see https://redis.io/commands/hpexpiretime
     |
     |      Args:
     |          key: The hash key.
     |          fields: A list of fields within the hash for which to get the expiration
     |                  time.
     |
     |      Returns:
     |          Returns a list which contains for each field in the request:
     |              - `-2` if the field does not exist, or if the key does not exist.
     |              - `-1` if the field exists but has no associated expire time.
     |              - A positive integer representing the expiration Unix timestamp in
     |                milliseconds, if the field has an associated expiration time.
     |
     |  hpttl(self, key: 'KeyT', *fields: 'FieldT') -> 'list[int] | Awaitable[list[int]]'
     |      Returns the TTL (Time To Live) in milliseconds for each specified field within a
     |      hash key.
     |
     |      For more information, see https://redis.io/commands/hpttl
     |
     |      Args:
     |          key: The hash key.
     |          fields: A list of fields within the hash for which to get the TTL.
     |
     |      Returns:
     |          Returns a list which contains for each field in the request:
     |              - `-2` if the field does not exist, or if the key does not exist.
     |              - `-1` if the field exists but has no associated expire time.
     |              - A positive integer representing the TTL in milliseconds if the field
     |                has an associated expiration time.
     |
     |  hset(self, name: 'KeyT', key: 'FieldT | None' = None, value: 'EncodableT | None' = None, mapping: 'Mapping[FieldT, EncodableT] | None' = None, items: 'Sequence[EncodableT] | None' = None) -> 'int | Awaitable[int]'
     |      Set ``key`` to ``value`` within hash ``name``,
     |      ``mapping`` accepts a dict of key/value pairs that will be
     |      added to hash ``name``.
     |      ``items`` accepts a list of key/value pairs that will be
     |      added to hash ``name``.
     |      Returns the number of fields that were added.
     |
     |      For more information, see https://redis.io/commands/hset
     |
     |  hsetex(self, name: 'KeyT', key: 'FieldT | None' = None, value: 'EncodableT | None' = None, mapping: 'Mapping[FieldT, EncodableT] | None' = None, items: 'Sequence[EncodableT] | None' = None, ex: 'ExpiryT | None' = None, px: 'ExpiryT | None' = None, exat: 'AbsExpiryT | None' = None, pxat: 'AbsExpiryT | None' = None, data_persist_option: 'HashDataPersistOptions | None' = None, keepttl: 'bool' = False) -> 'int | Awaitable[int]'
     |      Set ``key`` to ``value`` within hash ``name``
     |
     |      ``mapping`` accepts a dict of key/value pairs that will be
     |      added to hash ``name``.
     |
     |      ``items`` accepts a list of key/value pairs that will be
     |      added to hash ``name``.
     |
     |      ``ex`` sets an expire flag on ``keys`` for ``ex`` seconds.
     |
     |      ``px`` sets an expire flag on ``keys`` for ``px`` milliseconds.
     |
     |      ``exat`` sets an expire flag on ``keys`` for ``ex`` seconds,
     |          specified in unix time.
     |
     |      ``pxat`` sets an expire flag on ``keys`` for ``ex`` milliseconds,
     |          specified in unix time.
     |
     |      ``data_persist_option`` can be set to ``FNX`` or ``FXX`` to control the
     |          behavior of the command.
     |          ``FNX`` will set the value for each provided key to each
     |              provided value only if all do not already exist.
     |          ``FXX`` will set the value for each provided key to each
     |              provided value only if all already exist.
     |
     |      ``keepttl`` if True, retain the time to live associated with the keys.
     |
     |      Returns the number of fields that were added.
     |
     |      Available since Redis 8.0
     |      For more information, see https://redis.io/commands/hsetex
     |
     |  hsetnx(self, name: 'KeyT', key: 'FieldT', value: 'EncodableT') -> 'int | Awaitable[int]'
     |      Set ``key`` to ``value`` within hash ``name`` if ``key`` does not
     |      exist.  Returns 1 if HSETNX created a field, otherwise 0.
     |
     |      For more information, see https://redis.io/commands/hsetnx
     |
     |  hstrlen(self, name: 'KeyT', key: 'FieldT') -> 'int | Awaitable[int]'
     |      Return the number of bytes stored in the value of ``key``
     |      within hash ``name``
     |
     |      For more information, see https://redis.io/commands/hstrlen
     |
     |  httl(self, key: 'KeyT', *fields: 'FieldT') -> 'list[int] | Awaitable[list[int]]'
     |      Returns the TTL (Time To Live) in seconds for each specified field within a hash
     |      key.
     |
     |      For more information, see https://redis.io/commands/httl
     |
     |      Args:
     |          key: The hash key.
     |          fields: A list of fields within the hash for which to get the TTL.
     |
     |      Returns:
     |          Returns a list which contains for each field in the request:
     |              - `-2` if the field does not exist, or if the key does not exist.
     |              - `-1` if the field exists but has no associated expire time.
     |              - A positive integer representing the TTL in seconds if the field has
     |                an associated expiration time.
     |
     |  hvals(self, name: 'KeyT') -> 'list[bytes | str] | Awaitable[list[bytes | str]]'
     |      Return the list of values within hash ``name``
     |
     |      For more information, see https://redis.io/commands/hvals
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from redis.commands.core.GeoCommands:
     |
     |  geoadd(self, name: 'KeyT', values: 'Sequence[EncodableT]', nx: 'bool' = False, xx: 'bool' = False, ch: 'bool' = False) -> 'int | Awaitable[int]'
     |      Add the specified geospatial items to the specified key identified
     |      by the ``name`` argument. The Geospatial items are given as ordered
     |      members of the ``values`` argument, each item or place is formed by
     |      the triad longitude, latitude and name.
     |
     |      Note: You can use ZREM to remove elements.
     |
     |      ``nx`` forces ZADD to only create new elements and not to update
     |      scores for elements that already exist.
     |
     |      ``xx`` forces ZADD to only update scores of elements that already
     |      exist. New elements will not be added.
     |
     |      ``ch`` modifies the return value to be the numbers of elements changed.
     |      Changed elements include new elements that were added and elements
     |      whose scores changed.
     |
     |      For more information, see https://redis.io/commands/geoadd
     |
     |  geodist(self, name: 'KeyT', place1: 'FieldT', place2: 'FieldT', unit: 'str | None' = None) -> 'float | None | Awaitable[float | None]'
     |      Return the distance between ``place1`` and ``place2`` members of the
     |      ``name`` key.
     |      The units must be one of the following : m, km mi, ft. By default
     |      meters are used.
     |
     |      For more information, see https://redis.io/commands/geodist
     |
     |  geohash(self, name: 'KeyT', *values: 'FieldT') -> 'list[bytes | str | None] | Awaitable[list[bytes | str | None]]'
     |      Return the geo hash string for each item of ``values`` members of
     |      the specified key identified by the ``name`` argument.
     |
     |      For more information, see https://redis.io/commands/geohash
     |
     |  geopos(self, name: 'KeyT', *values: 'FieldT') -> 'list[GeoCoordinate | None] | Awaitable[list[GeoCoordinate | None]]'
     |      Return the positions of each item of ``values`` as members of
     |      the specified key identified by the ``name`` argument. Each position
     |      is represented by the pairs lon and lat.
     |
     |      For more information, see https://redis.io/commands/geopos
     |
     |  georadius(self, name: 'KeyT', longitude: 'float', latitude: 'float', radius: 'float', unit: 'str | None' = None, withdist: 'bool' = False, withcoord: 'bool' = False, withhash: 'bool' = False, count: 'int | None' = None, sort: 'str | None' = None, store: 'KeyT | None' = None, store_dist: 'KeyT | None' = None, any: 'bool' = False) -> 'GeoRadiusResponse | Awaitable[GeoRadiusResponse]'
     |      Return the members of the specified key identified by the
     |      ``name`` argument which are within the borders of the area specified
     |      with the ``latitude`` and ``longitude`` location and the maximum
     |      distance from the center specified by the ``radius`` value.
     |
     |      The units must be one of the following : m, km mi, ft. By default
     |
     |      ``withdist`` indicates to return the distances of each place.
     |
     |      ``withcoord`` indicates to return the latitude and longitude of
     |      each place.
     |
     |      ``withhash`` indicates to return the geohash string of each place.
     |
     |      ``count`` indicates to return the number of elements up to N.
     |
     |      ``sort`` indicates to return the places in a sorted way, ASC for
     |      nearest to fairest and DESC for fairest to nearest.
     |
     |      ``store`` indicates to save the places names in a sorted set named
     |      with a specific key, each element of the destination sorted set is
     |      populated with the score got from the original geo sorted set.
     |
     |      ``store_dist`` indicates to save the places names in a sorted set
     |      named with a specific key, instead of ``store`` the sorted set
     |      destination score is set with the distance.
     |
     |      For more information, see https://redis.io/commands/georadius
     |
     |  georadiusbymember(self, name: 'KeyT', member: 'FieldT', radius: 'float', unit: 'str | None' = None, withdist: 'bool' = False, withcoord: 'bool' = False, withhash: 'bool' = False, count: 'int | None' = None, sort: 'str | None' = None, store: 'Union[KeyT, None]' = None, store_dist: 'Union[KeyT, None]' = None, any: 'bool' = False) -> 'GeoRadiusResponse | Awaitable[GeoRadiusResponse]'
     |      This command is exactly like ``georadius`` with the sole difference
     |      that instead of taking, as the center of the area to query, a longitude
     |      and latitude value, it takes the name of a member already existing
     |      inside the geospatial index represented by the sorted set.
     |
     |      For more information, see https://redis.io/commands/georadiusbymember
     |
     |  geosearch(self, name: 'KeyT', member: 'FieldT | None' = None, longitude: 'float | None' = None, latitude: 'float | None' = None, unit: 'str' = 'm', radius: 'float | None' = None, width: 'float | None' = None, height: 'float | None' = None, sort: 'str | None' = None, count: 'int | None' = None, any: 'bool' = False, withcoord: 'bool' = False, withdist: 'bool' = False, withhash: 'bool' = False) -> 'GeoSearchResponse | Awaitable[GeoSearchResponse]'
     |      Return the members of specified key identified by the
     |      ``name`` argument, which are within the borders of the
     |      area specified by a given shape. This command extends the
     |      GEORADIUS command, so in addition to searching within circular
     |      areas, it supports searching within rectangular areas.
     |
     |      This command should be used in place of the deprecated
     |      GEORADIUS and GEORADIUSBYMEMBER commands.
     |
     |      ``member`` Use the position of the given existing
     |       member in the sorted set. Can't be given with ``longitude``
     |       and ``latitude``.
     |
     |      ``longitude`` and ``latitude`` Use the position given by
     |      this coordinates. Can't be given with ``member``
     |      ``radius`` Similar to GEORADIUS, search inside circular
     |      area according the given radius. Can't be given with
     |      ``height`` and ``width``.
     |      ``height`` and ``width`` Search inside an axis-aligned
     |      rectangle, determined by the given height and width.
     |      Can't be given with ``radius``
     |
     |      ``unit`` must be one of the following : m, km, mi, ft.
     |      `m` for meters (the default value), `km` for kilometers,
     |      `mi` for miles and `ft` for feet.
     |
     |      ``sort`` indicates to return the places in a sorted way,
     |      ASC for nearest to furthest and DESC for furthest to nearest.
     |
     |      ``count`` limit the results to the first count matching items.
     |
     |      ``any`` is set to True, the command will return as soon as
     |      enough matches are found. Can't be provided without ``count``
     |
     |      ``withdist`` indicates to return the distances of each place.
     |      ``withcoord`` indicates to return the latitude and longitude of
     |      each place.
     |
     |      ``withhash`` indicates to return the geohash string of each place.
     |
     |      For more information, see https://redis.io/commands/geosearch
     |
     |  geosearchstore(self, dest: 'KeyT', name: 'KeyT', member: 'FieldT | None' = None, longitude: 'float | None' = None, latitude: 'float | None' = None, unit: 'str' = 'm', radius: 'float | None' = None, width: 'float | None' = None, height: 'float | None' = None, sort: 'str | None' = None, count: 'int | None' = None, any: 'bool' = False, storedist: 'bool' = False) -> 'int | Awaitable[int]'
     |      This command is like GEOSEARCH, but stores the result in
     |      ``dest``. By default, it stores the results in the destination
     |      sorted set with their geospatial information.
     |      if ``store_dist`` set to True, the command will stores the
     |      items in a sorted set populated with their distance from the
     |      center of the circle or box, as a floating-point number.
     |
     |      For more information, see https://redis.io/commands/geosearchstore
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from redis.commands.core.ListCommands:
     |
     |  blmpop(self, timeout: 'float', numkeys: 'int', *args: 'str', direction: 'str', count: 'int | None' = 1) -> 'ListMultiPopResponse | Awaitable[ListMultiPopResponse]'
     |      Pop ``count`` values (default 1) from first non-empty in the list
     |      of provided key names.
     |
     |      When all lists are empty this command blocks the connection until another
     |      client pushes to it or until the timeout, timeout of 0 blocks indefinitely
     |
     |      For more information, see https://redis.io/commands/blmpop
     |
     |  blpop(self, keys: 'KeysT', timeout: 'Number | None' = 0) -> 'BlockingListPopResponse | Awaitable[BlockingListPopResponse]'
     |      LPOP a value off of the first non-empty list
     |      named in ``keys``.
     |
     |      If none of the lists in ``keys`` has a value to LPOP, then block
     |      for ``timeout`` seconds, or until a value gets pushed on to one
     |      of the lists.
     |
     |      If timeout is 0, then block indefinitely.
     |
     |      For more information, see https://redis.io/commands/blpop
     |
     |  brpop(self, keys: 'KeysT', timeout: 'Number | None' = 0) -> 'BlockingListPopResponse | Awaitable[BlockingListPopResponse]'
     |      RPOP a value off of the first non-empty list
     |      named in ``keys``.
     |
     |      If none of the lists in ``keys`` has a value to RPOP, then block
     |      for ``timeout`` seconds, or until a value gets pushed on to one
     |      of the lists.
     |
     |      If timeout is 0, then block indefinitely.
     |
     |      For more information, see https://redis.io/commands/brpop
     |
     |  brpoplpush(self, src: 'KeyT', dst: 'KeyT', timeout: 'Number | None' = 0) -> 'bytes | str | None | Awaitable[bytes | str | None]'
     |      Pop a value off the tail of ``src``, push it on the head of ``dst``
     |      and then return it.
     |
     |      This command blocks until a value is in ``src`` or until ``timeout``
     |      seconds elapse, whichever is first. A ``timeout`` value of 0 blocks
     |      forever.
     |
     |      For more information, see https://redis.io/commands/brpoplpush
     |
     |  lindex(self, name: 'KeyT', index: 'int') -> 'bytes | str | None | Awaitable[bytes | str | None]'
     |      Return the item from list ``name`` at position ``index``
     |
     |      Negative indexes are supported and will return an item at the
     |      end of the list
     |
     |      For more information, see https://redis.io/commands/lindex
     |
     |  linsert(self, name: 'KeyT', where: 'str', refvalue: 'str', value: 'str') -> 'int | Awaitable[int]'
     |      Insert ``value`` in list ``name`` either immediately before or after
     |      [``where``] ``refvalue``
     |
     |      Returns the new length of the list on success or -1 if ``refvalue``
     |      is not in the list.
     |
     |      For more information, see https://redis.io/commands/linsert
     |
     |  llen(self, name: 'KeyT') -> 'int | Awaitable[int]'
     |      Return the length of the list ``name``
     |
     |      For more information, see https://redis.io/commands/llen
     |
     |  lmpop(self, num_keys: 'int', *args: 'str', direction: 'str', count: 'int | None' = 1) -> 'ListMultiPopResponse | Awaitable[ListMultiPopResponse]'
     |      Pop ``count`` values (default 1) first non-empty list key from the list
     |      of args provided key names.
     |
     |      For more information, see https://redis.io/commands/lmpop
     |
     |  lpop(self, name: 'KeyT', count: 'int | None' = None) -> 'bytes | str | list[bytes | str] | None | Awaitable[bytes | str | list[bytes | str] | None]'
     |      Removes and returns the first elements of the list ``name``.
     |
     |      By default, the command pops a single element from the beginning of
     |      the list. When provided with the optional ``count`` argument, the reply
     |      will consist of up to count elements, depending on the list's length.
     |
     |      For more information, see https://redis.io/commands/lpop
     |
     |  lpos(self, name: 'KeyT', value: 'str', rank: 'int | None' = None, count: 'int | None' = None, maxlen: 'int | None' = None) -> 'int | list[int] | None | Awaitable[int | list[int] | None]'
     |      Get position of ``value`` within the list ``name``
     |
     |       If specified, ``rank`` indicates the "rank" of the first element to
     |       return in case there are multiple copies of ``value`` in the list.
     |       By default, LPOS returns the position of the first occurrence of
     |       ``value`` in the list. When ``rank`` 2, LPOS returns the position of
     |       the second ``value`` in the list. If ``rank`` is negative, LPOS
     |       searches the list in reverse. For example, -1 would return the
     |       position of the last occurrence of ``value`` and -2 would return the
     |       position of the next to last occurrence of ``value``.
     |
     |       If specified, ``count`` indicates that LPOS should return a list of
     |       up to ``count`` positions. A ``count`` of 2 would return a list of
     |       up to 2 positions. A ``count`` of 0 returns a list of all positions
     |       matching ``value``. When ``count`` is specified and but ``value``
     |       does not exist in the list, an empty list is returned.
     |
     |       If specified, ``maxlen`` indicates the maximum number of list
     |       elements to scan. A ``maxlen`` of 1000 will only return the
     |       position(s) of items within the first 1000 entries in the list.
     |       A ``maxlen`` of 0 (the default) will scan the entire list.
     |
     |       For more information, see https://redis.io/commands/lpos
     |
     |  lpush(self, name: 'KeyT', *values: 'FieldT') -> 'int | Awaitable[int]'
     |      Push ``values`` onto the head of the list ``name``
     |
     |      For more information, see https://redis.io/commands/lpush
     |
     |  lpushx(self, name: 'KeyT', *values: 'FieldT') -> 'int | Awaitable[int]'
     |      Push ``value`` onto the head of the list ``name`` if ``name`` exists
     |
     |      For more information, see https://redis.io/commands/lpushx
     |
     |  lrange(self, name: 'KeyT', start: 'int', end: 'int') -> 'list[bytes | str] | Awaitable[list[bytes | str]]'
     |      Return a slice of the list ``name`` between
     |      position ``start`` and ``end``
     |
     |      ``start`` and ``end`` can be negative numbers just like
     |      Python slicing notation
     |
     |      For more information, see https://redis.io/commands/lrange
     |
     |  lrem(self, name: 'KeyT', count: 'int', value: 'str') -> 'int | Awaitable[int]'
     |      Remove the first ``count`` occurrences of elements equal to ``value``
     |      from the list stored at ``name``.
     |
     |      The count argument influences the operation in the following ways:
     |          count > 0: Remove elements equal to value moving from head to tail.
     |          count < 0: Remove elements equal to value moving from tail to head.
     |          count = 0: Remove all elements equal to value.
     |
     |          For more information, see https://redis.io/commands/lrem
     |
     |  lset(self, name: 'KeyT', index: 'int', value: 'str') -> 'bool | Awaitable[bool]'
     |      Set element at ``index`` of list ``name`` to ``value``
     |
     |      For more information, see https://redis.io/commands/lset
     |
     |  ltrim(self, name: 'KeyT', start: 'int', end: 'int') -> 'bool | Awaitable[bool]'
     |      Trim the list ``name``, removing all values not within the slice
     |      between ``start`` and ``end``
     |
     |      ``start`` and ``end`` can be negative numbers just like
     |      Python slicing notation
     |
     |      For more information, see https://redis.io/commands/ltrim
     |
     |  rpop(self, name: 'KeyT', count: 'int | None' = None) -> 'bytes | str | list[bytes | str] | None | Awaitable[bytes | str | list[bytes | str] | None]'
     |      Removes and returns the last elements of the list ``name``.
     |
     |      By default, the command pops a single element from the end of the list.
     |      When provided with the optional ``count`` argument, the reply will
     |      consist of up to count elements, depending on the list's length.
     |
     |      For more information, see https://redis.io/commands/rpop
     |
     |  rpoplpush(self, src: 'KeyT', dst: 'KeyT') -> 'bytes | str | None | Awaitable[bytes | str | None]'
     |      RPOP a value off of the ``src`` list and atomically LPUSH it
     |      on to the ``dst`` list.  Returns the value.
     |
     |      For more information, see https://redis.io/commands/rpoplpush
     |
     |  rpush(self, name: 'KeyT', *values: 'FieldT') -> 'int | Awaitable[int]'
     |      Push ``values`` onto the tail of the list ``name``
     |
     |      For more information, see https://redis.io/commands/rpush
     |
     |  rpushx(self, name: 'KeyT', *values: 'str') -> 'int | Awaitable[int]'
     |      Push ``value`` onto the tail of the list ``name`` if ``name`` exists
     |
     |      For more information, see https://redis.io/commands/rpushx
     |
     |  sort(self, name: 'KeyT', start: 'int | None' = None, num: 'int | None' = None, by: 'str | None' = None, get: 'list[str] | None' = None, desc: 'bool' = False, alpha: 'bool' = False, store: 'str | None' = None, groups: 'bool | None' = False) -> 'SortResponse | Awaitable[SortResponse]'
     |      Sort and return the list, set or sorted set at ``name``.
     |
     |      ``start`` and ``num`` allow for paging through the sorted data
     |
     |      ``by`` allows using an external key to weight and sort the items.
     |          Use an "*" to indicate where in the key the item value is located
     |
     |      ``get`` allows for returning items from external keys rather than the
     |          sorted data itself.  Use an "*" to indicate where in the key
     |          the item value is located
     |
     |      ``desc`` allows for reversing the sort
     |
     |      ``alpha`` allows for sorting lexicographically rather than numerically
     |
     |      ``store`` allows for storing the result of the sort into
     |          the key ``store``
     |
     |      ``groups`` if set to True and if ``get`` contains at least two
     |          elements, sort will return a list of tuples, each containing the
     |          values fetched from the arguments to ``get``.
     |
     |      For more information, see https://redis.io/commands/sort
     |
     |  sort_ro(self, key: 'str', start: 'int | None' = None, num: 'int | None' = None, by: 'str | None' = None, get: 'list[str] | None' = None, desc: 'bool' = False, alpha: 'bool' = False) -> 'list[bytes | str] | Awaitable[list[bytes | str]]'
     |      Returns the elements contained in the list, set or sorted set at key.
     |      (read-only variant of the SORT command)
     |
     |      ``start`` and ``num`` allow for paging through the sorted data
     |
     |      ``by`` allows using an external key to weight and sort the items.
     |          Use an "*" to indicate where in the key the item value is located
     |
     |      ``get`` allows for returning items from external keys rather than the
     |          sorted data itself.  Use an "*" to indicate where in the key
     |          the item value is located
     |
     |      ``desc`` allows for reversing the sort
     |
     |      ``alpha`` allows for sorting lexicographically rather than numerically
     |
     |      For more information, see https://redis.io/commands/sort_ro
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from redis.commands.core.ArrayCommands:
     |
     |  arcount(self, name: 'KeyT') -> 'int | Awaitable[int]'
     |      Return the number of non-empty elements in the array stored at
     |      ``name``. Returns 0 if ``name`` does not exist.
     |
     |      For more information, see https://redis.io/commands/arcount
     |
     |  ardel(self, name: 'KeyT', *indices: 'int') -> 'int | Awaitable[int]'
     |      Delete elements at the specified ``indices`` in the array stored at
     |      ``name``. Deleting an index that does not exist counts as zero
     |      elements deleted and does not modify the array.
     |
     |      Returns the number of elements deleted.
     |
     |      For more information, see https://redis.io/commands/ardel
     |
     |  ardelrange(self, name: 'KeyT', *ranges: 'tuple[int, int]') -> 'int | Awaitable[int]'
     |      Delete elements within one or more inclusive index ranges in the
     |      array stored at ``name``. Each range is a ``(start, end)`` tuple.
     |      If ``start`` is greater than ``end`` for a given pair, the range is
     |      processed in ascending order regardless. Multiple pairs may overlap;
     |      each element is counted at most once.
     |
     |      Returns the number of elements deleted.
     |
     |      For more information, see https://redis.io/commands/ardelrange
     |
     |  arget(self, name: 'KeyT', index: 'int') -> 'bytes | str | None | Awaitable[bytes | str | None]'
     |      Return the value at ``index`` in the array stored at ``name``.
     |
     |      Returns ``None`` if ``name`` does not exist or no value is set at
     |      ``index``.
     |
     |      For more information, see https://redis.io/commands/arget
     |
     |  argetrange(self, name: 'KeyT', start: 'int', end: 'int') -> 'list[bytes | str | None] | Awaitable[list[bytes | str | None]]'
     |      Return the values in the inclusive index range [``start``, ``end``]
     |      in the array stored at ``name``. If ``start`` is greater than ``end``,
     |      elements are returned in reverse index order.
     |
     |      For more information, see https://redis.io/commands/argetrange
     |
     |  argrep(self, name: 'KeyT', start: 'int', end: 'int', predicates: 'list[tuple[ArrayPredicateType, EncodableT]]', combinator: 'ArrayPredicateCombinator | None' = None, limit: 'int | None' = None, withvalues: 'bool' = False, nocase: 'bool' = False) -> 'list[int] | list[list[int | bytes | str]] | Awaitable[list[int] | list[list[int | bytes | str]]]'
     |      Search elements of the array stored at ``name`` within the inclusive
     |      index range [``start``, ``end``] using one or more textual
     |      ``predicates``. Each predicate is a ``(type, value)`` tuple where
     |      ``type`` is a member of ``ArrayPredicateType``
     |      (``EXACT``, ``MATCH``, ``GLOB``, ``RE``).
     |
     |      Multiple predicates are combined via ``combinator``
     |      (``ArrayPredicateCombinator.AND`` or ``OR``); the server defaults to
     |      OR when omitted. ``limit`` caps the number of matches.
     |      ``withvalues=True`` returns a list of ``[index, value]`` pairs
     |      (``[[idx, val], ...]``) instead of a flat list of indices.
     |      ``nocase=True`` makes all comparisons case-insensitive.
     |
     |      Without ``withvalues``, returns a flat list of matching indices in
     |      traversal order. With ``withvalues``, returns a list of
     |      ``[index, value]`` pairs in traversal order. Empty slots are
     |      skipped.
     |
     |      For more information, see https://redis.io/commands/argrep
     |
     |  arinfo(self, name: 'KeyT', full: 'bool' = False) -> 'dict[str, int] | Awaitable[dict[str, int]]'
     |      Return metadata about the array stored at ``name`` as a dictionary.
     |      When ``full`` is ``True``, additionally include per-slice statistics
     |      (dense/sparse slice counts, average sizes, fill rates), which makes
     |      the call O(N) instead of O(1).
     |
     |      Raises ``ResponseError`` when the key does not exist.
     |
     |      For more information, see https://redis.io/commands/arinfo
     |
     |  arinsert(self, name: 'KeyT', *values: 'FieldT') -> 'int | Awaitable[int]'
     |      Insert one or more ``values`` at consecutive indices in the array
     |      stored at ``name``, beginning at the current insert cursor position.
     |      The cursor advances by one for each value inserted. Use ``ARNEXT``
     |      to inspect the current cursor position and ``ARSEEK`` to reposition
     |      it.
     |
     |      Returns the last index where a value was inserted.
     |
     |      For more information, see https://redis.io/commands/arinsert
     |
     |  arlastitems(self, name: 'KeyT', count: 'int', rev: 'bool' = False) -> 'list[bytes | str | None] | Awaitable[list[bytes | str | None]]'
     |      Return up to ``count`` most recently inserted elements from the array
     |      stored at ``name``. If the array contains fewer elements than
     |      ``count``, all elements are returned.
     |
     |      When ``rev`` is ``True``, elements are returned in reverse
     |      chronological order (most recent first) instead of the default
     |      oldest-first order.
     |
     |      For more information, see https://redis.io/commands/arlastitems
     |
     |  arlen(self, name: 'KeyT') -> 'int | Awaitable[int]'
     |      Return the length of the array stored at ``name``, defined as the
     |      maximum set index plus one. Returns 0 if ``name`` does not exist.
     |
     |      For more information, see https://redis.io/commands/arlen
     |
     |  armget(self, name: 'KeyT', *indices: 'int') -> 'list[bytes | str | None] | Awaitable[list[bytes | str | None]]'
     |      Return the values at the specified ``indices`` in the array stored at
     |      ``name``. The reply preserves the order of the requested indices and
     |      returns ``None`` for any index that is not set or when ``name`` does
     |      not exist.
     |
     |      For more information, see https://redis.io/commands/armget
     |
     |  armset(self, name: 'KeyT', mapping: 'Mapping[int, FieldT]') -> 'int | Awaitable[int]'
     |      Set multiple index/value pairs in the array stored at ``name``.
     |      ``mapping`` is a dictionary of zero-based integer indices to values.
     |      Pairs may be non-contiguous and in any order.
     |
     |      Returns the number of new slots that were set (previously empty).
     |
     |      For more information, see https://redis.io/commands/armset
     |
     |  arnext(self, name: 'KeyT') -> 'int | None | Awaitable[int | None]'
     |      Return the next index ``ARINSERT`` would use for the array stored at
     |      ``name``. Returns 0 if ``name`` does not exist or no insert happened
     |      yet, and ``None`` when the insertion cursor is exhausted (next insert
     |      would overflow).
     |
     |      For more information, see https://redis.io/commands/arnext
     |
     |  arop(self, name: 'KeyT', start: 'int', end: 'int', operation: 'ArrayAggregateOperations', value: 'EncodableT | None' = None) -> 'bytes | str | int | None | Awaitable[bytes | str | int | None]'
     |      Perform an aggregate ``operation`` on elements of the array stored at
     |      ``name`` in the inclusive index range [``start``, ``end``]. The range
     |      is always scanned from the lower to the higher index regardless of
     |      argument order.
     |
     |      ``operation`` is one of the members of ``ArrayAggregateOperations``.
     |      ``value`` is required when ``operation`` is
     |      ``ArrayAggregateOperations.MATCH`` and specifies the value to compare
     |      against.
     |
     |      Returns a bulk string for ``SUM``, ``MIN`` and ``MAX``, an integer
     |      for ``AND``, ``OR``, ``XOR``, ``MATCH`` and ``USED``, or ``None``
     |      when no elements match the operation.
     |
     |      For more information, see https://redis.io/commands/arop
     |
     |  arring(self, name: 'KeyT', size: 'int', *values: 'FieldT') -> 'int | Awaitable[int]'
     |      Insert one or more ``values`` into the array stored at ``name`` as a
     |      fixed-size ring buffer of ``size`` slots. Each value is placed at
     |      ``insert_idx % size``, wrapping back to index 0 once the end is
     |      reached and overwriting older values when full. If ``size`` is
     |      smaller than the current window, the array is truncated to fit.
     |
     |      Returns the last index where a value was inserted.
     |
     |      For more information, see https://redis.io/commands/arring
     |
     |  arscan(self, name: 'KeyT', start: 'int', end: 'int', limit: 'int | None' = None) -> 'list[list[int | bytes | str]] | Awaitable[list[list[int | bytes | str]]]'
     |      Iterate populated elements of the array stored at ``name`` in the
     |      inclusive range [``start``, ``end``] and return a list of
     |      ``[index, value]`` pairs in traversal order:
     |      ``[[idx1, val1], [idx2, val2], ...]``. Empty slots are skipped. If
     |      ``start`` is greater than ``end``, the iteration is reversed.
     |
     |      ``limit`` caps the number of populated elements returned. When
     |      omitted, all populated elements in range are returned.
     |
     |      For more information, see https://redis.io/commands/arscan
     |
     |  arseek(self, name: 'KeyT', index: 'int') -> 'int | Awaitable[int]'
     |      Set the insert cursor of the array stored at ``name`` to ``index``.
     |      Subsequent ``ARINSERT`` and ``ARRING`` operations begin inserting at
     |      this position.
     |
     |      Returns 1 if the cursor was set, 0 if ``name`` does not exist.
     |
     |      For more information, see https://redis.io/commands/arseek
     |
     |  arset(self, name: 'KeyT', index: 'int', *values: 'FieldT') -> 'int | Awaitable[int]'
     |      Set one or more contiguous ``values`` in the array stored at ``name``
     |      starting at ``index``. When multiple values are provided, they are
     |      stored at consecutive indices beginning at ``index``.
     |
     |      Returns the number of new slots that were set (previously empty).
     |
     |      For more information, see https://redis.io/commands/arset
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from redis.commands.core.AsyncScanCommands:
     |
     |  async hscan_iter(self, name: 'KeyT', match: 'Union[PatternT, None]' = None, count: 'Optional[int]' = None, no_values: 'Union[bool, None]' = None) -> 'AsyncIterator'
     |      Make an iterator using the HSCAN command so that the client doesn't
     |      need to remember the cursor position.
     |
     |      ``match`` allows for filtering the keys by pattern
     |
     |      ``count`` allows for hint the minimum number of returns
     |
     |      ``no_values`` indicates to return only the keys, without values
     |
     |  async sscan_iter(self, name: 'KeyT', match: 'Union[PatternT, None]' = None, count: 'Optional[int]' = None) -> 'AsyncIterator'
     |      Make an iterator using the SSCAN command so that the client doesn't
     |      need to remember the cursor position.
     |
     |      ``match`` allows for filtering the keys by pattern
     |
     |      ``count`` allows for hint the minimum number of returns
     |
     |  async zscan_iter(self, name: 'KeyT', match: 'Union[PatternT, None]' = None, count: 'Optional[int]' = None, score_cast_func: 'Union[type, Callable]' = <class 'float'>) -> 'AsyncIterator'
     |      Make an iterator using the ZSCAN command so that the client doesn't
     |      need to remember the cursor position.
     |
     |      ``match`` allows for filtering the keys by pattern
     |
     |      ``count`` allows for hint the minimum number of returns
     |
     |      ``score_cast_func`` a callable used to cast the score return value
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from redis.commands.core.ScanCommands:
     |
     |  hscan(self, name: 'KeyT', cursor: 'int' = 0, match: 'PatternT | None' = None, count: 'int | None' = None, no_values: 'bool | None' = None) -> 'HScanResponse | Awaitable[HScanResponse]'
     |      Incrementally return key/value slices in a hash. Also return a cursor
     |      indicating the scan position.
     |
     |      ``match`` allows for filtering the keys by pattern
     |
     |      ``count`` allows for hint the minimum number of returns
     |
     |      ``no_values`` indicates to return only the keys, without values.
     |
     |      For more information, see https://redis.io/commands/hscan
     |
     |  scan(self, cursor: 'int' = 0, match: 'PatternT | None' = None, count: 'int | None' = None, _type: 'str | None' = None, **kwargs) -> 'ScanResponse | Awaitable[ScanResponse]'
     |      Incrementally return lists of key names. Also return a cursor
     |      indicating the scan position.
     |
     |      ``match`` allows for filtering the keys by pattern
     |
     |      ``count`` provides a hint to Redis about the number of keys to
     |          return per batch.
     |
     |      ``_type`` filters the returned values by a particular Redis type.
     |          Stock Redis instances allow for the following types:
     |          HASH, LIST, SET, STREAM, STRING, ZSET
     |          Additionally, Redis modules can expose other types as well.
     |
     |      For more information, see https://redis.io/commands/scan
     |
     |  sscan(self, name: 'KeyT', cursor: 'int' = 0, match: 'PatternT | None' = None, count: 'int | None' = None) -> 'ScanResponse | Awaitable[ScanResponse]'
     |      Incrementally return lists of elements in a set. Also return a cursor
     |      indicating the scan position.
     |
     |      ``match`` allows for filtering the keys by pattern
     |
     |      ``count`` allows for hint the minimum number of returns
     |
     |      For more information, see https://redis.io/commands/sscan
     |
     |  zscan(self, name: 'KeyT', cursor: 'int' = 0, match: 'PatternT | None' = None, count: 'int | None' = None, score_cast_func: 'type | Callable' = <class 'float'>) -> 'ZScanResponse | Awaitable[ZScanResponse]'
     |      Incrementally return lists of elements in a sorted set. Also return a
     |      cursor indicating the scan position.
     |
     |      ``match`` allows for filtering the keys by pattern
     |
     |      ``count`` allows for hint the minimum number of returns
     |
     |      ``score_cast_func`` a callable used to cast the score return value
     |
     |      For more information, see https://redis.io/commands/zscan
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from redis.commands.core.SetCommands:
     |
     |  sadd(self, name: 'KeyT', *values: 'FieldT') -> 'int | Awaitable[int]'
     |      Add ``value(s)`` to set ``name``
     |
     |      For more information, see https://redis.io/commands/sadd
     |
     |  scard(self, name: 'KeyT') -> 'int | Awaitable[int]'
     |      Return the number of elements in set ``name``
     |
     |      For more information, see https://redis.io/commands/scard
     |
     |  sdiff(self, keys: 'List', *args: 'List') -> 'set[bytes | str] | Awaitable[set[bytes | str]]'
     |      Return the difference of sets specified by ``keys``
     |
     |      For more information, see https://redis.io/commands/sdiff
     |
     |  sdiffcard(self, numkeys: 'int', keys: 'List[KeyT]', limit: 'int' = 0) -> 'int | Awaitable[int]'
     |      Return the cardinality of the difference between the first set and all
     |      the successive sets specified by ``keys``, without returning the
     |      difference itself.
     |
     |      When LIMIT is provided (defaults to 0 and means unlimited), the returned
     |      cardinality is capped at ``limit`` and the server may stop the
     |      computation once the capped result is known.
     |
     |      For more information, see https://redis.io/commands/sdiffcard
     |
     |  sdiffstore(self, dest: 'str', keys: 'List', *args: 'List') -> 'int | Awaitable[int]'
     |      Store the difference of sets specified by ``keys`` into a new
     |      set named ``dest``.  Returns the number of keys in the new set.
     |
     |      For more information, see https://redis.io/commands/sdiffstore
     |
     |  sinter(self, keys: 'List', *args: 'List') -> 'set[bytes | str] | Awaitable[set[bytes | str]]'
     |      Return the intersection of sets specified by ``keys``
     |
     |      For more information, see https://redis.io/commands/sinter
     |
     |  sintercard(self, numkeys: 'int', keys: 'List[KeyT]', limit: 'int' = 0) -> 'int | Awaitable[int]'
     |      Return the cardinality of the intersect of multiple sets specified by ``keys``.
     |
     |      When LIMIT provided (defaults to 0 and means unlimited), if the intersection
     |      cardinality reaches limit partway through the computation, the algorithm will
     |      exit and yield limit as the cardinality
     |
     |      For more information, see https://redis.io/commands/sintercard
     |
     |  sinterstore(self, dest: 'KeyT', keys: 'List', *args: 'List') -> 'int | Awaitable[int]'
     |      Store the intersection of sets specified by ``keys`` into a new
     |      set named ``dest``.  Returns the number of keys in the new set.
     |
     |      For more information, see https://redis.io/commands/sinterstore
     |
     |  sismember(self, name: 'KeyT', value: 'str') -> 'Literal[0] | Literal[1] | Awaitable[Literal[0] | Literal[1]]'
     |      Return whether ``value`` is a member of set ``name``:
     |      - 1 if the value is a member of the set.
     |      - 0 if the value is not a member of the set or if key does not exist.
     |
     |      For more information, see https://redis.io/commands/sismember
     |
     |  smembers(self, name: 'KeyT') -> 'set[bytes | str] | Awaitable[set[bytes | str]]'
     |      Return all members of the set ``name``
     |
     |      For more information, see https://redis.io/commands/smembers
     |
     |  smismember(self, name: 'KeyT', values: 'List', *args: 'List') -> 'list[Literal[0] | Literal[1]] | Awaitable[list[Literal[0] | Literal[1]]]'
     |      Return whether each value in ``values`` is a member of the set ``name``
     |      as a list of ``int`` in the order of ``values``:
     |      - 1 if the value is a member of the set.
     |      - 0 if the value is not a member of the set or if key does not exist.
     |
     |      For more information, see https://redis.io/commands/smismember
     |
     |  smove(self, src: 'KeyT', dst: 'KeyT', value: 'str') -> 'bool | Awaitable[bool]'
     |      Move ``value`` from set ``src`` to set ``dst`` atomically
     |
     |      For more information, see https://redis.io/commands/smove
     |
     |  spop(self, name: 'KeyT', count: 'int | None' = None) -> 'bytes | str | set[bytes | str] | None | Awaitable[bytes | str | set[bytes | str] | None]'
     |      Remove and return a random member of set ``name``
     |
     |      For more information, see https://redis.io/commands/spop
     |
     |  srandmember(self, name: 'KeyT', number: 'int | None' = None) -> 'bytes | str | list[bytes | str] | None | Awaitable[bytes | str | list[bytes | str] | None]'
     |      If ``number`` is None, returns a random member of set ``name``.
     |
     |      If ``number`` is supplied, returns a list of ``number`` random
     |      members of set ``name``. Note this is only available when running
     |      Redis 2.6+.
     |
     |      For more information, see https://redis.io/commands/srandmember
     |
     |  srem(self, name: 'KeyT', *values: 'FieldT') -> 'int | Awaitable[int]'
     |      Remove ``values`` from set ``name``
     |
     |      For more information, see https://redis.io/commands/srem
     |
     |  sunion(self, keys: 'List', *args: 'List') -> 'set[bytes | str] | Awaitable[set[bytes | str]]'
     |      Return the union of sets specified by ``keys``
     |
     |      For more information, see https://redis.io/commands/sunion
     |
     |  sunioncard(self, numkeys: 'int', keys: 'List[KeyT]', limit: 'int' = 0, approx: 'bool' = False) -> 'int | Awaitable[int]'
     |      Return the cardinality of the union of multiple sets specified by
     |      ``keys``, without returning the union itself.
     |
     |      When ``approx`` is True, the ``APPROX`` option is sent and the server
     |      returns an approximate cardinality computed using HyperLogLog.
     |
     |      When LIMIT is provided (defaults to 0 and means unlimited), the returned
     |      cardinality is capped at ``limit``. In exact mode the result equals
     |      ``limit`` when the real cardinality exceeds ``limit``; in approximate
     |      mode the result will not exceed ``limit``. Options are emitted in the
     |      canonical order ``APPROX`` before ``LIMIT``.
     |
     |      For more information, see https://redis.io/commands/sunioncard
     |
     |  sunionstore(self, dest: 'KeyT', keys: 'List', *args: 'List') -> 'int | Awaitable[int]'
     |      Store the union of sets specified by ``keys`` into a new
     |      set named ``dest``.  Returns the number of keys in the new set.
     |
     |      For more information, see https://redis.io/commands/sunionstore
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from redis.commands.core.StreamCommands:
     |
     |  xack(self, name: 'KeyT', groupname: 'GroupT', *ids: 'StreamIdT') -> 'int | Awaitable[int]'
     |      Acknowledges the successful processing of one or more messages.
     |
     |      Args:
     |          name: name of the stream.
     |          groupname: name of the consumer group.
     |          *ids: message ids to acknowledge.
     |
     |      For more information, see https://redis.io/commands/xack
     |
     |  xackdel(self, name: 'KeyT', groupname: 'GroupT', *ids: 'StreamIdT', ref_policy: "Literal['KEEPREF', 'DELREF', 'ACKED']" = 'KEEPREF') -> 'int | Awaitable[int]'
     |      Combines the functionality of XACK and XDEL. Acknowledges the specified
     |      message IDs in the given consumer group and simultaneously attempts to
     |      delete the corresponding entries from the stream.
     |
     |  xadd(self, name: 'KeyT', fields: 'Dict[FieldT, EncodableT]', id: 'StreamIdT' = '*', maxlen: 'Optional[int]' = None, approximate: 'bool' = True, nomkstream: 'bool' = False, minid: 'Union[StreamIdT, None]' = None, limit: 'int | None' = None, ref_policy: "Literal['KEEPREF', 'DELREF', 'ACKED'] | None" = None, idmpauto: 'str | None' = None, idmp: 'tuple[str, bytes] | None' = None) -> 'bytes | str | Awaitable[bytes | str]'
     |      Add to a stream.
     |      name: name of the stream
     |      fields: dict of field/value pairs to insert into the stream
     |      id: Location to insert this record. By default it is appended.
     |      maxlen: truncate old stream members beyond this size.
     |      Can't be specified with minid.
     |      approximate: actual stream length may be slightly more than maxlen
     |      nomkstream: When set to true, do not make a stream
     |      minid: the minimum id in the stream to query.
     |      Can't be specified with maxlen.
     |      limit: specifies the maximum number of entries to retrieve
     |      ref_policy: optional reference policy for consumer groups when trimming:
     |          - KEEPREF (default): When trimming, preserves references in consumer groups' PEL
     |          - DELREF: When trimming, removes all references from consumer groups' PEL
     |          - ACKED: When trimming, only removes entries acknowledged by all consumer groups
     |      idmpauto: Producer ID for automatic idempotent ID calculation.
     |          Automatically calculates an idempotent ID based on entry content to prevent
     |          duplicate entries. Can only be used with id='*'. Creates an IDMP map if it
     |          doesn't exist yet. The producer ID must be unique per producer and consistent
     |          across restarts.
     |      idmp: Tuple of (producer_id, idempotent_id) for explicit idempotent ID.
     |          Uses a specific idempotent ID to prevent duplicate entries. Can only be used
     |          with id='*'. The producer ID must be unique per producer and consistent across
     |          restarts. The idempotent ID must be unique per message and per producer.
     |          Shorter idempotent IDs require less memory and allow faster processing.
     |          Creates an IDMP map if it doesn't exist yet.
     |
     |      For more information, see https://redis.io/commands/xadd
     |
     |  xautoclaim(self, name: 'KeyT', groupname: 'GroupT', consumername: 'ConsumerT', min_idle_time: 'int', start_id: 'StreamIdT' = '0-0', count: 'int | None' = None, justid: 'bool' = False) -> 'list[Any] | Awaitable[list[Any]]'
     |      Transfers ownership of pending stream entries that match the specified
     |      criteria. Conceptually, equivalent to calling XPENDING and then XCLAIM,
     |      but provides a more straightforward way to deal with message delivery
     |      failures via SCAN-like semantics.
     |      name: name of the stream.
     |      groupname: name of the consumer group.
     |      consumername: name of a consumer that claims the message.
     |      min_idle_time: filter messages that were idle less than this amount of
     |      milliseconds.
     |      start_id: filter messages with equal or greater ID.
     |      count: optional integer, upper limit of the number of entries that the
     |      command attempts to claim. Set to 100 by default.
     |      justid: optional boolean, false by default. Return just an array of IDs
     |      of messages successfully claimed, without returning the actual message
     |
     |      For more information, see https://redis.io/commands/xautoclaim
     |
     |  xcfgset(self, name: 'KeyT', idmp_duration: 'int | None' = None, idmp_maxsize: 'int | None' = None) -> 'bytes | str | Awaitable[bytes | str]'
     |      Configure the idempotency parameters for a stream's IDMP map.
     |
     |      Sets how long Redis remembers each idempotent ID (iid) and the maximum
     |      number of iids to track. This command clears the existing IDMP map
     |      (Redis forgets all previously stored iids), but only if the configuration
     |      value actually changes.
     |
     |      Args:
     |          name: The name of the stream.
     |          idmp_duration: How long Redis remembers each iid in seconds.
     |              Default: 100 seconds (or value set by stream-idmp-duration config).
     |              Minimum: 1 second, Maximum: 300 seconds.
     |              Redis won't forget an iid for this duration (unless maxsize is reached).
     |              Should accommodate application crash recovery time.
     |          idmp_maxsize: Maximum number of iids Redis remembers per producer ID (pid).
     |              Default: 100 iids (or value set by stream-idmp-maxsize config).
     |              Minimum: 1 iid, Maximum: 1,000,000 (1M) iids.
     |              Should be set to: mark-delay [in msec] × (messages/msec) + margin.
     |              Example: 10K msgs/sec (10 msgs/msec), 80 msec mark-delay
     |              → maxsize = 10 × 80 + margin = 1000 iids.
     |
     |      Returns:
     |          OK on success.
     |
     |      For more information, see https://redis.io/commands/xcfgset
     |
     |  xclaim(self, name: 'KeyT', groupname: 'GroupT', consumername: 'ConsumerT', min_idle_time: 'int', message_ids: 'Union[List[StreamIdT], Tuple[StreamIdT]]', idle: 'int | None' = None, time: 'int | None' = None, retrycount: 'int | None' = None, force: 'bool' = False, justid: 'bool' = False) -> 'XClaimResponse | Awaitable[XClaimResponse]'
     |      Changes the ownership of a pending message.
     |
     |      name: name of the stream.
     |
     |      groupname: name of the consumer group.
     |
     |      consumername: name of a consumer that claims the message.
     |
     |      min_idle_time: filter messages that were idle less than this amount of
     |      milliseconds
     |
     |      message_ids: non-empty list or tuple of message IDs to claim
     |
     |      idle: optional. Set the idle time (last time it was delivered) of the
     |      message in ms
     |
     |      time: optional integer. This is the same as idle but instead of a
     |      relative amount of milliseconds, it sets the idle time to a specific
     |      Unix time (in milliseconds).
     |
     |      retrycount: optional integer. set the retry counter to the specified
     |      value. This counter is incremented every time a message is delivered
     |      again.
     |
     |      force: optional boolean, false by default. Creates the pending message
     |      entry in the PEL even if certain specified IDs are not already in the
     |      PEL assigned to a different client.
     |
     |      justid: optional boolean, false by default. Return just an array of IDs
     |      of messages successfully claimed, without returning the actual message
     |
     |      For more information, see https://redis.io/commands/xclaim
     |
     |  xdel(self, name: 'KeyT', *ids: 'StreamIdT') -> 'int | Awaitable[int]'
     |      Deletes one or more messages from a stream.
     |
     |      Args:
     |          name: name of the stream.
     |          *ids: message ids to delete.
     |
     |      For more information, see https://redis.io/commands/xdel
     |
     |  xdelex(self, name: 'KeyT', *ids: 'StreamIdT', ref_policy: "Literal['KEEPREF', 'DELREF', 'ACKED']" = 'KEEPREF') -> 'int | Awaitable[int]'
     |      Extended version of XDEL that provides more control over how message entries
     |      are deleted concerning consumer groups.
     |
     |  xgroup_create(self, name: 'KeyT', groupname: 'GroupT', id: 'StreamIdT' = '$', mkstream: 'bool' = False, entries_read: 'int | None' = None) -> 'bool | Awaitable[bool]'
     |      Create a new consumer group associated with a stream.
     |      name: name of the stream.
     |      groupname: name of the consumer group.
     |      id: ID of the last item in the stream to consider already delivered.
     |
     |      For more information, see https://redis.io/commands/xgroup-create
     |
     |  xgroup_createconsumer(self, name: 'KeyT', groupname: 'GroupT', consumername: 'ConsumerT') -> 'int | Awaitable[int]'
     |      Consumers in a consumer group are auto-created every time a new
     |      consumer name is mentioned by some command.
     |      They can be explicitly created by using this command.
     |      name: name of the stream.
     |      groupname: name of the consumer group.
     |      consumername: name of consumer to create.
     |
     |      See: https://redis.io/commands/xgroup-createconsumer
     |
     |  xgroup_delconsumer(self, name: 'KeyT', groupname: 'GroupT', consumername: 'ConsumerT') -> 'int | Awaitable[int]'
     |      Remove a specific consumer from a consumer group.
     |      Returns the number of pending messages that the consumer had before it
     |      was deleted.
     |      name: name of the stream.
     |      groupname: name of the consumer group.
     |      consumername: name of consumer to delete
     |
     |      For more information, see https://redis.io/commands/xgroup-delconsumer
     |
     |  xgroup_destroy(self, name: 'KeyT', groupname: 'GroupT') -> 'bool | Awaitable[bool]'
     |      Destroy a consumer group.
     |      name: name of the stream.
     |      groupname: name of the consumer group.
     |
     |      For more information, see https://redis.io/commands/xgroup-destroy
     |
     |  xgroup_setid(self, name: 'KeyT', groupname: 'GroupT', id: 'StreamIdT', entries_read: 'int | None' = None) -> 'bool | Awaitable[bool]'
     |      Set the consumer group last delivered ID to something else.
     |      name: name of the stream.
     |      groupname: name of the consumer group.
     |      id: ID of the last item in the stream to consider already delivered.
     |
     |      For more information, see https://redis.io/commands/xgroup-setid
     |
     |  xinfo_consumers(self, name: 'KeyT', groupname: 'GroupT') -> 'list[dict[str, Any]] | Awaitable[list[dict[str, Any]]]'
     |      Returns general information about the consumers in the group.
     |      name: name of the stream.
     |      groupname: name of the consumer group.
     |
     |      For more information, see https://redis.io/commands/xinfo-consumers
     |
     |  xinfo_groups(self, name: 'KeyT') -> 'list[dict[str, Any]] | Awaitable[list[dict[str, Any]]]'
     |      Returns general information about the consumer groups of the stream.
     |      name: name of the stream.
     |
     |      For more information, see https://redis.io/commands/xinfo-groups
     |
     |  xinfo_stream(self, name: 'KeyT', full: 'bool' = False) -> 'dict[str, Any] | Awaitable[dict[str, Any]]'
     |      Returns general information about the stream.
     |      name: name of the stream.
     |      full: optional boolean, false by default. Return full summary
     |
     |      For more information, see https://redis.io/commands/xinfo-stream
     |
     |  xlen(self, name: 'KeyT') -> 'int | Awaitable[int]'
     |      Returns the number of elements in a given stream.
     |
     |      For more information, see https://redis.io/commands/xlen
     |
     |  xnack(self, name: 'KeyT', groupname: 'GroupT', mode: "Literal['SILENT', 'FAIL', 'FATAL']", *ids: 'StreamIdT', retrycount: 'int | None' = None, force: 'bool' = False) -> 'int | Awaitable[int]'
     |      Negatively acknowledges one or more messages in a consumer group's
     |      Pending Entries List (PEL).
     |
     |      Args:
     |          name: name of the stream.
     |          groupname: name of the consumer group.
     |          mode: the nacking mode. One of SILENT, FAIL, or FATAL.
     |              SILENT: consumer shutting down; decrements delivery counter.
     |              FAIL: consumer unable to process; delivery counter unchanged.
     |              FATAL: invalid/malicious message; delivery counter set to max.
     |          *ids: one or more message IDs to NACK.
     |          retrycount: optional integer >= 0. Overrides the mode's implicit
     |              delivery counter adjustment with an exact value.
     |          force: if True, creates a new unowned PEL entry for any ID not
     |              already in the group's PEL.
     |
     |      Returns:
     |          The number of messages successfully NACKed.
     |
     |      For more information, see https://redis.io/commands/xnack
     |
     |  xpending(self, name: 'KeyT', groupname: 'GroupT') -> 'dict[str, Any] | Awaitable[dict[str, Any]]'
     |      Returns information about pending messages of a group.
     |      name: name of the stream.
     |      groupname: name of the consumer group.
     |
     |      For more information, see https://redis.io/commands/xpending
     |
     |  xpending_range(self, name: 'KeyT', groupname: 'GroupT', min: 'StreamIdT', max: 'StreamIdT', count: 'int', consumername: 'ConsumerT | None' = None, idle: 'int | None' = None) -> 'XPendingRangeResponse | Awaitable[XPendingRangeResponse]'
     |      Returns information about pending messages, in a range.
     |
     |      name: name of the stream.
     |      groupname: name of the consumer group.
     |      idle: available from  version 6.2. filter entries by their
     |      idle-time, given in milliseconds (optional).
     |      min: minimum stream ID.
     |      max: maximum stream ID.
     |      count: number of messages to return
     |      consumername: name of a consumer to filter by (optional).
     |
     |  xrange(self, name: 'KeyT', min: 'StreamIdT' = '-', max: 'StreamIdT' = '+', count: 'int | None' = None) -> 'StreamRangeResponse | None | Awaitable[StreamRangeResponse | None]'
     |      Read stream values within an interval.
     |
     |      name: name of the stream.
     |
     |      start: first stream ID. defaults to '-',
     |             meaning the earliest available.
     |
     |      finish: last stream ID. defaults to '+',
     |              meaning the latest available.
     |
     |      count: if set, only return this many items, beginning with the
     |             earliest available.
     |
     |      For more information, see https://redis.io/commands/xrange
     |
     |  xread(self, streams: 'Dict[KeyT, StreamIdT]', count: 'int | None' = None, block: 'int | None' = None, max_count: 'int | None' = None, max_size: 'int | None' = None) -> 'XReadResponse | Awaitable[XReadResponse]'
     |      Block and monitor multiple streams for new data.
     |
     |      streams: a dict of stream names to stream IDs, where
     |                 IDs indicate the last ID already seen.
     |
     |      count: if set, only return this many items per stream, beginning with
     |             the earliest available.
     |
     |      block: number of milliseconds to wait, if nothing already present.
     |
     |      max_count: if set, cap the total number of entries returned across all
     |                 streams combined. Unlike ``count`` (a per-stream limit),
     |                 this is a cumulative cap over the whole reply. Must be a
     |                 positive integer and, when ``count`` is also set, must be
     |                 greater than or equal to ``count``. Requires Redis >= 8.10.0.
     |
     |      max_size: if set, a soft cap on the total server reply size in bytes
     |                across all streams combined. Measured server-side including
     |                protocol overhead, so it is not an exact application-payload
     |                size guarantee; a single available entry larger than the cap
     |                may still be returned. Must be a positive integer. Requires
     |                Redis >= 8.10.0.
     |
     |      For more information, see https://redis.io/commands/xread
     |
     |  xreadgroup(self, groupname: 'str', consumername: 'str', streams: 'Dict[KeyT, StreamIdT]', count: 'int | None' = None, block: 'int | None' = None, noack: 'bool' = False, claim_min_idle_time: 'int | None' = None, max_count: 'int | None' = None, max_size: 'int | None' = None) -> 'XReadGroupResponse | Awaitable[XReadGroupResponse]'
     |      Read from a stream via a consumer group.
     |
     |      groupname: name of the consumer group.
     |
     |      consumername: name of the requesting consumer.
     |
     |      streams: a dict of stream names to stream IDs, where
     |             IDs indicate the last ID already seen.
     |
     |      count: if set, only return this many items per stream, beginning with
     |             the earliest available.
     |
     |      block: number of milliseconds to wait, if nothing already present.
     |      noack: do not add messages to the PEL
     |
     |      claim_min_idle_time: accepts an integer type and represents a
     |                           time interval in milliseconds
     |
     |      max_count: if set, cap the total number of entries returned across all
     |                 streams combined. Unlike ``count`` (a per-stream limit),
     |                 this is a cumulative cap over the whole reply. Must be a
     |                 positive integer and, when ``count`` is also set, must be
     |                 greater than or equal to ``count``. Requires Redis 8.10.0.
     |
     |      max_size: if set, a soft cap on the total server reply size in bytes
     |                across all streams combined. Measured server-side including
     |                protocol overhead, so it is not an exact application-payload
     |                size guarantee; a single available entry larger than the cap
     |                may still be returned. Must be a positive integer. Requires
     |                Redis 8.10.0.
     |
     |      For more information, see https://redis.io/commands/xreadgroup
     |
     |  xrevrange(self, name: 'KeyT', max: 'StreamIdT' = '+', min: 'StreamIdT' = '-', count: 'int | None' = None) -> 'StreamRangeResponse | None | Awaitable[StreamRangeResponse | None]'
     |      Read stream values within an interval, in reverse order.
     |
     |      name: name of the stream
     |
     |      start: first stream ID. defaults to '+',
     |             meaning the latest available.
     |
     |      finish: last stream ID. defaults to '-',
     |              meaning the earliest available.
     |
     |      count: if set, only return this many items, beginning with the
     |             latest available.
     |
     |      For more information, see https://redis.io/commands/xrevrange
     |
     |  xtrim(self, name: 'KeyT', maxlen: 'int | None' = None, approximate: 'bool' = True, minid: 'StreamIdT | None' = None, limit: 'int | None' = None, ref_policy: "Literal['KEEPREF', 'DELREF', 'ACKED'] | None" = None) -> 'int | Awaitable[int]'
     |      Trims old messages from a stream.
     |      name: name of the stream.
     |      maxlen: truncate old stream messages beyond this size
     |      Can't be specified with minid.
     |      approximate: actual stream length may be slightly more than maxlen
     |      minid: the minimum id in the stream to query
     |      Can't be specified with maxlen.
     |      limit: specifies the maximum number of entries to retrieve
     |      ref_policy: optional reference policy for consumer groups:
     |          - KEEPREF (default): Trims entries but preserves references in consumer groups' PEL
     |          - DELREF: Trims entries and removes all references from consumer groups' PEL
     |          - ACKED: Only trims entries that were read and acknowledged by all consumer groups
     |
     |      For more information, see https://redis.io/commands/xtrim
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from redis.commands.core.SortedSetCommands:
     |
     |  bzmpop(self, timeout: 'float', numkeys: 'int', keys: 'List[str]', min: 'bool | None' = False, max: 'bool | None' = False, count: 'int | None' = 1) -> 'ZMPopResponse | Awaitable[ZMPopResponse]'
     |      Pop ``count`` values (default 1) off of the first non-empty sorted set
     |      named in the ``keys`` list.
     |
     |      If none of the sorted sets in ``keys`` has a value to pop,
     |      then block for ``timeout`` seconds, or until a member gets added
     |      to one of the sorted sets.
     |
     |      If timeout is 0, then block indefinitely.
     |
     |      For more information, see https://redis.io/commands/bzmpop
     |
     |  bzpopmax(self, keys: 'KeysT', timeout: 'TimeoutSecT' = 0) -> 'BlockingZSetPopResponse | Awaitable[BlockingZSetPopResponse]'
     |      ZPOPMAX a value off of the first non-empty sorted set
     |      named in the ``keys`` list.
     |
     |      If none of the sorted sets in ``keys`` has a value to ZPOPMAX,
     |      then block for ``timeout`` seconds, or until a member gets added
     |      to one of the sorted sets.
     |
     |      If timeout is 0, then block indefinitely.
     |
     |      For more information, see https://redis.io/commands/bzpopmax
     |
     |  bzpopmin(self, keys: 'KeysT', timeout: 'TimeoutSecT' = 0) -> 'BlockingZSetPopResponse | Awaitable[BlockingZSetPopResponse]'
     |      ZPOPMIN a value off of the first non-empty sorted set
     |      named in the ``keys`` list.
     |
     |      If none of the sorted sets in ``keys`` has a value to ZPOPMIN,
     |      then block for ``timeout`` seconds, or until a member gets added
     |      to one of the sorted sets.
     |
     |      If timeout is 0, then block indefinitely.
     |
     |      For more information, see https://redis.io/commands/bzpopmin
     |
     |  zadd(self, name: 'KeyT', mapping: 'Mapping[AnyKeyT, EncodableT]', nx: 'bool' = False, xx: 'bool' = False, ch: 'bool' = False, incr: 'bool' = False, gt: 'bool' = False, lt: 'bool' = False) -> 'int | float | None | Awaitable[int | float | None]'
     |      Set any number of element-name, score pairs to the key ``name``. Pairs
     |      are specified as a dict of element-names keys to score values.
     |
     |      ``nx`` forces ZADD to only create new elements and not to update
     |      scores for elements that already exist.
     |
     |      ``xx`` forces ZADD to only update scores of elements that already
     |      exist. New elements will not be added.
     |
     |      ``ch`` modifies the return value to be the numbers of elements changed.
     |      Changed elements include new elements that were added and elements
     |      whose scores changed.
     |
     |      ``incr`` modifies ZADD to behave like ZINCRBY. In this mode only a
     |      single element/score pair can be specified and the score is the amount
     |      the existing score will be incremented by. When using this mode the
     |      return value of ZADD will be the new score of the element.
     |
     |      ``lt`` only updates existing elements if the new score is less than
     |      the current score. This flag doesn't prevent adding new elements.
     |
     |      ``gt`` only updates existing elements if the new score is greater than
     |      the current score. This flag doesn't prevent adding new elements.
     |
     |      The return value of ZADD varies based on the mode specified. With no
     |      options, ZADD returns the number of new elements added to the sorted
     |      set.
     |
     |      ``nx``, ``lt``, and ``gt`` are mutually exclusive options.
     |
     |      See: https://redis.io/commands/ZADD
     |
     |  zcard(self, name: 'KeyT') -> 'int | Awaitable[int]'
     |      Return the number of elements in the sorted set ``name``
     |
     |      For more information, see https://redis.io/commands/zcard
     |
     |  zcount(self, name: 'KeyT', min: 'ZScoreBoundT', max: 'ZScoreBoundT') -> 'int | Awaitable[int]'
     |      Returns the number of elements in the sorted set at key ``name`` with
     |      a score between ``min`` and ``max``.
     |
     |      For more information, see https://redis.io/commands/zcount
     |
     |  zdiff(self, keys: 'KeysT', withscores: 'bool' = False) -> 'ZSetRangeResponse | Awaitable[ZSetRangeResponse]'
     |      Returns the difference between the first and all successive input
     |      sorted sets provided in ``keys``.
     |
     |      For more information, see https://redis.io/commands/zdiff
     |
     |  zdiffstore(self, dest: 'KeyT', keys: 'KeysT') -> 'int | Awaitable[int]'
     |      Computes the difference between the first and all successive input
     |      sorted sets provided in ``keys`` and stores the result in ``dest``.
     |
     |      For more information, see https://redis.io/commands/zdiffstore
     |
     |  zincrby(self, name: 'KeyT', amount: 'float', value: 'EncodableT') -> 'float | None | Awaitable[float | None]'
     |      Increment the score of ``value`` in sorted set ``name`` by ``amount``
     |
     |      For more information, see https://redis.io/commands/zincrby
     |
     |  zinter(self, keys: 'KeysT', aggregate: 'str | None' = None, withscores: 'bool' = False) -> 'ZSetRangeResponse | Awaitable[ZSetRangeResponse]'
     |      Return the intersect of multiple sorted sets specified by ``keys``.
     |
     |      With the ``aggregate`` option, it is possible to specify how the
     |      results of the intersection are aggregated. Available aggregation
     |      modes:
     |
     |      - ``SUM`` (default): the score of an element is summed across the
     |        inputs where it exists.
     |        Score = SUM(score₁×weight₁, score₂×weight₂, ...)
     |      - ``MIN``: the resulting set will contain the minimum score of an
     |        element across the inputs where it exists.
     |        Score = MIN(score₁×weight₁, score₂×weight₂, ...)
     |      - ``MAX``: the resulting set will contain the maximum score of an
     |        element across the inputs where it exists.
     |        Score = MAX(score₁×weight₁, score₂×weight₂, ...)
     |      - ``COUNT``: ignores the original scores and counts weighted set
     |        membership. Each element's score is the sum of the weights of
     |        the input sets that contain it.
     |        Score = SUM(weight₁, weight₂, ...) for sets containing the element.
     |        When all weights are 1 (default), the score equals the number
     |        of input sets containing the element.
     |
     |      For more information, see https://redis.io/commands/zinter
     |
     |  zintercard(self, numkeys: 'int', keys: 'List[str]', limit: 'int' = 0) -> 'int | Awaitable[int]'
     |      Return the cardinality of the intersect of multiple sorted sets
     |      specified by ``keys``.
     |      When LIMIT provided (defaults to 0 and means unlimited), if the intersection
     |      cardinality reaches limit partway through the computation, the algorithm will
     |      exit and yield limit as the cardinality
     |
     |      For more information, see https://redis.io/commands/zintercard
     |
     |  zinterstore(self, dest: 'KeyT', keys: 'Sequence[KeyT] | Mapping[AnyKeyT, float]', aggregate: 'str | None' = None) -> 'int | Awaitable[int]'
     |      Intersect multiple sorted sets specified by ``keys`` into a new
     |      sorted set, ``dest``. Scores in the destination will be aggregated
     |      based on the ``aggregate``.
     |
     |      Available aggregation modes:
     |
     |      - ``SUM`` (default): the score of an element is summed across the
     |        inputs where it exists.
     |        Score = SUM(score₁×weight₁, score₂×weight₂, ...)
     |      - ``MIN``: the resulting set will contain the minimum score of an
     |        element across the inputs where it exists.
     |        Score = MIN(score₁×weight₁, score₂×weight₂, ...)
     |      - ``MAX``: the resulting set will contain the maximum score of an
     |        element across the inputs where it exists.
     |        Score = MAX(score₁×weight₁, score₂×weight₂, ...)
     |      - ``COUNT``: ignores the original scores and counts weighted set
     |        membership. Each element's score is the sum of the weights of
     |        the input sets that contain it.
     |        Score = SUM(weight₁, weight₂, ...) for sets containing the element.
     |        When all weights are 1 (default), the score equals the number
     |        of input sets containing the element.
     |
     |      For more information, see https://redis.io/commands/zinterstore
     |
     |  zlexcount(self, name: 'KeyT', min: 'EncodableT', max: 'EncodableT') -> 'int | Awaitable[int]'
     |      Return the number of items in the sorted set ``name`` between the
     |      lexicographical range ``min`` and ``max``.
     |
     |      For more information, see https://redis.io/commands/zlexcount
     |
     |  zmpop(self, num_keys: 'int', keys: 'List[str]', min: 'bool | None' = False, max: 'bool | None' = False, count: 'int | None' = 1) -> 'ZMPopResponse | Awaitable[ZMPopResponse]'
     |      Pop ``count`` values (default 1) off of the first non-empty sorted set
     |      named in the ``keys`` list.
     |      For more information, see https://redis.io/commands/zmpop
     |
     |  zmscore(self, key: 'KeyT', members: 'List[str]') -> 'list[float | None] | Awaitable[list[float | None]]'
     |      Returns the scores associated with the specified members
     |      in the sorted set stored at key.
     |      ``members`` should be a list of the member name.
     |      Return type is a list of score.
     |      If the member does not exist, a None will be returned
     |      in corresponding position.
     |
     |      For more information, see https://redis.io/commands/zmscore
     |
     |  zpopmax(self, name: 'KeyT', count: 'int | None' = None) -> 'ZSetRangeResponse | Awaitable[ZSetRangeResponse]'
     |      Remove and return up to ``count`` members with the highest scores
     |      from the sorted set ``name``.
     |
     |      For more information, see https://redis.io/commands/zpopmax
     |
     |  zpopmin(self, name: 'KeyT', count: 'int | None' = None) -> 'ZSetRangeResponse | Awaitable[ZSetRangeResponse]'
     |      Remove and return up to ``count`` members with the lowest scores
     |      from the sorted set ``name``.
     |
     |      For more information, see https://redis.io/commands/zpopmin
     |
     |  zrandmember(self, key: 'KeyT', count: 'int | None' = None, withscores: 'bool' = False) -> 'ZRandMemberResponse | Awaitable[ZRandMemberResponse]'
     |      Return a random element from the sorted set value stored at key.
     |
     |      ``count`` if the argument is positive, return an array of distinct
     |      fields. If called with a negative count, the behavior changes and
     |      the command is allowed to return the same field multiple times.
     |      In this case, the number of returned fields is the absolute value
     |      of the specified count.
     |
     |      ``withscores`` The optional WITHSCORES modifier changes the reply so it
     |      includes the respective scores of the randomly selected elements from
     |      the sorted set.
     |
     |      For more information, see https://redis.io/commands/zrandmember
     |
     |  zrange(self, name: 'KeyT', start: 'EncodableT', end: 'EncodableT', desc: 'bool' = False, withscores: 'bool' = False, score_cast_func: 'type | Callable' = <class 'float'>, byscore: 'bool' = False, bylex: 'bool' = False, offset: 'int | None' = None, num: 'int | None' = None) -> 'ZSetRangeResponse | Awaitable[ZSetRangeResponse]'
     |      Return a range of values from sorted set ``name`` between
     |      ``start`` and ``end`` sorted in ascending order.
     |
     |      ``start`` and ``end`` can be negative, indicating the end of the range.
     |
     |      ``desc`` a boolean indicating whether to sort the results in reversed
     |      order.
     |
     |      ``withscores`` indicates to return the scores along with the values.
     |      The return type is a list of (value, score) pairs.
     |
     |      ``score_cast_func`` a callable used to cast the score return value.
     |
     |      ``byscore`` when set to True, returns the range of elements from the
     |      sorted set having scores equal or between ``start`` and ``end``.
     |
     |      ``bylex`` when set to True, returns the range of elements from the
     |      sorted set between the ``start`` and ``end`` lexicographical closed
     |      range intervals.
     |      Valid ``start`` and ``end`` must start with ( or [, in order to specify
     |      whether the range interval is exclusive or inclusive, respectively.
     |
     |      ``offset`` and ``num`` are specified, then return a slice of the range.
     |      Can't be provided when using ``bylex``.
     |
     |      For more information, see https://redis.io/commands/zrange
     |
     |  zrangebylex(self, name: 'KeyT', min: 'EncodableT', max: 'EncodableT', start: 'int | None' = None, num: 'int | None' = None) -> 'list[bytes | str] | Awaitable[list[bytes | str]]'
     |      Return the lexicographical range of values from sorted set ``name``
     |      between ``min`` and ``max``.
     |
     |      If ``start`` and ``num`` are specified, then return a slice of the
     |      range.
     |
     |      For more information, see https://redis.io/commands/zrangebylex
     |
     |  zrangebyscore(self, name: 'KeyT', min: 'ZScoreBoundT', max: 'ZScoreBoundT', start: 'int | None' = None, num: 'int | None' = None, withscores: 'bool' = False, score_cast_func: 'type | Callable' = <class 'float'>) -> 'ZSetRangeResponse | Awaitable[ZSetRangeResponse]'
     |      Return a range of values from the sorted set ``name`` with scores
     |      between ``min`` and ``max``.
     |
     |      If ``start`` and ``num`` are specified, then return a slice
     |      of the range.
     |
     |      ``withscores`` indicates to return the scores along with the values.
     |      The return type is a list of (value, score) pairs
     |
     |      `score_cast_func`` a callable used to cast the score return value
     |
     |      For more information, see https://redis.io/commands/zrangebyscore
     |
     |  zrangestore(self, dest: 'KeyT', name: 'KeyT', start: 'EncodableT', end: 'EncodableT', byscore: 'bool' = False, bylex: 'bool' = False, desc: 'bool' = False, offset: 'int | None' = None, num: 'int | None' = None) -> 'int | Awaitable[int]'
     |      Stores in ``dest`` the result of a range of values from sorted set
     |      ``name`` between ``start`` and ``end`` sorted in ascending order.
     |
     |      ``start`` and ``end`` can be negative, indicating the end of the range.
     |
     |      ``byscore`` when set to True, returns the range of elements from the
     |      sorted set having scores equal or between ``start`` and ``end``.
     |
     |      ``bylex`` when set to True, returns the range of elements from the
     |      sorted set between the ``start`` and ``end`` lexicographical closed
     |      range intervals.
     |      Valid ``start`` and ``end`` must start with ( or [, in order to specify
     |      whether the range interval is exclusive or inclusive, respectively.
     |
     |      ``desc`` a boolean indicating whether to sort the results in reversed
     |      order.
     |
     |      ``offset`` and ``num`` are specified, then return a slice of the range.
     |      Can't be provided when using ``bylex``.
     |
     |      For more information, see https://redis.io/commands/zrangestore
     |
     |  zrank(self, name: 'KeyT', value: 'EncodableT', withscore: 'bool' = False, score_cast_func: 'type | Callable' = <class 'float'>) -> 'int | list[Any] | None | Awaitable[int | list[Any] | None]'
     |      Returns a 0-based value indicating the rank of ``value`` in sorted set
     |      ``name``.
     |      The optional WITHSCORE argument supplements the command's
     |      reply with the score of the element returned.
     |
     |      ``score_cast_func`` a callable used to cast the score return value
     |
     |      For more information, see https://redis.io/commands/zrank
     |
     |  zrem(self, name: 'KeyT', *values: 'FieldT') -> 'int | Awaitable[int]'
     |      Remove member ``values`` from sorted set ``name``
     |
     |      For more information, see https://redis.io/commands/zrem
     |
     |  zremrangebylex(self, name: 'KeyT', min: 'EncodableT', max: 'EncodableT') -> 'int | Awaitable[int]'
     |      Remove all elements in the sorted set ``name`` between the
     |      lexicographical range specified by ``min`` and ``max``.
     |
     |      Returns the number of elements removed.
     |
     |      For more information, see https://redis.io/commands/zremrangebylex
     |
     |  zremrangebyrank(self, name: 'KeyT', min: 'int', max: 'int') -> 'int | Awaitable[int]'
     |      Remove all elements in the sorted set ``name`` with ranks between
     |      ``min`` and ``max``. Values are 0-based, ordered from smallest score
     |      to largest. Values can be negative indicating the highest scores.
     |      Returns the number of elements removed
     |
     |      For more information, see https://redis.io/commands/zremrangebyrank
     |
     |  zremrangebyscore(self, name: 'KeyT', min: 'ZScoreBoundT', max: 'ZScoreBoundT') -> 'int | Awaitable[int]'
     |      Remove all elements in the sorted set ``name`` with scores
     |      between ``min`` and ``max``. Returns the number of elements removed.
     |
     |      For more information, see https://redis.io/commands/zremrangebyscore
     |
     |  zrevrange(self, name: 'KeyT', start: 'int', end: 'int', withscores: 'bool' = False, score_cast_func: 'type | Callable' = <class 'float'>) -> 'ZSetRangeResponse | Awaitable[ZSetRangeResponse]'
     |      Return a range of values from sorted set ``name`` between
     |      ``start`` and ``end`` sorted in descending order.
     |
     |      ``start`` and ``end`` can be negative, indicating the end of the range.
     |
     |      ``withscores`` indicates to return the scores along with the values
     |      The return type is a list of (value, score) pairs
     |
     |      ``score_cast_func`` a callable used to cast the score return value
     |
     |      For more information, see https://redis.io/commands/zrevrange
     |
     |  zrevrangebylex(self, name: 'KeyT', max: 'EncodableT', min: 'EncodableT', start: 'int | None' = None, num: 'int | None' = None) -> 'list[bytes | str] | Awaitable[list[bytes | str]]'
     |      Return the reversed lexicographical range of values from sorted set
     |      ``name`` between ``max`` and ``min``.
     |
     |      If ``start`` and ``num`` are specified, then return a slice of the
     |      range.
     |
     |      For more information, see https://redis.io/commands/zrevrangebylex
     |
     |  zrevrangebyscore(self, name: 'KeyT', max: 'ZScoreBoundT', min: 'ZScoreBoundT', start: 'int | None' = None, num: 'int | None' = None, withscores: 'bool' = False, score_cast_func: 'type | Callable' = <class 'float'>) -> 'ZSetRangeResponse | Awaitable[ZSetRangeResponse]'
     |      Return a range of values from the sorted set ``name`` with scores
     |      between ``min`` and ``max`` in descending order.
     |
     |      If ``start`` and ``num`` are specified, then return a slice
     |      of the range.
     |
     |      ``withscores`` indicates to return the scores along with the values.
     |      The return type is a list of (value, score) pairs
     |
     |      ``score_cast_func`` a callable used to cast the score return value
     |
     |      For more information, see https://redis.io/commands/zrevrangebyscore
     |
     |  zrevrank(self, name: 'KeyT', value: 'EncodableT', withscore: 'bool' = False, score_cast_func: 'type | Callable' = <class 'float'>) -> 'int | list[Any] | None | Awaitable[int | list[Any] | None]'
     |      Returns a 0-based value indicating the descending rank of
     |      ``value`` in sorted set ``name``.
     |      The optional ``withscore`` argument supplements the command's
     |      reply with the score of the element returned.
     |
     |      ``score_cast_func`` a callable used to cast the score return value
     |
     |      For more information, see https://redis.io/commands/zrevrank
     |
     |  zscore(self, name: 'KeyT', value: 'EncodableT') -> 'float | None | Awaitable[float | None]'
     |      Return the score of element ``value`` in sorted set ``name``
     |
     |      For more information, see https://redis.io/commands/zscore
     |
     |  zunion(self, keys: 'Sequence[KeyT] | Mapping[AnyKeyT, float]', aggregate: 'str | None' = None, withscores: 'bool' = False, score_cast_func: 'type | Callable' = <class 'float'>) -> 'ZSetRangeResponse | Awaitable[ZSetRangeResponse]'
     |      Return the union of multiple sorted sets specified by ``keys``.
     |      ``keys`` can be provided as dictionary of keys and their weights.
     |      Scores will be aggregated based on the ``aggregate``, or SUM if
     |      none is provided.
     |
     |      Available aggregation modes:
     |
     |      - ``SUM`` (default): the score of an element is summed across the
     |        inputs where it exists.
     |        Score = SUM(score₁×weight₁, score₂×weight₂, ...)
     |      - ``MIN``: the resulting set will contain the minimum score of an
     |        element across the inputs where it exists.
     |        Score = MIN(score₁×weight₁, score₂×weight₂, ...)
     |      - ``MAX``: the resulting set will contain the maximum score of an
     |        element across the inputs where it exists.
     |        Score = MAX(score₁×weight₁, score₂×weight₂, ...)
     |      - ``COUNT``: ignores the original scores and counts weighted set
     |        membership. Each element's score is the sum of the weights of
     |        the input sets that contain it.
     |        Score = SUM(weight₁, weight₂, ...) for sets containing the element.
     |        When all weights are 1 (default), the score equals the number
     |        of input sets containing the element.
     |
     |      ``score_cast_func`` a callable used to cast the score return value
     |
     |      For more information, see https://redis.io/commands/zunion
     |
     |  zunionstore(self, dest: 'KeyT', keys: 'Sequence[KeyT] | Mapping[AnyKeyT, float]', aggregate: 'str | None' = None) -> 'int | Awaitable[int]'
     |      Union multiple sorted sets specified by ``keys`` into
     |      a new sorted set, ``dest``. Scores in the destination will be
     |      aggregated based on the ``aggregate``, or SUM if none is provided.
     |
     |      Available aggregation modes:
     |
     |      - ``SUM`` (default): the score of an element is summed across the
     |        inputs where it exists.
     |        Score = SUM(score₁×weight₁, score₂×weight₂, ...)
     |      - ``MIN``: the resulting set will contain the minimum score of an
     |        element across the inputs where it exists.
     |        Score = MIN(score₁×weight₁, score₂×weight₂, ...)
     |      - ``MAX``: the resulting set will contain the maximum score of an
     |        element across the inputs where it exists.
     |        Score = MAX(score₁×weight₁, score₂×weight₂, ...)
     |      - ``COUNT``: ignores the original scores and counts weighted set
     |        membership. Each element's score is the sum of the weights of
     |        the input sets that contain it.
     |        Score = SUM(weight₁, weight₂, ...) for sets containing the element.
     |        When all weights are 1 (default), the score equals the number
     |        of input sets containing the element.
     |
     |      For more information, see https://redis.io/commands/zunionstore
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from redis.commands.core.AsyncScriptCommands:
     |
     |  register_script(self: "Union['redis.asyncio.client.Redis', 'redis.asyncio.cluster.RedisCluster']", script: 'ScriptTextT') -> 'AsyncScript'
     |      Register a Lua ``script`` specifying the ``keys`` it will touch.
     |      Returns a Script object that is callable and hides the complexity of
     |      deal with scripts, keys, and shas. This is the preferred way to work
     |      with Lua scripts.
     |
     |  async script_debug(self, *args) -> 'None'
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from redis.commands.core.ScriptCommands:
     |
     |  eval(self, script: 'str', numkeys: 'int', *keys_and_args: 'KeyT | EncodableT') -> 'Any | Awaitable[Any]'
     |      Execute the Lua ``script``, specifying the ``numkeys`` the script
     |      will touch and the key names and argument values in ``keys_and_args``.
     |      Returns the result of the script.
     |
     |      In practice, use the object returned by ``register_script``. This
     |      function exists purely for Redis API completion.
     |
     |      For more information, see  https://redis.io/commands/eval
     |
     |  eval_ro(self, script: 'str', numkeys: 'int', *keys_and_args: 'KeyT | EncodableT') -> 'Any | Awaitable[Any]'
     |      The read-only variant of the EVAL command
     |
     |      Execute the read-only Lua ``script`` specifying the ``numkeys`` the script
     |      will touch and the key names and argument values in ``keys_and_args``.
     |      Returns the result of the script.
     |
     |      For more information, see  https://redis.io/commands/eval_ro
     |
     |  evalsha(self, sha: 'str', numkeys: 'int', *keys_and_args: 'KeyT | EncodableT') -> 'Any | Awaitable[Any]'
     |      Use the ``sha`` to execute a Lua script already registered via EVAL
     |      or SCRIPT LOAD. Specify the ``numkeys`` the script will touch and the
     |      key names and argument values in ``keys_and_args``. Returns the result
     |      of the script.
     |
     |      In practice, use the object returned by ``register_script``. This
     |      function exists purely for Redis API completion.
     |
     |      For more information, see  https://redis.io/commands/evalsha
     |
     |  evalsha_ro(self, sha: 'str', numkeys: 'int', *keys_and_args: 'KeyT | EncodableT') -> 'Any | Awaitable[Any]'
     |      The read-only variant of the EVALSHA command
     |
     |      Use the ``sha`` to execute a read-only Lua script already registered via EVAL
     |      or SCRIPT LOAD. Specify the ``numkeys`` the script will touch and the
     |      key names and argument values in ``keys_and_args``. Returns the result
     |      of the script.
     |
     |      For more information, see  https://redis.io/commands/evalsha_ro
     |
     |  script_exists(self, *args: 'str') -> 'list[bool] | Awaitable[list[bool]]'
     |      Check if a script exists in the script cache by specifying the SHAs of
     |      each script as ``args``. Returns a list of boolean values indicating if
     |      if each already script exists in the cache_data.
     |
     |      For more information, see  https://redis.io/commands/script-exists
     |
     |  script_flush(self, sync_type: "Literal['SYNC'] | Literal['ASYNC'] | None" = None) -> 'bool | Awaitable[bool]'
     |      Flush all scripts from the script cache_data.
     |
     |      ``sync_type`` is by default SYNC (synchronous) but it can also be
     |                    ASYNC.
     |
     |      For more information, see  https://redis.io/commands/script-flush
     |
     |  script_kill(self) -> 'bool | Awaitable[bool]'
     |      Kill the currently executing Lua script
     |
     |      For more information, see https://redis.io/commands/script-kill
     |
     |  script_load(self, script: 'ScriptTextT') -> 'str | Awaitable[str]'
     |      Load a Lua ``script`` into the script cache_data. Returns the SHA.
     |
     |      For more information, see https://redis.io/commands/script-load
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from redis.commands.core.FunctionCommands:
     |
     |  fcall(self, function, numkeys: 'int', *keys_and_args: 'Any') -> 'Any | Awaitable[Any]'
     |      Invoke a function.
     |
     |      For more information, see https://redis.io/commands/fcall
     |
     |  fcall_ro(self, function, numkeys: 'int', *keys_and_args: 'Any') -> 'Any | Awaitable[Any]'
     |      This is a read-only variant of the FCALL command that cannot
     |      execute commands that modify data.
     |
     |      For more information, see https://redis.io/commands/fcall_ro
     |
     |  function_delete(self, library: 'str') -> 'bool | Awaitable[bool]'
     |      Delete the library called ``library`` and all its functions.
     |
     |      For more information, see https://redis.io/commands/function-delete
     |
     |  function_dump(self) -> 'bytes | Awaitable[bytes]'
     |      Return the serialized payload of loaded libraries.
     |
     |      For more information, see https://redis.io/commands/function-dump
     |
     |  function_flush(self, mode: 'str' = 'SYNC') -> 'bool | Awaitable[bool]'
     |      Deletes all the libraries.
     |
     |      For more information, see https://redis.io/commands/function-flush
     |
     |  function_kill(self) -> 'bytes | str | Awaitable[bytes | str]'
     |      Kill a function that is currently executing.
     |
     |      For more information, see https://redis.io/commands/function-kill
     |
     |  function_list(self, library: 'str | None' = '*', withcode: 'bool | None' = False) -> 'list[Any] | Awaitable[list[Any]]'
     |      Return information about the functions and libraries.
     |
     |      Args:
     |
     |          library: specify a pattern for matching library names
     |          withcode: cause the server to include the libraries source implementation
     |              in the reply
     |
     |  function_load(self, code: 'str', replace: 'bool | None' = False) -> 'bytes | str | Awaitable[bytes | str]'
     |      Load a library to Redis.
     |      :param code: the source code (must start with
     |      Shebang statement that provides a metadata about the library)
     |      :param replace: changes the behavior to overwrite the existing library
     |      with the new contents.
     |      Return the library name that was loaded.
     |
     |      For more information, see https://redis.io/commands/function-load
     |
     |  function_restore(self, payload: 'str', policy: 'str | None' = 'APPEND') -> 'bool | Awaitable[bool]'
     |      Restore libraries from the serialized ``payload``.
     |      You can use the optional policy argument to provide a policy
     |      for handling existing libraries.
     |
     |      For more information, see https://redis.io/commands/function-restore
     |
     |  function_stats(self) -> 'Any | Awaitable[Any]'
     |      Return information about the function that's currently running
     |      and information about the available execution engines.
     |
     |      For more information, see https://redis.io/commands/function-stats
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors inherited from redis.commands.core.FunctionCommands:
     |
     |  __dict__
     |      dictionary for instance variables
     |
     |  __weakref__
     |      list of weak references to the object
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from redis.commands.core.ModuleCommands:
     |
     |  command_getkeys(self, *args) -> 'list[bytes | str] | Awaitable[list[bytes | str]]'
     |
     |  module_list(self) -> 'list[dict[Any, Any]] | Awaitable[list[dict[Any, Any]]]'
     |      Returns a list of dictionaries containing the name and version of
     |      all loaded modules.
     |
     |      For more information, see https://redis.io/commands/module-list
     |
     |  module_load(self, path, *args) -> 'bool | Awaitable[bool]'
     |      Loads the module from ``path``.
     |      Passes all ``*args`` to the module, during loading.
     |      Raises ``ModuleError`` if a module is not found at ``path``.
     |
     |      For more information, see https://redis.io/commands/module-load
     |
     |  module_loadex(self, path: 'str', options: 'List[str] | None' = None, args: 'List[str] | None' = None) -> 'bytes | str | Awaitable[bytes | str]'
     |      Loads a module from a dynamic library at runtime with configuration directives.
     |
     |      For more information, see https://redis.io/commands/module-loadex
     |
     |  module_unload(self, name) -> 'bool | Awaitable[bool]'
     |      Unloads the module ``name``.
     |      Raises ``ModuleError`` if ``name`` is not in loaded modules.
     |
     |      For more information, see https://redis.io/commands/module-unload
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from redis.typing.CommandsProtocol:
     |
     |  __init__ = _no_init_or_replace_init(self, *args, **kwargs) from typing
     |
     |  execute_command(self, *args, **options) -> Union[Awaitable[Any], Any]
     |
     |  ----------------------------------------------------------------------
     |  Data and other attributes inherited from redis.typing.CommandsProtocol:
     |
     |  __protocol_attrs__ = {'_event_dispatcher', 'execute_command'}
     |
     |  ----------------------------------------------------------------------
     |  Class methods inherited from typing.Protocol:
     |
     |  __init_subclass__(*args, **kwargs)
     |      This method is called when a class is subclassed.
     |
     |      The default implementation does nothing. It may be
     |      overridden to extend subclasses.
     |
     |  ----------------------------------------------------------------------
     |  Class methods inherited from typing.Generic:
     |
     |  __class_getitem__(...)
     |      Parameterizes a generic class.
     |
     |      At least, parameterizing a generic class is the *main* thing this
     |      method does. For example, for some generic class `Foo`, this is called
     |      when we do `Foo[int]` - there, with `cls=Foo` and `params=int`.
     |
     |      However, note that this method is also called when defining generic
     |      classes in the first place with `class Foo[T]: ...`.
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from redis.commands.redismodules.AsyncRedisModuleCommands:
     |
     |  bf(self) -> 'AsyncBFBloom'
     |      Access the bloom namespace.
     |
     |  cf(self) -> 'AsyncCFBloom'
     |      Access the bloom namespace.
     |
     |  cms(self) -> 'AsyncCMSBloom'
     |      Access the bloom namespace.
     |
     |  ft(self, index_name='idx') -> 'AsyncSearch'
     |      Access the search namespace, providing support for redis search.
     |
     |  json(self, encoder=<json.encoder.JSONEncoder object at 0x0000017B9C589190>, decoder=<json.decoder.JSONDecoder object at 0x0000017B9C589220>) -> 'AsyncJSON'
     |      Access the json namespace, providing support for redis json.
     |
     |  tdigest(self) -> 'AsyncTDigestBloom'
     |      Access the bloom namespace.
     |
     |  topk(self) -> 'AsyncTOPKBloom'
     |      Access the bloom namespace.
     |
     |  ts(self) -> 'AsyncTimeSeries'
     |      Access the timeseries namespace, providing support for
     |      redis timeseries data.
     |
     |  vset(self) -> 'AsyncVectorSet'
     |      Access the VectorSet commands namespace.

    class AsyncRedisModuleCommands(RedisModuleCommands)
     |  Method resolution order:
     |      AsyncRedisModuleCommands
     |      RedisModuleCommands
     |      builtins.object
     |
     |  Methods defined here:
     |
     |  bf(self) -> 'AsyncBFBloom'
     |      Access the bloom namespace.
     |
     |  cf(self) -> 'AsyncCFBloom'
     |      Access the bloom namespace.
     |
     |  cms(self) -> 'AsyncCMSBloom'
     |      Access the bloom namespace.
     |
     |  ft(self, index_name='idx') -> 'AsyncSearch'
     |      Access the search namespace, providing support for redis search.
     |
     |  json(self, encoder=<json.encoder.JSONEncoder object at 0x0000017B9C589190>, decoder=<json.decoder.JSONDecoder object at 0x0000017B9C589220>) -> 'AsyncJSON'
     |      Access the json namespace, providing support for redis json.
     |
     |  tdigest(self) -> 'AsyncTDigestBloom'
     |      Access the bloom namespace.
     |
     |  topk(self) -> 'AsyncTOPKBloom'
     |      Access the bloom namespace.
     |
     |  ts(self) -> 'AsyncTimeSeries'
     |      Access the timeseries namespace, providing support for
     |      redis timeseries data.
     |
     |  vset(self) -> 'AsyncVectorSet'
     |      Access the VectorSet commands namespace.
     |
     |  ----------------------------------------------------------------------
     |  Data and other attributes defined here:
     |
     |  __annotations__ = {}
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors inherited from RedisModuleCommands:
     |
     |  __dict__
     |      dictionary for instance variables
     |
     |  __weakref__
     |      list of weak references to the object

    class AsyncSentinelCommands(SentinelCommands)
     |  Method resolution order:
     |      AsyncSentinelCommands
     |      SentinelCommands
     |      builtins.object
     |
     |  Methods defined here:
     |
     |  async sentinel(self, *args) -> None
     |      Redis Sentinel's SENTINEL command.
     |
     |  ----------------------------------------------------------------------
     |  Data and other attributes defined here:
     |
     |  __annotations__ = {}
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from SentinelCommands:
     |
     |  sentinel_ckquorum(self, new_master_name) -> Union[bool, Awaitable[bool]]
     |      Check if the current Sentinel configuration is able to reach the
     |      quorum needed to failover a master, and the majority needed to
     |      authorize the failover.
     |
     |      This command should be used in monitoring systems to check if a
     |      Sentinel deployment is ok.
     |
     |  sentinel_failover(self, new_master_name) -> Union[bool, Awaitable[bool]]
     |      Force a failover as if the master was not reachable, and without
     |      asking for agreement to other Sentinels (however a new version of the
     |      configuration will be published so that the other Sentinels will
     |      update their configurations).
     |
     |  sentinel_flushconfig(self) -> Union[bool, Awaitable[bool]]
     |      Force Sentinel to rewrite its configuration on disk, including the
     |      current Sentinel state.
     |
     |      Normally Sentinel rewrites the configuration every time something
     |      changes in its state (in the context of the subset of the state which
     |      is persisted on disk across restart).
     |      However sometimes it is possible that the configuration file is lost
     |      because of operation errors, disk failures, package upgrade scripts or
     |      configuration managers. In those cases a way to to force Sentinel to
     |      rewrite the configuration file is handy.
     |
     |      This command works even if the previous configuration file is
     |      completely missing.
     |
     |  sentinel_get_master_addr_by_name(self, service_name, return_responses: bool = False) -> Union[tuple[bytes | str, int], NoneType, bool, Awaitable[tuple[bytes | str, int] | None | bool]]
     |      Returns a (host, port) pair for the given ``service_name`` when return_responses is True,
     |      otherwise returns a boolean value that indicates if the command was successful.
     |
     |  sentinel_master(self, service_name, return_responses: bool = False) -> Union[dict[str, Any], bool, Awaitable[dict[str, Any] | bool]]
     |      Returns a dictionary containing the specified masters state, when return_responses is True,
     |      otherwise returns a boolean value that indicates if the command was successful.
     |
     |  sentinel_masters(self) -> Union[dict[str, dict[str, Any]], list[dict[str, Any]], Awaitable[dict[str, dict[str, Any]] | list[dict[str, Any]]]]
     |      Returns a list of dictionaries containing each master's state.
     |
     |      Important: This function is called by the Sentinel implementation and is
     |      called directly on the Redis standalone client for sentinels,
     |      so it doesn't support the "once" and "return_responses" options.
     |
     |  sentinel_monitor(self, name, ip, port, quorum) -> Union[bool, Awaitable[bool]]
     |      Add a new master to Sentinel to be monitored
     |
     |  sentinel_remove(self, name) -> Union[bool, Awaitable[bool]]
     |      Remove a master from Sentinel's monitoring
     |
     |  sentinel_reset(self, pattern) -> Union[bool, Awaitable[bool]]
     |      This command will reset all the masters with matching name.
     |      The pattern argument is a glob-style pattern.
     |
     |      The reset process clears any previous state in a master (including a
     |      failover in progress), and removes every slave and sentinel already
     |      discovered and associated with the master.
     |
     |  sentinel_sentinels(self, service_name, return_responses: bool = False) -> Union[list[dict[str, Any]], bool, Awaitable[list[dict[str, Any]] | bool]]
     |      Returns a list of sentinels for ``service_name``, when return_responses is True,
     |      otherwise returns a boolean value that indicates if the command was successful.
     |
     |  sentinel_set(self, name, option, value) -> Union[bool, Awaitable[bool]]
     |      Set Sentinel monitoring parameters for a given master
     |
     |  sentinel_slaves(self, service_name) -> Union[list[dict[str, Any]], Awaitable[list[dict[str, Any]]]]
     |      Returns a list of slaves for ``service_name``
     |
     |      Important: This function is called by the Sentinel implementation and is
     |      called directly on the Redis standalone client for sentinels,
     |      so it doesn't support the "once" and "return_responses" options.
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors inherited from SentinelCommands:
     |
     |  __dict__
     |      dictionary for instance variables
     |
     |  __weakref__
     |      list of weak references to the object

    class CoreCommands(ACLCommands, ClusterCommands, DataAccessCommands, ManagementCommands, ModuleCommands, PubSubCommands, ScriptCommands, FunctionCommands)
     |  CoreCommands(*args, **kwargs)
     |
     |  A class containing all of the implemented redis commands. This class is
     |  to be used as a mixin for synchronous Redis clients.
     |
     |  Method resolution order:
     |      CoreCommands
     |      ACLCommands
     |      ClusterCommands
     |      DataAccessCommands
     |      BasicKeyCommands
     |      HyperlogCommands
     |      HashCommands
     |      GeoCommands
     |      ListCommands
     |      ArrayCommands
     |      ScanCommands
     |      SetCommands
     |      StreamCommands
     |      SortedSetCommands
     |      ManagementCommands
     |      ModuleCommands
     |      PubSubCommands
     |      ScriptCommands
     |      redis.typing.CommandsProtocol
     |      typing.Protocol
     |      typing.Generic
     |      FunctionCommands
     |      builtins.object
     |
     |  Class methods defined here:
     |
     |  __subclasshook__ = _proto_hook(other) from typing
     |
     |  ----------------------------------------------------------------------
     |  Data and other attributes defined here:
     |
     |  __abstractmethods__ = frozenset()
     |
     |  __annotations__ = {}
     |
     |  __parameters__ = ()
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from ACLCommands:
     |
     |  acl_cat(self, category: 'str | None' = None, **kwargs) -> 'list[bytes | str] | Awaitable[list[bytes | str]]'
     |      Returns a list of categories or commands within a category.
     |
     |      If ``category`` is not supplied, returns a list of all categories.
     |      If ``category`` is supplied, returns a list of all commands within
     |      that category.
     |
     |      For more information, see https://redis.io/commands/acl-cat
     |
     |  acl_deluser(self, *username: 'str', **kwargs) -> 'int | Awaitable[int]'
     |      Delete the ACL for the specified ``username``\s
     |
     |      For more information, see https://redis.io/commands/acl-deluser
     |
     |  acl_dryrun(self, username: 'str', *args: 'EncodableT', **kwargs) -> 'bytes | str | Awaitable[bytes | str]'
     |      Simulate the execution of a given command by a given ``username``.
     |
     |      For more information, see https://redis.io/commands/acl-dryrun
     |
     |  acl_genpass(self, bits: 'int | None' = None, **kwargs) -> 'bytes | str | Awaitable[bytes | str]'
     |      Generate a random password value.
     |      If ``bits`` is supplied then use this number of bits, rounded to
     |      the next multiple of 4.
     |      See: https://redis.io/commands/acl-genpass
     |
     |  acl_getuser(self, username: 'str', **kwargs) -> 'ACLGetUserData | Awaitable[ACLGetUserData]'
     |      Get the ACL details for the specified ``username``.
     |
     |      If ``username`` does not exist, return None
     |
     |      For more information, see https://redis.io/commands/acl-getuser
     |
     |  acl_help(self, **kwargs) -> 'list[bytes | str] | Awaitable[list[bytes | str]]'
     |      The ACL HELP command returns helpful text describing
     |      the different subcommands.
     |
     |      For more information, see https://redis.io/commands/acl-help
     |
     |  acl_list(self, **kwargs) -> 'list[bytes | str] | Awaitable[list[bytes | str]]'
     |      Return a list of all ACLs on the server
     |
     |      For more information, see https://redis.io/commands/acl-list
     |
     |  acl_load(self, **kwargs) -> 'bool | Awaitable[bool]'
     |      Load ACL rules from the configured ``aclfile``.
     |
     |      Note that the server must be configured with the ``aclfile``
     |      directive to be able to load ACL rules from an aclfile.
     |
     |      For more information, see https://redis.io/commands/acl-load
     |
     |  acl_log(self, count: 'int | None' = None, **kwargs) -> 'ACLLogData | Awaitable[ACLLogData]'
     |      Get ACL logs as a list.
     |      :param int count: Get logs[0:count].
     |      :rtype: List.
     |
     |      For more information, see https://redis.io/commands/acl-log
     |
     |  acl_log_reset(self, **kwargs) -> 'bool | Awaitable[bool]'
     |      Reset ACL logs.
     |      :rtype: Boolean.
     |
     |      For more information, see https://redis.io/commands/acl-log
     |
     |  acl_save(self, **kwargs) -> 'bool | Awaitable[bool]'
     |      Save ACL rules to the configured ``aclfile``.
     |
     |      Note that the server must be configured with the ``aclfile``
     |      directive to be able to save ACL rules to an aclfile.
     |
     |      For more information, see https://redis.io/commands/acl-save
     |
     |  acl_setuser(self, username: 'str', enabled: 'bool' = False, nopass: 'bool' = False, passwords: 'str | Iterable[str] | None' = None, hashed_passwords: 'str | Iterable[str] | None' = None, categories: 'Iterable[str] | None' = None, commands: 'Iterable[str] | None' = None, keys: 'Iterable[KeyT] | None' = None, channels: 'Iterable[ChannelT] | None' = None, selectors: 'Iterable[Tuple[str, KeyT]] | None' = None, reset: 'bool' = False, reset_keys: 'bool' = False, reset_channels: 'bool' = False, reset_passwords: 'bool' = False, **kwargs) -> 'bool | Awaitable[bool]'
     |      Create or update an ACL user.
     |
     |      Create or update the ACL for `username`. If the user already exists,
     |      the existing ACL is completely overwritten and replaced with the
     |      specified values.
     |
     |      For more information, see https://redis.io/commands/acl-setuser
     |
     |      Args:
     |          username: The name of the user whose ACL is to be created or updated.
     |          enabled: Indicates whether the user should be allowed to authenticate.
     |                   Defaults to `False`.
     |          nopass: Indicates whether the user can authenticate without a password.
     |                  This cannot be `True` if `passwords` are also specified.
     |          passwords: A list of plain text passwords to add to or remove from the user.
     |                     Each password must be prefixed with a '+' to add or a '-' to
     |                     remove. For convenience, a single prefixed string can be used
     |                     when adding or removing a single password.
     |          hashed_passwords: A list of SHA-256 hashed passwords to add to or remove
     |                            from the user. Each hashed password must be prefixed with
     |                            a '+' to add or a '-' to remove. For convenience, a single
     |                            prefixed string can be used when adding or removing a
     |                            single password.
     |          categories: A list of strings representing category permissions. Each string
     |                      must be prefixed with either a '+' to add the category
     |                      permission or a '-' to remove the category permission.
     |          commands: A list of strings representing command permissions. Each string
     |                    must be prefixed with either a '+' to add the command permission
     |                    or a '-' to remove the command permission.
     |          keys: A list of key patterns to grant the user access to. Key patterns allow
     |                ``'*'`` to support wildcard matching. For example, ``'*'`` grants
     |                access to all keys while ``'cache:*'`` grants access to all keys that
     |                are prefixed with ``cache:``.
     |                `keys` should not be prefixed with a ``'~'``.
     |          reset: Indicates whether the user should be fully reset prior to applying
     |                 the new ACL. Setting this to `True` will remove all existing
     |                 passwords, flags, and privileges from the user and then apply the
     |                 specified rules. If `False`, the user's existing passwords, flags,
     |                 and privileges will be kept and any new specified rules will be
     |                 applied on top.
     |          reset_keys: Indicates whether the user's key permissions should be reset
     |                      prior to applying any new key permissions specified in `keys`.
     |                      If `False`, the user's existing key permissions will be kept and
     |                      any new specified key permissions will be applied on top.
     |          reset_channels: Indicates whether the user's channel permissions should be
     |                          reset prior to applying any new channel permissions
     |                          specified in `channels`. If `False`, the user's existing
     |                          channel permissions will be kept and any new specified
     |                          channel permissions will be applied on top.
     |          reset_passwords: Indicates whether to remove all existing passwords and the
     |                           `nopass` flag from the user prior to applying any new
     |                           passwords specified in `passwords` or `hashed_passwords`.
     |                           If `False`, the user's existing passwords and `nopass`
     |                           status will be kept and any new specified passwords or
     |                           hashed passwords will be applied on top.
     |
     |  acl_users(self, **kwargs) -> 'list[bytes | str] | Awaitable[list[bytes | str]]'
     |      Returns a list of all registered users on the server.
     |
     |      For more information, see https://redis.io/commands/acl-users
     |
     |  acl_whoami(self, **kwargs) -> 'bytes | str | Awaitable[bytes | str]'
     |      Get the username for the current connection
     |
     |      For more information, see https://redis.io/commands/acl-whoami
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from ClusterCommands:
     |
     |  cluster(self, cluster_arg, *args, **kwargs) -> 'Any | Awaitable[Any]'
     |
     |  readonly(self, **kwargs) -> 'bool | Awaitable[bool]'
     |      Enables read queries for a connection to a Redis Cluster replica node.
     |
     |      For more information, see https://redis.io/commands/readonly
     |
     |  readwrite(self, **kwargs) -> 'bool | Awaitable[bool]'
     |      Disables read queries for a connection to a Redis Cluster slave node.
     |
     |      For more information, see https://redis.io/commands/readwrite
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from BasicKeyCommands:
     |
     |  __contains__ = exists(self, *names: 'KeyT') -> 'int | Awaitable[int]'
     |
     |  __delitem__(self, name: 'KeyT')
     |
     |  __getitem__(self, name: 'KeyT')
     |      Return the value at key ``name``, raises a KeyError if the key
     |      doesn't exist.
     |
     |  __setitem__(self, name: 'KeyT', value: 'EncodableT')
     |
     |  append(self, key: 'KeyT', value: 'EncodableT') -> 'int | Awaitable[int]'
     |      Appends the string ``value`` to the value at ``key``. If ``key``
     |      doesn't already exist, create it with a value of ``value``.
     |      Returns the new length of the value at ``key``.
     |
     |      For more information, see https://redis.io/commands/append
     |
     |  bitcount(self, key: 'KeyT', start: 'int | None' = None, end: 'int | None' = None, mode: 'str | None' = None) -> 'int | Awaitable[int]'
     |      Returns the count of set bits in the value of ``key``.  Optional
     |      ``start`` and ``end`` parameters indicate which bytes to consider
     |
     |      For more information, see https://redis.io/commands/bitcount
     |
     |  bitfield(self: "Union['redis.client.Redis', 'redis.asyncio.client.Redis']", key: 'KeyT', default_overflow: 'str | None' = None) -> 'BitFieldOperation'
     |      Return a BitFieldOperation instance to conveniently construct one or
     |      more bitfield operations on ``key``.
     |
     |      For more information, see https://redis.io/commands/bitfield
     |
     |  bitfield_ro(self: "Union['redis.client.Redis', 'redis.asyncio.client.Redis']", key: 'KeyT', encoding: 'str', offset: 'BitfieldOffsetT', items: 'list[tuple[str, BitfieldOffsetT]] | None' = None) -> 'list[int] | Awaitable[list[int]]'
     |      Return an array of the specified bitfield values
     |      where the first value is found using ``encoding`` and ``offset``
     |      parameters and remaining values are result of corresponding
     |      encoding/offset pairs in optional list ``items``
     |      Read-only variant of the BITFIELD command.
     |
     |      For more information, see https://redis.io/commands/bitfield_ro
     |
     |  bitop(self, operation: 'str', dest: 'KeyT', *keys: 'KeyT') -> 'int | Awaitable[int]'
     |      Perform a bitwise operation using ``operation`` between ``keys`` and
     |      store the result in ``dest``.
     |
     |      For more information, see https://redis.io/commands/bitop
     |
     |  bitpos(self, key: 'KeyT', bit: 'int', start: 'int | None' = None, end: 'int | None' = None, mode: 'str | None' = None) -> 'int | Awaitable[int]'
     |      Return the position of the first bit set to 1 or 0 in a string.
     |      ``start`` and ``end`` defines search range. The range is interpreted
     |      as a range of bytes and not a range of bits, so start=0 and end=2
     |      means to look at the first three bytes.
     |
     |      For more information, see https://redis.io/commands/bitpos
     |
     |  blmove(self, first_list: 'str', second_list: 'str', timeout: 'int', src: 'str' = 'LEFT', dest: 'str' = 'RIGHT') -> 'bytes | str | None | Awaitable[bytes | str | None]'
     |      Blocking version of lmove.
     |
     |      For more information, see https://redis.io/commands/blmove
     |
     |  blmovem(self, first_list: 'str', second_list: 'str', timeout: 'float', src: 'str' = 'LEFT', dest: 'str' = 'RIGHT', count: 'int | None' = None, mode: "Literal['COUNT', 'EXACTLY'] | None" = None, ordering: "Literal['OBO', 'BULK'] | None" = None) -> 'list[bytes | str] | None | Awaitable[list[bytes | str] | None]'
     |      Blocking version of lmovem.
     |
     |      Blocks until elements are available to move or ``timeout`` (in seconds)
     |      is reached; a ``timeout`` of ``0`` blocks indefinitely. With ``COUNT``
     |      the command unblocks once at least one element is available and moves
     |      ``min(count, available)``; with ``EXACTLY`` it blocks until the source
     |      holds at least ``count`` elements, then moves exactly ``count``
     |      atomically. On timeout ``None`` is returned and nothing is moved.
     |
     |      As with ``lmovem``, ``ordering`` (OBO or BULK) is required whenever
     |      ``count`` is given.
     |
     |      For more information, see https://redis.io/commands/blmovem
     |
     |  copy(self, source: 'str', destination: 'str', destination_db: 'str | None' = None, replace: 'bool' = False) -> 'bool | Awaitable[bool]'
     |      Copy the value stored in the ``source`` key to the ``destination`` key.
     |
     |      ``destination_db`` an alternative destination database. By default,
     |      the ``destination`` key is created in the source Redis database.
     |
     |      ``replace`` whether the ``destination`` key should be removed before
     |      copying the value to it. By default, the value is not copied if
     |      the ``destination`` key already exists.
     |
     |      For more information, see https://redis.io/commands/copy
     |
     |  decr = decrby(self, name: 'KeyT', amount: 'int' = 1) -> 'int | Awaitable[int]'
     |
     |  decrby(self, name: 'KeyT', amount: 'int' = 1) -> 'int | Awaitable[int]'
     |      Decrements the value of ``key`` by ``amount``.  If no key exists,
     |      the value will be initialized as 0 - ``amount``
     |
     |      For more information, see https://redis.io/commands/decrby
     |
     |  delete(self, *names: 'KeyT') -> 'int | Awaitable[int]'
     |      Delete one or more keys specified by ``names``
     |
     |  delex(self, name: 'KeyT', ifeq: 'bytes | str | None' = None, ifne: 'bytes | str | None' = None, ifdeq: 'str | None' = None, ifdne: 'str | None' = None) -> 'int | Awaitable[int]'
     |      Conditionally removes the specified key.
     |
     |      Warning:
     |      **Experimental** since 7.1.
     |      This API may change or be removed without notice.
     |      The API may change based on feedback.
     |
     |      Arguments:
     |          name: KeyT - the key to delete
     |          ifeq match-valu: Optional[Union[bytes, str]] - Delete the key only if its value is equal to match-value
     |          ifne match-value: Optional[Union[bytes, str]] - Delete the key only if its value is not equal to match-value
     |          ifdeq match-digest: Optional[str] - Delete the key only if the digest of its value is equal to match-digest
     |          ifdne match-digest: Optional[str] - Delete the key only if the digest of its value is not equal to match-digest
     |
     |      Returns:
     |          int: 1 if the key was deleted, 0 otherwise.
     |      Raises:
     |          redis.exceptions.ResponseError: if key exists but is not a string
     |                                          and a condition is specified.
     |          ValueError: if more than one condition is provided.
     |
     |
     |      Requires Redis 8.4 or greater.
     |      For more information, see https://redis.io/commands/delex
     |
     |  digest(self, name: 'KeyT') -> 'str | bytes | None | Awaitable[str | bytes | None]'
     |      Return the digest of the value stored at the specified key.
     |
     |      Warning:
     |      **Experimental** since 7.1.
     |      This API may change or be removed without notice.
     |      The API may change based on feedback.
     |
     |      Arguments:
     |        - name: KeyT - the key to get the digest of
     |
     |      Returns:
     |        - None if the key does not exist
     |        - (bulk string) the XXH3 digest of the value as a hex string
     |      Raises:
     |        - ResponseError if key exists but is not a string
     |
     |
     |      Requires Redis 8.4 or greater.
     |      For more information, see https://redis.io/commands/digest
     |
     |  digest_local(self, value: 'bytes | str') -> 'bytes | str'
     |      Compute the hexadecimal digest of the value locally, without sending it to the server.
     |
     |      This is useful for conditional operations like IFDEQ/IFDNE where you need to
     |      compute the digest client-side before sending a command.
     |
     |      Warning:
     |      **Experimental** - This API may change or be removed without notice.
     |
     |      Arguments:
     |        - value: Union[bytes, str] - the value to compute the digest of.
     |          If a string is provided, it will be encoded using UTF-8 before hashing,
     |          which matches Redis's default encoding behavior.
     |
     |      Returns:
     |        - (str | bytes) the XXH3 digest of the value as a hex string (16 hex characters).
     |          Returns bytes if decode_responses is False, otherwise returns str.
     |
     |      For more information, see https://redis.io/commands/digest
     |
     |  dump(self, name: 'KeyT') -> 'bytes | None | Awaitable[bytes | None]'
     |      Return a serialized version of the value stored at the specified key.
     |      If key does not exist a nil bulk reply is returned.
     |
     |      For more information, see https://redis.io/commands/dump
     |
     |  exists(self, *names: 'KeyT') -> 'int | Awaitable[int]'
     |      Returns the number of ``names`` that exist
     |
     |      For more information, see https://redis.io/commands/exists
     |
     |  expire(self, name: 'KeyT', time: 'ExpiryT', nx: 'bool' = False, xx: 'bool' = False, gt: 'bool' = False, lt: 'bool' = False) -> 'bool | Awaitable[bool]'
     |      Set an expire flag on key ``name`` for ``time`` seconds with given
     |      ``option``. ``time`` can be represented by an integer or a Python timedelta
     |      object.
     |
     |      Valid options are:
     |          NX -> Set expiry only when the key has no expiry
     |          XX -> Set expiry only when the key has an existing expiry
     |          GT -> Set expiry only when the new expiry is greater than current one
     |          LT -> Set expiry only when the new expiry is less than current one
     |
     |      For more information, see https://redis.io/commands/expire
     |
     |  expireat(self, name: 'KeyT', when: 'AbsExpiryT', nx: 'bool' = False, xx: 'bool' = False, gt: 'bool' = False, lt: 'bool' = False) -> 'bool | Awaitable[bool]'
     |      Set an expire flag on key ``name`` with given ``option``. ``when``
     |      can be represented as an integer indicating unix time or a Python
     |      datetime object.
     |
     |      Valid options are:
     |          -> NX -- Set expiry only when the key has no expiry
     |          -> XX -- Set expiry only when the key has an existing expiry
     |          -> GT -- Set expiry only when the new expiry is greater than current one
     |          -> LT -- Set expiry only when the new expiry is less than current one
     |
     |      For more information, see https://redis.io/commands/expireat
     |
     |  expiretime(self, key: 'str') -> 'int | Awaitable[int]'
     |      Returns the absolute Unix timestamp (since January 1, 1970) in seconds
     |      at which the given key will expire.
     |
     |      For more information, see https://redis.io/commands/expiretime
     |
     |  get(self, name: 'KeyT') -> 'bytes | str | None | Awaitable[bytes | str | None]'
     |      Return the value at key ``name``, or None if the key doesn't exist
     |
     |      For more information, see https://redis.io/commands/get
     |
     |  getbit(self, name: 'KeyT', offset: 'int') -> 'int | Awaitable[int]'
     |      Returns an integer indicating the value of ``offset`` in ``name``
     |
     |      For more information, see https://redis.io/commands/getbit
     |
     |  getdel(self, name: 'KeyT') -> 'bytes | str | None | Awaitable[bytes | str | None]'
     |      Get the value at key ``name`` and delete the key. This command
     |      is similar to GET, except for the fact that it also deletes
     |      the key on success (if and only if the key's value type
     |      is a string).
     |
     |      For more information, see https://redis.io/commands/getdel
     |
     |  getex(self, name: 'KeyT', ex: 'ExpiryT | None' = None, px: 'ExpiryT | None' = None, exat: 'AbsExpiryT | None' = None, pxat: 'AbsExpiryT | None' = None, persist: 'bool' = False) -> 'bytes | str | None | Awaitable[bytes | str | None]'
     |      Get the value of key and optionally set its expiration.
     |      GETEX is similar to GET, but is a write command with
     |      additional options. All time parameters can be given as
     |      datetime.timedelta or integers.
     |
     |      ``ex`` sets an expire flag on key ``name`` for ``ex`` seconds.
     |
     |      ``px`` sets an expire flag on key ``name`` for ``px`` milliseconds.
     |
     |      ``exat`` sets an expire flag on key ``name`` for ``ex`` seconds,
     |      specified in unix time.
     |
     |      ``pxat`` sets an expire flag on key ``name`` for ``ex`` milliseconds,
     |      specified in unix time.
     |
     |      ``persist`` remove the time to live associated with ``name``.
     |
     |      For more information, see https://redis.io/commands/getex
     |
     |  getrange(self, key: 'KeyT', start: 'int', end: 'int') -> 'bytes | str | Awaitable[bytes | str]'
     |      Returns the substring of the string value stored at ``key``,
     |      determined by the offsets ``start`` and ``end`` (both are inclusive)
     |
     |      For more information, see https://redis.io/commands/getrange
     |
     |  getset(self, name: 'KeyT', value: 'EncodableT') -> 'bytes | str | None | Awaitable[bytes | str | None]'
     |      Sets the value at key ``name`` to ``value``
     |      and returns the old value at key ``name`` atomically.
     |
     |      As per Redis 6.2, GETSET is considered deprecated.
     |      Please use SET with GET parameter in new code.
     |
     |      For more information, see https://redis.io/commands/getset
     |
     |  hrandfield(self, key: 'KeyT', count: 'int | None' = None, withvalues: 'bool' = False) -> 'HRandFieldResponse | Awaitable[HRandFieldResponse]'
     |      Return a random field from the hash value stored at key.
     |
     |      count: if the argument is positive, return an array of distinct fields.
     |      If called with a negative count, the behavior changes and the command
     |      is allowed to return the same field multiple times. In this case,
     |      the number of returned fields is the absolute value of the
     |      specified count.
     |      withvalues: The optional WITHVALUES modifier changes the reply so it
     |      includes the respective values of the randomly selected hash fields.
     |
     |      For more information, see https://redis.io/commands/hrandfield
     |
     |  incr = incrby(self, name: 'KeyT', amount: 'int' = 1) -> 'int | Awaitable[int]'
     |
     |  incrby(self, name: 'KeyT', amount: 'int' = 1) -> 'int | Awaitable[int]'
     |      Increments the value of ``key`` by ``amount``.  If no key exists,
     |      the value will be initialized as ``amount``
     |
     |      For more information, see https://redis.io/commands/incrby
     |
     |  incrbyfloat(self, name: 'KeyT', amount: 'float' = 1.0) -> 'float | Awaitable[float]'
     |      Increments the value at key ``name`` by floating ``amount``.
     |      If no key exists, the value will be initialized as ``amount``
     |
     |      For more information, see https://redis.io/commands/incrbyfloat
     |
     |  increx(self, name: 'KeyT', *, byfloat: 'EncodableT | None' = None, byint: 'EncodableT | None' = None, lbound: 'EncodableT | None' = None, ubound: 'EncodableT | None' = None, saturate: 'bool' = False, ex: 'ExpiryT | None' = None, px: 'ExpiryT | None' = None, exat: 'AbsExpiryT | None' = None, pxat: 'AbsExpiryT | None' = None, persist: 'bool' = False, enx: 'bool' = False) -> 'list[Number | bytes | str] | Awaitable[list[Number | bytes | str]]'
     |      Increment the numeric value at key ``name`` and return the new value
     |      and the actual increment.
     |
     |      ``byfloat`` increments a floating point value by the provided amount.
     |
     |      ``byint`` increments an integer value by the provided amount.
     |
     |      If neither ``byfloat`` nor ``byint`` is specified, the value is
     |      incremented by one.
     |
     |      ``lbound`` and ``ubound`` constrain the valid range of the result.
     |
     |      If ``saturate`` is True, out-of-bounds results are saturated to the
     |      specified bound, or to the type limit when no bound is specified.
     |      Otherwise, out-of-bounds results are rejected, leaving the value and
     |      TTL unchanged and returning the current value and zero as the actual
     |      increment.
     |
     |      ``enx`` applies the expiration only when the key does not already
     |      have an expiration, and requires ``ex``, ``px``, ``exat``, or ``pxat``.
     |
     |  keys(self, pattern: 'PatternT' = '*', **kwargs) -> 'list[bytes | str] | Awaitable[list[bytes | str]]'
     |      Returns a list of keys matching ``pattern``
     |
     |      For more information, see https://redis.io/commands/keys
     |
     |  lcs(self, key1: 'str', key2: 'str', len: 'bool | None' = False, idx: 'bool | None' = False, minmatchlen: 'int | None' = 0, withmatchlen: 'bool | None' = False) -> 'LCSCommandResponse | Awaitable[LCSCommandResponse]'
     |      Find the longest common subsequence between ``key1`` and ``key2``.
     |      If ``len`` is true the length of the match will be returned.
     |      If ``idx`` is true the match position in each strings will be returned.
     |      ``minmatchlen`` restrict the list of matches to the ones of
     |      the given ``minmatchlen``.
     |      If ``withmatchlen`` the length of the match also will be returned.
     |      For more information, see https://redis.io/commands/lcs
     |
     |  lmove(self, first_list: 'str', second_list: 'str', src: 'str' = 'LEFT', dest: 'str' = 'RIGHT') -> 'bytes | str | None | Awaitable[bytes | str | None]'
     |      Atomically returns and removes the first/last element of a list,
     |      pushing it as the first/last element on the destination list.
     |      Returns the element being popped and pushed.
     |
     |      For more information, see https://redis.io/commands/lmove
     |
     |  lmovem(self, first_list: 'str', second_list: 'str', src: 'str' = 'LEFT', dest: 'str' = 'RIGHT', count: 'int | None' = None, mode: "Literal['COUNT', 'EXACTLY'] | None" = None, ordering: "Literal['OBO', 'BULK'] | None" = None) -> 'list[bytes | str] | None | Awaitable[list[bytes | str] | None]'
     |      Atomically moves multiple elements from one end of the ``first_list``
     |      to one end of the ``second_list``, returning the moved elements in
     |      destination order.
     |
     |      ``src`` and ``dest`` are the ends to pop from / push to, either
     |      ``LEFT`` (head) or ``RIGHT`` (tail).
     |
     |      When ``count`` is given, ``mode`` selects how many elements to move:
     |      ``COUNT`` (the default) moves up to ``count`` elements, while
     |      ``EXACTLY`` moves exactly ``count`` elements or nothing at all. When
     |      ``count`` is not given a single element is moved.
     |
     |      ``ordering`` controls the order at the destination: ``OBO`` pushes each
     |      element as it is popped (reversing block order, stack semantics) while
     |      ``BULK`` preserves the original relative order (queue semantics). It is
     |      required whenever ``count`` is given.
     |
     |      Returns the array of moved elements, or ``None`` if nothing was moved.
     |
     |      For more information, see https://redis.io/commands/lmovem
     |
     |  mget(self, keys: 'KeysT', *args: 'EncodableT') -> 'list[bytes | str | None] | Awaitable[list[bytes | str | None]]'
     |      Returns a list of values ordered identically to ``keys``
     |
     |      ** Important ** When this method is used with Cluster clients, all keys
     |              must be in the same hash slot, otherwise a RedisClusterException
     |              will be raised.
     |
     |      For more information, see https://redis.io/commands/mget
     |
     |  move(self, name: 'KeyT', db: 'int') -> 'bool | Awaitable[bool]'
     |      Moves the key ``name`` to a different Redis database ``db``
     |
     |      For more information, see https://redis.io/commands/move
     |
     |  mset(self, mapping: 'Mapping[AnyKeyT, EncodableT]') -> 'bool | Awaitable[bool]'
     |      Sets key/values based on a mapping. Mapping is a dictionary of
     |      key/value pairs. Both keys and values should be strings or types that
     |      can be cast to a string via str().
     |
     |      ** Important ** When this method is used with Cluster clients, all keys
     |              must be in the same hash slot, otherwise a RedisClusterException
     |              will be raised.
     |
     |      For more information, see https://redis.io/commands/mset
     |
     |  msetex(self, mapping: 'Mapping[AnyKeyT, EncodableT]', data_persist_option: 'DataPersistOptions | None' = None, ex: 'ExpiryT | None' = None, px: 'ExpiryT | None' = None, exat: 'AbsExpiryT | None' = None, pxat: 'AbsExpiryT | None' = None, keepttl: 'bool' = False) -> 'int | Awaitable[int]'
     |      Sets key/values based on the provided ``mapping`` items.
     |
     |      ** Important ** When this method is used with Cluster clients, all keys
     |                      must be in the same hash slot, otherwise a RedisClusterException
     |                      will be raised.
     |
     |      ``mapping`` accepts a dict of key/value pairs that will be added to the database.
     |
     |      ``data_persist_option`` can be set to ``NX`` or ``XX`` to control the
     |          behavior of the command.
     |          ``NX`` will set the value for each provided key to each
     |              provided value only if all do not already exist.
     |          ``XX`` will set the value for each provided key to each
     |              provided value only if all already exist.
     |
     |      ``ex`` sets an expire flag on the keys in ``mapping`` for ``ex`` seconds.
     |
     |      ``px`` sets an expire flag on the keys in ``mapping`` for ``px`` milliseconds.
     |
     |      ``exat`` sets an expire flag on the keys in ``mapping`` for ``exat`` seconds,
     |          specified in unix time.
     |
     |      ``pxat`` sets an expire flag on the keys in ``mapping`` for ``pxat`` milliseconds,
     |          specified in unix time.
     |
     |      ``keepttl`` if True, retain the time to live associated with the keys.
     |
     |      Returns the number of fields that were added.
     |
     |      Available since Redis 8.4
     |      For more information, see https://redis.io/commands/msetex
     |
     |  msetnx(self, mapping: 'Mapping[AnyKeyT, EncodableT]') -> 'bool | Awaitable[bool]'
     |      Sets key/values based on a mapping if none of the keys are already set.
     |      Mapping is a dictionary of key/value pairs. Both keys and values
     |      should be strings or types that can be cast to a string via str().
     |      Returns a boolean indicating if the operation was successful.
     |
     |      ** Important ** When this method is used with Cluster clients, all keys
     |                      must be in the same hash slot, otherwise a RedisClusterException
     |                      will be raised.
     |
     |      For more information, see https://redis.io/commands/msetnx
     |
     |  persist(self, name: 'KeyT') -> 'bool | Awaitable[bool]'
     |      Removes an expiration on ``name``
     |
     |      For more information, see https://redis.io/commands/persist
     |
     |  pexpire(self, name: 'KeyT', time: 'ExpiryT', nx: 'bool' = False, xx: 'bool' = False, gt: 'bool' = False, lt: 'bool' = False) -> 'bool | Awaitable[bool]'
     |      Set an expire flag on key ``name`` for ``time`` milliseconds
     |      with given ``option``. ``time`` can be represented by an
     |      integer or a Python timedelta object.
     |
     |      Valid options are:
     |          NX -> Set expiry only when the key has no expiry
     |          XX -> Set expiry only when the key has an existing expiry
     |          GT -> Set expiry only when the new expiry is greater than current one
     |          LT -> Set expiry only when the new expiry is less than current one
     |
     |      For more information, see https://redis.io/commands/pexpire
     |
     |  pexpireat(self, name: 'KeyT', when: 'AbsExpiryT', nx: 'bool' = False, xx: 'bool' = False, gt: 'bool' = False, lt: 'bool' = False) -> 'bool | Awaitable[bool]'
     |      Set an expire flag on key ``name`` with given ``option``. ``when``
     |      can be represented as an integer representing unix time in
     |      milliseconds (unix time * 1000) or a Python datetime object.
     |
     |      Valid options are:
     |          NX -> Set expiry only when the key has no expiry
     |          XX -> Set expiry only when the key has an existing expiry
     |          GT -> Set expiry only when the new expiry is greater than current one
     |          LT -> Set expiry only when the new expiry is less than current one
     |
     |      For more information, see https://redis.io/commands/pexpireat
     |
     |  pexpiretime(self, key: 'str') -> 'int | Awaitable[int]'
     |      Returns the absolute Unix timestamp (since January 1, 1970) in milliseconds
     |      at which the given key will expire.
     |
     |      For more information, see https://redis.io/commands/pexpiretime
     |
     |  psetex(self, name: 'KeyT', time_ms: 'ExpiryT', value: 'EncodableT') -> 'bool | Awaitable[bool]'
     |      Set the value of key ``name`` to ``value`` that expires in ``time_ms``
     |      milliseconds. ``time_ms`` can be represented by an integer or a Python
     |      timedelta object
     |
     |      For more information, see https://redis.io/commands/psetex
     |
     |  pttl(self, name: 'KeyT') -> 'int | Awaitable[int]'
     |      Returns the number of milliseconds until the key ``name`` will expire
     |
     |      For more information, see https://redis.io/commands/pttl
     |
     |  randomkey(self, **kwargs) -> 'bytes | str | None | Awaitable[bytes | str | None]'
     |      Returns the name of a random key
     |
     |      For more information, see https://redis.io/commands/randomkey
     |
     |  rename(self, src: 'KeyT', dst: 'KeyT') -> 'bool | Awaitable[bool]'
     |      Rename key ``src`` to ``dst``
     |
     |      For more information, see https://redis.io/commands/rename
     |
     |  renamenx(self, src: 'KeyT', dst: 'KeyT') -> 'bool | Awaitable[bool]'
     |      Rename key ``src`` to ``dst`` if ``dst`` doesn't already exist
     |
     |      For more information, see https://redis.io/commands/renamenx
     |
     |  restore(self, name: 'KeyT', ttl: 'float', value: 'EncodableT', replace: 'bool' = False, absttl: 'bool' = False, idletime: 'int | None' = None, frequency: 'int | None' = None) -> 'bytes | str | Awaitable[bytes | str]'
     |      Create a key using the provided serialized value, previously obtained
     |      using DUMP.
     |
     |      ``replace`` allows an existing key on ``name`` to be overridden. If
     |      it's not specified an error is raised on collision.
     |
     |      ``absttl`` if True, specified ``ttl`` should represent an absolute Unix
     |      timestamp in milliseconds in which the key will expire. (Redis 5.0 or
     |      greater).
     |
     |      ``idletime`` Used for eviction, this is the number of seconds the
     |      key must be idle, prior to execution.
     |
     |      ``frequency`` Used for eviction, this is the frequency counter of
     |      the object stored at the key, prior to execution.
     |
     |      For more information, see https://redis.io/commands/restore
     |
     |  set(self, name: 'KeyT', value: 'EncodableT', ex: 'ExpiryT | None' = None, px: 'ExpiryT | None' = None, nx: 'bool' = False, xx: 'bool' = False, keepttl: 'bool' = False, get: 'bool' = False, exat: 'AbsExpiryT | None' = None, pxat: 'AbsExpiryT | None' = None, ifeq: 'bytes | str | None' = None, ifne: 'bytes | str | None' = None, ifdeq: 'str | None' = None, ifdne: 'str | None' = None) -> 'bool | str | bytes | None | Awaitable[bool | str | bytes | None]'
     |      Set the value at key ``name`` to ``value``
     |
     |      Warning:
     |      **Experimental** since 7.1.
     |      The usage of the arguments ``ifeq``, ``ifne``, ``ifdeq``, and ``ifdne``
     |      is experimental. The API or returned results when those parameters are used
     |      may change based on feedback.
     |
     |      ``ex`` sets an expire flag on key ``name`` for ``ex`` seconds.
     |
     |      ``px`` sets an expire flag on key ``name`` for ``px`` milliseconds.
     |
     |      ``nx`` if set to True, set the value at key ``name`` to ``value`` only
     |          if it does not exist.
     |
     |      ``xx`` if set to True, set the value at key ``name`` to ``value`` only
     |          if it already exists.
     |
     |      ``keepttl`` if True, retain the time to live associated with the key.
     |          (Available since Redis 6.0)
     |
     |      ``get`` if True, set the value at key ``name`` to ``value`` and return
     |          the old value stored at key, or None if the key did not exist.
     |          (Available since Redis 6.2)
     |
     |      ``exat`` sets an expire flag on key ``name`` for ``ex`` seconds,
     |          specified in unix time.
     |
     |      ``pxat`` sets an expire flag on key ``name`` for ``ex`` milliseconds,
     |          specified in unix time.
     |
     |      ``ifeq`` set the value at key ``name`` to ``value`` only if the current
     |          value exactly matches the argument.
     |          If key doesn’t exist - it won’t be created.
     |          (Requires Redis 8.4 or greater)
     |
     |      ``ifne`` set the value at key ``name`` to ``value`` only if the current
     |          value does not exactly match the argument.
     |          If key doesn’t exist - it will be created.
     |          (Requires Redis 8.4 or greater)
     |
     |      ``ifdeq`` set the value at key ``name`` to ``value`` only if the current
     |          value XXH3 hex digest exactly matches the argument.
     |          If key doesn’t exist - it won’t be created.
     |          (Requires Redis 8.4 or greater)
     |
     |      ``ifdne`` set the value at key ``name`` to ``value`` only if the current
     |          value XXH3 hex digest does not exactly match the argument.
     |          If key doesn’t exist - it will be created.
     |          (Requires Redis 8.4 or greater)
     |
     |      For more information, see https://redis.io/commands/set
     |
     |  setbit(self, name: 'KeyT', offset: 'int', value: 'int') -> 'int | Awaitable[int]'
     |      Flag the ``offset`` in ``name`` as ``value``. Returns an integer
     |      indicating the previous value of ``offset``.
     |
     |      For more information, see https://redis.io/commands/setbit
     |
     |  setex(self, name: 'KeyT', time: 'ExpiryT', value: 'EncodableT') -> 'bool | Awaitable[bool]'
     |      Set the value of key ``name`` to ``value`` that expires in ``time``
     |      seconds. ``time`` can be represented by an integer or a Python
     |      timedelta object.
     |
     |      As per Redis 2.6.12, SETEX is considered deprecated.
     |      Please use SET with EX parameter in new code.
     |
     |      For more information, see https://redis.io/commands/setex
     |
     |  setnx(self, name: 'KeyT', value: 'EncodableT') -> 'bool | Awaitable[bool]'
     |      Set the value of key ``name`` to ``value`` if key doesn't exist
     |
     |      For more information, see https://redis.io/commands/setnx
     |
     |  setrange(self, name: 'KeyT', offset: 'int', value: 'EncodableT') -> 'int | Awaitable[int]'
     |      Overwrite bytes in the value of ``name`` starting at ``offset`` with
     |      ``value``. If ``offset`` plus the length of ``value`` exceeds the
     |      length of the original value, the new value will be larger than before.
     |      If ``offset`` exceeds the length of the original value, null bytes
     |      will be used to pad between the end of the previous value and the start
     |      of what's being injected.
     |
     |      Returns the length of the new string.
     |
     |      For more information, see https://redis.io/commands/setrange
     |
     |  stralgo(self, algo: "Literal['LCS']", value1: 'KeyT', value2: 'KeyT', specific_argument: "Literal['strings'] | Literal['keys']" = 'strings', len: 'bool' = False, idx: 'bool' = False, minmatchlen: 'int | None' = None, withmatchlen: 'bool' = False, **kwargs) -> 'StralgoResponse | Awaitable[StralgoResponse]'
     |      Implements complex algorithms that operate on strings.
     |      Right now the only algorithm implemented is the LCS algorithm
     |      (longest common substring). However new algorithms could be
     |      implemented in the future.
     |
     |      ``algo`` Right now must be LCS
     |      ``value1`` and ``value2`` Can be two strings or two keys
     |      ``specific_argument`` Specifying if the arguments to the algorithm
     |      will be keys or strings. strings is the default.
     |      ``len`` Returns just the len of the match.
     |      ``idx`` Returns the match positions in each string.
     |      ``minmatchlen`` Restrict the list of matches to the ones of a given
     |      minimal length. Can be provided only when ``idx`` set to True.
     |      ``withmatchlen`` Returns the matches with the len of the match.
     |      Can be provided only when ``idx`` set to True.
     |
     |      For more information, see https://redis.io/commands/stralgo
     |
     |  strlen(self, name: 'KeyT') -> 'int | Awaitable[int]'
     |      Return the number of bytes stored in the value of ``name``
     |
     |      For more information, see https://redis.io/commands/strlen
     |
     |  substr(self, name: 'KeyT', start: 'int', end: 'int' = -1) -> 'bytes | str | Awaitable[bytes | str]'
     |      Return a substring of the string at key ``name``. ``start`` and ``end``
     |      are 0-based integers specifying the portion of the string to return.
     |
     |  touch(self, *args: 'KeyT') -> 'int | Awaitable[int]'
     |      Alters the last access time of a key(s) ``*args``. A key is ignored
     |      if it does not exist.
     |
     |      For more information, see https://redis.io/commands/touch
     |
     |  ttl(self, name: 'KeyT') -> 'int | Awaitable[int]'
     |      Returns the number of seconds until the key ``name`` will expire
     |
     |      For more information, see https://redis.io/commands/ttl
     |
     |  type(self, name: 'KeyT') -> 'bytes | str | Awaitable[bytes | str]'
     |      Returns the type of key ``name``
     |
     |      For more information, see https://redis.io/commands/type
     |
     |  unlink(self, *names: 'KeyT') -> 'int | Awaitable[int]'
     |      Unlink one or more keys specified by ``names``
     |
     |      For more information, see https://redis.io/commands/unlink
     |
     |  unwatch(self) -> 'None'
     |      Unwatches all previously watched keys for a transaction
     |
     |      For more information, see https://redis.io/commands/unwatch
     |
     |  watch(self, *names: 'KeyT') -> 'None'
     |      Watches the values at keys ``names``, or None if the key doesn't exist
     |
     |      For more information, see https://redis.io/commands/watch
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from HyperlogCommands:
     |
     |  pfadd(self, name: 'KeyT', *values: 'FieldT') -> 'int | Awaitable[int]'
     |      Adds the specified elements to the specified HyperLogLog.
     |
     |      For more information, see https://redis.io/commands/pfadd
     |
     |  pfcount(self, *sources: 'KeyT') -> 'int | Awaitable[int]'
     |      Return the approximated cardinality of
     |      the set observed by the HyperLogLog at key(s).
     |
     |      For more information, see https://redis.io/commands/pfcount
     |
     |  pfmerge(self, dest: 'KeyT', *sources: 'KeyT') -> 'bool | Awaitable[bool]'
     |      Merge N different HyperLogLogs into a single one.
     |
     |      For more information, see https://redis.io/commands/pfmerge
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from HashCommands:
     |
     |  hdel(self, name: 'KeyT', *keys: 'FieldT') -> 'int | Awaitable[int]'
     |      Delete ``keys`` from hash ``name``
     |
     |      For more information, see https://redis.io/commands/hdel
     |
     |  hexists(self, name: 'KeyT', key: 'FieldT') -> 'bool | Awaitable[bool]'
     |      Returns a boolean indicating if ``key`` exists within hash ``name``
     |
     |      For more information, see https://redis.io/commands/hexists
     |
     |  hexpire(self, name: 'KeyT', seconds: 'ExpiryT', *fields: 'FieldT', nx: 'bool' = False, xx: 'bool' = False, gt: 'bool' = False, lt: 'bool' = False) -> 'list[int] | Awaitable[list[int]]'
     |      Sets or updates the expiration time for fields within a hash key, using relative
     |      time in seconds.
     |
     |      If a field already has an expiration time, the behavior of the update can be
     |      controlled using the `nx`, `xx`, `gt`, and `lt` parameters.
     |
     |      The return value provides detailed information about the outcome for each field.
     |
     |      For more information, see https://redis.io/commands/hexpire
     |
     |      Args:
     |          name: The name of the hash key.
     |          seconds: Expiration time in seconds, relative. Can be an integer, or a
     |                   Python `timedelta` object.
     |          fields: List of fields within the hash to apply the expiration time to.
     |          nx: Set expiry only when the field has no expiry.
     |          xx: Set expiry only when the field has an existing expiry.
     |          gt: Set expiry only when the new expiry is greater than the current one.
     |          lt: Set expiry only when the new expiry is less than the current one.
     |
     |      Returns:
     |          Returns a list which contains for each field in the request:
     |              - `-2` if the field does not exist, or if the key does not exist.
     |              - `0` if the specified NX | XX | GT | LT condition was not met.
     |              - `1` if the expiration time was set or updated.
     |              - `2` if the field was deleted because the specified expiration time is
     |                in the past.
     |
     |  hexpireat(self, name: 'KeyT', unix_time_seconds: 'AbsExpiryT', *fields: 'FieldT', nx: 'bool' = False, xx: 'bool' = False, gt: 'bool' = False, lt: 'bool' = False) -> 'list[int] | Awaitable[list[int]]'
     |      Sets or updates the expiration time for fields within a hash key, using an
     |      absolute Unix timestamp in seconds.
     |
     |      If a field already has an expiration time, the behavior of the update can be
     |      controlled using the `nx`, `xx`, `gt`, and `lt` parameters.
     |
     |      The return value provides detailed information about the outcome for each field.
     |
     |      For more information, see https://redis.io/commands/hexpireat
     |
     |      Args:
     |          name: The name of the hash key.
     |          unix_time_seconds: Expiration time as Unix timestamp in seconds. Can be an
     |                             integer or a Python `datetime` object.
     |          fields: List of fields within the hash to apply the expiration time to.
     |          nx: Set expiry only when the field has no expiry.
     |          xx: Set expiry only when the field has an existing expiration time.
     |          gt: Set expiry only when the new expiry is greater than the current one.
     |          lt: Set expiry only when the new expiry is less than the current one.
     |
     |      Returns:
     |          Returns a list which contains for each field in the request:
     |              - `-2` if the field does not exist, or if the key does not exist.
     |              - `0` if the specified NX | XX | GT | LT condition was not met.
     |              - `1` if the expiration time was set or updated.
     |              - `2` if the field was deleted because the specified expiration time is
     |                in the past.
     |
     |  hexpiretime(self, key: 'KeyT', *fields: 'FieldT') -> 'list[int] | Awaitable[list[int]]'
     |      Returns the expiration times of hash fields as Unix timestamps in seconds.
     |
     |      For more information, see https://redis.io/commands/hexpiretime
     |
     |      Args:
     |          key: The hash key.
     |          fields: A list of fields within the hash for which to get the expiration
     |                  time.
     |
     |      Returns:
     |          Returns a list which contains for each field in the request:
     |              - `-2` if the field does not exist, or if the key does not exist.
     |              - `-1` if the field exists but has no associated expire time.
     |              - A positive integer representing the expiration Unix timestamp in
     |                seconds, if the field has an associated expiration time.
     |
     |  hget(self, name: 'KeyT', key: 'FieldT') -> 'bytes | str | None | Awaitable[bytes | str | None]'
     |      Return the value of ``key`` within the hash ``name``
     |
     |      For more information, see https://redis.io/commands/hget
     |
     |  hgetall(self, name: 'KeyT') -> 'dict[bytes | str, bytes | str] | Awaitable[dict[bytes | str, bytes | str]]'
     |      Return a Python dict of the hash's name/value pairs
     |
     |      For more information, see https://redis.io/commands/hgetall
     |
     |  hgetdel(self, name: 'KeyT', *keys: 'FieldT') -> 'list[bytes | str | None] | Awaitable[list[bytes | str | None]]'
     |      Return the value of ``key`` within the hash ``name`` and
     |      delete the field in the hash.
     |      This command is similar to HGET, except for the fact that it also deletes
     |      the key on success from the hash with the provided ```name```.
     |
     |      Available since Redis 8.0
     |      For more information, see https://redis.io/commands/hgetdel
     |
     |  hgetex(self, name: 'KeyT', *keys: 'FieldT', ex: 'ExpiryT | None' = None, px: 'ExpiryT | None' = None, exat: 'AbsExpiryT | None' = None, pxat: 'AbsExpiryT | None' = None, persist: 'bool' = False) -> 'list[bytes | str | None] | Awaitable[list[bytes | str | None]]'
     |      Return the values of ``key`` and ``keys`` within the hash ``name``
     |      and optionally set their expiration.
     |
     |      ``ex`` sets an expire flag on ``kyes`` for ``ex`` seconds.
     |
     |      ``px`` sets an expire flag on ``keys`` for ``px`` milliseconds.
     |
     |      ``exat`` sets an expire flag on ``keys`` for ``ex`` seconds,
     |      specified in unix time.
     |
     |      ``pxat`` sets an expire flag on ``keys`` for ``ex`` milliseconds,
     |      specified in unix time.
     |
     |      ``persist`` remove the time to live associated with the ``keys``.
     |
     |      Available since Redis 8.0
     |      For more information, see https://redis.io/commands/hgetex
     |
     |  himport_discard_all_internal(self) -> 'int | Awaitable[int]'
     |      Send ``HIMPORT DISCARDALL`` (returns the number of fieldsets removed).
     |
     |      .. warning::
     |          Internal wire mapping — not for direct use on a pooled client. It
     |          DISCARDs on a single arbitrary borrowed connection and bypasses the
     |          client's shared fieldset registry, leaving other connections and the
     |          registry out of sync. Use the client's ``himport_discard_all`` instead;
     |          call this only on a pinned single-connection client where you manage
     |          session state yourself.
     |
     |  himport_discard_internal(self, fieldset_name: 'str') -> 'int | Awaitable[int]'
     |      Send ``HIMPORT DISCARD fieldset_name`` (``1`` removed, ``0`` not found).
     |
     |      .. warning::
     |          Internal wire mapping — not for direct use on a pooled client. It
     |          DISCARDs on a single arbitrary borrowed connection and bypasses the
     |          client's shared fieldset registry, leaving other connections and the
     |          registry out of sync. Use the client's ``himport_discard`` instead; call
     |          this only on a pinned single-connection client where you manage session
     |          state yourself.
     |
     |  himport_prepare_internal(self, fieldset_name: 'str', fields: 'Iterable[FieldT]') -> 'bool | Awaitable[bool]'
     |      Send ``HIMPORT PREPARE fieldset_name field [field ...]``.
     |
     |      Registers the ordered field list under ``fieldset_name`` in the executing
     |      connection's session. Fields are sent in the caller's order, unmodified.
     |
     |      .. warning::
     |          Internal wire mapping — not for direct use on a pooled client. It
     |          PREPAREs on a single arbitrary borrowed connection and bypasses the
     |          client's shared fieldset registry, so other connections stay unaware and
     |          reintroduce the nondeterministic "no such fieldset" the HIMPORT design
     |          prevents. Use the client's ``himport_prepare`` instead; call this only
     |          on a pinned single-connection client where you manage session state
     |          yourself.
     |
     |  himport_set(self, key: 'KeyT', fieldset_name: 'str', values: 'Iterable[EncodableT]') -> 'bool | Awaitable[bool]'
     |      Create/replace ``key`` as a hash using ``fieldset_name``'s field list.
     |
     |      Values are sent in the caller's order and map positionally to the prepared
     |      fields. The fieldset is prepared on the serving connection on first use
     |      (PREPARE bundled with SET in one write) and reused on subsequent calls;
     |      runtime discards are reconciled on the next use of the connection. All of
     |      this happens inside the normal command path, so retry, disconnect-on-error
     |      and (for the cluster) routing / MOVED-ASK apply exactly as for any command.
     |
     |      .. note::
     |          Recovery from a mid-connection fieldset loss (the server dropping the
     |          prepared fieldset without dropping the socket, e.g. ``RESET`` or
     |          ``maxmemory-clients`` eviction) applies only to a standalone
     |          ``himport_set`` call: it catches the resulting ``no such fieldset`` and
     |          re-prepares on the same socket, retrying the SET once. A ``himport_set``
     |          buffered in a **pipeline or transaction** has no such per-command
     |          recovery — its fieldset is PREPAREd once as a pre-flight before the
     |          batch, and if the server loses it between that pre-flight and the batch
     |          the SET fails and surfaces as an error in the batch results. Callers who
     |          need the automatic recovery should issue those sets outside a pipeline.
     |
     |  hincrby(self, name: 'KeyT', key: 'FieldT', amount: 'int' = 1) -> 'int | Awaitable[int]'
     |      Increment the value of ``key`` in hash ``name`` by ``amount``
     |
     |      For more information, see https://redis.io/commands/hincrby
     |
     |  hincrbyfloat(self, name: 'KeyT', key: 'FieldT', amount: 'float' = 1.0) -> 'float | Awaitable[float]'
     |      Increment the value of ``key`` in hash ``name`` by floating ``amount``
     |
     |      For more information, see https://redis.io/commands/hincrbyfloat
     |
     |  hkeys(self, name: 'KeyT') -> 'list[bytes | str] | Awaitable[list[bytes | str]]'
     |      Return the list of keys within hash ``name``
     |
     |      For more information, see https://redis.io/commands/hkeys
     |
     |  hlen(self, name: 'KeyT') -> 'int | Awaitable[int]'
     |      Return the number of elements in hash ``name``
     |
     |      For more information, see https://redis.io/commands/hlen
     |
     |  hmget(self, name: 'KeyT', keys: 'FieldT | Iterable[FieldT]', *args: 'FieldT') -> 'list[bytes | str | None] | Awaitable[list[bytes | str | None]]'
     |      Returns a list of values ordered identically to ``keys``
     |
     |      For more information, see https://redis.io/commands/hmget
     |
     |  hmset(self, name: 'KeyT', mapping: 'Mapping[FieldT, EncodableT]') -> 'bool | Awaitable[bool]'
     |      Set key to value within hash ``name`` for each corresponding
     |      key and value from the ``mapping`` dict.
     |
     |      For more information, see https://redis.io/commands/hmset
     |
     |  hpersist(self, name: 'KeyT', *fields: 'FieldT') -> 'list[int] | Awaitable[list[int]]'
     |      Removes the expiration time for each specified field in a hash.
     |
     |      For more information, see https://redis.io/commands/hpersist
     |
     |      Args:
     |          name: The name of the hash key.
     |          fields: A list of fields within the hash from which to remove the
     |                  expiration time.
     |
     |      Returns:
     |          Returns a list which contains for each field in the request:
     |              - `-2` if the field does not exist, or if the key does not exist.
     |              - `-1` if the field exists but has no associated expiration time.
     |              - `1` if the expiration time was successfully removed from the field.
     |
     |  hpexpire(self, name: 'KeyT', milliseconds: 'ExpiryT', *fields: 'FieldT', nx: 'bool' = False, xx: 'bool' = False, gt: 'bool' = False, lt: 'bool' = False) -> 'list[int] | Awaitable[list[int]]'
     |      Sets or updates the expiration time for fields within a hash key, using relative
     |      time in milliseconds.
     |
     |      If a field already has an expiration time, the behavior of the update can be
     |      controlled using the `nx`, `xx`, `gt`, and `lt` parameters.
     |
     |      The return value provides detailed information about the outcome for each field.
     |
     |      For more information, see https://redis.io/commands/hpexpire
     |
     |      Args:
     |          name: The name of the hash key.
     |          milliseconds: Expiration time in milliseconds, relative. Can be an integer,
     |                        or a Python `timedelta` object.
     |          fields: List of fields within the hash to apply the expiration time to.
     |          nx: Set expiry only when the field has no expiry.
     |          xx: Set expiry only when the field has an existing expiry.
     |          gt: Set expiry only when the new expiry is greater than the current one.
     |          lt: Set expiry only when the new expiry is less than the current one.
     |
     |      Returns:
     |          Returns a list which contains for each field in the request:
     |              - `-2` if the field does not exist, or if the key does not exist.
     |              - `0` if the specified NX | XX | GT | LT condition was not met.
     |              - `1` if the expiration time was set or updated.
     |              - `2` if the field was deleted because the specified expiration time is
     |                in the past.
     |
     |  hpexpireat(self, name: 'KeyT', unix_time_milliseconds: 'AbsExpiryT', *fields: 'FieldT', nx: 'bool' = False, xx: 'bool' = False, gt: 'bool' = False, lt: 'bool' = False) -> 'list[int] | Awaitable[list[int]]'
     |      Sets or updates the expiration time for fields within a hash key, using an
     |      absolute Unix timestamp in milliseconds.
     |
     |      If a field already has an expiration time, the behavior of the update can be
     |      controlled using the `nx`, `xx`, `gt`, and `lt` parameters.
     |
     |      The return value provides detailed information about the outcome for each field.
     |
     |      For more information, see https://redis.io/commands/hpexpireat
     |
     |      Args:
     |          name: The name of the hash key.
     |          unix_time_milliseconds: Expiration time as Unix timestamp in milliseconds.
     |                                  Can be an integer or a Python `datetime` object.
     |          fields: List of fields within the hash to apply the expiry.
     |          nx: Set expiry only when the field has no expiry.
     |          xx: Set expiry only when the field has an existing expiry.
     |          gt: Set expiry only when the new expiry is greater than the current one.
     |          lt: Set expiry only when the new expiry is less than the current one.
     |
     |      Returns:
     |          Returns a list which contains for each field in the request:
     |              - `-2` if the field does not exist, or if the key does not exist.
     |              - `0` if the specified NX | XX | GT | LT condition was not met.
     |              - `1` if the expiration time was set or updated.
     |              - `2` if the field was deleted because the specified expiration time is
     |                in the past.
     |
     |  hpexpiretime(self, key: 'KeyT', *fields: 'FieldT') -> 'list[int] | Awaitable[list[int]]'
     |      Returns the expiration times of hash fields as Unix timestamps in milliseconds.
     |
     |      For more information, see https://redis.io/commands/hpexpiretime
     |
     |      Args:
     |          key: The hash key.
     |          fields: A list of fields within the hash for which to get the expiration
     |                  time.
     |
     |      Returns:
     |          Returns a list which contains for each field in the request:
     |              - `-2` if the field does not exist, or if the key does not exist.
     |              - `-1` if the field exists but has no associated expire time.
     |              - A positive integer representing the expiration Unix timestamp in
     |                milliseconds, if the field has an associated expiration time.
     |
     |  hpttl(self, key: 'KeyT', *fields: 'FieldT') -> 'list[int] | Awaitable[list[int]]'
     |      Returns the TTL (Time To Live) in milliseconds for each specified field within a
     |      hash key.
     |
     |      For more information, see https://redis.io/commands/hpttl
     |
     |      Args:
     |          key: The hash key.
     |          fields: A list of fields within the hash for which to get the TTL.
     |
     |      Returns:
     |          Returns a list which contains for each field in the request:
     |              - `-2` if the field does not exist, or if the key does not exist.
     |              - `-1` if the field exists but has no associated expire time.
     |              - A positive integer representing the TTL in milliseconds if the field
     |                has an associated expiration time.
     |
     |  hset(self, name: 'KeyT', key: 'FieldT | None' = None, value: 'EncodableT | None' = None, mapping: 'Mapping[FieldT, EncodableT] | None' = None, items: 'Sequence[EncodableT] | None' = None) -> 'int | Awaitable[int]'
     |      Set ``key`` to ``value`` within hash ``name``,
     |      ``mapping`` accepts a dict of key/value pairs that will be
     |      added to hash ``name``.
     |      ``items`` accepts a list of key/value pairs that will be
     |      added to hash ``name``.
     |      Returns the number of fields that were added.
     |
     |      For more information, see https://redis.io/commands/hset
     |
     |  hsetex(self, name: 'KeyT', key: 'FieldT | None' = None, value: 'EncodableT | None' = None, mapping: 'Mapping[FieldT, EncodableT] | None' = None, items: 'Sequence[EncodableT] | None' = None, ex: 'ExpiryT | None' = None, px: 'ExpiryT | None' = None, exat: 'AbsExpiryT | None' = None, pxat: 'AbsExpiryT | None' = None, data_persist_option: 'HashDataPersistOptions | None' = None, keepttl: 'bool' = False) -> 'int | Awaitable[int]'
     |      Set ``key`` to ``value`` within hash ``name``
     |
     |      ``mapping`` accepts a dict of key/value pairs that will be
     |      added to hash ``name``.
     |
     |      ``items`` accepts a list of key/value pairs that will be
     |      added to hash ``name``.
     |
     |      ``ex`` sets an expire flag on ``keys`` for ``ex`` seconds.
     |
     |      ``px`` sets an expire flag on ``keys`` for ``px`` milliseconds.
     |
     |      ``exat`` sets an expire flag on ``keys`` for ``ex`` seconds,
     |          specified in unix time.
     |
     |      ``pxat`` sets an expire flag on ``keys`` for ``ex`` milliseconds,
     |          specified in unix time.
     |
     |      ``data_persist_option`` can be set to ``FNX`` or ``FXX`` to control the
     |          behavior of the command.
     |          ``FNX`` will set the value for each provided key to each
     |              provided value only if all do not already exist.
     |          ``FXX`` will set the value for each provided key to each
     |              provided value only if all already exist.
     |
     |      ``keepttl`` if True, retain the time to live associated with the keys.
     |
     |      Returns the number of fields that were added.
     |
     |      Available since Redis 8.0
     |      For more information, see https://redis.io/commands/hsetex
     |
     |  hsetnx(self, name: 'KeyT', key: 'FieldT', value: 'EncodableT') -> 'int | Awaitable[int]'
     |      Set ``key`` to ``value`` within hash ``name`` if ``key`` does not
     |      exist.  Returns 1 if HSETNX created a field, otherwise 0.
     |
     |      For more information, see https://redis.io/commands/hsetnx
     |
     |  hstrlen(self, name: 'KeyT', key: 'FieldT') -> 'int | Awaitable[int]'
     |      Return the number of bytes stored in the value of ``key``
     |      within hash ``name``
     |
     |      For more information, see https://redis.io/commands/hstrlen
     |
     |  httl(self, key: 'KeyT', *fields: 'FieldT') -> 'list[int] | Awaitable[list[int]]'
     |      Returns the TTL (Time To Live) in seconds for each specified field within a hash
     |      key.
     |
     |      For more information, see https://redis.io/commands/httl
     |
     |      Args:
     |          key: The hash key.
     |          fields: A list of fields within the hash for which to get the TTL.
     |
     |      Returns:
     |          Returns a list which contains for each field in the request:
     |              - `-2` if the field does not exist, or if the key does not exist.
     |              - `-1` if the field exists but has no associated expire time.
     |              - A positive integer representing the TTL in seconds if the field has
     |                an associated expiration time.
     |
     |  hvals(self, name: 'KeyT') -> 'list[bytes | str] | Awaitable[list[bytes | str]]'
     |      Return the list of values within hash ``name``
     |
     |      For more information, see https://redis.io/commands/hvals
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from GeoCommands:
     |
     |  geoadd(self, name: 'KeyT', values: 'Sequence[EncodableT]', nx: 'bool' = False, xx: 'bool' = False, ch: 'bool' = False) -> 'int | Awaitable[int]'
     |      Add the specified geospatial items to the specified key identified
     |      by the ``name`` argument. The Geospatial items are given as ordered
     |      members of the ``values`` argument, each item or place is formed by
     |      the triad longitude, latitude and name.
     |
     |      Note: You can use ZREM to remove elements.
     |
     |      ``nx`` forces ZADD to only create new elements and not to update
     |      scores for elements that already exist.
     |
     |      ``xx`` forces ZADD to only update scores of elements that already
     |      exist. New elements will not be added.
     |
     |      ``ch`` modifies the return value to be the numbers of elements changed.
     |      Changed elements include new elements that were added and elements
     |      whose scores changed.
     |
     |      For more information, see https://redis.io/commands/geoadd
     |
     |  geodist(self, name: 'KeyT', place1: 'FieldT', place2: 'FieldT', unit: 'str | None' = None) -> 'float | None | Awaitable[float | None]'
     |      Return the distance between ``place1`` and ``place2`` members of the
     |      ``name`` key.
     |      The units must be one of the following : m, km mi, ft. By default
     |      meters are used.
     |
     |      For more information, see https://redis.io/commands/geodist
     |
     |  geohash(self, name: 'KeyT', *values: 'FieldT') -> 'list[bytes | str | None] | Awaitable[list[bytes | str | None]]'
     |      Return the geo hash string for each item of ``values`` members of
     |      the specified key identified by the ``name`` argument.
     |
     |      For more information, see https://redis.io/commands/geohash
     |
     |  geopos(self, name: 'KeyT', *values: 'FieldT') -> 'list[GeoCoordinate | None] | Awaitable[list[GeoCoordinate | None]]'
     |      Return the positions of each item of ``values`` as members of
     |      the specified key identified by the ``name`` argument. Each position
     |      is represented by the pairs lon and lat.
     |
     |      For more information, see https://redis.io/commands/geopos
     |
     |  georadius(self, name: 'KeyT', longitude: 'float', latitude: 'float', radius: 'float', unit: 'str | None' = None, withdist: 'bool' = False, withcoord: 'bool' = False, withhash: 'bool' = False, count: 'int | None' = None, sort: 'str | None' = None, store: 'KeyT | None' = None, store_dist: 'KeyT | None' = None, any: 'bool' = False) -> 'GeoRadiusResponse | Awaitable[GeoRadiusResponse]'
     |      Return the members of the specified key identified by the
     |      ``name`` argument which are within the borders of the area specified
     |      with the ``latitude`` and ``longitude`` location and the maximum
     |      distance from the center specified by the ``radius`` value.
     |
     |      The units must be one of the following : m, km mi, ft. By default
     |
     |      ``withdist`` indicates to return the distances of each place.
     |
     |      ``withcoord`` indicates to return the latitude and longitude of
     |      each place.
     |
     |      ``withhash`` indicates to return the geohash string of each place.
     |
     |      ``count`` indicates to return the number of elements up to N.
     |
     |      ``sort`` indicates to return the places in a sorted way, ASC for
     |      nearest to fairest and DESC for fairest to nearest.
     |
     |      ``store`` indicates to save the places names in a sorted set named
     |      with a specific key, each element of the destination sorted set is
     |      populated with the score got from the original geo sorted set.
     |
     |      ``store_dist`` indicates to save the places names in a sorted set
     |      named with a specific key, instead of ``store`` the sorted set
     |      destination score is set with the distance.
     |
     |      For more information, see https://redis.io/commands/georadius
     |
     |  georadiusbymember(self, name: 'KeyT', member: 'FieldT', radius: 'float', unit: 'str | None' = None, withdist: 'bool' = False, withcoord: 'bool' = False, withhash: 'bool' = False, count: 'int | None' = None, sort: 'str | None' = None, store: 'Union[KeyT, None]' = None, store_dist: 'Union[KeyT, None]' = None, any: 'bool' = False) -> 'GeoRadiusResponse | Awaitable[GeoRadiusResponse]'
     |      This command is exactly like ``georadius`` with the sole difference
     |      that instead of taking, as the center of the area to query, a longitude
     |      and latitude value, it takes the name of a member already existing
     |      inside the geospatial index represented by the sorted set.
     |
     |      For more information, see https://redis.io/commands/georadiusbymember
     |
     |  geosearch(self, name: 'KeyT', member: 'FieldT | None' = None, longitude: 'float | None' = None, latitude: 'float | None' = None, unit: 'str' = 'm', radius: 'float | None' = None, width: 'float | None' = None, height: 'float | None' = None, sort: 'str | None' = None, count: 'int | None' = None, any: 'bool' = False, withcoord: 'bool' = False, withdist: 'bool' = False, withhash: 'bool' = False) -> 'GeoSearchResponse | Awaitable[GeoSearchResponse]'
     |      Return the members of specified key identified by the
     |      ``name`` argument, which are within the borders of the
     |      area specified by a given shape. This command extends the
     |      GEORADIUS command, so in addition to searching within circular
     |      areas, it supports searching within rectangular areas.
     |
     |      This command should be used in place of the deprecated
     |      GEORADIUS and GEORADIUSBYMEMBER commands.
     |
     |      ``member`` Use the position of the given existing
     |       member in the sorted set. Can't be given with ``longitude``
     |       and ``latitude``.
     |
     |      ``longitude`` and ``latitude`` Use the position given by
     |      this coordinates. Can't be given with ``member``
     |      ``radius`` Similar to GEORADIUS, search inside circular
     |      area according the given radius. Can't be given with
     |      ``height`` and ``width``.
     |      ``height`` and ``width`` Search inside an axis-aligned
     |      rectangle, determined by the given height and width.
     |      Can't be given with ``radius``
     |
     |      ``unit`` must be one of the following : m, km, mi, ft.
     |      `m` for meters (the default value), `km` for kilometers,
     |      `mi` for miles and `ft` for feet.
     |
     |      ``sort`` indicates to return the places in a sorted way,
     |      ASC for nearest to furthest and DESC for furthest to nearest.
     |
     |      ``count`` limit the results to the first count matching items.
     |
     |      ``any`` is set to True, the command will return as soon as
     |      enough matches are found. Can't be provided without ``count``
     |
     |      ``withdist`` indicates to return the distances of each place.
     |      ``withcoord`` indicates to return the latitude and longitude of
     |      each place.
     |
     |      ``withhash`` indicates to return the geohash string of each place.
     |
     |      For more information, see https://redis.io/commands/geosearch
     |
     |  geosearchstore(self, dest: 'KeyT', name: 'KeyT', member: 'FieldT | None' = None, longitude: 'float | None' = None, latitude: 'float | None' = None, unit: 'str' = 'm', radius: 'float | None' = None, width: 'float | None' = None, height: 'float | None' = None, sort: 'str | None' = None, count: 'int | None' = None, any: 'bool' = False, storedist: 'bool' = False) -> 'int | Awaitable[int]'
     |      This command is like GEOSEARCH, but stores the result in
     |      ``dest``. By default, it stores the results in the destination
     |      sorted set with their geospatial information.
     |      if ``store_dist`` set to True, the command will stores the
     |      items in a sorted set populated with their distance from the
     |      center of the circle or box, as a floating-point number.
     |
     |      For more information, see https://redis.io/commands/geosearchstore
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from ListCommands:
     |
     |  blmpop(self, timeout: 'float', numkeys: 'int', *args: 'str', direction: 'str', count: 'int | None' = 1) -> 'ListMultiPopResponse | Awaitable[ListMultiPopResponse]'
     |      Pop ``count`` values (default 1) from first non-empty in the list
     |      of provided key names.
     |
     |      When all lists are empty this command blocks the connection until another
     |      client pushes to it or until the timeout, timeout of 0 blocks indefinitely
     |
     |      For more information, see https://redis.io/commands/blmpop
     |
     |  blpop(self, keys: 'KeysT', timeout: 'Number | None' = 0) -> 'BlockingListPopResponse | Awaitable[BlockingListPopResponse]'
     |      LPOP a value off of the first non-empty list
     |      named in ``keys``.
     |
     |      If none of the lists in ``keys`` has a value to LPOP, then block
     |      for ``timeout`` seconds, or until a value gets pushed on to one
     |      of the lists.
     |
     |      If timeout is 0, then block indefinitely.
     |
     |      For more information, see https://redis.io/commands/blpop
     |
     |  brpop(self, keys: 'KeysT', timeout: 'Number | None' = 0) -> 'BlockingListPopResponse | Awaitable[BlockingListPopResponse]'
     |      RPOP a value off of the first non-empty list
     |      named in ``keys``.
     |
     |      If none of the lists in ``keys`` has a value to RPOP, then block
     |      for ``timeout`` seconds, or until a value gets pushed on to one
     |      of the lists.
     |
     |      If timeout is 0, then block indefinitely.
     |
     |      For more information, see https://redis.io/commands/brpop
     |
     |  brpoplpush(self, src: 'KeyT', dst: 'KeyT', timeout: 'Number | None' = 0) -> 'bytes | str | None | Awaitable[bytes | str | None]'
     |      Pop a value off the tail of ``src``, push it on the head of ``dst``
     |      and then return it.
     |
     |      This command blocks until a value is in ``src`` or until ``timeout``
     |      seconds elapse, whichever is first. A ``timeout`` value of 0 blocks
     |      forever.
     |
     |      For more information, see https://redis.io/commands/brpoplpush
     |
     |  lindex(self, name: 'KeyT', index: 'int') -> 'bytes | str | None | Awaitable[bytes | str | None]'
     |      Return the item from list ``name`` at position ``index``
     |
     |      Negative indexes are supported and will return an item at the
     |      end of the list
     |
     |      For more information, see https://redis.io/commands/lindex
     |
     |  linsert(self, name: 'KeyT', where: 'str', refvalue: 'str', value: 'str') -> 'int | Awaitable[int]'
     |      Insert ``value`` in list ``name`` either immediately before or after
     |      [``where``] ``refvalue``
     |
     |      Returns the new length of the list on success or -1 if ``refvalue``
     |      is not in the list.
     |
     |      For more information, see https://redis.io/commands/linsert
     |
     |  llen(self, name: 'KeyT') -> 'int | Awaitable[int]'
     |      Return the length of the list ``name``
     |
     |      For more information, see https://redis.io/commands/llen
     |
     |  lmpop(self, num_keys: 'int', *args: 'str', direction: 'str', count: 'int | None' = 1) -> 'ListMultiPopResponse | Awaitable[ListMultiPopResponse]'
     |      Pop ``count`` values (default 1) first non-empty list key from the list
     |      of args provided key names.
     |
     |      For more information, see https://redis.io/commands/lmpop
     |
     |  lpop(self, name: 'KeyT', count: 'int | None' = None) -> 'bytes | str | list[bytes | str] | None | Awaitable[bytes | str | list[bytes | str] | None]'
     |      Removes and returns the first elements of the list ``name``.
     |
     |      By default, the command pops a single element from the beginning of
     |      the list. When provided with the optional ``count`` argument, the reply
     |      will consist of up to count elements, depending on the list's length.
     |
     |      For more information, see https://redis.io/commands/lpop
     |
     |  lpos(self, name: 'KeyT', value: 'str', rank: 'int | None' = None, count: 'int | None' = None, maxlen: 'int | None' = None) -> 'int | list[int] | None | Awaitable[int | list[int] | None]'
     |      Get position of ``value`` within the list ``name``
     |
     |       If specified, ``rank`` indicates the "rank" of the first element to
     |       return in case there are multiple copies of ``value`` in the list.
     |       By default, LPOS returns the position of the first occurrence of
     |       ``value`` in the list. When ``rank`` 2, LPOS returns the position of
     |       the second ``value`` in the list. If ``rank`` is negative, LPOS
     |       searches the list in reverse. For example, -1 would return the
     |       position of the last occurrence of ``value`` and -2 would return the
     |       position of the next to last occurrence of ``value``.
     |
     |       If specified, ``count`` indicates that LPOS should return a list of
     |       up to ``count`` positions. A ``count`` of 2 would return a list of
     |       up to 2 positions. A ``count`` of 0 returns a list of all positions
     |       matching ``value``. When ``count`` is specified and but ``value``
     |       does not exist in the list, an empty list is returned.
     |
     |       If specified, ``maxlen`` indicates the maximum number of list
     |       elements to scan. A ``maxlen`` of 1000 will only return the
     |       position(s) of items within the first 1000 entries in the list.
     |       A ``maxlen`` of 0 (the default) will scan the entire list.
     |
     |       For more information, see https://redis.io/commands/lpos
     |
     |  lpush(self, name: 'KeyT', *values: 'FieldT') -> 'int | Awaitable[int]'
     |      Push ``values`` onto the head of the list ``name``
     |
     |      For more information, see https://redis.io/commands/lpush
     |
     |  lpushx(self, name: 'KeyT', *values: 'FieldT') -> 'int | Awaitable[int]'
     |      Push ``value`` onto the head of the list ``name`` if ``name`` exists
     |
     |      For more information, see https://redis.io/commands/lpushx
     |
     |  lrange(self, name: 'KeyT', start: 'int', end: 'int') -> 'list[bytes | str] | Awaitable[list[bytes | str]]'
     |      Return a slice of the list ``name`` between
     |      position ``start`` and ``end``
     |
     |      ``start`` and ``end`` can be negative numbers just like
     |      Python slicing notation
     |
     |      For more information, see https://redis.io/commands/lrange
     |
     |  lrem(self, name: 'KeyT', count: 'int', value: 'str') -> 'int | Awaitable[int]'
     |      Remove the first ``count`` occurrences of elements equal to ``value``
     |      from the list stored at ``name``.
     |
     |      The count argument influences the operation in the following ways:
     |          count > 0: Remove elements equal to value moving from head to tail.
     |          count < 0: Remove elements equal to value moving from tail to head.
     |          count = 0: Remove all elements equal to value.
     |
     |          For more information, see https://redis.io/commands/lrem
     |
     |  lset(self, name: 'KeyT', index: 'int', value: 'str') -> 'bool | Awaitable[bool]'
     |      Set element at ``index`` of list ``name`` to ``value``
     |
     |      For more information, see https://redis.io/commands/lset
     |
     |  ltrim(self, name: 'KeyT', start: 'int', end: 'int') -> 'bool | Awaitable[bool]'
     |      Trim the list ``name``, removing all values not within the slice
     |      between ``start`` and ``end``
     |
     |      ``start`` and ``end`` can be negative numbers just like
     |      Python slicing notation
     |
     |      For more information, see https://redis.io/commands/ltrim
     |
     |  rpop(self, name: 'KeyT', count: 'int | None' = None) -> 'bytes | str | list[bytes | str] | None | Awaitable[bytes | str | list[bytes | str] | None]'
     |      Removes and returns the last elements of the list ``name``.
     |
     |      By default, the command pops a single element from the end of the list.
     |      When provided with the optional ``count`` argument, the reply will
     |      consist of up to count elements, depending on the list's length.
     |
     |      For more information, see https://redis.io/commands/rpop
     |
     |  rpoplpush(self, src: 'KeyT', dst: 'KeyT') -> 'bytes | str | None | Awaitable[bytes | str | None]'
     |      RPOP a value off of the ``src`` list and atomically LPUSH it
     |      on to the ``dst`` list.  Returns the value.
     |
     |      For more information, see https://redis.io/commands/rpoplpush
     |
     |  rpush(self, name: 'KeyT', *values: 'FieldT') -> 'int | Awaitable[int]'
     |      Push ``values`` onto the tail of the list ``name``
     |
     |      For more information, see https://redis.io/commands/rpush
     |
     |  rpushx(self, name: 'KeyT', *values: 'str') -> 'int | Awaitable[int]'
     |      Push ``value`` onto the tail of the list ``name`` if ``name`` exists
     |
     |      For more information, see https://redis.io/commands/rpushx
     |
     |  sort(self, name: 'KeyT', start: 'int | None' = None, num: 'int | None' = None, by: 'str | None' = None, get: 'list[str] | None' = None, desc: 'bool' = False, alpha: 'bool' = False, store: 'str | None' = None, groups: 'bool | None' = False) -> 'SortResponse | Awaitable[SortResponse]'
     |      Sort and return the list, set or sorted set at ``name``.
     |
     |      ``start`` and ``num`` allow for paging through the sorted data
     |
     |      ``by`` allows using an external key to weight and sort the items.
     |          Use an "*" to indicate where in the key the item value is located
     |
     |      ``get`` allows for returning items from external keys rather than the
     |          sorted data itself.  Use an "*" to indicate where in the key
     |          the item value is located
     |
     |      ``desc`` allows for reversing the sort
     |
     |      ``alpha`` allows for sorting lexicographically rather than numerically
     |
     |      ``store`` allows for storing the result of the sort into
     |          the key ``store``
     |
     |      ``groups`` if set to True and if ``get`` contains at least two
     |          elements, sort will return a list of tuples, each containing the
     |          values fetched from the arguments to ``get``.
     |
     |      For more information, see https://redis.io/commands/sort
     |
     |  sort_ro(self, key: 'str', start: 'int | None' = None, num: 'int | None' = None, by: 'str | None' = None, get: 'list[str] | None' = None, desc: 'bool' = False, alpha: 'bool' = False) -> 'list[bytes | str] | Awaitable[list[bytes | str]]'
     |      Returns the elements contained in the list, set or sorted set at key.
     |      (read-only variant of the SORT command)
     |
     |      ``start`` and ``num`` allow for paging through the sorted data
     |
     |      ``by`` allows using an external key to weight and sort the items.
     |          Use an "*" to indicate where in the key the item value is located
     |
     |      ``get`` allows for returning items from external keys rather than the
     |          sorted data itself.  Use an "*" to indicate where in the key
     |          the item value is located
     |
     |      ``desc`` allows for reversing the sort
     |
     |      ``alpha`` allows for sorting lexicographically rather than numerically
     |
     |      For more information, see https://redis.io/commands/sort_ro
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from ArrayCommands:
     |
     |  arcount(self, name: 'KeyT') -> 'int | Awaitable[int]'
     |      Return the number of non-empty elements in the array stored at
     |      ``name``. Returns 0 if ``name`` does not exist.
     |
     |      For more information, see https://redis.io/commands/arcount
     |
     |  ardel(self, name: 'KeyT', *indices: 'int') -> 'int | Awaitable[int]'
     |      Delete elements at the specified ``indices`` in the array stored at
     |      ``name``. Deleting an index that does not exist counts as zero
     |      elements deleted and does not modify the array.
     |
     |      Returns the number of elements deleted.
     |
     |      For more information, see https://redis.io/commands/ardel
     |
     |  ardelrange(self, name: 'KeyT', *ranges: 'tuple[int, int]') -> 'int | Awaitable[int]'
     |      Delete elements within one or more inclusive index ranges in the
     |      array stored at ``name``. Each range is a ``(start, end)`` tuple.
     |      If ``start`` is greater than ``end`` for a given pair, the range is
     |      processed in ascending order regardless. Multiple pairs may overlap;
     |      each element is counted at most once.
     |
     |      Returns the number of elements deleted.
     |
     |      For more information, see https://redis.io/commands/ardelrange
     |
     |  arget(self, name: 'KeyT', index: 'int') -> 'bytes | str | None | Awaitable[bytes | str | None]'
     |      Return the value at ``index`` in the array stored at ``name``.
     |
     |      Returns ``None`` if ``name`` does not exist or no value is set at
     |      ``index``.
     |
     |      For more information, see https://redis.io/commands/arget
     |
     |  argetrange(self, name: 'KeyT', start: 'int', end: 'int') -> 'list[bytes | str | None] | Awaitable[list[bytes | str | None]]'
     |      Return the values in the inclusive index range [``start``, ``end``]
     |      in the array stored at ``name``. If ``start`` is greater than ``end``,
     |      elements are returned in reverse index order.
     |
     |      For more information, see https://redis.io/commands/argetrange
     |
     |  argrep(self, name: 'KeyT', start: 'int', end: 'int', predicates: 'list[tuple[ArrayPredicateType, EncodableT]]', combinator: 'ArrayPredicateCombinator | None' = None, limit: 'int | None' = None, withvalues: 'bool' = False, nocase: 'bool' = False) -> 'list[int] | list[list[int | bytes | str]] | Awaitable[list[int] | list[list[int | bytes | str]]]'
     |      Search elements of the array stored at ``name`` within the inclusive
     |      index range [``start``, ``end``] using one or more textual
     |      ``predicates``. Each predicate is a ``(type, value)`` tuple where
     |      ``type`` is a member of ``ArrayPredicateType``
     |      (``EXACT``, ``MATCH``, ``GLOB``, ``RE``).
     |
     |      Multiple predicates are combined via ``combinator``
     |      (``ArrayPredicateCombinator.AND`` or ``OR``); the server defaults to
     |      OR when omitted. ``limit`` caps the number of matches.
     |      ``withvalues=True`` returns a list of ``[index, value]`` pairs
     |      (``[[idx, val], ...]``) instead of a flat list of indices.
     |      ``nocase=True`` makes all comparisons case-insensitive.
     |
     |      Without ``withvalues``, returns a flat list of matching indices in
     |      traversal order. With ``withvalues``, returns a list of
     |      ``[index, value]`` pairs in traversal order. Empty slots are
     |      skipped.
     |
     |      For more information, see https://redis.io/commands/argrep
     |
     |  arinfo(self, name: 'KeyT', full: 'bool' = False) -> 'dict[str, int] | Awaitable[dict[str, int]]'
     |      Return metadata about the array stored at ``name`` as a dictionary.
     |      When ``full`` is ``True``, additionally include per-slice statistics
     |      (dense/sparse slice counts, average sizes, fill rates), which makes
     |      the call O(N) instead of O(1).
     |
     |      Raises ``ResponseError`` when the key does not exist.
     |
     |      For more information, see https://redis.io/commands/arinfo
     |
     |  arinsert(self, name: 'KeyT', *values: 'FieldT') -> 'int | Awaitable[int]'
     |      Insert one or more ``values`` at consecutive indices in the array
     |      stored at ``name``, beginning at the current insert cursor position.
     |      The cursor advances by one for each value inserted. Use ``ARNEXT``
     |      to inspect the current cursor position and ``ARSEEK`` to reposition
     |      it.
     |
     |      Returns the last index where a value was inserted.
     |
     |      For more information, see https://redis.io/commands/arinsert
     |
     |  arlastitems(self, name: 'KeyT', count: 'int', rev: 'bool' = False) -> 'list[bytes | str | None] | Awaitable[list[bytes | str | None]]'
     |      Return up to ``count`` most recently inserted elements from the array
     |      stored at ``name``. If the array contains fewer elements than
     |      ``count``, all elements are returned.
     |
     |      When ``rev`` is ``True``, elements are returned in reverse
     |      chronological order (most recent first) instead of the default
     |      oldest-first order.
     |
     |      For more information, see https://redis.io/commands/arlastitems
     |
     |  arlen(self, name: 'KeyT') -> 'int | Awaitable[int]'
     |      Return the length of the array stored at ``name``, defined as the
     |      maximum set index plus one. Returns 0 if ``name`` does not exist.
     |
     |      For more information, see https://redis.io/commands/arlen
     |
     |  armget(self, name: 'KeyT', *indices: 'int') -> 'list[bytes | str | None] | Awaitable[list[bytes | str | None]]'
     |      Return the values at the specified ``indices`` in the array stored at
     |      ``name``. The reply preserves the order of the requested indices and
     |      returns ``None`` for any index that is not set or when ``name`` does
     |      not exist.
     |
     |      For more information, see https://redis.io/commands/armget
     |
     |  armset(self, name: 'KeyT', mapping: 'Mapping[int, FieldT]') -> 'int | Awaitable[int]'
     |      Set multiple index/value pairs in the array stored at ``name``.
     |      ``mapping`` is a dictionary of zero-based integer indices to values.
     |      Pairs may be non-contiguous and in any order.
     |
     |      Returns the number of new slots that were set (previously empty).
     |
     |      For more information, see https://redis.io/commands/armset
     |
     |  arnext(self, name: 'KeyT') -> 'int | None | Awaitable[int | None]'
     |      Return the next index ``ARINSERT`` would use for the array stored at
     |      ``name``. Returns 0 if ``name`` does not exist or no insert happened
     |      yet, and ``None`` when the insertion cursor is exhausted (next insert
     |      would overflow).
     |
     |      For more information, see https://redis.io/commands/arnext
     |
     |  arop(self, name: 'KeyT', start: 'int', end: 'int', operation: 'ArrayAggregateOperations', value: 'EncodableT | None' = None) -> 'bytes | str | int | None | Awaitable[bytes | str | int | None]'
     |      Perform an aggregate ``operation`` on elements of the array stored at
     |      ``name`` in the inclusive index range [``start``, ``end``]. The range
     |      is always scanned from the lower to the higher index regardless of
     |      argument order.
     |
     |      ``operation`` is one of the members of ``ArrayAggregateOperations``.
     |      ``value`` is required when ``operation`` is
     |      ``ArrayAggregateOperations.MATCH`` and specifies the value to compare
     |      against.
     |
     |      Returns a bulk string for ``SUM``, ``MIN`` and ``MAX``, an integer
     |      for ``AND``, ``OR``, ``XOR``, ``MATCH`` and ``USED``, or ``None``
     |      when no elements match the operation.
     |
     |      For more information, see https://redis.io/commands/arop
     |
     |  arring(self, name: 'KeyT', size: 'int', *values: 'FieldT') -> 'int | Awaitable[int]'
     |      Insert one or more ``values`` into the array stored at ``name`` as a
     |      fixed-size ring buffer of ``size`` slots. Each value is placed at
     |      ``insert_idx % size``, wrapping back to index 0 once the end is
     |      reached and overwriting older values when full. If ``size`` is
     |      smaller than the current window, the array is truncated to fit.
     |
     |      Returns the last index where a value was inserted.
     |
     |      For more information, see https://redis.io/commands/arring
     |
     |  arscan(self, name: 'KeyT', start: 'int', end: 'int', limit: 'int | None' = None) -> 'list[list[int | bytes | str]] | Awaitable[list[list[int | bytes | str]]]'
     |      Iterate populated elements of the array stored at ``name`` in the
     |      inclusive range [``start``, ``end``] and return a list of
     |      ``[index, value]`` pairs in traversal order:
     |      ``[[idx1, val1], [idx2, val2], ...]``. Empty slots are skipped. If
     |      ``start`` is greater than ``end``, the iteration is reversed.
     |
     |      ``limit`` caps the number of populated elements returned. When
     |      omitted, all populated elements in range are returned.
     |
     |      For more information, see https://redis.io/commands/arscan
     |
     |  arseek(self, name: 'KeyT', index: 'int') -> 'int | Awaitable[int]'
     |      Set the insert cursor of the array stored at ``name`` to ``index``.
     |      Subsequent ``ARINSERT`` and ``ARRING`` operations begin inserting at
     |      this position.
     |
     |      Returns 1 if the cursor was set, 0 if ``name`` does not exist.
     |
     |      For more information, see https://redis.io/commands/arseek
     |
     |  arset(self, name: 'KeyT', index: 'int', *values: 'FieldT') -> 'int | Awaitable[int]'
     |      Set one or more contiguous ``values`` in the array stored at ``name``
     |      starting at ``index``. When multiple values are provided, they are
     |      stored at consecutive indices beginning at ``index``.
     |
     |      Returns the number of new slots that were set (previously empty).
     |
     |      For more information, see https://redis.io/commands/arset
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from ScanCommands:
     |
     |  hscan(self, name: 'KeyT', cursor: 'int' = 0, match: 'PatternT | None' = None, count: 'int | None' = None, no_values: 'bool | None' = None) -> 'HScanResponse | Awaitable[HScanResponse]'
     |      Incrementally return key/value slices in a hash. Also return a cursor
     |      indicating the scan position.
     |
     |      ``match`` allows for filtering the keys by pattern
     |
     |      ``count`` allows for hint the minimum number of returns
     |
     |      ``no_values`` indicates to return only the keys, without values.
     |
     |      For more information, see https://redis.io/commands/hscan
     |
     |  hscan_iter(self, name: 'KeyT', match: 'Union[PatternT, None]' = None, count: 'Optional[int]' = None, no_values: 'Union[bool, None]' = None) -> 'Iterator'
     |      Make an iterator using the HSCAN command so that the client doesn't
     |      need to remember the cursor position.
     |
     |      ``match`` allows for filtering the keys by pattern
     |
     |      ``count`` allows for hint the minimum number of returns
     |
     |      ``no_values`` indicates to return only the keys, without values
     |
     |  scan(self, cursor: 'int' = 0, match: 'PatternT | None' = None, count: 'int | None' = None, _type: 'str | None' = None, **kwargs) -> 'ScanResponse | Awaitable[ScanResponse]'
     |      Incrementally return lists of key names. Also return a cursor
     |      indicating the scan position.
     |
     |      ``match`` allows for filtering the keys by pattern
     |
     |      ``count`` provides a hint to Redis about the number of keys to
     |          return per batch.
     |
     |      ``_type`` filters the returned values by a particular Redis type.
     |          Stock Redis instances allow for the following types:
     |          HASH, LIST, SET, STREAM, STRING, ZSET
     |          Additionally, Redis modules can expose other types as well.
     |
     |      For more information, see https://redis.io/commands/scan
     |
     |  scan_iter(self, match: 'Union[PatternT, None]' = None, count: 'Optional[int]' = None, _type: 'Optional[str]' = None, **kwargs) -> 'Iterator'
     |      Make an iterator using the SCAN command so that the client doesn't
     |      need to remember the cursor position.
     |
     |      ``match`` allows for filtering the keys by pattern
     |
     |      ``count`` provides a hint to Redis about the number of keys to
     |          return per batch.
     |
     |      ``_type`` filters the returned values by a particular Redis type.
     |          Stock Redis instances allow for the following types:
     |          HASH, LIST, SET, STREAM, STRING, ZSET
     |          Additionally, Redis modules can expose other types as well.
     |
     |  sscan(self, name: 'KeyT', cursor: 'int' = 0, match: 'PatternT | None' = None, count: 'int | None' = None) -> 'ScanResponse | Awaitable[ScanResponse]'
     |      Incrementally return lists of elements in a set. Also return a cursor
     |      indicating the scan position.
     |
     |      ``match`` allows for filtering the keys by pattern
     |
     |      ``count`` allows for hint the minimum number of returns
     |
     |      For more information, see https://redis.io/commands/sscan
     |
     |  sscan_iter(self, name: 'KeyT', match: 'Union[PatternT, None]' = None, count: 'Optional[int]' = None) -> 'Iterator'
     |      Make an iterator using the SSCAN command so that the client doesn't
     |      need to remember the cursor position.
     |
     |      ``match`` allows for filtering the keys by pattern
     |
     |      ``count`` allows for hint the minimum number of returns
     |
     |  zscan(self, name: 'KeyT', cursor: 'int' = 0, match: 'PatternT | None' = None, count: 'int | None' = None, score_cast_func: 'type | Callable' = <class 'float'>) -> 'ZScanResponse | Awaitable[ZScanResponse]'
     |      Incrementally return lists of elements in a sorted set. Also return a
     |      cursor indicating the scan position.
     |
     |      ``match`` allows for filtering the keys by pattern
     |
     |      ``count`` allows for hint the minimum number of returns
     |
     |      ``score_cast_func`` a callable used to cast the score return value
     |
     |      For more information, see https://redis.io/commands/zscan
     |
     |  zscan_iter(self, name: 'KeyT', match: 'Union[PatternT, None]' = None, count: 'Optional[int]' = None, score_cast_func: 'Union[type, Callable]' = <class 'float'>) -> 'Iterator'
     |      Make an iterator using the ZSCAN command so that the client doesn't
     |      need to remember the cursor position.
     |
     |      ``match`` allows for filtering the keys by pattern
     |
     |      ``count`` allows for hint the minimum number of returns
     |
     |      ``score_cast_func`` a callable used to cast the score return value
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from SetCommands:
     |
     |  sadd(self, name: 'KeyT', *values: 'FieldT') -> 'int | Awaitable[int]'
     |      Add ``value(s)`` to set ``name``
     |
     |      For more information, see https://redis.io/commands/sadd
     |
     |  scard(self, name: 'KeyT') -> 'int | Awaitable[int]'
     |      Return the number of elements in set ``name``
     |
     |      For more information, see https://redis.io/commands/scard
     |
     |  sdiff(self, keys: 'List', *args: 'List') -> 'set[bytes | str] | Awaitable[set[bytes | str]]'
     |      Return the difference of sets specified by ``keys``
     |
     |      For more information, see https://redis.io/commands/sdiff
     |
     |  sdiffcard(self, numkeys: 'int', keys: 'List[KeyT]', limit: 'int' = 0) -> 'int | Awaitable[int]'
     |      Return the cardinality of the difference between the first set and all
     |      the successive sets specified by ``keys``, without returning the
     |      difference itself.
     |
     |      When LIMIT is provided (defaults to 0 and means unlimited), the returned
     |      cardinality is capped at ``limit`` and the server may stop the
     |      computation once the capped result is known.
     |
     |      For more information, see https://redis.io/commands/sdiffcard
     |
     |  sdiffstore(self, dest: 'str', keys: 'List', *args: 'List') -> 'int | Awaitable[int]'
     |      Store the difference of sets specified by ``keys`` into a new
     |      set named ``dest``.  Returns the number of keys in the new set.
     |
     |      For more information, see https://redis.io/commands/sdiffstore
     |
     |  sinter(self, keys: 'List', *args: 'List') -> 'set[bytes | str] | Awaitable[set[bytes | str]]'
     |      Return the intersection of sets specified by ``keys``
     |
     |      For more information, see https://redis.io/commands/sinter
     |
     |  sintercard(self, numkeys: 'int', keys: 'List[KeyT]', limit: 'int' = 0) -> 'int | Awaitable[int]'
     |      Return the cardinality of the intersect of multiple sets specified by ``keys``.
     |
     |      When LIMIT provided (defaults to 0 and means unlimited), if the intersection
     |      cardinality reaches limit partway through the computation, the algorithm will
     |      exit and yield limit as the cardinality
     |
     |      For more information, see https://redis.io/commands/sintercard
     |
     |  sinterstore(self, dest: 'KeyT', keys: 'List', *args: 'List') -> 'int | Awaitable[int]'
     |      Store the intersection of sets specified by ``keys`` into a new
     |      set named ``dest``.  Returns the number of keys in the new set.
     |
     |      For more information, see https://redis.io/commands/sinterstore
     |
     |  sismember(self, name: 'KeyT', value: 'str') -> 'Literal[0] | Literal[1] | Awaitable[Literal[0] | Literal[1]]'
     |      Return whether ``value`` is a member of set ``name``:
     |      - 1 if the value is a member of the set.
     |      - 0 if the value is not a member of the set or if key does not exist.
     |
     |      For more information, see https://redis.io/commands/sismember
     |
     |  smembers(self, name: 'KeyT') -> 'set[bytes | str] | Awaitable[set[bytes | str]]'
     |      Return all members of the set ``name``
     |
     |      For more information, see https://redis.io/commands/smembers
     |
     |  smismember(self, name: 'KeyT', values: 'List', *args: 'List') -> 'list[Literal[0] | Literal[1]] | Awaitable[list[Literal[0] | Literal[1]]]'
     |      Return whether each value in ``values`` is a member of the set ``name``
     |      as a list of ``int`` in the order of ``values``:
     |      - 1 if the value is a member of the set.
     |      - 0 if the value is not a member of the set or if key does not exist.
     |
     |      For more information, see https://redis.io/commands/smismember
     |
     |  smove(self, src: 'KeyT', dst: 'KeyT', value: 'str') -> 'bool | Awaitable[bool]'
     |      Move ``value`` from set ``src`` to set ``dst`` atomically
     |
     |      For more information, see https://redis.io/commands/smove
     |
     |  spop(self, name: 'KeyT', count: 'int | None' = None) -> 'bytes | str | set[bytes | str] | None | Awaitable[bytes | str | set[bytes | str] | None]'
     |      Remove and return a random member of set ``name``
     |
     |      For more information, see https://redis.io/commands/spop
     |
     |  srandmember(self, name: 'KeyT', number: 'int | None' = None) -> 'bytes | str | list[bytes | str] | None | Awaitable[bytes | str | list[bytes | str] | None]'
     |      If ``number`` is None, returns a random member of set ``name``.
     |
     |      If ``number`` is supplied, returns a list of ``number`` random
     |      members of set ``name``. Note this is only available when running
     |      Redis 2.6+.
     |
     |      For more information, see https://redis.io/commands/srandmember
     |
     |  srem(self, name: 'KeyT', *values: 'FieldT') -> 'int | Awaitable[int]'
     |      Remove ``values`` from set ``name``
     |
     |      For more information, see https://redis.io/commands/srem
     |
     |  sunion(self, keys: 'List', *args: 'List') -> 'set[bytes | str] | Awaitable[set[bytes | str]]'
     |      Return the union of sets specified by ``keys``
     |
     |      For more information, see https://redis.io/commands/sunion
     |
     |  sunioncard(self, numkeys: 'int', keys: 'List[KeyT]', limit: 'int' = 0, approx: 'bool' = False) -> 'int | Awaitable[int]'
     |      Return the cardinality of the union of multiple sets specified by
     |      ``keys``, without returning the union itself.
     |
     |      When ``approx`` is True, the ``APPROX`` option is sent and the server
     |      returns an approximate cardinality computed using HyperLogLog.
     |
     |      When LIMIT is provided (defaults to 0 and means unlimited), the returned
     |      cardinality is capped at ``limit``. In exact mode the result equals
     |      ``limit`` when the real cardinality exceeds ``limit``; in approximate
     |      mode the result will not exceed ``limit``. Options are emitted in the
     |      canonical order ``APPROX`` before ``LIMIT``.
     |
     |      For more information, see https://redis.io/commands/sunioncard
     |
     |  sunionstore(self, dest: 'KeyT', keys: 'List', *args: 'List') -> 'int | Awaitable[int]'
     |      Store the union of sets specified by ``keys`` into a new
     |      set named ``dest``.  Returns the number of keys in the new set.
     |
     |      For more information, see https://redis.io/commands/sunionstore
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from StreamCommands:
     |
     |  xack(self, name: 'KeyT', groupname: 'GroupT', *ids: 'StreamIdT') -> 'int | Awaitable[int]'
     |      Acknowledges the successful processing of one or more messages.
     |
     |      Args:
     |          name: name of the stream.
     |          groupname: name of the consumer group.
     |          *ids: message ids to acknowledge.
     |
     |      For more information, see https://redis.io/commands/xack
     |
     |  xackdel(self, name: 'KeyT', groupname: 'GroupT', *ids: 'StreamIdT', ref_policy: "Literal['KEEPREF', 'DELREF', 'ACKED']" = 'KEEPREF') -> 'int | Awaitable[int]'
     |      Combines the functionality of XACK and XDEL. Acknowledges the specified
     |      message IDs in the given consumer group and simultaneously attempts to
     |      delete the corresponding entries from the stream.
     |
     |  xadd(self, name: 'KeyT', fields: 'Dict[FieldT, EncodableT]', id: 'StreamIdT' = '*', maxlen: 'Optional[int]' = None, approximate: 'bool' = True, nomkstream: 'bool' = False, minid: 'Union[StreamIdT, None]' = None, limit: 'int | None' = None, ref_policy: "Literal['KEEPREF', 'DELREF', 'ACKED'] | None" = None, idmpauto: 'str | None' = None, idmp: 'tuple[str, bytes] | None' = None) -> 'bytes | str | Awaitable[bytes | str]'
     |      Add to a stream.
     |      name: name of the stream
     |      fields: dict of field/value pairs to insert into the stream
     |      id: Location to insert this record. By default it is appended.
     |      maxlen: truncate old stream members beyond this size.
     |      Can't be specified with minid.
     |      approximate: actual stream length may be slightly more than maxlen
     |      nomkstream: When set to true, do not make a stream
     |      minid: the minimum id in the stream to query.
     |      Can't be specified with maxlen.
     |      limit: specifies the maximum number of entries to retrieve
     |      ref_policy: optional reference policy for consumer groups when trimming:
     |          - KEEPREF (default): When trimming, preserves references in consumer groups' PEL
     |          - DELREF: When trimming, removes all references from consumer groups' PEL
     |          - ACKED: When trimming, only removes entries acknowledged by all consumer groups
     |      idmpauto: Producer ID for automatic idempotent ID calculation.
     |          Automatically calculates an idempotent ID based on entry content to prevent
     |          duplicate entries. Can only be used with id='*'. Creates an IDMP map if it
     |          doesn't exist yet. The producer ID must be unique per producer and consistent
     |          across restarts.
     |      idmp: Tuple of (producer_id, idempotent_id) for explicit idempotent ID.
     |          Uses a specific idempotent ID to prevent duplicate entries. Can only be used
     |          with id='*'. The producer ID must be unique per producer and consistent across
     |          restarts. The idempotent ID must be unique per message and per producer.
     |          Shorter idempotent IDs require less memory and allow faster processing.
     |          Creates an IDMP map if it doesn't exist yet.
     |
     |      For more information, see https://redis.io/commands/xadd
     |
     |  xautoclaim(self, name: 'KeyT', groupname: 'GroupT', consumername: 'ConsumerT', min_idle_time: 'int', start_id: 'StreamIdT' = '0-0', count: 'int | None' = None, justid: 'bool' = False) -> 'list[Any] | Awaitable[list[Any]]'
     |      Transfers ownership of pending stream entries that match the specified
     |      criteria. Conceptually, equivalent to calling XPENDING and then XCLAIM,
     |      but provides a more straightforward way to deal with message delivery
     |      failures via SCAN-like semantics.
     |      name: name of the stream.
     |      groupname: name of the consumer group.
     |      consumername: name of a consumer that claims the message.
     |      min_idle_time: filter messages that were idle less than this amount of
     |      milliseconds.
     |      start_id: filter messages with equal or greater ID.
     |      count: optional integer, upper limit of the number of entries that the
     |      command attempts to claim. Set to 100 by default.
     |      justid: optional boolean, false by default. Return just an array of IDs
     |      of messages successfully claimed, without returning the actual message
     |
     |      For more information, see https://redis.io/commands/xautoclaim
     |
     |  xcfgset(self, name: 'KeyT', idmp_duration: 'int | None' = None, idmp_maxsize: 'int | None' = None) -> 'bytes | str | Awaitable[bytes | str]'
     |      Configure the idempotency parameters for a stream's IDMP map.
     |
     |      Sets how long Redis remembers each idempotent ID (iid) and the maximum
     |      number of iids to track. This command clears the existing IDMP map
     |      (Redis forgets all previously stored iids), but only if the configuration
     |      value actually changes.
     |
     |      Args:
     |          name: The name of the stream.
     |          idmp_duration: How long Redis remembers each iid in seconds.
     |              Default: 100 seconds (or value set by stream-idmp-duration config).
     |              Minimum: 1 second, Maximum: 300 seconds.
     |              Redis won't forget an iid for this duration (unless maxsize is reached).
     |              Should accommodate application crash recovery time.
     |          idmp_maxsize: Maximum number of iids Redis remembers per producer ID (pid).
     |              Default: 100 iids (or value set by stream-idmp-maxsize config).
     |              Minimum: 1 iid, Maximum: 1,000,000 (1M) iids.
     |              Should be set to: mark-delay [in msec] × (messages/msec) + margin.
     |              Example: 10K msgs/sec (10 msgs/msec), 80 msec mark-delay
     |              → maxsize = 10 × 80 + margin = 1000 iids.
     |
     |      Returns:
     |          OK on success.
     |
     |      For more information, see https://redis.io/commands/xcfgset
     |
     |  xclaim(self, name: 'KeyT', groupname: 'GroupT', consumername: 'ConsumerT', min_idle_time: 'int', message_ids: 'Union[List[StreamIdT], Tuple[StreamIdT]]', idle: 'int | None' = None, time: 'int | None' = None, retrycount: 'int | None' = None, force: 'bool' = False, justid: 'bool' = False) -> 'XClaimResponse | Awaitable[XClaimResponse]'
     |      Changes the ownership of a pending message.
     |
     |      name: name of the stream.
     |
     |      groupname: name of the consumer group.
     |
     |      consumername: name of a consumer that claims the message.
     |
     |      min_idle_time: filter messages that were idle less than this amount of
     |      milliseconds
     |
     |      message_ids: non-empty list or tuple of message IDs to claim
     |
     |      idle: optional. Set the idle time (last time it was delivered) of the
     |      message in ms
     |
     |      time: optional integer. This is the same as idle but instead of a
     |      relative amount of milliseconds, it sets the idle time to a specific
     |      Unix time (in milliseconds).
     |
     |      retrycount: optional integer. set the retry counter to the specified
     |      value. This counter is incremented every time a message is delivered
     |      again.
     |
     |      force: optional boolean, false by default. Creates the pending message
     |      entry in the PEL even if certain specified IDs are not already in the
     |      PEL assigned to a different client.
     |
     |      justid: optional boolean, false by default. Return just an array of IDs
     |      of messages successfully claimed, without returning the actual message
     |
     |      For more information, see https://redis.io/commands/xclaim
     |
     |  xdel(self, name: 'KeyT', *ids: 'StreamIdT') -> 'int | Awaitable[int]'
     |      Deletes one or more messages from a stream.
     |
     |      Args:
     |          name: name of the stream.
     |          *ids: message ids to delete.
     |
     |      For more information, see https://redis.io/commands/xdel
     |
     |  xdelex(self, name: 'KeyT', *ids: 'StreamIdT', ref_policy: "Literal['KEEPREF', 'DELREF', 'ACKED']" = 'KEEPREF') -> 'int | Awaitable[int]'
     |      Extended version of XDEL that provides more control over how message entries
     |      are deleted concerning consumer groups.
     |
     |  xgroup_create(self, name: 'KeyT', groupname: 'GroupT', id: 'StreamIdT' = '$', mkstream: 'bool' = False, entries_read: 'int | None' = None) -> 'bool | Awaitable[bool]'
     |      Create a new consumer group associated with a stream.
     |      name: name of the stream.
     |      groupname: name of the consumer group.
     |      id: ID of the last item in the stream to consider already delivered.
     |
     |      For more information, see https://redis.io/commands/xgroup-create
     |
     |  xgroup_createconsumer(self, name: 'KeyT', groupname: 'GroupT', consumername: 'ConsumerT') -> 'int | Awaitable[int]'
     |      Consumers in a consumer group are auto-created every time a new
     |      consumer name is mentioned by some command.
     |      They can be explicitly created by using this command.
     |      name: name of the stream.
     |      groupname: name of the consumer group.
     |      consumername: name of consumer to create.
     |
     |      See: https://redis.io/commands/xgroup-createconsumer
     |
     |  xgroup_delconsumer(self, name: 'KeyT', groupname: 'GroupT', consumername: 'ConsumerT') -> 'int | Awaitable[int]'
     |      Remove a specific consumer from a consumer group.
     |      Returns the number of pending messages that the consumer had before it
     |      was deleted.
     |      name: name of the stream.
     |      groupname: name of the consumer group.
     |      consumername: name of consumer to delete
     |
     |      For more information, see https://redis.io/commands/xgroup-delconsumer
     |
     |  xgroup_destroy(self, name: 'KeyT', groupname: 'GroupT') -> 'bool | Awaitable[bool]'
     |      Destroy a consumer group.
     |      name: name of the stream.
     |      groupname: name of the consumer group.
     |
     |      For more information, see https://redis.io/commands/xgroup-destroy
     |
     |  xgroup_setid(self, name: 'KeyT', groupname: 'GroupT', id: 'StreamIdT', entries_read: 'int | None' = None) -> 'bool | Awaitable[bool]'
     |      Set the consumer group last delivered ID to something else.
     |      name: name of the stream.
     |      groupname: name of the consumer group.
     |      id: ID of the last item in the stream to consider already delivered.
     |
     |      For more information, see https://redis.io/commands/xgroup-setid
     |
     |  xinfo_consumers(self, name: 'KeyT', groupname: 'GroupT') -> 'list[dict[str, Any]] | Awaitable[list[dict[str, Any]]]'
     |      Returns general information about the consumers in the group.
     |      name: name of the stream.
     |      groupname: name of the consumer group.
     |
     |      For more information, see https://redis.io/commands/xinfo-consumers
     |
     |  xinfo_groups(self, name: 'KeyT') -> 'list[dict[str, Any]] | Awaitable[list[dict[str, Any]]]'
     |      Returns general information about the consumer groups of the stream.
     |      name: name of the stream.
     |
     |      For more information, see https://redis.io/commands/xinfo-groups
     |
     |  xinfo_stream(self, name: 'KeyT', full: 'bool' = False) -> 'dict[str, Any] | Awaitable[dict[str, Any]]'
     |      Returns general information about the stream.
     |      name: name of the stream.
     |      full: optional boolean, false by default. Return full summary
     |
     |      For more information, see https://redis.io/commands/xinfo-stream
     |
     |  xlen(self, name: 'KeyT') -> 'int | Awaitable[int]'
     |      Returns the number of elements in a given stream.
     |
     |      For more information, see https://redis.io/commands/xlen
     |
     |  xnack(self, name: 'KeyT', groupname: 'GroupT', mode: "Literal['SILENT', 'FAIL', 'FATAL']", *ids: 'StreamIdT', retrycount: 'int | None' = None, force: 'bool' = False) -> 'int | Awaitable[int]'
     |      Negatively acknowledges one or more messages in a consumer group's
     |      Pending Entries List (PEL).
     |
     |      Args:
     |          name: name of the stream.
     |          groupname: name of the consumer group.
     |          mode: the nacking mode. One of SILENT, FAIL, or FATAL.
     |              SILENT: consumer shutting down; decrements delivery counter.
     |              FAIL: consumer unable to process; delivery counter unchanged.
     |              FATAL: invalid/malicious message; delivery counter set to max.
     |          *ids: one or more message IDs to NACK.
     |          retrycount: optional integer >= 0. Overrides the mode's implicit
     |              delivery counter adjustment with an exact value.
     |          force: if True, creates a new unowned PEL entry for any ID not
     |              already in the group's PEL.
     |
     |      Returns:
     |          The number of messages successfully NACKed.
     |
     |      For more information, see https://redis.io/commands/xnack
     |
     |  xpending(self, name: 'KeyT', groupname: 'GroupT') -> 'dict[str, Any] | Awaitable[dict[str, Any]]'
     |      Returns information about pending messages of a group.
     |      name: name of the stream.
     |      groupname: name of the consumer group.
     |
     |      For more information, see https://redis.io/commands/xpending
     |
     |  xpending_range(self, name: 'KeyT', groupname: 'GroupT', min: 'StreamIdT', max: 'StreamIdT', count: 'int', consumername: 'ConsumerT | None' = None, idle: 'int | None' = None) -> 'XPendingRangeResponse | Awaitable[XPendingRangeResponse]'
     |      Returns information about pending messages, in a range.
     |
     |      name: name of the stream.
     |      groupname: name of the consumer group.
     |      idle: available from  version 6.2. filter entries by their
     |      idle-time, given in milliseconds (optional).
     |      min: minimum stream ID.
     |      max: maximum stream ID.
     |      count: number of messages to return
     |      consumername: name of a consumer to filter by (optional).
     |
     |  xrange(self, name: 'KeyT', min: 'StreamIdT' = '-', max: 'StreamIdT' = '+', count: 'int | None' = None) -> 'StreamRangeResponse | None | Awaitable[StreamRangeResponse | None]'
     |      Read stream values within an interval.
     |
     |      name: name of the stream.
     |
     |      start: first stream ID. defaults to '-',
     |             meaning the earliest available.
     |
     |      finish: last stream ID. defaults to '+',
     |              meaning the latest available.
     |
     |      count: if set, only return this many items, beginning with the
     |             earliest available.
     |
     |      For more information, see https://redis.io/commands/xrange
     |
     |  xread(self, streams: 'Dict[KeyT, StreamIdT]', count: 'int | None' = None, block: 'int | None' = None, max_count: 'int | None' = None, max_size: 'int | None' = None) -> 'XReadResponse | Awaitable[XReadResponse]'
     |      Block and monitor multiple streams for new data.
     |
     |      streams: a dict of stream names to stream IDs, where
     |                 IDs indicate the last ID already seen.
     |
     |      count: if set, only return this many items per stream, beginning with
     |             the earliest available.
     |
     |      block: number of milliseconds to wait, if nothing already present.
     |
     |      max_count: if set, cap the total number of entries returned across all
     |                 streams combined. Unlike ``count`` (a per-stream limit),
     |                 this is a cumulative cap over the whole reply. Must be a
     |                 positive integer and, when ``count`` is also set, must be
     |                 greater than or equal to ``count``. Requires Redis >= 8.10.0.
     |
     |      max_size: if set, a soft cap on the total server reply size in bytes
     |                across all streams combined. Measured server-side including
     |                protocol overhead, so it is not an exact application-payload
     |                size guarantee; a single available entry larger than the cap
     |                may still be returned. Must be a positive integer. Requires
     |                Redis >= 8.10.0.
     |
     |      For more information, see https://redis.io/commands/xread
     |
     |  xreadgroup(self, groupname: 'str', consumername: 'str', streams: 'Dict[KeyT, StreamIdT]', count: 'int | None' = None, block: 'int | None' = None, noack: 'bool' = False, claim_min_idle_time: 'int | None' = None, max_count: 'int | None' = None, max_size: 'int | None' = None) -> 'XReadGroupResponse | Awaitable[XReadGroupResponse]'
     |      Read from a stream via a consumer group.
     |
     |      groupname: name of the consumer group.
     |
     |      consumername: name of the requesting consumer.
     |
     |      streams: a dict of stream names to stream IDs, where
     |             IDs indicate the last ID already seen.
     |
     |      count: if set, only return this many items per stream, beginning with
     |             the earliest available.
     |
     |      block: number of milliseconds to wait, if nothing already present.
     |      noack: do not add messages to the PEL
     |
     |      claim_min_idle_time: accepts an integer type and represents a
     |                           time interval in milliseconds
     |
     |      max_count: if set, cap the total number of entries returned across all
     |                 streams combined. Unlike ``count`` (a per-stream limit),
     |                 this is a cumulative cap over the whole reply. Must be a
     |                 positive integer and, when ``count`` is also set, must be
     |                 greater than or equal to ``count``. Requires Redis 8.10.0.
     |
     |      max_size: if set, a soft cap on the total server reply size in bytes
     |                across all streams combined. Measured server-side including
     |                protocol overhead, so it is not an exact application-payload
     |                size guarantee; a single available entry larger than the cap
     |                may still be returned. Must be a positive integer. Requires
     |                Redis 8.10.0.
     |
     |      For more information, see https://redis.io/commands/xreadgroup
     |
     |  xrevrange(self, name: 'KeyT', max: 'StreamIdT' = '+', min: 'StreamIdT' = '-', count: 'int | None' = None) -> 'StreamRangeResponse | None | Awaitable[StreamRangeResponse | None]'
     |      Read stream values within an interval, in reverse order.
     |
     |      name: name of the stream
     |
     |      start: first stream ID. defaults to '+',
     |             meaning the latest available.
     |
     |      finish: last stream ID. defaults to '-',
     |              meaning the earliest available.
     |
     |      count: if set, only return this many items, beginning with the
     |             latest available.
     |
     |      For more information, see https://redis.io/commands/xrevrange
     |
     |  xtrim(self, name: 'KeyT', maxlen: 'int | None' = None, approximate: 'bool' = True, minid: 'StreamIdT | None' = None, limit: 'int | None' = None, ref_policy: "Literal['KEEPREF', 'DELREF', 'ACKED'] | None" = None) -> 'int | Awaitable[int]'
     |      Trims old messages from a stream.
     |      name: name of the stream.
     |      maxlen: truncate old stream messages beyond this size
     |      Can't be specified with minid.
     |      approximate: actual stream length may be slightly more than maxlen
     |      minid: the minimum id in the stream to query
     |      Can't be specified with maxlen.
     |      limit: specifies the maximum number of entries to retrieve
     |      ref_policy: optional reference policy for consumer groups:
     |          - KEEPREF (default): Trims entries but preserves references in consumer groups' PEL
     |          - DELREF: Trims entries and removes all references from consumer groups' PEL
     |          - ACKED: Only trims entries that were read and acknowledged by all consumer groups
     |
     |      For more information, see https://redis.io/commands/xtrim
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from SortedSetCommands:
     |
     |  bzmpop(self, timeout: 'float', numkeys: 'int', keys: 'List[str]', min: 'bool | None' = False, max: 'bool | None' = False, count: 'int | None' = 1) -> 'ZMPopResponse | Awaitable[ZMPopResponse]'
     |      Pop ``count`` values (default 1) off of the first non-empty sorted set
     |      named in the ``keys`` list.
     |
     |      If none of the sorted sets in ``keys`` has a value to pop,
     |      then block for ``timeout`` seconds, or until a member gets added
     |      to one of the sorted sets.
     |
     |      If timeout is 0, then block indefinitely.
     |
     |      For more information, see https://redis.io/commands/bzmpop
     |
     |  bzpopmax(self, keys: 'KeysT', timeout: 'TimeoutSecT' = 0) -> 'BlockingZSetPopResponse | Awaitable[BlockingZSetPopResponse]'
     |      ZPOPMAX a value off of the first non-empty sorted set
     |      named in the ``keys`` list.
     |
     |      If none of the sorted sets in ``keys`` has a value to ZPOPMAX,
     |      then block for ``timeout`` seconds, or until a member gets added
     |      to one of the sorted sets.
     |
     |      If timeout is 0, then block indefinitely.
     |
     |      For more information, see https://redis.io/commands/bzpopmax
     |
     |  bzpopmin(self, keys: 'KeysT', timeout: 'TimeoutSecT' = 0) -> 'BlockingZSetPopResponse | Awaitable[BlockingZSetPopResponse]'
     |      ZPOPMIN a value off of the first non-empty sorted set
     |      named in the ``keys`` list.
     |
     |      If none of the sorted sets in ``keys`` has a value to ZPOPMIN,
     |      then block for ``timeout`` seconds, or until a member gets added
     |      to one of the sorted sets.
     |
     |      If timeout is 0, then block indefinitely.
     |
     |      For more information, see https://redis.io/commands/bzpopmin
     |
     |  zadd(self, name: 'KeyT', mapping: 'Mapping[AnyKeyT, EncodableT]', nx: 'bool' = False, xx: 'bool' = False, ch: 'bool' = False, incr: 'bool' = False, gt: 'bool' = False, lt: 'bool' = False) -> 'int | float | None | Awaitable[int | float | None]'
     |      Set any number of element-name, score pairs to the key ``name``. Pairs
     |      are specified as a dict of element-names keys to score values.
     |
     |      ``nx`` forces ZADD to only create new elements and not to update
     |      scores for elements that already exist.
     |
     |      ``xx`` forces ZADD to only update scores of elements that already
     |      exist. New elements will not be added.
     |
     |      ``ch`` modifies the return value to be the numbers of elements changed.
     |      Changed elements include new elements that were added and elements
     |      whose scores changed.
     |
     |      ``incr`` modifies ZADD to behave like ZINCRBY. In this mode only a
     |      single element/score pair can be specified and the score is the amount
     |      the existing score will be incremented by. When using this mode the
     |      return value of ZADD will be the new score of the element.
     |
     |      ``lt`` only updates existing elements if the new score is less than
     |      the current score. This flag doesn't prevent adding new elements.
     |
     |      ``gt`` only updates existing elements if the new score is greater than
     |      the current score. This flag doesn't prevent adding new elements.
     |
     |      The return value of ZADD varies based on the mode specified. With no
     |      options, ZADD returns the number of new elements added to the sorted
     |      set.
     |
     |      ``nx``, ``lt``, and ``gt`` are mutually exclusive options.
     |
     |      See: https://redis.io/commands/ZADD
     |
     |  zcard(self, name: 'KeyT') -> 'int | Awaitable[int]'
     |      Return the number of elements in the sorted set ``name``
     |
     |      For more information, see https://redis.io/commands/zcard
     |
     |  zcount(self, name: 'KeyT', min: 'ZScoreBoundT', max: 'ZScoreBoundT') -> 'int | Awaitable[int]'
     |      Returns the number of elements in the sorted set at key ``name`` with
     |      a score between ``min`` and ``max``.
     |
     |      For more information, see https://redis.io/commands/zcount
     |
     |  zdiff(self, keys: 'KeysT', withscores: 'bool' = False) -> 'ZSetRangeResponse | Awaitable[ZSetRangeResponse]'
     |      Returns the difference between the first and all successive input
     |      sorted sets provided in ``keys``.
     |
     |      For more information, see https://redis.io/commands/zdiff
     |
     |  zdiffstore(self, dest: 'KeyT', keys: 'KeysT') -> 'int | Awaitable[int]'
     |      Computes the difference between the first and all successive input
     |      sorted sets provided in ``keys`` and stores the result in ``dest``.
     |
     |      For more information, see https://redis.io/commands/zdiffstore
     |
     |  zincrby(self, name: 'KeyT', amount: 'float', value: 'EncodableT') -> 'float | None | Awaitable[float | None]'
     |      Increment the score of ``value`` in sorted set ``name`` by ``amount``
     |
     |      For more information, see https://redis.io/commands/zincrby
     |
     |  zinter(self, keys: 'KeysT', aggregate: 'str | None' = None, withscores: 'bool' = False) -> 'ZSetRangeResponse | Awaitable[ZSetRangeResponse]'
     |      Return the intersect of multiple sorted sets specified by ``keys``.
     |
     |      With the ``aggregate`` option, it is possible to specify how the
     |      results of the intersection are aggregated. Available aggregation
     |      modes:
     |
     |      - ``SUM`` (default): the score of an element is summed across the
     |        inputs where it exists.
     |        Score = SUM(score₁×weight₁, score₂×weight₂, ...)
     |      - ``MIN``: the resulting set will contain the minimum score of an
     |        element across the inputs where it exists.
     |        Score = MIN(score₁×weight₁, score₂×weight₂, ...)
     |      - ``MAX``: the resulting set will contain the maximum score of an
     |        element across the inputs where it exists.
     |        Score = MAX(score₁×weight₁, score₂×weight₂, ...)
     |      - ``COUNT``: ignores the original scores and counts weighted set
     |        membership. Each element's score is the sum of the weights of
     |        the input sets that contain it.
     |        Score = SUM(weight₁, weight₂, ...) for sets containing the element.
     |        When all weights are 1 (default), the score equals the number
     |        of input sets containing the element.
     |
     |      For more information, see https://redis.io/commands/zinter
     |
     |  zintercard(self, numkeys: 'int', keys: 'List[str]', limit: 'int' = 0) -> 'int | Awaitable[int]'
     |      Return the cardinality of the intersect of multiple sorted sets
     |      specified by ``keys``.
     |      When LIMIT provided (defaults to 0 and means unlimited), if the intersection
     |      cardinality reaches limit partway through the computation, the algorithm will
     |      exit and yield limit as the cardinality
     |
     |      For more information, see https://redis.io/commands/zintercard
     |
     |  zinterstore(self, dest: 'KeyT', keys: 'Sequence[KeyT] | Mapping[AnyKeyT, float]', aggregate: 'str | None' = None) -> 'int | Awaitable[int]'
     |      Intersect multiple sorted sets specified by ``keys`` into a new
     |      sorted set, ``dest``. Scores in the destination will be aggregated
     |      based on the ``aggregate``.
     |
     |      Available aggregation modes:
     |
     |      - ``SUM`` (default): the score of an element is summed across the
     |        inputs where it exists.
     |        Score = SUM(score₁×weight₁, score₂×weight₂, ...)
     |      - ``MIN``: the resulting set will contain the minimum score of an
     |        element across the inputs where it exists.
     |        Score = MIN(score₁×weight₁, score₂×weight₂, ...)
     |      - ``MAX``: the resulting set will contain the maximum score of an
     |        element across the inputs where it exists.
     |        Score = MAX(score₁×weight₁, score₂×weight₂, ...)
     |      - ``COUNT``: ignores the original scores and counts weighted set
     |        membership. Each element's score is the sum of the weights of
     |        the input sets that contain it.
     |        Score = SUM(weight₁, weight₂, ...) for sets containing the element.
     |        When all weights are 1 (default), the score equals the number
     |        of input sets containing the element.
     |
     |      For more information, see https://redis.io/commands/zinterstore
     |
     |  zlexcount(self, name: 'KeyT', min: 'EncodableT', max: 'EncodableT') -> 'int | Awaitable[int]'
     |      Return the number of items in the sorted set ``name`` between the
     |      lexicographical range ``min`` and ``max``.
     |
     |      For more information, see https://redis.io/commands/zlexcount
     |
     |  zmpop(self, num_keys: 'int', keys: 'List[str]', min: 'bool | None' = False, max: 'bool | None' = False, count: 'int | None' = 1) -> 'ZMPopResponse | Awaitable[ZMPopResponse]'
     |      Pop ``count`` values (default 1) off of the first non-empty sorted set
     |      named in the ``keys`` list.
     |      For more information, see https://redis.io/commands/zmpop
     |
     |  zmscore(self, key: 'KeyT', members: 'List[str]') -> 'list[float | None] | Awaitable[list[float | None]]'
     |      Returns the scores associated with the specified members
     |      in the sorted set stored at key.
     |      ``members`` should be a list of the member name.
     |      Return type is a list of score.
     |      If the member does not exist, a None will be returned
     |      in corresponding position.
     |
     |      For more information, see https://redis.io/commands/zmscore
     |
     |  zpopmax(self, name: 'KeyT', count: 'int | None' = None) -> 'ZSetRangeResponse | Awaitable[ZSetRangeResponse]'
     |      Remove and return up to ``count`` members with the highest scores
     |      from the sorted set ``name``.
     |
     |      For more information, see https://redis.io/commands/zpopmax
     |
     |  zpopmin(self, name: 'KeyT', count: 'int | None' = None) -> 'ZSetRangeResponse | Awaitable[ZSetRangeResponse]'
     |      Remove and return up to ``count`` members with the lowest scores
     |      from the sorted set ``name``.
     |
     |      For more information, see https://redis.io/commands/zpopmin
     |
     |  zrandmember(self, key: 'KeyT', count: 'int | None' = None, withscores: 'bool' = False) -> 'ZRandMemberResponse | Awaitable[ZRandMemberResponse]'
     |      Return a random element from the sorted set value stored at key.
     |
     |      ``count`` if the argument is positive, return an array of distinct
     |      fields. If called with a negative count, the behavior changes and
     |      the command is allowed to return the same field multiple times.
     |      In this case, the number of returned fields is the absolute value
     |      of the specified count.
     |
     |      ``withscores`` The optional WITHSCORES modifier changes the reply so it
     |      includes the respective scores of the randomly selected elements from
     |      the sorted set.
     |
     |      For more information, see https://redis.io/commands/zrandmember
     |
     |  zrange(self, name: 'KeyT', start: 'EncodableT', end: 'EncodableT', desc: 'bool' = False, withscores: 'bool' = False, score_cast_func: 'type | Callable' = <class 'float'>, byscore: 'bool' = False, bylex: 'bool' = False, offset: 'int | None' = None, num: 'int | None' = None) -> 'ZSetRangeResponse | Awaitable[ZSetRangeResponse]'
     |      Return a range of values from sorted set ``name`` between
     |      ``start`` and ``end`` sorted in ascending order.
     |
     |      ``start`` and ``end`` can be negative, indicating the end of the range.
     |
     |      ``desc`` a boolean indicating whether to sort the results in reversed
     |      order.
     |
     |      ``withscores`` indicates to return the scores along with the values.
     |      The return type is a list of (value, score) pairs.
     |
     |      ``score_cast_func`` a callable used to cast the score return value.
     |
     |      ``byscore`` when set to True, returns the range of elements from the
     |      sorted set having scores equal or between ``start`` and ``end``.
     |
     |      ``bylex`` when set to True, returns the range of elements from the
     |      sorted set between the ``start`` and ``end`` lexicographical closed
     |      range intervals.
     |      Valid ``start`` and ``end`` must start with ( or [, in order to specify
     |      whether the range interval is exclusive or inclusive, respectively.
     |
     |      ``offset`` and ``num`` are specified, then return a slice of the range.
     |      Can't be provided when using ``bylex``.
     |
     |      For more information, see https://redis.io/commands/zrange
     |
     |  zrangebylex(self, name: 'KeyT', min: 'EncodableT', max: 'EncodableT', start: 'int | None' = None, num: 'int | None' = None) -> 'list[bytes | str] | Awaitable[list[bytes | str]]'
     |      Return the lexicographical range of values from sorted set ``name``
     |      between ``min`` and ``max``.
     |
     |      If ``start`` and ``num`` are specified, then return a slice of the
     |      range.
     |
     |      For more information, see https://redis.io/commands/zrangebylex
     |
     |  zrangebyscore(self, name: 'KeyT', min: 'ZScoreBoundT', max: 'ZScoreBoundT', start: 'int | None' = None, num: 'int | None' = None, withscores: 'bool' = False, score_cast_func: 'type | Callable' = <class 'float'>) -> 'ZSetRangeResponse | Awaitable[ZSetRangeResponse]'
     |      Return a range of values from the sorted set ``name`` with scores
     |      between ``min`` and ``max``.
     |
     |      If ``start`` and ``num`` are specified, then return a slice
     |      of the range.
     |
     |      ``withscores`` indicates to return the scores along with the values.
     |      The return type is a list of (value, score) pairs
     |
     |      `score_cast_func`` a callable used to cast the score return value
     |
     |      For more information, see https://redis.io/commands/zrangebyscore
     |
     |  zrangestore(self, dest: 'KeyT', name: 'KeyT', start: 'EncodableT', end: 'EncodableT', byscore: 'bool' = False, bylex: 'bool' = False, desc: 'bool' = False, offset: 'int | None' = None, num: 'int | None' = None) -> 'int | Awaitable[int]'
     |      Stores in ``dest`` the result of a range of values from sorted set
     |      ``name`` between ``start`` and ``end`` sorted in ascending order.
     |
     |      ``start`` and ``end`` can be negative, indicating the end of the range.
     |
     |      ``byscore`` when set to True, returns the range of elements from the
     |      sorted set having scores equal or between ``start`` and ``end``.
     |
     |      ``bylex`` when set to True, returns the range of elements from the
     |      sorted set between the ``start`` and ``end`` lexicographical closed
     |      range intervals.
     |      Valid ``start`` and ``end`` must start with ( or [, in order to specify
     |      whether the range interval is exclusive or inclusive, respectively.
     |
     |      ``desc`` a boolean indicating whether to sort the results in reversed
     |      order.
     |
     |      ``offset`` and ``num`` are specified, then return a slice of the range.
     |      Can't be provided when using ``bylex``.
     |
     |      For more information, see https://redis.io/commands/zrangestore
     |
     |  zrank(self, name: 'KeyT', value: 'EncodableT', withscore: 'bool' = False, score_cast_func: 'type | Callable' = <class 'float'>) -> 'int | list[Any] | None | Awaitable[int | list[Any] | None]'
     |      Returns a 0-based value indicating the rank of ``value`` in sorted set
     |      ``name``.
     |      The optional WITHSCORE argument supplements the command's
     |      reply with the score of the element returned.
     |
     |      ``score_cast_func`` a callable used to cast the score return value
     |
     |      For more information, see https://redis.io/commands/zrank
     |
     |  zrem(self, name: 'KeyT', *values: 'FieldT') -> 'int | Awaitable[int]'
     |      Remove member ``values`` from sorted set ``name``
     |
     |      For more information, see https://redis.io/commands/zrem
     |
     |  zremrangebylex(self, name: 'KeyT', min: 'EncodableT', max: 'EncodableT') -> 'int | Awaitable[int]'
     |      Remove all elements in the sorted set ``name`` between the
     |      lexicographical range specified by ``min`` and ``max``.
     |
     |      Returns the number of elements removed.
     |
     |      For more information, see https://redis.io/commands/zremrangebylex
     |
     |  zremrangebyrank(self, name: 'KeyT', min: 'int', max: 'int') -> 'int | Awaitable[int]'
     |      Remove all elements in the sorted set ``name`` with ranks between
     |      ``min`` and ``max``. Values are 0-based, ordered from smallest score
     |      to largest. Values can be negative indicating the highest scores.
     |      Returns the number of elements removed
     |
     |      For more information, see https://redis.io/commands/zremrangebyrank
     |
     |  zremrangebyscore(self, name: 'KeyT', min: 'ZScoreBoundT', max: 'ZScoreBoundT') -> 'int | Awaitable[int]'
     |      Remove all elements in the sorted set ``name`` with scores
     |      between ``min`` and ``max``. Returns the number of elements removed.
     |
     |      For more information, see https://redis.io/commands/zremrangebyscore
     |
     |  zrevrange(self, name: 'KeyT', start: 'int', end: 'int', withscores: 'bool' = False, score_cast_func: 'type | Callable' = <class 'float'>) -> 'ZSetRangeResponse | Awaitable[ZSetRangeResponse]'
     |      Return a range of values from sorted set ``name`` between
     |      ``start`` and ``end`` sorted in descending order.
     |
     |      ``start`` and ``end`` can be negative, indicating the end of the range.
     |
     |      ``withscores`` indicates to return the scores along with the values
     |      The return type is a list of (value, score) pairs
     |
     |      ``score_cast_func`` a callable used to cast the score return value
     |
     |      For more information, see https://redis.io/commands/zrevrange
     |
     |  zrevrangebylex(self, name: 'KeyT', max: 'EncodableT', min: 'EncodableT', start: 'int | None' = None, num: 'int | None' = None) -> 'list[bytes | str] | Awaitable[list[bytes | str]]'
     |      Return the reversed lexicographical range of values from sorted set
     |      ``name`` between ``max`` and ``min``.
     |
     |      If ``start`` and ``num`` are specified, then return a slice of the
     |      range.
     |
     |      For more information, see https://redis.io/commands/zrevrangebylex
     |
     |  zrevrangebyscore(self, name: 'KeyT', max: 'ZScoreBoundT', min: 'ZScoreBoundT', start: 'int | None' = None, num: 'int | None' = None, withscores: 'bool' = False, score_cast_func: 'type | Callable' = <class 'float'>) -> 'ZSetRangeResponse | Awaitable[ZSetRangeResponse]'
     |      Return a range of values from the sorted set ``name`` with scores
     |      between ``min`` and ``max`` in descending order.
     |
     |      If ``start`` and ``num`` are specified, then return a slice
     |      of the range.
     |
     |      ``withscores`` indicates to return the scores along with the values.
     |      The return type is a list of (value, score) pairs
     |
     |      ``score_cast_func`` a callable used to cast the score return value
     |
     |      For more information, see https://redis.io/commands/zrevrangebyscore
     |
     |  zrevrank(self, name: 'KeyT', value: 'EncodableT', withscore: 'bool' = False, score_cast_func: 'type | Callable' = <class 'float'>) -> 'int | list[Any] | None | Awaitable[int | list[Any] | None]'
     |      Returns a 0-based value indicating the descending rank of
     |      ``value`` in sorted set ``name``.
     |      The optional ``withscore`` argument supplements the command's
     |      reply with the score of the element returned.
     |
     |      ``score_cast_func`` a callable used to cast the score return value
     |
     |      For more information, see https://redis.io/commands/zrevrank
     |
     |  zscore(self, name: 'KeyT', value: 'EncodableT') -> 'float | None | Awaitable[float | None]'
     |      Return the score of element ``value`` in sorted set ``name``
     |
     |      For more information, see https://redis.io/commands/zscore
     |
     |  zunion(self, keys: 'Sequence[KeyT] | Mapping[AnyKeyT, float]', aggregate: 'str | None' = None, withscores: 'bool' = False, score_cast_func: 'type | Callable' = <class 'float'>) -> 'ZSetRangeResponse | Awaitable[ZSetRangeResponse]'
     |      Return the union of multiple sorted sets specified by ``keys``.
     |      ``keys`` can be provided as dictionary of keys and their weights.
     |      Scores will be aggregated based on the ``aggregate``, or SUM if
     |      none is provided.
     |
     |      Available aggregation modes:
     |
     |      - ``SUM`` (default): the score of an element is summed across the
     |        inputs where it exists.
     |        Score = SUM(score₁×weight₁, score₂×weight₂, ...)
     |      - ``MIN``: the resulting set will contain the minimum score of an
     |        element across the inputs where it exists.
     |        Score = MIN(score₁×weight₁, score₂×weight₂, ...)
     |      - ``MAX``: the resulting set will contain the maximum score of an
     |        element across the inputs where it exists.
     |        Score = MAX(score₁×weight₁, score₂×weight₂, ...)
     |      - ``COUNT``: ignores the original scores and counts weighted set
     |        membership. Each element's score is the sum of the weights of
     |        the input sets that contain it.
     |        Score = SUM(weight₁, weight₂, ...) for sets containing the element.
     |        When all weights are 1 (default), the score equals the number
     |        of input sets containing the element.
     |
     |      ``score_cast_func`` a callable used to cast the score return value
     |
     |      For more information, see https://redis.io/commands/zunion
     |
     |  zunionstore(self, dest: 'KeyT', keys: 'Sequence[KeyT] | Mapping[AnyKeyT, float]', aggregate: 'str | None' = None) -> 'int | Awaitable[int]'
     |      Union multiple sorted sets specified by ``keys`` into
     |      a new sorted set, ``dest``. Scores in the destination will be
     |      aggregated based on the ``aggregate``, or SUM if none is provided.
     |
     |      Available aggregation modes:
     |
     |      - ``SUM`` (default): the score of an element is summed across the
     |        inputs where it exists.
     |        Score = SUM(score₁×weight₁, score₂×weight₂, ...)
     |      - ``MIN``: the resulting set will contain the minimum score of an
     |        element across the inputs where it exists.
     |        Score = MIN(score₁×weight₁, score₂×weight₂, ...)
     |      - ``MAX``: the resulting set will contain the maximum score of an
     |        element across the inputs where it exists.
     |        Score = MAX(score₁×weight₁, score₂×weight₂, ...)
     |      - ``COUNT``: ignores the original scores and counts weighted set
     |        membership. Each element's score is the sum of the weights of
     |        the input sets that contain it.
     |        Score = SUM(weight₁, weight₂, ...) for sets containing the element.
     |        When all weights are 1 (default), the score equals the number
     |        of input sets containing the element.
     |
     |      For more information, see https://redis.io/commands/zunionstore
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from ManagementCommands:
     |
     |  auth(self, password: 'str', username: 'str | None' = None, **kwargs) -> 'bool | Awaitable[bool]'
     |      Authenticates the user. If you do not pass username, Redis will try to
     |      authenticate for the "default" user. If you do pass username, it will
     |      authenticate for the given user.
     |      For more information, see https://redis.io/commands/auth
     |
     |  bgrewriteaof(self, **kwargs) -> 'bool | bytes | str | Awaitable[bool | bytes | str]'
     |      Tell the Redis server to rewrite the AOF file from data in memory.
     |
     |      For more information, see https://redis.io/commands/bgrewriteaof
     |
     |  bgsave(self, schedule: 'bool' = True, **kwargs) -> 'bool | bytes | str | Awaitable[bool | bytes | str]'
     |      Tell the Redis server to save its data to disk.  Unlike save(),
     |      this method is asynchronous and returns immediately.
     |
     |      For more information, see https://redis.io/commands/bgsave
     |
     |  client_getname(self, **kwargs) -> 'bytes | str | None | Awaitable[bytes | str | None]'
     |      Returns the current connection name
     |
     |      For more information, see https://redis.io/commands/client-getname
     |
     |  client_getredir(self, **kwargs) -> 'int | Awaitable[int]'
     |      Returns the ID (an integer) of the client to whom we are
     |      redirecting tracking notifications.
     |
     |      see: https://redis.io/commands/client-getredir
     |
     |  client_id(self, **kwargs) -> 'int | Awaitable[int]'
     |      Returns the current connection id
     |
     |      For more information, see https://redis.io/commands/client-id
     |
     |  client_info(self, **kwargs) -> 'dict[str, str | int] | Awaitable[dict[str, str | int]]'
     |      Returns information and statistics about the current
     |      client connection.
     |
     |      For more information, see https://redis.io/commands/client-info
     |
     |  client_kill(self, address: 'str', **kwargs) -> 'bool | int | Awaitable[bool | int]'
     |      Disconnects the client at ``address`` (ip:port)
     |
     |      For more information, see https://redis.io/commands/client-kill
     |
     |  client_kill_filter(self, _id: 'str | None' = None, _type: 'str | None' = None, addr: 'str | None' = None, skipme: 'bool | None' = None, laddr: 'bool | None' = None, user: 'str | None' = None, maxage: 'int | None' = None, **kwargs) -> 'int | Awaitable[int]'
     |      Disconnects client(s) using a variety of filter options
     |      :param _id: Kills a client by its unique ID field
     |      :param _type: Kills a client by type where type is one of 'normal',
     |      'master', 'slave', 'replica' or 'pubsub'
     |      :param addr: Kills a client by its 'address:port'
     |      :param skipme: If True, then the client calling the command
     |      will not get killed even if it is identified by one of the filter
     |      options. If skipme is not provided, the server defaults to skipme=True
     |      :param laddr: Kills a client by its 'local (bind) address:port'
     |      :param user: Kills a client for a specific user name
     |      :param maxage: Kills clients that are older than the specified age in seconds
     |
     |  client_list(self, _type: 'str | None' = None, client_id: 'List[EncodableT]' = [], **kwargs) -> 'list[dict[str, str]] | Awaitable[list[dict[str, str]]]'
     |      Returns a list of currently connected clients.
     |      If type of client specified, only that type will be returned.
     |
     |      :param _type: optional. one of the client types (normal, master,
     |       replica, pubsub)
     |      :param client_id: optional. a list of client ids
     |
     |      For more information, see https://redis.io/commands/client-list
     |
     |  client_no_evict(self, mode: 'str') -> 'bytes | str | Awaitable[bytes | str]'
     |      Sets the client eviction mode for the current connection.
     |
     |      For more information, see https://redis.io/commands/client-no-evict
     |
     |  client_no_touch(self, mode: 'str') -> 'bytes | str | Awaitable[bytes | str]'
     |      # The command controls whether commands sent by the client will alter
     |      # the LRU/LFU of the keys they access.
     |      # When turned on, the current client will not change LFU/LRU stats,
     |      # unless it sends the TOUCH command.
     |
     |      For more information, see https://redis.io/commands/client-no-touch
     |
     |  client_pause(self, timeout: 'int', all: 'bool' = True, **kwargs) -> 'bool | Awaitable[bool]'
     |      Suspend all the Redis clients for the specified amount of time.
     |
     |
     |      For more information, see https://redis.io/commands/client-pause
     |
     |      Args:
     |          timeout: milliseconds to pause clients
     |          all: If true (default) all client commands are blocked.
     |               otherwise, clients are only blocked if they attempt to execute
     |               a write command.
     |
     |      For the WRITE mode, some commands have special behavior:
     |
     |      * EVAL/EVALSHA: Will block client for all scripts.
     |      * PUBLISH: Will block client.
     |      * PFCOUNT: Will block client.
     |      * WAIT: Acknowledgments will be delayed, so this command will
     |          appear blocked.
     |
     |  client_reply(self, reply: "Literal['ON', 'OFF', 'SKIP']", **kwargs) -> 'bytes | str | Awaitable[bytes | str]'
     |      Enable and disable redis server replies.
     |
     |      ``reply`` Must be ON OFF or SKIP,
     |      ON - The default most with server replies to commands
     |      OFF - Disable server responses to commands
     |      SKIP - Skip the response of the immediately following command.
     |
     |      Note: When setting OFF or SKIP replies, you will need a client object
     |      with a timeout specified in seconds, and will need to catch the
     |      TimeoutError.
     |      The test_client_reply unit test illustrates this, and
     |      conftest.py has a client with a timeout.
     |
     |      See https://redis.io/commands/client-reply
     |
     |  client_setinfo(self, attr: 'str', value: 'str', **kwargs) -> 'bool | Awaitable[bool]'
     |      Sets the current connection library name or version
     |      For more information see https://redis.io/commands/client-setinfo
     |
     |  client_setname(self, name: 'str', **kwargs) -> 'bool | Awaitable[bool]'
     |      Sets the current connection name
     |
     |      For more information, see https://redis.io/commands/client-setname
     |
     |      .. note::
     |         This method sets client name only for **current** connection.
     |
     |         If you want to set a common name for all connections managed
     |         by this client, use ``client_name`` constructor argument.
     |
     |  client_tracking(self, on: 'bool' = True, clientid: 'int | None' = None, prefix: 'Sequence[KeyT]' = [], bcast: 'bool' = False, optin: 'bool' = False, optout: 'bool' = False, noloop: 'bool' = False, **kwargs) -> 'bytes | str | Awaitable[bytes | str]'
     |      Enables the tracking feature of the Redis server, that is used
     |      for server assisted client side caching.
     |
     |      ``on`` indicate for tracking on or tracking off. The default is on.
     |
     |      ``clientid`` send invalidation messages to the connection with
     |      the specified ID.
     |
     |      ``bcast`` enable tracking in broadcasting mode. In this mode
     |      invalidation messages are reported for all the prefixes
     |      specified, regardless of the keys requested by the connection.
     |
     |      ``optin``  when broadcasting is NOT active, normally don't track
     |      keys in read only commands, unless they are called immediately
     |      after a CLIENT CACHING yes command.
     |
     |      ``optout`` when broadcasting is NOT active, normally track keys in
     |      read only commands, unless they are called immediately after a
     |      CLIENT CACHING no command.
     |
     |      ``noloop`` don't send notifications about keys modified by this
     |      connection itself.
     |
     |      ``prefix``  for broadcasting, register a given key prefix, so that
     |      notifications will be provided only for keys starting with this string.
     |
     |      See https://redis.io/commands/client-tracking
     |
     |  client_tracking_off(self, clientid: 'int | None' = None, prefix: 'Sequence[KeyT]' = [], bcast: 'bool' = False, optin: 'bool' = False, optout: 'bool' = False, noloop: 'bool' = False) -> 'bytes | str | Awaitable[bytes | str]'
     |      Turn off the tracking mode.
     |      For more information, about the options look at client_tracking func.
     |
     |      See https://redis.io/commands/client-tracking
     |
     |  client_tracking_on(self, clientid: 'int | None' = None, prefix: 'Sequence[KeyT]' = [], bcast: 'bool' = False, optin: 'bool' = False, optout: 'bool' = False, noloop: 'bool' = False) -> 'bytes | str | Awaitable[bytes | str]'
     |      Turn on the tracking mode.
     |      For more information, about the options look at client_tracking func.
     |
     |      See https://redis.io/commands/client-tracking
     |
     |  client_trackinginfo(self, **kwargs) -> 'ClientTrackingInfoResponse | Awaitable[ClientTrackingInfoResponse]'
     |      Returns the information about the current client connection's
     |      use of the server assisted client side cache.
     |
     |      See https://redis.io/commands/client-trackinginfo
     |
     |  client_unblock(self, client_id: 'int', error: 'bool' = False, **kwargs) -> 'bool | Awaitable[bool]'
     |      Unblocks a connection by its client id.
     |      If ``error`` is True, unblocks the client with a special error message.
     |      If ``error`` is False (default), the client is unblocked using the
     |      regular timeout mechanism.
     |
     |      For more information, see https://redis.io/commands/client-unblock
     |
     |  client_unpause(self, **kwargs) -> 'bytes | str | Awaitable[bytes | str]'
     |      Unpause all redis clients
     |
     |      For more information, see https://redis.io/commands/client-unpause
     |
     |  command(self, **kwargs) -> 'dict[str, dict[str, Any]] | Awaitable[dict[str, dict[str, Any]]]'
     |      Returns dict reply of details about all Redis commands.
     |
     |      For more information, see https://redis.io/commands/command
     |
     |  command_count(self, **kwargs) -> 'int | Awaitable[int]'
     |
     |  command_docs(self, *args)
     |      This function throws a NotImplementedError since it is intentionally
     |      not supported.
     |
     |  command_getkeysandflags(self, *args: 'str') -> 'CommandGetKeysAndFlagsResponse | Awaitable[CommandGetKeysAndFlagsResponse]'
     |      Returns array of keys from a full Redis command and their usage flags.
     |
     |      For more information, see https://redis.io/commands/command-getkeysandflags
     |
     |  command_info(self, **kwargs) -> 'None'
     |
     |  command_list(self, module: 'str | None' = None, category: 'str | None' = None, pattern: 'str | None' = None) -> 'list[bytes | str] | Awaitable[list[bytes | str]]'
     |      Return an array of the server's command names.
     |      You can use one of the following filters:
     |      ``module``: get the commands that belong to the module
     |      ``category``: get the commands in the ACL category
     |      ``pattern``: get the commands that match the given pattern
     |
     |      For more information, see https://redis.io/commands/command-list/
     |
     |  config_get(self, pattern: 'PatternT' = '*', *args: 'PatternT', **kwargs) -> 'dict[str | None, str | None] | Awaitable[dict[str | None, str | None]]'
     |      Return a dictionary of configuration based on the ``pattern``
     |
     |      For more information, see https://redis.io/commands/config-get
     |
     |  config_resetstat(self, **kwargs) -> 'bool | Awaitable[bool]'
     |      Reset runtime statistics
     |
     |      For more information, see https://redis.io/commands/config-resetstat
     |
     |  config_rewrite(self, **kwargs) -> 'bytes | str | Awaitable[bytes | str]'
     |      Rewrite config file with the minimal change to reflect running config.
     |
     |      For more information, see https://redis.io/commands/config-rewrite
     |
     |  config_set(self, name: 'KeyT', value: 'EncodableT', *args: 'Union[KeyT, EncodableT]', **kwargs) -> 'bool | Awaitable[bool]'
     |      Set config item ``name`` with ``value``
     |
     |      For more information, see https://redis.io/commands/config-set
     |
     |  dbsize(self, **kwargs) -> 'int | Awaitable[int]'
     |      Returns the number of keys in the current database
     |
     |      For more information, see https://redis.io/commands/dbsize
     |
     |  debug_object(self, key: 'KeyT', **kwargs) -> 'dict[str, str | int] | bytes | str | Awaitable[dict[str, str | int] | bytes | str]'
     |      Returns version specific meta information about a given key
     |
     |      For more information, see https://redis.io/commands/debug-object
     |
     |  debug_segfault(self, **kwargs) -> 'None'
     |
     |  echo(self, value: 'EncodableT', **kwargs) -> 'bytes | str | Awaitable[bytes | str]'
     |      Echo the string back from the server
     |
     |      For more information, see https://redis.io/commands/echo
     |
     |  failover(self)
     |      This function throws a NotImplementedError since it is intentionally
     |      not supported.
     |
     |  flushall(self, asynchronous: 'bool' = False, **kwargs) -> 'bool | Awaitable[bool]'
     |      Delete all keys in all databases on the current host.
     |
     |      ``asynchronous`` indicates whether the operation is
     |      executed asynchronously by the server.
     |
     |      For more information, see https://redis.io/commands/flushall
     |
     |  flushdb(self, asynchronous: 'bool' = False, **kwargs) -> 'bool | Awaitable[bool]'
     |      Delete all keys in the current database.
     |
     |      ``asynchronous`` indicates whether the operation is
     |      executed asynchronously by the server.
     |
     |      For more information, see https://redis.io/commands/flushdb
     |
     |  hello(self)
     |      This function throws a NotImplementedError since it is intentionally
     |      not supported.
     |
     |  hotkeys_get(self, **kwargs) -> 'Union[Awaitable[list[dict[str | bytes, Any]]], list[dict[str | bytes, Any]]]'
     |      Retrieve the result of the ongoing collection session (if any),
     |      or the last collection session (if any).
     |
     |      HOTKEYS GET response is wrapped in an array for aggregation support.
     |      Each node returns a single-element array, allowing multiple node
     |      responses to be concatenated by DMC or other aggregators.
     |
     |      For more information, see https://redis.io/commands/hotkeys-get
     |
     |  hotkeys_reset(self, **kwargs) -> 'bytes | str | Awaitable[bytes | str]'
     |      Discard the last hotkeys collection session results (in order to save memory).
     |      Error if there is an ongoing collection session.
     |
     |      For more information, see https://redis.io/commands/hotkeys-reset
     |
     |  hotkeys_start(self, metrics: 'List[HotkeysMetricsTypes]', count: 'int | None' = None, duration: 'int | None' = None, sample_ratio: 'int | None' = None, slots: 'List[int] | None' = None, **kwargs) -> 'bytes | str | Awaitable[bytes | str]'
     |      Start collecting hotkeys data.
     |      Returns an error if there is an ongoing collection session.
     |
     |      Args:
     |          count: The number of keys to collect in each criteria (CPU and network consumption)
     |          metrics: List of metrics to track. Supported values: [HotkeysMetricsTypes.CPU, HotkeysMetricsTypes.NET]
     |          duration: Automatically stop the collection after `duration` seconds
     |          sample_ratio: Commands are sampled with probability 1/ratio (1 means no sampling)
     |          slots: Only track keys on the specified hash slots
     |
     |      For more information, see https://redis.io/commands/hotkeys-start
     |
     |  hotkeys_stop(self, **kwargs) -> 'bytes | str | Awaitable[bytes | str]'
     |      Stop the ongoing hotkeys collection session (if any).
     |      The results of the last collection session are kept for consumption with HOTKEYS GET.
     |
     |      For more information, see https://redis.io/commands/hotkeys-stop
     |
     |  info(self, section: 'Optional[str]' = None, *args: 'str', **kwargs) -> 'dict[str, Any] | Awaitable[dict[str, Any]]'
     |      Returns a dictionary containing information about the Redis server
     |
     |      The ``section`` option can be used to select a specific section
     |      of information
     |
     |      The section option is not supported by older versions of Redis Server,
     |      and will generate ResponseError
     |
     |      For more information, see https://redis.io/commands/info
     |
     |  lastsave(self, **kwargs) -> 'datetime.datetime | Awaitable[datetime.datetime]'
     |      Return a Python datetime object representing the last time the
     |      Redis database was saved to disk
     |
     |      For more information, see https://redis.io/commands/lastsave
     |
     |  latency_doctor(self)
     |      Raise a NotImplementedError, as the client will not support LATENCY DOCTOR.
     |      This function is best used within the redis-cli.
     |
     |      For more information, see https://redis.io/commands/latency-doctor
     |
     |  latency_graph(self)
     |      Raise a NotImplementedError, as the client will not support LATENCY GRAPH.
     |      This function is best used within the redis-cli.
     |
     |      For more information, see https://redis.io/commands/latency-graph.
     |
     |  latency_histogram(self, *args)
     |      This function throws a NotImplementedError since it is intentionally
     |      not supported.
     |
     |  latency_history(self, event: 'str') -> 'list[list[int]] | Awaitable[list[list[int]]]'
     |      Returns the raw data of the ``event``'s latency spikes time series.
     |
     |      For more information, see https://redis.io/commands/latency-history
     |
     |  latency_latest(self) -> 'list[list[bytes | str | int]] | Awaitable[list[list[bytes | str | int]]]'
     |      Reports the latest latency events logged.
     |
     |      For more information, see https://redis.io/commands/latency-latest
     |
     |  latency_reset(self, *events: 'str') -> 'int | Awaitable[int]'
     |      Resets the latency spikes time series of all, or only some, events.
     |
     |      For more information, see https://redis.io/commands/latency-reset
     |
     |  lolwut(self, *version_numbers: 'Union[str, float]', **kwargs) -> 'bytes | str | Awaitable[bytes | str]'
     |      Get the Redis version and a piece of generative computer art
     |
     |      See: https://redis.io/commands/lolwut
     |
     |  memory_doctor(self, **kwargs) -> 'None'
     |
     |  memory_help(self, **kwargs) -> 'None'
     |
     |  memory_malloc_stats(self, **kwargs) -> 'bytes | str | Awaitable[bytes | str]'
     |      Return an internal statistics report from the memory allocator.
     |
     |      See: https://redis.io/commands/memory-malloc-stats
     |
     |  memory_purge(self, **kwargs) -> 'bool | Awaitable[bool]'
     |      Attempts to purge dirty pages for reclamation by allocator
     |
     |      For more information, see https://redis.io/commands/memory-purge
     |
     |  memory_stats(self, **kwargs) -> 'dict[str, Any] | Awaitable[dict[str, Any]]'
     |      Return a dictionary of memory stats
     |
     |      For more information, see https://redis.io/commands/memory-stats
     |
     |  memory_usage(self, key: 'KeyT', samples: 'int | None' = None, **kwargs) -> 'int | None | Awaitable[int | None]'
     |      Return the total memory usage for key, its value and associated
     |      administrative overheads.
     |
     |      For nested data structures, ``samples`` is the number of elements to
     |      sample. If left unspecified, the server's default is 5. Use 0 to sample
     |      all elements.
     |
     |      For more information, see https://redis.io/commands/memory-usage
     |
     |  migrate(self, host: 'str', port: 'int', keys: 'KeysT', destination_db: 'int', timeout: 'int', copy: 'bool' = False, replace: 'bool' = False, auth: 'str | None' = None, **kwargs) -> 'bytes | str | Awaitable[bytes | str]'
     |      Migrate 1 or more keys from the current Redis server to a different
     |      server specified by the ``host``, ``port`` and ``destination_db``.
     |
     |      The ``timeout``, specified in milliseconds, indicates the maximum
     |      time the connection between the two servers can be idle before the
     |      command is interrupted.
     |
     |      If ``copy`` is True, the specified ``keys`` are NOT deleted from
     |      the source server.
     |
     |      If ``replace`` is True, this operation will overwrite the keys
     |      on the destination server if they exist.
     |
     |      If ``auth`` is specified, authenticate to the destination server with
     |      the password provided.
     |
     |      For more information, see https://redis.io/commands/migrate
     |
     |  object(self, infotype: 'str', key: 'KeyT', **kwargs) -> 'Any | Awaitable[Any]'
     |      Return the encoding, idletime, or refcount about the key
     |
     |  ping(self, **kwargs) -> 'Union[Awaitable[bool], bool]'
     |      Ping the Redis server to test connectivity.
     |
     |      Sends a PING command to the Redis server and returns True if the server
     |      responds with "PONG".
     |
     |      This command is useful for:
     |      - Testing whether a connection is still alive
     |      - Verifying the server's ability to serve data
     |
     |      For more information on the underlying ping command see https://redis.io/commands/ping
     |
     |  psync(self, replicationid: 'str', offset: 'int') -> 'bytes | Awaitable[bytes]'
     |      Initiates a replication stream from the master.
     |      Newer version for `sync`.
     |
     |      For more information, see https://redis.io/commands/sync
     |
     |  quit(self, **kwargs) -> 'bool | Awaitable[bool]'
     |      Ask the server to close the connection.
     |
     |      For more information, see https://redis.io/commands/quit
     |
     |  replicaof(self, *args, **kwargs) -> 'bytes | str | Awaitable[bytes | str]'
     |      Update the replication settings of a redis replica, on the fly.
     |
     |      Examples of valid arguments include:
     |
     |      NO ONE (set no replication)
     |      host port (set to the host and port of a redis server)
     |
     |      For more information, see  https://redis.io/commands/replicaof
     |
     |  reset(self) -> 'bytes | str | Awaitable[bytes | str]'
     |      Perform a full reset on the connection's server-side context.
     |
     |      See: https://redis.io/commands/reset
     |
     |  role(self) -> 'list[Any] | Awaitable[list[Any]]'
     |      Provide information on the role of a Redis instance in
     |      the context of replication, by returning if the instance
     |      is currently a master, slave, or sentinel.
     |
     |      For more information, see https://redis.io/commands/role
     |
     |  save(self, **kwargs) -> 'bool | Awaitable[bool]'
     |      Tell the Redis server to save its data to disk,
     |      blocking until the save is complete
     |
     |      For more information, see https://redis.io/commands/save
     |
     |  select(self, index: 'int', **kwargs) -> 'bool | Awaitable[bool]'
     |      Select the Redis logical database at index.
     |
     |      See: https://redis.io/commands/select
     |
     |  shutdown(self, save: 'bool' = False, nosave: 'bool' = False, now: 'bool' = False, force: 'bool' = False, abort: 'bool' = False, **kwargs) -> 'None'
     |      Shutdown the Redis server.  If Redis has persistence configured,
     |      data will be flushed before shutdown.
     |      It is possible to specify modifiers to alter the behavior of the command:
     |      ``save`` will force a DB saving operation even if no save points are configured.
     |      ``nosave`` will prevent a DB saving operation even if one or more save points
     |      are configured.
     |      ``now`` skips waiting for lagging replicas, i.e. it bypasses the first step in
     |      the shutdown sequence.
     |      ``force`` ignores any errors that would normally prevent the server from exiting
     |      ``abort`` cancels an ongoing shutdown and cannot be combined with other flags.
     |
     |      For more information, see https://redis.io/commands/shutdown
     |
     |  slaveof(self, host: 'str | None' = None, port: 'int | None' = None, **kwargs) -> 'bool | Awaitable[bool]'
     |      Set the server to be a replicated slave of the instance identified
     |      by the ``host`` and ``port``. If called without arguments, the
     |      instance is promoted to a master instead.
     |
     |      For more information, see https://redis.io/commands/slaveof
     |
     |  slowlog_get(self, num: 'int | None' = None, **kwargs) -> 'list[dict[str, Any]] | Awaitable[list[dict[str, Any]]]'
     |      Get the entries from the slowlog. If ``num`` is specified, get the
     |      most recent ``num`` items.
     |
     |      For more information, see https://redis.io/commands/slowlog-get
     |
     |  slowlog_len(self, **kwargs) -> 'int | Awaitable[int]'
     |      Get the number of items in the slowlog
     |
     |      For more information, see https://redis.io/commands/slowlog-len
     |
     |  slowlog_reset(self, **kwargs) -> 'bool | Awaitable[bool]'
     |      Remove all items in the slowlog
     |
     |      For more information, see https://redis.io/commands/slowlog-reset
     |
     |  swapdb(self, first: 'int', second: 'int', **kwargs) -> 'bool | Awaitable[bool]'
     |      Swap two databases
     |
     |      For more information, see https://redis.io/commands/swapdb
     |
     |  sync(self) -> 'bytes | Awaitable[bytes]'
     |      Initiates a replication stream from the master.
     |
     |      For more information, see https://redis.io/commands/sync
     |
     |  time(self, **kwargs) -> 'tuple[int, int] | Awaitable[tuple[int, int]]'
     |      Returns the server time as a 2-item tuple of ints:
     |      (seconds since epoch, microseconds into this second).
     |
     |      For more information, see https://redis.io/commands/time
     |
     |  wait(self, num_replicas: 'int', timeout: 'int', **kwargs) -> 'int | Awaitable[int]'
     |      Redis synchronous replication
     |      That returns the number of replicas that processed the query when
     |      we finally have at least ``num_replicas``, or when the ``timeout`` was
     |      reached.
     |
     |      For more information, see https://redis.io/commands/wait
     |
     |  waitaof(self, num_local: 'int', num_replicas: 'int', timeout: 'int', **kwargs) -> 'list[int] | Awaitable[list[int]]'
     |      This command blocks the current client until all previous write
     |      commands by that client are acknowledged as having been fsynced
     |      to the AOF of the local Redis and/or at least the specified number
     |      of replicas.
     |
     |      For more information, see https://redis.io/commands/waitaof
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from ModuleCommands:
     |
     |  command_getkeys(self, *args) -> 'list[bytes | str] | Awaitable[list[bytes | str]]'
     |
     |  module_list(self) -> 'list[dict[Any, Any]] | Awaitable[list[dict[Any, Any]]]'
     |      Returns a list of dictionaries containing the name and version of
     |      all loaded modules.
     |
     |      For more information, see https://redis.io/commands/module-list
     |
     |  module_load(self, path, *args) -> 'bool | Awaitable[bool]'
     |      Loads the module from ``path``.
     |      Passes all ``*args`` to the module, during loading.
     |      Raises ``ModuleError`` if a module is not found at ``path``.
     |
     |      For more information, see https://redis.io/commands/module-load
     |
     |  module_loadex(self, path: 'str', options: 'List[str] | None' = None, args: 'List[str] | None' = None) -> 'bytes | str | Awaitable[bytes | str]'
     |      Loads a module from a dynamic library at runtime with configuration directives.
     |
     |      For more information, see https://redis.io/commands/module-loadex
     |
     |  module_unload(self, name) -> 'bool | Awaitable[bool]'
     |      Unloads the module ``name``.
     |      Raises ``ModuleError`` if ``name`` is not in loaded modules.
     |
     |      For more information, see https://redis.io/commands/module-unload
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from PubSubCommands:
     |
     |  publish(self, channel: 'ChannelT', message: 'EncodableT', **kwargs) -> 'int | Awaitable[int]'
     |      Publish ``message`` on ``channel``.
     |      Returns the number of subscribers the message was delivered to.
     |
     |      For more information, see https://redis.io/commands/publish
     |
     |  pubsub_channels(self, pattern: 'PatternT' = '*', **kwargs) -> 'list[bytes | str] | Awaitable[list[bytes | str]]'
     |      Return a list of channels that have at least one subscriber
     |
     |      For more information, see https://redis.io/commands/pubsub-channels
     |
     |  pubsub_numpat(self, **kwargs) -> 'int | Awaitable[int]'
     |      Returns the number of subscriptions to patterns
     |
     |      For more information, see https://redis.io/commands/pubsub-numpat
     |
     |  pubsub_numsub(self, *args: 'ChannelT', **kwargs) -> 'list[tuple[bytes | str, int]] | Awaitable[list[tuple[bytes | str, int]]]'
     |      Return a list of (channel, number of subscribers) tuples
     |      for each channel given in ``*args``
     |
     |      For more information, see https://redis.io/commands/pubsub-numsub
     |
     |  pubsub_shardchannels(self, pattern: 'PatternT' = '*', **kwargs) -> 'list[bytes | str] | Awaitable[list[bytes | str]]'
     |      Return a list of shard_channels that have at least one subscriber
     |
     |      For more information, see https://redis.io/commands/pubsub-shardchannels
     |
     |  pubsub_shardnumsub(self, *args: 'ChannelT', **kwargs) -> 'list[tuple[bytes | str, int]] | Awaitable[list[tuple[bytes | str, int]]]'
     |      Return a list of (shard_channel, number of subscribers) tuples
     |      for each channel given in ``*args``
     |
     |      For more information, see https://redis.io/commands/pubsub-shardnumsub
     |
     |  spublish(self, shard_channel: 'ChannelT', message: 'EncodableT') -> 'int | Awaitable[int]'
     |      Posts a message to the given shard channel.
     |      Returns the number of clients that received the message
     |
     |      For more information, see https://redis.io/commands/spublish
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from ScriptCommands:
     |
     |  eval(self, script: 'str', numkeys: 'int', *keys_and_args: 'KeyT | EncodableT') -> 'Any | Awaitable[Any]'
     |      Execute the Lua ``script``, specifying the ``numkeys`` the script
     |      will touch and the key names and argument values in ``keys_and_args``.
     |      Returns the result of the script.
     |
     |      In practice, use the object returned by ``register_script``. This
     |      function exists purely for Redis API completion.
     |
     |      For more information, see  https://redis.io/commands/eval
     |
     |  eval_ro(self, script: 'str', numkeys: 'int', *keys_and_args: 'KeyT | EncodableT') -> 'Any | Awaitable[Any]'
     |      The read-only variant of the EVAL command
     |
     |      Execute the read-only Lua ``script`` specifying the ``numkeys`` the script
     |      will touch and the key names and argument values in ``keys_and_args``.
     |      Returns the result of the script.
     |
     |      For more information, see  https://redis.io/commands/eval_ro
     |
     |  evalsha(self, sha: 'str', numkeys: 'int', *keys_and_args: 'KeyT | EncodableT') -> 'Any | Awaitable[Any]'
     |      Use the ``sha`` to execute a Lua script already registered via EVAL
     |      or SCRIPT LOAD. Specify the ``numkeys`` the script will touch and the
     |      key names and argument values in ``keys_and_args``. Returns the result
     |      of the script.
     |
     |      In practice, use the object returned by ``register_script``. This
     |      function exists purely for Redis API completion.
     |
     |      For more information, see  https://redis.io/commands/evalsha
     |
     |  evalsha_ro(self, sha: 'str', numkeys: 'int', *keys_and_args: 'KeyT | EncodableT') -> 'Any | Awaitable[Any]'
     |      The read-only variant of the EVALSHA command
     |
     |      Use the ``sha`` to execute a read-only Lua script already registered via EVAL
     |      or SCRIPT LOAD. Specify the ``numkeys`` the script will touch and the
     |      key names and argument values in ``keys_and_args``. Returns the result
     |      of the script.
     |
     |      For more information, see  https://redis.io/commands/evalsha_ro
     |
     |  register_script(self: "Union['redis.client.Redis', 'redis.cluster.RedisCluster']", script: 'ScriptTextT') -> 'Script'
     |      Register a Lua ``script`` specifying the ``keys`` it will touch.
     |      Returns a Script object that is callable and hides the complexity of
     |      deal with scripts, keys, and shas. This is the preferred way to work
     |      with Lua scripts.
     |
     |  script_debug(self, *args) -> 'None'
     |
     |  script_exists(self, *args: 'str') -> 'list[bool] | Awaitable[list[bool]]'
     |      Check if a script exists in the script cache by specifying the SHAs of
     |      each script as ``args``. Returns a list of boolean values indicating if
     |      if each already script exists in the cache_data.
     |
     |      For more information, see  https://redis.io/commands/script-exists
     |
     |  script_flush(self, sync_type: "Literal['SYNC'] | Literal['ASYNC'] | None" = None) -> 'bool | Awaitable[bool]'
     |      Flush all scripts from the script cache_data.
     |
     |      ``sync_type`` is by default SYNC (synchronous) but it can also be
     |                    ASYNC.
     |
     |      For more information, see  https://redis.io/commands/script-flush
     |
     |  script_kill(self) -> 'bool | Awaitable[bool]'
     |      Kill the currently executing Lua script
     |
     |      For more information, see https://redis.io/commands/script-kill
     |
     |  script_load(self, script: 'ScriptTextT') -> 'str | Awaitable[str]'
     |      Load a Lua ``script`` into the script cache_data. Returns the SHA.
     |
     |      For more information, see https://redis.io/commands/script-load
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from redis.typing.CommandsProtocol:
     |
     |  __init__ = _no_init_or_replace_init(self, *args, **kwargs) from typing
     |
     |  execute_command(self, *args, **options) -> Union[Awaitable[Any], Any]
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors inherited from redis.typing.CommandsProtocol:
     |
     |  __dict__
     |      dictionary for instance variables
     |
     |  __weakref__
     |      list of weak references to the object
     |
     |  ----------------------------------------------------------------------
     |  Data and other attributes inherited from redis.typing.CommandsProtocol:
     |
     |  __protocol_attrs__ = {'_event_dispatcher', 'execute_command'}
     |
     |  ----------------------------------------------------------------------
     |  Class methods inherited from typing.Protocol:
     |
     |  __init_subclass__(*args, **kwargs)
     |      Function to initialize subclasses.
     |
     |  ----------------------------------------------------------------------
     |  Class methods inherited from typing.Generic:
     |
     |  __class_getitem__(...)
     |      Parameterizes a generic class.
     |
     |      At least, parameterizing a generic class is the *main* thing this
     |      method does. For example, for some generic class `Foo`, this is called
     |      when we do `Foo[int]` - there, with `cls=Foo` and `params=int`.
     |
     |      However, note that this method is also called when defining generic
     |      classes in the first place with `class Foo[T]: ...`.
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from FunctionCommands:
     |
     |  fcall(self, function, numkeys: 'int', *keys_and_args: 'Any') -> 'Any | Awaitable[Any]'
     |      Invoke a function.
     |
     |      For more information, see https://redis.io/commands/fcall
     |
     |  fcall_ro(self, function, numkeys: 'int', *keys_and_args: 'Any') -> 'Any | Awaitable[Any]'
     |      This is a read-only variant of the FCALL command that cannot
     |      execute commands that modify data.
     |
     |      For more information, see https://redis.io/commands/fcall_ro
     |
     |  function_delete(self, library: 'str') -> 'bool | Awaitable[bool]'
     |      Delete the library called ``library`` and all its functions.
     |
     |      For more information, see https://redis.io/commands/function-delete
     |
     |  function_dump(self) -> 'bytes | Awaitable[bytes]'
     |      Return the serialized payload of loaded libraries.
     |
     |      For more information, see https://redis.io/commands/function-dump
     |
     |  function_flush(self, mode: 'str' = 'SYNC') -> 'bool | Awaitable[bool]'
     |      Deletes all the libraries.
     |
     |      For more information, see https://redis.io/commands/function-flush
     |
     |  function_kill(self) -> 'bytes | str | Awaitable[bytes | str]'
     |      Kill a function that is currently executing.
     |
     |      For more information, see https://redis.io/commands/function-kill
     |
     |  function_list(self, library: 'str | None' = '*', withcode: 'bool | None' = False) -> 'list[Any] | Awaitable[list[Any]]'
     |      Return information about the functions and libraries.
     |
     |      Args:
     |
     |          library: specify a pattern for matching library names
     |          withcode: cause the server to include the libraries source implementation
     |              in the reply
     |
     |  function_load(self, code: 'str', replace: 'bool | None' = False) -> 'bytes | str | Awaitable[bytes | str]'
     |      Load a library to Redis.
     |      :param code: the source code (must start with
     |      Shebang statement that provides a metadata about the library)
     |      :param replace: changes the behavior to overwrite the existing library
     |      with the new contents.
     |      Return the library name that was loaded.
     |
     |      For more information, see https://redis.io/commands/function-load
     |
     |  function_restore(self, payload: 'str', policy: 'str | None' = 'APPEND') -> 'bool | Awaitable[bool]'
     |      Restore libraries from the serialized ``payload``.
     |      You can use the optional policy argument to provide a policy
     |      for handling existing libraries.
     |
     |      For more information, see https://redis.io/commands/function-restore
     |
     |  function_stats(self) -> 'Any | Awaitable[Any]'
     |      Return information about the function that's currently running
     |      and information about the available execution engines.
     |
     |      For more information, see https://redis.io/commands/function-stats

    class RedisClusterCommands(ClusterMultiKeyCommands, ClusterManagementCommands, redis.commands.core.ACLCommands, redis.commands.core.PubSubCommands, ClusterDataAccessCommands, redis.commands.core.ScriptCommands, redis.commands.core.FunctionCommands, redis.commands.core.ModuleCommands, redis.commands.redismodules.RedisModuleCommands)
     |  RedisClusterCommands(*args, **kwargs)
     |
     |  A class for all Redis Cluster commands
     |
     |  For key-based commands, the target node(s) will be internally determined
     |  by the keys' hash slot.
     |  Non-key-based commands can be executed with the 'target_nodes' argument to
     |  target specific nodes. By default, if target_nodes is not specified, the
     |  command will be executed on the default cluster node.
     |
     |  :param :target_nodes: type can be one of the followings:
     |      - nodes flag: ALL_NODES, PRIMARIES, REPLICAS, RANDOM
     |      - 'ClusterNode'
     |      - 'list(ClusterNodes)'
     |      - 'dict(any:clusterNodes)'
     |
     |  for example:
     |      r.cluster_info(target_nodes=RedisCluster.ALL_NODES)
     |
     |  Method resolution order:
     |      RedisClusterCommands
     |      ClusterMultiKeyCommands
     |      redis.typing.ClusterCommandsProtocol
     |      ClusterManagementCommands
     |      redis.commands.core.ManagementCommands
     |      redis.commands.core.ACLCommands
     |      redis.commands.core.PubSubCommands
     |      ClusterDataAccessCommands
     |      redis.commands.core.DataAccessCommands
     |      redis.commands.core.BasicKeyCommands
     |      redis.commands.core.HyperlogCommands
     |      redis.commands.core.HashCommands
     |      redis.commands.core.GeoCommands
     |      redis.commands.core.ListCommands
     |      redis.commands.core.ArrayCommands
     |      redis.commands.core.ScanCommands
     |      redis.commands.core.SetCommands
     |      redis.commands.core.StreamCommands
     |      redis.commands.core.SortedSetCommands
     |      redis.commands.core.ScriptCommands
     |      redis.commands.core.FunctionCommands
     |      redis.commands.core.ModuleCommands
     |      redis.typing.CommandsProtocol
     |      typing.Protocol
     |      typing.Generic
     |      redis.commands.redismodules.RedisModuleCommands
     |      builtins.object
     |
     |  Class methods defined here:
     |
     |  __subclasshook__ = _proto_hook(other) from typing
     |
     |  ----------------------------------------------------------------------
     |  Data and other attributes defined here:
     |
     |  __abstractmethods__ = frozenset()
     |
     |  __annotations__ = {}
     |
     |  __parameters__ = ()
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from ClusterMultiKeyCommands:
     |
     |  delete(self, *keys: 'KeyT') -> 'int | Awaitable[int]'
     |      Deletes the given keys in the cluster.
     |      The keys are first split up into slots
     |      and then an DEL command is sent for every slot
     |
     |      Non-existent keys are ignored.
     |      Returns the number of keys that were deleted.
     |
     |      For more information see https://redis.io/commands/del
     |
     |  exists(self, *keys: 'KeyT') -> 'int | Awaitable[int]'
     |      Returns the number of ``names`` that exist in the
     |      whole cluster. The keys are first split up into slots
     |      and then an EXISTS command is sent for every slot
     |
     |      For more information see https://redis.io/commands/exists
     |
     |  mget_nonatomic(self, keys: 'KeysT', *args: 'KeyT') -> 'List[Any | None]'
     |      Splits the keys into different slots and then calls MGET
     |      for the keys of every slot. This operation will not be atomic
     |      if keys belong to more than one slot.
     |
     |      Returns a list of values ordered identically to ``keys``
     |
     |      For more information see https://redis.io/commands/mget
     |
     |  mset_nonatomic(self, mapping: 'Mapping[AnyKeyT, EncodableT]') -> 'List[bool]'
     |      Sets key/values based on a mapping. Mapping is a dictionary of
     |      key/value pairs. Both keys and values should be strings or types that
     |      can be cast to a string via str().
     |
     |      Splits the keys into different slots and then calls MSET
     |      for the keys of every slot. This operation will not be atomic
     |      if keys belong to more than one slot.
     |
     |      For more information see https://redis.io/commands/mset
     |
     |  touch(self, *keys: 'KeyT') -> 'int | Awaitable[int]'
     |      Updates the last access time of given keys across the
     |      cluster.
     |
     |      The keys are first split up into slots
     |      and then an TOUCH command is sent for every slot
     |
     |      Non-existent keys are ignored.
     |      Returns the number of keys that were touched.
     |
     |      For more information see https://redis.io/commands/touch
     |
     |  unlink(self, *keys: 'KeyT') -> 'int | Awaitable[int]'
     |      Remove the specified keys in a different thread.
     |
     |      The keys are first split up into slots
     |      and then an TOUCH command is sent for every slot
     |
     |      Non-existent keys are ignored.
     |      Returns the number of keys that were unlinked.
     |
     |      For more information see https://redis.io/commands/unlink
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from ClusterManagementCommands:
     |
     |  client_tracking_off(self, clientid: 'int | None' = None, prefix: 'Sequence[KeyT]' = [], bcast: 'bool' = False, optin: 'bool' = False, optout: 'bool' = False, noloop: 'bool' = False, target_nodes: "'TargetNodesT' | None" = 'all') -> 'ResponseT'
     |      Disables the tracking feature of the Redis server, that is used
     |      for server assisted client side caching.
     |
     |      When clientid is provided - in target_nodes only the node that owns the
     |      connection with this id should be provided.
     |      When clientid is not provided - target_nodes can be any node.
     |
     |      For more information see https://redis.io/commands/client-tracking
     |
     |  client_tracking_on(self, clientid: 'int | None' = None, prefix: 'Sequence[KeyT]' = [], bcast: 'bool' = False, optin: 'bool' = False, optout: 'bool' = False, noloop: 'bool' = False, target_nodes: "'TargetNodesT' | None" = 'all') -> 'ResponseT'
     |      Enables the tracking feature of the Redis server, that is used
     |      for server assisted client side caching.
     |
     |      When clientid is provided - in target_nodes only the node that owns the
     |      connection with this id should be provided.
     |      When clientid is not provided - target_nodes can be any node.
     |
     |      For more information see https://redis.io/commands/client-tracking
     |
     |  cluster_addslots(self, target_node: "'TargetNodesT'", *slots: 'EncodableT') -> 'bool | Awaitable[bool]'
     |      Assign new hash slots to receiving node. Sends to specified node.
     |
     |      :target_node: 'ClusterNode'
     |          The node to execute the command on
     |
     |      For more information see https://redis.io/commands/cluster-addslots
     |
     |  cluster_addslotsrange(self, target_node: "'TargetNodesT'", *slots: 'EncodableT') -> 'bool | Awaitable[bool]'
     |      Similar to the CLUSTER ADDSLOTS command.
     |      The difference between the two commands is that ADDSLOTS takes a list of slots
     |      to assign to the node, while ADDSLOTSRANGE takes a list of slot ranges
     |      (specified by start and end slots) to assign to the node.
     |
     |      :target_node: 'ClusterNode'
     |          The node to execute the command on
     |
     |      For more information see https://redis.io/commands/cluster-addslotsrange
     |
     |  cluster_bumpepoch(self, target_nodes: "'TargetNodesT' | None" = None) -> 'None'
     |
     |  cluster_count_failure_report(self, node_id: 'str') -> 'int | Awaitable[int]'
     |      Return the number of failure reports active for a given node
     |      Sends to a random node
     |
     |      For more information see https://redis.io/commands/cluster-count-failure-reports
     |
     |  cluster_countkeysinslot(self, slot_id: 'int') -> 'int | Awaitable[int]'
     |      Return the number of local keys in the specified hash slot
     |      Send to node based on specified slot_id
     |
     |      For more information see https://redis.io/commands/cluster-countkeysinslot
     |
     |  cluster_delslots(self, *slots: 'EncodableT') -> 'List[bool]'
     |      Set hash slots as unbound in the cluster.
     |      It determines by it self what node the slot is in and sends it there
     |
     |      Returns a list of the results for each processed slot.
     |
     |      For more information see https://redis.io/commands/cluster-delslots
     |
     |  cluster_delslotsrange(self, *slots: 'EncodableT') -> 'bool | Awaitable[bool]'
     |      Similar to the CLUSTER DELSLOTS command.
     |      The difference is that CLUSTER DELSLOTS takes a list of hash slots to remove
     |      from the node, while CLUSTER DELSLOTSRANGE takes a list of slot ranges to remove
     |      from the node.
     |
     |      For more information see https://redis.io/commands/cluster-delslotsrange
     |
     |  cluster_failover(self, target_node: "'TargetNodesT'", option: 'str | None' = None) -> 'bool | Awaitable[bool]'
     |      Forces a slave to perform a manual failover of its master
     |      Sends to specified node
     |
     |      :target_node: 'ClusterNode'
     |          The node to execute the command on
     |
     |      For more information see https://redis.io/commands/cluster-failover
     |
     |  cluster_flushslots(self, target_nodes: "'TargetNodesT' | None" = None) -> 'None'
     |
     |  cluster_get_keys_in_slot(self, slot: 'int', num_keys: 'int') -> 'list[bytes | str] | Awaitable[list[bytes | str]]'
     |      Returns the number of keys in the specified cluster slot
     |
     |      For more information see https://redis.io/commands/cluster-getkeysinslot
     |
     |  cluster_info(self, target_nodes: "'TargetNodesT' | None" = None) -> 'dict[str, str] | Awaitable[dict[str, str]]'
     |      Provides info about Redis Cluster node state.
     |      The command will be sent to a random node in the cluster if no target
     |      node is specified.
     |
     |      For more information see https://redis.io/commands/cluster-info
     |
     |  cluster_keyslot(self, key: 'str') -> 'int | Awaitable[int]'
     |      Returns the hash slot of the specified key
     |      Sends to random node in the cluster
     |
     |      For more information see https://redis.io/commands/cluster-keyslot
     |
     |  cluster_links(self, target_node: "'TargetNodesT'") -> 'ClusterLinksResponse | Awaitable[ClusterLinksResponse]'
     |      Each node in a Redis Cluster maintains a pair of long-lived TCP link with each
     |      peer in the cluster: One for sending outbound messages towards the peer and one
     |      for receiving inbound messages from the peer.
     |
     |      This command outputs information of all such peer links as an array.
     |
     |      For more information see https://redis.io/commands/cluster-links
     |
     |  cluster_meet(self, host: 'str', port: 'int', target_nodes: "'TargetNodesT' | None" = None) -> 'bool | Awaitable[bool]'
     |      Force a node cluster to handshake with another node.
     |      Sends to specified node.
     |
     |      For more information see https://redis.io/commands/cluster-meet
     |
     |  cluster_myid(self, target_node: "'TargetNodesT'") -> 'bytes | str | Awaitable[bytes | str]'
     |      Returns the node's id.
     |
     |      :target_node: 'ClusterNode'
     |          The node to execute the command on
     |
     |      For more information check https://redis.io/commands/cluster-myid/
     |
     |  cluster_myshardid(self, target_nodes: "'TargetNodesT' | None" = None) -> 'bytes | str | Awaitable[bytes | str]'
     |      Returns the shard ID of the node.
     |
     |      For more information see https://redis.io/commands/cluster-myshardid/
     |
     |  cluster_nodes(self) -> 'dict[str, ClusterNodeDetail] | Awaitable[dict[str, ClusterNodeDetail]]'
     |      Get Cluster config for the node.
     |      Sends to random node in the cluster
     |
     |      For more information see https://redis.io/commands/cluster-nodes
     |
     |  cluster_replicas(self, node_id: 'str', target_nodes: "'TargetNodesT' | None" = None) -> 'dict[str, ClusterNodeDetail] | Awaitable[dict[str, ClusterNodeDetail]]'
     |      Provides a list of replica nodes replicating from the specified primary
     |      target node.
     |
     |      For more information see https://redis.io/commands/cluster-replicas
     |
     |  cluster_replicate(self, target_nodes: "'TargetNodesT'", node_id: 'str') -> 'bool | Awaitable[bool]'
     |      Reconfigure a node as a slave of the specified master node
     |
     |      For more information see https://redis.io/commands/cluster-replicate
     |
     |  cluster_reset(self, soft: 'bool' = True, target_nodes: "'TargetNodesT' | None" = None) -> 'bool | Awaitable[bool]'
     |      Reset a Redis Cluster node
     |
     |      If 'soft' is True then it will send 'SOFT' argument
     |      If 'soft' is False then it will send 'HARD' argument
     |
     |      For more information see https://redis.io/commands/cluster-reset
     |
     |  cluster_save_config(self, target_nodes: "'TargetNodesT' | None" = None) -> 'bool | Awaitable[bool]'
     |      Forces the node to save cluster state on disk
     |
     |      For more information see https://redis.io/commands/cluster-saveconfig
     |
     |  cluster_set_config_epoch(self, epoch: 'int', target_nodes: "'TargetNodesT' | None" = None) -> 'bool | Awaitable[bool]'
     |      Set the configuration epoch in a new node
     |
     |      For more information see https://redis.io/commands/cluster-set-config-epoch
     |
     |  cluster_setslot(self, target_node: "'TargetNodesT'", node_id: 'str', slot_id: 'int', state: 'str') -> 'bool | Awaitable[bool]'
     |      Bind an hash slot to a specific node
     |
     |      :target_node: 'ClusterNode'
     |          The node to execute the command on
     |
     |      For more information see https://redis.io/commands/cluster-setslot
     |
     |  cluster_setslot_stable(self, slot_id: 'int') -> 'bool | Awaitable[bool]'
     |      Clears migrating / importing state from the slot.
     |      It determines by it self what node the slot is in and sends it there.
     |
     |      For more information see https://redis.io/commands/cluster-setslot
     |
     |  cluster_shards(self, target_nodes: "'TargetNodesT' | None" = None) -> 'ClusterShardsResponse | Awaitable[ClusterShardsResponse]'
     |      Returns details about the shards of the cluster.
     |
     |      For more information see https://redis.io/commands/cluster-shards
     |
     |  cluster_slots(self, target_nodes: "'TargetNodesT' | None" = None) -> 'list[Any] | Awaitable[list[Any]]'
     |      Get array of Cluster slot to node mappings
     |
     |      For more information see https://redis.io/commands/cluster-slots
     |
     |  hotkeys_get(self, **kwargs) -> 'list[dict[str | bytes, Any]]'
     |      Cluster client does not support hotkeys command. Please use the non-cluster client.
     |
     |      For more information see https://redis.io/commands/hotkeys-get
     |
     |  hotkeys_reset(self, **kwargs) -> 'str | bytes'
     |      Cluster client does not support hotkeys command. Please use the non-cluster client.
     |
     |      For more information see https://redis.io/commands/hotkeys-reset
     |
     |  hotkeys_start(self, metrics: 'List[HotkeysMetricsTypes]', count: 'int | None' = None, duration: 'int | None' = None, sample_ratio: 'int | None' = None, slots: 'List[int] | None' = None, **kwargs) -> 'str | bytes'
     |      Cluster client does not support hotkeys command. Please use the non-cluster client.
     |
     |      For more information see https://redis.io/commands/hotkeys-start
     |
     |  hotkeys_stop(self, **kwargs) -> 'str | bytes'
     |      Cluster client does not support hotkeys command. Please use the non-cluster client.
     |
     |      For more information see https://redis.io/commands/hotkeys-stop
     |
     |  readonly(self, target_nodes: "'TargetNodesT' | None" = None) -> 'ResponseT'
     |      Enables read queries.
     |      The command will be sent to the default cluster node if target_nodes is
     |      not specified.
     |
     |      For more information see https://redis.io/commands/readonly
     |
     |  readwrite(self, target_nodes: "'TargetNodesT' | None" = None) -> 'ResponseT'
     |      Disables read queries.
     |      The command will be sent to the default cluster node if target_nodes is
     |      not specified.
     |
     |      For more information see https://redis.io/commands/readwrite
     |
     |  replicaof(self, *args, **kwargs) -> 'NoReturn'
     |      Make the server a replica of another instance, or promote it as master.
     |
     |      For more information see https://redis.io/commands/replicaof
     |
     |  slaveof(self, *args, **kwargs) -> 'NoReturn'
     |      Make the server a replica of another instance, or promote it as master.
     |
     |      For more information see https://redis.io/commands/slaveof
     |
     |  swapdb(self, *args, **kwargs) -> 'NoReturn'
     |      Swaps two Redis databases.
     |
     |      For more information see https://redis.io/commands/swapdb
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from redis.commands.core.ManagementCommands:
     |
     |  auth(self, password: 'str', username: 'str | None' = None, **kwargs) -> 'bool | Awaitable[bool]'
     |      Authenticates the user. If you do not pass username, Redis will try to
     |      authenticate for the "default" user. If you do pass username, it will
     |      authenticate for the given user.
     |      For more information, see https://redis.io/commands/auth
     |
     |  bgrewriteaof(self, **kwargs) -> 'bool | bytes | str | Awaitable[bool | bytes | str]'
     |      Tell the Redis server to rewrite the AOF file from data in memory.
     |
     |      For more information, see https://redis.io/commands/bgrewriteaof
     |
     |  bgsave(self, schedule: 'bool' = True, **kwargs) -> 'bool | bytes | str | Awaitable[bool | bytes | str]'
     |      Tell the Redis server to save its data to disk.  Unlike save(),
     |      this method is asynchronous and returns immediately.
     |
     |      For more information, see https://redis.io/commands/bgsave
     |
     |  client_getname(self, **kwargs) -> 'bytes | str | None | Awaitable[bytes | str | None]'
     |      Returns the current connection name
     |
     |      For more information, see https://redis.io/commands/client-getname
     |
     |  client_getredir(self, **kwargs) -> 'int | Awaitable[int]'
     |      Returns the ID (an integer) of the client to whom we are
     |      redirecting tracking notifications.
     |
     |      see: https://redis.io/commands/client-getredir
     |
     |  client_id(self, **kwargs) -> 'int | Awaitable[int]'
     |      Returns the current connection id
     |
     |      For more information, see https://redis.io/commands/client-id
     |
     |  client_info(self, **kwargs) -> 'dict[str, str | int] | Awaitable[dict[str, str | int]]'
     |      Returns information and statistics about the current
     |      client connection.
     |
     |      For more information, see https://redis.io/commands/client-info
     |
     |  client_kill(self, address: 'str', **kwargs) -> 'bool | int | Awaitable[bool | int]'
     |      Disconnects the client at ``address`` (ip:port)
     |
     |      For more information, see https://redis.io/commands/client-kill
     |
     |  client_kill_filter(self, _id: 'str | None' = None, _type: 'str | None' = None, addr: 'str | None' = None, skipme: 'bool | None' = None, laddr: 'bool | None' = None, user: 'str | None' = None, maxage: 'int | None' = None, **kwargs) -> 'int | Awaitable[int]'
     |      Disconnects client(s) using a variety of filter options
     |      :param _id: Kills a client by its unique ID field
     |      :param _type: Kills a client by type where type is one of 'normal',
     |      'master', 'slave', 'replica' or 'pubsub'
     |      :param addr: Kills a client by its 'address:port'
     |      :param skipme: If True, then the client calling the command
     |      will not get killed even if it is identified by one of the filter
     |      options. If skipme is not provided, the server defaults to skipme=True
     |      :param laddr: Kills a client by its 'local (bind) address:port'
     |      :param user: Kills a client for a specific user name
     |      :param maxage: Kills clients that are older than the specified age in seconds
     |
     |  client_list(self, _type: 'str | None' = None, client_id: 'List[EncodableT]' = [], **kwargs) -> 'list[dict[str, str]] | Awaitable[list[dict[str, str]]]'
     |      Returns a list of currently connected clients.
     |      If type of client specified, only that type will be returned.
     |
     |      :param _type: optional. one of the client types (normal, master,
     |       replica, pubsub)
     |      :param client_id: optional. a list of client ids
     |
     |      For more information, see https://redis.io/commands/client-list
     |
     |  client_no_evict(self, mode: 'str') -> 'bytes | str | Awaitable[bytes | str]'
     |      Sets the client eviction mode for the current connection.
     |
     |      For more information, see https://redis.io/commands/client-no-evict
     |
     |  client_no_touch(self, mode: 'str') -> 'bytes | str | Awaitable[bytes | str]'
     |      # The command controls whether commands sent by the client will alter
     |      # the LRU/LFU of the keys they access.
     |      # When turned on, the current client will not change LFU/LRU stats,
     |      # unless it sends the TOUCH command.
     |
     |      For more information, see https://redis.io/commands/client-no-touch
     |
     |  client_pause(self, timeout: 'int', all: 'bool' = True, **kwargs) -> 'bool | Awaitable[bool]'
     |      Suspend all the Redis clients for the specified amount of time.
     |
     |
     |      For more information, see https://redis.io/commands/client-pause
     |
     |      Args:
     |          timeout: milliseconds to pause clients
     |          all: If true (default) all client commands are blocked.
     |               otherwise, clients are only blocked if they attempt to execute
     |               a write command.
     |
     |      For the WRITE mode, some commands have special behavior:
     |
     |      * EVAL/EVALSHA: Will block client for all scripts.
     |      * PUBLISH: Will block client.
     |      * PFCOUNT: Will block client.
     |      * WAIT: Acknowledgments will be delayed, so this command will
     |          appear blocked.
     |
     |  client_reply(self, reply: "Literal['ON', 'OFF', 'SKIP']", **kwargs) -> 'bytes | str | Awaitable[bytes | str]'
     |      Enable and disable redis server replies.
     |
     |      ``reply`` Must be ON OFF or SKIP,
     |      ON - The default most with server replies to commands
     |      OFF - Disable server responses to commands
     |      SKIP - Skip the response of the immediately following command.
     |
     |      Note: When setting OFF or SKIP replies, you will need a client object
     |      with a timeout specified in seconds, and will need to catch the
     |      TimeoutError.
     |      The test_client_reply unit test illustrates this, and
     |      conftest.py has a client with a timeout.
     |
     |      See https://redis.io/commands/client-reply
     |
     |  client_setinfo(self, attr: 'str', value: 'str', **kwargs) -> 'bool | Awaitable[bool]'
     |      Sets the current connection library name or version
     |      For more information see https://redis.io/commands/client-setinfo
     |
     |  client_setname(self, name: 'str', **kwargs) -> 'bool | Awaitable[bool]'
     |      Sets the current connection name
     |
     |      For more information, see https://redis.io/commands/client-setname
     |
     |      .. note::
     |         This method sets client name only for **current** connection.
     |
     |         If you want to set a common name for all connections managed
     |         by this client, use ``client_name`` constructor argument.
     |
     |  client_tracking(self, on: 'bool' = True, clientid: 'int | None' = None, prefix: 'Sequence[KeyT]' = [], bcast: 'bool' = False, optin: 'bool' = False, optout: 'bool' = False, noloop: 'bool' = False, **kwargs) -> 'bytes | str | Awaitable[bytes | str]'
     |      Enables the tracking feature of the Redis server, that is used
     |      for server assisted client side caching.
     |
     |      ``on`` indicate for tracking on or tracking off. The default is on.
     |
     |      ``clientid`` send invalidation messages to the connection with
     |      the specified ID.
     |
     |      ``bcast`` enable tracking in broadcasting mode. In this mode
     |      invalidation messages are reported for all the prefixes
     |      specified, regardless of the keys requested by the connection.
     |
     |      ``optin``  when broadcasting is NOT active, normally don't track
     |      keys in read only commands, unless they are called immediately
     |      after a CLIENT CACHING yes command.
     |
     |      ``optout`` when broadcasting is NOT active, normally track keys in
     |      read only commands, unless they are called immediately after a
     |      CLIENT CACHING no command.
     |
     |      ``noloop`` don't send notifications about keys modified by this
     |      connection itself.
     |
     |      ``prefix``  for broadcasting, register a given key prefix, so that
     |      notifications will be provided only for keys starting with this string.
     |
     |      See https://redis.io/commands/client-tracking
     |
     |  client_trackinginfo(self, **kwargs) -> 'ClientTrackingInfoResponse | Awaitable[ClientTrackingInfoResponse]'
     |      Returns the information about the current client connection's
     |      use of the server assisted client side cache.
     |
     |      See https://redis.io/commands/client-trackinginfo
     |
     |  client_unblock(self, client_id: 'int', error: 'bool' = False, **kwargs) -> 'bool | Awaitable[bool]'
     |      Unblocks a connection by its client id.
     |      If ``error`` is True, unblocks the client with a special error message.
     |      If ``error`` is False (default), the client is unblocked using the
     |      regular timeout mechanism.
     |
     |      For more information, see https://redis.io/commands/client-unblock
     |
     |  client_unpause(self, **kwargs) -> 'bytes | str | Awaitable[bytes | str]'
     |      Unpause all redis clients
     |
     |      For more information, see https://redis.io/commands/client-unpause
     |
     |  command(self, **kwargs) -> 'dict[str, dict[str, Any]] | Awaitable[dict[str, dict[str, Any]]]'
     |      Returns dict reply of details about all Redis commands.
     |
     |      For more information, see https://redis.io/commands/command
     |
     |  command_count(self, **kwargs) -> 'int | Awaitable[int]'
     |
     |  command_docs(self, *args)
     |      This function throws a NotImplementedError since it is intentionally
     |      not supported.
     |
     |  command_getkeysandflags(self, *args: 'str') -> 'CommandGetKeysAndFlagsResponse | Awaitable[CommandGetKeysAndFlagsResponse]'
     |      Returns array of keys from a full Redis command and their usage flags.
     |
     |      For more information, see https://redis.io/commands/command-getkeysandflags
     |
     |  command_info(self, **kwargs) -> 'None'
     |
     |  command_list(self, module: 'str | None' = None, category: 'str | None' = None, pattern: 'str | None' = None) -> 'list[bytes | str] | Awaitable[list[bytes | str]]'
     |      Return an array of the server's command names.
     |      You can use one of the following filters:
     |      ``module``: get the commands that belong to the module
     |      ``category``: get the commands in the ACL category
     |      ``pattern``: get the commands that match the given pattern
     |
     |      For more information, see https://redis.io/commands/command-list/
     |
     |  config_get(self, pattern: 'PatternT' = '*', *args: 'PatternT', **kwargs) -> 'dict[str | None, str | None] | Awaitable[dict[str | None, str | None]]'
     |      Return a dictionary of configuration based on the ``pattern``
     |
     |      For more information, see https://redis.io/commands/config-get
     |
     |  config_resetstat(self, **kwargs) -> 'bool | Awaitable[bool]'
     |      Reset runtime statistics
     |
     |      For more information, see https://redis.io/commands/config-resetstat
     |
     |  config_rewrite(self, **kwargs) -> 'bytes | str | Awaitable[bytes | str]'
     |      Rewrite config file with the minimal change to reflect running config.
     |
     |      For more information, see https://redis.io/commands/config-rewrite
     |
     |  config_set(self, name: 'KeyT', value: 'EncodableT', *args: 'Union[KeyT, EncodableT]', **kwargs) -> 'bool | Awaitable[bool]'
     |      Set config item ``name`` with ``value``
     |
     |      For more information, see https://redis.io/commands/config-set
     |
     |  dbsize(self, **kwargs) -> 'int | Awaitable[int]'
     |      Returns the number of keys in the current database
     |
     |      For more information, see https://redis.io/commands/dbsize
     |
     |  debug_object(self, key: 'KeyT', **kwargs) -> 'dict[str, str | int] | bytes | str | Awaitable[dict[str, str | int] | bytes | str]'
     |      Returns version specific meta information about a given key
     |
     |      For more information, see https://redis.io/commands/debug-object
     |
     |  debug_segfault(self, **kwargs) -> 'None'
     |
     |  echo(self, value: 'EncodableT', **kwargs) -> 'bytes | str | Awaitable[bytes | str]'
     |      Echo the string back from the server
     |
     |      For more information, see https://redis.io/commands/echo
     |
     |  failover(self)
     |      This function throws a NotImplementedError since it is intentionally
     |      not supported.
     |
     |  flushall(self, asynchronous: 'bool' = False, **kwargs) -> 'bool | Awaitable[bool]'
     |      Delete all keys in all databases on the current host.
     |
     |      ``asynchronous`` indicates whether the operation is
     |      executed asynchronously by the server.
     |
     |      For more information, see https://redis.io/commands/flushall
     |
     |  flushdb(self, asynchronous: 'bool' = False, **kwargs) -> 'bool | Awaitable[bool]'
     |      Delete all keys in the current database.
     |
     |      ``asynchronous`` indicates whether the operation is
     |      executed asynchronously by the server.
     |
     |      For more information, see https://redis.io/commands/flushdb
     |
     |  hello(self)
     |      This function throws a NotImplementedError since it is intentionally
     |      not supported.
     |
     |  info(self, section: 'Optional[str]' = None, *args: 'str', **kwargs) -> 'dict[str, Any] | Awaitable[dict[str, Any]]'
     |      Returns a dictionary containing information about the Redis server
     |
     |      The ``section`` option can be used to select a specific section
     |      of information
     |
     |      The section option is not supported by older versions of Redis Server,
     |      and will generate ResponseError
     |
     |      For more information, see https://redis.io/commands/info
     |
     |  lastsave(self, **kwargs) -> 'datetime.datetime | Awaitable[datetime.datetime]'
     |      Return a Python datetime object representing the last time the
     |      Redis database was saved to disk
     |
     |      For more information, see https://redis.io/commands/lastsave
     |
     |  latency_doctor(self)
     |      Raise a NotImplementedError, as the client will not support LATENCY DOCTOR.
     |      This function is best used within the redis-cli.
     |
     |      For more information, see https://redis.io/commands/latency-doctor
     |
     |  latency_graph(self)
     |      Raise a NotImplementedError, as the client will not support LATENCY GRAPH.
     |      This function is best used within the redis-cli.
     |
     |      For more information, see https://redis.io/commands/latency-graph.
     |
     |  latency_histogram(self, *args)
     |      This function throws a NotImplementedError since it is intentionally
     |      not supported.
     |
     |  latency_history(self, event: 'str') -> 'list[list[int]] | Awaitable[list[list[int]]]'
     |      Returns the raw data of the ``event``'s latency spikes time series.
     |
     |      For more information, see https://redis.io/commands/latency-history
     |
     |  latency_latest(self) -> 'list[list[bytes | str | int]] | Awaitable[list[list[bytes | str | int]]]'
     |      Reports the latest latency events logged.
     |
     |      For more information, see https://redis.io/commands/latency-latest
     |
     |  latency_reset(self, *events: 'str') -> 'int | Awaitable[int]'
     |      Resets the latency spikes time series of all, or only some, events.
     |
     |      For more information, see https://redis.io/commands/latency-reset
     |
     |  lolwut(self, *version_numbers: 'Union[str, float]', **kwargs) -> 'bytes | str | Awaitable[bytes | str]'
     |      Get the Redis version and a piece of generative computer art
     |
     |      See: https://redis.io/commands/lolwut
     |
     |  memory_doctor(self, **kwargs) -> 'None'
     |
     |  memory_help(self, **kwargs) -> 'None'
     |
     |  memory_malloc_stats(self, **kwargs) -> 'bytes | str | Awaitable[bytes | str]'
     |      Return an internal statistics report from the memory allocator.
     |
     |      See: https://redis.io/commands/memory-malloc-stats
     |
     |  memory_purge(self, **kwargs) -> 'bool | Awaitable[bool]'
     |      Attempts to purge dirty pages for reclamation by allocator
     |
     |      For more information, see https://redis.io/commands/memory-purge
     |
     |  memory_stats(self, **kwargs) -> 'dict[str, Any] | Awaitable[dict[str, Any]]'
     |      Return a dictionary of memory stats
     |
     |      For more information, see https://redis.io/commands/memory-stats
     |
     |  memory_usage(self, key: 'KeyT', samples: 'int | None' = None, **kwargs) -> 'int | None | Awaitable[int | None]'
     |      Return the total memory usage for key, its value and associated
     |      administrative overheads.
     |
     |      For nested data structures, ``samples`` is the number of elements to
     |      sample. If left unspecified, the server's default is 5. Use 0 to sample
     |      all elements.
     |
     |      For more information, see https://redis.io/commands/memory-usage
     |
     |  migrate(self, host: 'str', port: 'int', keys: 'KeysT', destination_db: 'int', timeout: 'int', copy: 'bool' = False, replace: 'bool' = False, auth: 'str | None' = None, **kwargs) -> 'bytes | str | Awaitable[bytes | str]'
     |      Migrate 1 or more keys from the current Redis server to a different
     |      server specified by the ``host``, ``port`` and ``destination_db``.
     |
     |      The ``timeout``, specified in milliseconds, indicates the maximum
     |      time the connection between the two servers can be idle before the
     |      command is interrupted.
     |
     |      If ``copy`` is True, the specified ``keys`` are NOT deleted from
     |      the source server.
     |
     |      If ``replace`` is True, this operation will overwrite the keys
     |      on the destination server if they exist.
     |
     |      If ``auth`` is specified, authenticate to the destination server with
     |      the password provided.
     |
     |      For more information, see https://redis.io/commands/migrate
     |
     |  object(self, infotype: 'str', key: 'KeyT', **kwargs) -> 'Any | Awaitable[Any]'
     |      Return the encoding, idletime, or refcount about the key
     |
     |  ping(self, **kwargs) -> 'Union[Awaitable[bool], bool]'
     |      Ping the Redis server to test connectivity.
     |
     |      Sends a PING command to the Redis server and returns True if the server
     |      responds with "PONG".
     |
     |      This command is useful for:
     |      - Testing whether a connection is still alive
     |      - Verifying the server's ability to serve data
     |
     |      For more information on the underlying ping command see https://redis.io/commands/ping
     |
     |  psync(self, replicationid: 'str', offset: 'int') -> 'bytes | Awaitable[bytes]'
     |      Initiates a replication stream from the master.
     |      Newer version for `sync`.
     |
     |      For more information, see https://redis.io/commands/sync
     |
     |  quit(self, **kwargs) -> 'bool | Awaitable[bool]'
     |      Ask the server to close the connection.
     |
     |      For more information, see https://redis.io/commands/quit
     |
     |  reset(self) -> 'bytes | str | Awaitable[bytes | str]'
     |      Perform a full reset on the connection's server-side context.
     |
     |      See: https://redis.io/commands/reset
     |
     |  role(self) -> 'list[Any] | Awaitable[list[Any]]'
     |      Provide information on the role of a Redis instance in
     |      the context of replication, by returning if the instance
     |      is currently a master, slave, or sentinel.
     |
     |      For more information, see https://redis.io/commands/role
     |
     |  save(self, **kwargs) -> 'bool | Awaitable[bool]'
     |      Tell the Redis server to save its data to disk,
     |      blocking until the save is complete
     |
     |      For more information, see https://redis.io/commands/save
     |
     |  select(self, index: 'int', **kwargs) -> 'bool | Awaitable[bool]'
     |      Select the Redis logical database at index.
     |
     |      See: https://redis.io/commands/select
     |
     |  shutdown(self, save: 'bool' = False, nosave: 'bool' = False, now: 'bool' = False, force: 'bool' = False, abort: 'bool' = False, **kwargs) -> 'None'
     |      Shutdown the Redis server.  If Redis has persistence configured,
     |      data will be flushed before shutdown.
     |      It is possible to specify modifiers to alter the behavior of the command:
     |      ``save`` will force a DB saving operation even if no save points are configured.
     |      ``nosave`` will prevent a DB saving operation even if one or more save points
     |      are configured.
     |      ``now`` skips waiting for lagging replicas, i.e. it bypasses the first step in
     |      the shutdown sequence.
     |      ``force`` ignores any errors that would normally prevent the server from exiting
     |      ``abort`` cancels an ongoing shutdown and cannot be combined with other flags.
     |
     |      For more information, see https://redis.io/commands/shutdown
     |
     |  slowlog_get(self, num: 'int | None' = None, **kwargs) -> 'list[dict[str, Any]] | Awaitable[list[dict[str, Any]]]'
     |      Get the entries from the slowlog. If ``num`` is specified, get the
     |      most recent ``num`` items.
     |
     |      For more information, see https://redis.io/commands/slowlog-get
     |
     |  slowlog_len(self, **kwargs) -> 'int | Awaitable[int]'
     |      Get the number of items in the slowlog
     |
     |      For more information, see https://redis.io/commands/slowlog-len
     |
     |  slowlog_reset(self, **kwargs) -> 'bool | Awaitable[bool]'
     |      Remove all items in the slowlog
     |
     |      For more information, see https://redis.io/commands/slowlog-reset
     |
     |  sync(self) -> 'bytes | Awaitable[bytes]'
     |      Initiates a replication stream from the master.
     |
     |      For more information, see https://redis.io/commands/sync
     |
     |  time(self, **kwargs) -> 'tuple[int, int] | Awaitable[tuple[int, int]]'
     |      Returns the server time as a 2-item tuple of ints:
     |      (seconds since epoch, microseconds into this second).
     |
     |      For more information, see https://redis.io/commands/time
     |
     |  wait(self, num_replicas: 'int', timeout: 'int', **kwargs) -> 'int | Awaitable[int]'
     |      Redis synchronous replication
     |      That returns the number of replicas that processed the query when
     |      we finally have at least ``num_replicas``, or when the ``timeout`` was
     |      reached.
     |
     |      For more information, see https://redis.io/commands/wait
     |
     |  waitaof(self, num_local: 'int', num_replicas: 'int', timeout: 'int', **kwargs) -> 'list[int] | Awaitable[list[int]]'
     |      This command blocks the current client until all previous write
     |      commands by that client are acknowledged as having been fsynced
     |      to the AOF of the local Redis and/or at least the specified number
     |      of replicas.
     |
     |      For more information, see https://redis.io/commands/waitaof
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from redis.commands.core.ACLCommands:
     |
     |  acl_cat(self, category: 'str | None' = None, **kwargs) -> 'list[bytes | str] | Awaitable[list[bytes | str]]'
     |      Returns a list of categories or commands within a category.
     |
     |      If ``category`` is not supplied, returns a list of all categories.
     |      If ``category`` is supplied, returns a list of all commands within
     |      that category.
     |
     |      For more information, see https://redis.io/commands/acl-cat
     |
     |  acl_deluser(self, *username: 'str', **kwargs) -> 'int | Awaitable[int]'
     |      Delete the ACL for the specified ``username``\s
     |
     |      For more information, see https://redis.io/commands/acl-deluser
     |
     |  acl_dryrun(self, username: 'str', *args: 'EncodableT', **kwargs) -> 'bytes | str | Awaitable[bytes | str]'
     |      Simulate the execution of a given command by a given ``username``.
     |
     |      For more information, see https://redis.io/commands/acl-dryrun
     |
     |  acl_genpass(self, bits: 'int | None' = None, **kwargs) -> 'bytes | str | Awaitable[bytes | str]'
     |      Generate a random password value.
     |      If ``bits`` is supplied then use this number of bits, rounded to
     |      the next multiple of 4.
     |      See: https://redis.io/commands/acl-genpass
     |
     |  acl_getuser(self, username: 'str', **kwargs) -> 'ACLGetUserData | Awaitable[ACLGetUserData]'
     |      Get the ACL details for the specified ``username``.
     |
     |      If ``username`` does not exist, return None
     |
     |      For more information, see https://redis.io/commands/acl-getuser
     |
     |  acl_help(self, **kwargs) -> 'list[bytes | str] | Awaitable[list[bytes | str]]'
     |      The ACL HELP command returns helpful text describing
     |      the different subcommands.
     |
     |      For more information, see https://redis.io/commands/acl-help
     |
     |  acl_list(self, **kwargs) -> 'list[bytes | str] | Awaitable[list[bytes | str]]'
     |      Return a list of all ACLs on the server
     |
     |      For more information, see https://redis.io/commands/acl-list
     |
     |  acl_load(self, **kwargs) -> 'bool | Awaitable[bool]'
     |      Load ACL rules from the configured ``aclfile``.
     |
     |      Note that the server must be configured with the ``aclfile``
     |      directive to be able to load ACL rules from an aclfile.
     |
     |      For more information, see https://redis.io/commands/acl-load
     |
     |  acl_log(self, count: 'int | None' = None, **kwargs) -> 'ACLLogData | Awaitable[ACLLogData]'
     |      Get ACL logs as a list.
     |      :param int count: Get logs[0:count].
     |      :rtype: List.
     |
     |      For more information, see https://redis.io/commands/acl-log
     |
     |  acl_log_reset(self, **kwargs) -> 'bool | Awaitable[bool]'
     |      Reset ACL logs.
     |      :rtype: Boolean.
     |
     |      For more information, see https://redis.io/commands/acl-log
     |
     |  acl_save(self, **kwargs) -> 'bool | Awaitable[bool]'
     |      Save ACL rules to the configured ``aclfile``.
     |
     |      Note that the server must be configured with the ``aclfile``
     |      directive to be able to save ACL rules to an aclfile.
     |
     |      For more information, see https://redis.io/commands/acl-save
     |
     |  acl_setuser(self, username: 'str', enabled: 'bool' = False, nopass: 'bool' = False, passwords: 'str | Iterable[str] | None' = None, hashed_passwords: 'str | Iterable[str] | None' = None, categories: 'Iterable[str] | None' = None, commands: 'Iterable[str] | None' = None, keys: 'Iterable[KeyT] | None' = None, channels: 'Iterable[ChannelT] | None' = None, selectors: 'Iterable[Tuple[str, KeyT]] | None' = None, reset: 'bool' = False, reset_keys: 'bool' = False, reset_channels: 'bool' = False, reset_passwords: 'bool' = False, **kwargs) -> 'bool | Awaitable[bool]'
     |      Create or update an ACL user.
     |
     |      Create or update the ACL for `username`. If the user already exists,
     |      the existing ACL is completely overwritten and replaced with the
     |      specified values.
     |
     |      For more information, see https://redis.io/commands/acl-setuser
     |
     |      Args:
     |          username: The name of the user whose ACL is to be created or updated.
     |          enabled: Indicates whether the user should be allowed to authenticate.
     |                   Defaults to `False`.
     |          nopass: Indicates whether the user can authenticate without a password.
     |                  This cannot be `True` if `passwords` are also specified.
     |          passwords: A list of plain text passwords to add to or remove from the user.
     |                     Each password must be prefixed with a '+' to add or a '-' to
     |                     remove. For convenience, a single prefixed string can be used
     |                     when adding or removing a single password.
     |          hashed_passwords: A list of SHA-256 hashed passwords to add to or remove
     |                            from the user. Each hashed password must be prefixed with
     |                            a '+' to add or a '-' to remove. For convenience, a single
     |                            prefixed string can be used when adding or removing a
     |                            single password.
     |          categories: A list of strings representing category permissions. Each string
     |                      must be prefixed with either a '+' to add the category
     |                      permission or a '-' to remove the category permission.
     |          commands: A list of strings representing command permissions. Each string
     |                    must be prefixed with either a '+' to add the command permission
     |                    or a '-' to remove the command permission.
     |          keys: A list of key patterns to grant the user access to. Key patterns allow
     |                ``'*'`` to support wildcard matching. For example, ``'*'`` grants
     |                access to all keys while ``'cache:*'`` grants access to all keys that
     |                are prefixed with ``cache:``.
     |                `keys` should not be prefixed with a ``'~'``.
     |          reset: Indicates whether the user should be fully reset prior to applying
     |                 the new ACL. Setting this to `True` will remove all existing
     |                 passwords, flags, and privileges from the user and then apply the
     |                 specified rules. If `False`, the user's existing passwords, flags,
     |                 and privileges will be kept and any new specified rules will be
     |                 applied on top.
     |          reset_keys: Indicates whether the user's key permissions should be reset
     |                      prior to applying any new key permissions specified in `keys`.
     |                      If `False`, the user's existing key permissions will be kept and
     |                      any new specified key permissions will be applied on top.
     |          reset_channels: Indicates whether the user's channel permissions should be
     |                          reset prior to applying any new channel permissions
     |                          specified in `channels`. If `False`, the user's existing
     |                          channel permissions will be kept and any new specified
     |                          channel permissions will be applied on top.
     |          reset_passwords: Indicates whether to remove all existing passwords and the
     |                           `nopass` flag from the user prior to applying any new
     |                           passwords specified in `passwords` or `hashed_passwords`.
     |                           If `False`, the user's existing passwords and `nopass`
     |                           status will be kept and any new specified passwords or
     |                           hashed passwords will be applied on top.
     |
     |  acl_users(self, **kwargs) -> 'list[bytes | str] | Awaitable[list[bytes | str]]'
     |      Returns a list of all registered users on the server.
     |
     |      For more information, see https://redis.io/commands/acl-users
     |
     |  acl_whoami(self, **kwargs) -> 'bytes | str | Awaitable[bytes | str]'
     |      Get the username for the current connection
     |
     |      For more information, see https://redis.io/commands/acl-whoami
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from redis.commands.core.PubSubCommands:
     |
     |  publish(self, channel: 'ChannelT', message: 'EncodableT', **kwargs) -> 'int | Awaitable[int]'
     |      Publish ``message`` on ``channel``.
     |      Returns the number of subscribers the message was delivered to.
     |
     |      For more information, see https://redis.io/commands/publish
     |
     |  pubsub_channels(self, pattern: 'PatternT' = '*', **kwargs) -> 'list[bytes | str] | Awaitable[list[bytes | str]]'
     |      Return a list of channels that have at least one subscriber
     |
     |      For more information, see https://redis.io/commands/pubsub-channels
     |
     |  pubsub_numpat(self, **kwargs) -> 'int | Awaitable[int]'
     |      Returns the number of subscriptions to patterns
     |
     |      For more information, see https://redis.io/commands/pubsub-numpat
     |
     |  pubsub_numsub(self, *args: 'ChannelT', **kwargs) -> 'list[tuple[bytes | str, int]] | Awaitable[list[tuple[bytes | str, int]]]'
     |      Return a list of (channel, number of subscribers) tuples
     |      for each channel given in ``*args``
     |
     |      For more information, see https://redis.io/commands/pubsub-numsub
     |
     |  pubsub_shardchannels(self, pattern: 'PatternT' = '*', **kwargs) -> 'list[bytes | str] | Awaitable[list[bytes | str]]'
     |      Return a list of shard_channels that have at least one subscriber
     |
     |      For more information, see https://redis.io/commands/pubsub-shardchannels
     |
     |  pubsub_shardnumsub(self, *args: 'ChannelT', **kwargs) -> 'list[tuple[bytes | str, int]] | Awaitable[list[tuple[bytes | str, int]]]'
     |      Return a list of (shard_channel, number of subscribers) tuples
     |      for each channel given in ``*args``
     |
     |      For more information, see https://redis.io/commands/pubsub-shardnumsub
     |
     |  spublish(self, shard_channel: 'ChannelT', message: 'EncodableT') -> 'int | Awaitable[int]'
     |      Posts a message to the given shard channel.
     |      Returns the number of clients that received the message
     |
     |      For more information, see https://redis.io/commands/spublish
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from ClusterDataAccessCommands:
     |
     |  scan_iter(self, match: 'PatternT | None' = None, count: 'int | None' = None, _type: 'str | None' = None, **kwargs) -> 'Iterator'
     |      Make an iterator using the SCAN command so that the client doesn't
     |      need to remember the cursor position.
     |
     |      ``match`` allows for filtering the keys by pattern
     |
     |      ``count`` provides a hint to Redis about the number of keys to
     |          return per batch.
     |
     |      ``_type`` filters the returned values by a particular Redis type.
     |          Stock Redis instances allow for the following types:
     |          HASH, LIST, SET, STREAM, STRING, ZSET
     |          Additionally, Redis modules can expose other types as well.
     |
     |  stralgo(self, algo: "Literal['LCS']", value1: 'KeyT', value2: 'KeyT', specific_argument: "Literal['strings'] | Literal['keys']" = 'strings', len: 'bool' = False, idx: 'bool' = False, minmatchlen: 'int | None' = None, withmatchlen: 'bool' = False, **kwargs) -> 'StralgoResponse | Awaitable[StralgoResponse]'
     |      Implements complex algorithms that operate on strings.
     |      Right now the only algorithm implemented is the LCS algorithm
     |      (longest common substring). However new algorithms could be
     |      implemented in the future.
     |
     |      ``algo`` Right now must be LCS
     |      ``value1`` and ``value2`` Can be two strings or two keys
     |      ``specific_argument`` Specifying if the arguments to the algorithm
     |      will be keys or strings. strings is the default.
     |      ``len`` Returns just the len of the match.
     |      ``idx`` Returns the match positions in each string.
     |      ``minmatchlen`` Restrict the list of matches to the ones of a given
     |      minimal length. Can be provided only when ``idx`` set to True.
     |      ``withmatchlen`` Returns the matches with the len of the match.
     |      Can be provided only when ``idx`` set to True.
     |
     |      For more information see https://redis.io/commands/stralgo
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from redis.commands.core.BasicKeyCommands:
     |
     |  __contains__ = exists(self, *names: 'KeyT') -> 'int | Awaitable[int]'
     |      Returns the number of ``names`` that exist
     |
     |      For more information, see https://redis.io/commands/exists
     |
     |  __delitem__(self, name: 'KeyT')
     |
     |  __getitem__(self, name: 'KeyT')
     |      Return the value at key ``name``, raises a KeyError if the key
     |      doesn't exist.
     |
     |  __setitem__(self, name: 'KeyT', value: 'EncodableT')
     |
     |  append(self, key: 'KeyT', value: 'EncodableT') -> 'int | Awaitable[int]'
     |      Appends the string ``value`` to the value at ``key``. If ``key``
     |      doesn't already exist, create it with a value of ``value``.
     |      Returns the new length of the value at ``key``.
     |
     |      For more information, see https://redis.io/commands/append
     |
     |  bitcount(self, key: 'KeyT', start: 'int | None' = None, end: 'int | None' = None, mode: 'str | None' = None) -> 'int | Awaitable[int]'
     |      Returns the count of set bits in the value of ``key``.  Optional
     |      ``start`` and ``end`` parameters indicate which bytes to consider
     |
     |      For more information, see https://redis.io/commands/bitcount
     |
     |  bitfield(self: "Union['redis.client.Redis', 'redis.asyncio.client.Redis']", key: 'KeyT', default_overflow: 'str | None' = None) -> 'BitFieldOperation'
     |      Return a BitFieldOperation instance to conveniently construct one or
     |      more bitfield operations on ``key``.
     |
     |      For more information, see https://redis.io/commands/bitfield
     |
     |  bitfield_ro(self: "Union['redis.client.Redis', 'redis.asyncio.client.Redis']", key: 'KeyT', encoding: 'str', offset: 'BitfieldOffsetT', items: 'list[tuple[str, BitfieldOffsetT]] | None' = None) -> 'list[int] | Awaitable[list[int]]'
     |      Return an array of the specified bitfield values
     |      where the first value is found using ``encoding`` and ``offset``
     |      parameters and remaining values are result of corresponding
     |      encoding/offset pairs in optional list ``items``
     |      Read-only variant of the BITFIELD command.
     |
     |      For more information, see https://redis.io/commands/bitfield_ro
     |
     |  bitop(self, operation: 'str', dest: 'KeyT', *keys: 'KeyT') -> 'int | Awaitable[int]'
     |      Perform a bitwise operation using ``operation`` between ``keys`` and
     |      store the result in ``dest``.
     |
     |      For more information, see https://redis.io/commands/bitop
     |
     |  bitpos(self, key: 'KeyT', bit: 'int', start: 'int | None' = None, end: 'int | None' = None, mode: 'str | None' = None) -> 'int | Awaitable[int]'
     |      Return the position of the first bit set to 1 or 0 in a string.
     |      ``start`` and ``end`` defines search range. The range is interpreted
     |      as a range of bytes and not a range of bits, so start=0 and end=2
     |      means to look at the first three bytes.
     |
     |      For more information, see https://redis.io/commands/bitpos
     |
     |  blmove(self, first_list: 'str', second_list: 'str', timeout: 'int', src: 'str' = 'LEFT', dest: 'str' = 'RIGHT') -> 'bytes | str | None | Awaitable[bytes | str | None]'
     |      Blocking version of lmove.
     |
     |      For more information, see https://redis.io/commands/blmove
     |
     |  blmovem(self, first_list: 'str', second_list: 'str', timeout: 'float', src: 'str' = 'LEFT', dest: 'str' = 'RIGHT', count: 'int | None' = None, mode: "Literal['COUNT', 'EXACTLY'] | None" = None, ordering: "Literal['OBO', 'BULK'] | None" = None) -> 'list[bytes | str] | None | Awaitable[list[bytes | str] | None]'
     |      Blocking version of lmovem.
     |
     |      Blocks until elements are available to move or ``timeout`` (in seconds)
     |      is reached; a ``timeout`` of ``0`` blocks indefinitely. With ``COUNT``
     |      the command unblocks once at least one element is available and moves
     |      ``min(count, available)``; with ``EXACTLY`` it blocks until the source
     |      holds at least ``count`` elements, then moves exactly ``count``
     |      atomically. On timeout ``None`` is returned and nothing is moved.
     |
     |      As with ``lmovem``, ``ordering`` (OBO or BULK) is required whenever
     |      ``count`` is given.
     |
     |      For more information, see https://redis.io/commands/blmovem
     |
     |  copy(self, source: 'str', destination: 'str', destination_db: 'str | None' = None, replace: 'bool' = False) -> 'bool | Awaitable[bool]'
     |      Copy the value stored in the ``source`` key to the ``destination`` key.
     |
     |      ``destination_db`` an alternative destination database. By default,
     |      the ``destination`` key is created in the source Redis database.
     |
     |      ``replace`` whether the ``destination`` key should be removed before
     |      copying the value to it. By default, the value is not copied if
     |      the ``destination`` key already exists.
     |
     |      For more information, see https://redis.io/commands/copy
     |
     |  decr = decrby(self, name: 'KeyT', amount: 'int' = 1) -> 'int | Awaitable[int]'
     |
     |  decrby(self, name: 'KeyT', amount: 'int' = 1) -> 'int | Awaitable[int]'
     |      Decrements the value of ``key`` by ``amount``.  If no key exists,
     |      the value will be initialized as 0 - ``amount``
     |
     |      For more information, see https://redis.io/commands/decrby
     |
     |  delex(self, name: 'KeyT', ifeq: 'bytes | str | None' = None, ifne: 'bytes | str | None' = None, ifdeq: 'str | None' = None, ifdne: 'str | None' = None) -> 'int | Awaitable[int]'
     |      Conditionally removes the specified key.
     |
     |      Warning:
     |      **Experimental** since 7.1.
     |      This API may change or be removed without notice.
     |      The API may change based on feedback.
     |
     |      Arguments:
     |          name: KeyT - the key to delete
     |          ifeq match-valu: Optional[Union[bytes, str]] - Delete the key only if its value is equal to match-value
     |          ifne match-value: Optional[Union[bytes, str]] - Delete the key only if its value is not equal to match-value
     |          ifdeq match-digest: Optional[str] - Delete the key only if the digest of its value is equal to match-digest
     |          ifdne match-digest: Optional[str] - Delete the key only if the digest of its value is not equal to match-digest
     |
     |      Returns:
     |          int: 1 if the key was deleted, 0 otherwise.
     |      Raises:
     |          redis.exceptions.ResponseError: if key exists but is not a string
     |                                          and a condition is specified.
     |          ValueError: if more than one condition is provided.
     |
     |
     |      Requires Redis 8.4 or greater.
     |      For more information, see https://redis.io/commands/delex
     |
     |  digest(self, name: 'KeyT') -> 'str | bytes | None | Awaitable[str | bytes | None]'
     |      Return the digest of the value stored at the specified key.
     |
     |      Warning:
     |      **Experimental** since 7.1.
     |      This API may change or be removed without notice.
     |      The API may change based on feedback.
     |
     |      Arguments:
     |        - name: KeyT - the key to get the digest of
     |
     |      Returns:
     |        - None if the key does not exist
     |        - (bulk string) the XXH3 digest of the value as a hex string
     |      Raises:
     |        - ResponseError if key exists but is not a string
     |
     |
     |      Requires Redis 8.4 or greater.
     |      For more information, see https://redis.io/commands/digest
     |
     |  digest_local(self, value: 'bytes | str') -> 'bytes | str'
     |      Compute the hexadecimal digest of the value locally, without sending it to the server.
     |
     |      This is useful for conditional operations like IFDEQ/IFDNE where you need to
     |      compute the digest client-side before sending a command.
     |
     |      Warning:
     |      **Experimental** - This API may change or be removed without notice.
     |
     |      Arguments:
     |        - value: Union[bytes, str] - the value to compute the digest of.
     |          If a string is provided, it will be encoded using UTF-8 before hashing,
     |          which matches Redis's default encoding behavior.
     |
     |      Returns:
     |        - (str | bytes) the XXH3 digest of the value as a hex string (16 hex characters).
     |          Returns bytes if decode_responses is False, otherwise returns str.
     |
     |      For more information, see https://redis.io/commands/digest
     |
     |  dump(self, name: 'KeyT') -> 'bytes | None | Awaitable[bytes | None]'
     |      Return a serialized version of the value stored at the specified key.
     |      If key does not exist a nil bulk reply is returned.
     |
     |      For more information, see https://redis.io/commands/dump
     |
     |  expire(self, name: 'KeyT', time: 'ExpiryT', nx: 'bool' = False, xx: 'bool' = False, gt: 'bool' = False, lt: 'bool' = False) -> 'bool | Awaitable[bool]'
     |      Set an expire flag on key ``name`` for ``time`` seconds with given
     |      ``option``. ``time`` can be represented by an integer or a Python timedelta
     |      object.
     |
     |      Valid options are:
     |          NX -> Set expiry only when the key has no expiry
     |          XX -> Set expiry only when the key has an existing expiry
     |          GT -> Set expiry only when the new expiry is greater than current one
     |          LT -> Set expiry only when the new expiry is less than current one
     |
     |      For more information, see https://redis.io/commands/expire
     |
     |  expireat(self, name: 'KeyT', when: 'AbsExpiryT', nx: 'bool' = False, xx: 'bool' = False, gt: 'bool' = False, lt: 'bool' = False) -> 'bool | Awaitable[bool]'
     |      Set an expire flag on key ``name`` with given ``option``. ``when``
     |      can be represented as an integer indicating unix time or a Python
     |      datetime object.
     |
     |      Valid options are:
     |          -> NX -- Set expiry only when the key has no expiry
     |          -> XX -- Set expiry only when the key has an existing expiry
     |          -> GT -- Set expiry only when the new expiry is greater than current one
     |          -> LT -- Set expiry only when the new expiry is less than current one
     |
     |      For more information, see https://redis.io/commands/expireat
     |
     |  expiretime(self, key: 'str') -> 'int | Awaitable[int]'
     |      Returns the absolute Unix timestamp (since January 1, 1970) in seconds
     |      at which the given key will expire.
     |
     |      For more information, see https://redis.io/commands/expiretime
     |
     |  get(self, name: 'KeyT') -> 'bytes | str | None | Awaitable[bytes | str | None]'
     |      Return the value at key ``name``, or None if the key doesn't exist
     |
     |      For more information, see https://redis.io/commands/get
     |
     |  getbit(self, name: 'KeyT', offset: 'int') -> 'int | Awaitable[int]'
     |      Returns an integer indicating the value of ``offset`` in ``name``
     |
     |      For more information, see https://redis.io/commands/getbit
     |
     |  getdel(self, name: 'KeyT') -> 'bytes | str | None | Awaitable[bytes | str | None]'
     |      Get the value at key ``name`` and delete the key. This command
     |      is similar to GET, except for the fact that it also deletes
     |      the key on success (if and only if the key's value type
     |      is a string).
     |
     |      For more information, see https://redis.io/commands/getdel
     |
     |  getex(self, name: 'KeyT', ex: 'ExpiryT | None' = None, px: 'ExpiryT | None' = None, exat: 'AbsExpiryT | None' = None, pxat: 'AbsExpiryT | None' = None, persist: 'bool' = False) -> 'bytes | str | None | Awaitable[bytes | str | None]'
     |      Get the value of key and optionally set its expiration.
     |      GETEX is similar to GET, but is a write command with
     |      additional options. All time parameters can be given as
     |      datetime.timedelta or integers.
     |
     |      ``ex`` sets an expire flag on key ``name`` for ``ex`` seconds.
     |
     |      ``px`` sets an expire flag on key ``name`` for ``px`` milliseconds.
     |
     |      ``exat`` sets an expire flag on key ``name`` for ``ex`` seconds,
     |      specified in unix time.
     |
     |      ``pxat`` sets an expire flag on key ``name`` for ``ex`` milliseconds,
     |      specified in unix time.
     |
     |      ``persist`` remove the time to live associated with ``name``.
     |
     |      For more information, see https://redis.io/commands/getex
     |
     |  getrange(self, key: 'KeyT', start: 'int', end: 'int') -> 'bytes | str | Awaitable[bytes | str]'
     |      Returns the substring of the string value stored at ``key``,
     |      determined by the offsets ``start`` and ``end`` (both are inclusive)
     |
     |      For more information, see https://redis.io/commands/getrange
     |
     |  getset(self, name: 'KeyT', value: 'EncodableT') -> 'bytes | str | None | Awaitable[bytes | str | None]'
     |      Sets the value at key ``name`` to ``value``
     |      and returns the old value at key ``name`` atomically.
     |
     |      As per Redis 6.2, GETSET is considered deprecated.
     |      Please use SET with GET parameter in new code.
     |
     |      For more information, see https://redis.io/commands/getset
     |
     |  hrandfield(self, key: 'KeyT', count: 'int | None' = None, withvalues: 'bool' = False) -> 'HRandFieldResponse | Awaitable[HRandFieldResponse]'
     |      Return a random field from the hash value stored at key.
     |
     |      count: if the argument is positive, return an array of distinct fields.
     |      If called with a negative count, the behavior changes and the command
     |      is allowed to return the same field multiple times. In this case,
     |      the number of returned fields is the absolute value of the
     |      specified count.
     |      withvalues: The optional WITHVALUES modifier changes the reply so it
     |      includes the respective values of the randomly selected hash fields.
     |
     |      For more information, see https://redis.io/commands/hrandfield
     |
     |  incr = incrby(self, name: 'KeyT', amount: 'int' = 1) -> 'int | Awaitable[int]'
     |
     |  incrby(self, name: 'KeyT', amount: 'int' = 1) -> 'int | Awaitable[int]'
     |      Increments the value of ``key`` by ``amount``.  If no key exists,
     |      the value will be initialized as ``amount``
     |
     |      For more information, see https://redis.io/commands/incrby
     |
     |  incrbyfloat(self, name: 'KeyT', amount: 'float' = 1.0) -> 'float | Awaitable[float]'
     |      Increments the value at key ``name`` by floating ``amount``.
     |      If no key exists, the value will be initialized as ``amount``
     |
     |      For more information, see https://redis.io/commands/incrbyfloat
     |
     |  increx(self, name: 'KeyT', *, byfloat: 'EncodableT | None' = None, byint: 'EncodableT | None' = None, lbound: 'EncodableT | None' = None, ubound: 'EncodableT | None' = None, saturate: 'bool' = False, ex: 'ExpiryT | None' = None, px: 'ExpiryT | None' = None, exat: 'AbsExpiryT | None' = None, pxat: 'AbsExpiryT | None' = None, persist: 'bool' = False, enx: 'bool' = False) -> 'list[Number | bytes | str] | Awaitable[list[Number | bytes | str]]'
     |      Increment the numeric value at key ``name`` and return the new value
     |      and the actual increment.
     |
     |      ``byfloat`` increments a floating point value by the provided amount.
     |
     |      ``byint`` increments an integer value by the provided amount.
     |
     |      If neither ``byfloat`` nor ``byint`` is specified, the value is
     |      incremented by one.
     |
     |      ``lbound`` and ``ubound`` constrain the valid range of the result.
     |
     |      If ``saturate`` is True, out-of-bounds results are saturated to the
     |      specified bound, or to the type limit when no bound is specified.
     |      Otherwise, out-of-bounds results are rejected, leaving the value and
     |      TTL unchanged and returning the current value and zero as the actual
     |      increment.
     |
     |      ``enx`` applies the expiration only when the key does not already
     |      have an expiration, and requires ``ex``, ``px``, ``exat``, or ``pxat``.
     |
     |  keys(self, pattern: 'PatternT' = '*', **kwargs) -> 'list[bytes | str] | Awaitable[list[bytes | str]]'
     |      Returns a list of keys matching ``pattern``
     |
     |      For more information, see https://redis.io/commands/keys
     |
     |  lcs(self, key1: 'str', key2: 'str', len: 'bool | None' = False, idx: 'bool | None' = False, minmatchlen: 'int | None' = 0, withmatchlen: 'bool | None' = False) -> 'LCSCommandResponse | Awaitable[LCSCommandResponse]'
     |      Find the longest common subsequence between ``key1`` and ``key2``.
     |      If ``len`` is true the length of the match will be returned.
     |      If ``idx`` is true the match position in each strings will be returned.
     |      ``minmatchlen`` restrict the list of matches to the ones of
     |      the given ``minmatchlen``.
     |      If ``withmatchlen`` the length of the match also will be returned.
     |      For more information, see https://redis.io/commands/lcs
     |
     |  lmove(self, first_list: 'str', second_list: 'str', src: 'str' = 'LEFT', dest: 'str' = 'RIGHT') -> 'bytes | str | None | Awaitable[bytes | str | None]'
     |      Atomically returns and removes the first/last element of a list,
     |      pushing it as the first/last element on the destination list.
     |      Returns the element being popped and pushed.
     |
     |      For more information, see https://redis.io/commands/lmove
     |
     |  lmovem(self, first_list: 'str', second_list: 'str', src: 'str' = 'LEFT', dest: 'str' = 'RIGHT', count: 'int | None' = None, mode: "Literal['COUNT', 'EXACTLY'] | None" = None, ordering: "Literal['OBO', 'BULK'] | None" = None) -> 'list[bytes | str] | None | Awaitable[list[bytes | str] | None]'
     |      Atomically moves multiple elements from one end of the ``first_list``
     |      to one end of the ``second_list``, returning the moved elements in
     |      destination order.
     |
     |      ``src`` and ``dest`` are the ends to pop from / push to, either
     |      ``LEFT`` (head) or ``RIGHT`` (tail).
     |
     |      When ``count`` is given, ``mode`` selects how many elements to move:
     |      ``COUNT`` (the default) moves up to ``count`` elements, while
     |      ``EXACTLY`` moves exactly ``count`` elements or nothing at all. When
     |      ``count`` is not given a single element is moved.
     |
     |      ``ordering`` controls the order at the destination: ``OBO`` pushes each
     |      element as it is popped (reversing block order, stack semantics) while
     |      ``BULK`` preserves the original relative order (queue semantics). It is
     |      required whenever ``count`` is given.
     |
     |      Returns the array of moved elements, or ``None`` if nothing was moved.
     |
     |      For more information, see https://redis.io/commands/lmovem
     |
     |  mget(self, keys: 'KeysT', *args: 'EncodableT') -> 'list[bytes | str | None] | Awaitable[list[bytes | str | None]]'
     |      Returns a list of values ordered identically to ``keys``
     |
     |      ** Important ** When this method is used with Cluster clients, all keys
     |              must be in the same hash slot, otherwise a RedisClusterException
     |              will be raised.
     |
     |      For more information, see https://redis.io/commands/mget
     |
     |  move(self, name: 'KeyT', db: 'int') -> 'bool | Awaitable[bool]'
     |      Moves the key ``name`` to a different Redis database ``db``
     |
     |      For more information, see https://redis.io/commands/move
     |
     |  mset(self, mapping: 'Mapping[AnyKeyT, EncodableT]') -> 'bool | Awaitable[bool]'
     |      Sets key/values based on a mapping. Mapping is a dictionary of
     |      key/value pairs. Both keys and values should be strings or types that
     |      can be cast to a string via str().
     |
     |      ** Important ** When this method is used with Cluster clients, all keys
     |              must be in the same hash slot, otherwise a RedisClusterException
     |              will be raised.
     |
     |      For more information, see https://redis.io/commands/mset
     |
     |  msetex(self, mapping: 'Mapping[AnyKeyT, EncodableT]', data_persist_option: 'DataPersistOptions | None' = None, ex: 'ExpiryT | None' = None, px: 'ExpiryT | None' = None, exat: 'AbsExpiryT | None' = None, pxat: 'AbsExpiryT | None' = None, keepttl: 'bool' = False) -> 'int | Awaitable[int]'
     |      Sets key/values based on the provided ``mapping`` items.
     |
     |      ** Important ** When this method is used with Cluster clients, all keys
     |                      must be in the same hash slot, otherwise a RedisClusterException
     |                      will be raised.
     |
     |      ``mapping`` accepts a dict of key/value pairs that will be added to the database.
     |
     |      ``data_persist_option`` can be set to ``NX`` or ``XX`` to control the
     |          behavior of the command.
     |          ``NX`` will set the value for each provided key to each
     |              provided value only if all do not already exist.
     |          ``XX`` will set the value for each provided key to each
     |              provided value only if all already exist.
     |
     |      ``ex`` sets an expire flag on the keys in ``mapping`` for ``ex`` seconds.
     |
     |      ``px`` sets an expire flag on the keys in ``mapping`` for ``px`` milliseconds.
     |
     |      ``exat`` sets an expire flag on the keys in ``mapping`` for ``exat`` seconds,
     |          specified in unix time.
     |
     |      ``pxat`` sets an expire flag on the keys in ``mapping`` for ``pxat`` milliseconds,
     |          specified in unix time.
     |
     |      ``keepttl`` if True, retain the time to live associated with the keys.
     |
     |      Returns the number of fields that were added.
     |
     |      Available since Redis 8.4
     |      For more information, see https://redis.io/commands/msetex
     |
     |  msetnx(self, mapping: 'Mapping[AnyKeyT, EncodableT]') -> 'bool | Awaitable[bool]'
     |      Sets key/values based on a mapping if none of the keys are already set.
     |      Mapping is a dictionary of key/value pairs. Both keys and values
     |      should be strings or types that can be cast to a string via str().
     |      Returns a boolean indicating if the operation was successful.
     |
     |      ** Important ** When this method is used with Cluster clients, all keys
     |                      must be in the same hash slot, otherwise a RedisClusterException
     |                      will be raised.
     |
     |      For more information, see https://redis.io/commands/msetnx
     |
     |  persist(self, name: 'KeyT') -> 'bool | Awaitable[bool]'
     |      Removes an expiration on ``name``
     |
     |      For more information, see https://redis.io/commands/persist
     |
     |  pexpire(self, name: 'KeyT', time: 'ExpiryT', nx: 'bool' = False, xx: 'bool' = False, gt: 'bool' = False, lt: 'bool' = False) -> 'bool | Awaitable[bool]'
     |      Set an expire flag on key ``name`` for ``time`` milliseconds
     |      with given ``option``. ``time`` can be represented by an
     |      integer or a Python timedelta object.
     |
     |      Valid options are:
     |          NX -> Set expiry only when the key has no expiry
     |          XX -> Set expiry only when the key has an existing expiry
     |          GT -> Set expiry only when the new expiry is greater than current one
     |          LT -> Set expiry only when the new expiry is less than current one
     |
     |      For more information, see https://redis.io/commands/pexpire
     |
     |  pexpireat(self, name: 'KeyT', when: 'AbsExpiryT', nx: 'bool' = False, xx: 'bool' = False, gt: 'bool' = False, lt: 'bool' = False) -> 'bool | Awaitable[bool]'
     |      Set an expire flag on key ``name`` with given ``option``. ``when``
     |      can be represented as an integer representing unix time in
     |      milliseconds (unix time * 1000) or a Python datetime object.
     |
     |      Valid options are:
     |          NX -> Set expiry only when the key has no expiry
     |          XX -> Set expiry only when the key has an existing expiry
     |          GT -> Set expiry only when the new expiry is greater than current one
     |          LT -> Set expiry only when the new expiry is less than current one
     |
     |      For more information, see https://redis.io/commands/pexpireat
     |
     |  pexpiretime(self, key: 'str') -> 'int | Awaitable[int]'
     |      Returns the absolute Unix timestamp (since January 1, 1970) in milliseconds
     |      at which the given key will expire.
     |
     |      For more information, see https://redis.io/commands/pexpiretime
     |
     |  psetex(self, name: 'KeyT', time_ms: 'ExpiryT', value: 'EncodableT') -> 'bool | Awaitable[bool]'
     |      Set the value of key ``name`` to ``value`` that expires in ``time_ms``
     |      milliseconds. ``time_ms`` can be represented by an integer or a Python
     |      timedelta object
     |
     |      For more information, see https://redis.io/commands/psetex
     |
     |  pttl(self, name: 'KeyT') -> 'int | Awaitable[int]'
     |      Returns the number of milliseconds until the key ``name`` will expire
     |
     |      For more information, see https://redis.io/commands/pttl
     |
     |  randomkey(self, **kwargs) -> 'bytes | str | None | Awaitable[bytes | str | None]'
     |      Returns the name of a random key
     |
     |      For more information, see https://redis.io/commands/randomkey
     |
     |  rename(self, src: 'KeyT', dst: 'KeyT') -> 'bool | Awaitable[bool]'
     |      Rename key ``src`` to ``dst``
     |
     |      For more information, see https://redis.io/commands/rename
     |
     |  renamenx(self, src: 'KeyT', dst: 'KeyT') -> 'bool | Awaitable[bool]'
     |      Rename key ``src`` to ``dst`` if ``dst`` doesn't already exist
     |
     |      For more information, see https://redis.io/commands/renamenx
     |
     |  restore(self, name: 'KeyT', ttl: 'float', value: 'EncodableT', replace: 'bool' = False, absttl: 'bool' = False, idletime: 'int | None' = None, frequency: 'int | None' = None) -> 'bytes | str | Awaitable[bytes | str]'
     |      Create a key using the provided serialized value, previously obtained
     |      using DUMP.
     |
     |      ``replace`` allows an existing key on ``name`` to be overridden. If
     |      it's not specified an error is raised on collision.
     |
     |      ``absttl`` if True, specified ``ttl`` should represent an absolute Unix
     |      timestamp in milliseconds in which the key will expire. (Redis 5.0 or
     |      greater).
     |
     |      ``idletime`` Used for eviction, this is the number of seconds the
     |      key must be idle, prior to execution.
     |
     |      ``frequency`` Used for eviction, this is the frequency counter of
     |      the object stored at the key, prior to execution.
     |
     |      For more information, see https://redis.io/commands/restore
     |
     |  set(self, name: 'KeyT', value: 'EncodableT', ex: 'ExpiryT | None' = None, px: 'ExpiryT | None' = None, nx: 'bool' = False, xx: 'bool' = False, keepttl: 'bool' = False, get: 'bool' = False, exat: 'AbsExpiryT | None' = None, pxat: 'AbsExpiryT | None' = None, ifeq: 'bytes | str | None' = None, ifne: 'bytes | str | None' = None, ifdeq: 'str | None' = None, ifdne: 'str | None' = None) -> 'bool | str | bytes | None | Awaitable[bool | str | bytes | None]'
     |      Set the value at key ``name`` to ``value``
     |
     |      Warning:
     |      **Experimental** since 7.1.
     |      The usage of the arguments ``ifeq``, ``ifne``, ``ifdeq``, and ``ifdne``
     |      is experimental. The API or returned results when those parameters are used
     |      may change based on feedback.
     |
     |      ``ex`` sets an expire flag on key ``name`` for ``ex`` seconds.
     |
     |      ``px`` sets an expire flag on key ``name`` for ``px`` milliseconds.
     |
     |      ``nx`` if set to True, set the value at key ``name`` to ``value`` only
     |          if it does not exist.
     |
     |      ``xx`` if set to True, set the value at key ``name`` to ``value`` only
     |          if it already exists.
     |
     |      ``keepttl`` if True, retain the time to live associated with the key.
     |          (Available since Redis 6.0)
     |
     |      ``get`` if True, set the value at key ``name`` to ``value`` and return
     |          the old value stored at key, or None if the key did not exist.
     |          (Available since Redis 6.2)
     |
     |      ``exat`` sets an expire flag on key ``name`` for ``ex`` seconds,
     |          specified in unix time.
     |
     |      ``pxat`` sets an expire flag on key ``name`` for ``ex`` milliseconds,
     |          specified in unix time.
     |
     |      ``ifeq`` set the value at key ``name`` to ``value`` only if the current
     |          value exactly matches the argument.
     |          If key doesn’t exist - it won’t be created.
     |          (Requires Redis 8.4 or greater)
     |
     |      ``ifne`` set the value at key ``name`` to ``value`` only if the current
     |          value does not exactly match the argument.
     |          If key doesn’t exist - it will be created.
     |          (Requires Redis 8.4 or greater)
     |
     |      ``ifdeq`` set the value at key ``name`` to ``value`` only if the current
     |          value XXH3 hex digest exactly matches the argument.
     |          If key doesn’t exist - it won’t be created.
     |          (Requires Redis 8.4 or greater)
     |
     |      ``ifdne`` set the value at key ``name`` to ``value`` only if the current
     |          value XXH3 hex digest does not exactly match the argument.
     |          If key doesn’t exist - it will be created.
     |          (Requires Redis 8.4 or greater)
     |
     |      For more information, see https://redis.io/commands/set
     |
     |  setbit(self, name: 'KeyT', offset: 'int', value: 'int') -> 'int | Awaitable[int]'
     |      Flag the ``offset`` in ``name`` as ``value``. Returns an integer
     |      indicating the previous value of ``offset``.
     |
     |      For more information, see https://redis.io/commands/setbit
     |
     |  setex(self, name: 'KeyT', time: 'ExpiryT', value: 'EncodableT') -> 'bool | Awaitable[bool]'
     |      Set the value of key ``name`` to ``value`` that expires in ``time``
     |      seconds. ``time`` can be represented by an integer or a Python
     |      timedelta object.
     |
     |      As per Redis 2.6.12, SETEX is considered deprecated.
     |      Please use SET with EX parameter in new code.
     |
     |      For more information, see https://redis.io/commands/setex
     |
     |  setnx(self, name: 'KeyT', value: 'EncodableT') -> 'bool | Awaitable[bool]'
     |      Set the value of key ``name`` to ``value`` if key doesn't exist
     |
     |      For more information, see https://redis.io/commands/setnx
     |
     |  setrange(self, name: 'KeyT', offset: 'int', value: 'EncodableT') -> 'int | Awaitable[int]'
     |      Overwrite bytes in the value of ``name`` starting at ``offset`` with
     |      ``value``. If ``offset`` plus the length of ``value`` exceeds the
     |      length of the original value, the new value will be larger than before.
     |      If ``offset`` exceeds the length of the original value, null bytes
     |      will be used to pad between the end of the previous value and the start
     |      of what's being injected.
     |
     |      Returns the length of the new string.
     |
     |      For more information, see https://redis.io/commands/setrange
     |
     |  strlen(self, name: 'KeyT') -> 'int | Awaitable[int]'
     |      Return the number of bytes stored in the value of ``name``
     |
     |      For more information, see https://redis.io/commands/strlen
     |
     |  substr(self, name: 'KeyT', start: 'int', end: 'int' = -1) -> 'bytes | str | Awaitable[bytes | str]'
     |      Return a substring of the string at key ``name``. ``start`` and ``end``
     |      are 0-based integers specifying the portion of the string to return.
     |
     |  ttl(self, name: 'KeyT') -> 'int | Awaitable[int]'
     |      Returns the number of seconds until the key ``name`` will expire
     |
     |      For more information, see https://redis.io/commands/ttl
     |
     |  type(self, name: 'KeyT') -> 'bytes | str | Awaitable[bytes | str]'
     |      Returns the type of key ``name``
     |
     |      For more information, see https://redis.io/commands/type
     |
     |  unwatch(self) -> 'None'
     |      Unwatches all previously watched keys for a transaction
     |
     |      For more information, see https://redis.io/commands/unwatch
     |
     |  watch(self, *names: 'KeyT') -> 'None'
     |      Watches the values at keys ``names``, or None if the key doesn't exist
     |
     |      For more information, see https://redis.io/commands/watch
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from redis.commands.core.HyperlogCommands:
     |
     |  pfadd(self, name: 'KeyT', *values: 'FieldT') -> 'int | Awaitable[int]'
     |      Adds the specified elements to the specified HyperLogLog.
     |
     |      For more information, see https://redis.io/commands/pfadd
     |
     |  pfcount(self, *sources: 'KeyT') -> 'int | Awaitable[int]'
     |      Return the approximated cardinality of
     |      the set observed by the HyperLogLog at key(s).
     |
     |      For more information, see https://redis.io/commands/pfcount
     |
     |  pfmerge(self, dest: 'KeyT', *sources: 'KeyT') -> 'bool | Awaitable[bool]'
     |      Merge N different HyperLogLogs into a single one.
     |
     |      For more information, see https://redis.io/commands/pfmerge
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from redis.commands.core.HashCommands:
     |
     |  hdel(self, name: 'KeyT', *keys: 'FieldT') -> 'int | Awaitable[int]'
     |      Delete ``keys`` from hash ``name``
     |
     |      For more information, see https://redis.io/commands/hdel
     |
     |  hexists(self, name: 'KeyT', key: 'FieldT') -> 'bool | Awaitable[bool]'
     |      Returns a boolean indicating if ``key`` exists within hash ``name``
     |
     |      For more information, see https://redis.io/commands/hexists
     |
     |  hexpire(self, name: 'KeyT', seconds: 'ExpiryT', *fields: 'FieldT', nx: 'bool' = False, xx: 'bool' = False, gt: 'bool' = False, lt: 'bool' = False) -> 'list[int] | Awaitable[list[int]]'
     |      Sets or updates the expiration time for fields within a hash key, using relative
     |      time in seconds.
     |
     |      If a field already has an expiration time, the behavior of the update can be
     |      controlled using the `nx`, `xx`, `gt`, and `lt` parameters.
     |
     |      The return value provides detailed information about the outcome for each field.
     |
     |      For more information, see https://redis.io/commands/hexpire
     |
     |      Args:
     |          name: The name of the hash key.
     |          seconds: Expiration time in seconds, relative. Can be an integer, or a
     |                   Python `timedelta` object.
     |          fields: List of fields within the hash to apply the expiration time to.
     |          nx: Set expiry only when the field has no expiry.
     |          xx: Set expiry only when the field has an existing expiry.
     |          gt: Set expiry only when the new expiry is greater than the current one.
     |          lt: Set expiry only when the new expiry is less than the current one.
     |
     |      Returns:
     |          Returns a list which contains for each field in the request:
     |              - `-2` if the field does not exist, or if the key does not exist.
     |              - `0` if the specified NX | XX | GT | LT condition was not met.
     |              - `1` if the expiration time was set or updated.
     |              - `2` if the field was deleted because the specified expiration time is
     |                in the past.
     |
     |  hexpireat(self, name: 'KeyT', unix_time_seconds: 'AbsExpiryT', *fields: 'FieldT', nx: 'bool' = False, xx: 'bool' = False, gt: 'bool' = False, lt: 'bool' = False) -> 'list[int] | Awaitable[list[int]]'
     |      Sets or updates the expiration time for fields within a hash key, using an
     |      absolute Unix timestamp in seconds.
     |
     |      If a field already has an expiration time, the behavior of the update can be
     |      controlled using the `nx`, `xx`, `gt`, and `lt` parameters.
     |
     |      The return value provides detailed information about the outcome for each field.
     |
     |      For more information, see https://redis.io/commands/hexpireat
     |
     |      Args:
     |          name: The name of the hash key.
     |          unix_time_seconds: Expiration time as Unix timestamp in seconds. Can be an
     |                             integer or a Python `datetime` object.
     |          fields: List of fields within the hash to apply the expiration time to.
     |          nx: Set expiry only when the field has no expiry.
     |          xx: Set expiry only when the field has an existing expiration time.
     |          gt: Set expiry only when the new expiry is greater than the current one.
     |          lt: Set expiry only when the new expiry is less than the current one.
     |
     |      Returns:
     |          Returns a list which contains for each field in the request:
     |              - `-2` if the field does not exist, or if the key does not exist.
     |              - `0` if the specified NX | XX | GT | LT condition was not met.
     |              - `1` if the expiration time was set or updated.
     |              - `2` if the field was deleted because the specified expiration time is
     |                in the past.
     |
     |  hexpiretime(self, key: 'KeyT', *fields: 'FieldT') -> 'list[int] | Awaitable[list[int]]'
     |      Returns the expiration times of hash fields as Unix timestamps in seconds.
     |
     |      For more information, see https://redis.io/commands/hexpiretime
     |
     |      Args:
     |          key: The hash key.
     |          fields: A list of fields within the hash for which to get the expiration
     |                  time.
     |
     |      Returns:
     |          Returns a list which contains for each field in the request:
     |              - `-2` if the field does not exist, or if the key does not exist.
     |              - `-1` if the field exists but has no associated expire time.
     |              - A positive integer representing the expiration Unix timestamp in
     |                seconds, if the field has an associated expiration time.
     |
     |  hget(self, name: 'KeyT', key: 'FieldT') -> 'bytes | str | None | Awaitable[bytes | str | None]'
     |      Return the value of ``key`` within the hash ``name``
     |
     |      For more information, see https://redis.io/commands/hget
     |
     |  hgetall(self, name: 'KeyT') -> 'dict[bytes | str, bytes | str] | Awaitable[dict[bytes | str, bytes | str]]'
     |      Return a Python dict of the hash's name/value pairs
     |
     |      For more information, see https://redis.io/commands/hgetall
     |
     |  hgetdel(self, name: 'KeyT', *keys: 'FieldT') -> 'list[bytes | str | None] | Awaitable[list[bytes | str | None]]'
     |      Return the value of ``key`` within the hash ``name`` and
     |      delete the field in the hash.
     |      This command is similar to HGET, except for the fact that it also deletes
     |      the key on success from the hash with the provided ```name```.
     |
     |      Available since Redis 8.0
     |      For more information, see https://redis.io/commands/hgetdel
     |
     |  hgetex(self, name: 'KeyT', *keys: 'FieldT', ex: 'ExpiryT | None' = None, px: 'ExpiryT | None' = None, exat: 'AbsExpiryT | None' = None, pxat: 'AbsExpiryT | None' = None, persist: 'bool' = False) -> 'list[bytes | str | None] | Awaitable[list[bytes | str | None]]'
     |      Return the values of ``key`` and ``keys`` within the hash ``name``
     |      and optionally set their expiration.
     |
     |      ``ex`` sets an expire flag on ``kyes`` for ``ex`` seconds.
     |
     |      ``px`` sets an expire flag on ``keys`` for ``px`` milliseconds.
     |
     |      ``exat`` sets an expire flag on ``keys`` for ``ex`` seconds,
     |      specified in unix time.
     |
     |      ``pxat`` sets an expire flag on ``keys`` for ``ex`` milliseconds,
     |      specified in unix time.
     |
     |      ``persist`` remove the time to live associated with the ``keys``.
     |
     |      Available since Redis 8.0
     |      For more information, see https://redis.io/commands/hgetex
     |
     |  himport_discard_all_internal(self) -> 'int | Awaitable[int]'
     |      Send ``HIMPORT DISCARDALL`` (returns the number of fieldsets removed).
     |
     |      .. warning::
     |          Internal wire mapping — not for direct use on a pooled client. It
     |          DISCARDs on a single arbitrary borrowed connection and bypasses the
     |          client's shared fieldset registry, leaving other connections and the
     |          registry out of sync. Use the client's ``himport_discard_all`` instead;
     |          call this only on a pinned single-connection client where you manage
     |          session state yourself.
     |
     |  himport_discard_internal(self, fieldset_name: 'str') -> 'int | Awaitable[int]'
     |      Send ``HIMPORT DISCARD fieldset_name`` (``1`` removed, ``0`` not found).
     |
     |      .. warning::
     |          Internal wire mapping — not for direct use on a pooled client. It
     |          DISCARDs on a single arbitrary borrowed connection and bypasses the
     |          client's shared fieldset registry, leaving other connections and the
     |          registry out of sync. Use the client's ``himport_discard`` instead; call
     |          this only on a pinned single-connection client where you manage session
     |          state yourself.
     |
     |  himport_prepare_internal(self, fieldset_name: 'str', fields: 'Iterable[FieldT]') -> 'bool | Awaitable[bool]'
     |      Send ``HIMPORT PREPARE fieldset_name field [field ...]``.
     |
     |      Registers the ordered field list under ``fieldset_name`` in the executing
     |      connection's session. Fields are sent in the caller's order, unmodified.
     |
     |      .. warning::
     |          Internal wire mapping — not for direct use on a pooled client. It
     |          PREPAREs on a single arbitrary borrowed connection and bypasses the
     |          client's shared fieldset registry, so other connections stay unaware and
     |          reintroduce the nondeterministic "no such fieldset" the HIMPORT design
     |          prevents. Use the client's ``himport_prepare`` instead; call this only
     |          on a pinned single-connection client where you manage session state
     |          yourself.
     |
     |  himport_set(self, key: 'KeyT', fieldset_name: 'str', values: 'Iterable[EncodableT]') -> 'bool | Awaitable[bool]'
     |      Create/replace ``key`` as a hash using ``fieldset_name``'s field list.
     |
     |      Values are sent in the caller's order and map positionally to the prepared
     |      fields. The fieldset is prepared on the serving connection on first use
     |      (PREPARE bundled with SET in one write) and reused on subsequent calls;
     |      runtime discards are reconciled on the next use of the connection. All of
     |      this happens inside the normal command path, so retry, disconnect-on-error
     |      and (for the cluster) routing / MOVED-ASK apply exactly as for any command.
     |
     |      .. note::
     |          Recovery from a mid-connection fieldset loss (the server dropping the
     |          prepared fieldset without dropping the socket, e.g. ``RESET`` or
     |          ``maxmemory-clients`` eviction) applies only to a standalone
     |          ``himport_set`` call: it catches the resulting ``no such fieldset`` and
     |          re-prepares on the same socket, retrying the SET once. A ``himport_set``
     |          buffered in a **pipeline or transaction** has no such per-command
     |          recovery — its fieldset is PREPAREd once as a pre-flight before the
     |          batch, and if the server loses it between that pre-flight and the batch
     |          the SET fails and surfaces as an error in the batch results. Callers who
     |          need the automatic recovery should issue those sets outside a pipeline.
     |
     |  hincrby(self, name: 'KeyT', key: 'FieldT', amount: 'int' = 1) -> 'int | Awaitable[int]'
     |      Increment the value of ``key`` in hash ``name`` by ``amount``
     |
     |      For more information, see https://redis.io/commands/hincrby
     |
     |  hincrbyfloat(self, name: 'KeyT', key: 'FieldT', amount: 'float' = 1.0) -> 'float | Awaitable[float]'
     |      Increment the value of ``key`` in hash ``name`` by floating ``amount``
     |
     |      For more information, see https://redis.io/commands/hincrbyfloat
     |
     |  hkeys(self, name: 'KeyT') -> 'list[bytes | str] | Awaitable[list[bytes | str]]'
     |      Return the list of keys within hash ``name``
     |
     |      For more information, see https://redis.io/commands/hkeys
     |
     |  hlen(self, name: 'KeyT') -> 'int | Awaitable[int]'
     |      Return the number of elements in hash ``name``
     |
     |      For more information, see https://redis.io/commands/hlen
     |
     |  hmget(self, name: 'KeyT', keys: 'FieldT | Iterable[FieldT]', *args: 'FieldT') -> 'list[bytes | str | None] | Awaitable[list[bytes | str | None]]'
     |      Returns a list of values ordered identically to ``keys``
     |
     |      For more information, see https://redis.io/commands/hmget
     |
     |  hmset(self, name: 'KeyT', mapping: 'Mapping[FieldT, EncodableT]') -> 'bool | Awaitable[bool]'
     |      Set key to value within hash ``name`` for each corresponding
     |      key and value from the ``mapping`` dict.
     |
     |      For more information, see https://redis.io/commands/hmset
     |
     |  hpersist(self, name: 'KeyT', *fields: 'FieldT') -> 'list[int] | Awaitable[list[int]]'
     |      Removes the expiration time for each specified field in a hash.
     |
     |      For more information, see https://redis.io/commands/hpersist
     |
     |      Args:
     |          name: The name of the hash key.
     |          fields: A list of fields within the hash from which to remove the
     |                  expiration time.
     |
     |      Returns:
     |          Returns a list which contains for each field in the request:
     |              - `-2` if the field does not exist, or if the key does not exist.
     |              - `-1` if the field exists but has no associated expiration time.
     |              - `1` if the expiration time was successfully removed from the field.
     |
     |  hpexpire(self, name: 'KeyT', milliseconds: 'ExpiryT', *fields: 'FieldT', nx: 'bool' = False, xx: 'bool' = False, gt: 'bool' = False, lt: 'bool' = False) -> 'list[int] | Awaitable[list[int]]'
     |      Sets or updates the expiration time for fields within a hash key, using relative
     |      time in milliseconds.
     |
     |      If a field already has an expiration time, the behavior of the update can be
     |      controlled using the `nx`, `xx`, `gt`, and `lt` parameters.
     |
     |      The return value provides detailed information about the outcome for each field.
     |
     |      For more information, see https://redis.io/commands/hpexpire
     |
     |      Args:
     |          name: The name of the hash key.
     |          milliseconds: Expiration time in milliseconds, relative. Can be an integer,
     |                        or a Python `timedelta` object.
     |          fields: List of fields within the hash to apply the expiration time to.
     |          nx: Set expiry only when the field has no expiry.
     |          xx: Set expiry only when the field has an existing expiry.
     |          gt: Set expiry only when the new expiry is greater than the current one.
     |          lt: Set expiry only when the new expiry is less than the current one.
     |
     |      Returns:
     |          Returns a list which contains for each field in the request:
     |              - `-2` if the field does not exist, or if the key does not exist.
     |              - `0` if the specified NX | XX | GT | LT condition was not met.
     |              - `1` if the expiration time was set or updated.
     |              - `2` if the field was deleted because the specified expiration time is
     |                in the past.
     |
     |  hpexpireat(self, name: 'KeyT', unix_time_milliseconds: 'AbsExpiryT', *fields: 'FieldT', nx: 'bool' = False, xx: 'bool' = False, gt: 'bool' = False, lt: 'bool' = False) -> 'list[int] | Awaitable[list[int]]'
     |      Sets or updates the expiration time for fields within a hash key, using an
     |      absolute Unix timestamp in milliseconds.
     |
     |      If a field already has an expiration time, the behavior of the update can be
     |      controlled using the `nx`, `xx`, `gt`, and `lt` parameters.
     |
     |      The return value provides detailed information about the outcome for each field.
     |
     |      For more information, see https://redis.io/commands/hpexpireat
     |
     |      Args:
     |          name: The name of the hash key.
     |          unix_time_milliseconds: Expiration time as Unix timestamp in milliseconds.
     |                                  Can be an integer or a Python `datetime` object.
     |          fields: List of fields within the hash to apply the expiry.
     |          nx: Set expiry only when the field has no expiry.
     |          xx: Set expiry only when the field has an existing expiry.
     |          gt: Set expiry only when the new expiry is greater than the current one.
     |          lt: Set expiry only when the new expiry is less than the current one.
     |
     |      Returns:
     |          Returns a list which contains for each field in the request:
     |              - `-2` if the field does not exist, or if the key does not exist.
     |              - `0` if the specified NX | XX | GT | LT condition was not met.
     |              - `1` if the expiration time was set or updated.
     |              - `2` if the field was deleted because the specified expiration time is
     |                in the past.
     |
     |  hpexpiretime(self, key: 'KeyT', *fields: 'FieldT') -> 'list[int] | Awaitable[list[int]]'
     |      Returns the expiration times of hash fields as Unix timestamps in milliseconds.
     |
     |      For more information, see https://redis.io/commands/hpexpiretime
     |
     |      Args:
     |          key: The hash key.
     |          fields: A list of fields within the hash for which to get the expiration
     |                  time.
     |
     |      Returns:
     |          Returns a list which contains for each field in the request:
     |              - `-2` if the field does not exist, or if the key does not exist.
     |              - `-1` if the field exists but has no associated expire time.
     |              - A positive integer representing the expiration Unix timestamp in
     |                milliseconds, if the field has an associated expiration time.
     |
     |  hpttl(self, key: 'KeyT', *fields: 'FieldT') -> 'list[int] | Awaitable[list[int]]'
     |      Returns the TTL (Time To Live) in milliseconds for each specified field within a
     |      hash key.
     |
     |      For more information, see https://redis.io/commands/hpttl
     |
     |      Args:
     |          key: The hash key.
     |          fields: A list of fields within the hash for which to get the TTL.
     |
     |      Returns:
     |          Returns a list which contains for each field in the request:
     |              - `-2` if the field does not exist, or if the key does not exist.
     |              - `-1` if the field exists but has no associated expire time.
     |              - A positive integer representing the TTL in milliseconds if the field
     |                has an associated expiration time.
     |
     |  hset(self, name: 'KeyT', key: 'FieldT | None' = None, value: 'EncodableT | None' = None, mapping: 'Mapping[FieldT, EncodableT] | None' = None, items: 'Sequence[EncodableT] | None' = None) -> 'int | Awaitable[int]'
     |      Set ``key`` to ``value`` within hash ``name``,
     |      ``mapping`` accepts a dict of key/value pairs that will be
     |      added to hash ``name``.
     |      ``items`` accepts a list of key/value pairs that will be
     |      added to hash ``name``.
     |      Returns the number of fields that were added.
     |
     |      For more information, see https://redis.io/commands/hset
     |
     |  hsetex(self, name: 'KeyT', key: 'FieldT | None' = None, value: 'EncodableT | None' = None, mapping: 'Mapping[FieldT, EncodableT] | None' = None, items: 'Sequence[EncodableT] | None' = None, ex: 'ExpiryT | None' = None, px: 'ExpiryT | None' = None, exat: 'AbsExpiryT | None' = None, pxat: 'AbsExpiryT | None' = None, data_persist_option: 'HashDataPersistOptions | None' = None, keepttl: 'bool' = False) -> 'int | Awaitable[int]'
     |      Set ``key`` to ``value`` within hash ``name``
     |
     |      ``mapping`` accepts a dict of key/value pairs that will be
     |      added to hash ``name``.
     |
     |      ``items`` accepts a list of key/value pairs that will be
     |      added to hash ``name``.
     |
     |      ``ex`` sets an expire flag on ``keys`` for ``ex`` seconds.
     |
     |      ``px`` sets an expire flag on ``keys`` for ``px`` milliseconds.
     |
     |      ``exat`` sets an expire flag on ``keys`` for ``ex`` seconds,
     |          specified in unix time.
     |
     |      ``pxat`` sets an expire flag on ``keys`` for ``ex`` milliseconds,
     |          specified in unix time.
     |
     |      ``data_persist_option`` can be set to ``FNX`` or ``FXX`` to control the
     |          behavior of the command.
     |          ``FNX`` will set the value for each provided key to each
     |              provided value only if all do not already exist.
     |          ``FXX`` will set the value for each provided key to each
     |              provided value only if all already exist.
     |
     |      ``keepttl`` if True, retain the time to live associated with the keys.
     |
     |      Returns the number of fields that were added.
     |
     |      Available since Redis 8.0
     |      For more information, see https://redis.io/commands/hsetex
     |
     |  hsetnx(self, name: 'KeyT', key: 'FieldT', value: 'EncodableT') -> 'int | Awaitable[int]'
     |      Set ``key`` to ``value`` within hash ``name`` if ``key`` does not
     |      exist.  Returns 1 if HSETNX created a field, otherwise 0.
     |
     |      For more information, see https://redis.io/commands/hsetnx
     |
     |  hstrlen(self, name: 'KeyT', key: 'FieldT') -> 'int | Awaitable[int]'
     |      Return the number of bytes stored in the value of ``key``
     |      within hash ``name``
     |
     |      For more information, see https://redis.io/commands/hstrlen
     |
     |  httl(self, key: 'KeyT', *fields: 'FieldT') -> 'list[int] | Awaitable[list[int]]'
     |      Returns the TTL (Time To Live) in seconds for each specified field within a hash
     |      key.
     |
     |      For more information, see https://redis.io/commands/httl
     |
     |      Args:
     |          key: The hash key.
     |          fields: A list of fields within the hash for which to get the TTL.
     |
     |      Returns:
     |          Returns a list which contains for each field in the request:
     |              - `-2` if the field does not exist, or if the key does not exist.
     |              - `-1` if the field exists but has no associated expire time.
     |              - A positive integer representing the TTL in seconds if the field has
     |                an associated expiration time.
     |
     |  hvals(self, name: 'KeyT') -> 'list[bytes | str] | Awaitable[list[bytes | str]]'
     |      Return the list of values within hash ``name``
     |
     |      For more information, see https://redis.io/commands/hvals
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from redis.commands.core.GeoCommands:
     |
     |  geoadd(self, name: 'KeyT', values: 'Sequence[EncodableT]', nx: 'bool' = False, xx: 'bool' = False, ch: 'bool' = False) -> 'int | Awaitable[int]'
     |      Add the specified geospatial items to the specified key identified
     |      by the ``name`` argument. The Geospatial items are given as ordered
     |      members of the ``values`` argument, each item or place is formed by
     |      the triad longitude, latitude and name.
     |
     |      Note: You can use ZREM to remove elements.
     |
     |      ``nx`` forces ZADD to only create new elements and not to update
     |      scores for elements that already exist.
     |
     |      ``xx`` forces ZADD to only update scores of elements that already
     |      exist. New elements will not be added.
     |
     |      ``ch`` modifies the return value to be the numbers of elements changed.
     |      Changed elements include new elements that were added and elements
     |      whose scores changed.
     |
     |      For more information, see https://redis.io/commands/geoadd
     |
     |  geodist(self, name: 'KeyT', place1: 'FieldT', place2: 'FieldT', unit: 'str | None' = None) -> 'float | None | Awaitable[float | None]'
     |      Return the distance between ``place1`` and ``place2`` members of the
     |      ``name`` key.
     |      The units must be one of the following : m, km mi, ft. By default
     |      meters are used.
     |
     |      For more information, see https://redis.io/commands/geodist
     |
     |  geohash(self, name: 'KeyT', *values: 'FieldT') -> 'list[bytes | str | None] | Awaitable[list[bytes | str | None]]'
     |      Return the geo hash string for each item of ``values`` members of
     |      the specified key identified by the ``name`` argument.
     |
     |      For more information, see https://redis.io/commands/geohash
     |
     |  geopos(self, name: 'KeyT', *values: 'FieldT') -> 'list[GeoCoordinate | None] | Awaitable[list[GeoCoordinate | None]]'
     |      Return the positions of each item of ``values`` as members of
     |      the specified key identified by the ``name`` argument. Each position
     |      is represented by the pairs lon and lat.
     |
     |      For more information, see https://redis.io/commands/geopos
     |
     |  georadius(self, name: 'KeyT', longitude: 'float', latitude: 'float', radius: 'float', unit: 'str | None' = None, withdist: 'bool' = False, withcoord: 'bool' = False, withhash: 'bool' = False, count: 'int | None' = None, sort: 'str | None' = None, store: 'KeyT | None' = None, store_dist: 'KeyT | None' = None, any: 'bool' = False) -> 'GeoRadiusResponse | Awaitable[GeoRadiusResponse]'
     |      Return the members of the specified key identified by the
     |      ``name`` argument which are within the borders of the area specified
     |      with the ``latitude`` and ``longitude`` location and the maximum
     |      distance from the center specified by the ``radius`` value.
     |
     |      The units must be one of the following : m, km mi, ft. By default
     |
     |      ``withdist`` indicates to return the distances of each place.
     |
     |      ``withcoord`` indicates to return the latitude and longitude of
     |      each place.
     |
     |      ``withhash`` indicates to return the geohash string of each place.
     |
     |      ``count`` indicates to return the number of elements up to N.
     |
     |      ``sort`` indicates to return the places in a sorted way, ASC for
     |      nearest to fairest and DESC for fairest to nearest.
     |
     |      ``store`` indicates to save the places names in a sorted set named
     |      with a specific key, each element of the destination sorted set is
     |      populated with the score got from the original geo sorted set.
     |
     |      ``store_dist`` indicates to save the places names in a sorted set
     |      named with a specific key, instead of ``store`` the sorted set
     |      destination score is set with the distance.
     |
     |      For more information, see https://redis.io/commands/georadius
     |
     |  georadiusbymember(self, name: 'KeyT', member: 'FieldT', radius: 'float', unit: 'str | None' = None, withdist: 'bool' = False, withcoord: 'bool' = False, withhash: 'bool' = False, count: 'int | None' = None, sort: 'str | None' = None, store: 'Union[KeyT, None]' = None, store_dist: 'Union[KeyT, None]' = None, any: 'bool' = False) -> 'GeoRadiusResponse | Awaitable[GeoRadiusResponse]'
     |      This command is exactly like ``georadius`` with the sole difference
     |      that instead of taking, as the center of the area to query, a longitude
     |      and latitude value, it takes the name of a member already existing
     |      inside the geospatial index represented by the sorted set.
     |
     |      For more information, see https://redis.io/commands/georadiusbymember
     |
     |  geosearch(self, name: 'KeyT', member: 'FieldT | None' = None, longitude: 'float | None' = None, latitude: 'float | None' = None, unit: 'str' = 'm', radius: 'float | None' = None, width: 'float | None' = None, height: 'float | None' = None, sort: 'str | None' = None, count: 'int | None' = None, any: 'bool' = False, withcoord: 'bool' = False, withdist: 'bool' = False, withhash: 'bool' = False) -> 'GeoSearchResponse | Awaitable[GeoSearchResponse]'
     |      Return the members of specified key identified by the
     |      ``name`` argument, which are within the borders of the
     |      area specified by a given shape. This command extends the
     |      GEORADIUS command, so in addition to searching within circular
     |      areas, it supports searching within rectangular areas.
     |
     |      This command should be used in place of the deprecated
     |      GEORADIUS and GEORADIUSBYMEMBER commands.
     |
     |      ``member`` Use the position of the given existing
     |       member in the sorted set. Can't be given with ``longitude``
     |       and ``latitude``.
     |
     |      ``longitude`` and ``latitude`` Use the position given by
     |      this coordinates. Can't be given with ``member``
     |      ``radius`` Similar to GEORADIUS, search inside circular
     |      area according the given radius. Can't be given with
     |      ``height`` and ``width``.
     |      ``height`` and ``width`` Search inside an axis-aligned
     |      rectangle, determined by the given height and width.
     |      Can't be given with ``radius``
     |
     |      ``unit`` must be one of the following : m, km, mi, ft.
     |      `m` for meters (the default value), `km` for kilometers,
     |      `mi` for miles and `ft` for feet.
     |
     |      ``sort`` indicates to return the places in a sorted way,
     |      ASC for nearest to furthest and DESC for furthest to nearest.
     |
     |      ``count`` limit the results to the first count matching items.
     |
     |      ``any`` is set to True, the command will return as soon as
     |      enough matches are found. Can't be provided without ``count``
     |
     |      ``withdist`` indicates to return the distances of each place.
     |      ``withcoord`` indicates to return the latitude and longitude of
     |      each place.
     |
     |      ``withhash`` indicates to return the geohash string of each place.
     |
     |      For more information, see https://redis.io/commands/geosearch
     |
     |  geosearchstore(self, dest: 'KeyT', name: 'KeyT', member: 'FieldT | None' = None, longitude: 'float | None' = None, latitude: 'float | None' = None, unit: 'str' = 'm', radius: 'float | None' = None, width: 'float | None' = None, height: 'float | None' = None, sort: 'str | None' = None, count: 'int | None' = None, any: 'bool' = False, storedist: 'bool' = False) -> 'int | Awaitable[int]'
     |      This command is like GEOSEARCH, but stores the result in
     |      ``dest``. By default, it stores the results in the destination
     |      sorted set with their geospatial information.
     |      if ``store_dist`` set to True, the command will stores the
     |      items in a sorted set populated with their distance from the
     |      center of the circle or box, as a floating-point number.
     |
     |      For more information, see https://redis.io/commands/geosearchstore
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from redis.commands.core.ListCommands:
     |
     |  blmpop(self, timeout: 'float', numkeys: 'int', *args: 'str', direction: 'str', count: 'int | None' = 1) -> 'ListMultiPopResponse | Awaitable[ListMultiPopResponse]'
     |      Pop ``count`` values (default 1) from first non-empty in the list
     |      of provided key names.
     |
     |      When all lists are empty this command blocks the connection until another
     |      client pushes to it or until the timeout, timeout of 0 blocks indefinitely
     |
     |      For more information, see https://redis.io/commands/blmpop
     |
     |  blpop(self, keys: 'KeysT', timeout: 'Number | None' = 0) -> 'BlockingListPopResponse | Awaitable[BlockingListPopResponse]'
     |      LPOP a value off of the first non-empty list
     |      named in ``keys``.
     |
     |      If none of the lists in ``keys`` has a value to LPOP, then block
     |      for ``timeout`` seconds, or until a value gets pushed on to one
     |      of the lists.
     |
     |      If timeout is 0, then block indefinitely.
     |
     |      For more information, see https://redis.io/commands/blpop
     |
     |  brpop(self, keys: 'KeysT', timeout: 'Number | None' = 0) -> 'BlockingListPopResponse | Awaitable[BlockingListPopResponse]'
     |      RPOP a value off of the first non-empty list
     |      named in ``keys``.
     |
     |      If none of the lists in ``keys`` has a value to RPOP, then block
     |      for ``timeout`` seconds, or until a value gets pushed on to one
     |      of the lists.
     |
     |      If timeout is 0, then block indefinitely.
     |
     |      For more information, see https://redis.io/commands/brpop
     |
     |  brpoplpush(self, src: 'KeyT', dst: 'KeyT', timeout: 'Number | None' = 0) -> 'bytes | str | None | Awaitable[bytes | str | None]'
     |      Pop a value off the tail of ``src``, push it on the head of ``dst``
     |      and then return it.
     |
     |      This command blocks until a value is in ``src`` or until ``timeout``
     |      seconds elapse, whichever is first. A ``timeout`` value of 0 blocks
     |      forever.
     |
     |      For more information, see https://redis.io/commands/brpoplpush
     |
     |  lindex(self, name: 'KeyT', index: 'int') -> 'bytes | str | None | Awaitable[bytes | str | None]'
     |      Return the item from list ``name`` at position ``index``
     |
     |      Negative indexes are supported and will return an item at the
     |      end of the list
     |
     |      For more information, see https://redis.io/commands/lindex
     |
     |  linsert(self, name: 'KeyT', where: 'str', refvalue: 'str', value: 'str') -> 'int | Awaitable[int]'
     |      Insert ``value`` in list ``name`` either immediately before or after
     |      [``where``] ``refvalue``
     |
     |      Returns the new length of the list on success or -1 if ``refvalue``
     |      is not in the list.
     |
     |      For more information, see https://redis.io/commands/linsert
     |
     |  llen(self, name: 'KeyT') -> 'int | Awaitable[int]'
     |      Return the length of the list ``name``
     |
     |      For more information, see https://redis.io/commands/llen
     |
     |  lmpop(self, num_keys: 'int', *args: 'str', direction: 'str', count: 'int | None' = 1) -> 'ListMultiPopResponse | Awaitable[ListMultiPopResponse]'
     |      Pop ``count`` values (default 1) first non-empty list key from the list
     |      of args provided key names.
     |
     |      For more information, see https://redis.io/commands/lmpop
     |
     |  lpop(self, name: 'KeyT', count: 'int | None' = None) -> 'bytes | str | list[bytes | str] | None | Awaitable[bytes | str | list[bytes | str] | None]'
     |      Removes and returns the first elements of the list ``name``.
     |
     |      By default, the command pops a single element from the beginning of
     |      the list. When provided with the optional ``count`` argument, the reply
     |      will consist of up to count elements, depending on the list's length.
     |
     |      For more information, see https://redis.io/commands/lpop
     |
     |  lpos(self, name: 'KeyT', value: 'str', rank: 'int | None' = None, count: 'int | None' = None, maxlen: 'int | None' = None) -> 'int | list[int] | None | Awaitable[int | list[int] | None]'
     |      Get position of ``value`` within the list ``name``
     |
     |       If specified, ``rank`` indicates the "rank" of the first element to
     |       return in case there are multiple copies of ``value`` in the list.
     |       By default, LPOS returns the position of the first occurrence of
     |       ``value`` in the list. When ``rank`` 2, LPOS returns the position of
     |       the second ``value`` in the list. If ``rank`` is negative, LPOS
     |       searches the list in reverse. For example, -1 would return the
     |       position of the last occurrence of ``value`` and -2 would return the
     |       position of the next to last occurrence of ``value``.
     |
     |       If specified, ``count`` indicates that LPOS should return a list of
     |       up to ``count`` positions. A ``count`` of 2 would return a list of
     |       up to 2 positions. A ``count`` of 0 returns a list of all positions
     |       matching ``value``. When ``count`` is specified and but ``value``
     |       does not exist in the list, an empty list is returned.
     |
     |       If specified, ``maxlen`` indicates the maximum number of list
     |       elements to scan. A ``maxlen`` of 1000 will only return the
     |       position(s) of items within the first 1000 entries in the list.
     |       A ``maxlen`` of 0 (the default) will scan the entire list.
     |
     |       For more information, see https://redis.io/commands/lpos
     |
     |  lpush(self, name: 'KeyT', *values: 'FieldT') -> 'int | Awaitable[int]'
     |      Push ``values`` onto the head of the list ``name``
     |
     |      For more information, see https://redis.io/commands/lpush
     |
     |  lpushx(self, name: 'KeyT', *values: 'FieldT') -> 'int | Awaitable[int]'
     |      Push ``value`` onto the head of the list ``name`` if ``name`` exists
     |
     |      For more information, see https://redis.io/commands/lpushx
     |
     |  lrange(self, name: 'KeyT', start: 'int', end: 'int') -> 'list[bytes | str] | Awaitable[list[bytes | str]]'
     |      Return a slice of the list ``name`` between
     |      position ``start`` and ``end``
     |
     |      ``start`` and ``end`` can be negative numbers just like
     |      Python slicing notation
     |
     |      For more information, see https://redis.io/commands/lrange
     |
     |  lrem(self, name: 'KeyT', count: 'int', value: 'str') -> 'int | Awaitable[int]'
     |      Remove the first ``count`` occurrences of elements equal to ``value``
     |      from the list stored at ``name``.
     |
     |      The count argument influences the operation in the following ways:
     |          count > 0: Remove elements equal to value moving from head to tail.
     |          count < 0: Remove elements equal to value moving from tail to head.
     |          count = 0: Remove all elements equal to value.
     |
     |          For more information, see https://redis.io/commands/lrem
     |
     |  lset(self, name: 'KeyT', index: 'int', value: 'str') -> 'bool | Awaitable[bool]'
     |      Set element at ``index`` of list ``name`` to ``value``
     |
     |      For more information, see https://redis.io/commands/lset
     |
     |  ltrim(self, name: 'KeyT', start: 'int', end: 'int') -> 'bool | Awaitable[bool]'
     |      Trim the list ``name``, removing all values not within the slice
     |      between ``start`` and ``end``
     |
     |      ``start`` and ``end`` can be negative numbers just like
     |      Python slicing notation
     |
     |      For more information, see https://redis.io/commands/ltrim
     |
     |  rpop(self, name: 'KeyT', count: 'int | None' = None) -> 'bytes | str | list[bytes | str] | None | Awaitable[bytes | str | list[bytes | str] | None]'
     |      Removes and returns the last elements of the list ``name``.
     |
     |      By default, the command pops a single element from the end of the list.
     |      When provided with the optional ``count`` argument, the reply will
     |      consist of up to count elements, depending on the list's length.
     |
     |      For more information, see https://redis.io/commands/rpop
     |
     |  rpoplpush(self, src: 'KeyT', dst: 'KeyT') -> 'bytes | str | None | Awaitable[bytes | str | None]'
     |      RPOP a value off of the ``src`` list and atomically LPUSH it
     |      on to the ``dst`` list.  Returns the value.
     |
     |      For more information, see https://redis.io/commands/rpoplpush
     |
     |  rpush(self, name: 'KeyT', *values: 'FieldT') -> 'int | Awaitable[int]'
     |      Push ``values`` onto the tail of the list ``name``
     |
     |      For more information, see https://redis.io/commands/rpush
     |
     |  rpushx(self, name: 'KeyT', *values: 'str') -> 'int | Awaitable[int]'
     |      Push ``value`` onto the tail of the list ``name`` if ``name`` exists
     |
     |      For more information, see https://redis.io/commands/rpushx
     |
     |  sort(self, name: 'KeyT', start: 'int | None' = None, num: 'int | None' = None, by: 'str | None' = None, get: 'list[str] | None' = None, desc: 'bool' = False, alpha: 'bool' = False, store: 'str | None' = None, groups: 'bool | None' = False) -> 'SortResponse | Awaitable[SortResponse]'
     |      Sort and return the list, set or sorted set at ``name``.
     |
     |      ``start`` and ``num`` allow for paging through the sorted data
     |
     |      ``by`` allows using an external key to weight and sort the items.
     |          Use an "*" to indicate where in the key the item value is located
     |
     |      ``get`` allows for returning items from external keys rather than the
     |          sorted data itself.  Use an "*" to indicate where in the key
     |          the item value is located
     |
     |      ``desc`` allows for reversing the sort
     |
     |      ``alpha`` allows for sorting lexicographically rather than numerically
     |
     |      ``store`` allows for storing the result of the sort into
     |          the key ``store``
     |
     |      ``groups`` if set to True and if ``get`` contains at least two
     |          elements, sort will return a list of tuples, each containing the
     |          values fetched from the arguments to ``get``.
     |
     |      For more information, see https://redis.io/commands/sort
     |
     |  sort_ro(self, key: 'str', start: 'int | None' = None, num: 'int | None' = None, by: 'str | None' = None, get: 'list[str] | None' = None, desc: 'bool' = False, alpha: 'bool' = False) -> 'list[bytes | str] | Awaitable[list[bytes | str]]'
     |      Returns the elements contained in the list, set or sorted set at key.
     |      (read-only variant of the SORT command)
     |
     |      ``start`` and ``num`` allow for paging through the sorted data
     |
     |      ``by`` allows using an external key to weight and sort the items.
     |          Use an "*" to indicate where in the key the item value is located
     |
     |      ``get`` allows for returning items from external keys rather than the
     |          sorted data itself.  Use an "*" to indicate where in the key
     |          the item value is located
     |
     |      ``desc`` allows for reversing the sort
     |
     |      ``alpha`` allows for sorting lexicographically rather than numerically
     |
     |      For more information, see https://redis.io/commands/sort_ro
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from redis.commands.core.ArrayCommands:
     |
     |  arcount(self, name: 'KeyT') -> 'int | Awaitable[int]'
     |      Return the number of non-empty elements in the array stored at
     |      ``name``. Returns 0 if ``name`` does not exist.
     |
     |      For more information, see https://redis.io/commands/arcount
     |
     |  ardel(self, name: 'KeyT', *indices: 'int') -> 'int | Awaitable[int]'
     |      Delete elements at the specified ``indices`` in the array stored at
     |      ``name``. Deleting an index that does not exist counts as zero
     |      elements deleted and does not modify the array.
     |
     |      Returns the number of elements deleted.
     |
     |      For more information, see https://redis.io/commands/ardel
     |
     |  ardelrange(self, name: 'KeyT', *ranges: 'tuple[int, int]') -> 'int | Awaitable[int]'
     |      Delete elements within one or more inclusive index ranges in the
     |      array stored at ``name``. Each range is a ``(start, end)`` tuple.
     |      If ``start`` is greater than ``end`` for a given pair, the range is
     |      processed in ascending order regardless. Multiple pairs may overlap;
     |      each element is counted at most once.
     |
     |      Returns the number of elements deleted.
     |
     |      For more information, see https://redis.io/commands/ardelrange
     |
     |  arget(self, name: 'KeyT', index: 'int') -> 'bytes | str | None | Awaitable[bytes | str | None]'
     |      Return the value at ``index`` in the array stored at ``name``.
     |
     |      Returns ``None`` if ``name`` does not exist or no value is set at
     |      ``index``.
     |
     |      For more information, see https://redis.io/commands/arget
     |
     |  argetrange(self, name: 'KeyT', start: 'int', end: 'int') -> 'list[bytes | str | None] | Awaitable[list[bytes | str | None]]'
     |      Return the values in the inclusive index range [``start``, ``end``]
     |      in the array stored at ``name``. If ``start`` is greater than ``end``,
     |      elements are returned in reverse index order.
     |
     |      For more information, see https://redis.io/commands/argetrange
     |
     |  argrep(self, name: 'KeyT', start: 'int', end: 'int', predicates: 'list[tuple[ArrayPredicateType, EncodableT]]', combinator: 'ArrayPredicateCombinator | None' = None, limit: 'int | None' = None, withvalues: 'bool' = False, nocase: 'bool' = False) -> 'list[int] | list[list[int | bytes | str]] | Awaitable[list[int] | list[list[int | bytes | str]]]'
     |      Search elements of the array stored at ``name`` within the inclusive
     |      index range [``start``, ``end``] using one or more textual
     |      ``predicates``. Each predicate is a ``(type, value)`` tuple where
     |      ``type`` is a member of ``ArrayPredicateType``
     |      (``EXACT``, ``MATCH``, ``GLOB``, ``RE``).
     |
     |      Multiple predicates are combined via ``combinator``
     |      (``ArrayPredicateCombinator.AND`` or ``OR``); the server defaults to
     |      OR when omitted. ``limit`` caps the number of matches.
     |      ``withvalues=True`` returns a list of ``[index, value]`` pairs
     |      (``[[idx, val], ...]``) instead of a flat list of indices.
     |      ``nocase=True`` makes all comparisons case-insensitive.
     |
     |      Without ``withvalues``, returns a flat list of matching indices in
     |      traversal order. With ``withvalues``, returns a list of
     |      ``[index, value]`` pairs in traversal order. Empty slots are
     |      skipped.
     |
     |      For more information, see https://redis.io/commands/argrep
     |
     |  arinfo(self, name: 'KeyT', full: 'bool' = False) -> 'dict[str, int] | Awaitable[dict[str, int]]'
     |      Return metadata about the array stored at ``name`` as a dictionary.
     |      When ``full`` is ``True``, additionally include per-slice statistics
     |      (dense/sparse slice counts, average sizes, fill rates), which makes
     |      the call O(N) instead of O(1).
     |
     |      Raises ``ResponseError`` when the key does not exist.
     |
     |      For more information, see https://redis.io/commands/arinfo
     |
     |  arinsert(self, name: 'KeyT', *values: 'FieldT') -> 'int | Awaitable[int]'
     |      Insert one or more ``values`` at consecutive indices in the array
     |      stored at ``name``, beginning at the current insert cursor position.
     |      The cursor advances by one for each value inserted. Use ``ARNEXT``
     |      to inspect the current cursor position and ``ARSEEK`` to reposition
     |      it.
     |
     |      Returns the last index where a value was inserted.
     |
     |      For more information, see https://redis.io/commands/arinsert
     |
     |  arlastitems(self, name: 'KeyT', count: 'int', rev: 'bool' = False) -> 'list[bytes | str | None] | Awaitable[list[bytes | str | None]]'
     |      Return up to ``count`` most recently inserted elements from the array
     |      stored at ``name``. If the array contains fewer elements than
     |      ``count``, all elements are returned.
     |
     |      When ``rev`` is ``True``, elements are returned in reverse
     |      chronological order (most recent first) instead of the default
     |      oldest-first order.
     |
     |      For more information, see https://redis.io/commands/arlastitems
     |
     |  arlen(self, name: 'KeyT') -> 'int | Awaitable[int]'
     |      Return the length of the array stored at ``name``, defined as the
     |      maximum set index plus one. Returns 0 if ``name`` does not exist.
     |
     |      For more information, see https://redis.io/commands/arlen
     |
     |  armget(self, name: 'KeyT', *indices: 'int') -> 'list[bytes | str | None] | Awaitable[list[bytes | str | None]]'
     |      Return the values at the specified ``indices`` in the array stored at
     |      ``name``. The reply preserves the order of the requested indices and
     |      returns ``None`` for any index that is not set or when ``name`` does
     |      not exist.
     |
     |      For more information, see https://redis.io/commands/armget
     |
     |  armset(self, name: 'KeyT', mapping: 'Mapping[int, FieldT]') -> 'int | Awaitable[int]'
     |      Set multiple index/value pairs in the array stored at ``name``.
     |      ``mapping`` is a dictionary of zero-based integer indices to values.
     |      Pairs may be non-contiguous and in any order.
     |
     |      Returns the number of new slots that were set (previously empty).
     |
     |      For more information, see https://redis.io/commands/armset
     |
     |  arnext(self, name: 'KeyT') -> 'int | None | Awaitable[int | None]'
     |      Return the next index ``ARINSERT`` would use for the array stored at
     |      ``name``. Returns 0 if ``name`` does not exist or no insert happened
     |      yet, and ``None`` when the insertion cursor is exhausted (next insert
     |      would overflow).
     |
     |      For more information, see https://redis.io/commands/arnext
     |
     |  arop(self, name: 'KeyT', start: 'int', end: 'int', operation: 'ArrayAggregateOperations', value: 'EncodableT | None' = None) -> 'bytes | str | int | None | Awaitable[bytes | str | int | None]'
     |      Perform an aggregate ``operation`` on elements of the array stored at
     |      ``name`` in the inclusive index range [``start``, ``end``]. The range
     |      is always scanned from the lower to the higher index regardless of
     |      argument order.
     |
     |      ``operation`` is one of the members of ``ArrayAggregateOperations``.
     |      ``value`` is required when ``operation`` is
     |      ``ArrayAggregateOperations.MATCH`` and specifies the value to compare
     |      against.
     |
     |      Returns a bulk string for ``SUM``, ``MIN`` and ``MAX``, an integer
     |      for ``AND``, ``OR``, ``XOR``, ``MATCH`` and ``USED``, or ``None``
     |      when no elements match the operation.
     |
     |      For more information, see https://redis.io/commands/arop
     |
     |  arring(self, name: 'KeyT', size: 'int', *values: 'FieldT') -> 'int | Awaitable[int]'
     |      Insert one or more ``values`` into the array stored at ``name`` as a
     |      fixed-size ring buffer of ``size`` slots. Each value is placed at
     |      ``insert_idx % size``, wrapping back to index 0 once the end is
     |      reached and overwriting older values when full. If ``size`` is
     |      smaller than the current window, the array is truncated to fit.
     |
     |      Returns the last index where a value was inserted.
     |
     |      For more information, see https://redis.io/commands/arring
     |
     |  arscan(self, name: 'KeyT', start: 'int', end: 'int', limit: 'int | None' = None) -> 'list[list[int | bytes | str]] | Awaitable[list[list[int | bytes | str]]]'
     |      Iterate populated elements of the array stored at ``name`` in the
     |      inclusive range [``start``, ``end``] and return a list of
     |      ``[index, value]`` pairs in traversal order:
     |      ``[[idx1, val1], [idx2, val2], ...]``. Empty slots are skipped. If
     |      ``start`` is greater than ``end``, the iteration is reversed.
     |
     |      ``limit`` caps the number of populated elements returned. When
     |      omitted, all populated elements in range are returned.
     |
     |      For more information, see https://redis.io/commands/arscan
     |
     |  arseek(self, name: 'KeyT', index: 'int') -> 'int | Awaitable[int]'
     |      Set the insert cursor of the array stored at ``name`` to ``index``.
     |      Subsequent ``ARINSERT`` and ``ARRING`` operations begin inserting at
     |      this position.
     |
     |      Returns 1 if the cursor was set, 0 if ``name`` does not exist.
     |
     |      For more information, see https://redis.io/commands/arseek
     |
     |  arset(self, name: 'KeyT', index: 'int', *values: 'FieldT') -> 'int | Awaitable[int]'
     |      Set one or more contiguous ``values`` in the array stored at ``name``
     |      starting at ``index``. When multiple values are provided, they are
     |      stored at consecutive indices beginning at ``index``.
     |
     |      Returns the number of new slots that were set (previously empty).
     |
     |      For more information, see https://redis.io/commands/arset
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from redis.commands.core.ScanCommands:
     |
     |  hscan(self, name: 'KeyT', cursor: 'int' = 0, match: 'PatternT | None' = None, count: 'int | None' = None, no_values: 'bool | None' = None) -> 'HScanResponse | Awaitable[HScanResponse]'
     |      Incrementally return key/value slices in a hash. Also return a cursor
     |      indicating the scan position.
     |
     |      ``match`` allows for filtering the keys by pattern
     |
     |      ``count`` allows for hint the minimum number of returns
     |
     |      ``no_values`` indicates to return only the keys, without values.
     |
     |      For more information, see https://redis.io/commands/hscan
     |
     |  hscan_iter(self, name: 'KeyT', match: 'Union[PatternT, None]' = None, count: 'Optional[int]' = None, no_values: 'Union[bool, None]' = None) -> 'Iterator'
     |      Make an iterator using the HSCAN command so that the client doesn't
     |      need to remember the cursor position.
     |
     |      ``match`` allows for filtering the keys by pattern
     |
     |      ``count`` allows for hint the minimum number of returns
     |
     |      ``no_values`` indicates to return only the keys, without values
     |
     |  scan(self, cursor: 'int' = 0, match: 'PatternT | None' = None, count: 'int | None' = None, _type: 'str | None' = None, **kwargs) -> 'ScanResponse | Awaitable[ScanResponse]'
     |      Incrementally return lists of key names. Also return a cursor
     |      indicating the scan position.
     |
     |      ``match`` allows for filtering the keys by pattern
     |
     |      ``count`` provides a hint to Redis about the number of keys to
     |          return per batch.
     |
     |      ``_type`` filters the returned values by a particular Redis type.
     |          Stock Redis instances allow for the following types:
     |          HASH, LIST, SET, STREAM, STRING, ZSET
     |          Additionally, Redis modules can expose other types as well.
     |
     |      For more information, see https://redis.io/commands/scan
     |
     |  sscan(self, name: 'KeyT', cursor: 'int' = 0, match: 'PatternT | None' = None, count: 'int | None' = None) -> 'ScanResponse | Awaitable[ScanResponse]'
     |      Incrementally return lists of elements in a set. Also return a cursor
     |      indicating the scan position.
     |
     |      ``match`` allows for filtering the keys by pattern
     |
     |      ``count`` allows for hint the minimum number of returns
     |
     |      For more information, see https://redis.io/commands/sscan
     |
     |  sscan_iter(self, name: 'KeyT', match: 'Union[PatternT, None]' = None, count: 'Optional[int]' = None) -> 'Iterator'
     |      Make an iterator using the SSCAN command so that the client doesn't
     |      need to remember the cursor position.
     |
     |      ``match`` allows for filtering the keys by pattern
     |
     |      ``count`` allows for hint the minimum number of returns
     |
     |  zscan(self, name: 'KeyT', cursor: 'int' = 0, match: 'PatternT | None' = None, count: 'int | None' = None, score_cast_func: 'type | Callable' = <class 'float'>) -> 'ZScanResponse | Awaitable[ZScanResponse]'
     |      Incrementally return lists of elements in a sorted set. Also return a
     |      cursor indicating the scan position.
     |
     |      ``match`` allows for filtering the keys by pattern
     |
     |      ``count`` allows for hint the minimum number of returns
     |
     |      ``score_cast_func`` a callable used to cast the score return value
     |
     |      For more information, see https://redis.io/commands/zscan
     |
     |  zscan_iter(self, name: 'KeyT', match: 'Union[PatternT, None]' = None, count: 'Optional[int]' = None, score_cast_func: 'Union[type, Callable]' = <class 'float'>) -> 'Iterator'
     |      Make an iterator using the ZSCAN command so that the client doesn't
     |      need to remember the cursor position.
     |
     |      ``match`` allows for filtering the keys by pattern
     |
     |      ``count`` allows for hint the minimum number of returns
     |
     |      ``score_cast_func`` a callable used to cast the score return value
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from redis.commands.core.SetCommands:
     |
     |  sadd(self, name: 'KeyT', *values: 'FieldT') -> 'int | Awaitable[int]'
     |      Add ``value(s)`` to set ``name``
     |
     |      For more information, see https://redis.io/commands/sadd
     |
     |  scard(self, name: 'KeyT') -> 'int | Awaitable[int]'
     |      Return the number of elements in set ``name``
     |
     |      For more information, see https://redis.io/commands/scard
     |
     |  sdiff(self, keys: 'List', *args: 'List') -> 'set[bytes | str] | Awaitable[set[bytes | str]]'
     |      Return the difference of sets specified by ``keys``
     |
     |      For more information, see https://redis.io/commands/sdiff
     |
     |  sdiffcard(self, numkeys: 'int', keys: 'List[KeyT]', limit: 'int' = 0) -> 'int | Awaitable[int]'
     |      Return the cardinality of the difference between the first set and all
     |      the successive sets specified by ``keys``, without returning the
     |      difference itself.
     |
     |      When LIMIT is provided (defaults to 0 and means unlimited), the returned
     |      cardinality is capped at ``limit`` and the server may stop the
     |      computation once the capped result is known.
     |
     |      For more information, see https://redis.io/commands/sdiffcard
     |
     |  sdiffstore(self, dest: 'str', keys: 'List', *args: 'List') -> 'int | Awaitable[int]'
     |      Store the difference of sets specified by ``keys`` into a new
     |      set named ``dest``.  Returns the number of keys in the new set.
     |
     |      For more information, see https://redis.io/commands/sdiffstore
     |
     |  sinter(self, keys: 'List', *args: 'List') -> 'set[bytes | str] | Awaitable[set[bytes | str]]'
     |      Return the intersection of sets specified by ``keys``
     |
     |      For more information, see https://redis.io/commands/sinter
     |
     |  sintercard(self, numkeys: 'int', keys: 'List[KeyT]', limit: 'int' = 0) -> 'int | Awaitable[int]'
     |      Return the cardinality of the intersect of multiple sets specified by ``keys``.
     |
     |      When LIMIT provided (defaults to 0 and means unlimited), if the intersection
     |      cardinality reaches limit partway through the computation, the algorithm will
     |      exit and yield limit as the cardinality
     |
     |      For more information, see https://redis.io/commands/sintercard
     |
     |  sinterstore(self, dest: 'KeyT', keys: 'List', *args: 'List') -> 'int | Awaitable[int]'
     |      Store the intersection of sets specified by ``keys`` into a new
     |      set named ``dest``.  Returns the number of keys in the new set.
     |
     |      For more information, see https://redis.io/commands/sinterstore
     |
     |  sismember(self, name: 'KeyT', value: 'str') -> 'Literal[0] | Literal[1] | Awaitable[Literal[0] | Literal[1]]'
     |      Return whether ``value`` is a member of set ``name``:
     |      - 1 if the value is a member of the set.
     |      - 0 if the value is not a member of the set or if key does not exist.
     |
     |      For more information, see https://redis.io/commands/sismember
     |
     |  smembers(self, name: 'KeyT') -> 'set[bytes | str] | Awaitable[set[bytes | str]]'
     |      Return all members of the set ``name``
     |
     |      For more information, see https://redis.io/commands/smembers
     |
     |  smismember(self, name: 'KeyT', values: 'List', *args: 'List') -> 'list[Literal[0] | Literal[1]] | Awaitable[list[Literal[0] | Literal[1]]]'
     |      Return whether each value in ``values`` is a member of the set ``name``
     |      as a list of ``int`` in the order of ``values``:
     |      - 1 if the value is a member of the set.
     |      - 0 if the value is not a member of the set or if key does not exist.
     |
     |      For more information, see https://redis.io/commands/smismember
     |
     |  smove(self, src: 'KeyT', dst: 'KeyT', value: 'str') -> 'bool | Awaitable[bool]'
     |      Move ``value`` from set ``src`` to set ``dst`` atomically
     |
     |      For more information, see https://redis.io/commands/smove
     |
     |  spop(self, name: 'KeyT', count: 'int | None' = None) -> 'bytes | str | set[bytes | str] | None | Awaitable[bytes | str | set[bytes | str] | None]'
     |      Remove and return a random member of set ``name``
     |
     |      For more information, see https://redis.io/commands/spop
     |
     |  srandmember(self, name: 'KeyT', number: 'int | None' = None) -> 'bytes | str | list[bytes | str] | None | Awaitable[bytes | str | list[bytes | str] | None]'
     |      If ``number`` is None, returns a random member of set ``name``.
     |
     |      If ``number`` is supplied, returns a list of ``number`` random
     |      members of set ``name``. Note this is only available when running
     |      Redis 2.6+.
     |
     |      For more information, see https://redis.io/commands/srandmember
     |
     |  srem(self, name: 'KeyT', *values: 'FieldT') -> 'int | Awaitable[int]'
     |      Remove ``values`` from set ``name``
     |
     |      For more information, see https://redis.io/commands/srem
     |
     |  sunion(self, keys: 'List', *args: 'List') -> 'set[bytes | str] | Awaitable[set[bytes | str]]'
     |      Return the union of sets specified by ``keys``
     |
     |      For more information, see https://redis.io/commands/sunion
     |
     |  sunioncard(self, numkeys: 'int', keys: 'List[KeyT]', limit: 'int' = 0, approx: 'bool' = False) -> 'int | Awaitable[int]'
     |      Return the cardinality of the union of multiple sets specified by
     |      ``keys``, without returning the union itself.
     |
     |      When ``approx`` is True, the ``APPROX`` option is sent and the server
     |      returns an approximate cardinality computed using HyperLogLog.
     |
     |      When LIMIT is provided (defaults to 0 and means unlimited), the returned
     |      cardinality is capped at ``limit``. In exact mode the result equals
     |      ``limit`` when the real cardinality exceeds ``limit``; in approximate
     |      mode the result will not exceed ``limit``. Options are emitted in the
     |      canonical order ``APPROX`` before ``LIMIT``.
     |
     |      For more information, see https://redis.io/commands/sunioncard
     |
     |  sunionstore(self, dest: 'KeyT', keys: 'List', *args: 'List') -> 'int | Awaitable[int]'
     |      Store the union of sets specified by ``keys`` into a new
     |      set named ``dest``.  Returns the number of keys in the new set.
     |
     |      For more information, see https://redis.io/commands/sunionstore
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from redis.commands.core.StreamCommands:
     |
     |  xack(self, name: 'KeyT', groupname: 'GroupT', *ids: 'StreamIdT') -> 'int | Awaitable[int]'
     |      Acknowledges the successful processing of one or more messages.
     |
     |      Args:
     |          name: name of the stream.
     |          groupname: name of the consumer group.
     |          *ids: message ids to acknowledge.
     |
     |      For more information, see https://redis.io/commands/xack
     |
     |  xackdel(self, name: 'KeyT', groupname: 'GroupT', *ids: 'StreamIdT', ref_policy: "Literal['KEEPREF', 'DELREF', 'ACKED']" = 'KEEPREF') -> 'int | Awaitable[int]'
     |      Combines the functionality of XACK and XDEL. Acknowledges the specified
     |      message IDs in the given consumer group and simultaneously attempts to
     |      delete the corresponding entries from the stream.
     |
     |  xadd(self, name: 'KeyT', fields: 'Dict[FieldT, EncodableT]', id: 'StreamIdT' = '*', maxlen: 'Optional[int]' = None, approximate: 'bool' = True, nomkstream: 'bool' = False, minid: 'Union[StreamIdT, None]' = None, limit: 'int | None' = None, ref_policy: "Literal['KEEPREF', 'DELREF', 'ACKED'] | None" = None, idmpauto: 'str | None' = None, idmp: 'tuple[str, bytes] | None' = None) -> 'bytes | str | Awaitable[bytes | str]'
     |      Add to a stream.
     |      name: name of the stream
     |      fields: dict of field/value pairs to insert into the stream
     |      id: Location to insert this record. By default it is appended.
     |      maxlen: truncate old stream members beyond this size.
     |      Can't be specified with minid.
     |      approximate: actual stream length may be slightly more than maxlen
     |      nomkstream: When set to true, do not make a stream
     |      minid: the minimum id in the stream to query.
     |      Can't be specified with maxlen.
     |      limit: specifies the maximum number of entries to retrieve
     |      ref_policy: optional reference policy for consumer groups when trimming:
     |          - KEEPREF (default): When trimming, preserves references in consumer groups' PEL
     |          - DELREF: When trimming, removes all references from consumer groups' PEL
     |          - ACKED: When trimming, only removes entries acknowledged by all consumer groups
     |      idmpauto: Producer ID for automatic idempotent ID calculation.
     |          Automatically calculates an idempotent ID based on entry content to prevent
     |          duplicate entries. Can only be used with id='*'. Creates an IDMP map if it
     |          doesn't exist yet. The producer ID must be unique per producer and consistent
     |          across restarts.
     |      idmp: Tuple of (producer_id, idempotent_id) for explicit idempotent ID.
     |          Uses a specific idempotent ID to prevent duplicate entries. Can only be used
     |          with id='*'. The producer ID must be unique per producer and consistent across
     |          restarts. The idempotent ID must be unique per message and per producer.
     |          Shorter idempotent IDs require less memory and allow faster processing.
     |          Creates an IDMP map if it doesn't exist yet.
     |
     |      For more information, see https://redis.io/commands/xadd
     |
     |  xautoclaim(self, name: 'KeyT', groupname: 'GroupT', consumername: 'ConsumerT', min_idle_time: 'int', start_id: 'StreamIdT' = '0-0', count: 'int | None' = None, justid: 'bool' = False) -> 'list[Any] | Awaitable[list[Any]]'
     |      Transfers ownership of pending stream entries that match the specified
     |      criteria. Conceptually, equivalent to calling XPENDING and then XCLAIM,
     |      but provides a more straightforward way to deal with message delivery
     |      failures via SCAN-like semantics.
     |      name: name of the stream.
     |      groupname: name of the consumer group.
     |      consumername: name of a consumer that claims the message.
     |      min_idle_time: filter messages that were idle less than this amount of
     |      milliseconds.
     |      start_id: filter messages with equal or greater ID.
     |      count: optional integer, upper limit of the number of entries that the
     |      command attempts to claim. Set to 100 by default.
     |      justid: optional boolean, false by default. Return just an array of IDs
     |      of messages successfully claimed, without returning the actual message
     |
     |      For more information, see https://redis.io/commands/xautoclaim
     |
     |  xcfgset(self, name: 'KeyT', idmp_duration: 'int | None' = None, idmp_maxsize: 'int | None' = None) -> 'bytes | str | Awaitable[bytes | str]'
     |      Configure the idempotency parameters for a stream's IDMP map.
     |
     |      Sets how long Redis remembers each idempotent ID (iid) and the maximum
     |      number of iids to track. This command clears the existing IDMP map
     |      (Redis forgets all previously stored iids), but only if the configuration
     |      value actually changes.
     |
     |      Args:
     |          name: The name of the stream.
     |          idmp_duration: How long Redis remembers each iid in seconds.
     |              Default: 100 seconds (or value set by stream-idmp-duration config).
     |              Minimum: 1 second, Maximum: 300 seconds.
     |              Redis won't forget an iid for this duration (unless maxsize is reached).
     |              Should accommodate application crash recovery time.
     |          idmp_maxsize: Maximum number of iids Redis remembers per producer ID (pid).
     |              Default: 100 iids (or value set by stream-idmp-maxsize config).
     |              Minimum: 1 iid, Maximum: 1,000,000 (1M) iids.
     |              Should be set to: mark-delay [in msec] × (messages/msec) + margin.
     |              Example: 10K msgs/sec (10 msgs/msec), 80 msec mark-delay
     |              → maxsize = 10 × 80 + margin = 1000 iids.
     |
     |      Returns:
     |          OK on success.
     |
     |      For more information, see https://redis.io/commands/xcfgset
     |
     |  xclaim(self, name: 'KeyT', groupname: 'GroupT', consumername: 'ConsumerT', min_idle_time: 'int', message_ids: 'Union[List[StreamIdT], Tuple[StreamIdT]]', idle: 'int | None' = None, time: 'int | None' = None, retrycount: 'int | None' = None, force: 'bool' = False, justid: 'bool' = False) -> 'XClaimResponse | Awaitable[XClaimResponse]'
     |      Changes the ownership of a pending message.
     |
     |      name: name of the stream.
     |
     |      groupname: name of the consumer group.
     |
     |      consumername: name of a consumer that claims the message.
     |
     |      min_idle_time: filter messages that were idle less than this amount of
     |      milliseconds
     |
     |      message_ids: non-empty list or tuple of message IDs to claim
     |
     |      idle: optional. Set the idle time (last time it was delivered) of the
     |      message in ms
     |
     |      time: optional integer. This is the same as idle but instead of a
     |      relative amount of milliseconds, it sets the idle time to a specific
     |      Unix time (in milliseconds).
     |
     |      retrycount: optional integer. set the retry counter to the specified
     |      value. This counter is incremented every time a message is delivered
     |      again.
     |
     |      force: optional boolean, false by default. Creates the pending message
     |      entry in the PEL even if certain specified IDs are not already in the
     |      PEL assigned to a different client.
     |
     |      justid: optional boolean, false by default. Return just an array of IDs
     |      of messages successfully claimed, without returning the actual message
     |
     |      For more information, see https://redis.io/commands/xclaim
     |
     |  xdel(self, name: 'KeyT', *ids: 'StreamIdT') -> 'int | Awaitable[int]'
     |      Deletes one or more messages from a stream.
     |
     |      Args:
     |          name: name of the stream.
     |          *ids: message ids to delete.
     |
     |      For more information, see https://redis.io/commands/xdel
     |
     |  xdelex(self, name: 'KeyT', *ids: 'StreamIdT', ref_policy: "Literal['KEEPREF', 'DELREF', 'ACKED']" = 'KEEPREF') -> 'int | Awaitable[int]'
     |      Extended version of XDEL that provides more control over how message entries
     |      are deleted concerning consumer groups.
     |
     |  xgroup_create(self, name: 'KeyT', groupname: 'GroupT', id: 'StreamIdT' = '$', mkstream: 'bool' = False, entries_read: 'int | None' = None) -> 'bool | Awaitable[bool]'
     |      Create a new consumer group associated with a stream.
     |      name: name of the stream.
     |      groupname: name of the consumer group.
     |      id: ID of the last item in the stream to consider already delivered.
     |
     |      For more information, see https://redis.io/commands/xgroup-create
     |
     |  xgroup_createconsumer(self, name: 'KeyT', groupname: 'GroupT', consumername: 'ConsumerT') -> 'int | Awaitable[int]'
     |      Consumers in a consumer group are auto-created every time a new
     |      consumer name is mentioned by some command.
     |      They can be explicitly created by using this command.
     |      name: name of the stream.
     |      groupname: name of the consumer group.
     |      consumername: name of consumer to create.
     |
     |      See: https://redis.io/commands/xgroup-createconsumer
     |
     |  xgroup_delconsumer(self, name: 'KeyT', groupname: 'GroupT', consumername: 'ConsumerT') -> 'int | Awaitable[int]'
     |      Remove a specific consumer from a consumer group.
     |      Returns the number of pending messages that the consumer had before it
     |      was deleted.
     |      name: name of the stream.
     |      groupname: name of the consumer group.
     |      consumername: name of consumer to delete
     |
     |      For more information, see https://redis.io/commands/xgroup-delconsumer
     |
     |  xgroup_destroy(self, name: 'KeyT', groupname: 'GroupT') -> 'bool | Awaitable[bool]'
     |      Destroy a consumer group.
     |      name: name of the stream.
     |      groupname: name of the consumer group.
     |
     |      For more information, see https://redis.io/commands/xgroup-destroy
     |
     |  xgroup_setid(self, name: 'KeyT', groupname: 'GroupT', id: 'StreamIdT', entries_read: 'int | None' = None) -> 'bool | Awaitable[bool]'
     |      Set the consumer group last delivered ID to something else.
     |      name: name of the stream.
     |      groupname: name of the consumer group.
     |      id: ID of the last item in the stream to consider already delivered.
     |
     |      For more information, see https://redis.io/commands/xgroup-setid
     |
     |  xinfo_consumers(self, name: 'KeyT', groupname: 'GroupT') -> 'list[dict[str, Any]] | Awaitable[list[dict[str, Any]]]'
     |      Returns general information about the consumers in the group.
     |      name: name of the stream.
     |      groupname: name of the consumer group.
     |
     |      For more information, see https://redis.io/commands/xinfo-consumers
     |
     |  xinfo_groups(self, name: 'KeyT') -> 'list[dict[str, Any]] | Awaitable[list[dict[str, Any]]]'
     |      Returns general information about the consumer groups of the stream.
     |      name: name of the stream.
     |
     |      For more information, see https://redis.io/commands/xinfo-groups
     |
     |  xinfo_stream(self, name: 'KeyT', full: 'bool' = False) -> 'dict[str, Any] | Awaitable[dict[str, Any]]'
     |      Returns general information about the stream.
     |      name: name of the stream.
     |      full: optional boolean, false by default. Return full summary
     |
     |      For more information, see https://redis.io/commands/xinfo-stream
     |
     |  xlen(self, name: 'KeyT') -> 'int | Awaitable[int]'
     |      Returns the number of elements in a given stream.
     |
     |      For more information, see https://redis.io/commands/xlen
     |
     |  xnack(self, name: 'KeyT', groupname: 'GroupT', mode: "Literal['SILENT', 'FAIL', 'FATAL']", *ids: 'StreamIdT', retrycount: 'int | None' = None, force: 'bool' = False) -> 'int | Awaitable[int]'
     |      Negatively acknowledges one or more messages in a consumer group's
     |      Pending Entries List (PEL).
     |
     |      Args:
     |          name: name of the stream.
     |          groupname: name of the consumer group.
     |          mode: the nacking mode. One of SILENT, FAIL, or FATAL.
     |              SILENT: consumer shutting down; decrements delivery counter.
     |              FAIL: consumer unable to process; delivery counter unchanged.
     |              FATAL: invalid/malicious message; delivery counter set to max.
     |          *ids: one or more message IDs to NACK.
     |          retrycount: optional integer >= 0. Overrides the mode's implicit
     |              delivery counter adjustment with an exact value.
     |          force: if True, creates a new unowned PEL entry for any ID not
     |              already in the group's PEL.
     |
     |      Returns:
     |          The number of messages successfully NACKed.
     |
     |      For more information, see https://redis.io/commands/xnack
     |
     |  xpending(self, name: 'KeyT', groupname: 'GroupT') -> 'dict[str, Any] | Awaitable[dict[str, Any]]'
     |      Returns information about pending messages of a group.
     |      name: name of the stream.
     |      groupname: name of the consumer group.
     |
     |      For more information, see https://redis.io/commands/xpending
     |
     |  xpending_range(self, name: 'KeyT', groupname: 'GroupT', min: 'StreamIdT', max: 'StreamIdT', count: 'int', consumername: 'ConsumerT | None' = None, idle: 'int | None' = None) -> 'XPendingRangeResponse | Awaitable[XPendingRangeResponse]'
     |      Returns information about pending messages, in a range.
     |
     |      name: name of the stream.
     |      groupname: name of the consumer group.
     |      idle: available from  version 6.2. filter entries by their
     |      idle-time, given in milliseconds (optional).
     |      min: minimum stream ID.
     |      max: maximum stream ID.
     |      count: number of messages to return
     |      consumername: name of a consumer to filter by (optional).
     |
     |  xrange(self, name: 'KeyT', min: 'StreamIdT' = '-', max: 'StreamIdT' = '+', count: 'int | None' = None) -> 'StreamRangeResponse | None | Awaitable[StreamRangeResponse | None]'
     |      Read stream values within an interval.
     |
     |      name: name of the stream.
     |
     |      start: first stream ID. defaults to '-',
     |             meaning the earliest available.
     |
     |      finish: last stream ID. defaults to '+',
     |              meaning the latest available.
     |
     |      count: if set, only return this many items, beginning with the
     |             earliest available.
     |
     |      For more information, see https://redis.io/commands/xrange
     |
     |  xread(self, streams: 'Dict[KeyT, StreamIdT]', count: 'int | None' = None, block: 'int | None' = None, max_count: 'int | None' = None, max_size: 'int | None' = None) -> 'XReadResponse | Awaitable[XReadResponse]'
     |      Block and monitor multiple streams for new data.
     |
     |      streams: a dict of stream names to stream IDs, where
     |                 IDs indicate the last ID already seen.
     |
     |      count: if set, only return this many items per stream, beginning with
     |             the earliest available.
     |
     |      block: number of milliseconds to wait, if nothing already present.
     |
     |      max_count: if set, cap the total number of entries returned across all
     |                 streams combined. Unlike ``count`` (a per-stream limit),
     |                 this is a cumulative cap over the whole reply. Must be a
     |                 positive integer and, when ``count`` is also set, must be
     |                 greater than or equal to ``count``. Requires Redis >= 8.10.0.
     |
     |      max_size: if set, a soft cap on the total server reply size in bytes
     |                across all streams combined. Measured server-side including
     |                protocol overhead, so it is not an exact application-payload
     |                size guarantee; a single available entry larger than the cap
     |                may still be returned. Must be a positive integer. Requires
     |                Redis >= 8.10.0.
     |
     |      For more information, see https://redis.io/commands/xread
     |
     |  xreadgroup(self, groupname: 'str', consumername: 'str', streams: 'Dict[KeyT, StreamIdT]', count: 'int | None' = None, block: 'int | None' = None, noack: 'bool' = False, claim_min_idle_time: 'int | None' = None, max_count: 'int | None' = None, max_size: 'int | None' = None) -> 'XReadGroupResponse | Awaitable[XReadGroupResponse]'
     |      Read from a stream via a consumer group.
     |
     |      groupname: name of the consumer group.
     |
     |      consumername: name of the requesting consumer.
     |
     |      streams: a dict of stream names to stream IDs, where
     |             IDs indicate the last ID already seen.
     |
     |      count: if set, only return this many items per stream, beginning with
     |             the earliest available.
     |
     |      block: number of milliseconds to wait, if nothing already present.
     |      noack: do not add messages to the PEL
     |
     |      claim_min_idle_time: accepts an integer type and represents a
     |                           time interval in milliseconds
     |
     |      max_count: if set, cap the total number of entries returned across all
     |                 streams combined. Unlike ``count`` (a per-stream limit),
     |                 this is a cumulative cap over the whole reply. Must be a
     |                 positive integer and, when ``count`` is also set, must be
     |                 greater than or equal to ``count``. Requires Redis 8.10.0.
     |
     |      max_size: if set, a soft cap on the total server reply size in bytes
     |                across all streams combined. Measured server-side including
     |                protocol overhead, so it is not an exact application-payload
     |                size guarantee; a single available entry larger than the cap
     |                may still be returned. Must be a positive integer. Requires
     |                Redis 8.10.0.
     |
     |      For more information, see https://redis.io/commands/xreadgroup
     |
     |  xrevrange(self, name: 'KeyT', max: 'StreamIdT' = '+', min: 'StreamIdT' = '-', count: 'int | None' = None) -> 'StreamRangeResponse | None | Awaitable[StreamRangeResponse | None]'
     |      Read stream values within an interval, in reverse order.
     |
     |      name: name of the stream
     |
     |      start: first stream ID. defaults to '+',
     |             meaning the latest available.
     |
     |      finish: last stream ID. defaults to '-',
     |              meaning the earliest available.
     |
     |      count: if set, only return this many items, beginning with the
     |             latest available.
     |
     |      For more information, see https://redis.io/commands/xrevrange
     |
     |  xtrim(self, name: 'KeyT', maxlen: 'int | None' = None, approximate: 'bool' = True, minid: 'StreamIdT | None' = None, limit: 'int | None' = None, ref_policy: "Literal['KEEPREF', 'DELREF', 'ACKED'] | None" = None) -> 'int | Awaitable[int]'
     |      Trims old messages from a stream.
     |      name: name of the stream.
     |      maxlen: truncate old stream messages beyond this size
     |      Can't be specified with minid.
     |      approximate: actual stream length may be slightly more than maxlen
     |      minid: the minimum id in the stream to query
     |      Can't be specified with maxlen.
     |      limit: specifies the maximum number of entries to retrieve
     |      ref_policy: optional reference policy for consumer groups:
     |          - KEEPREF (default): Trims entries but preserves references in consumer groups' PEL
     |          - DELREF: Trims entries and removes all references from consumer groups' PEL
     |          - ACKED: Only trims entries that were read and acknowledged by all consumer groups
     |
     |      For more information, see https://redis.io/commands/xtrim
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from redis.commands.core.SortedSetCommands:
     |
     |  bzmpop(self, timeout: 'float', numkeys: 'int', keys: 'List[str]', min: 'bool | None' = False, max: 'bool | None' = False, count: 'int | None' = 1) -> 'ZMPopResponse | Awaitable[ZMPopResponse]'
     |      Pop ``count`` values (default 1) off of the first non-empty sorted set
     |      named in the ``keys`` list.
     |
     |      If none of the sorted sets in ``keys`` has a value to pop,
     |      then block for ``timeout`` seconds, or until a member gets added
     |      to one of the sorted sets.
     |
     |      If timeout is 0, then block indefinitely.
     |
     |      For more information, see https://redis.io/commands/bzmpop
     |
     |  bzpopmax(self, keys: 'KeysT', timeout: 'TimeoutSecT' = 0) -> 'BlockingZSetPopResponse | Awaitable[BlockingZSetPopResponse]'
     |      ZPOPMAX a value off of the first non-empty sorted set
     |      named in the ``keys`` list.
     |
     |      If none of the sorted sets in ``keys`` has a value to ZPOPMAX,
     |      then block for ``timeout`` seconds, or until a member gets added
     |      to one of the sorted sets.
     |
     |      If timeout is 0, then block indefinitely.
     |
     |      For more information, see https://redis.io/commands/bzpopmax
     |
     |  bzpopmin(self, keys: 'KeysT', timeout: 'TimeoutSecT' = 0) -> 'BlockingZSetPopResponse | Awaitable[BlockingZSetPopResponse]'
     |      ZPOPMIN a value off of the first non-empty sorted set
     |      named in the ``keys`` list.
     |
     |      If none of the sorted sets in ``keys`` has a value to ZPOPMIN,
     |      then block for ``timeout`` seconds, or until a member gets added
     |      to one of the sorted sets.
     |
     |      If timeout is 0, then block indefinitely.
     |
     |      For more information, see https://redis.io/commands/bzpopmin
     |
     |  zadd(self, name: 'KeyT', mapping: 'Mapping[AnyKeyT, EncodableT]', nx: 'bool' = False, xx: 'bool' = False, ch: 'bool' = False, incr: 'bool' = False, gt: 'bool' = False, lt: 'bool' = False) -> 'int | float | None | Awaitable[int | float | None]'
     |      Set any number of element-name, score pairs to the key ``name``. Pairs
     |      are specified as a dict of element-names keys to score values.
     |
     |      ``nx`` forces ZADD to only create new elements and not to update
     |      scores for elements that already exist.
     |
     |      ``xx`` forces ZADD to only update scores of elements that already
     |      exist. New elements will not be added.
     |
     |      ``ch`` modifies the return value to be the numbers of elements changed.
     |      Changed elements include new elements that were added and elements
     |      whose scores changed.
     |
     |      ``incr`` modifies ZADD to behave like ZINCRBY. In this mode only a
     |      single element/score pair can be specified and the score is the amount
     |      the existing score will be incremented by. When using this mode the
     |      return value of ZADD will be the new score of the element.
     |
     |      ``lt`` only updates existing elements if the new score is less than
     |      the current score. This flag doesn't prevent adding new elements.
     |
     |      ``gt`` only updates existing elements if the new score is greater than
     |      the current score. This flag doesn't prevent adding new elements.
     |
     |      The return value of ZADD varies based on the mode specified. With no
     |      options, ZADD returns the number of new elements added to the sorted
     |      set.
     |
     |      ``nx``, ``lt``, and ``gt`` are mutually exclusive options.
     |
     |      See: https://redis.io/commands/ZADD
     |
     |  zcard(self, name: 'KeyT') -> 'int | Awaitable[int]'
     |      Return the number of elements in the sorted set ``name``
     |
     |      For more information, see https://redis.io/commands/zcard
     |
     |  zcount(self, name: 'KeyT', min: 'ZScoreBoundT', max: 'ZScoreBoundT') -> 'int | Awaitable[int]'
     |      Returns the number of elements in the sorted set at key ``name`` with
     |      a score between ``min`` and ``max``.
     |
     |      For more information, see https://redis.io/commands/zcount
     |
     |  zdiff(self, keys: 'KeysT', withscores: 'bool' = False) -> 'ZSetRangeResponse | Awaitable[ZSetRangeResponse]'
     |      Returns the difference between the first and all successive input
     |      sorted sets provided in ``keys``.
     |
     |      For more information, see https://redis.io/commands/zdiff
     |
     |  zdiffstore(self, dest: 'KeyT', keys: 'KeysT') -> 'int | Awaitable[int]'
     |      Computes the difference between the first and all successive input
     |      sorted sets provided in ``keys`` and stores the result in ``dest``.
     |
     |      For more information, see https://redis.io/commands/zdiffstore
     |
     |  zincrby(self, name: 'KeyT', amount: 'float', value: 'EncodableT') -> 'float | None | Awaitable[float | None]'
     |      Increment the score of ``value`` in sorted set ``name`` by ``amount``
     |
     |      For more information, see https://redis.io/commands/zincrby
     |
     |  zinter(self, keys: 'KeysT', aggregate: 'str | None' = None, withscores: 'bool' = False) -> 'ZSetRangeResponse | Awaitable[ZSetRangeResponse]'
     |      Return the intersect of multiple sorted sets specified by ``keys``.
     |
     |      With the ``aggregate`` option, it is possible to specify how the
     |      results of the intersection are aggregated. Available aggregation
     |      modes:
     |
     |      - ``SUM`` (default): the score of an element is summed across the
     |        inputs where it exists.
     |        Score = SUM(score₁×weight₁, score₂×weight₂, ...)
     |      - ``MIN``: the resulting set will contain the minimum score of an
     |        element across the inputs where it exists.
     |        Score = MIN(score₁×weight₁, score₂×weight₂, ...)
     |      - ``MAX``: the resulting set will contain the maximum score of an
     |        element across the inputs where it exists.
     |        Score = MAX(score₁×weight₁, score₂×weight₂, ...)
     |      - ``COUNT``: ignores the original scores and counts weighted set
     |        membership. Each element's score is the sum of the weights of
     |        the input sets that contain it.
     |        Score = SUM(weight₁, weight₂, ...) for sets containing the element.
     |        When all weights are 1 (default), the score equals the number
     |        of input sets containing the element.
     |
     |      For more information, see https://redis.io/commands/zinter
     |
     |  zintercard(self, numkeys: 'int', keys: 'List[str]', limit: 'int' = 0) -> 'int | Awaitable[int]'
     |      Return the cardinality of the intersect of multiple sorted sets
     |      specified by ``keys``.
     |      When LIMIT provided (defaults to 0 and means unlimited), if the intersection
     |      cardinality reaches limit partway through the computation, the algorithm will
     |      exit and yield limit as the cardinality
     |
     |      For more information, see https://redis.io/commands/zintercard
     |
     |  zinterstore(self, dest: 'KeyT', keys: 'Sequence[KeyT] | Mapping[AnyKeyT, float]', aggregate: 'str | None' = None) -> 'int | Awaitable[int]'
     |      Intersect multiple sorted sets specified by ``keys`` into a new
     |      sorted set, ``dest``. Scores in the destination will be aggregated
     |      based on the ``aggregate``.
     |
     |      Available aggregation modes:
     |
     |      - ``SUM`` (default): the score of an element is summed across the
     |        inputs where it exists.
     |        Score = SUM(score₁×weight₁, score₂×weight₂, ...)
     |      - ``MIN``: the resulting set will contain the minimum score of an
     |        element across the inputs where it exists.
     |        Score = MIN(score₁×weight₁, score₂×weight₂, ...)
     |      - ``MAX``: the resulting set will contain the maximum score of an
     |        element across the inputs where it exists.
     |        Score = MAX(score₁×weight₁, score₂×weight₂, ...)
     |      - ``COUNT``: ignores the original scores and counts weighted set
     |        membership. Each element's score is the sum of the weights of
     |        the input sets that contain it.
     |        Score = SUM(weight₁, weight₂, ...) for sets containing the element.
     |        When all weights are 1 (default), the score equals the number
     |        of input sets containing the element.
     |
     |      For more information, see https://redis.io/commands/zinterstore
     |
     |  zlexcount(self, name: 'KeyT', min: 'EncodableT', max: 'EncodableT') -> 'int | Awaitable[int]'
     |      Return the number of items in the sorted set ``name`` between the
     |      lexicographical range ``min`` and ``max``.
     |
     |      For more information, see https://redis.io/commands/zlexcount
     |
     |  zmpop(self, num_keys: 'int', keys: 'List[str]', min: 'bool | None' = False, max: 'bool | None' = False, count: 'int | None' = 1) -> 'ZMPopResponse | Awaitable[ZMPopResponse]'
     |      Pop ``count`` values (default 1) off of the first non-empty sorted set
     |      named in the ``keys`` list.
     |      For more information, see https://redis.io/commands/zmpop
     |
     |  zmscore(self, key: 'KeyT', members: 'List[str]') -> 'list[float | None] | Awaitable[list[float | None]]'
     |      Returns the scores associated with the specified members
     |      in the sorted set stored at key.
     |      ``members`` should be a list of the member name.
     |      Return type is a list of score.
     |      If the member does not exist, a None will be returned
     |      in corresponding position.
     |
     |      For more information, see https://redis.io/commands/zmscore
     |
     |  zpopmax(self, name: 'KeyT', count: 'int | None' = None) -> 'ZSetRangeResponse | Awaitable[ZSetRangeResponse]'
     |      Remove and return up to ``count`` members with the highest scores
     |      from the sorted set ``name``.
     |
     |      For more information, see https://redis.io/commands/zpopmax
     |
     |  zpopmin(self, name: 'KeyT', count: 'int | None' = None) -> 'ZSetRangeResponse | Awaitable[ZSetRangeResponse]'
     |      Remove and return up to ``count`` members with the lowest scores
     |      from the sorted set ``name``.
     |
     |      For more information, see https://redis.io/commands/zpopmin
     |
     |  zrandmember(self, key: 'KeyT', count: 'int | None' = None, withscores: 'bool' = False) -> 'ZRandMemberResponse | Awaitable[ZRandMemberResponse]'
     |      Return a random element from the sorted set value stored at key.
     |
     |      ``count`` if the argument is positive, return an array of distinct
     |      fields. If called with a negative count, the behavior changes and
     |      the command is allowed to return the same field multiple times.
     |      In this case, the number of returned fields is the absolute value
     |      of the specified count.
     |
     |      ``withscores`` The optional WITHSCORES modifier changes the reply so it
     |      includes the respective scores of the randomly selected elements from
     |      the sorted set.
     |
     |      For more information, see https://redis.io/commands/zrandmember
     |
     |  zrange(self, name: 'KeyT', start: 'EncodableT', end: 'EncodableT', desc: 'bool' = False, withscores: 'bool' = False, score_cast_func: 'type | Callable' = <class 'float'>, byscore: 'bool' = False, bylex: 'bool' = False, offset: 'int | None' = None, num: 'int | None' = None) -> 'ZSetRangeResponse | Awaitable[ZSetRangeResponse]'
     |      Return a range of values from sorted set ``name`` between
     |      ``start`` and ``end`` sorted in ascending order.
     |
     |      ``start`` and ``end`` can be negative, indicating the end of the range.
     |
     |      ``desc`` a boolean indicating whether to sort the results in reversed
     |      order.
     |
     |      ``withscores`` indicates to return the scores along with the values.
     |      The return type is a list of (value, score) pairs.
     |
     |      ``score_cast_func`` a callable used to cast the score return value.
     |
     |      ``byscore`` when set to True, returns the range of elements from the
     |      sorted set having scores equal or between ``start`` and ``end``.
     |
     |      ``bylex`` when set to True, returns the range of elements from the
     |      sorted set between the ``start`` and ``end`` lexicographical closed
     |      range intervals.
     |      Valid ``start`` and ``end`` must start with ( or [, in order to specify
     |      whether the range interval is exclusive or inclusive, respectively.
     |
     |      ``offset`` and ``num`` are specified, then return a slice of the range.
     |      Can't be provided when using ``bylex``.
     |
     |      For more information, see https://redis.io/commands/zrange
     |
     |  zrangebylex(self, name: 'KeyT', min: 'EncodableT', max: 'EncodableT', start: 'int | None' = None, num: 'int | None' = None) -> 'list[bytes | str] | Awaitable[list[bytes | str]]'
     |      Return the lexicographical range of values from sorted set ``name``
     |      between ``min`` and ``max``.
     |
     |      If ``start`` and ``num`` are specified, then return a slice of the
     |      range.
     |
     |      For more information, see https://redis.io/commands/zrangebylex
     |
     |  zrangebyscore(self, name: 'KeyT', min: 'ZScoreBoundT', max: 'ZScoreBoundT', start: 'int | None' = None, num: 'int | None' = None, withscores: 'bool' = False, score_cast_func: 'type | Callable' = <class 'float'>) -> 'ZSetRangeResponse | Awaitable[ZSetRangeResponse]'
     |      Return a range of values from the sorted set ``name`` with scores
     |      between ``min`` and ``max``.
     |
     |      If ``start`` and ``num`` are specified, then return a slice
     |      of the range.
     |
     |      ``withscores`` indicates to return the scores along with the values.
     |      The return type is a list of (value, score) pairs
     |
     |      `score_cast_func`` a callable used to cast the score return value
     |
     |      For more information, see https://redis.io/commands/zrangebyscore
     |
     |  zrangestore(self, dest: 'KeyT', name: 'KeyT', start: 'EncodableT', end: 'EncodableT', byscore: 'bool' = False, bylex: 'bool' = False, desc: 'bool' = False, offset: 'int | None' = None, num: 'int | None' = None) -> 'int | Awaitable[int]'
     |      Stores in ``dest`` the result of a range of values from sorted set
     |      ``name`` between ``start`` and ``end`` sorted in ascending order.
     |
     |      ``start`` and ``end`` can be negative, indicating the end of the range.
     |
     |      ``byscore`` when set to True, returns the range of elements from the
     |      sorted set having scores equal or between ``start`` and ``end``.
     |
     |      ``bylex`` when set to True, returns the range of elements from the
     |      sorted set between the ``start`` and ``end`` lexicographical closed
     |      range intervals.
     |      Valid ``start`` and ``end`` must start with ( or [, in order to specify
     |      whether the range interval is exclusive or inclusive, respectively.
     |
     |      ``desc`` a boolean indicating whether to sort the results in reversed
     |      order.
     |
     |      ``offset`` and ``num`` are specified, then return a slice of the range.
     |      Can't be provided when using ``bylex``.
     |
     |      For more information, see https://redis.io/commands/zrangestore
     |
     |  zrank(self, name: 'KeyT', value: 'EncodableT', withscore: 'bool' = False, score_cast_func: 'type | Callable' = <class 'float'>) -> 'int | list[Any] | None | Awaitable[int | list[Any] | None]'
     |      Returns a 0-based value indicating the rank of ``value`` in sorted set
     |      ``name``.
     |      The optional WITHSCORE argument supplements the command's
     |      reply with the score of the element returned.
     |
     |      ``score_cast_func`` a callable used to cast the score return value
     |
     |      For more information, see https://redis.io/commands/zrank
     |
     |  zrem(self, name: 'KeyT', *values: 'FieldT') -> 'int | Awaitable[int]'
     |      Remove member ``values`` from sorted set ``name``
     |
     |      For more information, see https://redis.io/commands/zrem
     |
     |  zremrangebylex(self, name: 'KeyT', min: 'EncodableT', max: 'EncodableT') -> 'int | Awaitable[int]'
     |      Remove all elements in the sorted set ``name`` between the
     |      lexicographical range specified by ``min`` and ``max``.
     |
     |      Returns the number of elements removed.
     |
     |      For more information, see https://redis.io/commands/zremrangebylex
     |
     |  zremrangebyrank(self, name: 'KeyT', min: 'int', max: 'int') -> 'int | Awaitable[int]'
     |      Remove all elements in the sorted set ``name`` with ranks between
     |      ``min`` and ``max``. Values are 0-based, ordered from smallest score
     |      to largest. Values can be negative indicating the highest scores.
     |      Returns the number of elements removed
     |
     |      For more information, see https://redis.io/commands/zremrangebyrank
     |
     |  zremrangebyscore(self, name: 'KeyT', min: 'ZScoreBoundT', max: 'ZScoreBoundT') -> 'int | Awaitable[int]'
     |      Remove all elements in the sorted set ``name`` with scores
     |      between ``min`` and ``max``. Returns the number of elements removed.
     |
     |      For more information, see https://redis.io/commands/zremrangebyscore
     |
     |  zrevrange(self, name: 'KeyT', start: 'int', end: 'int', withscores: 'bool' = False, score_cast_func: 'type | Callable' = <class 'float'>) -> 'ZSetRangeResponse | Awaitable[ZSetRangeResponse]'
     |      Return a range of values from sorted set ``name`` between
     |      ``start`` and ``end`` sorted in descending order.
     |
     |      ``start`` and ``end`` can be negative, indicating the end of the range.
     |
     |      ``withscores`` indicates to return the scores along with the values
     |      The return type is a list of (value, score) pairs
     |
     |      ``score_cast_func`` a callable used to cast the score return value
     |
     |      For more information, see https://redis.io/commands/zrevrange
     |
     |  zrevrangebylex(self, name: 'KeyT', max: 'EncodableT', min: 'EncodableT', start: 'int | None' = None, num: 'int | None' = None) -> 'list[bytes | str] | Awaitable[list[bytes | str]]'
     |      Return the reversed lexicographical range of values from sorted set
     |      ``name`` between ``max`` and ``min``.
     |
     |      If ``start`` and ``num`` are specified, then return a slice of the
     |      range.
     |
     |      For more information, see https://redis.io/commands/zrevrangebylex
     |
     |  zrevrangebyscore(self, name: 'KeyT', max: 'ZScoreBoundT', min: 'ZScoreBoundT', start: 'int | None' = None, num: 'int | None' = None, withscores: 'bool' = False, score_cast_func: 'type | Callable' = <class 'float'>) -> 'ZSetRangeResponse | Awaitable[ZSetRangeResponse]'
     |      Return a range of values from the sorted set ``name`` with scores
     |      between ``min`` and ``max`` in descending order.
     |
     |      If ``start`` and ``num`` are specified, then return a slice
     |      of the range.
     |
     |      ``withscores`` indicates to return the scores along with the values.
     |      The return type is a list of (value, score) pairs
     |
     |      ``score_cast_func`` a callable used to cast the score return value
     |
     |      For more information, see https://redis.io/commands/zrevrangebyscore
     |
     |  zrevrank(self, name: 'KeyT', value: 'EncodableT', withscore: 'bool' = False, score_cast_func: 'type | Callable' = <class 'float'>) -> 'int | list[Any] | None | Awaitable[int | list[Any] | None]'
     |      Returns a 0-based value indicating the descending rank of
     |      ``value`` in sorted set ``name``.
     |      The optional ``withscore`` argument supplements the command's
     |      reply with the score of the element returned.
     |
     |      ``score_cast_func`` a callable used to cast the score return value
     |
     |      For more information, see https://redis.io/commands/zrevrank
     |
     |  zscore(self, name: 'KeyT', value: 'EncodableT') -> 'float | None | Awaitable[float | None]'
     |      Return the score of element ``value`` in sorted set ``name``
     |
     |      For more information, see https://redis.io/commands/zscore
     |
     |  zunion(self, keys: 'Sequence[KeyT] | Mapping[AnyKeyT, float]', aggregate: 'str | None' = None, withscores: 'bool' = False, score_cast_func: 'type | Callable' = <class 'float'>) -> 'ZSetRangeResponse | Awaitable[ZSetRangeResponse]'
     |      Return the union of multiple sorted sets specified by ``keys``.
     |      ``keys`` can be provided as dictionary of keys and their weights.
     |      Scores will be aggregated based on the ``aggregate``, or SUM if
     |      none is provided.
     |
     |      Available aggregation modes:
     |
     |      - ``SUM`` (default): the score of an element is summed across the
     |        inputs where it exists.
     |        Score = SUM(score₁×weight₁, score₂×weight₂, ...)
     |      - ``MIN``: the resulting set will contain the minimum score of an
     |        element across the inputs where it exists.
     |        Score = MIN(score₁×weight₁, score₂×weight₂, ...)
     |      - ``MAX``: the resulting set will contain the maximum score of an
     |        element across the inputs where it exists.
     |        Score = MAX(score₁×weight₁, score₂×weight₂, ...)
     |      - ``COUNT``: ignores the original scores and counts weighted set
     |        membership. Each element's score is the sum of the weights of
     |        the input sets that contain it.
     |        Score = SUM(weight₁, weight₂, ...) for sets containing the element.
     |        When all weights are 1 (default), the score equals the number
     |        of input sets containing the element.
     |
     |      ``score_cast_func`` a callable used to cast the score return value
     |
     |      For more information, see https://redis.io/commands/zunion
     |
     |  zunionstore(self, dest: 'KeyT', keys: 'Sequence[KeyT] | Mapping[AnyKeyT, float]', aggregate: 'str | None' = None) -> 'int | Awaitable[int]'
     |      Union multiple sorted sets specified by ``keys`` into
     |      a new sorted set, ``dest``. Scores in the destination will be
     |      aggregated based on the ``aggregate``, or SUM if none is provided.
     |
     |      Available aggregation modes:
     |
     |      - ``SUM`` (default): the score of an element is summed across the
     |        inputs where it exists.
     |        Score = SUM(score₁×weight₁, score₂×weight₂, ...)
     |      - ``MIN``: the resulting set will contain the minimum score of an
     |        element across the inputs where it exists.
     |        Score = MIN(score₁×weight₁, score₂×weight₂, ...)
     |      - ``MAX``: the resulting set will contain the maximum score of an
     |        element across the inputs where it exists.
     |        Score = MAX(score₁×weight₁, score₂×weight₂, ...)
     |      - ``COUNT``: ignores the original scores and counts weighted set
     |        membership. Each element's score is the sum of the weights of
     |        the input sets that contain it.
     |        Score = SUM(weight₁, weight₂, ...) for sets containing the element.
     |        When all weights are 1 (default), the score equals the number
     |        of input sets containing the element.
     |
     |      For more information, see https://redis.io/commands/zunionstore
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from redis.commands.core.ScriptCommands:
     |
     |  eval(self, script: 'str', numkeys: 'int', *keys_and_args: 'KeyT | EncodableT') -> 'Any | Awaitable[Any]'
     |      Execute the Lua ``script``, specifying the ``numkeys`` the script
     |      will touch and the key names and argument values in ``keys_and_args``.
     |      Returns the result of the script.
     |
     |      In practice, use the object returned by ``register_script``. This
     |      function exists purely for Redis API completion.
     |
     |      For more information, see  https://redis.io/commands/eval
     |
     |  eval_ro(self, script: 'str', numkeys: 'int', *keys_and_args: 'KeyT | EncodableT') -> 'Any | Awaitable[Any]'
     |      The read-only variant of the EVAL command
     |
     |      Execute the read-only Lua ``script`` specifying the ``numkeys`` the script
     |      will touch and the key names and argument values in ``keys_and_args``.
     |      Returns the result of the script.
     |
     |      For more information, see  https://redis.io/commands/eval_ro
     |
     |  evalsha(self, sha: 'str', numkeys: 'int', *keys_and_args: 'KeyT | EncodableT') -> 'Any | Awaitable[Any]'
     |      Use the ``sha`` to execute a Lua script already registered via EVAL
     |      or SCRIPT LOAD. Specify the ``numkeys`` the script will touch and the
     |      key names and argument values in ``keys_and_args``. Returns the result
     |      of the script.
     |
     |      In practice, use the object returned by ``register_script``. This
     |      function exists purely for Redis API completion.
     |
     |      For more information, see  https://redis.io/commands/evalsha
     |
     |  evalsha_ro(self, sha: 'str', numkeys: 'int', *keys_and_args: 'KeyT | EncodableT') -> 'Any | Awaitable[Any]'
     |      The read-only variant of the EVALSHA command
     |
     |      Use the ``sha`` to execute a read-only Lua script already registered via EVAL
     |      or SCRIPT LOAD. Specify the ``numkeys`` the script will touch and the
     |      key names and argument values in ``keys_and_args``. Returns the result
     |      of the script.
     |
     |      For more information, see  https://redis.io/commands/evalsha_ro
     |
     |  register_script(self: "Union['redis.client.Redis', 'redis.cluster.RedisCluster']", script: 'ScriptTextT') -> 'Script'
     |      Register a Lua ``script`` specifying the ``keys`` it will touch.
     |      Returns a Script object that is callable and hides the complexity of
     |      deal with scripts, keys, and shas. This is the preferred way to work
     |      with Lua scripts.
     |
     |  script_debug(self, *args) -> 'None'
     |
     |  script_exists(self, *args: 'str') -> 'list[bool] | Awaitable[list[bool]]'
     |      Check if a script exists in the script cache by specifying the SHAs of
     |      each script as ``args``. Returns a list of boolean values indicating if
     |      if each already script exists in the cache_data.
     |
     |      For more information, see  https://redis.io/commands/script-exists
     |
     |  script_flush(self, sync_type: "Literal['SYNC'] | Literal['ASYNC'] | None" = None) -> 'bool | Awaitable[bool]'
     |      Flush all scripts from the script cache_data.
     |
     |      ``sync_type`` is by default SYNC (synchronous) but it can also be
     |                    ASYNC.
     |
     |      For more information, see  https://redis.io/commands/script-flush
     |
     |  script_kill(self) -> 'bool | Awaitable[bool]'
     |      Kill the currently executing Lua script
     |
     |      For more information, see https://redis.io/commands/script-kill
     |
     |  script_load(self, script: 'ScriptTextT') -> 'str | Awaitable[str]'
     |      Load a Lua ``script`` into the script cache_data. Returns the SHA.
     |
     |      For more information, see https://redis.io/commands/script-load
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from redis.commands.core.FunctionCommands:
     |
     |  fcall(self, function, numkeys: 'int', *keys_and_args: 'Any') -> 'Any | Awaitable[Any]'
     |      Invoke a function.
     |
     |      For more information, see https://redis.io/commands/fcall
     |
     |  fcall_ro(self, function, numkeys: 'int', *keys_and_args: 'Any') -> 'Any | Awaitable[Any]'
     |      This is a read-only variant of the FCALL command that cannot
     |      execute commands that modify data.
     |
     |      For more information, see https://redis.io/commands/fcall_ro
     |
     |  function_delete(self, library: 'str') -> 'bool | Awaitable[bool]'
     |      Delete the library called ``library`` and all its functions.
     |
     |      For more information, see https://redis.io/commands/function-delete
     |
     |  function_dump(self) -> 'bytes | Awaitable[bytes]'
     |      Return the serialized payload of loaded libraries.
     |
     |      For more information, see https://redis.io/commands/function-dump
     |
     |  function_flush(self, mode: 'str' = 'SYNC') -> 'bool | Awaitable[bool]'
     |      Deletes all the libraries.
     |
     |      For more information, see https://redis.io/commands/function-flush
     |
     |  function_kill(self) -> 'bytes | str | Awaitable[bytes | str]'
     |      Kill a function that is currently executing.
     |
     |      For more information, see https://redis.io/commands/function-kill
     |
     |  function_list(self, library: 'str | None' = '*', withcode: 'bool | None' = False) -> 'list[Any] | Awaitable[list[Any]]'
     |      Return information about the functions and libraries.
     |
     |      Args:
     |
     |          library: specify a pattern for matching library names
     |          withcode: cause the server to include the libraries source implementation
     |              in the reply
     |
     |  function_load(self, code: 'str', replace: 'bool | None' = False) -> 'bytes | str | Awaitable[bytes | str]'
     |      Load a library to Redis.
     |      :param code: the source code (must start with
     |      Shebang statement that provides a metadata about the library)
     |      :param replace: changes the behavior to overwrite the existing library
     |      with the new contents.
     |      Return the library name that was loaded.
     |
     |      For more information, see https://redis.io/commands/function-load
     |
     |  function_restore(self, payload: 'str', policy: 'str | None' = 'APPEND') -> 'bool | Awaitable[bool]'
     |      Restore libraries from the serialized ``payload``.
     |      You can use the optional policy argument to provide a policy
     |      for handling existing libraries.
     |
     |      For more information, see https://redis.io/commands/function-restore
     |
     |  function_stats(self) -> 'Any | Awaitable[Any]'
     |      Return information about the function that's currently running
     |      and information about the available execution engines.
     |
     |      For more information, see https://redis.io/commands/function-stats
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors inherited from redis.commands.core.FunctionCommands:
     |
     |  __dict__
     |      dictionary for instance variables
     |
     |  __weakref__
     |      list of weak references to the object
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from redis.commands.core.ModuleCommands:
     |
     |  command_getkeys(self, *args) -> 'list[bytes | str] | Awaitable[list[bytes | str]]'
     |
     |  module_list(self) -> 'list[dict[Any, Any]] | Awaitable[list[dict[Any, Any]]]'
     |      Returns a list of dictionaries containing the name and version of
     |      all loaded modules.
     |
     |      For more information, see https://redis.io/commands/module-list
     |
     |  module_load(self, path, *args) -> 'bool | Awaitable[bool]'
     |      Loads the module from ``path``.
     |      Passes all ``*args`` to the module, during loading.
     |      Raises ``ModuleError`` if a module is not found at ``path``.
     |
     |      For more information, see https://redis.io/commands/module-load
     |
     |  module_loadex(self, path: 'str', options: 'List[str] | None' = None, args: 'List[str] | None' = None) -> 'bytes | str | Awaitable[bytes | str]'
     |      Loads a module from a dynamic library at runtime with configuration directives.
     |
     |      For more information, see https://redis.io/commands/module-loadex
     |
     |  module_unload(self, name) -> 'bool | Awaitable[bool]'
     |      Unloads the module ``name``.
     |      Raises ``ModuleError`` if ``name`` is not in loaded modules.
     |
     |      For more information, see https://redis.io/commands/module-unload
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from redis.typing.CommandsProtocol:
     |
     |  __init__ = _no_init_or_replace_init(self, *args, **kwargs) from typing
     |
     |  execute_command(self, *args, **options) -> Union[Awaitable[Any], Any]
     |
     |  ----------------------------------------------------------------------
     |  Data and other attributes inherited from redis.typing.CommandsProtocol:
     |
     |  __protocol_attrs__ = {'_event_dispatcher', 'execute_command'}
     |
     |  ----------------------------------------------------------------------
     |  Class methods inherited from typing.Protocol:
     |
     |  __init_subclass__(*args, **kwargs)
     |      This method is called when a class is subclassed.
     |
     |      The default implementation does nothing. It may be
     |      overridden to extend subclasses.
     |
     |  ----------------------------------------------------------------------
     |  Class methods inherited from typing.Generic:
     |
     |  __class_getitem__(...)
     |      Parameterizes a generic class.
     |
     |      At least, parameterizing a generic class is the *main* thing this
     |      method does. For example, for some generic class `Foo`, this is called
     |      when we do `Foo[int]` - there, with `cls=Foo` and `params=int`.
     |
     |      However, note that this method is also called when defining generic
     |      classes in the first place with `class Foo[T]: ...`.
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from redis.commands.redismodules.RedisModuleCommands:
     |
     |  bf(self) -> 'BFBloom'
     |      Access the bloom namespace.
     |
     |  cf(self) -> 'CFBloom'
     |      Access the bloom namespace.
     |
     |  cms(self) -> 'CMSBloom'
     |      Access the bloom namespace.
     |
     |  ft(self, index_name='idx') -> 'Search'
     |      Access the search namespace, providing support for redis search.
     |
     |  json(self, encoder=<json.encoder.JSONEncoder object at 0x0000017B9C588F50>, decoder=<json.decoder.JSONDecoder object at 0x0000017B9C588FB0>) -> 'JSON'
     |      Access the json namespace, providing support for redis json.
     |
     |  tdigest(self) -> 'TDigestBloom'
     |      Access the bloom namespace.
     |
     |  topk(self) -> 'TOPKBloom'
     |      Access the bloom namespace.
     |
     |  ts(self) -> 'TimeSeries'
     |      Access the timeseries namespace, providing support for
     |      redis timeseries data.
     |
     |  vset(self) -> 'VectorSet'
     |      Access the VectorSet commands namespace.

    class RedisModuleCommands(builtins.object)
     |  This class contains the wrapper functions to bring supported redis
     |  modules into the command namespace.
     |
     |  Methods defined here:
     |
     |  bf(self) -> 'BFBloom'
     |      Access the bloom namespace.
     |
     |  cf(self) -> 'CFBloom'
     |      Access the bloom namespace.
     |
     |  cms(self) -> 'CMSBloom'
     |      Access the bloom namespace.
     |
     |  ft(self, index_name='idx') -> 'Search'
     |      Access the search namespace, providing support for redis search.
     |
     |  json(self, encoder=<json.encoder.JSONEncoder object at 0x0000017B9C588F50>, decoder=<json.decoder.JSONDecoder object at 0x0000017B9C588FB0>) -> 'JSON'
     |      Access the json namespace, providing support for redis json.
     |
     |  tdigest(self) -> 'TDigestBloom'
     |      Access the bloom namespace.
     |
     |  topk(self) -> 'TOPKBloom'
     |      Access the bloom namespace.
     |
     |  ts(self) -> 'TimeSeries'
     |      Access the timeseries namespace, providing support for
     |      redis timeseries data.
     |
     |  vset(self) -> 'VectorSet'
     |      Access the VectorSet commands namespace.
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors defined here:
     |
     |  __dict__
     |      dictionary for instance variables
     |
     |  __weakref__
     |      list of weak references to the object
     |
     |  ----------------------------------------------------------------------
     |  Data and other attributes defined here:
     |
     |  __annotations__ = {}

    class SentinelCommands(builtins.object)
     |  A class containing the commands specific to redis sentinel. This class is
     |  to be used as a mixin.
     |
     |  Methods defined here:
     |
     |  sentinel(self, *args)
     |      Redis Sentinel's SENTINEL command.
     |
     |  sentinel_ckquorum(self, new_master_name) -> Union[bool, Awaitable[bool]]
     |      Check if the current Sentinel configuration is able to reach the
     |      quorum needed to failover a master, and the majority needed to
     |      authorize the failover.
     |
     |      This command should be used in monitoring systems to check if a
     |      Sentinel deployment is ok.
     |
     |  sentinel_failover(self, new_master_name) -> Union[bool, Awaitable[bool]]
     |      Force a failover as if the master was not reachable, and without
     |      asking for agreement to other Sentinels (however a new version of the
     |      configuration will be published so that the other Sentinels will
     |      update their configurations).
     |
     |  sentinel_flushconfig(self) -> Union[bool, Awaitable[bool]]
     |      Force Sentinel to rewrite its configuration on disk, including the
     |      current Sentinel state.
     |
     |      Normally Sentinel rewrites the configuration every time something
     |      changes in its state (in the context of the subset of the state which
     |      is persisted on disk across restart).
     |      However sometimes it is possible that the configuration file is lost
     |      because of operation errors, disk failures, package upgrade scripts or
     |      configuration managers. In those cases a way to to force Sentinel to
     |      rewrite the configuration file is handy.
     |
     |      This command works even if the previous configuration file is
     |      completely missing.
     |
     |  sentinel_get_master_addr_by_name(self, service_name, return_responses: bool = False) -> Union[tuple[bytes | str, int], NoneType, bool, Awaitable[tuple[bytes | str, int] | None | bool]]
     |      Returns a (host, port) pair for the given ``service_name`` when return_responses is True,
     |      otherwise returns a boolean value that indicates if the command was successful.
     |
     |  sentinel_master(self, service_name, return_responses: bool = False) -> Union[dict[str, Any], bool, Awaitable[dict[str, Any] | bool]]
     |      Returns a dictionary containing the specified masters state, when return_responses is True,
     |      otherwise returns a boolean value that indicates if the command was successful.
     |
     |  sentinel_masters(self) -> Union[dict[str, dict[str, Any]], list[dict[str, Any]], Awaitable[dict[str, dict[str, Any]] | list[dict[str, Any]]]]
     |      Returns a list of dictionaries containing each master's state.
     |
     |      Important: This function is called by the Sentinel implementation and is
     |      called directly on the Redis standalone client for sentinels,
     |      so it doesn't support the "once" and "return_responses" options.
     |
     |  sentinel_monitor(self, name, ip, port, quorum) -> Union[bool, Awaitable[bool]]
     |      Add a new master to Sentinel to be monitored
     |
     |  sentinel_remove(self, name) -> Union[bool, Awaitable[bool]]
     |      Remove a master from Sentinel's monitoring
     |
     |  sentinel_reset(self, pattern) -> Union[bool, Awaitable[bool]]
     |      This command will reset all the masters with matching name.
     |      The pattern argument is a glob-style pattern.
     |
     |      The reset process clears any previous state in a master (including a
     |      failover in progress), and removes every slave and sentinel already
     |      discovered and associated with the master.
     |
     |  sentinel_sentinels(self, service_name, return_responses: bool = False) -> Union[list[dict[str, Any]], bool, Awaitable[list[dict[str, Any]] | bool]]
     |      Returns a list of sentinels for ``service_name``, when return_responses is True,
     |      otherwise returns a boolean value that indicates if the command was successful.
     |
     |  sentinel_set(self, name, option, value) -> Union[bool, Awaitable[bool]]
     |      Set Sentinel monitoring parameters for a given master
     |
     |  sentinel_slaves(self, service_name) -> Union[list[dict[str, Any]], Awaitable[list[dict[str, Any]]]]
     |      Returns a list of slaves for ``service_name``
     |
     |      Important: This function is called by the Sentinel implementation and is
     |      called directly on the Redis standalone client for sentinels,
     |      so it doesn't support the "once" and "return_responses" options.
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors defined here:
     |
     |  __dict__
     |      dictionary for instance variables
     |
     |  __weakref__
     |      list of weak references to the object
     |
     |  ----------------------------------------------------------------------
     |  Data and other attributes defined here:
     |
     |  __annotations__ = {}

FUNCTIONS
    list_or_args(keys: Any, args: Optional[Iterable[Any]]) -> List[Any]

DATA
    READ_COMMANDS = frozenset({'BITCOUNT', 'BITFIELD_RO', 'BITPOS', 'DBSIZ...
    __all__ = ['AsyncCoreCommands', 'AsyncRedisClusterCommands', 'AsyncRed...

FILE
    c:\users\youse\appdata\local\programs\python\python312\lib\site-packages\redis\commands\__init__.py

Python Library Documentation: module redis.connection in redis

NAME
    redis.connection

CLASSES
    abc.ABC(builtins.object)
        ConnectionPoolInterface
    builtins.object
        ConnectionInterface
        HiredisRespSerializer
        MaintNotificationsAbstractConnection
            AbstractConnection(MaintNotificationsAbstractConnection, ConnectionInterface)
                Connection
                    SSLConnection
                UnixDomainSocketConnection
            CacheProxyConnection(MaintNotificationsAbstractConnection, ConnectionInterface)
        MaintNotificationsAbstractConnectionPool
            ConnectionPool(MaintNotificationsAbstractConnectionPool, ConnectionPoolInterface)
                BlockingConnectionPool
        PythonRespSerializer

    class AbstractConnection(MaintNotificationsAbstractConnection, ConnectionInterface)
     |  AbstractConnection(db: int = 0, password: Optional[str] = None, socket_timeout: Optional[float] = 5, socket_connect_timeout: Optional[float] = 5, retry_on_timeout: bool = False, retry_on_error: Union[Iterable[Type[Exception]], object] = <object object at 0x0000017B991493E0>, encoding: str = 'utf-8', encoding_errors: str = 'strict', decode_responses: bool = False, parser_class=<class 'redis._parsers.resp2._RESP2Parser'>, socket_read_size: int = 32768, health_check_interval: int = 0, client_name: Optional[str] = None, lib_name: Union[str, NoneType, object] = <object object at 0x0000017B991493E0>, lib_version: Union[str, NoneType, object] = <object object at 0x0000017B991493E0>, driver_info: Union[redis.driver_info.DriverInfo, NoneType, object] = <object object at 0x0000017B991493E0>, username: Optional[str] = None, retry: Optional[Any] = None, redis_connect_func: Optional[Callable[[], NoneType]] = None, credential_provider: Optional[redis.credentials.CredentialProvider] = None, protocol: Optional[int] = None, legacy_responses: bool = True, command_packer: Optional[Callable[[], NoneType]] = None, event_dispatcher: Optional[redis.event.EventDispatcher] = None, maint_notifications_config: Optional[redis.maint_notifications.MaintNotificationsConfig] = None, maint_notifications_pool_handler: Optional[redis.maint_notifications.MaintNotificationsPoolHandler] = None, maintenance_state: 'MaintenanceState' = <MaintenanceState.NONE: 'none'>, maintenance_notification_hash: Optional[int] = None, orig_host_address: Optional[str] = None, orig_socket_timeout: Optional[float] = None, orig_socket_connect_timeout: Optional[float] = None, oss_cluster_maint_notifications_handler: Optional[redis.maint_notifications.OSSMaintNotificationsHandler] = None, himport_registry: redis.himport.HImportRegistry | None = None)
     |
     |  Manages communication to and from a Redis server
     |
     |  Method resolution order:
     |      AbstractConnection
     |      MaintNotificationsAbstractConnection
     |      ConnectionInterface
     |      builtins.object
     |
     |  Methods defined here:
     |
     |  __del__(self)
     |
     |  __init__(self, db: int = 0, password: Optional[str] = None, socket_timeout: Optional[float] = 5, socket_connect_timeout: Optional[float] = 5, retry_on_timeout: bool = False, retry_on_error: Union[Iterable[Type[Exception]], object] = <object object at 0x0000017B991493E0>, encoding: str = 'utf-8', encoding_errors: str = 'strict', decode_responses: bool = False, parser_class=<class 'redis._parsers.resp2._RESP2Parser'>, socket_read_size: int = 32768, health_check_interval: int = 0, client_name: Optional[str] = None, lib_name: Union[str, NoneType, object] = <object object at 0x0000017B991493E0>, lib_version: Union[str, NoneType, object] = <object object at 0x0000017B991493E0>, driver_info: Union[redis.driver_info.DriverInfo, NoneType, object] = <object object at 0x0000017B991493E0>, username: Optional[str] = None, retry: Optional[Any] = None, redis_connect_func: Optional[Callable[[], NoneType]] = None, credential_provider: Optional[redis.credentials.CredentialProvider] = None, protocol: Optional[int] = None, legacy_responses: bool = True, command_packer: Optional[Callable[[], NoneType]] = None, event_dispatcher: Optional[redis.event.EventDispatcher] = None, maint_notifications_config: Optional[redis.maint_notifications.MaintNotificationsConfig] = None, maint_notifications_pool_handler: Optional[redis.maint_notifications.MaintNotificationsPoolHandler] = None, maintenance_state: 'MaintenanceState' = <MaintenanceState.NONE: 'none'>, maintenance_notification_hash: Optional[int] = None, orig_host_address: Optional[str] = None, orig_socket_timeout: Optional[float] = None, orig_socket_connect_timeout: Optional[float] = None, oss_cluster_maint_notifications_handler: Optional[redis.maint_notifications.OSSMaintNotificationsHandler] = None, himport_registry: redis.himport.HImportRegistry | None = None)
     |      Initialize a new Connection.
     |
     |      To specify a retry policy for specific errors, first set
     |      `retry_on_error` to a list of the error/s to retry on, then set
     |      `retry` to a valid `Retry` object.
     |      To retry on TimeoutError, `retry_on_timeout` can also be set to `True`.
     |
     |      Parameters
     |      ----------
     |      driver_info : DriverInfo, optional
     |          Driver metadata for CLIENT SETINFO. If provided, lib_name and lib_version
     |          are ignored. If not provided, a DriverInfo will be created from lib_name
     |          and lib_version. Explicit None disables CLIENT SETINFO.
     |      lib_name : str, optional
     |          **Deprecated.** Use driver_info instead. Library name for CLIENT SETINFO.
     |      lib_version : str, optional
     |          **Deprecated.** Use driver_info instead. Library version for CLIENT SETINFO.
     |
     |  __repr__(self)
     |      Return repr(self).
     |
     |  can_read(self, timeout: float = 0) -> bool
     |      Poll the socket to see if there's data that can be read.
     |
     |  check_health(self)
     |      Check the health of the connection with a PING/PONG
     |
     |  connect(self)
     |      Connects to the Redis server if not already connected
     |
     |  connect_check_health(self, check_health: bool = True, retry_socket_connect: bool = True)
     |
     |  deregister_connect_callback(self, callback)
     |      De-register a previously registered callback.  It will no-longer receive
     |      notifications on connection events.  Calling this is not required when the
     |      listener goes away, since the callbacks are kept as weak methods.
     |
     |  disconnect(self, *args, **kwargs)
     |      Disconnects from the Redis server
     |
     |  extract_connection_details(self) -> str
     |
     |  get_protocol(self) -> Union[int, str]
     |      Returns:
     |          The RESP protocol version, or ``None`` if the protocol is not specified,
     |          in which case the server default will be used.
     |
     |  mark_for_reconnect(self)
     |      Mark the connection to be reconnected on the next command.
     |      This is useful when a connection is moved to a different node.
     |
     |  on_connect(self)
     |
     |  on_connect_check_health(self, check_health: bool = True)
     |      Initialize the connection, authenticate and select a database
     |
     |  pack_command(self, *args)
     |      Pack a series of arguments into the Redis protocol
     |
     |  pack_commands(self, commands)
     |      Pack multiple commands into the Redis protocol
     |
     |  re_auth(self)
     |
     |  read_response(self, disable_decoding=False, *, timeout: Union[float, object] = <object object at 0x0000017B991493E0>, disconnect_on_error=True, push_request=False)
     |      Read the response from a previously sent command
     |
     |  register_connect_callback(self, callback)
     |      Register a callback to be called when the connection is established either
     |      initially or reconnected.  This allows listeners to issue commands that
     |      are ephemeral to the connection, for example pub/sub subscription or
     |      key tracking.  The callback must be a _method_ and will be kept as
     |      a weak reference.
     |
     |  repr_pieces(self)
     |
     |  reset_should_reconnect(self)
     |      Reset the internal flag to False.
     |
     |  send_command(self, *args, **kwargs)
     |      Pack and send a command to the Redis server
     |
     |  send_packed_command(self, command, check_health=True)
     |      Send an already packed command to the Redis server
     |
     |  set_parser(self, parser_class)
     |      Creates a new instance of parser_class with socket size:
     |      _socket_read_size and assigns it to the parser for the connection
     |      :param parser_class: The required parser class
     |
     |  set_re_auth_token(self, token: redis.auth.token.TokenInterface)
     |
     |  should_reconnect(self)
     |      Returns True if the connection should be reconnected.
     |
     |  ----------------------------------------------------------------------
     |  Readonly properties defined here:
     |
     |  is_connected
     |      Return ``True`` if the connection to the server is active.
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors defined here:
     |
     |  handshake_metadata
     |
     |  socket_connect_timeout
     |
     |  socket_timeout
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from MaintNotificationsAbstractConnection:
     |
     |  activate_maint_notifications_handling_if_enabled(self, check_health=True)
     |
     |  add_maint_start_notification(self, id: int)
     |
     |  add_skipped_end_notification(self, id: int)
     |
     |  get_processed_start_notifications(self) -> set
     |
     |  get_resolved_ip(self) -> Optional[str]
     |      Extract the resolved IP address from an
     |      established connection or resolve it from the host.
     |
     |      First tries to get the actual IP from the socket (most accurate),
     |      then falls back to DNS resolution if needed.
     |
     |      Returns:
     |          str: The resolved IP address, or None if it cannot be determined
     |
     |  get_skipped_end_notifications(self) -> set
     |
     |  getpeername(self)
     |      Returns the peer name of the connection.
     |
     |  reset_received_notifications(self)
     |
     |  reset_tmp_settings(self, reset_host_address: bool = False, reset_relaxed_timeout: bool = False)
     |
     |  set_maint_notifications_cluster_handler_for_connection(self, oss_cluster_maint_notifications_handler: redis.maint_notifications.OSSMaintNotificationsHandler)
     |
     |  set_maint_notifications_pool_handler_for_connection(self, maint_notifications_pool_handler: redis.maint_notifications.MaintNotificationsPoolHandler)
     |
     |  set_tmp_settings(self, tmp_host_address: Union[str, object, NoneType] = <object object at 0x0000017B991493E0>, tmp_relaxed_timeout: Optional[float] = -1)
     |      SENTINEL keeps the host unchanged. -1 keeps the relaxed timeout unchanged.
     |
     |  update_current_socket_timeout(self, relaxed_timeout: Optional[float] = None)
     |
     |  update_parser_timeout(self, timeout: Optional[float] = None)
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors inherited from MaintNotificationsAbstractConnection:
     |
     |  __dict__
     |      dictionary for instance variables
     |
     |  __weakref__
     |      list of weak references to the object
     |
     |  host
     |
     |  maintenance_state

    class BlockingConnectionPool(ConnectionPool)
     |  BlockingConnectionPool(max_connections=50, timeout=20, connection_class=<class 'redis.connection.Connection'>, queue_class=<class 'queue.LifoQueue'>, **connection_kwargs)
     |
     |  Thread-safe blocking connection pool::
     |
     |      >>> from redis.client import Redis
     |      >>> client = Redis(connection_pool=BlockingConnectionPool())
     |
     |  It performs the same function as the default
     |  :py:class:`~redis.ConnectionPool` implementation, in that,
     |  it maintains a pool of reusable connections that can be shared by
     |  multiple redis clients (safely across threads if required).
     |
     |  The difference is that, in the event that a client tries to get a
     |  connection from the pool when all of connections are in use, rather than
     |  raising a :py:class:`~redis.ConnectionError` (as the default
     |  :py:class:`~redis.ConnectionPool` implementation does), it
     |  makes the client wait ("blocks") for a specified number of seconds until
     |  a connection becomes available.
     |
     |  Use ``max_connections`` to increase / decrease the pool size::
     |
     |      >>> pool = BlockingConnectionPool(max_connections=10)
     |
     |  Use ``timeout`` to tell it either how many seconds to wait for a connection
     |  to become available, or to block forever:
     |
     |      >>> # Block forever.
     |      >>> pool = BlockingConnectionPool(timeout=None)
     |
     |      >>> # Raise a ``ConnectionError`` after five seconds if a connection is
     |      >>> # not available.
     |      >>> pool = BlockingConnectionPool(timeout=5)
     |
     |  Method resolution order:
     |      BlockingConnectionPool
     |      ConnectionPool
     |      MaintNotificationsAbstractConnectionPool
     |      ConnectionPoolInterface
     |      abc.ABC
     |      builtins.object
     |
     |  Methods defined here:
     |
     |  __del__(self) -> None
     |      Clean up connection pool and record metrics when garbage collected.
     |
     |  __init__(self, max_connections=50, timeout=20, connection_class=<class 'redis.connection.Connection'>, queue_class=<class 'queue.LifoQueue'>, **connection_kwargs)
     |      Initialize self.  See help(type(self)) for accurate signature.
     |
     |  disconnect(self, inuse_connections: bool = True)
     |      Disconnects either all connections in the pool or just the free connections.
     |
     |  get_connection(self, command_name=None, *keys, **options)
     |      Get a connection, blocking for ``self.timeout`` until a connection
     |      is available from the pool.
     |
     |      If the connection returned is ``None`` then creates a new connection.
     |      Because we use a last-in first-out queue, the existing connections
     |      (having been returned to the pool after the initial ``None`` values
     |      were added) will be returned before ``None`` values. This means we only
     |      create new connections when we need to, i.e.: the actual number of
     |      connections will only increase in response to demand.
     |
     |  make_connection(self)
     |      Make a fresh connection.
     |
     |  release(self, connection)
     |      Releases the connection back to the pool.
     |
     |  reset(self)
     |
     |  set_in_maintenance(self, in_maintenance: bool)
     |      Sets a flag that this Blocking ConnectionPool is in maintenance mode.
     |
     |      This is used to prevent new connections from being created while we are in maintenance mode.
     |      The pool will be in maintenance mode only when we are processing a MOVING notification.
     |
     |  ----------------------------------------------------------------------
     |  Data and other attributes defined here:
     |
     |  __abstractmethods__ = frozenset()
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from ConnectionPool:
     |
     |  __enter__(self: ~_CP) -> ~_CP
     |
     |  __exit__(self, exc_type, exc_value, traceback) -> None
     |
     |  __repr__(self) -> str
     |      Return repr(self).
     |
     |  close(self) -> None
     |      Close the pool, disconnecting all connections
     |
     |  get_connection_count(self) -> List[tuple[int, dict]]
     |      Returns a connection count (both idle and in use).
     |
     |  get_encoder(self) -> redis._parsers.encoders.Encoder
     |      Return an encoder based on encoding settings
     |
     |  get_protocol(self)
     |      Returns:
     |          The RESP protocol version, or ``None`` if the protocol is not specified,
     |          in which case the server default will be used.
     |
     |  owns_connection(self, connection: 'Connection') -> int
     |
     |  re_auth_callback(self, token: redis.auth.token.TokenInterface)
     |
     |  set_retry(self, retry: redis.retry.Retry) -> None
     |
     |  ----------------------------------------------------------------------
     |  Class methods inherited from ConnectionPool:
     |
     |  from_url(url: str, **kwargs) -> ~_CP
     |      Return a connection pool configured from the given URL.
     |
     |      For example::
     |
     |          redis://[[username]:[password]]@localhost:6379/0
     |          rediss://[[username]:[password]]@localhost:6379/0
     |          unix://[username@]/path/to/socket.sock?db=0[&password=password]
     |
     |      Three URL schemes are supported:
     |
     |      - `redis://` creates a TCP socket connection. See more at:
     |        <https://www.iana.org/assignments/uri-schemes/prov/redis>
     |      - `rediss://` creates a SSL wrapped TCP socket connection. See more at:
     |        <https://www.iana.org/assignments/uri-schemes/prov/rediss>
     |      - ``unix://``: creates a Unix Domain Socket connection.
     |
     |      The username, password, hostname, path and all querystring values
     |      are passed through urllib.parse.unquote in order to replace any
     |      percent-encoded values with their corresponding characters.
     |
     |      There are several ways to specify a database number. The first value
     |      found will be used:
     |
     |          1. A ``db`` querystring option, e.g. redis://localhost?db=0
     |          2. If using the redis:// or rediss:// schemes, the path argument
     |             of the url, e.g. redis://localhost/0
     |          3. A ``db`` keyword argument to this function.
     |
     |      If none of these options are specified, the default db=0 is used.
     |
     |      All querystring options are cast to their appropriate Python types.
     |      Boolean arguments can be specified with string values "True"/"False"
     |      or "Yes"/"No". Values that cannot be properly cast cause a
     |      ``ValueError`` to be raised. Once parsed, the querystring arguments
     |      and keyword arguments are passed to the ``ConnectionPool``'s
     |      class initializer. In the case of conflicting arguments, querystring
     |      arguments always win.
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors inherited from ConnectionPool:
     |
     |  connection_kwargs
     |
     |  ----------------------------------------------------------------------
     |  Data and other attributes inherited from ConnectionPool:
     |
     |  OMIT_REPR_KEYS = frozenset({'himport_registry'})
     |
     |  SENSITIVE_REPR_KEYS = frozenset({'credential_provider', 'password', 's...
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from MaintNotificationsAbstractConnectionPool:
     |
     |  disconnect_free_connections(self, moving_address_src: Optional[str] = None)
     |      Disconnect all free/available connections.
     |      This is used when a cluster node is migrated to a different address.
     |
     |      :param moving_address_src: The address of the node that is being moved.
     |
     |  maint_notifications_enabled(self)
     |      Returns:
     |          True if the maintenance notifications are enabled, False otherwise.
     |          The maintenance notifications config is stored in the pool handler.
     |          If the pool handler is not set, the maintenance notifications are not enabled.
     |
     |  update_active_connections_for_reconnect(self, moving_address_src: Optional[str] = None)
     |      Mark all active connections for reconnect.
     |      This is used when a cluster node is migrated to a different address.
     |
     |      :param moving_address_src: The address of the node that is being moved.
     |
     |  update_connection_kwargs(self, **kwargs)
     |      Update the connection kwargs for all future connections.
     |
     |      This method updates the connection kwargs for all future connections created by the pool.
     |      Existing connections are not affected.
     |
     |  update_connection_settings(self, conn: 'MaintNotificationsAbstractConnection', state: Optional[ForwardRef('MaintenanceState')] = None, maintenance_notification_hash: Optional[int] = None, host_address: Optional[str] = None, relaxed_timeout: Optional[float] = None, update_notification_hash: bool = False, reset_host_address: bool = False, reset_relaxed_timeout: bool = False)
     |      Update the settings for a single connection.
     |
     |  update_connections_settings(self, state: Optional[ForwardRef('MaintenanceState')] = None, maintenance_notification_hash: Optional[int] = None, host_address: Optional[str] = None, relaxed_timeout: Optional[float] = None, matching_address: Optional[str] = None, matching_notification_hash: Optional[int] = None, matching_pattern: Literal['connected_address', 'configured_address', 'notification_hash'] = 'connected_address', update_notification_hash: bool = False, reset_host_address: bool = False, reset_relaxed_timeout: bool = False, include_free_connections: bool = True)
     |      Update the settings for all matching connections in the pool.
     |
     |      This method does not create new connections.
     |      This method does not affect the connection kwargs.
     |
     |      :param state: The maintenance state to set for the connection.
     |      :param maintenance_notification_hash: The hash of the maintenance notification
     |                                             to set for the connection.
     |      :param host_address: The host address to set for the connection.
     |      :param relaxed_timeout: The relaxed timeout to set for the connection.
     |      :param matching_address: The address to match for the connection.
     |      :param matching_notification_hash: The notification hash to match for the connection.
     |      :param matching_pattern: The pattern to match for the connection.
     |      :param update_notification_hash: Whether to update the notification hash for the connection.
     |      :param reset_host_address: Whether to reset the host address to the original address.
     |      :param reset_relaxed_timeout: Whether to reset the relaxed timeout to the original timeout.
     |      :param include_free_connections: Whether to include free/available connections.
     |
     |  update_maint_notifications_config(self, maint_notifications_config: redis.maint_notifications.MaintNotificationsConfig, oss_cluster_maint_notifications_handler: Optional[redis.maint_notifications.OSSMaintNotificationsHandler] = None)
     |      Updates the maintenance notifications configuration.
     |      This method should be called only if the pool was created
     |      without enabling the maintenance notifications and
     |      in a later point in time maintenance notifications
     |      are requested to be enabled.
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors inherited from MaintNotificationsAbstractConnectionPool:
     |
     |  __dict__
     |      dictionary for instance variables
     |
     |  __weakref__
     |      list of weak references to the object

    class CacheProxyConnection(MaintNotificationsAbstractConnection, ConnectionInterface)
     |  CacheProxyConnection(conn: redis.connection.ConnectionInterface, cache: redis.cache.CacheInterface, pool_lock: <function RLock at 0x0000017B99973240>)
     |
     |  Method resolution order:
     |      CacheProxyConnection
     |      MaintNotificationsAbstractConnection
     |      ConnectionInterface
     |      builtins.object
     |
     |  Methods defined here:
     |
     |  __init__(self, conn: redis.connection.ConnectionInterface, cache: redis.cache.CacheInterface, pool_lock: <function RLock at 0x0000017B99973240>)
     |      Initialize the maintenance notifications for the connection.
     |
     |      Args:
     |          maint_notifications_config (MaintNotificationsConfig): The configuration for maintenance notifications.
     |          maint_notifications_pool_handler (Optional[MaintNotificationsPoolHandler]): The pool handler for maintenance notifications.
     |          maintenance_state (MaintenanceState): The current maintenance state of the connection.
     |          maintenance_notification_hash (Optional[int]): The current maintenance notification hash of the connection.
     |          orig_host_address (Optional[str]): The original host address of the connection.
     |          orig_socket_timeout (Optional[float]): The original socket timeout of the connection.
     |          orig_socket_connect_timeout (Optional[float]): The original socket connect timeout of the connection.
     |          oss_cluster_maint_notifications_handler (Optional[OSSMaintNotificationsHandler]): The OSS cluster handler for maintenance notifications.
     |          parser (Optional[BaseParser]): The parser to use for maintenance notifications.
     |                  If not provided, the parser from the connection is used.
     |                  This is useful when the parser is created after this object.
     |
     |  can_read(self, timeout: float = 0) -> bool
     |
     |  check_health(self)
     |
     |  connect(self)
     |
     |  deregister_connect_callback(self, callback)
     |
     |  disconnect(self, *args, **kwargs)
     |
     |  extract_connection_details(self) -> str
     |
     |  get_protocol(self)
     |      Returns:
     |          The RESP protocol version, or ``None`` if the protocol is not specified,
     |          in which case the server default will be used.
     |
     |  get_resolved_ip(self)
     |      Extract the resolved IP address from an
     |      established connection or resolve it from the host.
     |
     |      First tries to get the actual IP from the socket (most accurate),
     |      then falls back to DNS resolution if needed.
     |
     |      Returns:
     |          str: The resolved IP address, or None if it cannot be determined
     |
     |  getpeername(self)
     |      Returns the peer name of the connection.
     |
     |  mark_for_reconnect(self)
     |      Mark the connection to be reconnected on the next command.
     |      This is useful when a connection is moved to a different node.
     |
     |  on_connect(self)
     |
     |  pack_command(self, *args)
     |
     |  pack_commands(self, commands)
     |
     |  re_auth(self)
     |
     |  read_response(self, disable_decoding=False, *, timeout: Union[float, object] = <object object at 0x0000017B991493E0>, disconnect_on_error=True, push_request=False)
     |
     |  register_connect_callback(self, callback)
     |
     |  repr_pieces(self)
     |
     |  reset_should_reconnect(self)
     |      Reset the internal flag to False.
     |
     |  reset_tmp_settings(self, reset_host_address: bool = False, reset_relaxed_timeout: bool = False)
     |
     |  send_command(self, *args, **kwargs)
     |
     |  send_packed_command(self, command, check_health=True)
     |
     |  set_maint_notifications_cluster_handler_for_connection(self, oss_cluster_maint_notifications_handler)
     |
     |  set_maint_notifications_pool_handler_for_connection(self, maint_notifications_pool_handler)
     |
     |  set_parser(self, parser_class)
     |
     |  set_re_auth_token(self, token: redis.auth.token.TokenInterface)
     |
     |  set_tmp_settings(self, tmp_host_address: Optional[str] = None, tmp_relaxed_timeout: Optional[float] = -1)
     |      SENTINEL keeps the host unchanged. -1 keeps the relaxed timeout unchanged.
     |
     |  should_reconnect(self)
     |      Returns True if the connection should be reconnected.
     |
     |  update_current_socket_timeout(self, relaxed_timeout: Optional[float] = None)
     |
     |  ----------------------------------------------------------------------
     |  Readonly properties defined here:
     |
     |  handshake_metadata
     |
     |  himport_registry
     |
     |  is_connected
     |      Return ``True`` if the connection to the server is active.
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors defined here:
     |
     |  host
     |
     |  maintenance_state
     |
     |  socket_connect_timeout
     |
     |  socket_timeout
     |
     |  ----------------------------------------------------------------------
     |  Data and other attributes defined here:
     |
     |  DEFAULT_SERVER_NAME = 'redis'
     |
     |  DUMMY_CACHE_VALUE = b'foo'
     |
     |  MIN_ALLOWED_VERSION = '7.4.0'
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from MaintNotificationsAbstractConnection:
     |
     |  activate_maint_notifications_handling_if_enabled(self, check_health=True)
     |
     |  add_maint_start_notification(self, id: int)
     |
     |  add_skipped_end_notification(self, id: int)
     |
     |  get_processed_start_notifications(self) -> set
     |
     |  get_skipped_end_notifications(self) -> set
     |
     |  reset_received_notifications(self)
     |
     |  update_parser_timeout(self, timeout: Optional[float] = None)
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors inherited from MaintNotificationsAbstractConnection:
     |
     |  __dict__
     |      dictionary for instance variables
     |
     |  __weakref__
     |      list of weak references to the object

    class Connection(AbstractConnection)
     |  Connection(host='localhost', port=6379, socket_keepalive=True, socket_keepalive_options=<object object at 0x0000017B991493E0>, socket_type=0, **kwargs)
     |
     |  Manages TCP communication to and from a Redis server
     |
     |  Method resolution order:
     |      Connection
     |      AbstractConnection
     |      MaintNotificationsAbstractConnection
     |      ConnectionInterface
     |      builtins.object
     |
     |  Methods defined here:
     |
     |  __init__(self, host='localhost', port=6379, socket_keepalive=True, socket_keepalive_options=<object object at 0x0000017B991493E0>, socket_type=0, **kwargs)
     |      Initialize a TCP connection.
     |
     |      Parameters
     |      ----------
     |      socket_keepalive : bool
     |          If `True`, TCP keepalive is enabled for TCP socket connections.
     |      socket_keepalive_options : Mapping[int, int | bytes] | object | None
     |          Mapping of TCP keepalive socket option constants to values, for
     |          example `{socket.TCP_KEEPIDLE: 30}`. If left unspecified, redis-py
     |          uses TCP keepalive defaults when `socket_keepalive` is enabled:
     |          idle 30 seconds, interval 5 seconds, and 3 probes. Platform-specific
     |          options that are not available are skipped. Pass `None` or `{}` to
     |          avoid setting additional TCP keepalive options.
     |
     |  repr_pieces(self)
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors defined here:
     |
     |  host
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from AbstractConnection:
     |
     |  __del__(self)
     |
     |  __repr__(self)
     |      Return repr(self).
     |
     |  can_read(self, timeout: float = 0) -> bool
     |      Poll the socket to see if there's data that can be read.
     |
     |  check_health(self)
     |      Check the health of the connection with a PING/PONG
     |
     |  connect(self)
     |      Connects to the Redis server if not already connected
     |
     |  connect_check_health(self, check_health: bool = True, retry_socket_connect: bool = True)
     |
     |  deregister_connect_callback(self, callback)
     |      De-register a previously registered callback.  It will no-longer receive
     |      notifications on connection events.  Calling this is not required when the
     |      listener goes away, since the callbacks are kept as weak methods.
     |
     |  disconnect(self, *args, **kwargs)
     |      Disconnects from the Redis server
     |
     |  extract_connection_details(self) -> str
     |
     |  get_protocol(self) -> Union[int, str]
     |      Returns:
     |          The RESP protocol version, or ``None`` if the protocol is not specified,
     |          in which case the server default will be used.
     |
     |  mark_for_reconnect(self)
     |      Mark the connection to be reconnected on the next command.
     |      This is useful when a connection is moved to a different node.
     |
     |  on_connect(self)
     |
     |  on_connect_check_health(self, check_health: bool = True)
     |      Initialize the connection, authenticate and select a database
     |
     |  pack_command(self, *args)
     |      Pack a series of arguments into the Redis protocol
     |
     |  pack_commands(self, commands)
     |      Pack multiple commands into the Redis protocol
     |
     |  re_auth(self)
     |
     |  read_response(self, disable_decoding=False, *, timeout: Union[float, object] = <object object at 0x0000017B991493E0>, disconnect_on_error=True, push_request=False)
     |      Read the response from a previously sent command
     |
     |  register_connect_callback(self, callback)
     |      Register a callback to be called when the connection is established either
     |      initially or reconnected.  This allows listeners to issue commands that
     |      are ephemeral to the connection, for example pub/sub subscription or
     |      key tracking.  The callback must be a _method_ and will be kept as
     |      a weak reference.
     |
     |  reset_should_reconnect(self)
     |      Reset the internal flag to False.
     |
     |  send_command(self, *args, **kwargs)
     |      Pack and send a command to the Redis server
     |
     |  send_packed_command(self, command, check_health=True)
     |      Send an already packed command to the Redis server
     |
     |  set_parser(self, parser_class)
     |      Creates a new instance of parser_class with socket size:
     |      _socket_read_size and assigns it to the parser for the connection
     |      :param parser_class: The required parser class
     |
     |  set_re_auth_token(self, token: redis.auth.token.TokenInterface)
     |
     |  should_reconnect(self)
     |      Returns True if the connection should be reconnected.
     |
     |  ----------------------------------------------------------------------
     |  Readonly properties inherited from AbstractConnection:
     |
     |  is_connected
     |      Return ``True`` if the connection to the server is active.
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors inherited from AbstractConnection:
     |
     |  handshake_metadata
     |
     |  socket_connect_timeout
     |
     |  socket_timeout
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from MaintNotificationsAbstractConnection:
     |
     |  activate_maint_notifications_handling_if_enabled(self, check_health=True)
     |
     |  add_maint_start_notification(self, id: int)
     |
     |  add_skipped_end_notification(self, id: int)
     |
     |  get_processed_start_notifications(self) -> set
     |
     |  get_resolved_ip(self) -> Optional[str]
     |      Extract the resolved IP address from an
     |      established connection or resolve it from the host.
     |
     |      First tries to get the actual IP from the socket (most accurate),
     |      then falls back to DNS resolution if needed.
     |
     |      Returns:
     |          str: The resolved IP address, or None if it cannot be determined
     |
     |  get_skipped_end_notifications(self) -> set
     |
     |  getpeername(self)
     |      Returns the peer name of the connection.
     |
     |  reset_received_notifications(self)
     |
     |  reset_tmp_settings(self, reset_host_address: bool = False, reset_relaxed_timeout: bool = False)
     |
     |  set_maint_notifications_cluster_handler_for_connection(self, oss_cluster_maint_notifications_handler: redis.maint_notifications.OSSMaintNotificationsHandler)
     |
     |  set_maint_notifications_pool_handler_for_connection(self, maint_notifications_pool_handler: redis.maint_notifications.MaintNotificationsPoolHandler)
     |
     |  set_tmp_settings(self, tmp_host_address: Union[str, object, NoneType] = <object object at 0x0000017B991493E0>, tmp_relaxed_timeout: Optional[float] = -1)
     |      SENTINEL keeps the host unchanged. -1 keeps the relaxed timeout unchanged.
     |
     |  update_current_socket_timeout(self, relaxed_timeout: Optional[float] = None)
     |
     |  update_parser_timeout(self, timeout: Optional[float] = None)
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors inherited from MaintNotificationsAbstractConnection:
     |
     |  __dict__
     |      dictionary for instance variables
     |
     |  __weakref__
     |      list of weak references to the object
     |
     |  maintenance_state

    class ConnectionInterface(builtins.object)
     |  Methods defined here:
     |
     |  can_read(self, timeout: float = 0) -> bool
     |
     |  check_health(self)
     |
     |  connect(self)
     |
     |  deregister_connect_callback(self, callback)
     |
     |  disconnect(self, *args, **kwargs)
     |
     |  extract_connection_details(self) -> str
     |
     |  get_protocol(self)
     |
     |  mark_for_reconnect(self)
     |      Mark the connection to be reconnected on the next command.
     |      This is useful when a connection is moved to a different node.
     |
     |  on_connect(self)
     |
     |  pack_command(self, *args)
     |
     |  pack_commands(self, commands)
     |
     |  re_auth(self)
     |
     |  read_response(self, disable_decoding=False, *, timeout: Union[float, object] = <object object at 0x0000017B991493E0>, disconnect_on_error=True, push_request=False)
     |
     |  register_connect_callback(self, callback)
     |
     |  repr_pieces(self)
     |
     |  reset_should_reconnect(self)
     |      Reset the internal flag to False.
     |
     |  send_command(self, *args, **kwargs)
     |
     |  send_packed_command(self, command, check_health=True)
     |
     |  set_parser(self, parser_class)
     |
     |  set_re_auth_token(self, token: redis.auth.token.TokenInterface)
     |
     |  should_reconnect(self)
     |      Returns True if the connection should be reconnected.
     |
     |  ----------------------------------------------------------------------
     |  Readonly properties defined here:
     |
     |  handshake_metadata
     |
     |  is_connected
     |      Return ``True`` if the connection to the server is active.
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors defined here:
     |
     |  __dict__
     |      dictionary for instance variables
     |
     |  __weakref__
     |      list of weak references to the object

    class ConnectionPool(MaintNotificationsAbstractConnectionPool, ConnectionPoolInterface)
     |  ConnectionPool(connection_class=<class 'redis.connection.Connection'>, max_connections: Optional[int] = None, cache_factory: Optional[redis.cache.CacheFactoryInterface] = None, maint_notifications_config: Optional[redis.maint_notifications.MaintNotificationsConfig] = None, **connection_kwargs)
     |
     |  Create a connection pool. ``If max_connections`` is set, then this
     |  object raises :py:class:`~redis.exceptions.ConnectionError` when the pool's
     |  limit is reached.
     |
     |  By default, TCP connections are created unless ``connection_class``
     |  is specified. Use class:`.UnixDomainSocketConnection` for
     |  unix sockets.
     |  :py:class:`~redis.SSLConnection` can be used for SSL enabled connections.
     |
     |  If ``maint_notifications_config`` is provided, the connection pool will support
     |  maintenance notifications.
     |  Maintenance notifications are supported only with RESP3.
     |  If the ``maint_notifications_config`` is not provided but the ``protocol`` is 3,
     |  the maintenance notifications will be enabled by default.
     |
     |  Any additional keyword arguments are passed to the constructor of
     |  ``connection_class``.
     |
     |  Method resolution order:
     |      ConnectionPool
     |      MaintNotificationsAbstractConnectionPool
     |      ConnectionPoolInterface
     |      abc.ABC
     |      builtins.object
     |
     |  Methods defined here:
     |
     |  __del__(self) -> None
     |      Clean up connection pool and record metrics when garbage collected.
     |
     |  __enter__(self: ~_CP) -> ~_CP
     |
     |  __exit__(self, exc_type, exc_value, traceback) -> None
     |
     |  __init__(self, connection_class=<class 'redis.connection.Connection'>, max_connections: Optional[int] = None, cache_factory: Optional[redis.cache.CacheFactoryInterface] = None, maint_notifications_config: Optional[redis.maint_notifications.MaintNotificationsConfig] = None, **connection_kwargs)
     |      Initialize self.  See help(type(self)) for accurate signature.
     |
     |  __repr__(self) -> str
     |      Return repr(self).
     |
     |  close(self) -> None
     |      Close the pool, disconnecting all connections
     |
     |  disconnect(self, inuse_connections: bool = True) -> None
     |      Disconnects connections in the pool
     |
     |      If ``inuse_connections`` is True, disconnect connections that are
     |      currently in use, potentially by other threads. Otherwise only disconnect
     |      connections that are idle in the pool.
     |
     |  get_connection(self, command_name=None, *keys, **options) -> 'Connection'
     |      Get a connection from the pool
     |
     |  get_connection_count(self) -> List[tuple[int, dict]]
     |      Returns a connection count (both idle and in use).
     |
     |  get_encoder(self) -> redis._parsers.encoders.Encoder
     |      Return an encoder based on encoding settings
     |
     |  get_protocol(self)
     |      Returns:
     |          The RESP protocol version, or ``None`` if the protocol is not specified,
     |          in which case the server default will be used.
     |
     |  make_connection(self) -> 'ConnectionInterface'
     |      Create a new connection
     |
     |  owns_connection(self, connection: 'Connection') -> int
     |
     |  re_auth_callback(self, token: redis.auth.token.TokenInterface)
     |
     |  release(self, connection: 'Connection') -> None
     |      Releases the connection back to the pool
     |
     |  reset(self) -> None
     |
     |  set_retry(self, retry: redis.retry.Retry) -> None
     |
     |  ----------------------------------------------------------------------
     |  Class methods defined here:
     |
     |  from_url(url: str, **kwargs) -> ~_CP
     |      Return a connection pool configured from the given URL.
     |
     |      For example::
     |
     |          redis://[[username]:[password]]@localhost:6379/0
     |          rediss://[[username]:[password]]@localhost:6379/0
     |          unix://[username@]/path/to/socket.sock?db=0[&password=password]
     |
     |      Three URL schemes are supported:
     |
     |      - `redis://` creates a TCP socket connection. See more at:
     |        <https://www.iana.org/assignments/uri-schemes/prov/redis>
     |      - `rediss://` creates a SSL wrapped TCP socket connection. See more at:
     |        <https://www.iana.org/assignments/uri-schemes/prov/rediss>
     |      - ``unix://``: creates a Unix Domain Socket connection.
     |
     |      The username, password, hostname, path and all querystring values
     |      are passed through urllib.parse.unquote in order to replace any
     |      percent-encoded values with their corresponding characters.
     |
     |      There are several ways to specify a database number. The first value
     |      found will be used:
     |
     |          1. A ``db`` querystring option, e.g. redis://localhost?db=0
     |          2. If using the redis:// or rediss:// schemes, the path argument
     |             of the url, e.g. redis://localhost/0
     |          3. A ``db`` keyword argument to this function.
     |
     |      If none of these options are specified, the default db=0 is used.
     |
     |      All querystring options are cast to their appropriate Python types.
     |      Boolean arguments can be specified with string values "True"/"False"
     |      or "Yes"/"No". Values that cannot be properly cast cause a
     |      ``ValueError`` to be raised. Once parsed, the querystring arguments
     |      and keyword arguments are passed to the ``ConnectionPool``'s
     |      class initializer. In the case of conflicting arguments, querystring
     |      arguments always win.
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors defined here:
     |
     |  connection_kwargs
     |
     |  ----------------------------------------------------------------------
     |  Data and other attributes defined here:
     |
     |  OMIT_REPR_KEYS = frozenset({'himport_registry'})
     |
     |  SENSITIVE_REPR_KEYS = frozenset({'credential_provider', 'password', 's...
     |
     |  __abstractmethods__ = frozenset()
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from MaintNotificationsAbstractConnectionPool:
     |
     |  disconnect_free_connections(self, moving_address_src: Optional[str] = None)
     |      Disconnect all free/available connections.
     |      This is used when a cluster node is migrated to a different address.
     |
     |      :param moving_address_src: The address of the node that is being moved.
     |
     |  maint_notifications_enabled(self)
     |      Returns:
     |          True if the maintenance notifications are enabled, False otherwise.
     |          The maintenance notifications config is stored in the pool handler.
     |          If the pool handler is not set, the maintenance notifications are not enabled.
     |
     |  update_active_connections_for_reconnect(self, moving_address_src: Optional[str] = None)
     |      Mark all active connections for reconnect.
     |      This is used when a cluster node is migrated to a different address.
     |
     |      :param moving_address_src: The address of the node that is being moved.
     |
     |  update_connection_kwargs(self, **kwargs)
     |      Update the connection kwargs for all future connections.
     |
     |      This method updates the connection kwargs for all future connections created by the pool.
     |      Existing connections are not affected.
     |
     |  update_connection_settings(self, conn: 'MaintNotificationsAbstractConnection', state: Optional[ForwardRef('MaintenanceState')] = None, maintenance_notification_hash: Optional[int] = None, host_address: Optional[str] = None, relaxed_timeout: Optional[float] = None, update_notification_hash: bool = False, reset_host_address: bool = False, reset_relaxed_timeout: bool = False)
     |      Update the settings for a single connection.
     |
     |  update_connections_settings(self, state: Optional[ForwardRef('MaintenanceState')] = None, maintenance_notification_hash: Optional[int] = None, host_address: Optional[str] = None, relaxed_timeout: Optional[float] = None, matching_address: Optional[str] = None, matching_notification_hash: Optional[int] = None, matching_pattern: Literal['connected_address', 'configured_address', 'notification_hash'] = 'connected_address', update_notification_hash: bool = False, reset_host_address: bool = False, reset_relaxed_timeout: bool = False, include_free_connections: bool = True)
     |      Update the settings for all matching connections in the pool.
     |
     |      This method does not create new connections.
     |      This method does not affect the connection kwargs.
     |
     |      :param state: The maintenance state to set for the connection.
     |      :param maintenance_notification_hash: The hash of the maintenance notification
     |                                             to set for the connection.
     |      :param host_address: The host address to set for the connection.
     |      :param relaxed_timeout: The relaxed timeout to set for the connection.
     |      :param matching_address: The address to match for the connection.
     |      :param matching_notification_hash: The notification hash to match for the connection.
     |      :param matching_pattern: The pattern to match for the connection.
     |      :param update_notification_hash: Whether to update the notification hash for the connection.
     |      :param reset_host_address: Whether to reset the host address to the original address.
     |      :param reset_relaxed_timeout: Whether to reset the relaxed timeout to the original timeout.
     |      :param include_free_connections: Whether to include free/available connections.
     |
     |  update_maint_notifications_config(self, maint_notifications_config: redis.maint_notifications.MaintNotificationsConfig, oss_cluster_maint_notifications_handler: Optional[redis.maint_notifications.OSSMaintNotificationsHandler] = None)
     |      Updates the maintenance notifications configuration.
     |      This method should be called only if the pool was created
     |      without enabling the maintenance notifications and
     |      in a later point in time maintenance notifications
     |      are requested to be enabled.
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors inherited from MaintNotificationsAbstractConnectionPool:
     |
     |  __dict__
     |      dictionary for instance variables
     |
     |  __weakref__
     |      list of weak references to the object

    class ConnectionPoolInterface(abc.ABC)
     |  Method resolution order:
     |      ConnectionPoolInterface
     |      abc.ABC
     |      builtins.object
     |
     |  Methods defined here:
     |
     |  close(self)
     |
     |  disconnect(self, inuse_connections: bool = True)
     |
     |  get_connection(self, command_name: Optional[str], *keys, **options) -> redis.connection.ConnectionInterface
     |
     |  get_connection_count(self) -> list[tuple[int, dict]]
     |      Returns a connection count (both idle and in use).
     |
     |  get_encoder(self)
     |
     |  get_protocol(self)
     |
     |  re_auth_callback(self, token: redis.auth.token.TokenInterface)
     |
     |  release(self, connection: redis.connection.ConnectionInterface)
     |
     |  reset(self)
     |
     |  set_retry(self, retry: redis.retry.Retry)
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors defined here:
     |
     |  __dict__
     |      dictionary for instance variables
     |
     |  __weakref__
     |      list of weak references to the object
     |
     |  ----------------------------------------------------------------------
     |  Data and other attributes defined here:
     |
     |  __abstractmethods__ = frozenset({'close', 'disconnect', 'get_connectio...

    class HiredisRespSerializer(builtins.object)
     |  Methods defined here:
     |
     |  pack(self, *args: List)
     |      Pack a series of arguments into the Redis protocol
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors defined here:
     |
     |  __dict__
     |      dictionary for instance variables
     |
     |  __weakref__
     |      list of weak references to the object

    class MaintNotificationsAbstractConnection(builtins.object)
     |  MaintNotificationsAbstractConnection(maint_notifications_config: Optional[redis.maint_notifications.MaintNotificationsConfig], maint_notifications_pool_handler: Optional[redis.maint_notifications.MaintNotificationsPoolHandler] = None, maintenance_state: 'MaintenanceState' = <MaintenanceState.NONE: 'none'>, maintenance_notification_hash: Optional[int] = None, orig_host_address: Optional[str] = None, orig_socket_timeout: Optional[float] = None, orig_socket_connect_timeout: Optional[float] = None, oss_cluster_maint_notifications_handler: Optional[redis.maint_notifications.OSSMaintNotificationsHandler] = None, parser: Optional[redis._parsers.base.BaseParser] = None, event_dispatcher: Optional[redis.event.EventDispatcher] = None)
     |
     |  Abstract class for handling maintenance notifications logic.
     |  This class is expected to be used as base class together with ConnectionInterface.
     |
     |  This class is intended to be used with multiple inheritance!
     |
     |  All logic related to maintenance notifications is encapsulated in this class.
     |
     |  Methods defined here:
     |
     |  __init__(self, maint_notifications_config: Optional[redis.maint_notifications.MaintNotificationsConfig], maint_notifications_pool_handler: Optional[redis.maint_notifications.MaintNotificationsPoolHandler] = None, maintenance_state: 'MaintenanceState' = <MaintenanceState.NONE: 'none'>, maintenance_notification_hash: Optional[int] = None, orig_host_address: Optional[str] = None, orig_socket_timeout: Optional[float] = None, orig_socket_connect_timeout: Optional[float] = None, oss_cluster_maint_notifications_handler: Optional[redis.maint_notifications.OSSMaintNotificationsHandler] = None, parser: Optional[redis._parsers.base.BaseParser] = None, event_dispatcher: Optional[redis.event.EventDispatcher] = None)
     |      Initialize the maintenance notifications for the connection.
     |
     |      Args:
     |          maint_notifications_config (MaintNotificationsConfig): The configuration for maintenance notifications.
     |          maint_notifications_pool_handler (Optional[MaintNotificationsPoolHandler]): The pool handler for maintenance notifications.
     |          maintenance_state (MaintenanceState): The current maintenance state of the connection.
     |          maintenance_notification_hash (Optional[int]): The current maintenance notification hash of the connection.
     |          orig_host_address (Optional[str]): The original host address of the connection.
     |          orig_socket_timeout (Optional[float]): The original socket timeout of the connection.
     |          orig_socket_connect_timeout (Optional[float]): The original socket connect timeout of the connection.
     |          oss_cluster_maint_notifications_handler (Optional[OSSMaintNotificationsHandler]): The OSS cluster handler for maintenance notifications.
     |          parser (Optional[BaseParser]): The parser to use for maintenance notifications.
     |                  If not provided, the parser from the connection is used.
     |                  This is useful when the parser is created after this object.
     |
     |  activate_maint_notifications_handling_if_enabled(self, check_health=True)
     |
     |  add_maint_start_notification(self, id: int)
     |
     |  add_skipped_end_notification(self, id: int)
     |
     |  disconnect(self, *args, **kwargs)
     |
     |  get_processed_start_notifications(self) -> set
     |
     |  get_protocol(self) -> Union[int, str]
     |      Returns:
     |          The RESP protocol version, or ``None`` if the protocol is not specified,
     |          in which case the server default will be used.
     |
     |  get_resolved_ip(self) -> Optional[str]
     |      Extract the resolved IP address from an
     |      established connection or resolve it from the host.
     |
     |      First tries to get the actual IP from the socket (most accurate),
     |      then falls back to DNS resolution if needed.
     |
     |      Returns:
     |          str: The resolved IP address, or None if it cannot be determined
     |
     |  get_skipped_end_notifications(self) -> set
     |
     |  getpeername(self)
     |      Returns the peer name of the connection.
     |
     |  mark_for_reconnect(self)
     |
     |  read_response(self, disable_decoding=False, *, timeout: Union[float, object] = <object object at 0x0000017B991493E0>, disconnect_on_error=True, push_request=False)
     |
     |  reset_received_notifications(self)
     |
     |  reset_tmp_settings(self, reset_host_address: bool = False, reset_relaxed_timeout: bool = False)
     |
     |  send_command(self, *args, **kwargs)
     |
     |  set_maint_notifications_cluster_handler_for_connection(self, oss_cluster_maint_notifications_handler: redis.maint_notifications.OSSMaintNotificationsHandler)
     |
     |  set_maint_notifications_pool_handler_for_connection(self, maint_notifications_pool_handler: redis.maint_notifications.MaintNotificationsPoolHandler)
     |
     |  set_tmp_settings(self, tmp_host_address: Union[str, object, NoneType] = <object object at 0x0000017B991493E0>, tmp_relaxed_timeout: Optional[float] = -1)
     |      SENTINEL keeps the host unchanged. -1 keeps the relaxed timeout unchanged.
     |
     |  update_current_socket_timeout(self, relaxed_timeout: Optional[float] = None)
     |
     |  update_parser_timeout(self, timeout: Optional[float] = None)
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors defined here:
     |
     |  __dict__
     |      dictionary for instance variables
     |
     |  __weakref__
     |      list of weak references to the object
     |
     |  host
     |
     |  maintenance_state
     |
     |  socket_connect_timeout
     |
     |  socket_timeout

    class MaintNotificationsAbstractConnectionPool(builtins.object)
     |  MaintNotificationsAbstractConnectionPool(maint_notifications_config: Optional[redis.maint_notifications.MaintNotificationsConfig] = None, oss_cluster_maint_notifications_handler: Optional[redis.maint_notifications.OSSMaintNotificationsHandler] = None, **kwargs)
     |
     |  Abstract class for handling maintenance notifications logic.
     |  This class is mixed into the ConnectionPool classes.
     |
     |  This class is not intended to be used directly!
     |
     |  All logic related to maintenance notifications and
     |  connection pool handling is encapsulated in this class.
     |
     |  Methods defined here:
     |
     |  __init__(self, maint_notifications_config: Optional[redis.maint_notifications.MaintNotificationsConfig] = None, oss_cluster_maint_notifications_handler: Optional[redis.maint_notifications.OSSMaintNotificationsHandler] = None, **kwargs)
     |      Initialize self.  See help(type(self)) for accurate signature.
     |
     |  disconnect_free_connections(self, moving_address_src: Optional[str] = None)
     |      Disconnect all free/available connections.
     |      This is used when a cluster node is migrated to a different address.
     |
     |      :param moving_address_src: The address of the node that is being moved.
     |
     |  maint_notifications_enabled(self)
     |      Returns:
     |          True if the maintenance notifications are enabled, False otherwise.
     |          The maintenance notifications config is stored in the pool handler.
     |          If the pool handler is not set, the maintenance notifications are not enabled.
     |
     |  update_active_connections_for_reconnect(self, moving_address_src: Optional[str] = None)
     |      Mark all active connections for reconnect.
     |      This is used when a cluster node is migrated to a different address.
     |
     |      :param moving_address_src: The address of the node that is being moved.
     |
     |  update_connection_kwargs(self, **kwargs)
     |      Update the connection kwargs for all future connections.
     |
     |      This method updates the connection kwargs for all future connections created by the pool.
     |      Existing connections are not affected.
     |
     |  update_connection_settings(self, conn: 'MaintNotificationsAbstractConnection', state: Optional[ForwardRef('MaintenanceState')] = None, maintenance_notification_hash: Optional[int] = None, host_address: Optional[str] = None, relaxed_timeout: Optional[float] = None, update_notification_hash: bool = False, reset_host_address: bool = False, reset_relaxed_timeout: bool = False)
     |      Update the settings for a single connection.
     |
     |  update_connections_settings(self, state: Optional[ForwardRef('MaintenanceState')] = None, maintenance_notification_hash: Optional[int] = None, host_address: Optional[str] = None, relaxed_timeout: Optional[float] = None, matching_address: Optional[str] = None, matching_notification_hash: Optional[int] = None, matching_pattern: Literal['connected_address', 'configured_address', 'notification_hash'] = 'connected_address', update_notification_hash: bool = False, reset_host_address: bool = False, reset_relaxed_timeout: bool = False, include_free_connections: bool = True)
     |      Update the settings for all matching connections in the pool.
     |
     |      This method does not create new connections.
     |      This method does not affect the connection kwargs.
     |
     |      :param state: The maintenance state to set for the connection.
     |      :param maintenance_notification_hash: The hash of the maintenance notification
     |                                             to set for the connection.
     |      :param host_address: The host address to set for the connection.
     |      :param relaxed_timeout: The relaxed timeout to set for the connection.
     |      :param matching_address: The address to match for the connection.
     |      :param matching_notification_hash: The notification hash to match for the connection.
     |      :param matching_pattern: The pattern to match for the connection.
     |      :param update_notification_hash: Whether to update the notification hash for the connection.
     |      :param reset_host_address: Whether to reset the host address to the original address.
     |      :param reset_relaxed_timeout: Whether to reset the relaxed timeout to the original timeout.
     |      :param include_free_connections: Whether to include free/available connections.
     |
     |  update_maint_notifications_config(self, maint_notifications_config: redis.maint_notifications.MaintNotificationsConfig, oss_cluster_maint_notifications_handler: Optional[redis.maint_notifications.OSSMaintNotificationsHandler] = None)
     |      Updates the maintenance notifications configuration.
     |      This method should be called only if the pool was created
     |      without enabling the maintenance notifications and
     |      in a later point in time maintenance notifications
     |      are requested to be enabled.
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors defined here:
     |
     |  __dict__
     |      dictionary for instance variables
     |
     |  __weakref__
     |      list of weak references to the object
     |
     |  connection_kwargs

    class PythonRespSerializer(builtins.object)
     |  PythonRespSerializer(buffer_cutoff, encode) -> None
     |
     |  Methods defined here:
     |
     |  __init__(self, buffer_cutoff, encode) -> None
     |      Initialize self.  See help(type(self)) for accurate signature.
     |
     |  pack(self, *args)
     |      Pack a series of arguments into the Redis protocol
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors defined here:
     |
     |  __dict__
     |      dictionary for instance variables
     |
     |  __weakref__
     |      list of weak references to the object

    class SSLConnection(Connection)
     |  SSLConnection(ssl_keyfile=None, ssl_certfile=None, ssl_cert_reqs='required', ssl_include_verify_flags: Optional[List[ForwardRef('VerifyFlags')]] = None, ssl_exclude_verify_flags: Optional[List[ForwardRef('VerifyFlags')]] = None, ssl_ca_certs=None, ssl_ca_data=None, ssl_check_hostname=True, ssl_ca_path=None, ssl_password=None, ssl_validate_ocsp=False, ssl_validate_ocsp_stapled=False, ssl_ocsp_context=None, ssl_ocsp_expected_cert=None, ssl_min_version=None, ssl_ciphers=None, **kwargs)
     |
     |  Manages SSL connections to and from the Redis server(s).
     |  This class extends the Connection class, adding SSL functionality, and making
     |  use of ssl.SSLContext (https://docs.python.org/3/library/ssl.html#ssl.SSLContext)
     |
     |  Method resolution order:
     |      SSLConnection
     |      Connection
     |      AbstractConnection
     |      MaintNotificationsAbstractConnection
     |      ConnectionInterface
     |      builtins.object
     |
     |  Methods defined here:
     |
     |  __init__(self, ssl_keyfile=None, ssl_certfile=None, ssl_cert_reqs='required', ssl_include_verify_flags: Optional[List[ForwardRef('VerifyFlags')]] = None, ssl_exclude_verify_flags: Optional[List[ForwardRef('VerifyFlags')]] = None, ssl_ca_certs=None, ssl_ca_data=None, ssl_check_hostname=True, ssl_ca_path=None, ssl_password=None, ssl_validate_ocsp=False, ssl_validate_ocsp_stapled=False, ssl_ocsp_context=None, ssl_ocsp_expected_cert=None, ssl_min_version=None, ssl_ciphers=None, **kwargs)
     |      Constructor
     |
     |      Args:
     |          ssl_keyfile: Path to an ssl private key. Defaults to None.
     |          ssl_certfile: Path to an ssl certificate. Defaults to None.
     |          ssl_cert_reqs: The string value for the SSLContext.verify_mode (none, optional, required),
     |                         or an ssl.VerifyMode. Defaults to "required".
     |          ssl_include_verify_flags: A list of flags to be included in the SSLContext.verify_flags. Defaults to None.
     |          ssl_exclude_verify_flags: A list of flags to be excluded from the SSLContext.verify_flags. Defaults to None.
     |          ssl_ca_certs: The path to a file of concatenated CA certificates in PEM format. Defaults to None.
     |          ssl_ca_data: Either an ASCII string of one or more PEM-encoded certificates or a bytes-like object of DER-encoded certificates.
     |          ssl_check_hostname: If set, match the hostname during the SSL handshake. Defaults to True.
     |          ssl_ca_path: The path to a directory containing several CA certificates in PEM format. Defaults to None.
     |          ssl_password: Password for unlocking an encrypted private key. Defaults to None.
     |
     |          ssl_validate_ocsp: If set, perform a full ocsp validation (i.e not a stapled verification)
     |          ssl_validate_ocsp_stapled: If set, perform a validation on a stapled ocsp response
     |          ssl_ocsp_context: A fully initialized OpenSSL.SSL.Context object to be used in verifying the ssl_ocsp_expected_cert
     |          ssl_ocsp_expected_cert: A PEM armoured string containing the expected certificate to be returned from the ocsp verification service.
     |          ssl_min_version: The lowest supported SSL version. It affects the supported SSL versions of the SSLContext. None leaves the default provided by ssl module.
     |          ssl_ciphers: A string listing the ciphers that are allowed to be used. Defaults to None, which means that the default ciphers are used. See https://docs.python.org/3/library/ssl.html#ssl.SSLContext.set_ciphers for more information.
     |
     |      Raises:
     |          RedisError
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from Connection:
     |
     |  repr_pieces(self)
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors inherited from Connection:
     |
     |  host
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from AbstractConnection:
     |
     |  __del__(self)
     |
     |  __repr__(self)
     |      Return repr(self).
     |
     |  can_read(self, timeout: float = 0) -> bool
     |      Poll the socket to see if there's data that can be read.
     |
     |  check_health(self)
     |      Check the health of the connection with a PING/PONG
     |
     |  connect(self)
     |      Connects to the Redis server if not already connected
     |
     |  connect_check_health(self, check_health: bool = True, retry_socket_connect: bool = True)
     |
     |  deregister_connect_callback(self, callback)
     |      De-register a previously registered callback.  It will no-longer receive
     |      notifications on connection events.  Calling this is not required when the
     |      listener goes away, since the callbacks are kept as weak methods.
     |
     |  disconnect(self, *args, **kwargs)
     |      Disconnects from the Redis server
     |
     |  extract_connection_details(self) -> str
     |
     |  get_protocol(self) -> Union[int, str]
     |      Returns:
     |          The RESP protocol version, or ``None`` if the protocol is not specified,
     |          in which case the server default will be used.
     |
     |  mark_for_reconnect(self)
     |      Mark the connection to be reconnected on the next command.
     |      This is useful when a connection is moved to a different node.
     |
     |  on_connect(self)
     |
     |  on_connect_check_health(self, check_health: bool = True)
     |      Initialize the connection, authenticate and select a database
     |
     |  pack_command(self, *args)
     |      Pack a series of arguments into the Redis protocol
     |
     |  pack_commands(self, commands)
     |      Pack multiple commands into the Redis protocol
     |
     |  re_auth(self)
     |
     |  read_response(self, disable_decoding=False, *, timeout: Union[float, object] = <object object at 0x0000017B991493E0>, disconnect_on_error=True, push_request=False)
     |      Read the response from a previously sent command
     |
     |  register_connect_callback(self, callback)
     |      Register a callback to be called when the connection is established either
     |      initially or reconnected.  This allows listeners to issue commands that
     |      are ephemeral to the connection, for example pub/sub subscription or
     |      key tracking.  The callback must be a _method_ and will be kept as
     |      a weak reference.
     |
     |  reset_should_reconnect(self)
     |      Reset the internal flag to False.
     |
     |  send_command(self, *args, **kwargs)
     |      Pack and send a command to the Redis server
     |
     |  send_packed_command(self, command, check_health=True)
     |      Send an already packed command to the Redis server
     |
     |  set_parser(self, parser_class)
     |      Creates a new instance of parser_class with socket size:
     |      _socket_read_size and assigns it to the parser for the connection
     |      :param parser_class: The required parser class
     |
     |  set_re_auth_token(self, token: redis.auth.token.TokenInterface)
     |
     |  should_reconnect(self)
     |      Returns True if the connection should be reconnected.
     |
     |  ----------------------------------------------------------------------
     |  Readonly properties inherited from AbstractConnection:
     |
     |  is_connected
     |      Return ``True`` if the connection to the server is active.
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors inherited from AbstractConnection:
     |
     |  handshake_metadata
     |
     |  socket_connect_timeout
     |
     |  socket_timeout
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from MaintNotificationsAbstractConnection:
     |
     |  activate_maint_notifications_handling_if_enabled(self, check_health=True)
     |
     |  add_maint_start_notification(self, id: int)
     |
     |  add_skipped_end_notification(self, id: int)
     |
     |  get_processed_start_notifications(self) -> set
     |
     |  get_resolved_ip(self) -> Optional[str]
     |      Extract the resolved IP address from an
     |      established connection or resolve it from the host.
     |
     |      First tries to get the actual IP from the socket (most accurate),
     |      then falls back to DNS resolution if needed.
     |
     |      Returns:
     |          str: The resolved IP address, or None if it cannot be determined
     |
     |  get_skipped_end_notifications(self) -> set
     |
     |  getpeername(self)
     |      Returns the peer name of the connection.
     |
     |  reset_received_notifications(self)
     |
     |  reset_tmp_settings(self, reset_host_address: bool = False, reset_relaxed_timeout: bool = False)
     |
     |  set_maint_notifications_cluster_handler_for_connection(self, oss_cluster_maint_notifications_handler: redis.maint_notifications.OSSMaintNotificationsHandler)
     |
     |  set_maint_notifications_pool_handler_for_connection(self, maint_notifications_pool_handler: redis.maint_notifications.MaintNotificationsPoolHandler)
     |
     |  set_tmp_settings(self, tmp_host_address: Union[str, object, NoneType] = <object object at 0x0000017B991493E0>, tmp_relaxed_timeout: Optional[float] = -1)
     |      SENTINEL keeps the host unchanged. -1 keeps the relaxed timeout unchanged.
     |
     |  update_current_socket_timeout(self, relaxed_timeout: Optional[float] = None)
     |
     |  update_parser_timeout(self, timeout: Optional[float] = None)
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors inherited from MaintNotificationsAbstractConnection:
     |
     |  __dict__
     |      dictionary for instance variables
     |
     |  __weakref__
     |      list of weak references to the object
     |
     |  maintenance_state

    class UnixDomainSocketConnection(AbstractConnection)
     |  UnixDomainSocketConnection(path='', socket_timeout=5, **kwargs)
     |
     |  Manages UDS communication to and from a Redis server
     |
     |  Method resolution order:
     |      UnixDomainSocketConnection
     |      AbstractConnection
     |      MaintNotificationsAbstractConnection
     |      ConnectionInterface
     |      builtins.object
     |
     |  Methods defined here:
     |
     |  __init__(self, path='', socket_timeout=5, **kwargs)
     |      Initialize a new Connection.
     |
     |      To specify a retry policy for specific errors, first set
     |      `retry_on_error` to a list of the error/s to retry on, then set
     |      `retry` to a valid `Retry` object.
     |      To retry on TimeoutError, `retry_on_timeout` can also be set to `True`.
     |
     |      Parameters
     |      ----------
     |      driver_info : DriverInfo, optional
     |          Driver metadata for CLIENT SETINFO. If provided, lib_name and lib_version
     |          are ignored. If not provided, a DriverInfo will be created from lib_name
     |          and lib_version. Explicit None disables CLIENT SETINFO.
     |      lib_name : str, optional
     |          **Deprecated.** Use driver_info instead. Library name for CLIENT SETINFO.
     |      lib_version : str, optional
     |          **Deprecated.** Use driver_info instead. Library version for CLIENT SETINFO.
     |
     |  repr_pieces(self)
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from AbstractConnection:
     |
     |  __del__(self)
     |
     |  __repr__(self)
     |      Return repr(self).
     |
     |  can_read(self, timeout: float = 0) -> bool
     |      Poll the socket to see if there's data that can be read.
     |
     |  check_health(self)
     |      Check the health of the connection with a PING/PONG
     |
     |  connect(self)
     |      Connects to the Redis server if not already connected
     |
     |  connect_check_health(self, check_health: bool = True, retry_socket_connect: bool = True)
     |
     |  deregister_connect_callback(self, callback)
     |      De-register a previously registered callback.  It will no-longer receive
     |      notifications on connection events.  Calling this is not required when the
     |      listener goes away, since the callbacks are kept as weak methods.
     |
     |  disconnect(self, *args, **kwargs)
     |      Disconnects from the Redis server
     |
     |  extract_connection_details(self) -> str
     |
     |  get_protocol(self) -> Union[int, str]
     |      Returns:
     |          The RESP protocol version, or ``None`` if the protocol is not specified,
     |          in which case the server default will be used.
     |
     |  mark_for_reconnect(self)
     |      Mark the connection to be reconnected on the next command.
     |      This is useful when a connection is moved to a different node.
     |
     |  on_connect(self)
     |
     |  on_connect_check_health(self, check_health: bool = True)
     |      Initialize the connection, authenticate and select a database
     |
     |  pack_command(self, *args)
     |      Pack a series of arguments into the Redis protocol
     |
     |  pack_commands(self, commands)
     |      Pack multiple commands into the Redis protocol
     |
     |  re_auth(self)
     |
     |  read_response(self, disable_decoding=False, *, timeout: Union[float, object] = <object object at 0x0000017B991493E0>, disconnect_on_error=True, push_request=False)
     |      Read the response from a previously sent command
     |
     |  register_connect_callback(self, callback)
     |      Register a callback to be called when the connection is established either
     |      initially or reconnected.  This allows listeners to issue commands that
     |      are ephemeral to the connection, for example pub/sub subscription or
     |      key tracking.  The callback must be a _method_ and will be kept as
     |      a weak reference.
     |
     |  reset_should_reconnect(self)
     |      Reset the internal flag to False.
     |
     |  send_command(self, *args, **kwargs)
     |      Pack and send a command to the Redis server
     |
     |  send_packed_command(self, command, check_health=True)
     |      Send an already packed command to the Redis server
     |
     |  set_parser(self, parser_class)
     |      Creates a new instance of parser_class with socket size:
     |      _socket_read_size and assigns it to the parser for the connection
     |      :param parser_class: The required parser class
     |
     |  set_re_auth_token(self, token: redis.auth.token.TokenInterface)
     |
     |  should_reconnect(self)
     |      Returns True if the connection should be reconnected.
     |
     |  ----------------------------------------------------------------------
     |  Readonly properties inherited from AbstractConnection:
     |
     |  is_connected
     |      Return ``True`` if the connection to the server is active.
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors inherited from AbstractConnection:
     |
     |  handshake_metadata
     |
     |  socket_connect_timeout
     |
     |  socket_timeout
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from MaintNotificationsAbstractConnection:
     |
     |  activate_maint_notifications_handling_if_enabled(self, check_health=True)
     |
     |  add_maint_start_notification(self, id: int)
     |
     |  add_skipped_end_notification(self, id: int)
     |
     |  get_processed_start_notifications(self) -> set
     |
     |  get_resolved_ip(self) -> Optional[str]
     |      Extract the resolved IP address from an
     |      established connection or resolve it from the host.
     |
     |      First tries to get the actual IP from the socket (most accurate),
     |      then falls back to DNS resolution if needed.
     |
     |      Returns:
     |          str: The resolved IP address, or None if it cannot be determined
     |
     |  get_skipped_end_notifications(self) -> set
     |
     |  getpeername(self)
     |      Returns the peer name of the connection.
     |
     |  reset_received_notifications(self)
     |
     |  reset_tmp_settings(self, reset_host_address: bool = False, reset_relaxed_timeout: bool = False)
     |
     |  set_maint_notifications_cluster_handler_for_connection(self, oss_cluster_maint_notifications_handler: redis.maint_notifications.OSSMaintNotificationsHandler)
     |
     |  set_maint_notifications_pool_handler_for_connection(self, maint_notifications_pool_handler: redis.maint_notifications.MaintNotificationsPoolHandler)
     |
     |  set_tmp_settings(self, tmp_host_address: Union[str, object, NoneType] = <object object at 0x0000017B991493E0>, tmp_relaxed_timeout: Optional[float] = -1)
     |      SENTINEL keeps the host unchanged. -1 keeps the relaxed timeout unchanged.
     |
     |  update_current_socket_timeout(self, relaxed_timeout: Optional[float] = None)
     |
     |  update_parser_timeout(self, timeout: Optional[float] = None)
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors inherited from MaintNotificationsAbstractConnection:
     |
     |  __dict__
     |      dictionary for instance variables
     |
     |  __weakref__
     |      list of weak references to the object
     |
     |  host
     |
     |  maintenance_state

FUNCTIONS
    parse_ssl_verify_flags(value)

    parse_url(url)

    to_bool(value)

DATA
    CRYPTOGRAPHY_AVAILABLE = True
    Callable = typing.Callable
        Deprecated alias to collections.abc.Callable.

        Callable[[int], str] signifies a function that takes a single
        parameter of type int and returns a str.

        The subscription syntax must always be used with exactly two
        values: the argument list and the return type.
        The argument list must be a list of types, a ParamSpec,
        Concatenate or ellipsis. The return type must be a single type.

        There is no syntax to indicate optional or keyword arguments;
        such function types are rarely used as callback types.

    DB_CLIENT_CONNECTION_POOL_NAME = 'db.client.connection.pool.name'
    DB_CLIENT_CONNECTION_STATE = 'db.client.connection.state'
    DEFAULT_RESP_VERSION = 3
    DEFAULT_SOCKET_CONNECT_TIMEOUT = 5
    DEFAULT_SOCKET_READ_SIZE = 32768
    DEFAULT_SOCKET_TIMEOUT = 5
    Dict = typing.Dict
        A generic version of dict.

    FALSE_STRINGS = ('0', 'F', 'FALSE', 'N', 'NO')
    HIREDIS_AVAILABLE = False
    Iterable = typing.Iterable
        A generic version of collections.abc.Iterable.

    List = typing.List
        A generic version of list.

    Literal = typing.Literal
        Special typing form to define literal types (a.k.a. value types).

        This form can be used to indicate to type checkers that the corresponding
        variable or function parameter has a value equivalent to the provided
        literal (or one of several literals)::

            def validate_simple(data: Any) -> Literal[True]:  # always returns True
                ...

            MODE = Literal['r', 'rb', 'w', 'wb']
            def open_helper(file: str, mode: MODE) -> str:
                ...

            open_helper('/some/path', 'r')  # Passes type check
            open_helper('/other/path', 'typo')  # Error in type checker

        Literal[...] cannot be subclassed. At runtime, an arbitrary value
        is allowed as type argument to Literal[...], but type checkers may
        impose restrictions.

    Optional = typing.Optional
        Optional[X] is equivalent to Union[X, None].

    SENTINEL = <object object>
    SSL_AVAILABLE = True
    SYM_CRLF = b'\r\n'
    SYM_DOLLAR = b'$'
    SYM_EMPTY = b''
    SYM_STAR = b'*'
    Type = typing.Type
        Deprecated alias to builtins.type.

        builtins.type or typing.Type can be used to annotate class objects.
        For example, suppose we have the following classes::

            class User: ...  # Abstract base for User classes
            class BasicUser(User): ...
            class ProUser(User): ...
            class TeamUser(User): ...

        And a function that takes a class argument that's a subclass of
        User and returns an instance of the corresponding class::

            def new_user[U](user_class: Type[U]) -> U:
                user = user_class()
                # (Here we could write the user object to a database)
                return user

            joe = new_user(BasicUser)

        At this point the type checker knows that joe has type BasicUser.

    URL_QUERY_ARGUMENT_PARSERS = {'db': <class 'int'>, 'health_check_inter...
    Union = typing.Union
        Union type; Union[X, Y] means either X or Y.

        On Python 3.10 and higher, the | operator
        can also be used to denote unions;
        X | Y means the same thing to the type checker as Union[X, Y].

        To define a union, use e.g. Union[int, str]. Details:
        - The arguments must be types and there must be at least one.
        - None as an argument is a special case and is replaced by
          type(None).
        - Unions of unions are flattened, e.g.::

            assert Union[Union[int, str], float] == Union[int, str, float]

        - Unions of a single argument vanish, e.g.::

            assert Union[int] == int  # The constructor actually returns int

        - Redundant arguments are skipped, e.g.::

            assert Union[int, str, int] == Union[int, str]

        - When comparing unions, the argument order is ignored, e.g.::

            assert Union[int, str] == Union[str, int]

        - You cannot subclass or instantiate a union.
        - You can use Optional[X] as a shorthand for Union[X, None].

    __annotations__ = {'DefaultParser': typing.Type[typing.Union[redis._pa...

FILE
    c:\users\youse\appdata\local\programs\python\python312\lib\site-packages\redis\connection.py

Python Library Documentation: module redis.crc in redis

NAME
    redis.crc

FUNCTIONS
    key_slot(key: Union[bytes, bytearray, memoryview], bucket: int = 16384) -> int
        Calculate key slot for a given key.
        See Keys distribution model in https://redis.io/topics/cluster-spec
        :param key - bytes
        :param bucket - int

DATA
    REDIS_CLUSTER_HASH_SLOTS = 16384
    __all__ = ['key_slot', 'REDIS_CLUSTER_HASH_SLOTS']

FILE
    c:\users\youse\appdata\local\programs\python\python312\lib\site-packages\redis\crc.py

Python Library Documentation: module redis.credentials in redis

NAME
    redis.credentials

CLASSES
    builtins.object
        CredentialProvider
            StreamingCredentialProvider(CredentialProvider, abc.ABC)
            UsernamePasswordCredentialProvider

    class CredentialProvider(builtins.object)
     |  Credentials Provider.
     |
     |  Methods defined here:
     |
     |  get_credentials(self) -> Union[Tuple[str], Tuple[str, str]]
     |
     |  async get_credentials_async(self) -> Union[Tuple[str], Tuple[str, str]]
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors defined here:
     |
     |  __dict__
     |      dictionary for instance variables
     |
     |  __weakref__
     |      list of weak references to the object

    class StreamingCredentialProvider(CredentialProvider, abc.ABC)
     |  Credential provider that streams credentials in the background.
     |
     |  Method resolution order:
     |      StreamingCredentialProvider
     |      CredentialProvider
     |      abc.ABC
     |      builtins.object
     |
     |  Methods defined here:
     |
     |  is_streaming(self) -> bool
     |
     |  on_error(self, callback: Callable[[Exception], NoneType])
     |
     |  on_next(self, callback: Callable[[Any], NoneType])
     |      Specifies the callback that should be invoked
     |      when the next credentials will be retrieved.
     |
     |      :param callback: Callback with
     |      :return:
     |
     |  ----------------------------------------------------------------------
     |  Data and other attributes defined here:
     |
     |  __abstractmethods__ = frozenset({'is_streaming', 'on_error', 'on_next'...
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from CredentialProvider:
     |
     |  get_credentials(self) -> Union[Tuple[str], Tuple[str, str]]
     |
     |  async get_credentials_async(self) -> Union[Tuple[str], Tuple[str, str]]
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors inherited from CredentialProvider:
     |
     |  __dict__
     |      dictionary for instance variables
     |
     |  __weakref__
     |      list of weak references to the object

    class UsernamePasswordCredentialProvider(CredentialProvider)
     |  UsernamePasswordCredentialProvider(username: Optional[str] = None, password: Optional[str] = None)
     |
     |  Simple implementation of CredentialProvider that just wraps static
     |  username and password.
     |
     |  Method resolution order:
     |      UsernamePasswordCredentialProvider
     |      CredentialProvider
     |      builtins.object
     |
     |  Methods defined here:
     |
     |  __init__(self, username: Optional[str] = None, password: Optional[str] = None)
     |      Initialize self.  See help(type(self)) for accurate signature.
     |
     |  get_credentials(self)
     |
     |  async get_credentials_async(self) -> Union[Tuple[str], Tuple[str, str]]
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors inherited from CredentialProvider:
     |
     |  __dict__
     |      dictionary for instance variables
     |
     |  __weakref__
     |      list of weak references to the object

DATA
    Callable = typing.Callable
        Deprecated alias to collections.abc.Callable.

        Callable[[int], str] signifies a function that takes a single
        parameter of type int and returns a str.

        The subscription syntax must always be used with exactly two
        values: the argument list and the return type.
        The argument list must be a list of types, a ParamSpec,
        Concatenate or ellipsis. The return type must be a single type.

        There is no syntax to indicate optional or keyword arguments;
        such function types are rarely used as callback types.

    Optional = typing.Optional
        Optional[X] is equivalent to Union[X, None].

    Tuple = typing.Tuple
        Deprecated alias to builtins.tuple.

        Tuple[X, Y] is the cross-product type of X and Y.

        Example: Tuple[T1, T2] is a tuple of two elements corresponding
        to type variables T1 and T2.  Tuple[int, float, str] is a tuple
        of an int, a float and a string.

        To specify a variable-length tuple of homogeneous type, use Tuple[T, ...].

    Union = typing.Union
        Union type; Union[X, Y] means either X or Y.

        On Python 3.10 and higher, the | operator
        can also be used to denote unions;
        X | Y means the same thing to the type checker as Union[X, Y].

        To define a union, use e.g. Union[int, str]. Details:
        - The arguments must be types and there must be at least one.
        - None as an argument is a special case and is replaced by
          type(None).
        - Unions of unions are flattened, e.g.::

            assert Union[Union[int, str], float] == Union[int, str, float]

        - Unions of a single argument vanish, e.g.::

            assert Union[int] == int  # The constructor actually returns int

        - Redundant arguments are skipped, e.g.::

            assert Union[int, str, int] == Union[int, str]

        - When comparing unions, the argument order is ignored, e.g.::

            assert Union[int, str] == Union[str, int]

        - You cannot subclass or instantiate a union.
        - You can use Optional[X] as a shorthand for Union[X, None].

    logger = <Logger redis.credentials (WARNING)>

FILE
    c:\users\youse\appdata\local\programs\python\python312\lib\site-packages\redis\credentials.py

Python Library Documentation: function default_backoff in module redis.backoff

default_backoff()

Python Library Documentation: module redis.driver_info in redis

NAME
    redis.driver_info

CLASSES
    builtins.object
        DriverInfo

    class DriverInfo(builtins.object)
     |  DriverInfo(name: 'Optional[str] | object' = <object object at 0x0000017B991493E0>, lib_version: 'Optional[str] | object' = <object object at 0x0000017B991493E0>, _upstream: 'List[str]' = <factory>) -> None
     |
     |  Driver information used to build the CLIENT SETINFO LIB-NAME and LIB-VER values.
     |
     |  This class consolidates all driver metadata (redis-py version and upstream drivers)
     |  into a single object that is propagated through connection pools and connections.
     |
     |  The formatted name follows the pattern::
     |
     |      name(driver1_vVersion1;driver2_vVersion2)
     |
     |  Parameters
     |  ----------
     |  name : str, optional
     |      The base library name. If omitted, defaults to "redis-py". If None,
     |      LIB-NAME will not be sent.
     |  lib_version : str, optional
     |      The redis-py library version. If omitted, the version will be determined
     |      automatically from the installed package. If None, LIB-VER will not be sent.
     |
     |  Examples
     |  --------
     |  >>> info = DriverInfo()
     |  >>> info.formatted_name
     |  'redis-py'
     |
     |  >>> info = DriverInfo().add_upstream_driver("django-redis", "5.4.0")
     |  >>> info.formatted_name
     |  'redis-py(django-redis_v5.4.0)'
     |
     |  >>> info = DriverInfo(lib_version="5.0.0")
     |  >>> info.lib_version
     |  '5.0.0'
     |
     |  Methods defined here:
     |
     |  __eq__(self, other)
     |      Return self==value.
     |
     |  __init__(self, name: 'Optional[str] | object' = <object object at 0x0000017B991493E0>, lib_version: 'Optional[str] | object' = <object object at 0x0000017B991493E0>, _upstream: 'List[str]' = <factory>) -> None
     |      Initialize self.  See help(type(self)) for accurate signature.
     |
     |  __post_init__(self)
     |      Initialize default metadata if not explicitly provided.
     |
     |  __repr__(self)
     |      Return repr(self).
     |
     |  add_upstream_driver(self, driver_name: 'str', driver_version: 'str') -> "'DriverInfo'"
     |      Add an upstream driver to this instance and return self.
     |
     |      The most recently added driver appears first in :pyattr:`formatted_name`.
     |
     |  ----------------------------------------------------------------------
     |  Readonly properties defined here:
     |
     |  formatted_name
     |      Return the base name with upstream drivers encoded, if any.
     |
     |      With no upstream drivers, this is just :pyattr:`name`. Otherwise::
     |
     |          name(driver1_vX;driver2_vY)
     |
     |  upstream_drivers
     |      Return a copy of the upstream driver entries.
     |
     |      Each entry is in the form ``"driver-name_vversion"``.
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors defined here:
     |
     |  __dict__
     |      dictionary for instance variables
     |
     |  __weakref__
     |      list of weak references to the object
     |
     |  ----------------------------------------------------------------------
     |  Data and other attributes defined here:
     |
     |  __annotations__ = {'_upstream': 'List[str]', 'lib_version': 'Optional[...
     |
     |  __dataclass_fields__ = {'_upstream': Field(name='_upstream',type='List...
     |
     |  __dataclass_params__ = _DataclassParams(init=True,repr=True,eq=True,or...
     |
     |  __hash__ = None
     |
     |  __match_args__ = ('name', 'lib_version', '_upstream')
     |
     |  lib_version = <object object>
     |
     |  name = <object object>

FUNCTIONS
    resolve_driver_info(driver_info: 'Optional[DriverInfo] | object' = <object object at 0x0000017B991493E0>, lib_name: 'Optional[str] | object' = <object object at 0x0000017B991493E0>, lib_version: 'Optional[str] | object' = <object object at 0x0000017B991493E0>) -> 'Optional[DriverInfo]'
        Resolve driver_info from parameters.

        If driver_info is provided, use it. Otherwise, create DriverInfo from
        lib_name and lib_version (using defaults only for sentinel values).

        Parameters
        ----------
        driver_info : DriverInfo, optional
            The DriverInfo instance to use
        lib_name : str, optional
            The library name (default: "redis-py")
        lib_version : str, optional
            The library version (default: auto-detected)

        Returns
        -------
        DriverInfo, optional
            The resolved DriverInfo instance

DATA
    List = typing.List
        A generic version of list.

    Optional = typing.Optional
        Optional[X] is equivalent to Union[X, None].

    SENTINEL = <object object>

FILE
    c:\users\youse\appdata\local\programs\python\python312\lib\site-packages\redis\driver_info.py

Python Library Documentation: module redis.event in redis

NAME
    redis.event

CLASSES
    abc.ABC(builtins.object)
        AsyncEventListenerInterface
            AsyncReAuthConnectionListener
        EventDispatcherInterface
            EventDispatcher
        EventListenerInterface
            InitializeConnectionCountObservability
            ReAuthConnectionListener
            RegisterReAuthForAsyncClusterNodes
            RegisterReAuthForPooledConnections
            RegisterReAuthForPubSub
            RegisterReAuthForSingleConnection
    builtins.Exception(builtins.BaseException)
        EventException
    builtins.object
        AfterAsyncClusterInstantiationEvent
        AfterConnectionReleasedEvent
            AsyncAfterConnectionReleasedEvent
        AfterPooledConnectionsInstantiationEvent
        AfterPubSubConnectionInstantiationEvent
        AfterSingleConnectionInstantiationEvent
        AfterSlotsCacheRefreshEvent
            AsyncAfterSlotsCacheRefreshEvent
        OnCommandsFailEvent
            AsyncOnCommandsFailEvent
    enum.Enum(builtins.object)
        ClientType

    class AfterAsyncClusterInstantiationEvent(builtins.object)
     |  AfterAsyncClusterInstantiationEvent(nodes: dict, credential_provider: Optional[redis.credentials.CredentialProvider] = None)
     |
     |  Event that will be fired after async cluster instance was created.
     |
     |  Async cluster doesn't use connection pools,
     |  instead ClusterNode object manages connections.
     |
     |  Methods defined here:
     |
     |  __init__(self, nodes: dict, credential_provider: Optional[redis.credentials.CredentialProvider] = None)
     |      Initialize self.  See help(type(self)) for accurate signature.
     |
     |  ----------------------------------------------------------------------
     |  Readonly properties defined here:
     |
     |  credential_provider
     |
     |  nodes
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors defined here:
     |
     |  __dict__
     |      dictionary for instance variables
     |
     |  __weakref__
     |      list of weak references to the object

    class AfterConnectionReleasedEvent(builtins.object)
     |  AfterConnectionReleasedEvent(connection)
     |
     |  Event that will be fired before each command execution.
     |
     |  Methods defined here:
     |
     |  __init__(self, connection)
     |      Initialize self.  See help(type(self)) for accurate signature.
     |
     |  ----------------------------------------------------------------------
     |  Readonly properties defined here:
     |
     |  connection
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors defined here:
     |
     |  __dict__
     |      dictionary for instance variables
     |
     |  __weakref__
     |      list of weak references to the object

    class AfterPooledConnectionsInstantiationEvent(builtins.object)
     |  AfterPooledConnectionsInstantiationEvent(connection_pools: List, client_type: redis.event.ClientType, credential_provider: Optional[redis.credentials.CredentialProvider] = None)
     |
     |  Event that will be fired after pooled connection instances was created.
     |
     |  Methods defined here:
     |
     |  __init__(self, connection_pools: List, client_type: redis.event.ClientType, credential_provider: Optional[redis.credentials.CredentialProvider] = None)
     |      Initialize self.  See help(type(self)) for accurate signature.
     |
     |  ----------------------------------------------------------------------
     |  Readonly properties defined here:
     |
     |  client_type
     |
     |  connection_pools
     |
     |  credential_provider
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors defined here:
     |
     |  __dict__
     |      dictionary for instance variables
     |
     |  __weakref__
     |      list of weak references to the object

    class AfterPubSubConnectionInstantiationEvent(builtins.object)
     |  AfterPubSubConnectionInstantiationEvent(pubsub_connection, connection_pool, client_type: redis.event.ClientType, connection_lock: Union[RLock, asyncio.locks.Lock])
     |
     |  Methods defined here:
     |
     |  __init__(self, pubsub_connection, connection_pool, client_type: redis.event.ClientType, connection_lock: Union[RLock, asyncio.locks.Lock])
     |      Initialize self.  See help(type(self)) for accurate signature.
     |
     |  ----------------------------------------------------------------------
     |  Readonly properties defined here:
     |
     |  client_type
     |
     |  connection_lock
     |
     |  connection_pool
     |
     |  pubsub_connection
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors defined here:
     |
     |  __dict__
     |      dictionary for instance variables
     |
     |  __weakref__
     |      list of weak references to the object

    class AfterSingleConnectionInstantiationEvent(builtins.object)
     |  AfterSingleConnectionInstantiationEvent(connection, client_type: redis.event.ClientType, connection_lock: Union[RLock, asyncio.locks.Lock])
     |
     |  Event that will be fired after single connection instances was created.
     |
     |  :param connection_lock: For sync client thread-lock should be provided,
     |  for async asyncio.Lock
     |
     |  Methods defined here:
     |
     |  __init__(self, connection, client_type: redis.event.ClientType, connection_lock: Union[RLock, asyncio.locks.Lock])
     |      Initialize self.  See help(type(self)) for accurate signature.
     |
     |  ----------------------------------------------------------------------
     |  Readonly properties defined here:
     |
     |  client_type
     |
     |  connection
     |
     |  connection_lock
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors defined here:
     |
     |  __dict__
     |      dictionary for instance variables
     |
     |  __weakref__
     |      list of weak references to the object

    class AfterSlotsCacheRefreshEvent(builtins.object)
     |  Event fired after NodesManager's slots cache is refreshed, either via a
     |  full re-initialization or a MOVED-driven slot re-mapping. Signal-only;
     |  carries no payload. Listeners typically reconcile per-node bookkeeping
     |  (e.g. ClusterPubSub shard subscriptions).
     |
     |  Data descriptors defined here:
     |
     |  __dict__
     |      dictionary for instance variables
     |
     |  __weakref__
     |      list of weak references to the object

    class AsyncAfterConnectionReleasedEvent(AfterConnectionReleasedEvent)
     |  AsyncAfterConnectionReleasedEvent(connection)
     |
     |  Method resolution order:
     |      AsyncAfterConnectionReleasedEvent
     |      AfterConnectionReleasedEvent
     |      builtins.object
     |
     |  Methods inherited from AfterConnectionReleasedEvent:
     |
     |  __init__(self, connection)
     |      Initialize self.  See help(type(self)) for accurate signature.
     |
     |  ----------------------------------------------------------------------
     |  Readonly properties inherited from AfterConnectionReleasedEvent:
     |
     |  connection
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors inherited from AfterConnectionReleasedEvent:
     |
     |  __dict__
     |      dictionary for instance variables
     |
     |  __weakref__
     |      list of weak references to the object

    class AsyncAfterSlotsCacheRefreshEvent(AfterSlotsCacheRefreshEvent)
     |  Method resolution order:
     |      AsyncAfterSlotsCacheRefreshEvent
     |      AfterSlotsCacheRefreshEvent
     |      builtins.object
     |
     |  Data descriptors inherited from AfterSlotsCacheRefreshEvent:
     |
     |  __dict__
     |      dictionary for instance variables
     |
     |  __weakref__
     |      list of weak references to the object

    class AsyncEventListenerInterface(abc.ABC)
     |  Represents an async listener for given event object.
     |
     |  Method resolution order:
     |      AsyncEventListenerInterface
     |      abc.ABC
     |      builtins.object
     |
     |  Methods defined here:
     |
     |  async listen(self, event: object)
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors defined here:
     |
     |  __dict__
     |      dictionary for instance variables
     |
     |  __weakref__
     |      list of weak references to the object
     |
     |  ----------------------------------------------------------------------
     |  Data and other attributes defined here:
     |
     |  __abstractmethods__ = frozenset({'listen'})

    class AsyncOnCommandsFailEvent(OnCommandsFailEvent)
     |  AsyncOnCommandsFailEvent(commands: tuple, exception: Exception)
     |
     |  Method resolution order:
     |      AsyncOnCommandsFailEvent
     |      OnCommandsFailEvent
     |      builtins.object
     |
     |  Methods inherited from OnCommandsFailEvent:
     |
     |  __init__(self, commands: tuple, exception: Exception)
     |      Initialize self.  See help(type(self)) for accurate signature.
     |
     |  ----------------------------------------------------------------------
     |  Readonly properties inherited from OnCommandsFailEvent:
     |
     |  commands
     |
     |  exception
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors inherited from OnCommandsFailEvent:
     |
     |  __dict__
     |      dictionary for instance variables
     |
     |  __weakref__
     |      list of weak references to the object

    class AsyncReAuthConnectionListener(AsyncEventListenerInterface)
     |  Async listener that performs re-authentication of given connection.
     |
     |  Method resolution order:
     |      AsyncReAuthConnectionListener
     |      AsyncEventListenerInterface
     |      abc.ABC
     |      builtins.object
     |
     |  Methods defined here:
     |
     |  async listen(self, event: redis.event.AsyncAfterConnectionReleasedEvent)
     |
     |  ----------------------------------------------------------------------
     |  Data and other attributes defined here:
     |
     |  __abstractmethods__ = frozenset()
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors inherited from AsyncEventListenerInterface:
     |
     |  __dict__
     |      dictionary for instance variables
     |
     |  __weakref__
     |      list of weak references to the object

    class ClientType(enum.Enum)
     |  ClientType(*values)
     |
     |  Method resolution order:
     |      ClientType
     |      enum.Enum
     |      builtins.object
     |
     |  Data and other attributes defined here:
     |
     |  ASYNC = <ClientType.ASYNC: ('async',)>
     |
     |  SYNC = <ClientType.SYNC: ('sync',)>
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors inherited from enum.Enum:
     |
     |  name
     |      The name of the Enum member.
     |
     |  value
     |      The value of the Enum member.
     |
     |  ----------------------------------------------------------------------
     |  Static methods inherited from enum.EnumType:
     |
     |  __contains__(value)
     |      Return True if `value` is in `cls`.
     |
     |      `value` is in `cls` if:
     |      1) `value` is a member of `cls`, or
     |      2) `value` is the value of one of the `cls`'s members.
     |
     |  __getitem__(name)
     |      Return the member matching `name`.
     |
     |  __iter__()
     |      Return members in definition order.
     |
     |  __len__()
     |      Return the number of members (no aliases)
     |
     |  ----------------------------------------------------------------------
     |  Readonly properties inherited from enum.EnumType:
     |
     |  __members__
     |      Returns a mapping of member name->value.
     |
     |      This mapping lists all enum members, including aliases. Note that this
     |      is a read-only view of the internal mapping.

    class EventDispatcher(EventDispatcherInterface)
     |  EventDispatcher(event_listeners: Optional[Dict[Type[object], List[redis.event.EventListenerInterface]]] = None)
     |
     |  Method resolution order:
     |      EventDispatcher
     |      EventDispatcherInterface
     |      abc.ABC
     |      builtins.object
     |
     |  Methods defined here:
     |
     |  __init__(self, event_listeners: Optional[Dict[Type[object], List[redis.event.EventListenerInterface]]] = None)
     |      Dispatcher that dispatches events to listeners associated with given event.
     |
     |  dispatch(self, event: object)
     |
     |  async dispatch_async(self, event: object)
     |
     |  register_listeners(self, mappings: Dict[Type[object], List[Union[redis.event.EventListenerInterface, redis.event.AsyncEventListenerInterface]]])
     |      Register additional listeners.
     |
     |  unregister_listeners(self, mappings: Dict[Type[object], List[Union[redis.event.EventListenerInterface, redis.event.AsyncEventListenerInterface]]])
     |      Remove previously registered listeners by identity.
     |
     |  ----------------------------------------------------------------------
     |  Data and other attributes defined here:
     |
     |  __abstractmethods__ = frozenset()
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors inherited from EventDispatcherInterface:
     |
     |  __dict__
     |      dictionary for instance variables
     |
     |  __weakref__
     |      list of weak references to the object

    class EventDispatcherInterface(abc.ABC)
     |  Represents a dispatcher that dispatches events to listeners
     |  associated with given event.
     |
     |  Method resolution order:
     |      EventDispatcherInterface
     |      abc.ABC
     |      builtins.object
     |
     |  Methods defined here:
     |
     |  dispatch(self, event: object)
     |
     |  async dispatch_async(self, event: object)
     |
     |  register_listeners(self, mappings: Dict[Type[object], List[Union[redis.event.EventListenerInterface, redis.event.AsyncEventListenerInterface]]])
     |      Register additional listeners.
     |
     |  unregister_listeners(self, mappings: Dict[Type[object], List[Union[redis.event.EventListenerInterface, redis.event.AsyncEventListenerInterface]]])
     |      Remove previously registered listeners by identity.
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors defined here:
     |
     |  __dict__
     |      dictionary for instance variables
     |
     |  __weakref__
     |      list of weak references to the object
     |
     |  ----------------------------------------------------------------------
     |  Data and other attributes defined here:
     |
     |  __abstractmethods__ = frozenset({'dispatch', 'dispatch_async', 'regist...

    class EventException(builtins.Exception)
     |  EventException(exception: Exception, event: object)
     |
     |  Exception wrapper that adds an event object into exception context.
     |
     |  Method resolution order:
     |      EventException
     |      builtins.Exception
     |      builtins.BaseException
     |      builtins.object
     |
     |  Methods defined here:
     |
     |  __init__(self, exception: Exception, event: object)
     |      Initialize self.  See help(type(self)) for accurate signature.
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors defined here:
     |
     |  __weakref__
     |      list of weak references to the object
     |
     |  ----------------------------------------------------------------------
     |  Static methods inherited from builtins.Exception:
     |
     |  __new__(*args, **kwargs) class method of builtins.Exception
     |      Create and return a new object.  See help(type) for accurate signature.
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from builtins.BaseException:
     |
     |  __getattribute__(self, name, /)
     |      Return getattr(self, name).
     |
     |  __reduce__(...)
     |      Helper for pickle.
     |
     |  __repr__(self, /)
     |      Return repr(self).
     |
     |  __setstate__(...)
     |
     |  __str__(self, /)
     |      Return str(self).
     |
     |  add_note(...)
     |      Exception.add_note(note) --
     |      add a note to the exception
     |
     |  with_traceback(...)
     |      Exception.with_traceback(tb) --
     |      set self.__traceback__ to tb and return self.
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors inherited from builtins.BaseException:
     |
     |  __cause__
     |      exception cause
     |
     |  __context__
     |      exception context
     |
     |  __dict__
     |
     |  __suppress_context__
     |
     |  __traceback__
     |
     |  args

    class EventListenerInterface(abc.ABC)
     |  Represents a listener for given event object.
     |
     |  Method resolution order:
     |      EventListenerInterface
     |      abc.ABC
     |      builtins.object
     |
     |  Methods defined here:
     |
     |  listen(self, event: object)
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors defined here:
     |
     |  __dict__
     |      dictionary for instance variables
     |
     |  __weakref__
     |      list of weak references to the object
     |
     |  ----------------------------------------------------------------------
     |  Data and other attributes defined here:
     |
     |  __abstractmethods__ = frozenset({'listen'})

    class InitializeConnectionCountObservability(EventListenerInterface)
     |  Listener that initializes connection count observability.
     |
     |  Method resolution order:
     |      InitializeConnectionCountObservability
     |      EventListenerInterface
     |      abc.ABC
     |      builtins.object
     |
     |  Methods defined here:
     |
     |  listen(self, event: redis.event.AfterPooledConnectionsInstantiationEvent)
     |      # Create regular wrapper for sync functions
     |
     |  ----------------------------------------------------------------------
     |  Data and other attributes defined here:
     |
     |  __abstractmethods__ = frozenset()
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors inherited from EventListenerInterface:
     |
     |  __dict__
     |      dictionary for instance variables
     |
     |  __weakref__
     |      list of weak references to the object

    class OnCommandsFailEvent(builtins.object)
     |  OnCommandsFailEvent(commands: tuple, exception: Exception)
     |
     |  Event fired whenever a command fails during the execution.
     |
     |  Methods defined here:
     |
     |  __init__(self, commands: tuple, exception: Exception)
     |      Initialize self.  See help(type(self)) for accurate signature.
     |
     |  ----------------------------------------------------------------------
     |  Readonly properties defined here:
     |
     |  commands
     |
     |  exception
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors defined here:
     |
     |  __dict__
     |      dictionary for instance variables
     |
     |  __weakref__
     |      list of weak references to the object

    class ReAuthConnectionListener(EventListenerInterface)
     |  Listener that performs re-authentication of given connection.
     |
     |  Method resolution order:
     |      ReAuthConnectionListener
     |      EventListenerInterface
     |      abc.ABC
     |      builtins.object
     |
     |  Methods defined here:
     |
     |  listen(self, event: redis.event.AfterConnectionReleasedEvent)
     |
     |  ----------------------------------------------------------------------
     |  Data and other attributes defined here:
     |
     |  __abstractmethods__ = frozenset()
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors inherited from EventListenerInterface:
     |
     |  __dict__
     |      dictionary for instance variables
     |
     |  __weakref__
     |      list of weak references to the object

    class RegisterReAuthForAsyncClusterNodes(EventListenerInterface)
     |  Method resolution order:
     |      RegisterReAuthForAsyncClusterNodes
     |      EventListenerInterface
     |      abc.ABC
     |      builtins.object
     |
     |  Methods defined here:
     |
     |  __init__(self)
     |      Initialize self.  See help(type(self)) for accurate signature.
     |
     |  listen(self, event: redis.event.AfterAsyncClusterInstantiationEvent)
     |
     |  ----------------------------------------------------------------------
     |  Data and other attributes defined here:
     |
     |  __abstractmethods__ = frozenset()
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors inherited from EventListenerInterface:
     |
     |  __dict__
     |      dictionary for instance variables
     |
     |  __weakref__
     |      list of weak references to the object

    class RegisterReAuthForPooledConnections(EventListenerInterface)
     |  Listener that registers a re-authentication callback for pooled connections.
     |  Required by :class:`StreamingCredentialProvider`.
     |
     |  Method resolution order:
     |      RegisterReAuthForPooledConnections
     |      EventListenerInterface
     |      abc.ABC
     |      builtins.object
     |
     |  Methods defined here:
     |
     |  __init__(self)
     |      Initialize self.  See help(type(self)) for accurate signature.
     |
     |  listen(self, event: redis.event.AfterPooledConnectionsInstantiationEvent)
     |
     |  ----------------------------------------------------------------------
     |  Data and other attributes defined here:
     |
     |  __abstractmethods__ = frozenset()
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors inherited from EventListenerInterface:
     |
     |  __dict__
     |      dictionary for instance variables
     |
     |  __weakref__
     |      list of weak references to the object

    class RegisterReAuthForPubSub(EventListenerInterface)
     |  Method resolution order:
     |      RegisterReAuthForPubSub
     |      EventListenerInterface
     |      abc.ABC
     |      builtins.object
     |
     |  Methods defined here:
     |
     |  __init__(self)
     |      Initialize self.  See help(type(self)) for accurate signature.
     |
     |  listen(self, event: redis.event.AfterPubSubConnectionInstantiationEvent)
     |
     |  ----------------------------------------------------------------------
     |  Data and other attributes defined here:
     |
     |  __abstractmethods__ = frozenset()
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors inherited from EventListenerInterface:
     |
     |  __dict__
     |      dictionary for instance variables
     |
     |  __weakref__
     |      list of weak references to the object

    class RegisterReAuthForSingleConnection(EventListenerInterface)
     |  Listener that registers a re-authentication callback for single connection.
     |  Required by :class:`StreamingCredentialProvider`.
     |
     |  Method resolution order:
     |      RegisterReAuthForSingleConnection
     |      EventListenerInterface
     |      abc.ABC
     |      builtins.object
     |
     |  Methods defined here:
     |
     |  __init__(self)
     |      Initialize self.  See help(type(self)) for accurate signature.
     |
     |  listen(self, event: redis.event.AfterSingleConnectionInstantiationEvent)
     |
     |  ----------------------------------------------------------------------
     |  Data and other attributes defined here:
     |
     |  __abstractmethods__ = frozenset()
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors inherited from EventListenerInterface:
     |
     |  __dict__
     |      dictionary for instance variables
     |
     |  __weakref__
     |      list of weak references to the object

DATA
    Dict = typing.Dict
        A generic version of dict.

    List = typing.List
        A generic version of list.

    Optional = typing.Optional
        Optional[X] is equivalent to Union[X, None].

    Type = typing.Type
        Deprecated alias to builtins.type.

        builtins.type or typing.Type can be used to annotate class objects.
        For example, suppose we have the following classes::

            class User: ...  # Abstract base for User classes
            class BasicUser(User): ...
            class ProUser(User): ...
            class TeamUser(User): ...

        And a function that takes a class argument that's a subclass of
        User and returns an instance of the corresponding class::

            def new_user[U](user_class: Type[U]) -> U:
                user = user_class()
                # (Here we could write the user object to a database)
                return user

            joe = new_user(BasicUser)

        At this point the type checker knows that joe has type BasicUser.

    Union = typing.Union
        Union type; Union[X, Y] means either X or Y.

        On Python 3.10 and higher, the | operator
        can also be used to denote unions;
        X | Y means the same thing to the type checker as Union[X, Y].

        To define a union, use e.g. Union[int, str]. Details:
        - The arguments must be types and there must be at least one.
        - None as an argument is a special case and is replaced by
          type(None).
        - Unions of unions are flattened, e.g.::

            assert Union[Union[int, str], float] == Union[int, str, float]

        - Unions of a single argument vanish, e.g.::

            assert Union[int] == int  # The constructor actually returns int

        - Redundant arguments are skipped, e.g.::

            assert Union[int, str, int] == Union[int, str]

        - When comparing unions, the argument order is ignored, e.g.::

            assert Union[int, str] == Union[str, int]

        - You cannot subclass or instantiate a union.
        - You can use Optional[X] as a shorthand for Union[X, None].

FILE
    c:\users\youse\appdata\local\programs\python\python312\lib\site-packages\redis\event.py

Python Library Documentation: module redis.exceptions in redis

NAME
    redis.exceptions

CLASSES
    builtins.Exception(builtins.BaseException)
        ChildDeadlockedError
        IncorrectPolicyType
        RedisClusterException
            CrossSlotTransactionError
            InvalidPipelineStack
            SlotNotCoveredError
        RedisError
            ClusterError
                ClusterDownError(ClusterError, ResponseError)
                    MasterDownError
            ConnectionError
                AuthenticationError
                AuthorizationError
                BusyLoadingError
                ExternalAuthProviderError
                MaxConnectionsError
            DataError
            InvalidResponse
            LockError(RedisError, builtins.ValueError)
                LockNotOwnedError
            PubSubError
            ResponseError
                AskError
                    MovedError
                AuthenticationWrongNumberOfArgsError
                ClusterCrossSlotError
                ExecAbortError
                ModuleError
                NoPermissionError
                NoScriptError
                NoSuchFieldsetError
                OutOfMemoryError
                ReadOnlyError
                TryAgainError
            TimeoutError
            WatchError
    enum.Enum(builtins.object)
        ExceptionType

    class AskError(ResponseError)
     |  AskError(resp, status_code: str | None = None)
     |
     |  Error indicated ASK error received from cluster.
     |  When a slot is set as MIGRATING, the node will accept all queries that
     |  pertain to this hash slot, but only if the key in question exists,
     |  otherwise the query is forwarded using a -ASK redirection to the node that
     |  is target of the migration.
     |
     |  src node: MIGRATING to dst node
     |      get > ASK error
     |      ask dst node > ASKING command
     |  dst node: IMPORTING from src node
     |      asking command only affects next command
     |      any op will be allowed after asking command
     |
     |  Method resolution order:
     |      AskError
     |      ResponseError
     |      RedisError
     |      builtins.Exception
     |      builtins.BaseException
     |      builtins.object
     |
     |  Methods defined here:
     |
     |  __init__(self, resp, status_code: str | None = None)
     |      should only redirect to master node
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from RedisError:
     |
     |  __repr__(self)
     |      Return repr(self).
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors inherited from RedisError:
     |
     |  __weakref__
     |      list of weak references to the object
     |
     |  ----------------------------------------------------------------------
     |  Static methods inherited from builtins.Exception:
     |
     |  __new__(*args, **kwargs) class method of builtins.Exception
     |      Create and return a new object.  See help(type) for accurate signature.
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from builtins.BaseException:
     |
     |  __getattribute__(self, name, /)
     |      Return getattr(self, name).
     |
     |  __reduce__(...)
     |      Helper for pickle.
     |
     |  __setstate__(...)
     |
     |  __str__(self, /)
     |      Return str(self).
     |
     |  add_note(...)
     |      Exception.add_note(note) --
     |      add a note to the exception
     |
     |  with_traceback(...)
     |      Exception.with_traceback(tb) --
     |      set self.__traceback__ to tb and return self.
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors inherited from builtins.BaseException:
     |
     |  __cause__
     |      exception cause
     |
     |  __context__
     |      exception context
     |
     |  __dict__
     |
     |  __suppress_context__
     |
     |  __traceback__
     |
     |  args

    class AuthenticationError(ConnectionError)
     |  AuthenticationError(*args, status_code: str | None = None)
     |
     |  Method resolution order:
     |      AuthenticationError
     |      ConnectionError
     |      RedisError
     |      builtins.Exception
     |      builtins.BaseException
     |      builtins.object
     |
     |  Methods defined here:
     |
     |  __init__(self, *args, status_code: str | None = None)
     |      Initialize self.  See help(type(self)) for accurate signature.
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from RedisError:
     |
     |  __repr__(self)
     |      Return repr(self).
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors inherited from RedisError:
     |
     |  __weakref__
     |      list of weak references to the object
     |
     |  ----------------------------------------------------------------------
     |  Static methods inherited from builtins.Exception:
     |
     |  __new__(*args, **kwargs) class method of builtins.Exception
     |      Create and return a new object.  See help(type) for accurate signature.
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from builtins.BaseException:
     |
     |  __getattribute__(self, name, /)
     |      Return getattr(self, name).
     |
     |  __reduce__(...)
     |      Helper for pickle.
     |
     |  __setstate__(...)
     |
     |  __str__(self, /)
     |      Return str(self).
     |
     |  add_note(...)
     |      Exception.add_note(note) --
     |      add a note to the exception
     |
     |  with_traceback(...)
     |      Exception.with_traceback(tb) --
     |      set self.__traceback__ to tb and return self.
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors inherited from builtins.BaseException:
     |
     |  __cause__
     |      exception cause
     |
     |  __context__
     |      exception context
     |
     |  __dict__
     |
     |  __suppress_context__
     |
     |  __traceback__
     |
     |  args

    class AuthenticationWrongNumberOfArgsError(ResponseError)
     |  AuthenticationWrongNumberOfArgsError(*args, status_code: str | None = None)
     |
     |  An error to indicate that the wrong number of args
     |  were sent to the AUTH command
     |
     |  Method resolution order:
     |      AuthenticationWrongNumberOfArgsError
     |      ResponseError
     |      RedisError
     |      builtins.Exception
     |      builtins.BaseException
     |      builtins.object
     |
     |  Methods defined here:
     |
     |  __init__(self, *args, status_code: str | None = None)
     |      Initialize self.  See help(type(self)) for accurate signature.
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from RedisError:
     |
     |  __repr__(self)
     |      Return repr(self).
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors inherited from RedisError:
     |
     |  __weakref__
     |      list of weak references to the object
     |
     |  ----------------------------------------------------------------------
     |  Static methods inherited from builtins.Exception:
     |
     |  __new__(*args, **kwargs) class method of builtins.Exception
     |      Create and return a new object.  See help(type) for accurate signature.
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from builtins.BaseException:
     |
     |  __getattribute__(self, name, /)
     |      Return getattr(self, name).
     |
     |  __reduce__(...)
     |      Helper for pickle.
     |
     |  __setstate__(...)
     |
     |  __str__(self, /)
     |      Return str(self).
     |
     |  add_note(...)
     |      Exception.add_note(note) --
     |      add a note to the exception
     |
     |  with_traceback(...)
     |      Exception.with_traceback(tb) --
     |      set self.__traceback__ to tb and return self.
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors inherited from builtins.BaseException:
     |
     |  __cause__
     |      exception cause
     |
     |  __context__
     |      exception context
     |
     |  __dict__
     |
     |  __suppress_context__
     |
     |  __traceback__
     |
     |  args

    class AuthorizationError(ConnectionError)
     |  AuthorizationError(*args, status_code: str | None = None)
     |
     |  Method resolution order:
     |      AuthorizationError
     |      ConnectionError
     |      RedisError
     |      builtins.Exception
     |      builtins.BaseException
     |      builtins.object
     |
     |  Methods defined here:
     |
     |  __init__(self, *args, status_code: str | None = None)
     |      Initialize self.  See help(type(self)) for accurate signature.
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from RedisError:
     |
     |  __repr__(self)
     |      Return repr(self).
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors inherited from RedisError:
     |
     |  __weakref__
     |      list of weak references to the object
     |
     |  ----------------------------------------------------------------------
     |  Static methods inherited from builtins.Exception:
     |
     |  __new__(*args, **kwargs) class method of builtins.Exception
     |      Create and return a new object.  See help(type) for accurate signature.
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from builtins.BaseException:
     |
     |  __getattribute__(self, name, /)
     |      Return getattr(self, name).
     |
     |  __reduce__(...)
     |      Helper for pickle.
     |
     |  __setstate__(...)
     |
     |  __str__(self, /)
     |      Return str(self).
     |
     |  add_note(...)
     |      Exception.add_note(note) --
     |      add a note to the exception
     |
     |  with_traceback(...)
     |      Exception.with_traceback(tb) --
     |      set self.__traceback__ to tb and return self.
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors inherited from builtins.BaseException:
     |
     |  __cause__
     |      exception cause
     |
     |  __context__
     |      exception context
     |
     |  __dict__
     |
     |  __suppress_context__
     |
     |  __traceback__
     |
     |  args

    class BusyLoadingError(ConnectionError)
     |  BusyLoadingError(*args, status_code: str | None = None)
     |
     |  Method resolution order:
     |      BusyLoadingError
     |      ConnectionError
     |      RedisError
     |      builtins.Exception
     |      builtins.BaseException
     |      builtins.object
     |
     |  Methods defined here:
     |
     |  __init__(self, *args, status_code: str | None = None)
     |      Initialize self.  See help(type(self)) for accurate signature.
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from RedisError:
     |
     |  __repr__(self)
     |      Return repr(self).
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors inherited from RedisError:
     |
     |  __weakref__
     |      list of weak references to the object
     |
     |  ----------------------------------------------------------------------
     |  Static methods inherited from builtins.Exception:
     |
     |  __new__(*args, **kwargs) class method of builtins.Exception
     |      Create and return a new object.  See help(type) for accurate signature.
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from builtins.BaseException:
     |
     |  __getattribute__(self, name, /)
     |      Return getattr(self, name).
     |
     |  __reduce__(...)
     |      Helper for pickle.
     |
     |  __setstate__(...)
     |
     |  __str__(self, /)
     |      Return str(self).
     |
     |  add_note(...)
     |      Exception.add_note(note) --
     |      add a note to the exception
     |
     |  with_traceback(...)
     |      Exception.with_traceback(tb) --
     |      set self.__traceback__ to tb and return self.
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors inherited from builtins.BaseException:
     |
     |  __cause__
     |      exception cause
     |
     |  __context__
     |      exception context
     |
     |  __dict__
     |
     |  __suppress_context__
     |
     |  __traceback__
     |
     |  args

    class ChildDeadlockedError(builtins.Exception)
     |  Error indicating that a child process is deadlocked after a fork()
     |
     |  Method resolution order:
     |      ChildDeadlockedError
     |      builtins.Exception
     |      builtins.BaseException
     |      builtins.object
     |
     |  Data descriptors defined here:
     |
     |  __weakref__
     |      list of weak references to the object
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from builtins.Exception:
     |
     |  __init__(self, /, *args, **kwargs)
     |      Initialize self.  See help(type(self)) for accurate signature.
     |
     |  ----------------------------------------------------------------------
     |  Static methods inherited from builtins.Exception:
     |
     |  __new__(*args, **kwargs) class method of builtins.Exception
     |      Create and return a new object.  See help(type) for accurate signature.
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from builtins.BaseException:
     |
     |  __getattribute__(self, name, /)
     |      Return getattr(self, name).
     |
     |  __reduce__(...)
     |      Helper for pickle.
     |
     |  __repr__(self, /)
     |      Return repr(self).
     |
     |  __setstate__(...)
     |
     |  __str__(self, /)
     |      Return str(self).
     |
     |  add_note(...)
     |      Exception.add_note(note) --
     |      add a note to the exception
     |
     |  with_traceback(...)
     |      Exception.with_traceback(tb) --
     |      set self.__traceback__ to tb and return self.
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors inherited from builtins.BaseException:
     |
     |  __cause__
     |      exception cause
     |
     |  __context__
     |      exception context
     |
     |  __dict__
     |
     |  __suppress_context__
     |
     |  __traceback__
     |
     |  args

    class ClusterCrossSlotError(ResponseError)
     |  ClusterCrossSlotError(*args, status_code: str | None = None)
     |
     |  Error indicated CROSSSLOT error received from cluster.
     |  A CROSSSLOT error is generated when keys in a request don't hash to the
     |  same slot.
     |
     |  Method resolution order:
     |      ClusterCrossSlotError
     |      ResponseError
     |      RedisError
     |      builtins.Exception
     |      builtins.BaseException
     |      builtins.object
     |
     |  Methods defined here:
     |
     |  __init__(self, *args, status_code: str | None = None)
     |      Initialize self.  See help(type(self)) for accurate signature.
     |
     |  ----------------------------------------------------------------------
     |  Data and other attributes defined here:
     |
     |  message = "Keys in request don't hash to the same slot"
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from RedisError:
     |
     |  __repr__(self)
     |      Return repr(self).
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors inherited from RedisError:
     |
     |  __weakref__
     |      list of weak references to the object
     |
     |  ----------------------------------------------------------------------
     |  Static methods inherited from builtins.Exception:
     |
     |  __new__(*args, **kwargs) class method of builtins.Exception
     |      Create and return a new object.  See help(type) for accurate signature.
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from builtins.BaseException:
     |
     |  __getattribute__(self, name, /)
     |      Return getattr(self, name).
     |
     |  __reduce__(...)
     |      Helper for pickle.
     |
     |  __setstate__(...)
     |
     |  __str__(self, /)
     |      Return str(self).
     |
     |  add_note(...)
     |      Exception.add_note(note) --
     |      add a note to the exception
     |
     |  with_traceback(...)
     |      Exception.with_traceback(tb) --
     |      set self.__traceback__ to tb and return self.
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors inherited from builtins.BaseException:
     |
     |  __cause__
     |      exception cause
     |
     |  __context__
     |      exception context
     |
     |  __dict__
     |
     |  __suppress_context__
     |
     |  __traceback__
     |
     |  args

    class ClusterDownError(ClusterError, ResponseError)
     |  ClusterDownError(resp, status_code: str | None = None)
     |
     |  Error indicated CLUSTERDOWN error received from cluster.
     |  By default Redis Cluster nodes stop accepting queries if they detect there
     |  is at least a hash slot uncovered (no available node is serving it).
     |  This way if the cluster is partially down (for example a range of hash
     |  slots are no longer covered) the entire cluster eventually becomes
     |  unavailable. It automatically returns available as soon as all the slots
     |  are covered again.
     |
     |  Method resolution order:
     |      ClusterDownError
     |      ClusterError
     |      ResponseError
     |      RedisError
     |      builtins.Exception
     |      builtins.BaseException
     |      builtins.object
     |
     |  Methods defined here:
     |
     |  __init__(self, resp, status_code: str | None = None)
     |      Initialize self.  See help(type(self)) for accurate signature.
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from RedisError:
     |
     |  __repr__(self)
     |      Return repr(self).
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors inherited from RedisError:
     |
     |  __weakref__
     |      list of weak references to the object
     |
     |  ----------------------------------------------------------------------
     |  Static methods inherited from builtins.Exception:
     |
     |  __new__(*args, **kwargs) class method of builtins.Exception
     |      Create and return a new object.  See help(type) for accurate signature.
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from builtins.BaseException:
     |
     |  __getattribute__(self, name, /)
     |      Return getattr(self, name).
     |
     |  __reduce__(...)
     |      Helper for pickle.
     |
     |  __setstate__(...)
     |
     |  __str__(self, /)
     |      Return str(self).
     |
     |  add_note(...)
     |      Exception.add_note(note) --
     |      add a note to the exception
     |
     |  with_traceback(...)
     |      Exception.with_traceback(tb) --
     |      set self.__traceback__ to tb and return self.
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors inherited from builtins.BaseException:
     |
     |  __cause__
     |      exception cause
     |
     |  __context__
     |      exception context
     |
     |  __dict__
     |
     |  __suppress_context__
     |
     |  __traceback__
     |
     |  args

    class ClusterError(RedisError)
     |  ClusterError(*args, status_code: str | None = None)
     |
     |  Cluster errors occurred multiple times, resulting in an exhaustion of the
     |  command execution TTL
     |
     |  Method resolution order:
     |      ClusterError
     |      RedisError
     |      builtins.Exception
     |      builtins.BaseException
     |      builtins.object
     |
     |  Methods defined here:
     |
     |  __init__(self, *args, status_code: str | None = None)
     |      Initialize self.  See help(type(self)) for accurate signature.
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from RedisError:
     |
     |  __repr__(self)
     |      Return repr(self).
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors inherited from RedisError:
     |
     |  __weakref__
     |      list of weak references to the object
     |
     |  ----------------------------------------------------------------------
     |  Static methods inherited from builtins.Exception:
     |
     |  __new__(*args, **kwargs) class method of builtins.Exception
     |      Create and return a new object.  See help(type) for accurate signature.
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from builtins.BaseException:
     |
     |  __getattribute__(self, name, /)
     |      Return getattr(self, name).
     |
     |  __reduce__(...)
     |      Helper for pickle.
     |
     |  __setstate__(...)
     |
     |  __str__(self, /)
     |      Return str(self).
     |
     |  add_note(...)
     |      Exception.add_note(note) --
     |      add a note to the exception
     |
     |  with_traceback(...)
     |      Exception.with_traceback(tb) --
     |      set self.__traceback__ to tb and return self.
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors inherited from builtins.BaseException:
     |
     |  __cause__
     |      exception cause
     |
     |  __context__
     |      exception context
     |
     |  __dict__
     |
     |  __suppress_context__
     |
     |  __traceback__
     |
     |  args

    class ConnectionError(RedisError)
     |  ConnectionError(*args, status_code: str | None = None)
     |
     |  Method resolution order:
     |      ConnectionError
     |      RedisError
     |      builtins.Exception
     |      builtins.BaseException
     |      builtins.object
     |
     |  Methods defined here:
     |
     |  __init__(self, *args, status_code: str | None = None)
     |      Initialize self.  See help(type(self)) for accurate signature.
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from RedisError:
     |
     |  __repr__(self)
     |      Return repr(self).
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors inherited from RedisError:
     |
     |  __weakref__
     |      list of weak references to the object
     |
     |  ----------------------------------------------------------------------
     |  Static methods inherited from builtins.Exception:
     |
     |  __new__(*args, **kwargs) class method of builtins.Exception
     |      Create and return a new object.  See help(type) for accurate signature.
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from builtins.BaseException:
     |
     |  __getattribute__(self, name, /)
     |      Return getattr(self, name).
     |
     |  __reduce__(...)
     |      Helper for pickle.
     |
     |  __setstate__(...)
     |
     |  __str__(self, /)
     |      Return str(self).
     |
     |  add_note(...)
     |      Exception.add_note(note) --
     |      add a note to the exception
     |
     |  with_traceback(...)
     |      Exception.with_traceback(tb) --
     |      set self.__traceback__ to tb and return self.
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors inherited from builtins.BaseException:
     |
     |  __cause__
     |      exception cause
     |
     |  __context__
     |      exception context
     |
     |  __dict__
     |
     |  __suppress_context__
     |
     |  __traceback__
     |
     |  args

    class CrossSlotTransactionError(RedisClusterException)
     |  CrossSlotTransactionError(*args: object) -> None
     |
     |  Raised when a transaction or watch is triggered in a pipeline
     |  and not all keys or all commands belong to the same slot.
     |
     |  Method resolution order:
     |      CrossSlotTransactionError
     |      RedisClusterException
     |      builtins.Exception
     |      builtins.BaseException
     |      builtins.object
     |
     |  Methods inherited from RedisClusterException:
     |
     |  __init__(self, *args: object) -> None
     |      Initialize self.  See help(type(self)) for accurate signature.
     |
     |  __repr__(self)
     |      Return repr(self).
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors inherited from RedisClusterException:
     |
     |  __weakref__
     |      list of weak references to the object
     |
     |  ----------------------------------------------------------------------
     |  Static methods inherited from builtins.Exception:
     |
     |  __new__(*args, **kwargs) class method of builtins.Exception
     |      Create and return a new object.  See help(type) for accurate signature.
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from builtins.BaseException:
     |
     |  __getattribute__(self, name, /)
     |      Return getattr(self, name).
     |
     |  __reduce__(...)
     |      Helper for pickle.
     |
     |  __setstate__(...)
     |
     |  __str__(self, /)
     |      Return str(self).
     |
     |  add_note(...)
     |      Exception.add_note(note) --
     |      add a note to the exception
     |
     |  with_traceback(...)
     |      Exception.with_traceback(tb) --
     |      set self.__traceback__ to tb and return self.
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors inherited from builtins.BaseException:
     |
     |  __cause__
     |      exception cause
     |
     |  __context__
     |      exception context
     |
     |  __dict__
     |
     |  __suppress_context__
     |
     |  __traceback__
     |
     |  args

    class DataError(RedisError)
     |  DataError(*args, status_code: str | None = None)
     |
     |  Method resolution order:
     |      DataError
     |      RedisError
     |      builtins.Exception
     |      builtins.BaseException
     |      builtins.object
     |
     |  Methods inherited from RedisError:
     |
     |  __init__(self, *args, status_code: str | None = None)
     |      Initialize self.  See help(type(self)) for accurate signature.
     |
     |  __repr__(self)
     |      Return repr(self).
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors inherited from RedisError:
     |
     |  __weakref__
     |      list of weak references to the object
     |
     |  ----------------------------------------------------------------------
     |  Static methods inherited from builtins.Exception:
     |
     |  __new__(*args, **kwargs) class method of builtins.Exception
     |      Create and return a new object.  See help(type) for accurate signature.
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from builtins.BaseException:
     |
     |  __getattribute__(self, name, /)
     |      Return getattr(self, name).
     |
     |  __reduce__(...)
     |      Helper for pickle.
     |
     |  __setstate__(...)
     |
     |  __str__(self, /)
     |      Return str(self).
     |
     |  add_note(...)
     |      Exception.add_note(note) --
     |      add a note to the exception
     |
     |  with_traceback(...)
     |      Exception.with_traceback(tb) --
     |      set self.__traceback__ to tb and return self.
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors inherited from builtins.BaseException:
     |
     |  __cause__
     |      exception cause
     |
     |  __context__
     |      exception context
     |
     |  __dict__
     |
     |  __suppress_context__
     |
     |  __traceback__
     |
     |  args

    class ExceptionType(enum.Enum)
     |  ExceptionType(*values)
     |
     |  Method resolution order:
     |      ExceptionType
     |      enum.Enum
     |      builtins.object
     |
     |  Data and other attributes defined here:
     |
     |  AUTH = <ExceptionType.AUTH: 'auth'>
     |
     |  NETWORK = <ExceptionType.NETWORK: 'network'>
     |
     |  SERVER = <ExceptionType.SERVER: 'server'>
     |
     |  TLS = <ExceptionType.TLS: 'tls'>
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors inherited from enum.Enum:
     |
     |  name
     |      The name of the Enum member.
     |
     |  value
     |      The value of the Enum member.
     |
     |  ----------------------------------------------------------------------
     |  Static methods inherited from enum.EnumType:
     |
     |  __contains__(value)
     |      Return True if `value` is in `cls`.
     |
     |      `value` is in `cls` if:
     |      1) `value` is a member of `cls`, or
     |      2) `value` is the value of one of the `cls`'s members.
     |
     |  __getitem__(name)
     |      Return the member matching `name`.
     |
     |  __iter__()
     |      Return members in definition order.
     |
     |  __len__()
     |      Return the number of members (no aliases)
     |
     |  ----------------------------------------------------------------------
     |  Readonly properties inherited from enum.EnumType:
     |
     |  __members__
     |      Returns a mapping of member name->value.
     |
     |      This mapping lists all enum members, including aliases. Note that this
     |      is a read-only view of the internal mapping.

    class ExecAbortError(ResponseError)
     |  ExecAbortError(*args, status_code: str | None = None)
     |
     |  Method resolution order:
     |      ExecAbortError
     |      ResponseError
     |      RedisError
     |      builtins.Exception
     |      builtins.BaseException
     |      builtins.object
     |
     |  Methods inherited from RedisError:
     |
     |  __init__(self, *args, status_code: str | None = None)
     |      Initialize self.  See help(type(self)) for accurate signature.
     |
     |  __repr__(self)
     |      Return repr(self).
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors inherited from RedisError:
     |
     |  __weakref__
     |      list of weak references to the object
     |
     |  ----------------------------------------------------------------------
     |  Static methods inherited from builtins.Exception:
     |
     |  __new__(*args, **kwargs) class method of builtins.Exception
     |      Create and return a new object.  See help(type) for accurate signature.
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from builtins.BaseException:
     |
     |  __getattribute__(self, name, /)
     |      Return getattr(self, name).
     |
     |  __reduce__(...)
     |      Helper for pickle.
     |
     |  __setstate__(...)
     |
     |  __str__(self, /)
     |      Return str(self).
     |
     |  add_note(...)
     |      Exception.add_note(note) --
     |      add a note to the exception
     |
     |  with_traceback(...)
     |      Exception.with_traceback(tb) --
     |      set self.__traceback__ to tb and return self.
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors inherited from builtins.BaseException:
     |
     |  __cause__
     |      exception cause
     |
     |  __context__
     |      exception context
     |
     |  __dict__
     |
     |  __suppress_context__
     |
     |  __traceback__
     |
     |  args

    class ExternalAuthProviderError(ConnectionError)
     |  ExternalAuthProviderError(*args, status_code: str | None = None)
     |
     |  Raised when an external authentication provider returns an error.
     |
     |  Method resolution order:
     |      ExternalAuthProviderError
     |      ConnectionError
     |      RedisError
     |      builtins.Exception
     |      builtins.BaseException
     |      builtins.object
     |
     |  Methods inherited from ConnectionError:
     |
     |  __init__(self, *args, status_code: str | None = None)
     |      Initialize self.  See help(type(self)) for accurate signature.
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from RedisError:
     |
     |  __repr__(self)
     |      Return repr(self).
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors inherited from RedisError:
     |
     |  __weakref__
     |      list of weak references to the object
     |
     |  ----------------------------------------------------------------------
     |  Static methods inherited from builtins.Exception:
     |
     |  __new__(*args, **kwargs) class method of builtins.Exception
     |      Create and return a new object.  See help(type) for accurate signature.
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from builtins.BaseException:
     |
     |  __getattribute__(self, name, /)
     |      Return getattr(self, name).
     |
     |  __reduce__(...)
     |      Helper for pickle.
     |
     |  __setstate__(...)
     |
     |  __str__(self, /)
     |      Return str(self).
     |
     |  add_note(...)
     |      Exception.add_note(note) --
     |      add a note to the exception
     |
     |  with_traceback(...)
     |      Exception.with_traceback(tb) --
     |      set self.__traceback__ to tb and return self.
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors inherited from builtins.BaseException:
     |
     |  __cause__
     |      exception cause
     |
     |  __context__
     |      exception context
     |
     |  __dict__
     |
     |  __suppress_context__
     |
     |  __traceback__
     |
     |  args

    class IncorrectPolicyType(builtins.Exception)
     |  Raised when a policy type isn't matching to any known policy types.
     |
     |  Method resolution order:
     |      IncorrectPolicyType
     |      builtins.Exception
     |      builtins.BaseException
     |      builtins.object
     |
     |  Data descriptors defined here:
     |
     |  __weakref__
     |      list of weak references to the object
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from builtins.Exception:
     |
     |  __init__(self, /, *args, **kwargs)
     |      Initialize self.  See help(type(self)) for accurate signature.
     |
     |  ----------------------------------------------------------------------
     |  Static methods inherited from builtins.Exception:
     |
     |  __new__(*args, **kwargs) class method of builtins.Exception
     |      Create and return a new object.  See help(type) for accurate signature.
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from builtins.BaseException:
     |
     |  __getattribute__(self, name, /)
     |      Return getattr(self, name).
     |
     |  __reduce__(...)
     |      Helper for pickle.
     |
     |  __repr__(self, /)
     |      Return repr(self).
     |
     |  __setstate__(...)
     |
     |  __str__(self, /)
     |      Return str(self).
     |
     |  add_note(...)
     |      Exception.add_note(note) --
     |      add a note to the exception
     |
     |  with_traceback(...)
     |      Exception.with_traceback(tb) --
     |      set self.__traceback__ to tb and return self.
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors inherited from builtins.BaseException:
     |
     |  __cause__
     |      exception cause
     |
     |  __context__
     |      exception context
     |
     |  __dict__
     |
     |  __suppress_context__
     |
     |  __traceback__
     |
     |  args

    class InvalidPipelineStack(RedisClusterException)
     |  InvalidPipelineStack(*args: object) -> None
     |
     |  Raised on unexpected response length on pipelines. This is
     |  most likely a handling error on the stack.
     |
     |  Method resolution order:
     |      InvalidPipelineStack
     |      RedisClusterException
     |      builtins.Exception
     |      builtins.BaseException
     |      builtins.object
     |
     |  Methods inherited from RedisClusterException:
     |
     |  __init__(self, *args: object) -> None
     |      Initialize self.  See help(type(self)) for accurate signature.
     |
     |  __repr__(self)
     |      Return repr(self).
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors inherited from RedisClusterException:
     |
     |  __weakref__
     |      list of weak references to the object
     |
     |  ----------------------------------------------------------------------
     |  Static methods inherited from builtins.Exception:
     |
     |  __new__(*args, **kwargs) class method of builtins.Exception
     |      Create and return a new object.  See help(type) for accurate signature.
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from builtins.BaseException:
     |
     |  __getattribute__(self, name, /)
     |      Return getattr(self, name).
     |
     |  __reduce__(...)
     |      Helper for pickle.
     |
     |  __setstate__(...)
     |
     |  __str__(self, /)
     |      Return str(self).
     |
     |  add_note(...)
     |      Exception.add_note(note) --
     |      add a note to the exception
     |
     |  with_traceback(...)
     |      Exception.with_traceback(tb) --
     |      set self.__traceback__ to tb and return self.
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors inherited from builtins.BaseException:
     |
     |  __cause__
     |      exception cause
     |
     |  __context__
     |      exception context
     |
     |  __dict__
     |
     |  __suppress_context__
     |
     |  __traceback__
     |
     |  args

    class InvalidResponse(RedisError)
     |  InvalidResponse(*args, status_code: str | None = None)
     |
     |  Method resolution order:
     |      InvalidResponse
     |      RedisError
     |      builtins.Exception
     |      builtins.BaseException
     |      builtins.object
     |
     |  Methods inherited from RedisError:
     |
     |  __init__(self, *args, status_code: str | None = None)
     |      Initialize self.  See help(type(self)) for accurate signature.
     |
     |  __repr__(self)
     |      Return repr(self).
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors inherited from RedisError:
     |
     |  __weakref__
     |      list of weak references to the object
     |
     |  ----------------------------------------------------------------------
     |  Static methods inherited from builtins.Exception:
     |
     |  __new__(*args, **kwargs) class method of builtins.Exception
     |      Create and return a new object.  See help(type) for accurate signature.
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from builtins.BaseException:
     |
     |  __getattribute__(self, name, /)
     |      Return getattr(self, name).
     |
     |  __reduce__(...)
     |      Helper for pickle.
     |
     |  __setstate__(...)
     |
     |  __str__(self, /)
     |      Return str(self).
     |
     |  add_note(...)
     |      Exception.add_note(note) --
     |      add a note to the exception
     |
     |  with_traceback(...)
     |      Exception.with_traceback(tb) --
     |      set self.__traceback__ to tb and return self.
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors inherited from builtins.BaseException:
     |
     |  __cause__
     |      exception cause
     |
     |  __context__
     |      exception context
     |
     |  __dict__
     |
     |  __suppress_context__
     |
     |  __traceback__
     |
     |  args

    class LockError(RedisError, builtins.ValueError)
     |  LockError(message: str | None = None, lock_name: str | None = None) -> None
     |
     |  Errors acquiring or releasing a lock
     |
     |  Method resolution order:
     |      LockError
     |      RedisError
     |      builtins.ValueError
     |      builtins.Exception
     |      builtins.BaseException
     |      builtins.object
     |
     |  Methods defined here:
     |
     |  __init__(self, message: str | None = None, lock_name: str | None = None) -> None
     |      Initialize self.  See help(type(self)) for accurate signature.
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from RedisError:
     |
     |  __repr__(self)
     |      Return repr(self).
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors inherited from RedisError:
     |
     |  __weakref__
     |      list of weak references to the object
     |
     |  ----------------------------------------------------------------------
     |  Static methods inherited from builtins.ValueError:
     |
     |  __new__(*args, **kwargs) class method of builtins.ValueError
     |      Create and return a new object.  See help(type) for accurate signature.
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from builtins.BaseException:
     |
     |  __getattribute__(self, name, /)
     |      Return getattr(self, name).
     |
     |  __reduce__(...)
     |      Helper for pickle.
     |
     |  __setstate__(...)
     |
     |  __str__(self, /)
     |      Return str(self).
     |
     |  add_note(...)
     |      Exception.add_note(note) --
     |      add a note to the exception
     |
     |  with_traceback(...)
     |      Exception.with_traceback(tb) --
     |      set self.__traceback__ to tb and return self.
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors inherited from builtins.BaseException:
     |
     |  __cause__
     |      exception cause
     |
     |  __context__
     |      exception context
     |
     |  __dict__
     |
     |  __suppress_context__
     |
     |  __traceback__
     |
     |  args

    class LockNotOwnedError(LockError)
     |  LockNotOwnedError(message: str | None = None, lock_name: str | None = None) -> None
     |
     |  Error trying to extend or release a lock that is not owned (anymore)
     |
     |  Method resolution order:
     |      LockNotOwnedError
     |      LockError
     |      RedisError
     |      builtins.ValueError
     |      builtins.Exception
     |      builtins.BaseException
     |      builtins.object
     |
     |  Methods inherited from LockError:
     |
     |  __init__(self, message: str | None = None, lock_name: str | None = None) -> None
     |      Initialize self.  See help(type(self)) for accurate signature.
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from RedisError:
     |
     |  __repr__(self)
     |      Return repr(self).
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors inherited from RedisError:
     |
     |  __weakref__
     |      list of weak references to the object
     |
     |  ----------------------------------------------------------------------
     |  Static methods inherited from builtins.ValueError:
     |
     |  __new__(*args, **kwargs) class method of builtins.ValueError
     |      Create and return a new object.  See help(type) for accurate signature.
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from builtins.BaseException:
     |
     |  __getattribute__(self, name, /)
     |      Return getattr(self, name).
     |
     |  __reduce__(...)
     |      Helper for pickle.
     |
     |  __setstate__(...)
     |
     |  __str__(self, /)
     |      Return str(self).
     |
     |  add_note(...)
     |      Exception.add_note(note) --
     |      add a note to the exception
     |
     |  with_traceback(...)
     |      Exception.with_traceback(tb) --
     |      set self.__traceback__ to tb and return self.
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors inherited from builtins.BaseException:
     |
     |  __cause__
     |      exception cause
     |
     |  __context__
     |      exception context
     |
     |  __dict__
     |
     |  __suppress_context__
     |
     |  __traceback__
     |
     |  args

    class MasterDownError(ClusterDownError)
     |  MasterDownError(resp, status_code: str | None = None)
     |
     |  Error indicated MASTERDOWN error received from cluster.
     |  Link with MASTER is down and replica-serve-stale-data is set to 'no'.
     |
     |  Method resolution order:
     |      MasterDownError
     |      ClusterDownError
     |      ClusterError
     |      ResponseError
     |      RedisError
     |      builtins.Exception
     |      builtins.BaseException
     |      builtins.object
     |
     |  Methods inherited from ClusterDownError:
     |
     |  __init__(self, resp, status_code: str | None = None)
     |      Initialize self.  See help(type(self)) for accurate signature.
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from RedisError:
     |
     |  __repr__(self)
     |      Return repr(self).
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors inherited from RedisError:
     |
     |  __weakref__
     |      list of weak references to the object
     |
     |  ----------------------------------------------------------------------
     |  Static methods inherited from builtins.Exception:
     |
     |  __new__(*args, **kwargs) class method of builtins.Exception
     |      Create and return a new object.  See help(type) for accurate signature.
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from builtins.BaseException:
     |
     |  __getattribute__(self, name, /)
     |      Return getattr(self, name).
     |
     |  __reduce__(...)
     |      Helper for pickle.
     |
     |  __setstate__(...)
     |
     |  __str__(self, /)
     |      Return str(self).
     |
     |  add_note(...)
     |      Exception.add_note(note) --
     |      add a note to the exception
     |
     |  with_traceback(...)
     |      Exception.with_traceback(tb) --
     |      set self.__traceback__ to tb and return self.
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors inherited from builtins.BaseException:
     |
     |  __cause__
     |      exception cause
     |
     |  __context__
     |      exception context
     |
     |  __dict__
     |
     |  __suppress_context__
     |
     |  __traceback__
     |
     |  args

    class MaxConnectionsError(ConnectionError)
     |  MaxConnectionsError(*args, status_code: str | None = None)
     |
     |  Raised when a connection pool has reached its max_connections limit.
     |  This indicates pool exhaustion rather than an actual connection failure.
     |
     |  Method resolution order:
     |      MaxConnectionsError
     |      ConnectionError
     |      RedisError
     |      builtins.Exception
     |      builtins.BaseException
     |      builtins.object
     |
     |  Methods inherited from ConnectionError:
     |
     |  __init__(self, *args, status_code: str | None = None)
     |      Initialize self.  See help(type(self)) for accurate signature.
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from RedisError:
     |
     |  __repr__(self)
     |      Return repr(self).
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors inherited from RedisError:
     |
     |  __weakref__
     |      list of weak references to the object
     |
     |  ----------------------------------------------------------------------
     |  Static methods inherited from builtins.Exception:
     |
     |  __new__(*args, **kwargs) class method of builtins.Exception
     |      Create and return a new object.  See help(type) for accurate signature.
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from builtins.BaseException:
     |
     |  __getattribute__(self, name, /)
     |      Return getattr(self, name).
     |
     |  __reduce__(...)
     |      Helper for pickle.
     |
     |  __setstate__(...)
     |
     |  __str__(self, /)
     |      Return str(self).
     |
     |  add_note(...)
     |      Exception.add_note(note) --
     |      add a note to the exception
     |
     |  with_traceback(...)
     |      Exception.with_traceback(tb) --
     |      set self.__traceback__ to tb and return self.
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors inherited from builtins.BaseException:
     |
     |  __cause__
     |      exception cause
     |
     |  __context__
     |      exception context
     |
     |  __dict__
     |
     |  __suppress_context__
     |
     |  __traceback__
     |
     |  args

    class ModuleError(ResponseError)
     |  ModuleError(*args, status_code: str | None = None)
     |
     |  Method resolution order:
     |      ModuleError
     |      ResponseError
     |      RedisError
     |      builtins.Exception
     |      builtins.BaseException
     |      builtins.object
     |
     |  Methods inherited from RedisError:
     |
     |  __init__(self, *args, status_code: str | None = None)
     |      Initialize self.  See help(type(self)) for accurate signature.
     |
     |  __repr__(self)
     |      Return repr(self).
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors inherited from RedisError:
     |
     |  __weakref__
     |      list of weak references to the object
     |
     |  ----------------------------------------------------------------------
     |  Static methods inherited from builtins.Exception:
     |
     |  __new__(*args, **kwargs) class method of builtins.Exception
     |      Create and return a new object.  See help(type) for accurate signature.
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from builtins.BaseException:
     |
     |  __getattribute__(self, name, /)
     |      Return getattr(self, name).
     |
     |  __reduce__(...)
     |      Helper for pickle.
     |
     |  __setstate__(...)
     |
     |  __str__(self, /)
     |      Return str(self).
     |
     |  add_note(...)
     |      Exception.add_note(note) --
     |      add a note to the exception
     |
     |  with_traceback(...)
     |      Exception.with_traceback(tb) --
     |      set self.__traceback__ to tb and return self.
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors inherited from builtins.BaseException:
     |
     |  __cause__
     |      exception cause
     |
     |  __context__
     |      exception context
     |
     |  __dict__
     |
     |  __suppress_context__
     |
     |  __traceback__
     |
     |  args

    class MovedError(AskError)
     |  MovedError(resp, status_code: str | None = None)
     |
     |  Error indicated MOVED error received from cluster.
     |  A request sent to a node that doesn't serve this key will be replayed with
     |  a MOVED error that points to the correct node.
     |
     |  Method resolution order:
     |      MovedError
     |      AskError
     |      ResponseError
     |      RedisError
     |      builtins.Exception
     |      builtins.BaseException
     |      builtins.object
     |
     |  Methods inherited from AskError:
     |
     |  __init__(self, resp, status_code: str | None = None)
     |      should only redirect to master node
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from RedisError:
     |
     |  __repr__(self)
     |      Return repr(self).
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors inherited from RedisError:
     |
     |  __weakref__
     |      list of weak references to the object
     |
     |  ----------------------------------------------------------------------
     |  Static methods inherited from builtins.Exception:
     |
     |  __new__(*args, **kwargs) class method of builtins.Exception
     |      Create and return a new object.  See help(type) for accurate signature.
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from builtins.BaseException:
     |
     |  __getattribute__(self, name, /)
     |      Return getattr(self, name).
     |
     |  __reduce__(...)
     |      Helper for pickle.
     |
     |  __setstate__(...)
     |
     |  __str__(self, /)
     |      Return str(self).
     |
     |  add_note(...)
     |      Exception.add_note(note) --
     |      add a note to the exception
     |
     |  with_traceback(...)
     |      Exception.with_traceback(tb) --
     |      set self.__traceback__ to tb and return self.
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors inherited from builtins.BaseException:
     |
     |  __cause__
     |      exception cause
     |
     |  __context__
     |      exception context
     |
     |  __dict__
     |
     |  __suppress_context__
     |
     |  __traceback__
     |
     |  args

    class NoPermissionError(ResponseError)
     |  NoPermissionError(*args, status_code: str | None = None)
     |
     |  Method resolution order:
     |      NoPermissionError
     |      ResponseError
     |      RedisError
     |      builtins.Exception
     |      builtins.BaseException
     |      builtins.object
     |
     |  Methods defined here:
     |
     |  __init__(self, *args, status_code: str | None = None)
     |      Initialize self.  See help(type(self)) for accurate signature.
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from RedisError:
     |
     |  __repr__(self)
     |      Return repr(self).
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors inherited from RedisError:
     |
     |  __weakref__
     |      list of weak references to the object
     |
     |  ----------------------------------------------------------------------
     |  Static methods inherited from builtins.Exception:
     |
     |  __new__(*args, **kwargs) class method of builtins.Exception
     |      Create and return a new object.  See help(type) for accurate signature.
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from builtins.BaseException:
     |
     |  __getattribute__(self, name, /)
     |      Return getattr(self, name).
     |
     |  __reduce__(...)
     |      Helper for pickle.
     |
     |  __setstate__(...)
     |
     |  __str__(self, /)
     |      Return str(self).
     |
     |  add_note(...)
     |      Exception.add_note(note) --
     |      add a note to the exception
     |
     |  with_traceback(...)
     |      Exception.with_traceback(tb) --
     |      set self.__traceback__ to tb and return self.
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors inherited from builtins.BaseException:
     |
     |  __cause__
     |      exception cause
     |
     |  __context__
     |      exception context
     |
     |  __dict__
     |
     |  __suppress_context__
     |
     |  __traceback__
     |
     |  args

    class NoScriptError(ResponseError)
     |  NoScriptError(*args, status_code: str | None = None)
     |
     |  Method resolution order:
     |      NoScriptError
     |      ResponseError
     |      RedisError
     |      builtins.Exception
     |      builtins.BaseException
     |      builtins.object
     |
     |  Methods inherited from RedisError:
     |
     |  __init__(self, *args, status_code: str | None = None)
     |      Initialize self.  See help(type(self)) for accurate signature.
     |
     |  __repr__(self)
     |      Return repr(self).
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors inherited from RedisError:
     |
     |  __weakref__
     |      list of weak references to the object
     |
     |  ----------------------------------------------------------------------
     |  Static methods inherited from builtins.Exception:
     |
     |  __new__(*args, **kwargs) class method of builtins.Exception
     |      Create and return a new object.  See help(type) for accurate signature.
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from builtins.BaseException:
     |
     |  __getattribute__(self, name, /)
     |      Return getattr(self, name).
     |
     |  __reduce__(...)
     |      Helper for pickle.
     |
     |  __setstate__(...)
     |
     |  __str__(self, /)
     |      Return str(self).
     |
     |  add_note(...)
     |      Exception.add_note(note) --
     |      add a note to the exception
     |
     |  with_traceback(...)
     |      Exception.with_traceback(tb) --
     |      set self.__traceback__ to tb and return self.
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors inherited from builtins.BaseException:
     |
     |  __cause__
     |      exception cause
     |
     |  __context__
     |      exception context
     |
     |  __dict__
     |
     |  __suppress_context__
     |
     |  __traceback__
     |
     |  args

    class NoSuchFieldsetError(ResponseError)
     |  NoSuchFieldsetError(*args, status_code: str | None = None)
     |
     |  Server reply when ``HIMPORT SET`` targets a fieldset the connection has not
     |  prepared.
     |
     |  Under lazy PREPARE bundling this is nearly unreachable, but the server can drop
     |  session state mid-connection without dropping the socket (e.g. ``RESET`` or
     |  ``maxmemory-clients`` eviction). The client catches this to re-prepare on the same
     |  socket and retry the SET once instead of failing.
     |
     |  Method resolution order:
     |      NoSuchFieldsetError
     |      ResponseError
     |      RedisError
     |      builtins.Exception
     |      builtins.BaseException
     |      builtins.object
     |
     |  Methods inherited from RedisError:
     |
     |  __init__(self, *args, status_code: str | None = None)
     |      Initialize self.  See help(type(self)) for accurate signature.
     |
     |  __repr__(self)
     |      Return repr(self).
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors inherited from RedisError:
     |
     |  __weakref__
     |      list of weak references to the object
     |
     |  ----------------------------------------------------------------------
     |  Static methods inherited from builtins.Exception:
     |
     |  __new__(*args, **kwargs) class method of builtins.Exception
     |      Create and return a new object.  See help(type) for accurate signature.
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from builtins.BaseException:
     |
     |  __getattribute__(self, name, /)
     |      Return getattr(self, name).
     |
     |  __reduce__(...)
     |      Helper for pickle.
     |
     |  __setstate__(...)
     |
     |  __str__(self, /)
     |      Return str(self).
     |
     |  add_note(...)
     |      Exception.add_note(note) --
     |      add a note to the exception
     |
     |  with_traceback(...)
     |      Exception.with_traceback(tb) --
     |      set self.__traceback__ to tb and return self.
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors inherited from builtins.BaseException:
     |
     |  __cause__
     |      exception cause
     |
     |  __context__
     |      exception context
     |
     |  __dict__
     |
     |  __suppress_context__
     |
     |  __traceback__
     |
     |  args

    class OutOfMemoryError(ResponseError)
     |  OutOfMemoryError(*args, status_code: str | None = None)
     |
     |  Indicates the database is full. Can only occur when either:
     |    * Redis maxmemory-policy=noeviction
     |    * Redis maxmemory-policy=volatile* and there are no evictable keys
     |
     |  For more information see `Memory optimization in Redis <https://redis.io/docs/management/optimization/memory-optimization/#memory-allocation>`_. # noqa
     |
     |  Method resolution order:
     |      OutOfMemoryError
     |      ResponseError
     |      RedisError
     |      builtins.Exception
     |      builtins.BaseException
     |      builtins.object
     |
     |  Methods inherited from RedisError:
     |
     |  __init__(self, *args, status_code: str | None = None)
     |      Initialize self.  See help(type(self)) for accurate signature.
     |
     |  __repr__(self)
     |      Return repr(self).
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors inherited from RedisError:
     |
     |  __weakref__
     |      list of weak references to the object
     |
     |  ----------------------------------------------------------------------
     |  Static methods inherited from builtins.Exception:
     |
     |  __new__(*args, **kwargs) class method of builtins.Exception
     |      Create and return a new object.  See help(type) for accurate signature.
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from builtins.BaseException:
     |
     |  __getattribute__(self, name, /)
     |      Return getattr(self, name).
     |
     |  __reduce__(...)
     |      Helper for pickle.
     |
     |  __setstate__(...)
     |
     |  __str__(self, /)
     |      Return str(self).
     |
     |  add_note(...)
     |      Exception.add_note(note) --
     |      add a note to the exception
     |
     |  with_traceback(...)
     |      Exception.with_traceback(tb) --
     |      set self.__traceback__ to tb and return self.
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors inherited from builtins.BaseException:
     |
     |  __cause__
     |      exception cause
     |
     |  __context__
     |      exception context
     |
     |  __dict__
     |
     |  __suppress_context__
     |
     |  __traceback__
     |
     |  args

    class PubSubError(RedisError)
     |  PubSubError(*args, status_code: str | None = None)
     |
     |  Method resolution order:
     |      PubSubError
     |      RedisError
     |      builtins.Exception
     |      builtins.BaseException
     |      builtins.object
     |
     |  Methods inherited from RedisError:
     |
     |  __init__(self, *args, status_code: str | None = None)
     |      Initialize self.  See help(type(self)) for accurate signature.
     |
     |  __repr__(self)
     |      Return repr(self).
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors inherited from RedisError:
     |
     |  __weakref__
     |      list of weak references to the object
     |
     |  ----------------------------------------------------------------------
     |  Static methods inherited from builtins.Exception:
     |
     |  __new__(*args, **kwargs) class method of builtins.Exception
     |      Create and return a new object.  See help(type) for accurate signature.
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from builtins.BaseException:
     |
     |  __getattribute__(self, name, /)
     |      Return getattr(self, name).
     |
     |  __reduce__(...)
     |      Helper for pickle.
     |
     |  __setstate__(...)
     |
     |  __str__(self, /)
     |      Return str(self).
     |
     |  add_note(...)
     |      Exception.add_note(note) --
     |      add a note to the exception
     |
     |  with_traceback(...)
     |      Exception.with_traceback(tb) --
     |      set self.__traceback__ to tb and return self.
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors inherited from builtins.BaseException:
     |
     |  __cause__
     |      exception cause
     |
     |  __context__
     |      exception context
     |
     |  __dict__
     |
     |  __suppress_context__
     |
     |  __traceback__
     |
     |  args

    class ReadOnlyError(ResponseError)
     |  ReadOnlyError(*args, status_code: str | None = None)
     |
     |  Method resolution order:
     |      ReadOnlyError
     |      ResponseError
     |      RedisError
     |      builtins.Exception
     |      builtins.BaseException
     |      builtins.object
     |
     |  Methods inherited from RedisError:
     |
     |  __init__(self, *args, status_code: str | None = None)
     |      Initialize self.  See help(type(self)) for accurate signature.
     |
     |  __repr__(self)
     |      Return repr(self).
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors inherited from RedisError:
     |
     |  __weakref__
     |      list of weak references to the object
     |
     |  ----------------------------------------------------------------------
     |  Static methods inherited from builtins.Exception:
     |
     |  __new__(*args, **kwargs) class method of builtins.Exception
     |      Create and return a new object.  See help(type) for accurate signature.
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from builtins.BaseException:
     |
     |  __getattribute__(self, name, /)
     |      Return getattr(self, name).
     |
     |  __reduce__(...)
     |      Helper for pickle.
     |
     |  __setstate__(...)
     |
     |  __str__(self, /)
     |      Return str(self).
     |
     |  add_note(...)
     |      Exception.add_note(note) --
     |      add a note to the exception
     |
     |  with_traceback(...)
     |      Exception.with_traceback(tb) --
     |      set self.__traceback__ to tb and return self.
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors inherited from builtins.BaseException:
     |
     |  __cause__
     |      exception cause
     |
     |  __context__
     |      exception context
     |
     |  __dict__
     |
     |  __suppress_context__
     |
     |  __traceback__
     |
     |  args

    class RedisClusterException(builtins.Exception)
     |  RedisClusterException(*args: object) -> None
     |
     |  Base exception for the RedisCluster client
     |
     |  Method resolution order:
     |      RedisClusterException
     |      builtins.Exception
     |      builtins.BaseException
     |      builtins.object
     |
     |  Methods defined here:
     |
     |  __init__(self, *args: object) -> None
     |      Initialize self.  See help(type(self)) for accurate signature.
     |
     |  __repr__(self)
     |      Return repr(self).
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors defined here:
     |
     |  __weakref__
     |      list of weak references to the object
     |
     |  ----------------------------------------------------------------------
     |  Static methods inherited from builtins.Exception:
     |
     |  __new__(*args, **kwargs) class method of builtins.Exception
     |      Create and return a new object.  See help(type) for accurate signature.
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from builtins.BaseException:
     |
     |  __getattribute__(self, name, /)
     |      Return getattr(self, name).
     |
     |  __reduce__(...)
     |      Helper for pickle.
     |
     |  __setstate__(...)
     |
     |  __str__(self, /)
     |      Return str(self).
     |
     |  add_note(...)
     |      Exception.add_note(note) --
     |      add a note to the exception
     |
     |  with_traceback(...)
     |      Exception.with_traceback(tb) --
     |      set self.__traceback__ to tb and return self.
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors inherited from builtins.BaseException:
     |
     |  __cause__
     |      exception cause
     |
     |  __context__
     |      exception context
     |
     |  __dict__
     |
     |  __suppress_context__
     |
     |  __traceback__
     |
     |  args

    class RedisError(builtins.Exception)
     |  RedisError(*args, status_code: str | None = None)
     |
     |  Method resolution order:
     |      RedisError
     |      builtins.Exception
     |      builtins.BaseException
     |      builtins.object
     |
     |  Methods defined here:
     |
     |  __init__(self, *args, status_code: str | None = None)
     |      Initialize self.  See help(type(self)) for accurate signature.
     |
     |  __repr__(self)
     |      Return repr(self).
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors defined here:
     |
     |  __weakref__
     |      list of weak references to the object
     |
     |  ----------------------------------------------------------------------
     |  Static methods inherited from builtins.Exception:
     |
     |  __new__(*args, **kwargs) class method of builtins.Exception
     |      Create and return a new object.  See help(type) for accurate signature.
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from builtins.BaseException:
     |
     |  __getattribute__(self, name, /)
     |      Return getattr(self, name).
     |
     |  __reduce__(...)
     |      Helper for pickle.
     |
     |  __setstate__(...)
     |
     |  __str__(self, /)
     |      Return str(self).
     |
     |  add_note(...)
     |      Exception.add_note(note) --
     |      add a note to the exception
     |
     |  with_traceback(...)
     |      Exception.with_traceback(tb) --
     |      set self.__traceback__ to tb and return self.
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors inherited from builtins.BaseException:
     |
     |  __cause__
     |      exception cause
     |
     |  __context__
     |      exception context
     |
     |  __dict__
     |
     |  __suppress_context__
     |
     |  __traceback__
     |
     |  args

    class ResponseError(RedisError)
     |  ResponseError(*args, status_code: str | None = None)
     |
     |  Method resolution order:
     |      ResponseError
     |      RedisError
     |      builtins.Exception
     |      builtins.BaseException
     |      builtins.object
     |
     |  Methods inherited from RedisError:
     |
     |  __init__(self, *args, status_code: str | None = None)
     |      Initialize self.  See help(type(self)) for accurate signature.
     |
     |  __repr__(self)
     |      Return repr(self).
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors inherited from RedisError:
     |
     |  __weakref__
     |      list of weak references to the object
     |
     |  ----------------------------------------------------------------------
     |  Static methods inherited from builtins.Exception:
     |
     |  __new__(*args, **kwargs) class method of builtins.Exception
     |      Create and return a new object.  See help(type) for accurate signature.
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from builtins.BaseException:
     |
     |  __getattribute__(self, name, /)
     |      Return getattr(self, name).
     |
     |  __reduce__(...)
     |      Helper for pickle.
     |
     |  __setstate__(...)
     |
     |  __str__(self, /)
     |      Return str(self).
     |
     |  add_note(...)
     |      Exception.add_note(note) --
     |      add a note to the exception
     |
     |  with_traceback(...)
     |      Exception.with_traceback(tb) --
     |      set self.__traceback__ to tb and return self.
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors inherited from builtins.BaseException:
     |
     |  __cause__
     |      exception cause
     |
     |  __context__
     |      exception context
     |
     |  __dict__
     |
     |  __suppress_context__
     |
     |  __traceback__
     |
     |  args

    class SlotNotCoveredError(RedisClusterException)
     |  SlotNotCoveredError(*args: object) -> None
     |
     |  This error only happens in the case where the connection pool will try to
     |  fetch what node that is covered by a given slot.
     |
     |  If this error is raised the client should drop the current node layout and
     |  attempt to reconnect and refresh the node layout again
     |
     |  Method resolution order:
     |      SlotNotCoveredError
     |      RedisClusterException
     |      builtins.Exception
     |      builtins.BaseException
     |      builtins.object
     |
     |  Methods inherited from RedisClusterException:
     |
     |  __init__(self, *args: object) -> None
     |      Initialize self.  See help(type(self)) for accurate signature.
     |
     |  __repr__(self)
     |      Return repr(self).
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors inherited from RedisClusterException:
     |
     |  __weakref__
     |      list of weak references to the object
     |
     |  ----------------------------------------------------------------------
     |  Static methods inherited from builtins.Exception:
     |
     |  __new__(*args, **kwargs) class method of builtins.Exception
     |      Create and return a new object.  See help(type) for accurate signature.
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from builtins.BaseException:
     |
     |  __getattribute__(self, name, /)
     |      Return getattr(self, name).
     |
     |  __reduce__(...)
     |      Helper for pickle.
     |
     |  __setstate__(...)
     |
     |  __str__(self, /)
     |      Return str(self).
     |
     |  add_note(...)
     |      Exception.add_note(note) --
     |      add a note to the exception
     |
     |  with_traceback(...)
     |      Exception.with_traceback(tb) --
     |      set self.__traceback__ to tb and return self.
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors inherited from builtins.BaseException:
     |
     |  __cause__
     |      exception cause
     |
     |  __context__
     |      exception context
     |
     |  __dict__
     |
     |  __suppress_context__
     |
     |  __traceback__
     |
     |  args

    class TimeoutError(RedisError)
     |  TimeoutError(*args, status_code: str | None = None)
     |
     |  Method resolution order:
     |      TimeoutError
     |      RedisError
     |      builtins.Exception
     |      builtins.BaseException
     |      builtins.object
     |
     |  Methods defined here:
     |
     |  __init__(self, *args, status_code: str | None = None)
     |      Initialize self.  See help(type(self)) for accurate signature.
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from RedisError:
     |
     |  __repr__(self)
     |      Return repr(self).
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors inherited from RedisError:
     |
     |  __weakref__
     |      list of weak references to the object
     |
     |  ----------------------------------------------------------------------
     |  Static methods inherited from builtins.Exception:
     |
     |  __new__(*args, **kwargs) class method of builtins.Exception
     |      Create and return a new object.  See help(type) for accurate signature.
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from builtins.BaseException:
     |
     |  __getattribute__(self, name, /)
     |      Return getattr(self, name).
     |
     |  __reduce__(...)
     |      Helper for pickle.
     |
     |  __setstate__(...)
     |
     |  __str__(self, /)
     |      Return str(self).
     |
     |  add_note(...)
     |      Exception.add_note(note) --
     |      add a note to the exception
     |
     |  with_traceback(...)
     |      Exception.with_traceback(tb) --
     |      set self.__traceback__ to tb and return self.
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors inherited from builtins.BaseException:
     |
     |  __cause__
     |      exception cause
     |
     |  __context__
     |      exception context
     |
     |  __dict__
     |
     |  __suppress_context__
     |
     |  __traceback__
     |
     |  args

    class TryAgainError(ResponseError)
     |  TryAgainError(*args, status_code: str | None = None, **kwargs)
     |
     |  Error indicated TRYAGAIN error received from cluster.
     |  Operations on keys that don't exist or are - during resharding - split
     |  between the source and destination nodes, will generate a -TRYAGAIN error.
     |
     |  Method resolution order:
     |      TryAgainError
     |      ResponseError
     |      RedisError
     |      builtins.Exception
     |      builtins.BaseException
     |      builtins.object
     |
     |  Methods defined here:
     |
     |  __init__(self, *args, status_code: str | None = None, **kwargs)
     |      Initialize self.  See help(type(self)) for accurate signature.
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from RedisError:
     |
     |  __repr__(self)
     |      Return repr(self).
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors inherited from RedisError:
     |
     |  __weakref__
     |      list of weak references to the object
     |
     |  ----------------------------------------------------------------------
     |  Static methods inherited from builtins.Exception:
     |
     |  __new__(*args, **kwargs) class method of builtins.Exception
     |      Create and return a new object.  See help(type) for accurate signature.
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from builtins.BaseException:
     |
     |  __getattribute__(self, name, /)
     |      Return getattr(self, name).
     |
     |  __reduce__(...)
     |      Helper for pickle.
     |
     |  __setstate__(...)
     |
     |  __str__(self, /)
     |      Return str(self).
     |
     |  add_note(...)
     |      Exception.add_note(note) --
     |      add a note to the exception
     |
     |  with_traceback(...)
     |      Exception.with_traceback(tb) --
     |      set self.__traceback__ to tb and return self.
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors inherited from builtins.BaseException:
     |
     |  __cause__
     |      exception cause
     |
     |  __context__
     |      exception context
     |
     |  __dict__
     |
     |  __suppress_context__
     |
     |  __traceback__
     |
     |  args

    class WatchError(RedisError)
     |  WatchError(*args, status_code: str | None = None)
     |
     |  Method resolution order:
     |      WatchError
     |      RedisError
     |      builtins.Exception
     |      builtins.BaseException
     |      builtins.object
     |
     |  Methods inherited from RedisError:
     |
     |  __init__(self, *args, status_code: str | None = None)
     |      Initialize self.  See help(type(self)) for accurate signature.
     |
     |  __repr__(self)
     |      Return repr(self).
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors inherited from RedisError:
     |
     |  __weakref__
     |      list of weak references to the object
     |
     |  ----------------------------------------------------------------------
     |  Static methods inherited from builtins.Exception:
     |
     |  __new__(*args, **kwargs) class method of builtins.Exception
     |      Create and return a new object.  See help(type) for accurate signature.
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from builtins.BaseException:
     |
     |  __getattribute__(self, name, /)
     |      Return getattr(self, name).
     |
     |  __reduce__(...)
     |      Helper for pickle.
     |
     |  __setstate__(...)
     |
     |  __str__(self, /)
     |      Return str(self).
     |
     |  add_note(...)
     |      Exception.add_note(note) --
     |      add a note to the exception
     |
     |  with_traceback(...)
     |      Exception.with_traceback(tb) --
     |      set self.__traceback__ to tb and return self.
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors inherited from builtins.BaseException:
     |
     |  __cause__
     |      exception cause
     |
     |  __context__
     |      exception context
     |
     |  __dict__
     |
     |  __suppress_context__
     |
     |  __traceback__
     |
     |  args

FILE
    c:\users\youse\appdata\local\programs\python\python312\lib\site-packages\redis\exceptions.py

Python Library Documentation: function from_url in module redis.utils

from_url(url: str, **kwargs: Any) -> 'Redis'
    Returns an active Redis client generated from the given database URL.

    Will attempt to extract the database id from the path url fragment, if
    none is provided.

Python Library Documentation: function get_channel_type in module redis.keyspace_notifications

get_channel_type(channel: 'str | bytes') -> 'ChannelType | None'
    Determine the type of a Redis keyspace notification channel.

    Args:
        channel: The channel name to check (string or bytes).

    Returns:
        ChannelType.KEYSPACE if it's a keyspace notification channel,
        ChannelType.KEYEVENT if it's a keyevent notification channel,
        None if it's not a keyspace notification channel.

    Examples:
        >>> get_channel_type("__keyspace@0__:mykey")
        ChannelType.KEYSPACE
        >>> get_channel_type("__keyevent@0__:set")
        ChannelType.KEYEVENT
        >>> get_channel_type("regular_channel") is None
        True
        >>> get_channel_type(b"__keyspace@0__:mykey")
        ChannelType.KEYSPACE

Python Library Documentation: module redis.himport in redis

NAME
    redis.himport - HIMPORT client-side fieldset registry for redis-py.

DESCRIPTION
    `HIMPORT` lets a client register an ordered list of hash field names once per
    connection (a *fieldset*) and then create many hashes by sending only values.
    Because a fieldset is server-side session state bound to a single physical
    connection, redis-py keeps a client-level registry of the fieldsets the
    application has declared and prepares them lazily, per connection, on first use
    by ``himport_set``.

    This module holds only that registry. It is pure in-memory state with no I/O and
    no ``asyncio`` primitives, so a single class is shared by both the sync and async
    clients.

    Example::

        >>> from redis.himport import HImportRegistry
        >>> registry = HImportRegistry()
        >>> registry.prepare("account_data", ["name", "email", "age"])
        >>> registry.get("account_data").fields
        ('name', 'email', 'age')

CLASSES
    builtins.object
        HImportFieldset
        HImportRegistry

    class HImportFieldset(builtins.object)
     |  HImportFieldset(name: str, fields: tuple[typing.Union[bytes, bytearray, memoryview, str, int, float], ...], version: int) -> None
     |
     |  An immutable HIMPORT fieldset entry.
     |
     |  Attributes:
     |      name: Fieldset name used by ``HIMPORT SET`` / ``HIMPORT DISCARD``.
     |      fields: Ordered field names, exactly as supplied by the caller. They are
     |          never reordered or deduplicated (HLD R.2): the server canonicalizes
     |          field order internally and rejects duplicate field names, so the
     |          client only preserves the caller's positional order.
     |      version: Monotonic stamp bumped each time the fieldset is (re)declared.
     |          Connections compare the version they last prepared against this value
     |          to detect a stale prepared state; the stamp is drawn from the registry's
     |          mutation clock (:attr:`HImportRegistry.revision`), which never repeats,
     |          so discarding and re-declaring the same name yields a fresh version
     |          rather than a colliding one. This is the prepare-side signal; the
     |          discard-side counterpart is the clock advancing on removal, since a
     |          removed fieldset leaves no entry to stamp.
     |
     |  Methods defined here:
     |
     |  __delattr__(self, name)
     |      Implement delattr(self, name).
     |
     |  __eq__(self, other)
     |      Return self==value.
     |
     |  __hash__(self)
     |      Return hash(self).
     |
     |  __init__(self, name: str, fields: tuple[typing.Union[bytes, bytearray, memoryview, str, int, float], ...], version: int) -> None
     |      Initialize self.  See help(type(self)) for accurate signature.
     |
     |  __repr__(self)
     |      Return repr(self).
     |
     |  __setattr__(self, name, value)
     |      Implement setattr(self, name, value).
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors defined here:
     |
     |  __dict__
     |      dictionary for instance variables
     |
     |  __weakref__
     |      list of weak references to the object
     |
     |  ----------------------------------------------------------------------
     |  Data and other attributes defined here:
     |
     |  __annotations__ = {'fields': tuple[typing.Union[bytes, bytearray, memo...
     |
     |  __dataclass_fields__ = {'fields': Field(name='fields',type=tuple[typin...
     |
     |  __dataclass_params__ = _DataclassParams(init=True,repr=True,eq=True,or...
     |
     |  __match_args__ = ('name', 'fields', 'version')

    class HImportRegistry(builtins.object)
     |  HImportRegistry() -> None
     |
     |  Client-level registry of HIMPORT fieldsets.
     |
     |  Pure in-memory state, shared by the sync and async clients. It is mutated only
     |  through the client's ``himport_prepare`` / ``himport_discard`` /
     |  ``himport_discard_all`` methods and exposed read-only through the client's
     |  ``himport_registry`` property. Mutations are serialized under a lock so the
     |  revision bump and dict change stay consistent when a sync ``Redis`` instance is
     |  shared across threads. Reads that iterate or snapshot the registry take the same
     |  lock, so a concurrent mutation cannot make them observe a torn view or raise
     |  ``dictionary changed size during iteration``; single-key/scalar reads (``get``,
     |  ``__contains__``, ``__len__``, :attr:`revision`) are atomic and stay lock-free.
     |  The async client runs single-threaded and never contends.
     |
     |  The registry always starts empty; fieldsets are declared at runtime through the
     |  client's ``himport_prepare`` method.
     |
     |  Methods defined here:
     |
     |  __contains__(self, name: object) -> bool
     |
     |  __init__(self) -> None
     |      Initialize self.  See help(type(self)) for accurate signature.
     |
     |  __iter__(self) -> collections.abc.Iterator[str]
     |
     |  __len__(self) -> int
     |
     |  __repr__(self) -> str
     |      Return repr(self).
     |
     |  discard(self, name: str) -> bool
     |      Remove a fieldset from the registry.
     |
     |      Returns ``True`` if a fieldset was removed, ``False`` if ``name`` was not
     |      registered. Advances :attr:`revision` when a fieldset is actually removed.
     |
     |  discard_all(self) -> int
     |      Remove all fieldsets and return the number removed.
     |
     |      Advances :attr:`revision` when at least one fieldset is removed.
     |
     |  get(self, name: str) -> redis.himport.HImportFieldset | None
     |      Return the fieldset registered under ``name``, or ``None``.
     |
     |  items(self) -> list[tuple[str, redis.himport.HImportFieldset]]
     |      Return a snapshot of ``(name, fieldset)`` pairs.
     |
     |  names(self) -> list[str]
     |      Return the registered fieldset names.
     |
     |  names_to_discard(self, prepared_names: collections.abc.Iterable[str]) -> list[str]
     |      Return which of ``prepared_names`` are no longer registered.
     |
     |      Given the fieldset names a connection has prepared on the server, this is
     |      the set that must be sent ``HIMPORT DISCARD`` (typically when the
     |      connection is released), because they have been removed from the registry.
     |
     |  prepare(self, name: str, fields: collections.abc.Iterable[typing.Union[bytes, bytearray, memoryview, str, int, float]]) -> redis.himport.HImportFieldset
     |      Add or replace a fieldset, bumping its version, and return the entry.
     |
     |      Re-declaring an existing name replaces its fields and bumps its version.
     |      Field order is preserved verbatim; nothing is reordered or deduplicated.
     |
     |  ----------------------------------------------------------------------
     |  Readonly properties defined here:
     |
     |  revision
     |      Monotonic mutation clock, advanced on every registry change.
     |
     |      It is the discard-side counterpart to per-fieldset
     |      :attr:`HImportFieldset.version`. A connection records the revision it last
     |      reconciled against; when it differs, a discard (or prepare) has occurred
     |      since, so the connection recomputes which of its prepared fieldsets are no
     |      longer registered — see :meth:`names_to_discard` — and discards those when
     |      it is released back to the pool.
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors defined here:
     |
     |  __dict__
     |      dictionary for instance variables
     |
     |  __weakref__
     |      list of weak references to the object

FUNCTIONS
    himport_discard_command(fieldset_name: str) -> tuple
        Positional wire args for ``HIMPORT DISCARD fieldset_name``.

    himport_prepare_command(fieldset_name: str, fields: collections.abc.Iterable[typing.Union[bytes, bytearray, memoryview, str, int, float]]) -> tuple
        Positional wire args for ``HIMPORT PREPARE fieldset_name field [field ...]``.

    himport_set_command(key: Union[bytes, str, memoryview], fieldset_name: str, values: collections.abc.Iterable[typing.Union[bytes, bytearray, memoryview, str, int, float]]) -> tuple
        Positional wire args for ``HIMPORT SET key fieldset_name value [value ...]``.

    is_himport_set_command(command_name) -> bool
        Return ``True`` if ``command_name`` names the ``HIMPORT SET`` command.

        Redis command names are case-insensitive on the wire, and a caller using the
        raw ``execute_command`` API may pass the name in any case and as either
        ``str`` or ``bytes`` (e.g. ``execute_command("himport set", ...)`` or
        ``b"HIMPORT SET"``). The connection-state-aware ``HIMPORT SET`` path keys off
        the command name, so it must recognise all of those spellings: an exact
        comparison against :data:`HIMPORT_SET` would miss them and send a bare SET
        that fails with ``no such fieldset`` for a fieldset registered in the client
        but not yet PREPAREd on the borrowed connection. The length check keeps the
        per-command cost on the hot path to a single comparison for the common case
        of a differently-sized command name (``upper()`` runs only on a size match).

    parse_himport_set_args(args)
        Detect an ``HIMPORT SET`` command in ``args`` and return its operands.

        ``HIMPORT SET`` reaches the raw ``execute_command`` API in two wire-equivalent
        forms that the serializer both accept:

        * the joined form ``("HIMPORT SET", key, fieldset, *values)`` (``args[0]`` is
          the two-word command name the request packer splits on the space), and
        * the split form ``("HIMPORT", "SET", key, fieldset, *values)``.

        Both are case- and encoding-insensitive. The connection-state-aware executor
        and the pipeline pre-flight need the operands at the right offsets for either
        form, so this returns ``(key, fieldset_name, values_list)`` when ``args`` is an
        ``HIMPORT SET`` with enough operands, or ``None`` otherwise (a non-``HIMPORT
        SET`` command, or one with too few operands -- which falls through to the plain
        send so the server returns its own arity error).

DATA
    EncodableT = typing.Union[bytes, bytearray, memoryview, str, int, floa...
    FieldT = typing.Union[bytes, bytearray, memoryview, str, int, float]
    HIMPORT_DISCARD = 'HIMPORT DISCARD'
    HIMPORT_DISCARDALL = 'HIMPORT DISCARDALL'
    HIMPORT_PREPARE = 'HIMPORT PREPARE'
    HIMPORT_SET = 'HIMPORT SET'
    KeyT = typing.Union[bytes, str, memoryview]

FILE
    c:\users\youse\appdata\local\programs\python\python312\lib\site-packages\redis\himport.py

Python Library Documentation: function int_or_str in module redis

int_or_str(value)

Python Library Documentation: module redis.keyspace_notifications in redis

NAME
    redis.keyspace_notifications - Redis Keyspace Notifications support for redis-py.

DESCRIPTION
    This module provides utilities for subscribing to and parsing Redis keyspace
    notifications. Keyspace notifications allow clients to receive events when
    keys are modified in Redis.

    Note: Keyspace notifications must be enabled on the Redis server via the
    ``notify-keyspace-events`` configuration option. This is a server-side
    configuration that should be done by your infrastructure/operations team.
    See the Redis documentation for details:
    https://redis.io/docs/latest/develop/pubsub/keyspace-notifications/

    Standalone Redis Example:
        >>> from redis import Redis
        >>> from redis.keyspace_notifications import (
        ...     KeyspaceNotifications,
        ...     KeyspaceChannel,
        ...     EventType,
        ... )
        >>>
        >>> r = Redis()
        >>> # Server must have notify-keyspace-events configured (e.g., "KEA")
        >>> ksn = KeyspaceNotifications(r)
        >>>
        >>> # Subscribe using Channel class (patterns auto-detected)
        >>> channel = KeyspaceChannel("user:*")
        >>> ksn.subscribe(channel)
        >>>
        >>> # Or use convenience methods for specific event types
        >>> ksn.subscribe_keyevent(EventType.SET)
        >>>
        >>> for notification in ksn.listen():
        ...     print(f"Key: {notification.key}, Event: {notification.event_type}")

    Redis Cluster Example:
        >>> from redis.cluster import RedisCluster
        >>> from redis.keyspace_notifications import (
        ...     ClusterKeyspaceNotifications,
        ...     KeyspaceChannel,
        ...     EventType,
        ... )
        >>>
        >>> rc = RedisCluster(host="localhost", port=7000)
        >>> # Server must have notify-keyspace-events configured (e.g., "KEA")
        >>> ksn = ClusterKeyspaceNotifications(rc)
        >>>
        >>> # Subscribe using Channel class (patterns auto-detected)
        >>> channel = KeyspaceChannel("user:*")
        >>> ksn.subscribe(channel)
        >>>
        >>> # Or use convenience methods for specific event types
        >>> ksn.subscribe_keyevent(EventType.SET)
        >>>
        >>> for notification in ksn.listen():
        ...     print(f"Key: {notification.key}, Event: {notification.event_type}")

CLASSES
    abc.ABC(builtins.object)
        KeyspaceNotificationsInterface
            AbstractKeyspaceNotifications
                ClusterKeyspaceNotifications
                KeyspaceNotifications
    builtins.object
        EventType
        KeyNotification
        KeyeventChannel
        KeyspaceChannel
        SubkeyeventChannel
        SubkeyspaceChannel
        SubkeyspaceeventChannel
        SubkeyspaceitemChannel
    enum.Enum(builtins.object)
        ChannelType
    threading.Thread(builtins.object)
        KeyspaceWorkerThread

    class AbstractKeyspaceNotifications(KeyspaceNotificationsInterface)
     |  AbstractKeyspaceNotifications(key_prefix: 'str | bytes | None' = None, ignore_subscribe_messages: 'bool' = True)
     |
     |  Abstract base class for keyspace notification managers.
     |
     |  Provides shared implementation for subscribe/unsubscribe logic.
     |  Subclasses must implement:
     |  - _execute_subscribe: Execute the subscribe operation
     |  - _execute_unsubscribe: Execute the unsubscribe operation
     |  - get_message: Get the next notification
     |  - listen: Generator for notifications
     |  - close: Clean up resources
     |
     |  Method resolution order:
     |      AbstractKeyspaceNotifications
     |      KeyspaceNotificationsInterface
     |      abc.ABC
     |      builtins.object
     |
     |  Methods defined here:
     |
     |  __enter__(self)
     |
     |  __exit__(self, _exc_type, _exc_val, _exc_tb)
     |
     |  __init__(self, key_prefix: 'str | bytes | None' = None, ignore_subscribe_messages: 'bool' = True)
     |      Initialize the base keyspace notification manager.
     |
     |      Args:
     |          key_prefix: Optional prefix to filter and strip from keys in notifications
     |          ignore_subscribe_messages: If True, subscribe/unsubscribe confirmations
     |                                    are not returned by get_message/listen
     |
     |  run_in_thread(self, poll_timeout: 'float' = 0.0, daemon: 'bool' = False, exception_handler: 'Callable[[BaseException, KeyspaceNotificationsInterface, KeyspaceWorkerThread], None] | None' = None) -> 'KeyspaceWorkerThread'
     |      Start a background thread that polls for notifications and triggers handlers.
     |
     |      This method spawns a thread that continuously calls get_message() to
     |      process incoming notifications. When a notification arrives, any
     |      registered handler for that channel/pattern is invoked automatically.
     |
     |      All subscriptions must have handlers registered before calling this method.
     |
     |      Args:
     |          poll_timeout: Timeout in seconds for get_message() calls. When no message
     |                       is available, the thread waits up to this long before checking
     |                       again. Default 0.0 (non-blocking). WARNING: the default
     |                       causes a CPU spin-loop. It is preferred to pass a positive
     |                       value (e.g. 0.1 or 1.0).
     |          daemon: If True, the thread will be a daemon thread and will be
     |                 terminated when the main program exits. Default False.
     |          exception_handler: Optional callback invoked when an exception occurs
     |                            in the worker thread. Receives (exception, notifications,
     |                            thread) as arguments. If None, exceptions are raised.
     |
     |      Returns:
     |          KeyspaceWorkerThread: The started worker thread. Call stop() on it
     |                               to stop the thread and close the notifications.
     |
     |      Raises:
     |          RedisError: If any subscription doesn't have a handler registered.
     |
     |      Example:
     |          >>> def my_handler(notification):
     |          ...     print(f"Got: {notification.key} - {notification.event_type}")
     |          >>>
     |          >>> notifications.subscribe(KeyspaceChannel("user:*"), handler=my_handler)
     |          >>> thread = notifications.run_in_thread(poll_timeout=0.1, daemon=True)
     |          >>> # ... handlers are called automatically ...
     |          >>> thread.stop()
     |
     |  subscribe(self, *channels: 'ChannelT', handler: 'SyncHandlerT | None' = None)
     |      Subscribe to keyspace notification channels.
     |
     |      Automatically detects whether each channel is a pattern (contains
     |      wildcards like *, ?, [) or an exact channel name and uses the
     |      appropriate Redis subscribe command internally.
     |
     |      Args:
     |          *channels: Channels to subscribe to. Can be strings, KeyspaceChannel,
     |                    or KeyeventChannel objects. Patterns are auto-detected.
     |          handler: Optional callback function that receives KeyNotification
     |                  objects. If provided, notifications are passed to the handler
     |                  instead of being returned by get_message()/listen().
     |
     |  subscribe_keyevent(self, event: 'str', db: 'int' = 0, handler: 'SyncHandlerT | None' = None)
     |      Subscribe to keyevent notifications for specific event types.
     |
     |      Args:
     |          event: The event type to monitor (e.g., EventType.SET or "set")
     |          db: The database number (default 0).
     |          handler: Optional callback for notifications.
     |
     |      Example:
     |          >>> ksn.subscribe_keyevent(EventType.SET)
     |          >>> ksn.subscribe_keyevent(EventType.EXPIRED, handler=my_handler)
     |
     |  subscribe_keyspace(self, key_or_pattern: 'str', db: 'int' = 0, handler: 'SyncHandlerT | None' = None)
     |      Subscribe to keyspace notifications for specific keys.
     |
     |      Args:
     |          key_or_pattern: The key or pattern to monitor. Use '*' for wildcards.
     |          db: The database number (default 0).
     |          handler: Optional callback for notifications.
     |
     |      Example:
     |          >>> ksn.subscribe_keyspace("user:123", db=0)
     |          >>> ksn.subscribe_keyspace("user:*", db=0)
     |
     |  subscribe_subkeyevent(self, event: 'str', db: 'int' = 0, handler: 'SyncHandlerT | None' = None)
     |      Subscribe to subkeyevent notifications for specific event types.
     |
     |      Receives the affected key and subkeys when the given event occurs.
     |
     |      Args:
     |          event: The event type to monitor (e.g., "hset", "hdel").
     |          db: The database number (default 0).
     |          handler: Optional callback for notifications.
     |
     |  subscribe_subkeyspace(self, key_or_pattern: 'str', db: 'int' = 0, handler: 'SyncHandlerT | None' = None)
     |      Subscribe to subkeyspace notifications for specific keys.
     |
     |      Receives events with affected subkeys (fields) for the given key.
     |
     |      Args:
     |          key_or_pattern: The key or pattern to monitor.
     |          db: The database number (default 0).
     |          handler: Optional callback for notifications.
     |
     |  subscribe_subkeyspaceevent(self, event: 'str', key_or_pattern: 'str', db: 'int' = 0, handler: 'SyncHandlerT | None' = None)
     |      Subscribe to subkeyspaceevent notifications for an event on a key.
     |
     |      Receives the affected subkeys when the given event occurs on the
     |      given key.
     |
     |      Args:
     |          event: The event type to monitor.
     |          key_or_pattern: The key or pattern to monitor.
     |          db: The database number (default 0).
     |          handler: Optional callback for notifications.
     |
     |  subscribe_subkeyspaceitem(self, key_or_pattern: 'str', subkey_or_pattern: 'str', db: 'int' = 0, handler: 'SyncHandlerT | None' = None)
     |      Subscribe to subkeyspaceitem notifications for a specific subkey.
     |
     |      Receives the event type when the given subkey of the given key is
     |      modified.
     |
     |      Args:
     |          key_or_pattern: The key or pattern to monitor.
     |          subkey_or_pattern: The subkey (field) or pattern to monitor.
     |          db: The database number (default 0).
     |          handler: Optional callback for notifications.
     |
     |  unsubscribe(self, *channels: 'ChannelT')
     |      Unsubscribe from keyspace notification channels.
     |
     |      Automatically detects whether each channel is a pattern or exact
     |      channel and uses the appropriate Redis unsubscribe command.
     |
     |      Args:
     |          *channels: Channels to unsubscribe from.
     |
     |  ----------------------------------------------------------------------
     |  Data and other attributes defined here:
     |
     |  __abstractmethods__ = frozenset({'_execute_subscribe', '_execute_unsub...
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from KeyspaceNotificationsInterface:
     |
     |  close(self)
     |      Close the notification manager and clean up resources.
     |
     |  get_message(self, ignore_subscribe_messages: 'bool | None' = None, timeout: 'float' = 0.0) -> 'KeyNotification | None'
     |      Get the next keyspace notification if one is available.
     |
     |  listen(self)
     |      Listen for keyspace notifications.
     |
     |  ----------------------------------------------------------------------
     |  Readonly properties inherited from KeyspaceNotificationsInterface:
     |
     |  subscribed
     |      Check if there are any active subscriptions and not closed.
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors inherited from KeyspaceNotificationsInterface:
     |
     |  __dict__
     |      dictionary for instance variables
     |
     |  __weakref__
     |      list of weak references to the object

    class ChannelType(enum.Enum)
     |  ChannelType(*values)
     |
     |  Enum representing the type of a Redis keyspace notification channel.
     |
     |  Redis provides two types of keyspace notifications and four subkey
     |  notification types:
     |
     |  - KEYSPACE: ``__keyspace@{db}__:{key}`` — data is the event type.
     |  - KEYEVENT: ``__keyevent@{db}__:{event}`` — data is the key name.
     |  - SUBKEYSPACE: ``__subkeyspace@{db}__:{key}`` — data is event + subkeys.
     |  - SUBKEYEVENT: ``__subkeyevent@{db}__:{event}`` — data is key + subkeys.
     |  - SUBKEYSPACEITEM: ``__subkeyspaceitem@{db}__:{key}\n{subkey}`` — data
     |    is the event type.
     |  - SUBKEYSPACEEVENT: ``__subkeyspaceevent@{db}__:{event}|{key}`` — data
     |    is a subkey list.
     |
     |  Examples:
     |      >>> get_channel_type("__keyspace@0__:mykey")
     |      ChannelType.KEYSPACE
     |      >>> get_channel_type("__subkeyspace@0__:myhash")
     |      ChannelType.SUBKEYSPACE
     |
     |  Method resolution order:
     |      ChannelType
     |      enum.Enum
     |      builtins.object
     |
     |  Data and other attributes defined here:
     |
     |  KEYEVENT = <ChannelType.KEYEVENT: 'keyevent'>
     |
     |  KEYSPACE = <ChannelType.KEYSPACE: 'keyspace'>
     |
     |  SUBKEYEVENT = <ChannelType.SUBKEYEVENT: 'subkeyevent'>
     |
     |  SUBKEYSPACE = <ChannelType.SUBKEYSPACE: 'subkeyspace'>
     |
     |  SUBKEYSPACEEVENT = <ChannelType.SUBKEYSPACEEVENT: 'subkeyspaceevent'>
     |
     |  SUBKEYSPACEITEM = <ChannelType.SUBKEYSPACEITEM: 'subkeyspaceitem'>
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors inherited from enum.Enum:
     |
     |  name
     |      The name of the Enum member.
     |
     |  value
     |      The value of the Enum member.
     |
     |  ----------------------------------------------------------------------
     |  Static methods inherited from enum.EnumType:
     |
     |  __contains__(value)
     |      Return True if `value` is in `cls`.
     |
     |      `value` is in `cls` if:
     |      1) `value` is a member of `cls`, or
     |      2) `value` is the value of one of the `cls`'s members.
     |
     |  __getitem__(name)
     |      Return the member matching `name`.
     |
     |  __iter__()
     |      Return members in definition order.
     |
     |  __len__()
     |      Return the number of members (no aliases)
     |
     |  ----------------------------------------------------------------------
     |  Readonly properties inherited from enum.EnumType:
     |
     |  __members__
     |      Returns a mapping of member name->value.
     |
     |      This mapping lists all enum members, including aliases. Note that this
     |      is a read-only view of the internal mapping.

    class ClusterKeyspaceNotifications(AbstractKeyspaceNotifications)
     |  ClusterKeyspaceNotifications(redis_cluster: 'RedisCluster', key_prefix: 'str | bytes | None' = None, ignore_subscribe_messages: 'bool' = True)
     |
     |  Manages keyspace notification subscriptions across all nodes in a Redis Cluster.
     |
     |  In Redis Cluster, keyspace notifications are NOT broadcast between nodes.
     |  Each node only emits notifications for keys it owns. This class automatically
     |  subscribes to all primary nodes in the cluster and handles topology changes.
     |
     |  Method resolution order:
     |      ClusterKeyspaceNotifications
     |      AbstractKeyspaceNotifications
     |      KeyspaceNotificationsInterface
     |      abc.ABC
     |      builtins.object
     |
     |  Methods defined here:
     |
     |  __init__(self, redis_cluster: 'RedisCluster', key_prefix: 'str | bytes | None' = None, ignore_subscribe_messages: 'bool' = True)
     |      Initialize the cluster keyspace notification manager.
     |
     |      Note: Keyspace notifications must be enabled on all Redis cluster nodes via
     |      the ``notify-keyspace-events`` configuration option. This is a server-side
     |      configuration that should be done by your infrastructure/operations team.
     |
     |      Args:
     |          redis_cluster: A RedisCluster instance
     |          key_prefix: Optional prefix to filter and strip from keys in notifications
     |          ignore_subscribe_messages: If True, subscribe/unsubscribe confirmations
     |                                    are not returned by get_message/listen
     |
     |  close(self)
     |      Close all pubsub connections and clean up resources.
     |
     |  get_message(self, ignore_subscribe_messages: 'bool | None' = None, timeout: 'float' = 0.0) -> 'KeyNotification | None'
     |      Get the next keyspace notification if one is available.
     |
     |      This method polls all node pubsubs in round-robin fashion until
     |      a message is received or the timeout expires.
     |      If a connection error occurs, subscriptions are automatically refreshed.
     |
     |      Args:
     |          ignore_subscribe_messages: If True, skip subscribe/unsubscribe messages.
     |                                    Defaults to the value set in __init__ (True).
     |          timeout: Total time to wait for a message (distributed across all nodes)
     |
     |      Returns:
     |          A KeyNotification if a notification is available, None otherwise.
     |
     |  listen(self)
     |      Listen for keyspace notifications from all cluster nodes.
     |
     |      This is a generator that yields KeyNotification objects as they arrive.
     |      It blocks until a notification is received.
     |
     |      Yields:
     |          KeyNotification objects for each keyspace/keyevent notification.
     |
     |      Example:
     |          >>> for notification in ksn.listen():
     |          ...     print(f"{notification.key}: {notification.event_type}")
     |
     |  refresh_subscriptions(self)
     |      Refresh subscriptions after a topology change.
     |
     |      This method is called automatically when topology changes are detected
     |      or when connection errors occur. You can also call it manually if needed.
     |
     |      This method:
     |      1. Discovers any new primary nodes and subscribes them
     |      2. Removes pubsubs for nodes that are no longer primaries
     |      3. Re-creates broken pubsub connections for existing nodes
     |
     |  ----------------------------------------------------------------------
     |  Readonly properties defined here:
     |
     |  subscribed
     |      Check if there are any active subscriptions and not closed.
     |
     |  ----------------------------------------------------------------------
     |  Data and other attributes defined here:
     |
     |  __abstractmethods__ = frozenset()
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from AbstractKeyspaceNotifications:
     |
     |  __enter__(self)
     |
     |  __exit__(self, _exc_type, _exc_val, _exc_tb)
     |
     |  run_in_thread(self, poll_timeout: 'float' = 0.0, daemon: 'bool' = False, exception_handler: 'Callable[[BaseException, KeyspaceNotificationsInterface, KeyspaceWorkerThread], None] | None' = None) -> 'KeyspaceWorkerThread'
     |      Start a background thread that polls for notifications and triggers handlers.
     |
     |      This method spawns a thread that continuously calls get_message() to
     |      process incoming notifications. When a notification arrives, any
     |      registered handler for that channel/pattern is invoked automatically.
     |
     |      All subscriptions must have handlers registered before calling this method.
     |
     |      Args:
     |          poll_timeout: Timeout in seconds for get_message() calls. When no message
     |                       is available, the thread waits up to this long before checking
     |                       again. Default 0.0 (non-blocking). WARNING: the default
     |                       causes a CPU spin-loop. It is preferred to pass a positive
     |                       value (e.g. 0.1 or 1.0).
     |          daemon: If True, the thread will be a daemon thread and will be
     |                 terminated when the main program exits. Default False.
     |          exception_handler: Optional callback invoked when an exception occurs
     |                            in the worker thread. Receives (exception, notifications,
     |                            thread) as arguments. If None, exceptions are raised.
     |
     |      Returns:
     |          KeyspaceWorkerThread: The started worker thread. Call stop() on it
     |                               to stop the thread and close the notifications.
     |
     |      Raises:
     |          RedisError: If any subscription doesn't have a handler registered.
     |
     |      Example:
     |          >>> def my_handler(notification):
     |          ...     print(f"Got: {notification.key} - {notification.event_type}")
     |          >>>
     |          >>> notifications.subscribe(KeyspaceChannel("user:*"), handler=my_handler)
     |          >>> thread = notifications.run_in_thread(poll_timeout=0.1, daemon=True)
     |          >>> # ... handlers are called automatically ...
     |          >>> thread.stop()
     |
     |  subscribe(self, *channels: 'ChannelT', handler: 'SyncHandlerT | None' = None)
     |      Subscribe to keyspace notification channels.
     |
     |      Automatically detects whether each channel is a pattern (contains
     |      wildcards like *, ?, [) or an exact channel name and uses the
     |      appropriate Redis subscribe command internally.
     |
     |      Args:
     |          *channels: Channels to subscribe to. Can be strings, KeyspaceChannel,
     |                    or KeyeventChannel objects. Patterns are auto-detected.
     |          handler: Optional callback function that receives KeyNotification
     |                  objects. If provided, notifications are passed to the handler
     |                  instead of being returned by get_message()/listen().
     |
     |  subscribe_keyevent(self, event: 'str', db: 'int' = 0, handler: 'SyncHandlerT | None' = None)
     |      Subscribe to keyevent notifications for specific event types.
     |
     |      Args:
     |          event: The event type to monitor (e.g., EventType.SET or "set")
     |          db: The database number (default 0).
     |          handler: Optional callback for notifications.
     |
     |      Example:
     |          >>> ksn.subscribe_keyevent(EventType.SET)
     |          >>> ksn.subscribe_keyevent(EventType.EXPIRED, handler=my_handler)
     |
     |  subscribe_keyspace(self, key_or_pattern: 'str', db: 'int' = 0, handler: 'SyncHandlerT | None' = None)
     |      Subscribe to keyspace notifications for specific keys.
     |
     |      Args:
     |          key_or_pattern: The key or pattern to monitor. Use '*' for wildcards.
     |          db: The database number (default 0).
     |          handler: Optional callback for notifications.
     |
     |      Example:
     |          >>> ksn.subscribe_keyspace("user:123", db=0)
     |          >>> ksn.subscribe_keyspace("user:*", db=0)
     |
     |  subscribe_subkeyevent(self, event: 'str', db: 'int' = 0, handler: 'SyncHandlerT | None' = None)
     |      Subscribe to subkeyevent notifications for specific event types.
     |
     |      Receives the affected key and subkeys when the given event occurs.
     |
     |      Args:
     |          event: The event type to monitor (e.g., "hset", "hdel").
     |          db: The database number (default 0).
     |          handler: Optional callback for notifications.
     |
     |  subscribe_subkeyspace(self, key_or_pattern: 'str', db: 'int' = 0, handler: 'SyncHandlerT | None' = None)
     |      Subscribe to subkeyspace notifications for specific keys.
     |
     |      Receives events with affected subkeys (fields) for the given key.
     |
     |      Args:
     |          key_or_pattern: The key or pattern to monitor.
     |          db: The database number (default 0).
     |          handler: Optional callback for notifications.
     |
     |  subscribe_subkeyspaceevent(self, event: 'str', key_or_pattern: 'str', db: 'int' = 0, handler: 'SyncHandlerT | None' = None)
     |      Subscribe to subkeyspaceevent notifications for an event on a key.
     |
     |      Receives the affected subkeys when the given event occurs on the
     |      given key.
     |
     |      Args:
     |          event: The event type to monitor.
     |          key_or_pattern: The key or pattern to monitor.
     |          db: The database number (default 0).
     |          handler: Optional callback for notifications.
     |
     |  subscribe_subkeyspaceitem(self, key_or_pattern: 'str', subkey_or_pattern: 'str', db: 'int' = 0, handler: 'SyncHandlerT | None' = None)
     |      Subscribe to subkeyspaceitem notifications for a specific subkey.
     |
     |      Receives the event type when the given subkey of the given key is
     |      modified.
     |
     |      Args:
     |          key_or_pattern: The key or pattern to monitor.
     |          subkey_or_pattern: The subkey (field) or pattern to monitor.
     |          db: The database number (default 0).
     |          handler: Optional callback for notifications.
     |
     |  unsubscribe(self, *channels: 'ChannelT')
     |      Unsubscribe from keyspace notification channels.
     |
     |      Automatically detects whether each channel is a pattern or exact
     |      channel and uses the appropriate Redis unsubscribe command.
     |
     |      Args:
     |          *channels: Channels to unsubscribe from.
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors inherited from KeyspaceNotificationsInterface:
     |
     |  __dict__
     |      dictionary for instance variables
     |
     |  __weakref__
     |      list of weak references to the object

    class EventType(builtins.object)
     |  Common Redis keyspace notification event type constants.
     |
     |  These are provided for convenience and IDE autocomplete. You can use
     |  any string as an event type - new Redis events will work without
     |  needing library updates.
     |
     |  Data descriptors defined here:
     |
     |  __dict__
     |      dictionary for instance variables
     |
     |  __weakref__
     |      list of weak references to the object
     |
     |  ----------------------------------------------------------------------
     |  Data and other attributes defined here:
     |
     |  APPEND = 'append'
     |
     |  BLMOVE = 'blmove'
     |
     |  BLPOP = 'blpop'
     |
     |  BRPOP = 'brpop'
     |
     |  BZPOPMAX = 'bzpopmax'
     |
     |  BZPOPMIN = 'bzpopmin'
     |
     |  COPY_TO = 'copy_to'
     |
     |  DECR = 'decr'
     |
     |  DECRBY = 'decrby'
     |
     |  DEL = 'del'
     |
     |  EVICTED = 'evicted'
     |
     |  EXPIRE = 'expire'
     |
     |  EXPIREAT = 'expireat'
     |
     |  EXPIRED = 'expired'
     |
     |  GETDEL = 'getdel'
     |
     |  GETEX = 'getex'
     |
     |  HDEL = 'hdel'
     |
     |  HINCRBY = 'hincrby'
     |
     |  HINCRBYFLOAT = 'hincrbyfloat'
     |
     |  HSET = 'hset'
     |
     |  HSETNX = 'hsetnx'
     |
     |  INCR = 'incr'
     |
     |  INCRBY = 'incrby'
     |
     |  INCRBYFLOAT = 'incrbyfloat'
     |
     |  LINSERT = 'linsert'
     |
     |  LMOVE = 'lmove'
     |
     |  LPOP = 'lpop'
     |
     |  LPUSH = 'lpush'
     |
     |  LSET = 'lset'
     |
     |  LTRIM = 'ltrim'
     |
     |  MOVE = 'move'
     |
     |  NEW = 'new'
     |
     |  PERSIST = 'persist'
     |
     |  PEXPIRE = 'pexpire'
     |
     |  PEXPIREAT = 'pexpireat'
     |
     |  RENAME = 'rename'
     |
     |  RENAME_FROM = 'rename_from'
     |
     |  RENAME_TO = 'rename_to'
     |
     |  RESTORE = 'restore'
     |
     |  RPOP = 'rpop'
     |
     |  RPUSH = 'rpush'
     |
     |  SADD = 'sadd'
     |
     |  SDIFFSTORE = 'sdiffstore'
     |
     |  SET = 'set'
     |
     |  SETEX = 'setex'
     |
     |  SETIFEQ = 'setifeq'
     |
     |  SETIFGT = 'setifgt'
     |
     |  SETIFLT = 'setiflt'
     |
     |  SETIFNE = 'setifne'
     |
     |  SETNX = 'setnx'
     |
     |  SETRANGE = 'setrange'
     |
     |  SINTERSTORE = 'sinterstore'
     |
     |  SMOVE = 'smove'
     |
     |  SORTSTORE = 'sortstore'
     |
     |  SPOP = 'spop'
     |
     |  SREM = 'srem'
     |
     |  SUNIONSTORE = 'sunionstore'
     |
     |  UNLINK = 'unlink'
     |
     |  XADD = 'xadd'
     |
     |  XAUTOCLAIM = 'xautoclaim'
     |
     |  XCLAIM = 'xclaim'
     |
     |  XDEL = 'xdel'
     |
     |  XGROUP_CREATE = 'xgroup-create'
     |
     |  XGROUP_CREATECONSUMER = 'xgroup-createconsumer'
     |
     |  XGROUP_DELCONSUMER = 'xgroup-delconsumer'
     |
     |  XGROUP_DESTROY = 'xgroup-destroy'
     |
     |  XGROUP_SETID = 'xgroup-setid'
     |
     |  XREADGROUP = 'xreadgroup'
     |
     |  XSETID = 'xsetid'
     |
     |  XTRIM = 'xtrim'
     |
     |  ZADD = 'zadd'
     |
     |  ZDIFFSTORE = 'zdiffstore'
     |
     |  ZINCRBY = 'zincrby'
     |
     |  ZINTERSTORE = 'zinterstore'
     |
     |  ZPOPMAX = 'zpopmax'
     |
     |  ZPOPMIN = 'zpopmin'
     |
     |  ZRANGESTORE = 'zrangestore'
     |
     |  ZREM = 'zrem'
     |
     |  ZREMRANGEBYLEX = 'zremrangebylex'
     |
     |  ZREMRANGEBYRANK = 'zremrangebyrank'
     |
     |  ZREMRANGEBYSCORE = 'zremrangebyscore'
     |
     |  ZUNIONSTORE = 'zunionstore'

    class KeyNotification(builtins.object)
     |  KeyNotification(key: 'str', event_type: 'str', database: 'int', channel: 'str', is_keyspace: 'bool', data: 'str', subkeys: 'list[str]' = None) -> None
     |
     |  Represents a parsed Redis keyspace, keyevent, or subkey notification.
     |
     |  This class provides convenient access to the notification details
     |  like key, event type, database number, and affected subkeys.
     |
     |  Attributes:
     |      key: The Redis key that was affected (for keyspace notifications)
     |           or the key name from the message data (for keyevent notifications)
     |      event_type: The type of operation that occurred (e.g., "set", "del").
     |                 This is a plain string, so new Redis events work automatically.
     |                 Compare against EventType constants or any string.
     |      database: The database number where the event occurred
     |      channel: The original channel name
     |      is_keyspace: True if this is a keyspace notification, False for keyevent
     |      data: The raw data payload from the notification message.
     |      subkeys: List of affected subkeys (fields) for subkey notifications.
     |              Empty list for regular keyspace/keyevent notifications.
     |
     |  Methods defined here:
     |
     |  __eq__(self, other)
     |      Return self==value.
     |
     |  __init__(self, key: 'str', event_type: 'str', database: 'int', channel: 'str', is_keyspace: 'bool', data: 'str', subkeys: 'list[str]' = None) -> None
     |      Initialize self.  See help(type(self)) for accurate signature.
     |
     |  __post_init__(self)
     |
     |  __repr__(self)
     |      Return repr(self).
     |
     |  key_starts_with(self, prefix: 'str | bytes') -> 'bool'
     |      Check if the key starts with the given prefix.
     |
     |  ----------------------------------------------------------------------
     |  Class methods defined here:
     |
     |  from_message(message: 'dict[str, Any] | None', key_prefix: 'str | bytes | None' = None) -> 'KeyNotification | None'
     |      Parse a pub/sub message into a KeyNotification.
     |
     |      Args:
     |          message: A pub/sub message dict with 'channel', 'data', and 'type' keys
     |          key_prefix: Optional prefix to filter and strip from keys.
     |                     If provided, only notifications for keys starting with
     |                     this prefix will be returned, and the prefix will be
     |                     stripped from the key.
     |
     |      Returns:
     |          A KeyNotification if the message is a valid keyspace/keyevent
     |          notification, None otherwise.
     |
     |      Example:
     |          >>> message = {
     |          ...     'type': 'pmessage',
     |          ...     'pattern': '__keyspace@0__:user:*',
     |          ...     'channel': '__keyspace@0__:user:123',
     |          ...     'data': 'set'
     |          ... }
     |          >>> notification = KeyNotification.from_message(message)
     |          >>> notification.key
     |          'user:123'
     |          >>> notification.event_type
     |          'set'
     |
     |  try_parse(channel: 'str | bytes', data: 'str | bytes', key_prefix: 'str | bytes | None' = None) -> 'KeyNotification | None'
     |      Try to parse a channel and data into a KeyNotification.
     |
     |      This is a lower-level method that takes the channel and data directly,
     |      useful when working with callback-based subscription handlers.
     |
     |      Args:
     |          channel: The channel name (e.g., "__keyspace@0__:mykey")
     |          data: The message data (event type for keyspace, key for keyevent)
     |          key_prefix: Optional prefix to filter and strip from keys
     |
     |      Returns:
     |          A KeyNotification if valid, None otherwise.
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors defined here:
     |
     |  __dict__
     |      dictionary for instance variables
     |
     |  __weakref__
     |      list of weak references to the object
     |
     |  ----------------------------------------------------------------------
     |  Data and other attributes defined here:
     |
     |  __annotations__ = {'_KEYEVENT_PATTERN': 'ClassVar[re.Pattern]', '_KEYS...
     |
     |  __dataclass_fields__ = {'_KEYEVENT_PATTERN': Field(name='_KEYEVENT_PAT...
     |
     |  __dataclass_params__ = _DataclassParams(init=True,repr=True,eq=True,or...
     |
     |  __hash__ = None
     |
     |  __match_args__ = ('key', 'event_type', 'database', 'channel', 'is_keys...
     |
     |  subkeys = None

    class KeyeventChannel(builtins.object)
     |  KeyeventChannel(event: 'str', db: 'int' = 0)
     |
     |  Represents a keyevent notification channel for subscribing to event types.
     |
     |  Keyevent notifications publish the key name as the message when the specified
     |  event type occurs on any key.
     |
     |  This class can be used directly with subscribe()/psubscribe() as it implements
     |  __str__ to return the channel string.
     |
     |  Attributes:
     |      event: The event type to monitor
     |      db: The database number (defaults to 0, the only database in Redis Cluster)
     |      is_pattern: Whether this channel contains wildcards
     |
     |  Examples:
     |      >>> channel = KeyeventChannel(EventType.SET, db=0)
     |      >>> str(channel)
     |      '__keyevent@0__:set'
     |
     |      >>> channel = KeyeventChannel.all_events(db=0)
     |      >>> str(channel)
     |      '__keyevent@0__:*'
     |
     |      >>> # Use with KeyspaceNotifications
     |      >>> notifications = KeyspaceNotifications(redis_client)
     |      >>> notifications.subscribe(channel)
     |
     |  Methods defined here:
     |
     |  __eq__(self, other: 'object') -> 'bool'
     |      Return self==value.
     |
     |  __hash__(self) -> 'int'
     |      Return hash(self).
     |
     |  __init__(self, event: 'str', db: 'int' = 0)
     |      Create a keyevent notification channel.
     |
     |      Args:
     |          event: The event type to monitor (e.g., EventType.SET or "set")
     |          db: The database number. Defaults to 0 (the only database in Redis Cluster).
     |
     |  __repr__(self) -> 'str'
     |      Return repr(self).
     |
     |  __str__(self) -> 'str'
     |      Return str(self).
     |
     |  ----------------------------------------------------------------------
     |  Class methods defined here:
     |
     |  all_events(db: 'int' = 0) -> "'KeyeventChannel'"
     |      Create a keyevent pattern for subscribing to all event types.
     |
     |      This is equivalent to KeyeventChannel("*").
     |
     |      Args:
     |          db: The database number. Defaults to 0 (the only database in Redis Cluster).
     |
     |      Returns:
     |          A KeyeventChannel configured to receive all events.
     |
     |      Examples:
     |          >>> channel = KeyeventChannel.all_events()
     |          >>> str(channel)
     |          '__keyevent@0__:*'
     |
     |  ----------------------------------------------------------------------
     |  Readonly properties defined here:
     |
     |  is_pattern
     |      Check if this channel contains wildcards and should use psubscribe.
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors defined here:
     |
     |  __dict__
     |      dictionary for instance variables
     |
     |  __weakref__
     |      list of weak references to the object
     |
     |  ----------------------------------------------------------------------
     |  Data and other attributes defined here:
     |
     |  PREFIX = '__keyevent@'
     |
     |  __annotations__ = {'PREFIX': 'ClassVar[str]'}

    class KeyspaceChannel(builtins.object)
     |  KeyspaceChannel(key_or_pattern: 'str', db: 'int' = 0)
     |
     |  Represents a keyspace notification channel for subscribing to events on keys.
     |
     |  Keyspace notifications publish the event type (e.g., "set", "del") as the message
     |  when a key matching the pattern is modified.
     |
     |  This class can be used directly with subscribe()/psubscribe() as it implements
     |  __str__ to return the channel string.
     |
     |  Attributes:
     |      key_or_pattern: The key or pattern to monitor (use '*' for wildcards)
     |      db: The database number (defaults to 0, the only database in Redis Cluster)
     |      is_pattern: Whether this channel contains wildcards
     |
     |  Examples:
     |      >>> channel = KeyspaceChannel("user:123", db=0)
     |      >>> str(channel)
     |      '__keyspace@0__:user:123'
     |
     |      >>> # Pattern subscription (wildcards are auto-detected)
     |      >>> channel = KeyspaceChannel("user:*", db=0)
     |      >>> str(channel)
     |      '__keyspace@0__:user:*'
     |
     |      >>> # Use with KeyspaceNotifications
     |      >>> notifications = KeyspaceNotifications(redis_client)
     |      >>> notifications.subscribe(channel)
     |
     |  Methods defined here:
     |
     |  __eq__(self, other: 'object') -> 'bool'
     |      Return self==value.
     |
     |  __hash__(self) -> 'int'
     |      Return hash(self).
     |
     |  __init__(self, key_or_pattern: 'str', db: 'int' = 0)
     |      Create a keyspace notification channel.
     |
     |      Args:
     |          key_or_pattern: The key or pattern to monitor. Use '*' for wildcards.
     |          db: The database number. Defaults to 0 (the only database in Redis Cluster).
     |
     |  __repr__(self) -> 'str'
     |      Return repr(self).
     |
     |  __str__(self) -> 'str'
     |      Return str(self).
     |
     |  ----------------------------------------------------------------------
     |  Readonly properties defined here:
     |
     |  is_pattern
     |      Check if this channel contains wildcards and should use psubscribe.
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors defined here:
     |
     |  __dict__
     |      dictionary for instance variables
     |
     |  __weakref__
     |      list of weak references to the object
     |
     |  ----------------------------------------------------------------------
     |  Data and other attributes defined here:
     |
     |  PREFIX = '__keyspace@'
     |
     |  __annotations__ = {'PREFIX': 'ClassVar[str]'}

    class KeyspaceNotifications(AbstractKeyspaceNotifications)
     |  KeyspaceNotifications(redis_client: 'Redis', key_prefix: 'str | bytes | None' = None, ignore_subscribe_messages: 'bool' = True)
     |
     |  Manages keyspace notification subscriptions for standalone Redis.
     |
     |  For standalone Redis, keyspace notifications work with a single PubSub
     |  connection. This class wraps that connection and provides:
     |  - Automatic pattern vs exact channel detection
     |  - KeyNotification parsing with optional key_prefix filtering
     |  - Convenience methods for keyspace and keyevent subscriptions
     |  - Context manager and run_in_thread support
     |
     |  Method resolution order:
     |      KeyspaceNotifications
     |      AbstractKeyspaceNotifications
     |      KeyspaceNotificationsInterface
     |      abc.ABC
     |      builtins.object
     |
     |  Methods defined here:
     |
     |  __init__(self, redis_client: 'Redis', key_prefix: 'str | bytes | None' = None, ignore_subscribe_messages: 'bool' = True)
     |      Initialize the standalone keyspace notification manager.
     |
     |      Note: Keyspace notifications must be enabled on the Redis server via
     |      the ``notify-keyspace-events`` configuration option. This is a server-side
     |      configuration that should be done by your infrastructure/operations team.
     |
     |      Args:
     |          redis_client: A Redis client instance
     |          key_prefix: Optional prefix to filter and strip from keys in notifications
     |          ignore_subscribe_messages: If True, subscribe/unsubscribe confirmations
     |                                    are not returned by get_message/listen
     |
     |  close(self)
     |      Close the pubsub connection and clean up resources.
     |
     |  get_message(self, ignore_subscribe_messages: 'bool | None' = None, timeout: 'float' = 0.0) -> 'KeyNotification | None'
     |      Get the next keyspace notification if one is available.
     |
     |      Note: If a handler was registered for the channel, pubsub will call
     |      the handler directly and this method returns None for that message.
     |
     |      Args:
     |          ignore_subscribe_messages: If True, skip subscribe/unsubscribe messages.
     |                                    Defaults to the value set in __init__ (True).
     |          timeout: Time to wait for a message.
     |
     |      Returns:
     |          A KeyNotification if a notification is available and no handler
     |          was registered for the channel, None otherwise.
     |
     |  listen(self)
     |      Listen for keyspace notifications.
     |
     |      This is a generator that yields KeyNotification objects as they arrive.
     |      It blocks until a notification is received.
     |
     |      Yields:
     |          KeyNotification objects for each keyspace/keyevent notification.
     |
     |      Example:
     |          >>> for notification in ksn.listen():
     |          ...     print(f"{notification.key}: {notification.event_type}")
     |
     |  ----------------------------------------------------------------------
     |  Readonly properties defined here:
     |
     |  subscribed
     |      Check if there are any active subscriptions and not closed.
     |
     |  ----------------------------------------------------------------------
     |  Data and other attributes defined here:
     |
     |  __abstractmethods__ = frozenset()
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from AbstractKeyspaceNotifications:
     |
     |  __enter__(self)
     |
     |  __exit__(self, _exc_type, _exc_val, _exc_tb)
     |
     |  run_in_thread(self, poll_timeout: 'float' = 0.0, daemon: 'bool' = False, exception_handler: 'Callable[[BaseException, KeyspaceNotificationsInterface, KeyspaceWorkerThread], None] | None' = None) -> 'KeyspaceWorkerThread'
     |      Start a background thread that polls for notifications and triggers handlers.
     |
     |      This method spawns a thread that continuously calls get_message() to
     |      process incoming notifications. When a notification arrives, any
     |      registered handler for that channel/pattern is invoked automatically.
     |
     |      All subscriptions must have handlers registered before calling this method.
     |
     |      Args:
     |          poll_timeout: Timeout in seconds for get_message() calls. When no message
     |                       is available, the thread waits up to this long before checking
     |                       again. Default 0.0 (non-blocking). WARNING: the default
     |                       causes a CPU spin-loop. It is preferred to pass a positive
     |                       value (e.g. 0.1 or 1.0).
     |          daemon: If True, the thread will be a daemon thread and will be
     |                 terminated when the main program exits. Default False.
     |          exception_handler: Optional callback invoked when an exception occurs
     |                            in the worker thread. Receives (exception, notifications,
     |                            thread) as arguments. If None, exceptions are raised.
     |
     |      Returns:
     |          KeyspaceWorkerThread: The started worker thread. Call stop() on it
     |                               to stop the thread and close the notifications.
     |
     |      Raises:
     |          RedisError: If any subscription doesn't have a handler registered.
     |
     |      Example:
     |          >>> def my_handler(notification):
     |          ...     print(f"Got: {notification.key} - {notification.event_type}")
     |          >>>
     |          >>> notifications.subscribe(KeyspaceChannel("user:*"), handler=my_handler)
     |          >>> thread = notifications.run_in_thread(poll_timeout=0.1, daemon=True)
     |          >>> # ... handlers are called automatically ...
     |          >>> thread.stop()
     |
     |  subscribe(self, *channels: 'ChannelT', handler: 'SyncHandlerT | None' = None)
     |      Subscribe to keyspace notification channels.
     |
     |      Automatically detects whether each channel is a pattern (contains
     |      wildcards like *, ?, [) or an exact channel name and uses the
     |      appropriate Redis subscribe command internally.
     |
     |      Args:
     |          *channels: Channels to subscribe to. Can be strings, KeyspaceChannel,
     |                    or KeyeventChannel objects. Patterns are auto-detected.
     |          handler: Optional callback function that receives KeyNotification
     |                  objects. If provided, notifications are passed to the handler
     |                  instead of being returned by get_message()/listen().
     |
     |  subscribe_keyevent(self, event: 'str', db: 'int' = 0, handler: 'SyncHandlerT | None' = None)
     |      Subscribe to keyevent notifications for specific event types.
     |
     |      Args:
     |          event: The event type to monitor (e.g., EventType.SET or "set")
     |          db: The database number (default 0).
     |          handler: Optional callback for notifications.
     |
     |      Example:
     |          >>> ksn.subscribe_keyevent(EventType.SET)
     |          >>> ksn.subscribe_keyevent(EventType.EXPIRED, handler=my_handler)
     |
     |  subscribe_keyspace(self, key_or_pattern: 'str', db: 'int' = 0, handler: 'SyncHandlerT | None' = None)
     |      Subscribe to keyspace notifications for specific keys.
     |
     |      Args:
     |          key_or_pattern: The key or pattern to monitor. Use '*' for wildcards.
     |          db: The database number (default 0).
     |          handler: Optional callback for notifications.
     |
     |      Example:
     |          >>> ksn.subscribe_keyspace("user:123", db=0)
     |          >>> ksn.subscribe_keyspace("user:*", db=0)
     |
     |  subscribe_subkeyevent(self, event: 'str', db: 'int' = 0, handler: 'SyncHandlerT | None' = None)
     |      Subscribe to subkeyevent notifications for specific event types.
     |
     |      Receives the affected key and subkeys when the given event occurs.
     |
     |      Args:
     |          event: The event type to monitor (e.g., "hset", "hdel").
     |          db: The database number (default 0).
     |          handler: Optional callback for notifications.
     |
     |  subscribe_subkeyspace(self, key_or_pattern: 'str', db: 'int' = 0, handler: 'SyncHandlerT | None' = None)
     |      Subscribe to subkeyspace notifications for specific keys.
     |
     |      Receives events with affected subkeys (fields) for the given key.
     |
     |      Args:
     |          key_or_pattern: The key or pattern to monitor.
     |          db: The database number (default 0).
     |          handler: Optional callback for notifications.
     |
     |  subscribe_subkeyspaceevent(self, event: 'str', key_or_pattern: 'str', db: 'int' = 0, handler: 'SyncHandlerT | None' = None)
     |      Subscribe to subkeyspaceevent notifications for an event on a key.
     |
     |      Receives the affected subkeys when the given event occurs on the
     |      given key.
     |
     |      Args:
     |          event: The event type to monitor.
     |          key_or_pattern: The key or pattern to monitor.
     |          db: The database number (default 0).
     |          handler: Optional callback for notifications.
     |
     |  subscribe_subkeyspaceitem(self, key_or_pattern: 'str', subkey_or_pattern: 'str', db: 'int' = 0, handler: 'SyncHandlerT | None' = None)
     |      Subscribe to subkeyspaceitem notifications for a specific subkey.
     |
     |      Receives the event type when the given subkey of the given key is
     |      modified.
     |
     |      Args:
     |          key_or_pattern: The key or pattern to monitor.
     |          subkey_or_pattern: The subkey (field) or pattern to monitor.
     |          db: The database number (default 0).
     |          handler: Optional callback for notifications.
     |
     |  unsubscribe(self, *channels: 'ChannelT')
     |      Unsubscribe from keyspace notification channels.
     |
     |      Automatically detects whether each channel is a pattern or exact
     |      channel and uses the appropriate Redis unsubscribe command.
     |
     |      Args:
     |          *channels: Channels to unsubscribe from.
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors inherited from KeyspaceNotificationsInterface:
     |
     |  __dict__
     |      dictionary for instance variables
     |
     |  __weakref__
     |      list of weak references to the object

    class KeyspaceNotificationsInterface(abc.ABC)
     |  Interface for keyspace notification managers.
     |
     |  This interface provides a consistent API for both standalone (KeyspaceNotifications)
     |  and cluster (ClusterKeyspaceNotifications) implementations, allowing the same
     |  code patterns to work with both standalone and cluster Redis deployments.
     |
     |  Method resolution order:
     |      KeyspaceNotificationsInterface
     |      abc.ABC
     |      builtins.object
     |
     |  Methods defined here:
     |
     |  __enter__(self)
     |
     |  __exit__(self, _exc_type, _exc_val, _exc_tb)
     |
     |  close(self)
     |      Close the notification manager and clean up resources.
     |
     |  get_message(self, ignore_subscribe_messages: 'bool | None' = None, timeout: 'float' = 0.0) -> 'KeyNotification | None'
     |      Get the next keyspace notification if one is available.
     |
     |  listen(self)
     |      Listen for keyspace notifications.
     |
     |  run_in_thread(self, poll_timeout: 'float' = 0.0, daemon: 'bool' = False, exception_handler: 'Callable[[BaseException, KeyspaceNotificationsInterface, KeyspaceWorkerThread], None] | None' = None) -> 'KeyspaceWorkerThread'
     |      Start a background thread that polls for notifications.
     |
     |  subscribe(self, *channels: 'ChannelT', handler: 'SyncHandlerT | None' = None)
     |      Subscribe to keyspace notification channels.
     |
     |  subscribe_keyevent(self, event: 'str', db: 'int' = 0, handler: 'SyncHandlerT | None' = None)
     |      Subscribe to keyevent notifications for specific event types.
     |
     |  subscribe_keyspace(self, key_or_pattern: 'str', db: 'int' = 0, handler: 'SyncHandlerT | None' = None)
     |      Subscribe to keyspace notifications for specific keys.
     |
     |  subscribe_subkeyevent(self, event: 'str', db: 'int' = 0, handler: 'SyncHandlerT | None' = None)
     |      Subscribe to subkeyevent notifications for specific event types.
     |
     |  subscribe_subkeyspace(self, key_or_pattern: 'str', db: 'int' = 0, handler: 'SyncHandlerT | None' = None)
     |      Subscribe to subkeyspace notifications for specific keys.
     |
     |  subscribe_subkeyspaceevent(self, event: 'str', key_or_pattern: 'str', db: 'int' = 0, handler: 'SyncHandlerT | None' = None)
     |      Subscribe to subkeyspaceevent notifications for an event on a key.
     |
     |  subscribe_subkeyspaceitem(self, key_or_pattern: 'str', subkey_or_pattern: 'str', db: 'int' = 0, handler: 'SyncHandlerT | None' = None)
     |      Subscribe to subkeyspaceitem notifications for a specific subkey.
     |
     |  unsubscribe(self, *channels: 'ChannelT')
     |      Unsubscribe from keyspace notification channels.
     |
     |  ----------------------------------------------------------------------
     |  Readonly properties defined here:
     |
     |  subscribed
     |      Check if there are any active subscriptions and not closed.
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors defined here:
     |
     |  __dict__
     |      dictionary for instance variables
     |
     |  __weakref__
     |      list of weak references to the object
     |
     |  ----------------------------------------------------------------------
     |  Data and other attributes defined here:
     |
     |  __abstractmethods__ = frozenset({'__enter__', '__exit__', 'close', 'ge...

    class KeyspaceWorkerThread(threading.Thread)
     |  KeyspaceWorkerThread(notifications: 'KeyspaceNotificationsInterface', poll_timeout: 'float', daemon: 'bool' = False, exception_handler: 'Callable[[BaseException, KeyspaceNotificationsInterface, KeyspaceWorkerThread], None] | None' = None)
     |
     |  Background thread for processing keyspace notifications.
     |
     |  This thread continuously polls for notifications and invokes registered
     |  handlers. It works with both KeyspaceNotifications (standalone) and
     |  ClusterKeyspaceNotifications.
     |
     |  Example:
     |      >>> thread = notifications.run_in_thread(poll_timeout=0.1)
     |      >>> # ... handlers are called automatically ...
     |      >>> thread.stop()
     |
     |  Method resolution order:
     |      KeyspaceWorkerThread
     |      threading.Thread
     |      builtins.object
     |
     |  Methods defined here:
     |
     |  __init__(self, notifications: 'KeyspaceNotificationsInterface', poll_timeout: 'float', daemon: 'bool' = False, exception_handler: 'Callable[[BaseException, KeyspaceNotificationsInterface, KeyspaceWorkerThread], None] | None' = None)
     |      This constructor should always be called with keyword arguments. Arguments are:
     |
     |      *group* should be None; reserved for future extension when a ThreadGroup
     |      class is implemented.
     |
     |      *target* is the callable object to be invoked by the run()
     |      method. Defaults to None, meaning nothing is called.
     |
     |      *name* is the thread name. By default, a unique name is constructed of
     |      the form "Thread-N" where N is a small decimal number.
     |
     |      *args* is a list or tuple of arguments for the target invocation. Defaults to ().
     |
     |      *kwargs* is a dictionary of keyword arguments for the target
     |      invocation. Defaults to {}.
     |
     |      If a subclass overrides the constructor, it must make sure to invoke
     |      the base class constructor (Thread.__init__()) before doing anything
     |      else to the thread.
     |
     |  run(self) -> 'None'
     |      Main loop that polls for notifications and triggers handlers.
     |
     |  stop(self) -> 'None'
     |      Stop the worker thread.
     |
     |      This signals the thread to exit its run loop. The thread will close
     |      the notifications object before terminating.
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from threading.Thread:
     |
     |  __repr__(self)
     |      Return repr(self).
     |
     |  getName(self)
     |      Return a string used for identification purposes only.
     |
     |      This method is deprecated, use the name attribute instead.
     |
     |  isDaemon(self)
     |      Return whether this thread is a daemon.
     |
     |      This method is deprecated, use the daemon attribute instead.
     |
     |  is_alive(self)
     |      Return whether the thread is alive.
     |
     |      This method returns True just before the run() method starts until just
     |      after the run() method terminates. See also the module function
     |      enumerate().
     |
     |  join(self, timeout=None)
     |      Wait until the thread terminates.
     |
     |      This blocks the calling thread until the thread whose join() method is
     |      called terminates -- either normally or through an unhandled exception
     |      or until the optional timeout occurs.
     |
     |      When the timeout argument is present and not None, it should be a
     |      floating-point number specifying a timeout for the operation in seconds
     |      (or fractions thereof). As join() always returns None, you must call
     |      is_alive() after join() to decide whether a timeout happened -- if the
     |      thread is still alive, the join() call timed out.
     |
     |      When the timeout argument is not present or None, the operation will
     |      block until the thread terminates.
     |
     |      A thread can be join()ed many times.
     |
     |      join() raises a RuntimeError if an attempt is made to join the current
     |      thread as that would cause a deadlock. It is also an error to join() a
     |      thread before it has been started and attempts to do so raises the same
     |      exception.
     |
     |  setDaemon(self, daemonic)
     |      Set whether this thread is a daemon.
     |
     |      This method is deprecated, use the .daemon property instead.
     |
     |  setName(self, name)
     |      Set the name string for this thread.
     |
     |      This method is deprecated, use the name attribute instead.
     |
     |  start(self)
     |      Start the thread's activity.
     |
     |      It must be called at most once per thread object. It arranges for the
     |      object's run() method to be invoked in a separate thread of control.
     |
     |      This method will raise a RuntimeError if called more than once on the
     |      same thread object.
     |
     |  ----------------------------------------------------------------------
     |  Readonly properties inherited from threading.Thread:
     |
     |  ident
     |      Thread identifier of this thread or None if it has not been started.
     |
     |      This is a nonzero integer. See the get_ident() function. Thread
     |      identifiers may be recycled when a thread exits and another thread is
     |      created. The identifier is available even after the thread has exited.
     |
     |  native_id
     |      Native integral thread ID of this thread, or None if it has not been started.
     |
     |      This is a non-negative integer. See the get_native_id() function.
     |      This represents the Thread ID as reported by the kernel.
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors inherited from threading.Thread:
     |
     |  __dict__
     |      dictionary for instance variables
     |
     |  __weakref__
     |      list of weak references to the object
     |
     |  daemon
     |      A boolean value indicating whether this thread is a daemon thread.
     |
     |      This must be set before start() is called, otherwise RuntimeError is
     |      raised. Its initial value is inherited from the creating thread; the
     |      main thread is not a daemon thread and therefore all threads created in
     |      the main thread default to daemon = False.
     |
     |      The entire Python program exits when only daemon threads are left.
     |
     |  name
     |      A string used for identification purposes only.
     |
     |      It has no semantics. Multiple threads may be given the same name. The
     |      initial name is set by the constructor.

    class SubkeyeventChannel(builtins.object)
     |  SubkeyeventChannel(event: 'str', db: 'int' = 0)
     |
     |  Represents a subkeyevent notification channel for subscribing to
     |  specific event types with subkey-level detail.
     |
     |  The channel format is ``__subkeyevent@<db>__:<event>``.
     |  The message payload is ``<key_len>:<key>|<subkey_len>:<subkey>[,...]``.
     |
     |  Examples:
     |      >>> channel = SubkeyeventChannel("hdel", db=0)
     |      >>> str(channel)
     |      '__subkeyevent@0__:hdel'
     |
     |  Methods defined here:
     |
     |  __eq__(self, other: 'object') -> 'bool'
     |      Return self==value.
     |
     |  __hash__(self) -> 'int'
     |      Return hash(self).
     |
     |  __init__(self, event: 'str', db: 'int' = 0)
     |      Initialize self.  See help(type(self)) for accurate signature.
     |
     |  __repr__(self) -> 'str'
     |      Return repr(self).
     |
     |  __str__(self) -> 'str'
     |      Return str(self).
     |
     |  ----------------------------------------------------------------------
     |  Class methods defined here:
     |
     |  all_events(db: 'int' = 0) -> 'SubkeyeventChannel'
     |      Create a channel for all subkeyevent types.
     |
     |  ----------------------------------------------------------------------
     |  Readonly properties defined here:
     |
     |  is_pattern
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors defined here:
     |
     |  __dict__
     |      dictionary for instance variables
     |
     |  __weakref__
     |      list of weak references to the object
     |
     |  ----------------------------------------------------------------------
     |  Data and other attributes defined here:
     |
     |  PREFIX = '__subkeyevent@'
     |
     |  __annotations__ = {'PREFIX': 'ClassVar[str]'}

    class SubkeyspaceChannel(builtins.object)
     |  SubkeyspaceChannel(key_or_pattern: 'str', db: 'int' = 0)
     |
     |  Represents a subkeyspace notification channel for subscribing to
     |  subkey-level events on keys (e.g., hash field changes).
     |
     |  The channel format is ``__subkeyspace@<db>__:<key>``.
     |  The message payload is ``<event>|<subkey_len>:<subkey>[,...]``.
     |
     |  Examples:
     |      >>> channel = SubkeyspaceChannel("myhash", db=0)
     |      >>> str(channel)
     |      '__subkeyspace@0__:myhash'
     |
     |  Methods defined here:
     |
     |  __eq__(self, other: 'object') -> 'bool'
     |      Return self==value.
     |
     |  __hash__(self) -> 'int'
     |      Return hash(self).
     |
     |  __init__(self, key_or_pattern: 'str', db: 'int' = 0)
     |      Initialize self.  See help(type(self)) for accurate signature.
     |
     |  __repr__(self) -> 'str'
     |      Return repr(self).
     |
     |  __str__(self) -> 'str'
     |      Return str(self).
     |
     |  ----------------------------------------------------------------------
     |  Readonly properties defined here:
     |
     |  is_pattern
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors defined here:
     |
     |  __dict__
     |      dictionary for instance variables
     |
     |  __weakref__
     |      list of weak references to the object
     |
     |  ----------------------------------------------------------------------
     |  Data and other attributes defined here:
     |
     |  PREFIX = '__subkeyspace@'
     |
     |  __annotations__ = {'PREFIX': 'ClassVar[str]'}

    class SubkeyspaceeventChannel(builtins.object)
     |  SubkeyspaceeventChannel(event: 'str', key_or_pattern: 'str', db: 'int' = 0)
     |
     |  Represents a subkeyspaceevent notification channel for subscribing to
     |  a specific event on a specific key, receiving affected subkeys.
     |
     |  The channel format is ``__subkeyspaceevent@<db>__:<event>|<key>``.
     |  The message payload is a length-prefixed subkey list.
     |
     |  Examples:
     |      >>> channel = SubkeyspaceeventChannel("hset", "myhash", db=0)
     |      >>> str(channel)
     |      '__subkeyspaceevent@0__:hset|myhash'
     |
     |  Methods defined here:
     |
     |  __eq__(self, other: 'object') -> 'bool'
     |      Return self==value.
     |
     |  __hash__(self) -> 'int'
     |      Return hash(self).
     |
     |  __init__(self, event: 'str', key_or_pattern: 'str', db: 'int' = 0)
     |      Initialize self.  See help(type(self)) for accurate signature.
     |
     |  __repr__(self) -> 'str'
     |      Return repr(self).
     |
     |  __str__(self) -> 'str'
     |      Return str(self).
     |
     |  ----------------------------------------------------------------------
     |  Readonly properties defined here:
     |
     |  is_pattern
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors defined here:
     |
     |  __dict__
     |      dictionary for instance variables
     |
     |  __weakref__
     |      list of weak references to the object
     |
     |  ----------------------------------------------------------------------
     |  Data and other attributes defined here:
     |
     |  PREFIX = '__subkeyspaceevent@'
     |
     |  __annotations__ = {'PREFIX': 'ClassVar[str]'}

    class SubkeyspaceitemChannel(builtins.object)
     |  SubkeyspaceitemChannel(key_or_pattern: 'str', subkey_or_pattern: 'str', db: 'int' = 0)
     |
     |  Represents a subkeyspaceitem notification channel for subscribing to
     |  events on a specific subkey (field) of a specific key.
     |
     |  The channel format is ``__subkeyspaceitem@<db>__:<key>\n<subkey>``.
     |  The message payload is the event type (e.g., ``"hset"``).
     |
     |  Note:
     |      The server only emits this notification when the key does not
     |      contain a newline character.
     |
     |  Examples:
     |      >>> channel = SubkeyspaceitemChannel("myhash", "myfield", db=0)
     |      >>> str(channel)
     |      '__subkeyspaceitem@0__:myhash\nmyfield'
     |
     |  Methods defined here:
     |
     |  __eq__(self, other: 'object') -> 'bool'
     |      Return self==value.
     |
     |  __hash__(self) -> 'int'
     |      Return hash(self).
     |
     |  __init__(self, key_or_pattern: 'str', subkey_or_pattern: 'str', db: 'int' = 0)
     |      Initialize self.  See help(type(self)) for accurate signature.
     |
     |  __repr__(self) -> 'str'
     |      Return repr(self).
     |
     |  __str__(self) -> 'str'
     |      Return str(self).
     |
     |  ----------------------------------------------------------------------
     |  Readonly properties defined here:
     |
     |  is_pattern
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors defined here:
     |
     |  __dict__
     |      dictionary for instance variables
     |
     |  __weakref__
     |      list of weak references to the object
     |
     |  ----------------------------------------------------------------------
     |  Data and other attributes defined here:
     |
     |  PREFIX = '__subkeyspaceitem@'
     |
     |  __annotations__ = {'PREFIX': 'ClassVar[str]'}

FUNCTIONS
    get_channel_type(channel: 'str | bytes') -> 'ChannelType | None'
        Determine the type of a Redis keyspace notification channel.

        Args:
            channel: The channel name to check (string or bytes).

        Returns:
            ChannelType.KEYSPACE if it's a keyspace notification channel,
            ChannelType.KEYEVENT if it's a keyevent notification channel,
            None if it's not a keyspace notification channel.

        Examples:
            >>> get_channel_type("__keyspace@0__:mykey")
            ChannelType.KEYSPACE
            >>> get_channel_type("__keyevent@0__:set")
            ChannelType.KEYEVENT
            >>> get_channel_type("regular_channel") is None
            True
            >>> get_channel_type(b"__keyspace@0__:mykey")
            ChannelType.KEYSPACE

DATA
    ChannelT = typing.Union[str, bytes, ForwardRef('KeyspaceCha...Channel'...
    ClassVar = typing.ClassVar
        Special type construct to mark class variables.

        An annotation wrapped in ClassVar indicates that a given
        attribute is intended to be used as a class variable and
        should not be set on instances of that class.

        Usage::

            class Starship:
                stats: ClassVar[dict[str, int]] = {} # class variable
                damage: int = 10                     # instance variable

        ClassVar accepts only types and cannot be further subscribed.

        Note that ClassVar is not a class itself, and should not
        be used with isinstance() or issubclass().

    SyncHandlerT = collections.abc.Callable[['KeyNotification'], None]
    TYPE_CHECKING = False
    Union = typing.Union
        Union type; Union[X, Y] means either X or Y.

        On Python 3.10 and higher, the | operator
        can also be used to denote unions;
        X | Y means the same thing to the type checker as Union[X, Y].

        To define a union, use e.g. Union[int, str]. Details:
        - The arguments must be types and there must be at least one.
        - None as an argument is a special case and is replaced by
          type(None).
        - Unions of unions are flattened, e.g.::

            assert Union[Union[int, str], float] == Union[int, str, float]

        - Unions of a single argument vanish, e.g.::

            assert Union[int] == int  # The constructor actually returns int

        - Redundant arguments are skipped, e.g.::

            assert Union[int, str, int] == Union[int, str]

        - When comparing unions, the argument order is ignored, e.g.::

            assert Union[int, str] == Union[str, int]

        - You cannot subclass or instantiate a union.
        - You can use Optional[X] as a shorthand for Union[X, None].

    __annotations__ = {'ChannelT': 'TypeAlias'}
    logger = <Logger redis.keyspace_notifications (WARNING)>

FILE
    c:\users\youse\appdata\local\programs\python\python312\lib\site-packages\redis\keyspace_notifications.py

Python Library Documentation: module redis.lock in redis

NAME
    redis.lock

CLASSES
    builtins.object
        Lock

    class Lock(builtins.object)
     |  Lock(redis, name: str, timeout: Union[int, float, NoneType] = None, sleep: Union[int, float] = 0.1, blocking: bool = True, blocking_timeout: Union[int, float, NoneType] = None, thread_local: bool = True, raise_on_release_error: bool = True)
     |
     |  A shared, distributed Lock. Using Redis for locking allows the Lock
     |  to be shared across processes and/or machines.
     |
     |  It's left to the user to resolve deadlock issues and make sure
     |  multiple clients play nicely together.
     |
     |  Methods defined here:
     |
     |  __enter__(self) -> 'Lock'
     |
     |  __exit__(self, exc_type: Optional[Type[BaseException]], exc_value: Optional[BaseException], traceback: Optional[traceback]) -> None
     |
     |  __init__(self, redis, name: str, timeout: Union[int, float, NoneType] = None, sleep: Union[int, float] = 0.1, blocking: bool = True, blocking_timeout: Union[int, float, NoneType] = None, thread_local: bool = True, raise_on_release_error: bool = True)
     |      Create a new Lock instance named ``name`` using the Redis client
     |      supplied by ``redis``.
     |
     |      ``timeout`` indicates a maximum life for the lock in seconds.
     |      By default, it will remain locked until release() is called.
     |      ``timeout`` can be specified as a float or integer, both representing
     |      the number of seconds to wait.
     |
     |      ``sleep`` indicates the amount of time to sleep in seconds per loop
     |      iteration when the lock is in blocking mode and another client is
     |      currently holding the lock.
     |
     |      ``blocking`` indicates whether calling ``acquire`` should block until
     |      the lock has been acquired or to fail immediately, causing ``acquire``
     |      to return False and the lock not being acquired. Defaults to True.
     |      Note this value can be overridden by passing a ``blocking``
     |      argument to ``acquire``.
     |
     |      ``blocking_timeout`` indicates the maximum amount of time in seconds to
     |      spend trying to acquire the lock. A value of ``None`` indicates
     |      continue trying forever. ``blocking_timeout`` can be specified as a
     |      float or integer, both representing the number of seconds to wait.
     |
     |      ``thread_local`` indicates whether the lock token is placed in
     |      thread-local storage. By default, the token is placed in thread local
     |      storage so that a thread only sees its token, not a token set by
     |      another thread. Consider the following timeline:
     |
     |          time: 0, thread-1 acquires `my-lock`, with a timeout of 5 seconds.
     |                   thread-1 sets the token to "abc"
     |          time: 1, thread-2 blocks trying to acquire `my-lock` using the
     |                   Lock instance.
     |          time: 5, thread-1 has not yet completed. redis expires the lock
     |                   key.
     |          time: 5, thread-2 acquired `my-lock` now that it's available.
     |                   thread-2 sets the token to "xyz"
     |          time: 6, thread-1 finishes its work and calls release(). if the
     |                   token is *not* stored in thread local storage, then
     |                   thread-1 would see the token value as "xyz" and would be
     |                   able to successfully release the thread-2's lock.
     |
     |      ``raise_on_release_error`` indicates whether to raise an exception when
     |      the lock is no longer owned when exiting the context manager. By default,
     |      this is True, meaning an exception will be raised. If False, the warning
     |      will be logged and the exception will be suppressed.
     |
     |      In some use cases it's necessary to disable thread local storage. For
     |      example, if you have code where one thread acquires a lock and passes
     |      that lock instance to a worker thread to release later. If thread
     |      local storage isn't disabled in this case, the worker thread won't see
     |      the token set by the thread that acquired the lock. Our assumption
     |      is that these cases aren't common and as such default to using
     |      thread local storage.
     |
     |  acquire(self, sleep: Union[int, float, NoneType] = None, blocking: Optional[bool] = None, blocking_timeout: Union[int, float, NoneType] = None, token: Optional[str] = None)
     |      Use Redis to hold a shared, distributed lock named ``name``.
     |      Returns True once the lock is acquired.
     |
     |      If ``blocking`` is False, always return immediately. If the lock
     |      was acquired, return True, otherwise return False.
     |
     |      ``blocking_timeout`` specifies the maximum number of seconds to
     |      wait trying to acquire the lock.
     |
     |      ``token`` specifies the token value to be used. If provided, token
     |      must be a bytes object or a string that can be encoded to a bytes
     |      object with the default encoding. If a token isn't specified, a UUID
     |      will be generated.
     |
     |  do_acquire(self, token: str) -> bool
     |
     |  do_extend(self, additional_time: Union[int, float], replace_ttl: bool) -> Literal[True]
     |
     |  do_reacquire(self) -> Literal[True]
     |
     |  do_release(self, expected_token: str) -> None
     |
     |  extend(self, additional_time: Union[int, float], replace_ttl: bool = False) -> Literal[True]
     |      Adds more time to an already acquired lock.
     |
     |      ``additional_time`` can be specified as an integer or a float, both
     |      representing the number of seconds to add.
     |
     |      ``replace_ttl`` if False (the default), add `additional_time` to
     |      the lock's existing ttl. If True, replace the lock's ttl with
     |      `additional_time`.
     |
     |  locked(self) -> bool
     |      Returns True if this key is locked by any process, otherwise False.
     |
     |  owned(self) -> bool
     |      Returns True if this key is locked by this lock, otherwise False.
     |
     |  reacquire(self) -> Literal[True]
     |      Resets a TTL of an already acquired lock back to a timeout value.
     |
     |  register_scripts(self) -> None
     |
     |  release(self) -> None
     |      Releases the already acquired lock
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors defined here:
     |
     |  __dict__
     |      dictionary for instance variables
     |
     |  __weakref__
     |      list of weak references to the object
     |
     |  ----------------------------------------------------------------------
     |  Data and other attributes defined here:
     |
     |  LUA_EXTEND_SCRIPT = "\n        local token = redis.call('get', KEYS[1]...
     |
     |  LUA_REACQUIRE_SCRIPT = "\n        local token = redis.call('get', KEYS...
     |
     |  LUA_RELEASE_SCRIPT = "\n        local token = redis.call('get', KEYS[1...
     |
     |  lua_extend = None
     |
     |  lua_reacquire = None
     |
     |  lua_release = None

DATA
    Literal = typing.Literal
        Special typing form to define literal types (a.k.a. value types).

        This form can be used to indicate to type checkers that the corresponding
        variable or function parameter has a value equivalent to the provided
        literal (or one of several literals)::

            def validate_simple(data: Any) -> Literal[True]:  # always returns True
                ...

            MODE = Literal['r', 'rb', 'w', 'wb']
            def open_helper(file: str, mode: MODE) -> str:
                ...

            open_helper('/some/path', 'r')  # Passes type check
            open_helper('/other/path', 'typo')  # Error in type checker

        Literal[...] cannot be subclassed. At runtime, an arbitrary value
        is allowed as type argument to Literal[...], but type checkers may
        impose restrictions.

    Number = typing.Union[int, float]
    Optional = typing.Optional
        Optional[X] is equivalent to Union[X, None].

    Type = typing.Type
        Deprecated alias to builtins.type.

        builtins.type or typing.Type can be used to annotate class objects.
        For example, suppose we have the following classes::

            class User: ...  # Abstract base for User classes
            class BasicUser(User): ...
            class ProUser(User): ...
            class TeamUser(User): ...

        And a function that takes a class argument that's a subclass of
        User and returns an instance of the corresponding class::

            def new_user[U](user_class: Type[U]) -> U:
                user = user_class()
                # (Here we could write the user object to a database)
                return user

            joe = new_user(BasicUser)

        At this point the type checker knows that joe has type BasicUser.

    logger = <Logger redis.lock (WARNING)>

FILE
    c:\users\youse\appdata\local\programs\python\python312\lib\site-packages\redis\lock.py

Python Library Documentation: module redis.maint_notifications in redis

NAME
    redis.maint_notifications

CLASSES
    abc.ABC(builtins.object)
        MaintenanceNotification
            NodeFailedOverNotification
            NodeFailingOverNotification
            NodeMigratedNotification
            NodeMigratingNotification
            NodeMovingNotification
            OSSNodeMigratedNotification
            OSSNodeMigratingNotification
    builtins.object
        MaintNotificationsConfig
        MaintNotificationsConnectionHandler
        MaintNotificationsPoolHandler
        OSSMaintNotificationsHandler
    enum.Enum(builtins.object)
        EndpointType
        MaintenanceState

    class EndpointType(enum.Enum)
     |  EndpointType(*values)
     |
     |  Valid endpoint types used in CLIENT MAINT_NOTIFICATIONS command.
     |
     |  Method resolution order:
     |      EndpointType
     |      enum.Enum
     |      builtins.object
     |
     |  Data and other attributes defined here:
     |
     |  EXTERNAL_FQDN = <EndpointType.EXTERNAL_FQDN: 'external-fqdn'>
     |
     |  EXTERNAL_IP = <EndpointType.EXTERNAL_IP: 'external-ip'>
     |
     |  INTERNAL_FQDN = <EndpointType.INTERNAL_FQDN: 'internal-fqdn'>
     |
     |  INTERNAL_IP = <EndpointType.INTERNAL_IP: 'internal-ip'>
     |
     |  NONE = <EndpointType.NONE: 'none'>
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors inherited from enum.Enum:
     |
     |  name
     |      The name of the Enum member.
     |
     |  value
     |      The value of the Enum member.
     |
     |  ----------------------------------------------------------------------
     |  Static methods inherited from enum.EnumType:
     |
     |  __contains__(value)
     |      Return True if `value` is in `cls`.
     |
     |      `value` is in `cls` if:
     |      1) `value` is a member of `cls`, or
     |      2) `value` is the value of one of the `cls`'s members.
     |
     |  __getitem__(name)
     |      Return the member matching `name`.
     |
     |  __iter__()
     |      Return members in definition order.
     |
     |  __len__()
     |      Return the number of members (no aliases)
     |
     |  ----------------------------------------------------------------------
     |  Readonly properties inherited from enum.EnumType:
     |
     |  __members__
     |      Returns a mapping of member name->value.
     |
     |      This mapping lists all enum members, including aliases. Note that this
     |      is a read-only view of the internal mapping.

    class MaintNotificationsConfig(builtins.object)
     |  MaintNotificationsConfig(enabled: Union[bool, Literal['auto']] = 'auto', proactive_reconnect: bool = True, relaxed_timeout: Union[int, float, NoneType] = 10, endpoint_type: Optional[redis.maint_notifications.EndpointType] = None)
     |
     |  Configuration class for maintenance notifications handling behaviour. Notifications are received through
     |  push notifications.
     |
     |  This class defines how the Redis client should react to different push notifications
     |  such as node moving, migrations, etc. in a Redis cluster.
     |
     |  Methods defined here:
     |
     |  __init__(self, enabled: Union[bool, Literal['auto']] = 'auto', proactive_reconnect: bool = True, relaxed_timeout: Union[int, float, NoneType] = 10, endpoint_type: Optional[redis.maint_notifications.EndpointType] = None)
     |      Initialize a new MaintNotificationsConfig.
     |
     |      Args:
     |          enabled (bool | "auto"): Controls maintenance notifications handling behavior.
     |              - True: The CLIENT MAINT_NOTIFICATIONS command must succeed during connection setup,
     |              otherwise a ResponseError is raised.
     |              - "auto": The CLIENT MAINT_NOTIFICATIONS command is attempted but failures are
     |              gracefully handled - a warning is logged and normal operation continues.
     |              - False: Maintenance notifications are completely disabled.
     |              Defaults to "auto".
     |          proactive_reconnect (bool): Whether to proactively reconnect when a node is replaced.
     |              Defaults to True.
     |          relaxed_timeout (Number): The relaxed timeout to use for the connection during maintenance.
     |              If -1 is provided - the relaxed timeout is disabled. Defaults to 20.
     |          endpoint_type (Optional[EndpointType]): Override for the endpoint type to use in CLIENT MAINT_NOTIFICATIONS.
     |              If None, the endpoint type will be automatically determined based on the host and TLS configuration.
     |              Defaults to None.
     |
     |      Raises:
     |          ValueError: If endpoint_type is provided but is not a valid endpoint type.
     |
     |  __repr__(self) -> str
     |      Return repr(self).
     |
     |  get_endpoint_type(self, host: str, connection: 'MaintNotificationsAbstractConnection | AsyncMaintNotificationsAbstractConnection') -> redis.maint_notifications.EndpointType
     |      Determine the appropriate endpoint type for CLIENT MAINT_NOTIFICATIONS command.
     |
     |      Logic:
     |      1. If endpoint_type is explicitly set, use it
     |      2. Otherwise, check the original host from connection.host:
     |         - If host is an IP address, use it directly to determine internal-ip vs external-ip
     |         - If host is an FQDN, get the resolved IP to determine internal-fqdn vs external-fqdn
     |
     |      Args:
     |          host: User provided hostname to analyze
     |          connection: The connection object to analyze for endpoint type determination
     |
     |      Returns:
     |
     |  is_relaxed_timeouts_enabled(self) -> bool
     |      Check if the relaxed_timeout is enabled. The '-1' value is used to disable the relaxed_timeout.
     |      If relaxed_timeout is set to None, it will make the operation blocking
     |      and waiting until any response is received.
     |
     |      Returns:
     |          True if the relaxed_timeout is enabled, False otherwise.
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors defined here:
     |
     |  __dict__
     |      dictionary for instance variables
     |
     |  __weakref__
     |      list of weak references to the object

    class MaintNotificationsConnectionHandler(builtins.object)
     |  MaintNotificationsConnectionHandler(connection: 'MaintNotificationsAbstractConnection', config: redis.maint_notifications.MaintNotificationsConfig) -> None
     |
     |  Methods defined here:
     |
     |  __init__(self, connection: 'MaintNotificationsAbstractConnection', config: redis.maint_notifications.MaintNotificationsConfig) -> None
     |      Initialize self.  See help(type(self)) for accurate signature.
     |
     |  handle_maintenance_completed_notification(self, **kwargs: Any) -> None
     |
     |  handle_maintenance_start_notification(self, maintenance_state: redis.maint_notifications.MaintenanceState, notification: redis.maint_notifications.MaintenanceNotification)
     |
     |  handle_notification(self, notification: redis.maint_notifications.MaintenanceNotification)
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors defined here:
     |
     |  __dict__
     |      dictionary for instance variables
     |
     |  __weakref__
     |      list of weak references to the object
     |
     |  ----------------------------------------------------------------------
     |  Data and other attributes defined here:
     |
     |  __annotations__ = {'_NOTIFICATION_TYPES': dict[type['MaintenanceNotifi...

    class MaintNotificationsPoolHandler(builtins.object)
     |  MaintNotificationsPoolHandler(pool: 'MaintNotificationsAbstractConnectionPool', config: redis.maint_notifications.MaintNotificationsConfig) -> None
     |
     |  Methods defined here:
     |
     |  __init__(self, pool: 'MaintNotificationsAbstractConnectionPool', config: redis.maint_notifications.MaintNotificationsConfig) -> None
     |      Initialize self.  See help(type(self)) for accurate signature.
     |
     |  get_handler_for_connection(self)
     |
     |  handle_node_moved_notification(self, notification: redis.maint_notifications.NodeMovingNotification)
     |      Handle the cleanup after a node moving notification expires.
     |
     |  handle_node_moving_notification(self, notification: redis.maint_notifications.NodeMovingNotification)
     |
     |  handle_notification(self, notification: redis.maint_notifications.MaintenanceNotification)
     |
     |  remove_expired_notifications(self)
     |
     |  run_proactive_reconnect(self, moving_address_src: Optional[str] = None)
     |      Run proactive reconnect for the pool.
     |      Active connections are marked for reconnect after they complete the current command.
     |      Inactive connections are disconnected and will be connected on next use.
     |
     |  set_connection(self, connection: 'MaintNotificationsAbstractConnection')
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors defined here:
     |
     |  __dict__
     |      dictionary for instance variables
     |
     |  __weakref__
     |      list of weak references to the object

    class MaintenanceNotification(abc.ABC)
     |  MaintenanceNotification(id: int, ttl: int)
     |
     |  Base class for maintenance notifications sent through push messages by Redis server.
     |
     |  This class provides common functionality for all maintenance notifications including
     |  unique identification and TTL (Time-To-Live) functionality.
     |
     |  Attributes:
     |      id (int): Unique identifier for this notification
     |      ttl (int): Time-to-live in seconds for this notification
     |      creation_time (float): Timestamp when the notification was created/read
     |
     |  Method resolution order:
     |      MaintenanceNotification
     |      abc.ABC
     |      builtins.object
     |
     |  Methods defined here:
     |
     |  __eq__(self, other) -> bool
     |      Compare two maintenance notifications for equality.
     |
     |      This method must be implemented by all concrete subclasses.
     |      Notifications are typically considered equal if they have the same id
     |      and are of the same type.
     |
     |      Args:
     |          other: The other object to compare with
     |
     |      Returns:
     |          bool: True if the notifications are equal, False otherwise
     |
     |  __hash__(self) -> int
     |      Return a hash value for the maintenance notification.
     |
     |      This method must be implemented by all concrete subclasses to allow
     |      instances to be used in sets and as dictionary keys.
     |
     |      Returns:
     |          int: Hash value for the notification
     |
     |  __init__(self, id: int, ttl: int)
     |      Initialize a new MaintenanceNotification with unique ID and TTL functionality.
     |
     |      Args:
     |          id (int): Unique identifier for this notification
     |          ttl (int): Time-to-live in seconds for this notification
     |
     |  __repr__(self) -> str
     |      Return a string representation of the maintenance notification.
     |
     |      This method must be implemented by all concrete subclasses.
     |
     |      Returns:
     |          str: String representation of the notification
     |
     |  is_expired(self) -> bool
     |      Check if this notification has expired based on its TTL
     |      and creation time.
     |
     |      Returns:
     |          bool: True if the notification has expired, False otherwise
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors defined here:
     |
     |  __dict__
     |      dictionary for instance variables
     |
     |  __weakref__
     |      list of weak references to the object
     |
     |  ----------------------------------------------------------------------
     |  Data and other attributes defined here:
     |
     |  __abstractmethods__ = frozenset({'__eq__', '__hash__', '__repr__'})

    class MaintenanceState(enum.Enum)
     |  MaintenanceState(*values)
     |
     |  Method resolution order:
     |      MaintenanceState
     |      enum.Enum
     |      builtins.object
     |
     |  Data and other attributes defined here:
     |
     |  MAINTENANCE = <MaintenanceState.MAINTENANCE: 'maintenance'>
     |
     |  MOVING = <MaintenanceState.MOVING: 'moving'>
     |
     |  NONE = <MaintenanceState.NONE: 'none'>
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors inherited from enum.Enum:
     |
     |  name
     |      The name of the Enum member.
     |
     |  value
     |      The value of the Enum member.
     |
     |  ----------------------------------------------------------------------
     |  Static methods inherited from enum.EnumType:
     |
     |  __contains__(value)
     |      Return True if `value` is in `cls`.
     |
     |      `value` is in `cls` if:
     |      1) `value` is a member of `cls`, or
     |      2) `value` is the value of one of the `cls`'s members.
     |
     |  __getitem__(name)
     |      Return the member matching `name`.
     |
     |  __iter__()
     |      Return members in definition order.
     |
     |  __len__()
     |      Return the number of members (no aliases)
     |
     |  ----------------------------------------------------------------------
     |  Readonly properties inherited from enum.EnumType:
     |
     |  __members__
     |      Returns a mapping of member name->value.
     |
     |      This mapping lists all enum members, including aliases. Note that this
     |      is a read-only view of the internal mapping.

    class NodeFailedOverNotification(MaintenanceNotification)
     |  NodeFailedOverNotification(id: int)
     |
     |  Notification for when a Redis cluster node has completed a failover.
     |
     |  This notification is received when a node has finished the failover process
     |  during cluster maintenance operations or after handling node failures.
     |
     |  Args:
     |      id (int): Unique identifier for this notification
     |
     |  Method resolution order:
     |      NodeFailedOverNotification
     |      MaintenanceNotification
     |      abc.ABC
     |      builtins.object
     |
     |  Methods defined here:
     |
     |  __eq__(self, other) -> bool
     |      Two NodeFailedOverNotification notifications are considered equal if they have the same
     |      id and are of the same type.
     |
     |  __hash__(self) -> int
     |      Return a hash value for the notification to allow
     |      instances to be used in sets and as dictionary keys.
     |
     |      Returns:
     |          int: Hash value based on notification type and id
     |
     |  __init__(self, id: int)
     |      Initialize a new MaintenanceNotification with unique ID and TTL functionality.
     |
     |      Args:
     |          id (int): Unique identifier for this notification
     |          ttl (int): Time-to-live in seconds for this notification
     |
     |  __repr__(self) -> str
     |      Return a string representation of the maintenance notification.
     |
     |      This method must be implemented by all concrete subclasses.
     |
     |      Returns:
     |          str: String representation of the notification
     |
     |  ----------------------------------------------------------------------
     |  Data and other attributes defined here:
     |
     |  DEFAULT_TTL = 5
     |
     |  __abstractmethods__ = frozenset()
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from MaintenanceNotification:
     |
     |  is_expired(self) -> bool
     |      Check if this notification has expired based on its TTL
     |      and creation time.
     |
     |      Returns:
     |          bool: True if the notification has expired, False otherwise
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors inherited from MaintenanceNotification:
     |
     |  __dict__
     |      dictionary for instance variables
     |
     |  __weakref__
     |      list of weak references to the object

    class NodeFailingOverNotification(MaintenanceNotification)
     |  NodeFailingOverNotification(id: int, ttl: int)
     |
     |  Notification for when a Redis cluster node is in the process of failing over.
     |
     |  This notification is received when a node starts a failover process during
     |  cluster maintenance operations or when handling node failures.
     |
     |  Args:
     |      id (int): Unique identifier for this notification
     |      ttl (int): Time-to-live in seconds for this notification
     |
     |  Method resolution order:
     |      NodeFailingOverNotification
     |      MaintenanceNotification
     |      abc.ABC
     |      builtins.object
     |
     |  Methods defined here:
     |
     |  __eq__(self, other) -> bool
     |      Two NodeFailingOverNotification notifications are considered equal if they have the same
     |      id and are of the same type.
     |
     |  __hash__(self) -> int
     |      Return a hash value for the notification to allow
     |      instances to be used in sets and as dictionary keys.
     |
     |      Returns:
     |          int: Hash value based on notification type and id
     |
     |  __init__(self, id: int, ttl: int)
     |      Initialize a new MaintenanceNotification with unique ID and TTL functionality.
     |
     |      Args:
     |          id (int): Unique identifier for this notification
     |          ttl (int): Time-to-live in seconds for this notification
     |
     |  __repr__(self) -> str
     |      Return a string representation of the maintenance notification.
     |
     |      This method must be implemented by all concrete subclasses.
     |
     |      Returns:
     |          str: String representation of the notification
     |
     |  ----------------------------------------------------------------------
     |  Data and other attributes defined here:
     |
     |  __abstractmethods__ = frozenset()
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from MaintenanceNotification:
     |
     |  is_expired(self) -> bool
     |      Check if this notification has expired based on its TTL
     |      and creation time.
     |
     |      Returns:
     |          bool: True if the notification has expired, False otherwise
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors inherited from MaintenanceNotification:
     |
     |  __dict__
     |      dictionary for instance variables
     |
     |  __weakref__
     |      list of weak references to the object

    class NodeMigratedNotification(MaintenanceNotification)
     |  NodeMigratedNotification(id: int)
     |
     |  Notification for when a Redis cluster node has completed migrating slots.
     |
     |  This notification is received when a node has finished migrating all its slots
     |  to other nodes during cluster rebalancing or maintenance operations.
     |
     |  Args:
     |      id (int): Unique identifier for this notification
     |
     |  Method resolution order:
     |      NodeMigratedNotification
     |      MaintenanceNotification
     |      abc.ABC
     |      builtins.object
     |
     |  Methods defined here:
     |
     |  __eq__(self, other) -> bool
     |      Two NodeMigratedNotification notifications are considered equal if they have the same
     |      id and are of the same type.
     |
     |  __hash__(self) -> int
     |      Return a hash value for the notification to allow
     |      instances to be used in sets and as dictionary keys.
     |
     |      Returns:
     |          int: Hash value based on notification type and id
     |
     |  __init__(self, id: int)
     |      Initialize a new MaintenanceNotification with unique ID and TTL functionality.
     |
     |      Args:
     |          id (int): Unique identifier for this notification
     |          ttl (int): Time-to-live in seconds for this notification
     |
     |  __repr__(self) -> str
     |      Return a string representation of the maintenance notification.
     |
     |      This method must be implemented by all concrete subclasses.
     |
     |      Returns:
     |          str: String representation of the notification
     |
     |  ----------------------------------------------------------------------
     |  Data and other attributes defined here:
     |
     |  DEFAULT_TTL = 5
     |
     |  __abstractmethods__ = frozenset()
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from MaintenanceNotification:
     |
     |  is_expired(self) -> bool
     |      Check if this notification has expired based on its TTL
     |      and creation time.
     |
     |      Returns:
     |          bool: True if the notification has expired, False otherwise
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors inherited from MaintenanceNotification:
     |
     |  __dict__
     |      dictionary for instance variables
     |
     |  __weakref__
     |      list of weak references to the object

    class NodeMigratingNotification(MaintenanceNotification)
     |  NodeMigratingNotification(id: int, ttl: int)
     |
     |  Notification for when a Redis cluster node is in the process of migrating slots.
     |
     |  This notification is received when a node starts migrating its slots to another node
     |  during cluster rebalancing or maintenance operations.
     |
     |  Args:
     |      id (int): Unique identifier for this notification
     |      ttl (int): Time-to-live in seconds for this notification
     |
     |  Method resolution order:
     |      NodeMigratingNotification
     |      MaintenanceNotification
     |      abc.ABC
     |      builtins.object
     |
     |  Methods defined here:
     |
     |  __eq__(self, other) -> bool
     |      Two NodeMigratingNotification notifications are considered equal if they have the same
     |      id and are of the same type.
     |
     |  __hash__(self) -> int
     |      Return a hash value for the notification to allow
     |      instances to be used in sets and as dictionary keys.
     |
     |      Returns:
     |          int: Hash value based on notification type and id
     |
     |  __init__(self, id: int, ttl: int)
     |      Initialize a new MaintenanceNotification with unique ID and TTL functionality.
     |
     |      Args:
     |          id (int): Unique identifier for this notification
     |          ttl (int): Time-to-live in seconds for this notification
     |
     |  __repr__(self) -> str
     |      Return a string representation of the maintenance notification.
     |
     |      This method must be implemented by all concrete subclasses.
     |
     |      Returns:
     |          str: String representation of the notification
     |
     |  ----------------------------------------------------------------------
     |  Data and other attributes defined here:
     |
     |  __abstractmethods__ = frozenset()
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from MaintenanceNotification:
     |
     |  is_expired(self) -> bool
     |      Check if this notification has expired based on its TTL
     |      and creation time.
     |
     |      Returns:
     |          bool: True if the notification has expired, False otherwise
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors inherited from MaintenanceNotification:
     |
     |  __dict__
     |      dictionary for instance variables
     |
     |  __weakref__
     |      list of weak references to the object

    class NodeMovingNotification(MaintenanceNotification)
     |  NodeMovingNotification(id: int, new_node_host: Optional[str], new_node_port: Optional[int], ttl: int)
     |
     |  This notification is received when a node is replaced with a new node
     |  during cluster rebalancing or maintenance operations.
     |
     |  Method resolution order:
     |      NodeMovingNotification
     |      MaintenanceNotification
     |      abc.ABC
     |      builtins.object
     |
     |  Methods defined here:
     |
     |  __eq__(self, other) -> bool
     |      Two NodeMovingNotification notifications are considered equal if they have the same
     |      id, new_node_host, and new_node_port.
     |
     |  __hash__(self) -> int
     |      Return a hash value for the notification to allow
     |      instances to be used in sets and as dictionary keys.
     |
     |      Returns:
     |          int: Hash value based on notification type class name, id,
     |          new_node_host and new_node_port
     |
     |  __init__(self, id: int, new_node_host: Optional[str], new_node_port: Optional[int], ttl: int)
     |      Initialize a new NodeMovingNotification.
     |
     |      Args:
     |          id (int): Unique identifier for this notification
     |          new_node_host (str): Hostname or IP address of the new replacement node
     |          new_node_port (int): Port number of the new replacement node
     |          ttl (int): Time-to-live in seconds for this notification
     |
     |  __repr__(self) -> str
     |      Return a string representation of the maintenance notification.
     |
     |      This method must be implemented by all concrete subclasses.
     |
     |      Returns:
     |          str: String representation of the notification
     |
     |  ----------------------------------------------------------------------
     |  Data and other attributes defined here:
     |
     |  __abstractmethods__ = frozenset()
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from MaintenanceNotification:
     |
     |  is_expired(self) -> bool
     |      Check if this notification has expired based on its TTL
     |      and creation time.
     |
     |      Returns:
     |          bool: True if the notification has expired, False otherwise
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors inherited from MaintenanceNotification:
     |
     |  __dict__
     |      dictionary for instance variables
     |
     |  __weakref__
     |      list of weak references to the object

    class OSSMaintNotificationsHandler(builtins.object)
     |  OSSMaintNotificationsHandler(cluster_client: 'MaintNotificationsAbstractRedisCluster', config: redis.maint_notifications.MaintNotificationsConfig) -> None
     |
     |  Methods defined here:
     |
     |  __init__(self, cluster_client: 'MaintNotificationsAbstractRedisCluster', config: redis.maint_notifications.MaintNotificationsConfig) -> None
     |      Initialize self.  See help(type(self)) for accurate signature.
     |
     |  handle_notification(self, notification: redis.maint_notifications.MaintenanceNotification)
     |
     |  handle_oss_maintenance_completed_notification(self, notification: redis.maint_notifications.OSSNodeMigratedNotification)
     |
     |  remove_expired_notifications(self)
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors defined here:
     |
     |  __dict__
     |      dictionary for instance variables
     |
     |  __weakref__
     |      list of weak references to the object

    class OSSNodeMigratedNotification(MaintenanceNotification)
     |  OSSNodeMigratedNotification(id: int, nodes_to_slots_mapping: Dict[str, List[Dict[str, str]]])
     |
     |  Notification for when a Redis OSS API client is used and a node has completed migrating slots.
     |
     |  This notification is received when a node has finished migrating all its slots
     |  to other nodes during cluster rebalancing or maintenance operations.
     |
     |  Args:
     |      id (int): Unique identifier for this notification
     |      nodes_to_slots_mapping (Dict[str, List[Dict[str, str]]]): Map of source node address
     |          to list of destination mappings. Each destination mapping is a dict with
     |          the destination node address as key and the slot range as value.
     |
     |          Structure example:
     |          {
     |              "127.0.0.1:6379": [
     |                  {"127.0.0.1:6380": "1-100"},
     |                  {"127.0.0.1:6381": "101-200"}
     |              ],
     |              "127.0.0.1:6382": [
     |                  {"127.0.0.1:6383": "201-300"}
     |              ]
     |          }
     |
     |          Where:
     |          - Key (str): Source node address in "host:port" format
     |          - Value (List[Dict[str, str]]): List of destination mappings where each dict
     |            contains destination node address as key and slot range as value
     |
     |  Method resolution order:
     |      OSSNodeMigratedNotification
     |      MaintenanceNotification
     |      abc.ABC
     |      builtins.object
     |
     |  Methods defined here:
     |
     |  __eq__(self, other) -> bool
     |      Two OSSNodeMigratedNotification notifications are considered equal if they have the same
     |      id and are of the same type.
     |
     |  __hash__(self) -> int
     |      Return a hash value for the notification to allow
     |      instances to be used in sets and as dictionary keys.
     |
     |      Returns:
     |          int: Hash value based on notification type and id
     |
     |  __init__(self, id: int, nodes_to_slots_mapping: Dict[str, List[Dict[str, str]]])
     |      Initialize a new MaintenanceNotification with unique ID and TTL functionality.
     |
     |      Args:
     |          id (int): Unique identifier for this notification
     |          ttl (int): Time-to-live in seconds for this notification
     |
     |  __repr__(self) -> str
     |      Return a string representation of the maintenance notification.
     |
     |      This method must be implemented by all concrete subclasses.
     |
     |      Returns:
     |          str: String representation of the notification
     |
     |  ----------------------------------------------------------------------
     |  Data and other attributes defined here:
     |
     |  DEFAULT_TTL = 120
     |
     |  __abstractmethods__ = frozenset()
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from MaintenanceNotification:
     |
     |  is_expired(self) -> bool
     |      Check if this notification has expired based on its TTL
     |      and creation time.
     |
     |      Returns:
     |          bool: True if the notification has expired, False otherwise
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors inherited from MaintenanceNotification:
     |
     |  __dict__
     |      dictionary for instance variables
     |
     |  __weakref__
     |      list of weak references to the object

    class OSSNodeMigratingNotification(MaintenanceNotification)
     |  OSSNodeMigratingNotification(id: int, slots: Optional[str] = None)
     |
     |  Notification for when a Redis OSS API client is used and a node is in the process of migrating slots.
     |
     |  This notification is received when a node starts migrating its slots to another node
     |  during cluster rebalancing or maintenance operations.
     |
     |  Args:
     |      id (int): Unique identifier for this notification
     |      slots (Optional[List[int]]): List of slots being migrated
     |
     |  Method resolution order:
     |      OSSNodeMigratingNotification
     |      MaintenanceNotification
     |      abc.ABC
     |      builtins.object
     |
     |  Methods defined here:
     |
     |  __eq__(self, other) -> bool
     |      Two OSSNodeMigratingNotification notifications are considered equal if they have the same
     |      id and are of the same type.
     |
     |  __hash__(self) -> int
     |      Return a hash value for the notification to allow
     |      instances to be used in sets and as dictionary keys.
     |
     |      Returns:
     |          int: Hash value based on notification type and id
     |
     |  __init__(self, id: int, slots: Optional[str] = None)
     |      Initialize a new MaintenanceNotification with unique ID and TTL functionality.
     |
     |      Args:
     |          id (int): Unique identifier for this notification
     |          ttl (int): Time-to-live in seconds for this notification
     |
     |  __repr__(self) -> str
     |      Return a string representation of the maintenance notification.
     |
     |      This method must be implemented by all concrete subclasses.
     |
     |      Returns:
     |          str: String representation of the notification
     |
     |  ----------------------------------------------------------------------
     |  Data and other attributes defined here:
     |
     |  DEFAULT_TTL = 30
     |
     |  __abstractmethods__ = frozenset()
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from MaintenanceNotification:
     |
     |  is_expired(self) -> bool
     |      Check if this notification has expired based on its TTL
     |      and creation time.
     |
     |      Returns:
     |          bool: True if the notification has expired, False otherwise
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors inherited from MaintenanceNotification:
     |
     |  __dict__
     |      dictionary for instance variables
     |
     |  __weakref__
     |      list of weak references to the object

FUNCTIONS
    add_debug_log_for_notification(connection: 'MaintNotificationsAbstractConnection', notification: Union[str, redis.maint_notifications.MaintenanceNotification])

DATA
    Dict = typing.Dict
        A generic version of dict.

    List = typing.List
        A generic version of list.

    Literal = typing.Literal
        Special typing form to define literal types (a.k.a. value types).

        This form can be used to indicate to type checkers that the corresponding
        variable or function parameter has a value equivalent to the provided
        literal (or one of several literals)::

            def validate_simple(data: Any) -> Literal[True]:  # always returns True
                ...

            MODE = Literal['r', 'rb', 'w', 'wb']
            def open_helper(file: str, mode: MODE) -> str:
                ...

            open_helper('/some/path', 'r')  # Passes type check
            open_helper('/other/path', 'typo')  # Error in type checker

        Literal[...] cannot be subclassed. At runtime, an arbitrary value
        is allowed as type argument to Literal[...], but type checkers may
        impose restrictions.

    Mapping = typing.Mapping
        A generic version of collections.abc.Mapping.

    Number = typing.Union[int, float]
    Optional = typing.Optional
        Optional[X] is equivalent to Union[X, None].

    TYPE_CHECKING = False
    Union = typing.Union
        Union type; Union[X, Y] means either X or Y.

        On Python 3.10 and higher, the | operator
        can also be used to denote unions;
        X | Y means the same thing to the type checker as Union[X, Y].

        To define a union, use e.g. Union[int, str]. Details:
        - The arguments must be types and there must be at least one.
        - None as an argument is a special case and is replaced by
          type(None).
        - Unions of unions are flattened, e.g.::

            assert Union[Union[int, str], float] == Union[int, str, float]

        - Unions of a single argument vanish, e.g.::

            assert Union[int] == int  # The constructor actually returns int

        - Redundant arguments are skipped, e.g.::

            assert Union[int, str, int] == Union[int, str]

        - When comparing unions, the argument order is ignored, e.g.::

            assert Union[int, str] == Union[str, int]

        - You cannot subclass or instantiate a union.
        - You can use Optional[X] as a shorthand for Union[X, None].

    __annotations__ = {'notification_types_mapping': dict[type[redis.maint...
    logger = <Logger redis.maint_notifications (WARNING)>
    notification_types_mapping = {<class 'redis.maint_notifications.NodeMo...

FILE
    c:\users\youse\appdata\local\programs\python\python312\lib\site-packages\redis\maint_notifications.py

Python Library Documentation: package redis.observability in redis

NAME
    redis.observability - OpenTelemetry observability module for redis-py.

DESCRIPTION
    This module provides APIs for collecting and exporting Redis metrics using OpenTelemetry.

    Usage:
        from redis.observability import get_observability_instance, OTelConfig

        otel = get_observability_instance()
        otel.init(OTelConfig())

PACKAGE CONTENTS
    attributes
    config
    metrics
    providers
    recorder
    registry

CLASSES
    builtins.object
        redis.observability.config.OTelConfig
        redis.observability.providers.ObservabilityInstance
    enum.IntFlag(builtins.int, enum.ReprEnum, enum.Flag)
        redis.observability.config.MetricGroup
        redis.observability.config.TelemetryOption

    class MetricGroup(enum.IntFlag)
     |  MetricGroup(*values)
     |
     |  Metric groups that can be enabled/disabled.
     |
     |  Method resolution order:
     |      MetricGroup
     |      enum.IntFlag
     |      builtins.int
     |      enum.ReprEnum
     |      enum.Flag
     |      enum.Enum
     |      builtins.object
     |
     |  Methods defined here:
     |
     |  __and__(self, other) from enum.Flag
     |
     |  __format__(self, format_spec, /) from builtins.int
     |      Convert to a string according to format_spec.
     |
     |  __invert__(self) from enum.Flag
     |
     |  __new__(cls, value) from enum.Enum
     |      Create and return a new object.  See help(type) for accurate signature.
     |
     |  __or__(self, other) from enum.Flag
     |      Return self|value.
     |
     |  __rand__ = __and__(self, other)
     |
     |  __ror__ = __or__(self, other)
     |
     |  __rxor__ = __xor__(self, other)
     |
     |  __xor__(self, other) from enum.Flag
     |
     |  ----------------------------------------------------------------------
     |  Data and other attributes defined here:
     |
     |  COMMAND = <MetricGroup.COMMAND: 8>
     |
     |  CONNECTION_ADVANCED = <MetricGroup.CONNECTION_ADVANCED: 4>
     |
     |  CONNECTION_BASIC = <MetricGroup.CONNECTION_BASIC: 2>
     |
     |  CSC = <MetricGroup.CSC: 16>
     |
     |  PUBSUB = <MetricGroup.PUBSUB: 64>
     |
     |  RESILIENCY = <MetricGroup.RESILIENCY: 1>
     |
     |  STREAMING = <MetricGroup.STREAMING: 32>
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from enum.IntFlag:
     |
     |  __repr__(self) from enum.Flag
     |      Return repr(self).
     |
     |  __str__ = __repr__(self, /) from builtins.int
     |      Return repr(self).
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from builtins.int:
     |
     |  __abs__(self, /)
     |      abs(self)
     |
     |  __add__(self, value, /)
     |      Return self+value.
     |
     |  __bool__(self, /)
     |      True if self else False
     |
     |  __ceil__(...)
     |      Ceiling of an Integral returns itself.
     |
     |  __divmod__(self, value, /)
     |      Return divmod(self, value).
     |
     |  __eq__(self, value, /)
     |      Return self==value.
     |
     |  __float__(self, /)
     |      float(self)
     |
     |  __floor__(...)
     |      Flooring an Integral returns itself.
     |
     |  __floordiv__(self, value, /)
     |      Return self//value.
     |
     |  __ge__(self, value, /)
     |      Return self>=value.
     |
     |  __getattribute__(self, name, /)
     |      Return getattr(self, name).
     |
     |  __getnewargs__(self, /)
     |
     |  __gt__(self, value, /)
     |      Return self>value.
     |
     |  __hash__(self, /)
     |      Return hash(self).
     |
     |  __index__(self, /)
     |      Return self converted to an integer, if self is suitable for use as an index into a list.
     |
     |  __int__(self, /)
     |      int(self)
     |
     |  __le__(self, value, /)
     |      Return self<=value.
     |
     |  __lshift__(self, value, /)
     |      Return self<<value.
     |
     |  __lt__(self, value, /)
     |      Return self<value.
     |
     |  __mod__(self, value, /)
     |      Return self%value.
     |
     |  __mul__(self, value, /)
     |      Return self*value.
     |
     |  __ne__(self, value, /)
     |      Return self!=value.
     |
     |  __neg__(self, /)
     |      -self
     |
     |  __pos__(self, /)
     |      +self
     |
     |  __pow__(self, value, mod=None, /)
     |      Return pow(self, value, mod).
     |
     |  __radd__(self, value, /)
     |      Return value+self.
     |
     |  __rdivmod__(self, value, /)
     |      Return divmod(value, self).
     |
     |  __rfloordiv__(self, value, /)
     |      Return value//self.
     |
     |  __rlshift__(self, value, /)
     |      Return value<<self.
     |
     |  __rmod__(self, value, /)
     |      Return value%self.
     |
     |  __rmul__(self, value, /)
     |      Return value*self.
     |
     |  __round__(...)
     |      Rounding an Integral returns itself.
     |
     |      Rounding with an ndigits argument also returns an integer.
     |
     |  __rpow__(self, value, mod=None, /)
     |      Return pow(value, self, mod).
     |
     |  __rrshift__(self, value, /)
     |      Return value>>self.
     |
     |  __rshift__(self, value, /)
     |      Return self>>value.
     |
     |  __rsub__(self, value, /)
     |      Return value-self.
     |
     |  __rtruediv__(self, value, /)
     |      Return value/self.
     |
     |  __sizeof__(self, /)
     |      Returns size in memory, in bytes.
     |
     |  __sub__(self, value, /)
     |      Return self-value.
     |
     |  __truediv__(self, value, /)
     |      Return self/value.
     |
     |  __trunc__(...)
     |      Truncating an Integral returns itself.
     |
     |  as_integer_ratio(self, /)
     |      Return a pair of integers, whose ratio is equal to the original int.
     |
     |      The ratio is in lowest terms and has a positive denominator.
     |
     |      >>> (10).as_integer_ratio()
     |      (10, 1)
     |      >>> (-10).as_integer_ratio()
     |      (-10, 1)
     |      >>> (0).as_integer_ratio()
     |      (0, 1)
     |
     |  bit_count(self, /)
     |      Number of ones in the binary representation of the absolute value of self.
     |
     |      Also known as the population count.
     |
     |      >>> bin(13)
     |      '0b1101'
     |      >>> (13).bit_count()
     |      3
     |
     |  bit_length(self, /)
     |      Number of bits necessary to represent self in binary.
     |
     |      >>> bin(37)
     |      '0b100101'
     |      >>> (37).bit_length()
     |      6
     |
     |  conjugate(...)
     |      Returns self, the complex conjugate of any int.
     |
     |  is_integer(self, /)
     |      Returns True. Exists for duck type compatibility with float.is_integer.
     |
     |  to_bytes(self, /, length=1, byteorder='big', *, signed=False)
     |      Return an array of bytes representing an integer.
     |
     |      length
     |        Length of bytes object to use.  An OverflowError is raised if the
     |        integer is not representable with the given number of bytes.  Default
     |        is length 1.
     |      byteorder
     |        The byte order used to represent the integer.  If byteorder is 'big',
     |        the most significant byte is at the beginning of the byte array.  If
     |        byteorder is 'little', the most significant byte is at the end of the
     |        byte array.  To request the native byte order of the host system, use
     |        `sys.byteorder' as the byte order value.  Default is to use 'big'.
     |      signed
     |        Determines whether two's complement is used to represent the integer.
     |        If signed is False and a negative integer is given, an OverflowError
     |        is raised.
     |
     |  ----------------------------------------------------------------------
     |  Class methods inherited from builtins.int:
     |
     |  from_bytes(bytes, byteorder='big', *, signed=False)
     |      Return the integer represented by the given array of bytes.
     |
     |      bytes
     |        Holds the array of bytes to convert.  The argument must either
     |        support the buffer protocol or be an iterable object producing bytes.
     |        Bytes and bytearray are examples of built-in objects that support the
     |        buffer protocol.
     |      byteorder
     |        The byte order used to represent the integer.  If byteorder is 'big',
     |        the most significant byte is at the beginning of the byte array.  If
     |        byteorder is 'little', the most significant byte is at the end of the
     |        byte array.  To request the native byte order of the host system, use
     |        `sys.byteorder' as the byte order value.  Default is to use 'big'.
     |      signed
     |        Indicates whether two's complement is used to represent the integer.
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors inherited from builtins.int:
     |
     |  denominator
     |      the denominator of a rational number in lowest terms
     |
     |  imag
     |      the imaginary part of a complex number
     |
     |  numerator
     |      the numerator of a rational number in lowest terms
     |
     |  real
     |      the real part of a complex number
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from enum.Flag:
     |
     |  __contains__(self, other)
     |      Returns True if self has at least the same flags set as other.
     |
     |  __iter__(self)
     |      Returns flags in definition order.
     |
     |  __len__(self)
     |      Return the number of members (no aliases)
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from enum.Enum:
     |
     |  __dir__(self)
     |      Returns public methods and other interesting attributes.
     |
     |  __init__(self, *args, **kwds)
     |      Initialize self.  See help(type(self)) for accurate signature.
     |
     |  __reduce_ex__(self, proto)
     |      Helper for pickle.
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors inherited from enum.Enum:
     |
     |  name
     |      The name of the Enum member.
     |
     |  value
     |      The value of the Enum member.
     |
     |  ----------------------------------------------------------------------
     |  Static methods inherited from enum.EnumType:
     |
     |  __getitem__(name)
     |      Return the member matching `name`.
     |
     |  ----------------------------------------------------------------------
     |  Readonly properties inherited from enum.EnumType:
     |
     |  __members__
     |      Returns a mapping of member name->value.
     |
     |      This mapping lists all enum members, including aliases. Note that this
     |      is a read-only view of the internal mapping.

    class OTelConfig(builtins.object)
     |  OTelConfig(enabled_telemetry: Optional[List[redis.observability.config.TelemetryOption]] = None, metric_groups: Optional[List[redis.observability.config.MetricGroup]] = None, include_commands: Optional[List[str]] = None, exclude_commands: Optional[List[str]] = None, hide_pubsub_channel_names: bool = False, hide_stream_names: bool = False, buckets_operation_duration: Sequence[float] = [0.0001, 0.00025, 0.0005, 0.001, 0.0025, 0.005, 0.01, 0.025, 0.05, 0.1, 0.25, 0.5, 1, 2.5], buckets_stream_processing_duration: Sequence[float] = [0.0001, 0.0005, 0.001, 0.005, 0.01, 0.05, 0.1, 0.5, 1, 5, 10], buckets_connection_create_time: Sequence[float] = [0.0001, 0.0005, 0.001, 0.005, 0.01, 0.05, 0.1, 0.5, 1, 5, 10], buckets_connection_wait_time: Sequence[float] = [0.0001, 0.0005, 0.001, 0.005, 0.01, 0.05, 0.1, 0.5, 1, 5, 10])
     |
     |  Configuration for OpenTelemetry observability in redis-py.
     |
     |  This class manages all OTel-related settings including metrics, traces (future),
     |  and logs (future). Configuration can be provided via constructor parameters or
     |  environment variables (OTEL_* spec).
     |
     |  Constructor parameters take precedence over environment variables.
     |
     |  Args:
     |      enabled_telemetry: Enabled telemetry options to export (default: metrics). Traces and logs will be added
     |                         in future phases.
     |      metric_groups: Group of metrics that should be exported.
     |      include_commands: Explicit allowlist of commands to track
     |      exclude_commands: Blocklist of commands to track
     |      hide_pubsub_channel_names: If True, hide PubSub channel names in metrics (default: False)
     |      hide_stream_names: If True, hide stream names in streaming metrics (default: False)
     |
     |  Note:
     |      Redis-py uses the global MeterProvider set by your application.
     |      Set it up before initializing observability:
     |
     |          from opentelemetry import metrics
     |          from opentelemetry.sdk.metrics import MeterProvider
     |          from opentelemetry.sdk.metrics._internal.view import View
     |          from opentelemetry.sdk.metrics._internal.aggregation import ExplicitBucketHistogramAggregation
     |
     |          # Configure histogram bucket boundaries via Views
     |          views = [
     |              View(
     |                  instrument_name="db.client.operation.duration",
     |                  aggregation=ExplicitBucketHistogramAggregation(
     |                      boundaries=[0.0001, 0.00025, 0.0005, 0.001, 0.0025, 0.005,
     |                                  0.01, 0.025, 0.05, 0.1, 0.25, 0.5, 1, 2.5]
     |                  ),
     |              ),
     |              # Add more views for other histograms...
     |          ]
     |
     |          provider = MeterProvider(views=views, metric_readers=[reader])
     |          metrics.set_meter_provider(provider)
     |
     |          # Then initialize redis-py observability
     |          from redis.observability import get_observability_instance, OTelConfig
     |          otel = get_observability_instance()
     |          otel.init(OTelConfig())
     |
     |  Methods defined here:
     |
     |  __init__(self, enabled_telemetry: Optional[List[redis.observability.config.TelemetryOption]] = None, metric_groups: Optional[List[redis.observability.config.MetricGroup]] = None, include_commands: Optional[List[str]] = None, exclude_commands: Optional[List[str]] = None, hide_pubsub_channel_names: bool = False, hide_stream_names: bool = False, buckets_operation_duration: Sequence[float] = [0.0001, 0.00025, 0.0005, 0.001, 0.0025, 0.005, 0.01, 0.025, 0.05, 0.1, 0.25, 0.5, 1, 2.5], buckets_stream_processing_duration: Sequence[float] = [0.0001, 0.0005, 0.001, 0.005, 0.01, 0.05, 0.1, 0.5, 1, 5, 10], buckets_connection_create_time: Sequence[float] = [0.0001, 0.0005, 0.001, 0.005, 0.01, 0.05, 0.1, 0.5, 1, 5, 10], buckets_connection_wait_time: Sequence[float] = [0.0001, 0.0005, 0.001, 0.005, 0.01, 0.05, 0.1, 0.5, 1, 5, 10])
     |      Initialize self.  See help(type(self)) for accurate signature.
     |
     |  __repr__(self) -> str
     |      Return repr(self).
     |
     |  is_enabled(self) -> bool
     |      Check if any observability feature is enabled.
     |
     |  should_track_command(self, command_name: str) -> bool
     |      Determine if a command should be tracked based on include/exclude lists.
     |
     |      Args:
     |          command_name: The Redis command name (e.g., 'GET', 'SET')
     |
     |      Returns:
     |          True if the command should be tracked, False otherwise
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors defined here:
     |
     |  __dict__
     |      dictionary for instance variables
     |
     |  __weakref__
     |      list of weak references to the object
     |
     |  ----------------------------------------------------------------------
     |  Data and other attributes defined here:
     |
     |  DEFAULT_METRIC_GROUPS = <MetricGroup.RESILIENCY|CONNECTION_BASIC: 3>
     |
     |  DEFAULT_TELEMETRY = <TelemetryOption.METRICS: 1>

    class ObservabilityInstance(builtins.object)
     |  Singleton instance for managing OpenTelemetry observability.
     |
     |  This class follows the singleton pattern similar to Glide's GetOtelInstance().
     |  Use GetObservabilityInstance() to get the singleton instance, then call init()
     |  to initialize observability.
     |
     |  Example:
     |      >>> from redis.observability.config import OTelConfig
     |      >>>
     |      >>> # Get singleton instance
     |      >>> otel = get_observability_instance()
     |      >>>
     |      >>> # Initialize once at app startup
     |      >>> otel.init(OTelConfig())
     |      >>>
     |      >>> # All Redis clients now automatically collect metrics
     |      >>> import redis
     |      >>> r = redis.Redis(host='localhost', port=6379)
     |      >>> r.set('key', 'value')  # Metrics collected automatically
     |
     |  Methods defined here:
     |
     |  __init__(self)
     |      Initialize self.  See help(type(self)) for accurate signature.
     |
     |  force_flush(self, timeout_millis: int = 30000) -> bool
     |      Force flush all pending metrics immediately.
     |
     |      Useful for testing or when you want to ensure metrics are exported
     |      before a specific point in your application.
     |
     |      Args:
     |          timeout_millis: Maximum time to wait for flush
     |
     |      Returns:
     |          True if flush was successful
     |
     |      Example:
     |          >>> otel = get_observability_instance()
     |          >>> # Execute some Redis commands
     |          >>> r.set('key', 'value')
     |          >>> # Force flush metrics immediately
     |          >>> otel.force_flush()
     |
     |  get_provider_manager(self) -> Optional[redis.observability.providers.OTelProviderManager]
     |      Get the provider manager instance.
     |
     |      Returns:
     |          The provider manager, or None if not initialized
     |
     |      Example:
     |          >>> otel = get_observability_instance()
     |          >>> manager = otel.get_provider_manager()
     |          >>> if manager is not None:
     |          ...     print(f"Observability enabled: {manager.config.is_enabled()}")
     |
     |  init(self, config: redis.observability.config.OTelConfig) -> 'ObservabilityInstance'
     |      Initialize OpenTelemetry observability globally for all Redis clients.
     |
     |      This should be called once at application startup. After initialization,
     |      all Redis clients will automatically collect and export metrics without
     |      needing any additional configuration.
     |
     |      Safe to call multiple times - will shutdown previous instance before
     |      initializing a new one.
     |
     |      Args:
     |          config: OTel configuration object
     |
     |      Returns:
     |          Self for method chaining
     |
     |      Example:
     |          >>> otel = get_observability_instance()
     |          >>> otel.init(OTelConfig())
     |
     |  is_enabled(self) -> bool
     |      Check if observability is enabled.
     |
     |      Returns:
     |          True if observability is initialized and metrics are enabled
     |
     |      Example:
     |          >>> otel = get_observability_instance()
     |          >>> if otel.is_enabled():
     |          ...     print("Metrics are being collected")
     |
     |  shutdown(self, timeout_millis: int = 30000) -> bool
     |      Shutdown observability and flush any pending metrics.
     |
     |      This should be called at application shutdown to ensure all metrics
     |      are exported before the application exits.
     |
     |      Args:
     |          timeout_millis: Maximum time to wait for shutdown
     |
     |      Returns:
     |          True if shutdown was successful
     |
     |      Example:
     |          >>> otel = get_observability_instance()
     |          >>> # At application shutdown
     |          >>> otel.shutdown()
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors defined here:
     |
     |  __dict__
     |      dictionary for instance variables
     |
     |  __weakref__
     |      list of weak references to the object

    class TelemetryOption(enum.IntFlag)
     |  TelemetryOption(*values)
     |
     |  Telemetry options to export.
     |
     |  Method resolution order:
     |      TelemetryOption
     |      enum.IntFlag
     |      builtins.int
     |      enum.ReprEnum
     |      enum.Flag
     |      enum.Enum
     |      builtins.object
     |
     |  Methods defined here:
     |
     |  __and__(self, other) from enum.Flag
     |
     |  __format__(self, format_spec, /) from builtins.int
     |      Convert to a string according to format_spec.
     |
     |  __invert__(self) from enum.Flag
     |
     |  __new__(cls, value) from enum.Enum
     |      Create and return a new object.  See help(type) for accurate signature.
     |
     |  __or__(self, other) from enum.Flag
     |      Return self|value.
     |
     |  __rand__ = __and__(self, other)
     |
     |  __ror__ = __or__(self, other)
     |
     |  __rxor__ = __xor__(self, other)
     |
     |  __xor__(self, other) from enum.Flag
     |
     |  ----------------------------------------------------------------------
     |  Data and other attributes defined here:
     |
     |  METRICS = <TelemetryOption.METRICS: 1>
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from enum.IntFlag:
     |
     |  __repr__(self) from enum.Flag
     |      Return repr(self).
     |
     |  __str__ = __repr__(self, /) from builtins.int
     |      Return repr(self).
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from builtins.int:
     |
     |  __abs__(self, /)
     |      abs(self)
     |
     |  __add__(self, value, /)
     |      Return self+value.
     |
     |  __bool__(self, /)
     |      True if self else False
     |
     |  __ceil__(...)
     |      Ceiling of an Integral returns itself.
     |
     |  __divmod__(self, value, /)
     |      Return divmod(self, value).
     |
     |  __eq__(self, value, /)
     |      Return self==value.
     |
     |  __float__(self, /)
     |      float(self)
     |
     |  __floor__(...)
     |      Flooring an Integral returns itself.
     |
     |  __floordiv__(self, value, /)
     |      Return self//value.
     |
     |  __ge__(self, value, /)
     |      Return self>=value.
     |
     |  __getattribute__(self, name, /)
     |      Return getattr(self, name).
     |
     |  __getnewargs__(self, /)
     |
     |  __gt__(self, value, /)
     |      Return self>value.
     |
     |  __hash__(self, /)
     |      Return hash(self).
     |
     |  __index__(self, /)
     |      Return self converted to an integer, if self is suitable for use as an index into a list.
     |
     |  __int__(self, /)
     |      int(self)
     |
     |  __le__(self, value, /)
     |      Return self<=value.
     |
     |  __lshift__(self, value, /)
     |      Return self<<value.
     |
     |  __lt__(self, value, /)
     |      Return self<value.
     |
     |  __mod__(self, value, /)
     |      Return self%value.
     |
     |  __mul__(self, value, /)
     |      Return self*value.
     |
     |  __ne__(self, value, /)
     |      Return self!=value.
     |
     |  __neg__(self, /)
     |      -self
     |
     |  __pos__(self, /)
     |      +self
     |
     |  __pow__(self, value, mod=None, /)
     |      Return pow(self, value, mod).
     |
     |  __radd__(self, value, /)
     |      Return value+self.
     |
     |  __rdivmod__(self, value, /)
     |      Return divmod(value, self).
     |
     |  __rfloordiv__(self, value, /)
     |      Return value//self.
     |
     |  __rlshift__(self, value, /)
     |      Return value<<self.
     |
     |  __rmod__(self, value, /)
     |      Return value%self.
     |
     |  __rmul__(self, value, /)
     |      Return value*self.
     |
     |  __round__(...)
     |      Rounding an Integral returns itself.
     |
     |      Rounding with an ndigits argument also returns an integer.
     |
     |  __rpow__(self, value, mod=None, /)
     |      Return pow(value, self, mod).
     |
     |  __rrshift__(self, value, /)
     |      Return value>>self.
     |
     |  __rshift__(self, value, /)
     |      Return self>>value.
     |
     |  __rsub__(self, value, /)
     |      Return value-self.
     |
     |  __rtruediv__(self, value, /)
     |      Return value/self.
     |
     |  __sizeof__(self, /)
     |      Returns size in memory, in bytes.
     |
     |  __sub__(self, value, /)
     |      Return self-value.
     |
     |  __truediv__(self, value, /)
     |      Return self/value.
     |
     |  __trunc__(...)
     |      Truncating an Integral returns itself.
     |
     |  as_integer_ratio(self, /)
     |      Return a pair of integers, whose ratio is equal to the original int.
     |
     |      The ratio is in lowest terms and has a positive denominator.
     |
     |      >>> (10).as_integer_ratio()
     |      (10, 1)
     |      >>> (-10).as_integer_ratio()
     |      (-10, 1)
     |      >>> (0).as_integer_ratio()
     |      (0, 1)
     |
     |  bit_count(self, /)
     |      Number of ones in the binary representation of the absolute value of self.
     |
     |      Also known as the population count.
     |
     |      >>> bin(13)
     |      '0b1101'
     |      >>> (13).bit_count()
     |      3
     |
     |  bit_length(self, /)
     |      Number of bits necessary to represent self in binary.
     |
     |      >>> bin(37)
     |      '0b100101'
     |      >>> (37).bit_length()
     |      6
     |
     |  conjugate(...)
     |      Returns self, the complex conjugate of any int.
     |
     |  is_integer(self, /)
     |      Returns True. Exists for duck type compatibility with float.is_integer.
     |
     |  to_bytes(self, /, length=1, byteorder='big', *, signed=False)
     |      Return an array of bytes representing an integer.
     |
     |      length
     |        Length of bytes object to use.  An OverflowError is raised if the
     |        integer is not representable with the given number of bytes.  Default
     |        is length 1.
     |      byteorder
     |        The byte order used to represent the integer.  If byteorder is 'big',
     |        the most significant byte is at the beginning of the byte array.  If
     |        byteorder is 'little', the most significant byte is at the end of the
     |        byte array.  To request the native byte order of the host system, use
     |        `sys.byteorder' as the byte order value.  Default is to use 'big'.
     |      signed
     |        Determines whether two's complement is used to represent the integer.
     |        If signed is False and a negative integer is given, an OverflowError
     |        is raised.
     |
     |  ----------------------------------------------------------------------
     |  Class methods inherited from builtins.int:
     |
     |  from_bytes(bytes, byteorder='big', *, signed=False)
     |      Return the integer represented by the given array of bytes.
     |
     |      bytes
     |        Holds the array of bytes to convert.  The argument must either
     |        support the buffer protocol or be an iterable object producing bytes.
     |        Bytes and bytearray are examples of built-in objects that support the
     |        buffer protocol.
     |      byteorder
     |        The byte order used to represent the integer.  If byteorder is 'big',
     |        the most significant byte is at the beginning of the byte array.  If
     |        byteorder is 'little', the most significant byte is at the end of the
     |        byte array.  To request the native byte order of the host system, use
     |        `sys.byteorder' as the byte order value.  Default is to use 'big'.
     |      signed
     |        Indicates whether two's complement is used to represent the integer.
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors inherited from builtins.int:
     |
     |  denominator
     |      the denominator of a rational number in lowest terms
     |
     |  imag
     |      the imaginary part of a complex number
     |
     |  numerator
     |      the numerator of a rational number in lowest terms
     |
     |  real
     |      the real part of a complex number
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from enum.Flag:
     |
     |  __contains__(self, other)
     |      Returns True if self has at least the same flags set as other.
     |
     |  __iter__(self)
     |      Returns flags in definition order.
     |
     |  __len__(self)
     |      Return the number of members (no aliases)
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from enum.Enum:
     |
     |  __dir__(self)
     |      Returns public methods and other interesting attributes.
     |
     |  __init__(self, *args, **kwds)
     |      Initialize self.  See help(type(self)) for accurate signature.
     |
     |  __reduce_ex__(self, proto)
     |      Helper for pickle.
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors inherited from enum.Enum:
     |
     |  name
     |      The name of the Enum member.
     |
     |  value
     |      The value of the Enum member.
     |
     |  ----------------------------------------------------------------------
     |  Static methods inherited from enum.EnumType:
     |
     |  __getitem__(name)
     |      Return the member matching `name`.
     |
     |  ----------------------------------------------------------------------
     |  Readonly properties inherited from enum.EnumType:
     |
     |  __members__
     |      Returns a mapping of member name->value.
     |
     |      This mapping lists all enum members, including aliases. Note that this
     |      is a read-only view of the internal mapping.

FUNCTIONS
    get_observability_instance() -> redis.observability.providers.ObservabilityInstance
        Get the global observability singleton instance.

        This is the Pythonic way to get the singleton instance.

        Returns:
            The global ObservabilityInstance singleton

        Example:
            >>>
            >>> otel = get_observability_instance()
            >>> otel.init(OTelConfig())

    reset_observability_instance() -> None
        Reset the global observability singleton instance.

        This is primarily used for testing and benchmarking to ensure
        a clean state between test runs.

        Warning:
            This will shutdown any active provider manager and reset
            the global state. Use with caution in production code.

DATA
    __all__ = ['OTelConfig', 'MetricGroup', 'TelemetryOption', 'Observabil...

FILE
    c:\users\youse\appdata\local\programs\python\python312\lib\site-packages\redis\observability\__init__.py

Python Library Documentation: module redis.retry in redis

NAME
    redis.retry

CLASSES
    abc.ABC(builtins.object)
        AbstractRetry(typing.Generic, abc.ABC)
            Retry
    typing.Generic(builtins.object)
        AbstractRetry(typing.Generic, abc.ABC)
            Retry

    class AbstractRetry(typing.Generic, abc.ABC)
     |  AbstractRetry(backoff: 'AbstractBackoff', retries: int, supported_errors: Tuple[Type[+E], ...])
     |
     |  Retry a specific number of times after a failure
     |
     |  Method resolution order:
     |      AbstractRetry
     |      typing.Generic
     |      abc.ABC
     |      builtins.object
     |
     |  Methods defined here:
     |
     |  __eq__(self, other: Any) -> bool
     |      Return self==value.
     |
     |  __hash__(self) -> int
     |      Return hash(self).
     |
     |  __init__(self, backoff: 'AbstractBackoff', retries: int, supported_errors: Tuple[Type[+E], ...])
     |      Initialize a `Retry` object with a `Backoff` object
     |      that retries a maximum of `retries` times.
     |      `retries` can be negative to retry forever.
     |      You can specify the types of supported errors which trigger
     |      a retry with the `supported_errors` parameter.
     |
     |  get_retries(self) -> int
     |      Get the number of retries.
     |
     |  update_retries(self, value: int) -> None
     |      Set the number of retries.
     |
     |  update_supported_errors(self, specified_errors: Iterable[Type[+E]]) -> None
     |      Updates the supported errors with the specified error types
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors defined here:
     |
     |  __dict__
     |      dictionary for instance variables
     |
     |  __weakref__
     |      list of weak references to the object
     |
     |  ----------------------------------------------------------------------
     |  Data and other attributes defined here:
     |
     |  __abstractmethods__ = frozenset({'__eq__'})
     |
     |  __annotations__ = {'_supported_errors': typing.Tuple[typing.Type[+E], ...
     |
     |  __orig_bases__ = (typing.Generic[+E], <class 'abc.ABC'>)
     |
     |  __parameters__ = (+E,)
     |
     |  ----------------------------------------------------------------------
     |  Class methods inherited from typing.Generic:
     |
     |  __class_getitem__(...)
     |      Parameterizes a generic class.
     |
     |      At least, parameterizing a generic class is the *main* thing this
     |      method does. For example, for some generic class `Foo`, this is called
     |      when we do `Foo[int]` - there, with `cls=Foo` and `params=int`.
     |
     |      However, note that this method is also called when defining generic
     |      classes in the first place with `class Foo[T]: ...`.
     |
     |  __init_subclass__(...)
     |      Function to initialize subclasses.

    class Retry(AbstractRetry)
     |  Retry(backoff: 'AbstractBackoff', retries: int, supported_errors: Tuple[Type[Exception], ...] = (<class 'redis.exceptions.ConnectionError'>, <class 'redis.exceptions.TimeoutError'>, <class 'TimeoutError'>))
     |
     |  Method resolution order:
     |      Retry
     |      AbstractRetry
     |      typing.Generic
     |      abc.ABC
     |      builtins.object
     |
     |  Methods defined here:
     |
     |  __eq__(self, other: Any) -> bool
     |      Return self==value.
     |
     |  __hash__(self) -> int from AbstractRetry
     |      Return hash(self).
     |
     |  __init__(self, backoff: 'AbstractBackoff', retries: int, supported_errors: Tuple[Type[Exception], ...] = (<class 'redis.exceptions.ConnectionError'>, <class 'redis.exceptions.TimeoutError'>, <class 'TimeoutError'>))
     |      Initialize a `Retry` object with a `Backoff` object
     |      that retries a maximum of `retries` times.
     |      `retries` can be negative to retry forever.
     |      You can specify the types of supported errors which trigger
     |      a retry with the `supported_errors` parameter.
     |
     |  call_with_retry(self, do: Callable[[], ~T], fail: Union[Callable[[Exception], Any], Callable[[Exception, int], Any]], is_retryable: Optional[Callable[[Exception], bool]] = None, with_failure_count: bool = False) -> ~T
     |      Execute an operation that might fail and returns its result, or
     |      raise the exception that was thrown depending on the `Backoff` object.
     |      `do`: the operation to call. Expects no argument.
     |      `fail`: the failure handler, expects the last error that was thrown
     |      ``is_retryable``: optional function to determine if an error is retryable
     |      ``with_failure_count``: if True, the failure count is passed to the failure handler
     |
     |  ----------------------------------------------------------------------
     |  Data and other attributes defined here:
     |
     |  __abstractmethods__ = frozenset()
     |
     |  __annotations__ = {}
     |
     |  __orig_bases__ = (redis.retry.AbstractRetry[Exception],)
     |
     |  __parameters__ = ()
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from AbstractRetry:
     |
     |  get_retries(self) -> int
     |      Get the number of retries.
     |
     |  update_retries(self, value: int) -> None
     |      Set the number of retries.
     |
     |  update_supported_errors(self, specified_errors: Iterable[Type[+E]]) -> None
     |      Updates the supported errors with the specified error types
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors inherited from AbstractRetry:
     |
     |  __dict__
     |      dictionary for instance variables
     |
     |  __weakref__
     |      list of weak references to the object
     |
     |  ----------------------------------------------------------------------
     |  Class methods inherited from typing.Generic:
     |
     |  __class_getitem__(...)
     |      Parameterizes a generic class.
     |
     |      At least, parameterizing a generic class is the *main* thing this
     |      method does. For example, for some generic class `Foo`, this is called
     |      when we do `Foo[int]` - there, with `cls=Foo` and `params=int`.
     |
     |      However, note that this method is also called when defining generic
     |      classes in the first place with `class Foo[T]: ...`.
     |
     |  __init_subclass__(...)
     |      Function to initialize subclasses.

FUNCTIONS
    sleep(...)
        sleep(seconds)

        Delay execution for a given number of seconds.  The argument may be
        a floating-point number for subsecond precision.

DATA
    Callable = typing.Callable
        Deprecated alias to collections.abc.Callable.

        Callable[[int], str] signifies a function that takes a single
        parameter of type int and returns a str.

        The subscription syntax must always be used with exactly two
        values: the argument list and the return type.
        The argument list must be a list of types, a ParamSpec,
        Concatenate or ellipsis. The return type must be a single type.

        There is no syntax to indicate optional or keyword arguments;
        such function types are rarely used as callback types.

    E = +E
    Iterable = typing.Iterable
        A generic version of collections.abc.Iterable.

    Optional = typing.Optional
        Optional[X] is equivalent to Union[X, None].

    T = ~T
    TYPE_CHECKING = False
    Tuple = typing.Tuple
        Deprecated alias to builtins.tuple.

        Tuple[X, Y] is the cross-product type of X and Y.

        Example: Tuple[T1, T2] is a tuple of two elements corresponding
        to type variables T1 and T2.  Tuple[int, float, str] is a tuple
        of an int, a float and a string.

        To specify a variable-length tuple of homogeneous type, use Tuple[T, ...].

    Type = typing.Type
        Deprecated alias to builtins.type.

        builtins.type or typing.Type can be used to annotate class objects.
        For example, suppose we have the following classes::

            class User: ...  # Abstract base for User classes
            class BasicUser(User): ...
            class ProUser(User): ...
            class TeamUser(User): ...

        And a function that takes a class argument that's a subclass of
        User and returns an instance of the corresponding class::

            def new_user[U](user_class: Type[U]) -> U:
                user = user_class()
                # (Here we could write the user object to a database)
                return user

            joe = new_user(BasicUser)

        At this point the type checker knows that joe has type BasicUser.

    Union = typing.Union
        Union type; Union[X, Y] means either X or Y.

        On Python 3.10 and higher, the | operator
        can also be used to denote unions;
        X | Y means the same thing to the type checker as Union[X, Y].

        To define a union, use e.g. Union[int, str]. Details:
        - The arguments must be types and there must be at least one.
        - None as an argument is a special case and is replaced by
          type(None).
        - Unions of unions are flattened, e.g.::

            assert Union[Union[int, str], float] == Union[int, str, float]

        - Unions of a single argument vanish, e.g.::

            assert Union[int] == int  # The constructor actually returns int

        - Redundant arguments are skipped, e.g.::

            assert Union[int, str, int] == Union[int, str]

        - When comparing unions, the argument order is ignored, e.g.::

            assert Union[int, str] == Union[str, int]

        - You cannot subclass or instantiate a union.
        - You can use Optional[X] as a shorthand for Union[X, None].

FILE
    c:\users\youse\appdata\local\programs\python\python312\lib\site-packages\redis\retry.py

Python Library Documentation: module redis.sentinel in redis

NAME
    redis.sentinel

CLASSES
    builtins.object
        SentinelConnectionPoolProxy
    redis.commands.sentinel.SentinelCommands(builtins.object)
        Sentinel
    redis.connection.Connection(redis.connection.AbstractConnection)
        SentinelManagedConnection
            SentinelManagedSSLConnection(SentinelManagedConnection, redis.connection.SSLConnection)
    redis.connection.ConnectionPool(redis.connection.MaintNotificationsAbstractConnectionPool, redis.connection.ConnectionPoolInterface)
        SentinelConnectionPool
    redis.exceptions.ConnectionError(redis.exceptions.RedisError)
        MasterNotFoundError
        SlaveNotFoundError

    class MasterNotFoundError(redis.exceptions.ConnectionError)
     |  MasterNotFoundError(*args, status_code: str | None = None)
     |
     |  Method resolution order:
     |      MasterNotFoundError
     |      redis.exceptions.ConnectionError
     |      redis.exceptions.RedisError
     |      builtins.Exception
     |      builtins.BaseException
     |      builtins.object
     |
     |  Methods inherited from redis.exceptions.ConnectionError:
     |
     |  __init__(self, *args, status_code: str | None = None)
     |      Initialize self.  See help(type(self)) for accurate signature.
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from redis.exceptions.RedisError:
     |
     |  __repr__(self)
     |      Return repr(self).
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors inherited from redis.exceptions.RedisError:
     |
     |  __weakref__
     |      list of weak references to the object
     |
     |  ----------------------------------------------------------------------
     |  Static methods inherited from builtins.Exception:
     |
     |  __new__(*args, **kwargs) class method of builtins.Exception
     |      Create and return a new object.  See help(type) for accurate signature.
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from builtins.BaseException:
     |
     |  __getattribute__(self, name, /)
     |      Return getattr(self, name).
     |
     |  __reduce__(...)
     |      Helper for pickle.
     |
     |  __setstate__(...)
     |
     |  __str__(self, /)
     |      Return str(self).
     |
     |  add_note(...)
     |      Exception.add_note(note) --
     |      add a note to the exception
     |
     |  with_traceback(...)
     |      Exception.with_traceback(tb) --
     |      set self.__traceback__ to tb and return self.
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors inherited from builtins.BaseException:
     |
     |  __cause__
     |      exception cause
     |
     |  __context__
     |      exception context
     |
     |  __dict__
     |
     |  __suppress_context__
     |
     |  __traceback__
     |
     |  args

    ReplicaNotFoundError = class SlaveNotFoundError(redis.exceptions.ConnectionError)
     |  ReplicaNotFoundError(*args, status_code: str | None = None)
     |
     |  Method resolution order:
     |      SlaveNotFoundError
     |      redis.exceptions.ConnectionError
     |      redis.exceptions.RedisError
     |      builtins.Exception
     |      builtins.BaseException
     |      builtins.object
     |
     |  Methods inherited from redis.exceptions.ConnectionError:
     |
     |  __init__(self, *args, status_code: str | None = None)
     |      Initialize self.  See help(type(self)) for accurate signature.
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from redis.exceptions.RedisError:
     |
     |  __repr__(self)
     |      Return repr(self).
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors inherited from redis.exceptions.RedisError:
     |
     |  __weakref__
     |      list of weak references to the object
     |
     |  ----------------------------------------------------------------------
     |  Static methods inherited from builtins.Exception:
     |
     |  __new__(*args, **kwargs) class method of builtins.Exception
     |      Create and return a new object.  See help(type) for accurate signature.
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from builtins.BaseException:
     |
     |  __getattribute__(self, name, /)
     |      Return getattr(self, name).
     |
     |  __reduce__(...)
     |      Helper for pickle.
     |
     |  __setstate__(...)
     |
     |  __str__(self, /)
     |      Return str(self).
     |
     |  add_note(...)
     |      Exception.add_note(note) --
     |      add a note to the exception
     |
     |  with_traceback(...)
     |      Exception.with_traceback(tb) --
     |      set self.__traceback__ to tb and return self.
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors inherited from builtins.BaseException:
     |
     |  __cause__
     |      exception cause
     |
     |  __context__
     |      exception context
     |
     |  __dict__
     |
     |  __suppress_context__
     |
     |  __traceback__
     |
     |  args

    class Sentinel(redis.commands.sentinel.SentinelCommands)
     |  Sentinel(sentinels, min_other_sentinels=0, sentinel_kwargs=None, force_master_ip=None, **connection_kwargs)
     |
     |  Redis Sentinel cluster client
     |
     |  >>> from redis.sentinel import Sentinel
     |  >>> sentinel = Sentinel([('localhost', 26379)], socket_timeout=0.1)
     |  >>> master = sentinel.master_for('mymaster', socket_timeout=0.1)
     |  >>> master.set('foo', 'bar')
     |  >>> slave = sentinel.slave_for('mymaster', socket_timeout=0.1)
     |  >>> slave.get('foo')
     |  b'bar'
     |
     |  ``sentinels`` is a list of sentinel nodes. Each node is represented by
     |  a pair (hostname, port).
     |
     |  ``min_other_sentinels`` defined a minimum number of peers for a sentinel.
     |  When querying a sentinel, if it doesn't meet this threshold, responses
     |  from that sentinel won't be considered valid.
     |
     |  ``sentinel_kwargs`` is a dictionary of connection arguments used when
     |  connecting to sentinel instances. Any argument that can be passed to
     |  a normal Redis connection can be specified here. If ``sentinel_kwargs`` is
     |  not specified, any socket_timeout and socket_keepalive options specified
     |  in ``connection_kwargs`` will be used.
     |
     |  ``connection_kwargs`` are keyword arguments that will be used when
     |  establishing a connection to a Redis server.
     |
     |  Method resolution order:
     |      Sentinel
     |      redis.commands.sentinel.SentinelCommands
     |      builtins.object
     |
     |  Methods defined here:
     |
     |  __enter__(self)
     |
     |  __exit__(self, exc_type, exc_value, traceback)
     |
     |  __init__(self, sentinels, min_other_sentinels=0, sentinel_kwargs=None, force_master_ip=None, **connection_kwargs)
     |      Initialize self.  See help(type(self)) for accurate signature.
     |
     |  __repr__(self)
     |      Return repr(self).
     |
     |  check_master_state(self, state, service_name)
     |
     |  close(self) -> None
     |      Close all sentinel clients created by this Sentinel and their
     |      connection pools.
     |
     |      Each client is closed independently: if one raises, the remaining
     |      clients are still closed and the first error is re-raised afterwards.
     |
     |      Clients returned by ``master_for``/``slave_for`` are owned by the
     |      caller and are not closed here.
     |
     |  discover_master(self, service_name)
     |      Asks sentinel servers for the Redis master's address corresponding
     |      to the service labeled ``service_name``.
     |
     |      Returns a pair (address, port) or raises MasterNotFoundError if no
     |      master is found.
     |
     |  discover_replicas(self, service_name)
     |      Returns a list of alive replicas for service ``service_name``.
     |
     |      This is an alias for :py:meth:`discover_slaves`,
     |      using the preferred Redis 5.0+ terminology.
     |
     |  discover_slaves(self, service_name)
     |      Returns a list of alive slaves for service ``service_name``
     |
     |  execute_command(self, *args, **kwargs)
     |      Execute Sentinel command in sentinel nodes.
     |      once - If set to True, then execute the resulting command on a single
     |      node at random, rather than across the entire sentinel cluster.
     |
     |  filter_replicas(self, replicas)
     |      Remove replicas that are in an ODOWN or SDOWN state.
     |
     |      This is an alias for :py:meth:`filter_slaves`,
     |      using the preferred Redis 5.0+ terminology.
     |
     |  filter_slaves(self, slaves)
     |      Remove slaves that are in an ODOWN or SDOWN state
     |
     |  master_for(self, service_name, redis_class=<class 'redis.client.Redis'>, connection_pool_class=<class 'redis.sentinel.SentinelConnectionPool'>, **kwargs)
     |      Returns a redis client instance for the ``service_name`` master.
     |      Sentinel client will detect failover and reconnect Redis clients
     |      automatically.
     |
     |      A :py:class:`~redis.sentinel.SentinelConnectionPool` class is
     |      used to retrieve the master's address before establishing a new
     |      connection.
     |
     |      NOTE: If the master's address has changed, any cached connections to
     |      the old master are closed.
     |
     |      By default clients will be a :py:class:`~redis.Redis` instance.
     |      Specify a different class to the ``redis_class`` argument if you
     |      desire something different.
     |
     |      The ``connection_pool_class`` specifies the connection pool to
     |      use.  The :py:class:`~redis.sentinel.SentinelConnectionPool`
     |      will be used by default.
     |
     |      All other keyword arguments are merged with any connection_kwargs
     |      passed to this class and passed to the connection pool as keyword
     |      arguments to be used to initialize Redis connections.
     |
     |      HIMPORT note: the returned client exposes the HIMPORT command family
     |      (``himport_prepare``, ``himport_set``, ``himport_discard``,
     |      ``himport_discard_all``). Fieldsets are declared at runtime with
     |      ``himport_prepare`` on the client and live on that client's shared registry,
     |      so they survive Sentinel failover automatically: the pool re-points to the
     |      new master and the fieldset is re-prepared lazily on the next
     |      ``himport_set``. Each call to the current method returns a *new* client with
     |      its *own* empty registry, so call ``himport_prepare`` on the long-lived client
     |      you reuse rather than creating a fresh one per operation; otherwise ``himport_set``
     |      fails with ``no such fieldset``. (``himport_set`` is a write and is served by
     |      the master.)
     |
     |  replica_for(self, service_name, redis_class=<class 'redis.client.Redis'>, connection_pool_class=<class 'redis.sentinel.SentinelConnectionPool'>, **kwargs)
     |      Returns redis client instance for the ``service_name`` replica(s).
     |
     |      This is an alias for :py:meth:`slave_for`,
     |      using the preferred Redis 5.0+ terminology.
     |
     |  slave_for(self, service_name, redis_class=<class 'redis.client.Redis'>, connection_pool_class=<class 'redis.sentinel.SentinelConnectionPool'>, **kwargs)
     |      Returns redis client instance for the ``service_name`` slave(s).
     |
     |      A SentinelConnectionPool class is used to retrieve the slave's
     |      address before establishing a new connection.
     |
     |      By default clients will be a :py:class:`~redis.Redis` instance.
     |      Specify a different class to the ``redis_class`` argument if you
     |      desire something different.
     |
     |      The ``connection_pool_class`` specifies the connection pool to use.
     |      The SentinelConnectionPool will be used by default.
     |
     |      All other keyword arguments are merged with any connection_kwargs
     |      passed to this class and passed to the connection pool as keyword
     |      arguments to be used to initialize Redis connections.
     |
     |      HIMPORT note: the returned client exposes the HIMPORT command family
     |      (``himport_prepare``, ``himport_set``, ``himport_discard``,
     |      ``himport_discard_all``). Fieldsets are declared at runtime with
     |      ``himport_prepare`` on the client and live on that client's shared registry,
     |      so they survive Sentinel failover automatically: the pool re-points to the
     |      new master and the fieldset is re-prepared lazily on the next
     |      ``himport_set``. Each call to current method returns a *new* client with
     |      its *own* empty registry, so call ``himport_prepare`` on the long-lived client
     |      you reuse rather than creating a fresh one per operation; otherwise ``himport_set``
     |      fails with ``no such fieldset``. (``himport_set`` is a write and is served by
     |      the master.)
     |
     |  ----------------------------------------------------------------------
     |  Data and other attributes defined here:
     |
     |  __annotations__ = {}
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from redis.commands.sentinel.SentinelCommands:
     |
     |  sentinel(self, *args)
     |      Redis Sentinel's SENTINEL command.
     |
     |  sentinel_ckquorum(self, new_master_name) -> Union[bool, Awaitable[bool]]
     |      Check if the current Sentinel configuration is able to reach the
     |      quorum needed to failover a master, and the majority needed to
     |      authorize the failover.
     |
     |      This command should be used in monitoring systems to check if a
     |      Sentinel deployment is ok.
     |
     |  sentinel_failover(self, new_master_name) -> Union[bool, Awaitable[bool]]
     |      Force a failover as if the master was not reachable, and without
     |      asking for agreement to other Sentinels (however a new version of the
     |      configuration will be published so that the other Sentinels will
     |      update their configurations).
     |
     |  sentinel_flushconfig(self) -> Union[bool, Awaitable[bool]]
     |      Force Sentinel to rewrite its configuration on disk, including the
     |      current Sentinel state.
     |
     |      Normally Sentinel rewrites the configuration every time something
     |      changes in its state (in the context of the subset of the state which
     |      is persisted on disk across restart).
     |      However sometimes it is possible that the configuration file is lost
     |      because of operation errors, disk failures, package upgrade scripts or
     |      configuration managers. In those cases a way to to force Sentinel to
     |      rewrite the configuration file is handy.
     |
     |      This command works even if the previous configuration file is
     |      completely missing.
     |
     |  sentinel_get_master_addr_by_name(self, service_name, return_responses: bool = False) -> Union[tuple[bytes | str, int], NoneType, bool, Awaitable[tuple[bytes | str, int] | None | bool]]
     |      Returns a (host, port) pair for the given ``service_name`` when return_responses is True,
     |      otherwise returns a boolean value that indicates if the command was successful.
     |
     |  sentinel_master(self, service_name, return_responses: bool = False) -> Union[dict[str, Any], bool, Awaitable[dict[str, Any] | bool]]
     |      Returns a dictionary containing the specified masters state, when return_responses is True,
     |      otherwise returns a boolean value that indicates if the command was successful.
     |
     |  sentinel_masters(self) -> Union[dict[str, dict[str, Any]], list[dict[str, Any]], Awaitable[dict[str, dict[str, Any]] | list[dict[str, Any]]]]
     |      Returns a list of dictionaries containing each master's state.
     |
     |      Important: This function is called by the Sentinel implementation and is
     |      called directly on the Redis standalone client for sentinels,
     |      so it doesn't support the "once" and "return_responses" options.
     |
     |  sentinel_monitor(self, name, ip, port, quorum) -> Union[bool, Awaitable[bool]]
     |      Add a new master to Sentinel to be monitored
     |
     |  sentinel_remove(self, name) -> Union[bool, Awaitable[bool]]
     |      Remove a master from Sentinel's monitoring
     |
     |  sentinel_reset(self, pattern) -> Union[bool, Awaitable[bool]]
     |      This command will reset all the masters with matching name.
     |      The pattern argument is a glob-style pattern.
     |
     |      The reset process clears any previous state in a master (including a
     |      failover in progress), and removes every slave and sentinel already
     |      discovered and associated with the master.
     |
     |  sentinel_sentinels(self, service_name, return_responses: bool = False) -> Union[list[dict[str, Any]], bool, Awaitable[list[dict[str, Any]] | bool]]
     |      Returns a list of sentinels for ``service_name``, when return_responses is True,
     |      otherwise returns a boolean value that indicates if the command was successful.
     |
     |  sentinel_set(self, name, option, value) -> Union[bool, Awaitable[bool]]
     |      Set Sentinel monitoring parameters for a given master
     |
     |  sentinel_slaves(self, service_name) -> Union[list[dict[str, Any]], Awaitable[list[dict[str, Any]]]]
     |      Returns a list of slaves for ``service_name``
     |
     |      Important: This function is called by the Sentinel implementation and is
     |      called directly on the Redis standalone client for sentinels,
     |      so it doesn't support the "once" and "return_responses" options.
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors inherited from redis.commands.sentinel.SentinelCommands:
     |
     |  __dict__
     |      dictionary for instance variables
     |
     |  __weakref__
     |      list of weak references to the object

    class SentinelConnectionPool(redis.connection.ConnectionPool)
     |  SentinelConnectionPool(service_name, sentinel_manager, **kwargs)
     |
     |  Sentinel backed connection pool.
     |
     |  If ``check_connection`` flag is set to True, SentinelManagedConnection
     |  sends a PING command right after establishing the connection.
     |
     |  Method resolution order:
     |      SentinelConnectionPool
     |      redis.connection.ConnectionPool
     |      redis.connection.MaintNotificationsAbstractConnectionPool
     |      redis.connection.ConnectionPoolInterface
     |      abc.ABC
     |      builtins.object
     |
     |  Methods defined here:
     |
     |  __init__(self, service_name, sentinel_manager, **kwargs)
     |      Initialize self.  See help(type(self)) for accurate signature.
     |
     |  __repr__(self)
     |      Return repr(self).
     |
     |  get_master_address(self)
     |
     |  owns_connection(self, connection)
     |
     |  reset(self)
     |
     |  rotate_replicas(self)
     |      Round-robin replica balancer.
     |
     |      This is an alias for :py:meth:`rotate_slaves`,
     |      using the preferred Redis 5.0+ terminology.
     |
     |  rotate_slaves(self)
     |      Round-robin slave balancer
     |
     |  ----------------------------------------------------------------------
     |  Readonly properties defined here:
     |
     |  master_address
     |
     |  ----------------------------------------------------------------------
     |  Data and other attributes defined here:
     |
     |  __abstractmethods__ = frozenset()
     |
     |  __annotations__ = {}
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from redis.connection.ConnectionPool:
     |
     |  __del__(self) -> None
     |      Clean up connection pool and record metrics when garbage collected.
     |
     |  __enter__(self: ~_CP) -> ~_CP
     |
     |  __exit__(self, exc_type, exc_value, traceback) -> None
     |
     |  close(self) -> None
     |      Close the pool, disconnecting all connections
     |
     |  disconnect(self, inuse_connections: bool = True) -> None
     |      Disconnects connections in the pool
     |
     |      If ``inuse_connections`` is True, disconnect connections that are
     |      currently in use, potentially by other threads. Otherwise only disconnect
     |      connections that are idle in the pool.
     |
     |  get_connection(self, command_name=None, *keys, **options) -> 'Connection'
     |      Get a connection from the pool
     |
     |  get_connection_count(self) -> List[tuple[int, dict]]
     |      Returns a connection count (both idle and in use).
     |
     |  get_encoder(self) -> redis._parsers.encoders.Encoder
     |      Return an encoder based on encoding settings
     |
     |  get_protocol(self)
     |      Returns:
     |          The RESP protocol version, or ``None`` if the protocol is not specified,
     |          in which case the server default will be used.
     |
     |  make_connection(self) -> 'ConnectionInterface'
     |      Create a new connection
     |
     |  re_auth_callback(self, token: redis.auth.token.TokenInterface)
     |
     |  release(self, connection: 'Connection') -> None
     |      Releases the connection back to the pool
     |
     |  set_retry(self, retry: redis.retry.Retry) -> None
     |
     |  ----------------------------------------------------------------------
     |  Class methods inherited from redis.connection.ConnectionPool:
     |
     |  from_url(url: str, **kwargs) -> ~_CP
     |      Return a connection pool configured from the given URL.
     |
     |      For example::
     |
     |          redis://[[username]:[password]]@localhost:6379/0
     |          rediss://[[username]:[password]]@localhost:6379/0
     |          unix://[username@]/path/to/socket.sock?db=0[&password=password]
     |
     |      Three URL schemes are supported:
     |
     |      - `redis://` creates a TCP socket connection. See more at:
     |        <https://www.iana.org/assignments/uri-schemes/prov/redis>
     |      - `rediss://` creates a SSL wrapped TCP socket connection. See more at:
     |        <https://www.iana.org/assignments/uri-schemes/prov/rediss>
     |      - ``unix://``: creates a Unix Domain Socket connection.
     |
     |      The username, password, hostname, path and all querystring values
     |      are passed through urllib.parse.unquote in order to replace any
     |      percent-encoded values with their corresponding characters.
     |
     |      There are several ways to specify a database number. The first value
     |      found will be used:
     |
     |          1. A ``db`` querystring option, e.g. redis://localhost?db=0
     |          2. If using the redis:// or rediss:// schemes, the path argument
     |             of the url, e.g. redis://localhost/0
     |          3. A ``db`` keyword argument to this function.
     |
     |      If none of these options are specified, the default db=0 is used.
     |
     |      All querystring options are cast to their appropriate Python types.
     |      Boolean arguments can be specified with string values "True"/"False"
     |      or "Yes"/"No". Values that cannot be properly cast cause a
     |      ``ValueError`` to be raised. Once parsed, the querystring arguments
     |      and keyword arguments are passed to the ``ConnectionPool``'s
     |      class initializer. In the case of conflicting arguments, querystring
     |      arguments always win.
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors inherited from redis.connection.ConnectionPool:
     |
     |  connection_kwargs
     |
     |  ----------------------------------------------------------------------
     |  Data and other attributes inherited from redis.connection.ConnectionPool:
     |
     |  OMIT_REPR_KEYS = frozenset({'himport_registry'})
     |
     |  SENSITIVE_REPR_KEYS = frozenset({'credential_provider', 'password', 's...
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from redis.connection.MaintNotificationsAbstractConnectionPool:
     |
     |  disconnect_free_connections(self, moving_address_src: Optional[str] = None)
     |      Disconnect all free/available connections.
     |      This is used when a cluster node is migrated to a different address.
     |
     |      :param moving_address_src: The address of the node that is being moved.
     |
     |  maint_notifications_enabled(self)
     |      Returns:
     |          True if the maintenance notifications are enabled, False otherwise.
     |          The maintenance notifications config is stored in the pool handler.
     |          If the pool handler is not set, the maintenance notifications are not enabled.
     |
     |  update_active_connections_for_reconnect(self, moving_address_src: Optional[str] = None)
     |      Mark all active connections for reconnect.
     |      This is used when a cluster node is migrated to a different address.
     |
     |      :param moving_address_src: The address of the node that is being moved.
     |
     |  update_connection_kwargs(self, **kwargs)
     |      Update the connection kwargs for all future connections.
     |
     |      This method updates the connection kwargs for all future connections created by the pool.
     |      Existing connections are not affected.
     |
     |  update_connection_settings(self, conn: 'MaintNotificationsAbstractConnection', state: Optional[ForwardRef('MaintenanceState')] = None, maintenance_notification_hash: Optional[int] = None, host_address: Optional[str] = None, relaxed_timeout: Optional[float] = None, update_notification_hash: bool = False, reset_host_address: bool = False, reset_relaxed_timeout: bool = False)
     |      Update the settings for a single connection.
     |
     |  update_connections_settings(self, state: Optional[ForwardRef('MaintenanceState')] = None, maintenance_notification_hash: Optional[int] = None, host_address: Optional[str] = None, relaxed_timeout: Optional[float] = None, matching_address: Optional[str] = None, matching_notification_hash: Optional[int] = None, matching_pattern: Literal['connected_address', 'configured_address', 'notification_hash'] = 'connected_address', update_notification_hash: bool = False, reset_host_address: bool = False, reset_relaxed_timeout: bool = False, include_free_connections: bool = True)
     |      Update the settings for all matching connections in the pool.
     |
     |      This method does not create new connections.
     |      This method does not affect the connection kwargs.
     |
     |      :param state: The maintenance state to set for the connection.
     |      :param maintenance_notification_hash: The hash of the maintenance notification
     |                                             to set for the connection.
     |      :param host_address: The host address to set for the connection.
     |      :param relaxed_timeout: The relaxed timeout to set for the connection.
     |      :param matching_address: The address to match for the connection.
     |      :param matching_notification_hash: The notification hash to match for the connection.
     |      :param matching_pattern: The pattern to match for the connection.
     |      :param update_notification_hash: Whether to update the notification hash for the connection.
     |      :param reset_host_address: Whether to reset the host address to the original address.
     |      :param reset_relaxed_timeout: Whether to reset the relaxed timeout to the original timeout.
     |      :param include_free_connections: Whether to include free/available connections.
     |
     |  update_maint_notifications_config(self, maint_notifications_config: redis.maint_notifications.MaintNotificationsConfig, oss_cluster_maint_notifications_handler: Optional[redis.maint_notifications.OSSMaintNotificationsHandler] = None)
     |      Updates the maintenance notifications configuration.
     |      This method should be called only if the pool was created
     |      without enabling the maintenance notifications and
     |      in a later point in time maintenance notifications
     |      are requested to be enabled.
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors inherited from redis.connection.MaintNotificationsAbstractConnectionPool:
     |
     |  __dict__
     |      dictionary for instance variables
     |
     |  __weakref__
     |      list of weak references to the object

    class SentinelConnectionPoolProxy(builtins.object)
     |  SentinelConnectionPoolProxy(connection_pool, is_master, check_connection, service_name, sentinel_manager)
     |
     |  Methods defined here:
     |
     |  __init__(self, connection_pool, is_master, check_connection, service_name, sentinel_manager)
     |      Initialize self.  See help(type(self)) for accurate signature.
     |
     |  get_master_address(self)
     |
     |  reset(self)
     |
     |  rotate_replicas(self)
     |      Round-robin replica balancer.
     |
     |      This is an alias for :py:meth:`rotate_slaves`,
     |      using the preferred Redis 5.0+ terminology.
     |
     |  rotate_slaves(self)
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors defined here:
     |
     |  __dict__
     |      dictionary for instance variables
     |
     |  __weakref__
     |      list of weak references to the object

    class SentinelManagedConnection(redis.connection.Connection)
     |  SentinelManagedConnection(**kwargs)
     |
     |  Method resolution order:
     |      SentinelManagedConnection
     |      redis.connection.Connection
     |      redis.connection.AbstractConnection
     |      redis.connection.MaintNotificationsAbstractConnection
     |      redis.connection.ConnectionInterface
     |      builtins.object
     |
     |  Methods defined here:
     |
     |  __init__(self, **kwargs)
     |      Initialize a TCP connection.
     |
     |      Parameters
     |      ----------
     |      socket_keepalive : bool
     |          If `True`, TCP keepalive is enabled for TCP socket connections.
     |      socket_keepalive_options : Mapping[int, int | bytes] | object | None
     |          Mapping of TCP keepalive socket option constants to values, for
     |          example `{socket.TCP_KEEPIDLE: 30}`. If left unspecified, redis-py
     |          uses TCP keepalive defaults when `socket_keepalive` is enabled:
     |          idle 30 seconds, interval 5 seconds, and 3 probes. Platform-specific
     |          options that are not available are skipped. Pass `None` or `{}` to
     |          avoid setting additional TCP keepalive options.
     |
     |  __repr__(self)
     |      Return repr(self).
     |
     |  connect(self)
     |      Connects to the Redis server if not already connected
     |
     |  connect_to(self, address)
     |
     |  read_response(self, disable_decoding=False, *, timeout: Union[float, object] = <object object at 0x0000017B991493E0>, disconnect_on_error: Optional[bool] = False, push_request: Optional[bool] = False)
     |      Read the response from a previously sent command
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from redis.connection.Connection:
     |
     |  repr_pieces(self)
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors inherited from redis.connection.Connection:
     |
     |  host
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from redis.connection.AbstractConnection:
     |
     |  __del__(self)
     |
     |  can_read(self, timeout: float = 0) -> bool
     |      Poll the socket to see if there's data that can be read.
     |
     |  check_health(self)
     |      Check the health of the connection with a PING/PONG
     |
     |  connect_check_health(self, check_health: bool = True, retry_socket_connect: bool = True)
     |
     |  deregister_connect_callback(self, callback)
     |      De-register a previously registered callback.  It will no-longer receive
     |      notifications on connection events.  Calling this is not required when the
     |      listener goes away, since the callbacks are kept as weak methods.
     |
     |  disconnect(self, *args, **kwargs)
     |      Disconnects from the Redis server
     |
     |  extract_connection_details(self) -> str
     |
     |  get_protocol(self) -> Union[int, str]
     |      Returns:
     |          The RESP protocol version, or ``None`` if the protocol is not specified,
     |          in which case the server default will be used.
     |
     |  mark_for_reconnect(self)
     |      Mark the connection to be reconnected on the next command.
     |      This is useful when a connection is moved to a different node.
     |
     |  on_connect(self)
     |
     |  on_connect_check_health(self, check_health: bool = True)
     |      Initialize the connection, authenticate and select a database
     |
     |  pack_command(self, *args)
     |      Pack a series of arguments into the Redis protocol
     |
     |  pack_commands(self, commands)
     |      Pack multiple commands into the Redis protocol
     |
     |  re_auth(self)
     |
     |  register_connect_callback(self, callback)
     |      Register a callback to be called when the connection is established either
     |      initially or reconnected.  This allows listeners to issue commands that
     |      are ephemeral to the connection, for example pub/sub subscription or
     |      key tracking.  The callback must be a _method_ and will be kept as
     |      a weak reference.
     |
     |  reset_should_reconnect(self)
     |      Reset the internal flag to False.
     |
     |  send_command(self, *args, **kwargs)
     |      Pack and send a command to the Redis server
     |
     |  send_packed_command(self, command, check_health=True)
     |      Send an already packed command to the Redis server
     |
     |  set_parser(self, parser_class)
     |      Creates a new instance of parser_class with socket size:
     |      _socket_read_size and assigns it to the parser for the connection
     |      :param parser_class: The required parser class
     |
     |  set_re_auth_token(self, token: redis.auth.token.TokenInterface)
     |
     |  should_reconnect(self)
     |      Returns True if the connection should be reconnected.
     |
     |  ----------------------------------------------------------------------
     |  Readonly properties inherited from redis.connection.AbstractConnection:
     |
     |  is_connected
     |      Return ``True`` if the connection to the server is active.
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors inherited from redis.connection.AbstractConnection:
     |
     |  handshake_metadata
     |
     |  socket_connect_timeout
     |
     |  socket_timeout
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from redis.connection.MaintNotificationsAbstractConnection:
     |
     |  activate_maint_notifications_handling_if_enabled(self, check_health=True)
     |
     |  add_maint_start_notification(self, id: int)
     |
     |  add_skipped_end_notification(self, id: int)
     |
     |  get_processed_start_notifications(self) -> set
     |
     |  get_resolved_ip(self) -> Optional[str]
     |      Extract the resolved IP address from an
     |      established connection or resolve it from the host.
     |
     |      First tries to get the actual IP from the socket (most accurate),
     |      then falls back to DNS resolution if needed.
     |
     |      Returns:
     |          str: The resolved IP address, or None if it cannot be determined
     |
     |  get_skipped_end_notifications(self) -> set
     |
     |  getpeername(self)
     |      Returns the peer name of the connection.
     |
     |  reset_received_notifications(self)
     |
     |  reset_tmp_settings(self, reset_host_address: bool = False, reset_relaxed_timeout: bool = False)
     |
     |  set_maint_notifications_cluster_handler_for_connection(self, oss_cluster_maint_notifications_handler: redis.maint_notifications.OSSMaintNotificationsHandler)
     |
     |  set_maint_notifications_pool_handler_for_connection(self, maint_notifications_pool_handler: redis.maint_notifications.MaintNotificationsPoolHandler)
     |
     |  set_tmp_settings(self, tmp_host_address: Union[str, object, NoneType] = <object object at 0x0000017B991493E0>, tmp_relaxed_timeout: Optional[float] = -1)
     |      SENTINEL keeps the host unchanged. -1 keeps the relaxed timeout unchanged.
     |
     |  update_current_socket_timeout(self, relaxed_timeout: Optional[float] = None)
     |
     |  update_parser_timeout(self, timeout: Optional[float] = None)
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors inherited from redis.connection.MaintNotificationsAbstractConnection:
     |
     |  __dict__
     |      dictionary for instance variables
     |
     |  __weakref__
     |      list of weak references to the object
     |
     |  maintenance_state

    class SentinelManagedSSLConnection(SentinelManagedConnection, redis.connection.SSLConnection)
     |  SentinelManagedSSLConnection(**kwargs)
     |
     |  Method resolution order:
     |      SentinelManagedSSLConnection
     |      SentinelManagedConnection
     |      redis.connection.SSLConnection
     |      redis.connection.Connection
     |      redis.connection.AbstractConnection
     |      redis.connection.MaintNotificationsAbstractConnection
     |      redis.connection.ConnectionInterface
     |      builtins.object
     |
     |  Methods inherited from SentinelManagedConnection:
     |
     |  __init__(self, **kwargs)
     |      Initialize a TCP connection.
     |
     |      Parameters
     |      ----------
     |      socket_keepalive : bool
     |          If `True`, TCP keepalive is enabled for TCP socket connections.
     |      socket_keepalive_options : Mapping[int, int | bytes] | object | None
     |          Mapping of TCP keepalive socket option constants to values, for
     |          example `{socket.TCP_KEEPIDLE: 30}`. If left unspecified, redis-py
     |          uses TCP keepalive defaults when `socket_keepalive` is enabled:
     |          idle 30 seconds, interval 5 seconds, and 3 probes. Platform-specific
     |          options that are not available are skipped. Pass `None` or `{}` to
     |          avoid setting additional TCP keepalive options.
     |
     |  __repr__(self)
     |      Return repr(self).
     |
     |  connect(self)
     |      Connects to the Redis server if not already connected
     |
     |  connect_to(self, address)
     |
     |  read_response(self, disable_decoding=False, *, timeout: Union[float, object] = <object object at 0x0000017B991493E0>, disconnect_on_error: Optional[bool] = False, push_request: Optional[bool] = False)
     |      Read the response from a previously sent command
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from redis.connection.Connection:
     |
     |  repr_pieces(self)
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors inherited from redis.connection.Connection:
     |
     |  host
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from redis.connection.AbstractConnection:
     |
     |  __del__(self)
     |
     |  can_read(self, timeout: float = 0) -> bool
     |      Poll the socket to see if there's data that can be read.
     |
     |  check_health(self)
     |      Check the health of the connection with a PING/PONG
     |
     |  connect_check_health(self, check_health: bool = True, retry_socket_connect: bool = True)
     |
     |  deregister_connect_callback(self, callback)
     |      De-register a previously registered callback.  It will no-longer receive
     |      notifications on connection events.  Calling this is not required when the
     |      listener goes away, since the callbacks are kept as weak methods.
     |
     |  disconnect(self, *args, **kwargs)
     |      Disconnects from the Redis server
     |
     |  extract_connection_details(self) -> str
     |
     |  get_protocol(self) -> Union[int, str]
     |      Returns:
     |          The RESP protocol version, or ``None`` if the protocol is not specified,
     |          in which case the server default will be used.
     |
     |  mark_for_reconnect(self)
     |      Mark the connection to be reconnected on the next command.
     |      This is useful when a connection is moved to a different node.
     |
     |  on_connect(self)
     |
     |  on_connect_check_health(self, check_health: bool = True)
     |      Initialize the connection, authenticate and select a database
     |
     |  pack_command(self, *args)
     |      Pack a series of arguments into the Redis protocol
     |
     |  pack_commands(self, commands)
     |      Pack multiple commands into the Redis protocol
     |
     |  re_auth(self)
     |
     |  register_connect_callback(self, callback)
     |      Register a callback to be called when the connection is established either
     |      initially or reconnected.  This allows listeners to issue commands that
     |      are ephemeral to the connection, for example pub/sub subscription or
     |      key tracking.  The callback must be a _method_ and will be kept as
     |      a weak reference.
     |
     |  reset_should_reconnect(self)
     |      Reset the internal flag to False.
     |
     |  send_command(self, *args, **kwargs)
     |      Pack and send a command to the Redis server
     |
     |  send_packed_command(self, command, check_health=True)
     |      Send an already packed command to the Redis server
     |
     |  set_parser(self, parser_class)
     |      Creates a new instance of parser_class with socket size:
     |      _socket_read_size and assigns it to the parser for the connection
     |      :param parser_class: The required parser class
     |
     |  set_re_auth_token(self, token: redis.auth.token.TokenInterface)
     |
     |  should_reconnect(self)
     |      Returns True if the connection should be reconnected.
     |
     |  ----------------------------------------------------------------------
     |  Readonly properties inherited from redis.connection.AbstractConnection:
     |
     |  is_connected
     |      Return ``True`` if the connection to the server is active.
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors inherited from redis.connection.AbstractConnection:
     |
     |  handshake_metadata
     |
     |  socket_connect_timeout
     |
     |  socket_timeout
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from redis.connection.MaintNotificationsAbstractConnection:
     |
     |  activate_maint_notifications_handling_if_enabled(self, check_health=True)
     |
     |  add_maint_start_notification(self, id: int)
     |
     |  add_skipped_end_notification(self, id: int)
     |
     |  get_processed_start_notifications(self) -> set
     |
     |  get_resolved_ip(self) -> Optional[str]
     |      Extract the resolved IP address from an
     |      established connection or resolve it from the host.
     |
     |      First tries to get the actual IP from the socket (most accurate),
     |      then falls back to DNS resolution if needed.
     |
     |      Returns:
     |          str: The resolved IP address, or None if it cannot be determined
     |
     |  get_skipped_end_notifications(self) -> set
     |
     |  getpeername(self)
     |      Returns the peer name of the connection.
     |
     |  reset_received_notifications(self)
     |
     |  reset_tmp_settings(self, reset_host_address: bool = False, reset_relaxed_timeout: bool = False)
     |
     |  set_maint_notifications_cluster_handler_for_connection(self, oss_cluster_maint_notifications_handler: redis.maint_notifications.OSSMaintNotificationsHandler)
     |
     |  set_maint_notifications_pool_handler_for_connection(self, maint_notifications_pool_handler: redis.maint_notifications.MaintNotificationsPoolHandler)
     |
     |  set_tmp_settings(self, tmp_host_address: Union[str, object, NoneType] = <object object at 0x0000017B991493E0>, tmp_relaxed_timeout: Optional[float] = -1)
     |      SENTINEL keeps the host unchanged. -1 keeps the relaxed timeout unchanged.
     |
     |  update_current_socket_timeout(self, relaxed_timeout: Optional[float] = None)
     |
     |  update_parser_timeout(self, timeout: Optional[float] = None)
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors inherited from redis.connection.MaintNotificationsAbstractConnection:
     |
     |  __dict__
     |      dictionary for instance variables
     |
     |  __weakref__
     |      list of weak references to the object
     |
     |  maintenance_state

    class SlaveNotFoundError(redis.exceptions.ConnectionError)
     |  SlaveNotFoundError(*args, status_code: str | None = None)
     |
     |  Method resolution order:
     |      SlaveNotFoundError
     |      redis.exceptions.ConnectionError
     |      redis.exceptions.RedisError
     |      builtins.Exception
     |      builtins.BaseException
     |      builtins.object
     |
     |  Methods inherited from redis.exceptions.ConnectionError:
     |
     |  __init__(self, *args, status_code: str | None = None)
     |      Initialize self.  See help(type(self)) for accurate signature.
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from redis.exceptions.RedisError:
     |
     |  __repr__(self)
     |      Return repr(self).
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors inherited from redis.exceptions.RedisError:
     |
     |  __weakref__
     |      list of weak references to the object
     |
     |  ----------------------------------------------------------------------
     |  Static methods inherited from builtins.Exception:
     |
     |  __new__(*args, **kwargs) class method of builtins.Exception
     |      Create and return a new object.  See help(type) for accurate signature.
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from builtins.BaseException:
     |
     |  __getattribute__(self, name, /)
     |      Return getattr(self, name).
     |
     |  __reduce__(...)
     |      Helper for pickle.
     |
     |  __setstate__(...)
     |
     |  __str__(self, /)
     |      Return str(self).
     |
     |  add_note(...)
     |      Exception.add_note(note) --
     |      add a note to the exception
     |
     |  with_traceback(...)
     |      Exception.with_traceback(tb) --
     |      set self.__traceback__ to tb and return self.
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors inherited from builtins.BaseException:
     |
     |  __cause__
     |      exception cause
     |
     |  __context__
     |      exception context
     |
     |  __dict__
     |
     |  __suppress_context__
     |
     |  __traceback__
     |
     |  args

DATA
    Optional = typing.Optional
        Optional[X] is equivalent to Union[X, None].

    SENTINEL = <object object>
    Union = typing.Union
        Union type; Union[X, Y] means either X or Y.

        On Python 3.10 and higher, the | operator
        can also be used to denote unions;
        X | Y means the same thing to the type checker as Union[X, Y].

        To define a union, use e.g. Union[int, str]. Details:
        - The arguments must be types and there must be at least one.
        - None as an argument is a special case and is replaced by
          type(None).
        - Unions of unions are flattened, e.g.::

            assert Union[Union[int, str], float] == Union[int, str, float]

        - Unions of a single argument vanish, e.g.::

            assert Union[int] == int  # The constructor actually returns int

        - Redundant arguments are skipped, e.g.::

            assert Union[int, str, int] == Union[int, str]

        - When comparing unions, the argument order is ignored, e.g.::

            assert Union[int, str] == Union[str, int]

        - You cannot subclass or instantiate a union.
        - You can use Optional[X] as a shorthand for Union[X, None].

FILE
    c:\users\youse\appdata\local\programs\python\python312\lib\site-packages\redis\sentinel.py

Python Library Documentation: module redis.typing in redis

NAME
    redis.typing

CLASSES
    builtins.object
        Subscription
    typing.Protocol(typing.Generic)
        AsyncClientProtocol
        CommandsProtocol
            ClusterCommandsProtocol
        SyncClientProtocol

    class AsyncClientProtocol(typing.Protocol)
     |  AsyncClientProtocol(*args, **kwargs)
     |
     |  Protocol for asynchronous Redis clients (redis.asyncio.client.Redis).
     |
     |  This protocol uses a Literal marker to identify async clients.
     |  Used in @overload to provide correct return types for async clients.
     |
     |  Method resolution order:
     |      AsyncClientProtocol
     |      typing.Protocol
     |      typing.Generic
     |      builtins.object
     |
     |  Methods defined here:
     |
     |  __init__ = _no_init_or_replace_init(self, *args, **kwargs) from typing
     |
     |  ----------------------------------------------------------------------
     |  Class methods defined here:
     |
     |  __subclasshook__ = _proto_hook(other) from typing
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors defined here:
     |
     |  __dict__
     |      dictionary for instance variables
     |
     |  __weakref__
     |      list of weak references to the object
     |
     |  ----------------------------------------------------------------------
     |  Data and other attributes defined here:
     |
     |  __abstractmethods__ = frozenset()
     |
     |  __annotations__ = {'_is_async_client': typing.Literal[True]}
     |
     |  __parameters__ = ()
     |
     |  __protocol_attrs__ = {'_is_async_client'}
     |
     |  ----------------------------------------------------------------------
     |  Class methods inherited from typing.Protocol:
     |
     |  __init_subclass__(*args, **kwargs)
     |      Function to initialize subclasses.
     |
     |  ----------------------------------------------------------------------
     |  Class methods inherited from typing.Generic:
     |
     |  __class_getitem__(...)
     |      Parameterizes a generic class.
     |
     |      At least, parameterizing a generic class is the *main* thing this
     |      method does. For example, for some generic class `Foo`, this is called
     |      when we do `Foo[int]` - there, with `cls=Foo` and `params=int`.
     |
     |      However, note that this method is also called when defining generic
     |      classes in the first place with `class Foo[T]: ...`.

    class ClusterCommandsProtocol(CommandsProtocol)
     |  ClusterCommandsProtocol(*args, **kwargs)
     |
     |  Method resolution order:
     |      ClusterCommandsProtocol
     |      CommandsProtocol
     |      typing.Protocol
     |      typing.Generic
     |      builtins.object
     |
     |  Class methods defined here:
     |
     |  __subclasshook__ = _proto_hook(other) from typing
     |
     |  ----------------------------------------------------------------------
     |  Data and other attributes defined here:
     |
     |  __abstractmethods__ = frozenset()
     |
     |  __annotations__ = {'encoder': 'Encoder'}
     |
     |  __parameters__ = ()
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from CommandsProtocol:
     |
     |  __init__ = _no_init_or_replace_init(self, *args, **kwargs) from typing
     |
     |  execute_command(self, *args, **options) -> Union[Awaitable[Any], Any]
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors inherited from CommandsProtocol:
     |
     |  __dict__
     |      dictionary for instance variables
     |
     |  __weakref__
     |      list of weak references to the object
     |
     |  ----------------------------------------------------------------------
     |  Data and other attributes inherited from CommandsProtocol:
     |
     |  __protocol_attrs__ = {'_event_dispatcher', 'execute_command'}
     |
     |  ----------------------------------------------------------------------
     |  Class methods inherited from typing.Protocol:
     |
     |  __init_subclass__(*args, **kwargs)
     |      Function to initialize subclasses.
     |
     |  ----------------------------------------------------------------------
     |  Class methods inherited from typing.Generic:
     |
     |  __class_getitem__(...)
     |      Parameterizes a generic class.
     |
     |      At least, parameterizing a generic class is the *main* thing this
     |      method does. For example, for some generic class `Foo`, this is called
     |      when we do `Foo[int]` - there, with `cls=Foo` and `params=int`.
     |
     |      However, note that this method is also called when defining generic
     |      classes in the first place with `class Foo[T]: ...`.

    class CommandsProtocol(typing.Protocol)
     |  CommandsProtocol(*args, **kwargs)
     |
     |  Method resolution order:
     |      CommandsProtocol
     |      typing.Protocol
     |      typing.Generic
     |      builtins.object
     |
     |  Methods defined here:
     |
     |  __init__ = _no_init_or_replace_init(self, *args, **kwargs) from typing
     |
     |  execute_command(self, *args, **options) -> Union[Awaitable[Any], Any]
     |
     |  ----------------------------------------------------------------------
     |  Class methods defined here:
     |
     |  __subclasshook__ = _proto_hook(other) from typing
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors defined here:
     |
     |  __dict__
     |      dictionary for instance variables
     |
     |  __weakref__
     |      list of weak references to the object
     |
     |  ----------------------------------------------------------------------
     |  Data and other attributes defined here:
     |
     |  __abstractmethods__ = frozenset()
     |
     |  __annotations__ = {'_event_dispatcher': 'EventDispatcherInterface'}
     |
     |  __parameters__ = ()
     |
     |  __protocol_attrs__ = {'_event_dispatcher', 'execute_command'}
     |
     |  ----------------------------------------------------------------------
     |  Class methods inherited from typing.Protocol:
     |
     |  __init_subclass__(*args, **kwargs)
     |      Function to initialize subclasses.
     |
     |  ----------------------------------------------------------------------
     |  Class methods inherited from typing.Generic:
     |
     |  __class_getitem__(...)
     |      Parameterizes a generic class.
     |
     |      At least, parameterizing a generic class is the *main* thing this
     |      method does. For example, for some generic class `Foo`, this is called
     |      when we do `Foo[int]` - there, with `cls=Foo` and `params=int`.
     |
     |      However, note that this method is also called when defining generic
     |      classes in the first place with `class Foo[T]: ...`.

    class Subscription(builtins.object)
     |  Subscription(name: Union[bytes, str, memoryview], handler: Optional[Callable[[dict[str, Any]], Any]] = None) -> None
     |
     |  PubSub channel or pattern subscription with an optional handler.
     |
     |  Methods defined here:
     |
     |  __delattr__(self, name)
     |      Implement delattr(self, name).
     |
     |  __eq__(self, other)
     |      Return self==value.
     |
     |  __hash__(self)
     |      Return hash(self).
     |
     |  __init__(self, name: Union[bytes, str, memoryview], handler: Optional[Callable[[dict[str, Any]], Any]] = None) -> None
     |      Initialize self.  See help(type(self)) for accurate signature.
     |
     |  __repr__(self)
     |      Return repr(self).
     |
     |  __setattr__(self, name, value)
     |      Implement setattr(self, name, value).
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors defined here:
     |
     |  __dict__
     |      dictionary for instance variables
     |
     |  __weakref__
     |      list of weak references to the object
     |
     |  ----------------------------------------------------------------------
     |  Data and other attributes defined here:
     |
     |  __annotations__ = {'handler': typing.Optional[typing.Callable[[dict[st...
     |
     |  __dataclass_fields__ = {'handler': Field(name='handler',type=typing.Op...
     |
     |  __dataclass_params__ = _DataclassParams(init=True,repr=True,eq=True,or...
     |
     |  __match_args__ = ('name', 'handler')
     |
     |  handler = None

    class SyncClientProtocol(typing.Protocol)
     |  SyncClientProtocol(*args, **kwargs)
     |
     |  Protocol for synchronous Redis clients (redis.client.Redis).
     |
     |  This protocol uses a Literal marker to identify sync clients.
     |  Used in @overload to provide correct return types for sync clients.
     |
     |  Method resolution order:
     |      SyncClientProtocol
     |      typing.Protocol
     |      typing.Generic
     |      builtins.object
     |
     |  Methods defined here:
     |
     |  __init__ = _no_init_or_replace_init(self, *args, **kwargs) from typing
     |
     |  ----------------------------------------------------------------------
     |  Class methods defined here:
     |
     |  __subclasshook__ = _proto_hook(other) from typing
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors defined here:
     |
     |  __dict__
     |      dictionary for instance variables
     |
     |  __weakref__
     |      list of weak references to the object
     |
     |  ----------------------------------------------------------------------
     |  Data and other attributes defined here:
     |
     |  __abstractmethods__ = frozenset()
     |
     |  __annotations__ = {'_is_async_client': typing.Literal[False]}
     |
     |  __parameters__ = ()
     |
     |  __protocol_attrs__ = {'_is_async_client'}
     |
     |  ----------------------------------------------------------------------
     |  Class methods inherited from typing.Protocol:
     |
     |  __init_subclass__(*args, **kwargs)
     |      Function to initialize subclasses.
     |
     |  ----------------------------------------------------------------------
     |  Class methods inherited from typing.Generic:
     |
     |  __class_getitem__(...)
     |      Parameterizes a generic class.
     |
     |      At least, parameterizing a generic class is the *main* thing this
     |      method does. For example, for some generic class `Foo`, this is called
     |      when we do `Foo[int]` - there, with `cls=Foo` and `params=int`.
     |
     |      However, note that this method is also called when defining generic
     |      classes in the first place with `class Foo[T]: ...`.

DATA
    ACLGetUserData = dict[str, bool | list[str] | list[list[str]] | list[d...
    ACLLogData = list[dict[str, str | float | dict[str, str | int]]]
    ACLLogEntry = dict[str, str | float | dict[str, str | int]]
    AbsExpiryT = typing.Union[int, datetime.datetime]
    AnyChannelT = ~AnyChannelT
    AnyFieldT = ~AnyFieldT
    AnyKeyT = ~AnyKeyT
    Awaitable = typing.Awaitable
        A generic version of collections.abc.Awaitable.

    BitfieldOffsetT = typing.Union[int, str]
    BlockingListPopResponse = tuple[bytes | str, bytes | str] | list[bytes...
    BlockingZSetPopResponse = tuple[bytes | str, bytes | str, float] | lis...
    BloomScanDumpResponse = tuple[int, bytes | None]
    Callable = typing.Callable
        Deprecated alias to collections.abc.Callable.

        Callable[[int], str] signifies a function that takes a single
        parameter of type int and returns a str.

        The subscription syntax must always be used with exactly two
        values: the argument list and the return type.
        The argument list must be a list of types, a ParamSpec,
        Concatenate or ellipsis. The return type must be a single type.

        There is no syntax to indicate optional or keyword arguments;
        such function types are rarely used as callback types.

    ChannelT = typing.Union[bytes, str, memoryview]
    ClientTrackingInfoResponse = list[bytes | str] | dict[str, typing.Any]
    ClusterLink = dict[str, typing.Any] | list[typing.Any]
    ClusterLinksResponse = list[dict[str, typing.Any] | list[typing.Any]]
    ClusterNodeDetail = dict[str, str | bool | list[list[str]] | list[dict...
    ClusterShard = dict[str, typing.Any]
    ClusterShardsResponse = list[dict[str, typing.Any]]
    CommandGetKeysAndFlagsEntry = list[bytes | str | list[bytes | str]]
    CommandGetKeysAndFlagsResponse = list[list[bytes | str | list[bytes | ...
    ConsumerT = typing.Union[bytes, str, memoryview]
    DecodedT = typing.Union[str, int, float]
    EncodableT = typing.Union[bytes, bytearray, memoryview, str, int, floa...
    EncodedT = typing.Union[bytes, bytearray, memoryview]
    ExceptionMappingT = typing.Mapping[str, typing.Union[typing.Type[Exc.....
    ExpiryT = typing.Union[int, datetime.timedelta]
    FieldT = typing.Union[bytes, bytearray, memoryview, str, int, float]
    GeoCoordinate = tuple[float, float] | list[float]
    GeoRadiusResponse = list[bytes | str | list[bytes | str | float | int ...
    GeoSearchItem = bytes | str | list[bytes | str | float | int | tuple[f...
    GeoSearchResponse = list[bytes | str | list[bytes | str | float | int ...
    GroupT = typing.Union[bytes, str, memoryview]
    HRandFieldResponse = bytes | str | list[bytes | str] | list[list[bytes...
    HScanPayload = dict[bytes | str, bytes | str] | list[bytes | str]
    HScanResponse = tuple[int, dict[bytes | str, bytes | str] | list[bytes...
    Iterable = typing.Iterable
        A generic version of collections.abc.Iterable.

    KeyT = typing.Union[bytes, str, memoryview]
    KeysT = typing.Union[bytes, str, memoryview, typing.Iterable[typing.Un...
    LCSCommandResponse = bytes | str | int | list[typing.Any] | dict[bytes...
    LCSIndexResponse = list[typing.Any] | dict[bytes | str, typing.Any]
    LCSMatch = list[int | tuple[int, int] | list[int]]
    LCSRange = tuple[int, int] | list[int]
    LCSResult = dict[str, int | list[list[int | tuple[int, int] | list[int...
    ListMultiPopResponse = list[bytes | str | list[bytes | str]] | None
    Literal = typing.Literal
        Special typing form to define literal types (a.k.a. value types).

        This form can be used to indicate to type checkers that the corresponding
        variable or function parameter has a value equivalent to the provided
        literal (or one of several literals)::

            def validate_simple(data: Any) -> Literal[True]:  # always returns True
                ...

            MODE = Literal['r', 'rb', 'w', 'wb']
            def open_helper(file: str, mode: MODE) -> str:
                ...

            open_helper('/some/path', 'r')  # Passes type check
            open_helper('/other/path', 'typo')  # Error in type checker

        Literal[...] cannot be subclassed. At runtime, an arbitrary value
        is allowed as type argument to Literal[...], but type checkers may
        impose restrictions.

    Mapping = typing.Mapping
        A generic version of collections.abc.Mapping.

    ModuleListResponse = list[bytes | int | float | str | None]
    Number = typing.Union[int, float]
    PatternT = typing.Union[bytes, str, memoryview]
    PubSubHandler = typing.Callable[[dict[str, typing.Any]], typing.Any]
    ResponseT = typing.Union[typing.Awaitable[typing.Any], typing.Any]
    ScanResponse = tuple[int, list[bytes | str]]
    ScriptTextT = typing.Union[bytes, str, memoryview]
    SentinelMasterAddress = tuple[bytes | str, int] | None
    SentinelMastersResponse = dict[str, dict[str, typing.Any]] | list[dict...
    SortResponse = list[bytes | str] | list[tuple[bytes | str, ...]] | int
    StralgoResponse = str | int | dict[str, int | list[list[int | tuple[in...
    StreamEntry = tuple[bytes | str | None, dict[bytes | str, bytes | str]...
    StreamIdT = typing.Union[int, bytes, str, memoryview]
    StreamRangeResponse = list[tuple[bytes | str | None, dict[bytes | str,...
    TYPE_CHECKING = False
    TimeSeriesMRangeResponse = list[typing.Any] | dict[bytes | str, list[t...
    TimeSeriesMRangeSeries = list[typing.Any]
    TimeSeriesNRangeResponse = list[list[int | list[float]]]
    TimeSeriesRangeResponse = list[tuple[int, float] | list[int | float]]
    TimeSeriesSample = tuple[int, float] | list[int | float]
    TimeoutSecT = typing.Union[int, float, bytes, str, memoryview]
    Type = typing.Type
        Deprecated alias to builtins.type.

        builtins.type or typing.Type can be used to annotate class objects.
        For example, suppose we have the following classes::

            class User: ...  # Abstract base for User classes
            class BasicUser(User): ...
            class ProUser(User): ...
            class TeamUser(User): ...

        And a function that takes a class argument that's a subclass of
        User and returns an instance of the corresponding class::

            def new_user[U](user_class: Type[U]) -> U:
                user = user_class()
                # (Here we could write the user object to a database)
                return user

            joe = new_user(BasicUser)

        At this point the type checker knows that joe has type BasicUser.

    Union = typing.Union
        Union type; Union[X, Y] means either X or Y.

        On Python 3.10 and higher, the | operator
        can also be used to denote unions;
        X | Y means the same thing to the type checker as Union[X, Y].

        To define a union, use e.g. Union[int, str]. Details:
        - The arguments must be types and there must be at least one.
        - None as an argument is a special case and is replaced by
          type(None).
        - Unions of unions are flattened, e.g.::

            assert Union[Union[int, str], float] == Union[int, str, float]

        - Unions of a single argument vanish, e.g.::

            assert Union[int] == int  # The constructor actually returns int

        - Redundant arguments are skipped, e.g.::

            assert Union[int, str, int] == Union[int, str]

        - When comparing unions, the argument order is ignored, e.g.::

            assert Union[int, str] == Union[str, int]

        - You cannot subclass or instantiate a union.
        - You can use Optional[X] as a shorthand for Union[X, None].

    XClaimResponse = list[tuple[bytes | str | None, dict[bytes | str, byte...
    XPendingRangeEntry = dict[str, bytes | str | int]
    XPendingRangeResponse = list[dict[str, bytes | str | int]]
    XReadGroupClaimEntry = tuple[bytes | str, dict[bytes | str, bytes | st...
    XReadGroupResponse = list[list[typing.Any]] | dict[bytes | str, list[....
    XReadGroupStreamResponse = list[tuple[bytes | str | None, dict[bytes |...
    XReadResponse = list[list[typing.Any]] | dict[bytes | str, list[... | ...
    ZMPopResponse = list[bytes | str | list[list[typing.Any]]] | None
    ZRandMemberResponse = bytes | str | None | list[bytes | str] | list[by...
    ZScanPair = tuple[bytes | str, float] | list[bytes | str | float]
    ZScanResponse = tuple[int, list[tuple[bytes | str, float] | list[bytes...
    ZScoreBoundT = typing.Union[float, str]
    ZSetRangeResponse = list[bytes | str] | list[tuple[bytes | str, typing...
    ZSetScoredMembers = list[tuple[bytes | str, typing.Any]] | list[list[t...

FILE
    c:\users\youse\appdata\local\programs\python\python312\lib\site-packages\redis\typing.py

Python Library Documentation: module redis.utils in redis

NAME
    redis.utils

FUNCTIONS
    check_protocol_version(protocol: str | int | object | None, expected_version: int = 3) -> bool

    compare_versions(version1: str, version2: str) -> int
        Compare two versions.

        :return: -1 if version1 > version2
                 0 if both versions are equal
                 1 if version1 < version2

    decode_field_value(value, key=None, field_encodings=None)
        Decode a field value respecting optional per-field encoding overrides.

        - If *field_encodings* is provided and *key* is in it, the corresponding
          encoding is used (``None`` means keep raw bytes).
        - Otherwise falls back to :func:`str_if_bytes`.

    deprecated_args(args_to_warn: Optional[List[str]] = None, allowed_args: Optional[List[str]] = None, reason: str = '', version: str = '') -> collections.abc.Callable[[~C], ~C]
        Decorator to mark specified args of a function as deprecated.
        If '*' is in args_to_warn, all arguments will be marked as deprecated.

    deprecated_function(reason='', version='', name=None)
        Decorator to mark a function as deprecated.

    dict_merge(*dicts: Mapping[str, Any]) -> Dict[str, Any]
        Merge all provided dicts into 1 dict.
        *dicts : `dict`
            dictionaries to merge

    dummy_fail()
        Fake function for a Retry object if you don't need to handle each failure.

    async dummy_fail_async()
        Async fake function for a Retry object if you don't need to handle each failure.

    ensure_string(key)

    experimental(cls)
        Decorator to mark a class as experimental.

    experimental_args(args_to_warn: Optional[List[str]] = None) -> collections.abc.Callable[[~C], ~C]
        Decorator to mark specified args of a function as experimental.
        If '*' is in args_to_warn, all arguments will be marked as experimental.

    experimental_method() -> collections.abc.Callable[[~C], ~C]
        Decorator to mark a function as experimental.

    extract_expire_flags(ex: Union[int, datetime.timedelta, NoneType] = None, px: Union[int, datetime.timedelta, NoneType] = None, exat: Union[int, datetime.datetime, NoneType] = None, pxat: Union[int, datetime.datetime, NoneType] = None) -> List[Union[bytes, bytearray, memoryview, str, int, float]]

    format_error_message(host_error: str, exception: BaseException) -> str

    from_url(url: str, **kwargs: Any) -> 'Redis'
        Returns an active Redis client generated from the given database URL.

        Will attempt to extract the database id from the path url fragment, if
        none is provided.

    get_lib_version()

    list_keys_to_dict(key_list, callback)

    merge_result(command, res)
        Merge all items in `res` into a list.

        This command is used when sending a command to multiple nodes
        and the result from each node should be merged into a single list.

        res : 'dict'

    pipeline(redis_obj)

    safe_str(value)

    str_if_bytes(value: Union[str, bytes]) -> str

    truncate_text(txt, max_length=100)

    warn_deprecated(name, reason='', version='', stacklevel=2)

    warn_deprecated_arg_usage(arg_name: Union[list, str], function_name: str, reason: str = '', version: str = '', stacklevel: int = 2)

    warn_experimental(name, stacklevel=2)

    warn_experimental_arg_usage(arg_name: Union[list, str], function_name: str, stacklevel: int = 2)

DATA
    AbsExpiryT = typing.Union[int, datetime.datetime]
    C = ~C
    CRYPTOGRAPHY_AVAILABLE = True
    DEFAULT_RESP_VERSION = 3
    Dict = typing.Dict
        A generic version of dict.

    EncodableT = typing.Union[bytes, bytearray, memoryview, str, int, floa...
    ExpiryT = typing.Union[int, datetime.timedelta]
    HIREDIS_AVAILABLE = False
    List = typing.List
        A generic version of list.

    Mapping = typing.Mapping
        A generic version of collections.abc.Mapping.

    Optional = typing.Optional
        Optional[X] is equivalent to Union[X, None].

    SENTINEL = <object object>
    SSL_AVAILABLE = True
    TYPE_CHECKING = False
    Union = typing.Union
        Union type; Union[X, Y] means either X or Y.

        On Python 3.10 and higher, the | operator
        can also be used to denote unions;
        X | Y means the same thing to the type checker as Union[X, Y].

        To define a union, use e.g. Union[int, str]. Details:
        - The arguments must be types and there must be at least one.
        - None as an argument is a special case and is replaced by
          type(None).
        - Unions of unions are flattened, e.g.::

            assert Union[Union[int, str], float] == Union[int, str, float]

        - Unions of a single argument vanish, e.g.::

            assert Union[int] == int  # The constructor actually returns int

        - Redundant arguments are skipped, e.g.::

            assert Union[int, str, int] == Union[int, str]

        - When comparing unions, the argument order is ignored, e.g.::

            assert Union[int, str] == Union[str, int]

        - You cannot subclass or instantiate a union.
        - You can use Optional[X] as a shorthand for Union[X, None].

FILE
    c:\users\youse\appdata\local\programs\python\python312\lib\site-packages\redis\utils.py