valkey-glide 1.3.4rc6__cp310-cp310-macosx_11_0_arm64.whl → 2.0.0rc2__cp310-cp310-macosx_11_0_arm64.whl

glide/async_commands/core.py

@@ -19,7 +19,6 @@ from typing import (
 from glide.async_commands.bitmap import (
     BitFieldGet,
     BitFieldSubCommands,
-    BitmapIndexType,
     BitwiseOperation,
     OffsetOptions,
     _create_bitfield_args,
@@ -71,12 +70,13 @@ from ..glide import ClusterScanCursor
 class ConditionalChange(Enum):
     """
     A condition to the `SET`, `ZADD` and `GEOADD` commands.
-    - ONLY_IF_EXISTS - Only update key / elements that already exist. Equivalent to `XX` in the Valkey API.
-    - ONLY_IF_DOES_NOT_EXIST - Only set key / add elements that does not already exist. Equivalent to `NX` in the Valkey API.
     """
 
     ONLY_IF_EXISTS = "XX"
+    """ Only update key / elements that already exist. Equivalent to `XX` in the Valkey API. """
+
     ONLY_IF_DOES_NOT_EXIST = "NX"
+    """ Only set key / add elements that does not already exist. Equivalent to `NX` in the Valkey API. """
 
 
 @dataclass
@@ -84,7 +84,9 @@ class OnlyIfEqual:
     """
     Change condition to the `SET` command,
     For additional conditonal options see ConditionalChange
+
     - comparison_value - value to compare to the current value of a key.
+
     If comparison_value is equal to the key, it will overwrite the value of key to the new provided value
     Equivalent to the IFEQ comparison-value in the Valkey API
     """
@@ -93,130 +95,164 @@ class OnlyIfEqual:
 
 
 class ExpiryType(Enum):
-    """SET option: The type of the expiry.
-    - SEC - Set the specified expire time, in seconds. Equivalent to `EX` in the Valkey API.
-    - MILLSEC - Set the specified expire time, in milliseconds. Equivalent to `PX` in the Valkey API.
-    - UNIX_SEC - Set the specified Unix time at which the key will expire, in seconds. Equivalent to `EXAT` in the Valkey API.
-    - UNIX_MILLSEC - Set the specified Unix time at which the key will expire, in milliseconds. Equivalent to `PXAT` in the
-        Valkey API.
-    - KEEP_TTL - Retain the time to live associated with the key. Equivalent to `KEEPTTL` in the Valkey API.
+    """
+    SET option: The type of the expiry.
+    """
+
+    SEC = 0, Union[int, timedelta]
+    """
+    Set the specified expire time, in seconds. Equivalent to `EX` in the Valkey API.
+    """
+
+    MILLSEC = 1, Union[int, timedelta]
+    """
+    Set the specified expire time, in milliseconds. Equivalent to `PX` in the Valkey API.
+    """
+
+    UNIX_SEC = 2, Union[int, datetime]
+    """
+    Set the specified Unix time at which the key will expire, in seconds. Equivalent to `EXAT` in the Valkey API.
     """
 
-    SEC = 0, Union[int, timedelta]  # Equivalent to `EX` in the Valkey API
-    MILLSEC = 1, Union[int, timedelta]  # Equivalent to `PX` in the Valkey API
-    UNIX_SEC = 2, Union[int, datetime]  # Equivalent to `EXAT` in the Valkey API
-    UNIX_MILLSEC = 3, Union[int, datetime]  # Equivalent to `PXAT` in the Valkey API
-    KEEP_TTL = 4, Type[None]  # Equivalent to `KEEPTTL` in the Valkey API
+    UNIX_MILLSEC = 3, Union[int, datetime]
+    """
+    Set the specified Unix time at which the key will expire, in milliseconds. Equivalent to `PXAT` in the Valkey API.
+    """
+
+    KEEP_TTL = 4, Type[None]
+    """
+    Retain the time to live associated with the key. Equivalent to `KEEPTTL` in the Valkey API.
+    """
 
 
 class ExpiryTypeGetEx(Enum):
-    """GetEx option: The type of the expiry.
-    - EX - Set the specified expire time, in seconds. Equivalent to `EX` in the Valkey API.
-    - PX - Set the specified expire time, in milliseconds. Equivalent to `PX` in the Valkey API.
-    - UNIX_SEC - Set the specified Unix time at which the key will expire, in seconds. Equivalent to `EXAT` in the Valkey API.
-    - UNIX_MILLSEC - Set the specified Unix time at which the key will expire, in milliseconds. Equivalent to `PXAT` in the
-        Valkey API.
-    - PERSIST - Remove the time to live associated with the key. Equivalent to `PERSIST` in the Valkey API.
     """
+    GetEx option: The type of the expiry.
+    """
+
+    SEC = 0, Union[int, timedelta]
+    """ Set the specified expire time, in seconds. Equivalent to `EX` in the Valkey API. """
 
-    SEC = 0, Union[int, timedelta]  # Equivalent to `EX` in the Valkey API
-    MILLSEC = 1, Union[int, timedelta]  # Equivalent to `PX` in the Valkey API
-    UNIX_SEC = 2, Union[int, datetime]  # Equivalent to `EXAT` in the Valkey API
-    UNIX_MILLSEC = 3, Union[int, datetime]  # Equivalent to `PXAT` in the Valkey API
-    PERSIST = 4, Type[None]  # Equivalent to `PERSIST` in the Valkey API
+    MILLSEC = 1, Union[int, timedelta]
+    """ Set the specified expire time, in milliseconds. Equivalent to `PX` in the Valkey API. """
+
+    UNIX_SEC = 2, Union[int, datetime]
+    """ Set the specified Unix time at which the key will expire, in seconds. Equivalent to `EXAT` in the Valkey API. """
+
+    UNIX_MILLSEC = 3, Union[int, datetime]
+    """ Set the specified Unix time at which the key will expire, in milliseconds. Equivalent to `PXAT` in the Valkey API. """
+
+    PERSIST = 4, Type[None]
+    """ Remove the time to live associated with the key. Equivalent to `PERSIST` in the Valkey API. """
 
 
 class InfoSection(Enum):
     """
     INFO option: a specific section of information:
 
-    -SERVER: General information about the server
-    -CLIENTS: Client connections section
-    -MEMORY: Memory consumption related information
-    -PERSISTENCE: RDB and AOF related information
-    -STATS: General statistics
-    -REPLICATION: Master/replica replication information
-    -CPU: CPU consumption statistics
-    -COMMANDSTATS: Valkey command statistics
-    -LATENCYSTATS: Valkey command latency percentile distribution statistics
-    -SENTINEL: Valkey Sentinel section (only applicable to Sentinel instances)
-    -CLUSTER: Valkey Cluster section
-    -MODULES: Modules section
-    -KEYSPACE: Database related statistics
-    -ERRORSTATS: Valkey error statistics
-    -ALL: Return all sections (excluding module generated ones)
-    -DEFAULT: Return only the default set of sections
-    -EVERYTHING: Includes all and modules
     When no parameter is provided, the default option is assumed.
     """
 
     SERVER = "server"
+    """ General information about the server """
+
     CLIENTS = "clients"
+    """ Client connections section """
+
     MEMORY = "memory"
+    """ Memory consumption related information """
+
     PERSISTENCE = "persistence"
+    """ RDB and AOF related information """
+
     STATS = "stats"
+    """ General statistics """
+
     REPLICATION = "replication"
+    """ Master/replica replication information """
+
     CPU = "cpu"
+    """ CPU consumption statistics """
+
     COMMAND_STATS = "commandstats"
+    """ Valkey command statistics """
+
     LATENCY_STATS = "latencystats"
+    """ Valkey command latency percentile distribution statistics """
+
     SENTINEL = "sentinel"
+    """ Valkey Sentinel section (only applicable to Sentinel instances) """
+
     CLUSTER = "cluster"
+    """ Valkey Cluster section """
+
     MODULES = "modules"
+    """ Modules section """
+
     KEYSPACE = "keyspace"
+    """ Database related statistics """
+
     ERROR_STATS = "errorstats"
+    """ Valkey error statistics """
+
     ALL = "all"
+    """ Return all sections (excluding module generated ones) """
+
     DEFAULT = "default"
+    """ Return only the default set of sections """
+
     EVERYTHING = "everything"
+    """ Includes all and modules """
 
 
 class ExpireOptions(Enum):
     """
     EXPIRE option: options for setting key expiry.
-
-    - HasNoExpiry: Set expiry only when the key has no expiry (Equivalent to "NX" in Valkey).
-    - HasExistingExpiry: Set expiry only when the key has an existing expiry (Equivalent to "XX" in Valkey).
-    - NewExpiryGreaterThanCurrent: Set expiry only when the new expiry is greater than the current one (Equivalent
-        to "GT" in Valkey).
-    - NewExpiryLessThanCurrent: Set expiry only when the new expiry is less than the current one (Equivalent to "LT" in Valkey).
     """
 
     HasNoExpiry = "NX"
+    """ Set expiry only when the key has no expiry (Equivalent to "NX" in Valkey). """
+
     HasExistingExpiry = "XX"
+    """ Set expiry only when the key has an existing expiry (Equivalent to "XX" in Valkey). """
+
     NewExpiryGreaterThanCurrent = "GT"
+    """
+    Set expiry only when the new expiry is greater than the current one (Equivalent to "GT" in Valkey).
+    """
+
     NewExpiryLessThanCurrent = "LT"
+    """
+    Set expiry only when the new expiry is less than the current one (Equivalent to "LT" in Valkey).
+    """
 
 
 class UpdateOptions(Enum):
     """
     Options for updating elements of a sorted set key.
-
-    - LESS_THAN: Only update existing elements if the new score is less than the current score.
-    - GREATER_THAN: Only update existing elements if the new score is greater than the current score.
     """
 
     LESS_THAN = "LT"
+    """ Only update existing elements if the new score is less than the current score. """
+
     GREATER_THAN = "GT"
+    """ Only update existing elements if the new score is greater than the current score. """
 
 
 class ExpirySet:
-    """SET option: Represents the expiry type and value to be executed with "SET" command."""
+    """
+    SET option: Represents the expiry type and value to be executed with "SET" command.
+
+    Attributes:
+        cmd_arg (str): The expiry type.
+        value (str): The value for the expiry type.
+    """
 
     def __init__(
         self,
         expiry_type: ExpiryType,
         value: Optional[Union[int, datetime, timedelta]],
     ) -> None:
-        """
-        Args:
-            - expiry_type (ExpiryType): The expiry type.
-            - value (Optional[Union[int, datetime, timedelta]]): The value of the expiration type. The type of expiration
-                determines the type of expiration value:
-                - SEC: Union[int, timedelta]
-                - MILLSEC: Union[int, timedelta]
-                - UNIX_SEC: Union[int, datetime]
-                - UNIX_MILLSEC: Union[int, datetime]
-                - KEEP_TTL: Type[None]
-        """
         self.set_expiry_type_and_value(expiry_type, value)
 
     def __eq__(self, other: "object") -> bool:
@@ -227,6 +263,18 @@ class ExpirySet:
     def set_expiry_type_and_value(
         self, expiry_type: ExpiryType, value: Optional[Union[int, datetime, timedelta]]
     ):
+        """
+        Args:
+            expiry_type (ExpiryType): The expiry type.
+            value (Optional[Union[int, datetime, timedelta]]): The value of the expiration type. The type of expiration
+                determines the type of expiration value:
+
+                    - SEC: Union[int, timedelta]
+                    - MILLSEC: Union[int, timedelta]
+                    - UNIX_SEC: Union[int, datetime]
+                    - UNIX_MILLSEC: Union[int, datetime]
+                    - KEEP_TTL: Type[None]
+        """
         if not isinstance(value, get_args(expiry_type.value[1])):
             raise ValueError(
                 f"The value of {expiry_type} should be of type {expiry_type.value[1]}"
@@ -257,24 +305,19 @@ class ExpirySet:
 
 
 class ExpiryGetEx:
-    """GetEx option: Represents the expiry type and value to be executed with "GetEx" command."""
+    """
+    GetEx option: Represents the expiry type and value to be executed with "GetEx" command.
+
+    Attributes:
+        cmd_arg (str): The expiry type.
+        value (str): The value for the expiry type.
+    """
 
     def __init__(
         self,
         expiry_type: ExpiryTypeGetEx,
         value: Optional[Union[int, datetime, timedelta]],
     ) -> None:
-        """
-        Args:
-            - expiry_type (ExpiryType): The expiry type.
-            - value (Optional[Union[int, datetime, timedelta]]): The value of the expiration type. The type of expiration
-                determines the type of expiration value:
-                - SEC: Union[int, timedelta]
-                - MILLSEC: Union[int, timedelta]
-                - UNIX_SEC: Union[int, datetime]
-                - UNIX_MILLSEC: Union[int, datetime]
-                - PERSIST: Type[None]
-        """
         self.set_expiry_type_and_value(expiry_type, value)
 
     def set_expiry_type_and_value(
@@ -282,6 +325,18 @@ class ExpiryGetEx:
         expiry_type: ExpiryTypeGetEx,
         value: Optional[Union[int, datetime, timedelta]],
     ):
+        """
+        Args:
+            expiry_type (ExpiryType): The expiry type.
+            value (Optional[Union[int, datetime, timedelta]]): The value of the expiration type. The type of expiration
+                determines the type of expiration value:
+
+                    - SEC: Union[int, timedelta]
+                    - MILLSEC: Union[int, timedelta]
+                    - UNIX_SEC: Union[int, datetime]
+                    - UNIX_MILLSEC: Union[int, datetime]
+                    - PERSIST: Type[None]
+        """
         if not isinstance(value, get_args(expiry_type.value[1])):
             raise ValueError(
                 f"The value of {expiry_type} should be of type {expiry_type.value[1]}"
@@ -322,7 +377,8 @@ class FlushMode(Enum):
 
     `FLUSHALL` command and `FUNCTION FLUSH` command.
 
-    See https://valkey.io/commands/flushall/ and https://valkey.io/commands/function-flush/ for details
+    See [FLUSHAL](https://valkey.io/commands/flushall/) and [FUNCTION-FLUSH](https://valkey.io/commands/function-flush/)
+    for details
 
     SYNC was introduced in version 6.2.0.
     """
@@ -334,17 +390,19 @@ class FlushMode(Enum):
 class FunctionRestorePolicy(Enum):
     """
     Options for the FUNCTION RESTORE command.
-
-    - APPEND: Appends the restored libraries to the existing libraries and aborts on collision. This is the
-        default policy.
-    - FLUSH: Deletes all existing libraries before restoring the payload.
-    - REPLACE: Appends the restored libraries to the existing libraries, replacing any existing ones in case
-        of name collisions. Note that this policy doesn't prevent function name collisions, only libraries.
     """
 
     APPEND = "APPEND"
+    """ Appends the restored libraries to the existing libraries and aborts on collision. This is the default policy. """
+
     FLUSH = "FLUSH"
+    """ Deletes all existing libraries before restoring the payload. """
+
     REPLACE = "REPLACE"
+    """
+    Appends the restored libraries to the existing libraries, replacing any existing ones in case
+    of name collisions. Note that this policy doesn't prevent function name collisions, only libraries.
+    """
 
 
 def _build_sort_args(
@@ -388,10 +446,15 @@ class CoreCommands(Protocol):
         route: Optional[Route] = ...,
     ) -> TResult: ...
 
-    async def _execute_transaction(
+    async def _execute_batch(
         self,
         commands: List[Tuple[RequestType.ValueType, List[TEncodable]]],
+        is_atomic: bool,
+        raise_on_error: bool,
+        retry_server_error: bool = False,
+        retry_connection_error: bool = False,
         route: Optional[Route] = None,
+        timeout: Optional[int] = None,
     ) -> List[TResult]: ...
 
     async def _execute_script(
@@ -421,8 +484,9 @@ class CoreCommands(Protocol):
         """
         Update the current connection password with a new password.
 
-        **Note:** This method updates the client's internal password configuration and does
-        not perform password rotation on the server side.
+        Note:
+            This method updates the client's internal password configuration and does
+            not perform password rotation on the server side.
 
         This method is useful in scenarios where the server password has changed or when
         utilizing short-lived passwords for enhanced security. It allows the client to
@@ -432,11 +496,11 @@ class CoreCommands(Protocol):
 
         Args:
             password (`Optional[str]`): The new password to use for the connection,
-            if `None` the password will be removed.
+                if `None` the password will be removed.
             immediate_auth (`bool`):
-                - `True`: The client will authenticate immediately with the new password against all connections, Using `AUTH` command.
-                          If password supplied is an empty string, auth will not be performed and warning will be returned.
-                          The default is `False`.
+                `True`: The client will authenticate immediately with the new password against all connections, Using `AUTH`
+                command. If password supplied is an empty string, auth will not be performed and warning will be returned.
+                The default is `False`.
 
         Returns:
             TOK: A simple OK response. If `immediate_auth=True` returns OK if the reauthenticate succeed.
@@ -459,7 +523,8 @@ class CoreCommands(Protocol):
     ) -> Optional[bytes]:
         """
         Set the given key with the given value. Return value is dependent on the passed options.
-        See https://valkey.io/commands/set/ for more details.
+
+        See [valkey.io](https://valkey.io/commands/set/) for more details.
 
         Args:
             key (TEncodable): the key to store.
@@ -473,27 +538,34 @@ class CoreCommands(Protocol):
                 Equivalent to `GET` in the Valkey API. Defaults to False.
 
         Returns:
-            Optional[bytes]:
-                If the value is successfully set, return OK.
-                If value isn't set because of only_if_exists or only_if_does_not_exist conditions, return None.
-                If return_old_value is set, return the old value as a bytes string.
+            Optional[bytes]: If the value is successfully set, return OK.
+
+            If value isn't set because of `only_if_exists` or `only_if_does_not_exist` conditions, return `None`.
+
+            If return_old_value is set, return the old value as a bytes string.
 
         Example:
             >>> await client.set(b"key", b"value")
                 'OK'
-
                 # ONLY_IF_EXISTS -> Only set the key if it already exists
                 # expiry -> Set the amount of time until key expires
-            >>> await client.set("key", "new_value",conditional_set=ConditionalChange.ONLY_IF_EXISTS, expiry=ExpirySet(ExpiryType.SEC, 5))
+            >>> await client.set(
+            ...     "key",
+            ...     "new_value",
+            ...     conditional_set=ConditionalChange.ONLY_IF_EXISTS,
+            ...     expiry=ExpirySet(ExpiryType.SEC, 5)
+            ... )
                 'OK' # Set "new_value" to "key" only if "key" already exists, and set the key expiration to 5 seconds.
-
                 # ONLY_IF_DOES_NOT_EXIST -> Only set key if it does not already exist
-            >>> await client.set("key", "value", conditional_set=ConditionalChange.ONLY_IF_DOES_NOT_EXIST,return_old_value=True)
+            >>> await client.set(
+            ...     "key",
+            ...     "value",
+            ...     conditional_set=ConditionalChange.ONLY_IF_DOES_NOT_EXIST,
+            ...     return_old_value=True
+            ... )
                 b'new_value' # Returns the old value of "key".
             >>> await client.get("key")
                 b'new_value' # Value wasn't modified back to being "value" because of "NX" flag.
-
-
                 # ONLY_IF_EQUAL -> Only set key if provided value is equal to current value of the key
             >>> await client.set("key", "value")
                 'OK' # Reset "key" to "value"
@@ -522,13 +594,16 @@ class CoreCommands(Protocol):
     async def get(self, key: TEncodable) -> Optional[bytes]:
         """
         Get the value associated with the given key, or null if no such value exists.
-        See https://valkey.io/commands/get/ for details.
+
+        See [valkey.io](https://valkey.io/commands/get/) for details.
 
         Args:
             key (TEncodable): The key to retrieve from the database.
 
         Returns:
-            Optional[bytes]: If the key exists, returns the value of the key as a byte string. Otherwise, return None.
+            Optional[bytes]: If the key exists, returns the value of the key as a byte string.
+
+            Otherwise, return None.
 
         Example:
             >>> await client.get("key")
@@ -541,13 +616,15 @@ class CoreCommands(Protocol):
         """
         Gets a value associated with the given string `key` and deletes the key.
 
-        See https://valkey.io/commands/getdel for more details.
+        See [valkey.io](https://valkey.io/commands/getdel) for more details.
 
         Args:
             key (TEncodable): The `key` to retrieve from the database.
 
         Returns:
-            Optional[bytes]: If `key` exists, returns the `value` of `key`. Otherwise, returns `None`.
+            Optional[bytes]: If `key` exists, returns the `value` of `key`.
+
+            Otherwise, returns `None`.
 
         Examples:
             >>> await client.set("key", "value")
@@ -569,7 +646,7 @@ class CoreCommands(Protocol):
         If `key` does not exist, an empty byte string is returned. If `start` or `end`
         are out of range, returns the substring within the valid range of the value.
 
-        See https://valkey.io/commands/getrange/ for more details.
+        See [valkey.io](https://valkey.io/commands/getrange/) for more details.
 
         Args:
             key (TEncodable): The key of the string.
@@ -600,9 +677,11 @@ class CoreCommands(Protocol):
     async def append(self, key: TEncodable, value: TEncodable) -> int:
         """
         Appends a value to a key.
-        If `key` does not exist it is created and set as an empty string, so `APPEND` will be similar to `SET` in this special case.
 
-        See https://valkey.io/commands/append for more details.
+        If `key` does not exist it is created and set as an empty string, so `APPEND` will be similar to `SET` in this special
+        case.
+
+        See [valkey.io](https://valkey.io/commands/append) for more details.
 
         Args:
             key (TEncodable): The key to which the value will be appended.
@@ -613,9 +692,11 @@ class CoreCommands(Protocol):
 
         Examples:
             >>> await client.append("key", "Hello")
-                5  # Indicates that "Hello" has been appended to the value of "key", which was initially empty, resulting in a new value of "Hello" with a length of 5 - similar to the set operation.
+                5  # Indicates that "Hello" has been appended to the value of "key", which was initially empty, resulting in a
+                   # new value of "Hello" with a length of 5 - similar to the set operation.
             >>> await client.append("key", " world")
-                11  # Indicates that " world" has been appended to the value of "key", resulting in a new value of "Hello world" with a length of 11.
+                11  # Indicates that " world" has been appended to the value of "key", resulting in a new value of
+                    # "Hello world" with a length of 11.
             >>> await client.get("key")
                 b"Hello world"  # Returns the value stored in "key", which is now "Hello world".
         """
@@ -624,14 +705,16 @@ class CoreCommands(Protocol):
     async def strlen(self, key: TEncodable) -> int:
         """
         Get the length of the string value stored at `key`.
-        See https://valkey.io/commands/strlen/ for more details.
+
+        See [valkey.io](https://valkey.io/commands/strlen/) for more details.
 
         Args:
             key (TEncodable): The key to return its length.
 
         Returns:
             int: The length of the string value stored at `key`.
-                If `key` does not exist, it is treated as an empty string and 0 is returned.
+
+            If `key` does not exist, it is treated as an empty string and 0 is returned.
 
         Examples:
             >>> await client.set("key", "GLIDE")
@@ -645,17 +728,20 @@ class CoreCommands(Protocol):
         """
         Renames `key` to `new_key`.
         If `newkey` already exists it is overwritten.
-        See https://valkey.io/commands/rename/ for more details.
+
+        See [valkey.io](https://valkey.io/commands/rename/) for more details.
 
         Note:
             When in cluster mode, both `key` and `newkey` must map to the same hash slot.
 
         Args:
-            key (TEncodable) : The key to rename.
-            new_key (TEncodable) : The new name of the key.
+            key (TEncodable): The key to rename.
+            new_key (TEncodable): The new name of the key.
 
         Returns:
-            OK: If the `key` was successfully renamed, return "OK". If `key` does not exist, an error is thrown.
+            OK: If the `key` was successfully renamed, return "OK".
+
+            If `key` does not exist, an error is thrown.
         """
         return cast(
             TOK, await self._execute_command(RequestType.Rename, [key, new_key])
@@ -665,7 +751,7 @@ class CoreCommands(Protocol):
         """
         Renames `key` to `new_key` if `new_key` does not yet exist.
 
-        See https://valkey.io/commands/renamenx for more details.
+        See [valkey.io](https://valkey.io/commands/renamenx) for more details.
 
         Note:
             When in cluster mode, both `key` and `new_key` must map to the same hash slot.
@@ -675,7 +761,9 @@ class CoreCommands(Protocol):
             new_key (TEncodable): The new key name.
 
         Returns:
-            bool: True if `key` was renamed to `new_key`, or False if `new_key` already exists.
+            bool: True if `key` was renamed to `new_key`,
+
+            False if `new_key` already exists.
 
         Examples:
             >>> await client.renamenx("old_key", "new_key")
@@ -689,7 +777,8 @@ class CoreCommands(Protocol):
     async def delete(self, keys: List[TEncodable]) -> int:
         """
         Delete one or more keys from the database. A key is ignored if it does not exist.
-        See https://valkey.io/commands/del/ for details.
+
+        See [valkey.io](https://valkey.io/commands/del/) for details.
 
         Note:
             In cluster mode, if keys in `keys` map to different hash slots,
@@ -719,10 +808,11 @@ class CoreCommands(Protocol):
         """
         Increments the number stored at `key` by one. If the key does not exist, it is set to 0 before performing the
         operation.
-        See https://valkey.io/commands/incr/ for more details.
+
+        See [valkey.io](https://valkey.io/commands/incr/) for more details.
 
         Args:
-          key (TEncodable): The key to increment its value.
+            key (TEncodable): The key to increment its value.
 
         Returns:
             int: The value of `key` after the increment.
@@ -737,11 +827,13 @@ class CoreCommands(Protocol):
     async def incrby(self, key: TEncodable, amount: int) -> int:
         """
         Increments the number stored at `key` by `amount`. If the key does not exist, it is set to 0 before performing
-        the operation. See https://valkey.io/commands/incrby/ for more details.
+        the operation.
+
+        See [valkey.io](https://valkey.io/commands/incrby/) for more details.
 
         Args:
-          key (TEncodable): The key to increment its value.
-          amount (int) : The amount to increment.
+            key (TEncodable): The key to increment its value.
+            amount (int) : The amount to increment.
 
         Returns:
             int: The value of key after the increment.
@@ -760,11 +852,12 @@ class CoreCommands(Protocol):
         Increment the string representing a floating point number stored at `key` by `amount`.
         By using a negative increment value, the value stored at the `key` is decremented.
         If the key does not exist, it is set to 0 before performing the operation.
-        See https://valkey.io/commands/incrbyfloat/ for more details.
+
+        See [valkey.io](https://valkey.io/commands/incrbyfloat/) for more details.
 
         Args:
-          key (TEncodable): The key to increment its value.
-          amount (float) : The amount to increment.
+            key (TEncodable): The key to increment its value.
+            amount (float) : The amount to increment.
 
         Returns:
             float: The value of key after the increment.
@@ -787,7 +880,7 @@ class CoreCommands(Protocol):
         the string is padded with zero bytes to make `offset` fit. Creates the `key`
         if it doesn't exist.
 
-        See https://valkey.io/commands/setrange for more details.
+        See [valkey.io](https://valkey.io/commands/setrange) for more details.
 
         Args:
             key (TEncodable): The key of the string to update.
@@ -812,7 +905,8 @@ class CoreCommands(Protocol):
     async def mset(self, key_value_map: Mapping[TEncodable, TEncodable]) -> TOK:
         """
         Set multiple keys to multiple values in a single atomic operation.
-        See https://valkey.io/commands/mset/ for more details.
+
+        See [valkey.io](https://valkey.io/commands/mset/) for more details.
 
         Note:
             In cluster mode, if keys in `key_value_map` map to different hash slots,
@@ -846,10 +940,11 @@ class CoreCommands(Protocol):
         Note:
             When in cluster mode, all keys in `key_value_map` must map to the same hash slot.
 
-        See https://valkey.io/commands/msetnx/ for more details.
+        See [valkey.io](https://valkey.io/commands/msetnx/) for more details.
 
         Args:
-            key_value_map (Mapping[TEncodable, TEncodable]): A key-value map consisting of keys and their respective values to set.
+            key_value_map (Mapping[TEncodable, TEncodable]): A key-value map consisting of keys and their respective values to
+                set.
 
         Returns:
             bool: True if all keys were set. False if no key was set.
@@ -871,7 +966,8 @@ class CoreCommands(Protocol):
     async def mget(self, keys: List[TEncodable]) -> List[Optional[bytes]]:
         """
         Retrieve the values of multiple keys.
-        See https://valkey.io/commands/mget/ for more details.
+
+        See [valkey.io](https://valkey.io/commands/mget/) for more details.
 
         Note:
             In cluster mode, if keys in `keys` map to different hash slots,
@@ -881,6 +977,7 @@ class CoreCommands(Protocol):
             though some requests may have succeeded while others did not.
             If this behavior impacts your application logic, consider splitting the
             request into sub-requests per slot to ensure atomicity.
+
         Args:
             keys (List[TEncodable]): A list of keys to retrieve values for.
 
@@ -902,10 +999,11 @@ class CoreCommands(Protocol):
         """
         Decrement the number stored at `key` by one. If the key does not exist, it is set to 0 before performing the
         operation.
-        See https://valkey.io/commands/decr/ for more details.
+
+        See [valkey.io](https://valkey.io/commands/decr/) for more details.
 
         Args:
-          key (TEncodable): The key to increment its value.
+            key (TEncodable): The key to increment its value.
 
         Returns:
             int: The value of key after the decrement.
@@ -921,11 +1019,12 @@ class CoreCommands(Protocol):
         """
         Decrements the number stored at `key` by `amount`. If the key does not exist, it is set to 0 before performing
         the operation.
-        See https://valkey.io/commands/decrby/ for more details.
+
+        See [valkey.io](https://valkey.io/commands/decrby/) for more details.
 
         Args:
-          key (TEncodable): The key to decrement its value.
-          amount (int) : The amount to decrement.
+            key (TEncodable): The key to decrement its value.
+            amount (int) : The amount to decrement.
 
         Returns:
             int: The value of key after the decrement.
@@ -943,7 +1042,7 @@ class CoreCommands(Protocol):
         """
         Updates the last access time of specified keys.
 
-        See https://valkey.io/commands/touch/ for details.
+        See [valkey.io](https://valkey.io/commands/touch/) for details.
 
         Note:
             In cluster mode, if keys in `key_value_map` map to different hash slots,
@@ -952,8 +1051,7 @@ class CoreCommands(Protocol):
             requests fail, the entire call will return the first encountered error, even
             though some requests may have succeeded while others did not.
             If this behavior impacts your application logic, consider splitting the
-            request into sub-requests per slot to ensure atomicity.        Args:
-            keys (List[TEncodable]): The list of keys to unlink.
+            request into sub-requests per slot to ensure atomicity.
 
         Args:
             keys (List[TEncodable]): The keys to update last access time.
@@ -976,12 +1074,13 @@ class CoreCommands(Protocol):
     ) -> int:
         """
         Sets the specified fields to their respective values in the hash stored at `key`.
-        See https://valkey.io/commands/hset/ for more details.
+
+        See [valkey.io](https://valkey.io/commands/hset/) for more details.
 
         Args:
             key (TEncodable): The key of the hash.
-            field_value_map (Mapping[TEncodable, TEncodable]): A field-value map consisting of fields and their corresponding values
-            to be set in the hash stored at the specified key.
+            field_value_map (Mapping[TEncodable, TEncodable]): A field-value map consisting of fields and their corresponding
+                values to be set in the hash stored at the specified key.
 
         Returns:
             int: The number of fields that were added to the hash.
@@ -1001,7 +1100,8 @@ class CoreCommands(Protocol):
     async def hget(self, key: TEncodable, field: TEncodable) -> Optional[bytes]:
         """
         Retrieves the value associated with `field` in the hash stored at `key`.
-        See https://valkey.io/commands/hget/ for more details.
+
+        See [valkey.io](https://valkey.io/commands/hget/) for more details.
 
         Args:
             key (TEncodable): The key of the hash.
@@ -1009,6 +1109,7 @@ class CoreCommands(Protocol):
 
         Returns:
             Optional[bytes]: The value associated `field` in the hash.
+
             Returns None if `field` is not presented in the hash or `key` does not exist.
 
         Examples:
@@ -1033,7 +1134,8 @@ class CoreCommands(Protocol):
         Sets `field` in the hash stored at `key` to `value`, only if `field` does not yet exist.
         If `key` does not exist, a new key holding a hash is created.
         If `field` already exists, this operation has no effect.
-        See https://valkey.io/commands/hsetnx/ for more details.
+
+        See [valkey.io](https://valkey.io/commands/hsetnx/) for more details.
 
         Args:
             key (TEncodable): The key of the hash.
@@ -1041,7 +1143,9 @@ class CoreCommands(Protocol):
             value (TEncodable): The value to set.
 
         Returns:
-            bool: True if the field was set, False if the field already existed and was not set.
+            bool: True if the field was set.
+
+            False if the field already existed and was not set.
 
         Examples:
             >>> await client.hsetnx("my_hash", "field", "value")
@@ -1059,7 +1163,8 @@ class CoreCommands(Protocol):
         Increment or decrement the value of a `field` in the hash stored at `key` by the specified amount.
         By using a negative increment value, the value stored at `field` in the hash stored at `key` is decremented.
         If `field` or `key` does not exist, it is set to 0 before performing the operation.
-        See https://valkey.io/commands/hincrby/ for more details.
+
+        See [valkey.io](https://valkey.io/commands/hincrby/) for more details.
 
         Args:
             key (TEncodable): The key of the hash.
@@ -1087,7 +1192,8 @@ class CoreCommands(Protocol):
         amount.
         By using a negative increment value, the value stored at `field` in the hash stored at `key` is decremented.
         If `field` or `key` does not exist, it is set to 0 before performing the operation.
-        See https://valkey.io/commands/hincrbyfloat/ for more details.
+
+        See [valkey.io](https://valkey.io/commands/hincrbyfloat/) for more details.
 
         Args:
             key (TEncodable): The key of the hash.
@@ -1112,15 +1218,17 @@ class CoreCommands(Protocol):
     async def hexists(self, key: TEncodable, field: TEncodable) -> bool:
         """
         Check if a field exists in the hash stored at `key`.
-        See https://valkey.io/commands/hexists/ for more details.
+
+        See [valkey.io](https://valkey.io/commands/hexists/) for more details.
 
         Args:
             key (TEncodable): The key of the hash.
             field (TEncodable): The field to check in the hash stored at `key`.
 
         Returns:
-            bool: Returns 'True' if the hash contains the specified field. If the hash does not contain the field,
-                or if the key does not exist, it returns 'False'.
+            bool: `True` if the hash contains the specified field.
+
+            `False` if the hash does not contain the field, or if the key does not exist.
 
         Examples:
             >>> await client.hexists("my_hash", "field1")
@@ -1135,14 +1243,16 @@ class CoreCommands(Protocol):
     async def hgetall(self, key: TEncodable) -> Dict[bytes, bytes]:
         """
         Returns all fields and values of the hash stored at `key`.
-        See https://valkey.io/commands/hgetall/ for details.
+
+        See [valkey.io](https://valkey.io/commands/hgetall/) for details.
 
         Args:
             key (TEncodable): The key of the hash.
 
         Returns:
-            Dict[bytes, bytes]: A dictionary of fields and their values stored in the hash. Every field name in the list is followed by
-            its value.
+            Dict[bytes, bytes]: A dictionary of fields and their values stored in the hash. Every field name in the list is
+            followed by its value.
+
             If `key` does not exist, it returns an empty dictionary.
 
         Examples:
@@ -1158,7 +1268,8 @@ class CoreCommands(Protocol):
     ) -> List[Optional[bytes]]:
         """
         Retrieve the values associated with specified fields in the hash stored at `key`.
-        See https://valkey.io/commands/hmget/ for details.
+
+        See [valkey.io](https://valkey.io/commands/hmget/) for details.
 
         Args:
             key (TEncodable): The key of the hash.
@@ -1167,6 +1278,7 @@ class CoreCommands(Protocol):
         Returns:
             List[Optional[bytes]]: A list of values associated with the given fields, in the same order as they are requested.
             For every field that does not exist in the hash, a null value is returned.
+
             If `key` does not exist, it is treated as an empty hash, and the function returns a list of null values.
 
         Examples:
@@ -1181,7 +1293,8 @@ class CoreCommands(Protocol):
     async def hdel(self, key: TEncodable, fields: List[TEncodable]) -> int:
         """
         Remove specified fields from the hash stored at `key`.
-        See https://valkey.io/commands/hdel/ for more details.
+
+        See [valkey.io](https://valkey.io/commands/hdel/) for more details.
 
         Args:
             key (TEncodable): The key of the hash.
@@ -1189,6 +1302,7 @@ class CoreCommands(Protocol):
 
         Returns:
             int: The number of fields that were removed from the hash, excluding specified but non-existing fields.
+
             If `key` does not exist, it is treated as an empty hash, and the function returns 0.
 
         Examples:
@@ -1201,13 +1315,14 @@ class CoreCommands(Protocol):
         """
         Returns the number of fields contained in the hash stored at `key`.
 
-        See https://valkey.io/commands/hlen/ for more details.
+        See [valkey.io](https://valkey.io/commands/hlen/) for more details.
 
         Args:
             key (TEncodable): The key of the hash.
 
         Returns:
             int: The number of fields in the hash, or 0 when the key does not exist.
+
             If `key` holds a value that is not a hash, an error is returned.
 
         Examples:
@@ -1222,7 +1337,7 @@ class CoreCommands(Protocol):
         """
         Returns all values in the hash stored at `key`.
 
-        See https://valkey.io/commands/hvals/ for more details.
+        See [valkey.io](https://valkey.io/commands/hvals/) for more details.
 
         Args:
             key (TEncodable): The key of the hash.
@@ -1240,7 +1355,7 @@ class CoreCommands(Protocol):
         """
         Returns all field names in the hash stored at `key`.
 
-        See https://valkey.io/commands/hkeys/ for more details.
+        See [valkey.io](https://valkey.io/commands/hkeys/) for more details.
 
         Args:
             key (TEncodable): The key of the hash.
@@ -1258,13 +1373,14 @@ class CoreCommands(Protocol):
         """
         Returns a random field name from the hash value stored at `key`.
 
-        See https://valkey.io/commands/hrandfield for more details.
+        See [valkey.io](https://valkey.io/commands/hrandfield) for more details.
 
         Args:
             key (TEncodable): The key of the hash.
 
         Returns:
             Optional[bytes]: A random field name from the hash stored at `key`.
+
             If the hash does not exist or is empty, None will be returned.
 
         Examples:
@@ -1279,16 +1395,18 @@ class CoreCommands(Protocol):
         """
         Retrieves up to `count` random field names from the hash value stored at `key`.
 
-        See https://valkey.io/commands/hrandfield for more details.
+        See [valkey.io](https://valkey.io/commands/hrandfield) for more details.
 
         Args:
             key (TEncodable): The key of the hash.
             count (int): The number of field names to return.
-                If `count` is positive, returns unique elements.
-                If `count` is negative, allows for duplicates elements.
+
+                - If `count` is positive, returns unique elements.
+                - If `count` is negative, allows for duplicates elements.
 
         Returns:
             List[bytes]: A list of random field names from the hash.
+
             If the hash does not exist or is empty, the response will be an empty list.
 
         Examples:
@@ -1308,17 +1426,19 @@ class CoreCommands(Protocol):
         """
         Retrieves up to `count` random field names along with their values from the hash value stored at `key`.
 
-        See https://valkey.io/commands/hrandfield for more details.
+        See [valkey.io](https://valkey.io/commands/hrandfield) for more details.
 
         Args:
             key (TEncodable): The key of the hash.
             count (int): The number of field names to return.
-                If `count` is positive, returns unique elements.
-                If `count` is negative, allows for duplicates elements.
+
+                - If `count` is positive, returns unique elements.
+                - If `count` is negative, allows for duplicates elements.
 
         Returns:
             List[List[bytes]]: A list of `[field_name, value]` lists, where `field_name` is a random field name from the
             hash and `value` is the associated value of the field name.
+
             If the hash does not exist or is empty, the response will be an empty list.
 
         Examples:
@@ -1336,14 +1456,16 @@ class CoreCommands(Protocol):
         """
         Returns the string length of the value associated with `field` in the hash stored at `key`.
 
-        See https://valkey.io/commands/hstrlen/ for more details.
+        See [valkey.io](https://valkey.io/commands/hstrlen/) for more details.
 
         Args:
             key (TEncodable): The key of the hash.
             field (TEncodable): The field in the hash.
 
         Returns:
-            int: The string length or 0 if `field` or `key` does not exist.
+            int: The string length
+
+            0 if `field` or `key` does not exist.
 
         Examples:
             >>> await client.hset("my_hash", "field", "value")
@@ -1360,7 +1482,8 @@ class CoreCommands(Protocol):
         Insert all the specified values at the head of the list stored at `key`.
         `elements` are inserted one after the other to the head of the list, from the leftmost element
         to the rightmost element. If `key` does not exist, it is created as empty list before performing the push operations.
-        See https://valkey.io/commands/lpush/ for more details.
+
+        See [valkey.io](https://valkey.io/commands/lpush/) for more details.
 
         Args:
             key (TEncodable): The key of the list.
@@ -1384,7 +1507,7 @@ class CoreCommands(Protocol):
         Inserts all the specified values at the head of the list stored at `key`, only if `key` exists and holds a list.
         If `key` is not a list, this performs no operation.
 
-        See https://valkey.io/commands/lpushx/ for more details.
+        See [valkey.io](https://valkey.io/commands/lpushx/) for more details.
 
         Args:
             key (TEncodable): The key of the list.
@@ -1407,13 +1530,15 @@ class CoreCommands(Protocol):
         """
         Remove and return the first elements of the list stored at `key`.
         The command pops a single element from the beginning of the list.
-        See https://valkey.io/commands/lpop/ for details.
+
+        See [valkey.io](https://valkey.io/commands/lpop/) for details.
 
         Args:
             key (TEncodable): The key of the list.
 
         Returns:
             Optional[bytes]: The value of the first element.
+
             If `key` does not exist, None will be returned.
 
         Examples:
@@ -1430,7 +1555,8 @@ class CoreCommands(Protocol):
     async def lpop_count(self, key: TEncodable, count: int) -> Optional[List[bytes]]:
         """
         Remove and return up to `count` elements from the list stored at `key`, depending on the list's length.
-        See https://valkey.io/commands/lpop/ for details.
+
+        See [valkey.io](https://valkey.io/commands/lpop/) for details.
 
         Args:
             key (TEncodable): The key of the list.
@@ -1438,6 +1564,7 @@ class CoreCommands(Protocol):
 
         Returns:
             Optional[List[bytes]]: A a list of popped elements will be returned depending on the list's length.
+
             If `key` does not exist, None will be returned.
 
         Examples:
@@ -1457,19 +1584,25 @@ class CoreCommands(Protocol):
         """
         Pops an element from the head of the first list that is non-empty, with the given keys being checked in the
         order that they are given. Blocks the connection when there are no elements to pop from any of the given lists.
-        See https://valkey.io/commands/blpop for details.
 
-        Notes:
+        See [valkey.io](https://valkey.io/commands/blpop) for details.
+
+        Note:
             1. When in cluster mode, all `keys` must map to the same hash slot.
-            2. `BLPOP` is a client blocking command, see https://github.com/valkey-io/valkey-glide/wiki/General-Concepts#blocking-commands for more details and best practices.
+            2. `BLPOP` is a client blocking command, see
+               [blocking commands](https://github.com/valkey-io/valkey-glide/wiki/General-Concepts#blocking-commands)
+               for more details and best practices.
 
         Args:
             keys (List[TEncodable]): The keys of the lists to pop from.
-            timeout (float): The number of seconds to wait for a blocking operation to complete. A value of 0 will block indefinitely.
+            timeout (float): The number of seconds to wait for a blocking operation to complete.
+                A value of 0 will block indefinitely.
 
         Returns:
             Optional[List[bytes]]: A two-element list containing the key from which the element was popped and the value of the
-                popped element, formatted as `[key, value]`. If no element could be popped and the `timeout` expired, returns None.
+            popped element, formatted as `[key, value]`.
+
+            If no element could be popped and the `timeout` expired, returns None.
 
         Examples:
             >>> await client.blpop(["list1", "list2"], 0.5)
@@ -1491,15 +1624,19 @@ class CoreCommands(Protocol):
 
         When in cluster mode, all `keys` must map to the same hash slot.
 
-        See https://valkey.io/commands/lmpop/ for details.
+        See [valkey.io](https://valkey.io/commands/lmpop/) for details.
 
         Args:
             keys (List[TEncodable]): An array of keys of lists.
-            direction (ListDirection): The direction based on which elements are popped from (`ListDirection.LEFT` or `ListDirection.RIGHT`).
-            count (Optional[int]): The maximum number of popped elements. If not provided, defaults to popping a single element.
+            direction (ListDirection): The direction based on which elements are popped from
+                (`ListDirection.LEFT` or `ListDirection.RIGHT`).
+            count (Optional[int]): The maximum number of popped elements. If not provided, defaults to popping a
+                single element.
 
         Returns:
-            Optional[Mapping[bytes, List[bytes]]]: A map of `key` name mapped to an array of popped elements, or None if no elements could be popped.
+            Optional[Mapping[bytes, List[bytes]]]: A `map` of `key` name mapped to an array of popped elements,
+
+            `None` if no elements could be popped.
 
         Examples:
             >>> await client.lpush("testKey", ["one", "two", "three"])
@@ -1529,20 +1666,27 @@ class CoreCommands(Protocol):
 
         `BLMPOP` is the blocking variant of `LMPOP`.
 
-        Notes:
+        Note:
             1. When in cluster mode, all `keys` must map to the same hash slot.
-            2. `BLMPOP` is a client blocking command, see https://github.com/valkey-io/valkey-glide/wiki/General-Concepts#blocking-commands for more details and best practices.
+            2. `BLMPOP` is a client blocking command, see
+               [blocking commands](https://github.com/valkey-io/valkey-glide/wiki/General-Concepts#blocking-commands)
+               for more details and best practices.
 
-        See https://valkey.io/commands/blmpop/ for details.
+        See [valkey.io](https://valkey.io/commands/blmpop/) for details.
 
         Args:
             keys (List[TEncodable]): An array of keys of lists.
-            direction (ListDirection): The direction based on which elements are popped from (`ListDirection.LEFT` or `ListDirection.RIGHT`).
-            timeout (float): The number of seconds to wait for a blocking operation to complete. A value of `0` will block indefinitely.
-            count (Optional[int]): The maximum number of popped elements. If not provided, defaults to popping a single element.
+            direction (ListDirection): The direction based on which elements are popped from
+                (`ListDirection.LEFT` or `ListDirection.RIGHT`).
+            timeout (float): The number of seconds to wait for a blocking operation to complete.
+                A value of `0` will block indefinitely.
+            count (Optional[int]): The maximum number of popped elements. If not provided, defaults to popping a single
+                element.
 
         Returns:
-            Optional[Mapping[bytes, List[bytes]]]: A map of `key` name mapped to an array of popped elements, or None if no elements could be popped and the timeout expired.
+            Optional[Mapping[bytes, List[bytes]]]: A `map` of `key` name mapped to an array of popped elements.
+
+            `None` if no elements could be popped and the timeout expired.
 
         Examples:
             >>> await client.lpush("testKey", ["one", "two", "three"])
@@ -1566,7 +1710,8 @@ class CoreCommands(Protocol):
         The offsets `start` and `end` are zero-based indexes, with 0 being the first element of the list, 1 being the next
         element and so on. These offsets can also be negative numbers indicating offsets starting at the end of the list,
         with -1 being the last element of the list, -2 being the penultimate, and so on.
-        See https://valkey.io/commands/lrange/ for details.
+
+        See [valkey.io](https://valkey.io/commands/lrange/) for details.
 
         Args:
             key (TEncodable): The key of the list.
@@ -1575,8 +1720,11 @@ class CoreCommands(Protocol):
 
         Returns:
             List[bytes]: A list of elements within the specified range.
+
             If `start` exceeds the `end` of the list, or if `start` is greater than `end`, an empty list will be returned.
+
             If `end` exceeds the actual end of the list, the range will stop at the actual end of the list.
+
             If `key` does not exist an empty list will be returned.
 
         Examples:
@@ -1606,7 +1754,7 @@ class CoreCommands(Protocol):
         Negative indices can be used to designate elements starting at the tail of the list.
         Here, -1 means the last element, -2 means the penultimate and so forth.
 
-        See https://valkey.io/commands/lindex/ for more details.
+        See [valkey.io](https://valkey.io/commands/lindex/) for more details.
 
         Args:
             key (TEncodable): The key of the list.
@@ -1614,7 +1762,8 @@ class CoreCommands(Protocol):
 
         Returns:
             Optional[bytes]: The element at `index` in the list stored at `key`.
-                If `index` is out of range or if `key` does not exist, None is returned.
+
+            If `index` is out of range or if `key` does not exist, None is returned.
 
         Examples:
             >>> await client.lindex("my_list", 0)
@@ -1635,7 +1784,7 @@ class CoreCommands(Protocol):
         Negative indices can be used to designate elements starting at the tail of the list.
         Here, `-1` means the last element, `-2` means the penultimate and so forth.
 
-        See https://valkey.io/commands/lset/ for details.
+        See [valkey.io](https://valkey.io/commands/lset/) for details.
 
         Args:
             key (TEncodable): The key of the list.
@@ -1659,7 +1808,8 @@ class CoreCommands(Protocol):
         Inserts all the specified values at the tail of the list stored at `key`.
         `elements` are inserted one after the other to the tail of the list, from the leftmost element
         to the rightmost element. If `key` does not exist, it is created as empty list before performing the push operations.
-        See https://valkey.io/commands/rpush/ for more details.
+
+        See [valkey.io](https://valkey.io/commands/rpush/) for more details.
 
         Args:
             key (TEncodable): The key of the list.
@@ -1683,7 +1833,7 @@ class CoreCommands(Protocol):
         Inserts all the specified values at the tail of the list stored at `key`, only if `key` exists and holds a list.
         If `key` is not a list, this performs no operation.
 
-        See https://valkey.io/commands/rpushx/ for more details.
+        See [valkey.io](https://valkey.io/commands/rpushx/) for more details.
 
         Args:
             key (TEncodable): The key of the list.
@@ -1706,13 +1856,15 @@ class CoreCommands(Protocol):
         """
         Removes and returns the last elements of the list stored at `key`.
         The command pops a single element from the end of the list.
-        See https://valkey.io/commands/rpop/ for details.
+
+        See [valkey.io](https://valkey.io/commands/rpop/) for details.
 
         Args:
             key (TEncodable): The key of the list.
 
         Returns:
             Optional[bytes]: The value of the last element.
+
             If `key` does not exist, None will be returned.
 
         Examples:
@@ -1729,7 +1881,8 @@ class CoreCommands(Protocol):
     async def rpop_count(self, key: TEncodable, count: int) -> Optional[List[bytes]]:
         """
         Removes and returns up to `count` elements from the list stored at `key`, depending on the list's length.
-        See https://valkey.io/commands/rpop/ for details.
+
+        See [valkey.io](https://valkey.io/commands/rpop/) for details.
 
         Args:
             key (TEncodable): The key of the list.
@@ -1737,6 +1890,7 @@ class CoreCommands(Protocol):
 
         Returns:
             Optional[List[bytes]: A list of popped elements will be returned depending on the list's length.
+
             If `key` does not exist, None will be returned.
 
         Examples:
@@ -1756,19 +1910,25 @@ class CoreCommands(Protocol):
         """
         Pops an element from the tail of the first list that is non-empty, with the given keys being checked in the
         order that they are given. Blocks the connection when there are no elements to pop from any of the given lists.
-        See https://valkey.io/commands/brpop for details.
+
+        See [valkey.io](https://valkey.io/commands/brpop) for details.
 
         Notes:
             1. When in cluster mode, all `keys` must map to the same hash slot.
-            2. `BRPOP` is a client blocking command, see https://github.com/valkey-io/valkey-glide/wiki/General-Concepts#blocking-commands for more details and best practices.
+            2. `BRPOP` is a client blocking command, see
+               [blocking commands](https://github.com/valkey-io/valkey-glide/wiki/General-Concepts#blocking-commands)
+               for more details and best practices.
 
         Args:
             keys (List[TEncodable]): The keys of the lists to pop from.
-            timeout (float): The number of seconds to wait for a blocking operation to complete. A value of 0 will block indefinitely.
+            timeout (float): The number of seconds to wait for a blocking operation to complete.
+                A value of 0 will block indefinitely.
 
         Returns:
             Optional[List[bytes]]: A two-element list containing the key from which the element was popped and the value of the
-                popped element, formatted as `[key, value]`. If no element could be popped and the `timeout` expired, returns None.
+            popped element, formatted as `[key, value]`.
+
+            If no element could be popped and the `timeout` expired, returns None.
 
         Examples:
             >>> await client.brpop(["list1", "list2"], 0.5)
@@ -1789,7 +1949,7 @@ class CoreCommands(Protocol):
         """
         Inserts `element` in the list at `key` either before or after the `pivot`.
 
-        See https://valkey.io/commands/linsert/ for details.
+        See [valkey.io](https://valkey.io/commands/linsert/) for details.
 
         Args:
             key (TEncodable): The key of the list.
@@ -1800,8 +1960,10 @@ class CoreCommands(Protocol):
 
         Returns:
             int: The list length after a successful insert operation.
-                If the `key` doesn't exist returns `-1`.
-                If the `pivot` wasn't found, returns `0`.
+
+            If the `key` doesn't exist returns `-1`.
+
+            If the `pivot` wasn't found, returns `0`.
 
         Examples:
             >>> await client.linsert("my_list", InsertPosition.BEFORE, "World", "There")
@@ -1828,16 +1990,20 @@ class CoreCommands(Protocol):
 
         When in cluster mode, both `source` and `destination` must map to the same hash slot.
 
-        See https://valkey.io/commands/lmove/ for details.
+        See [valkey.io](https://valkey.io/commands/lmove/) for details.
 
         Args:
             source (TEncodable): The key to the source list.
             destination (TEncodable): The key to the destination list.
-            where_from (ListDirection): The direction to remove the element from (`ListDirection.LEFT` or `ListDirection.RIGHT`).
-            where_to (ListDirection): The direction to add the element to (`ListDirection.LEFT` or `ListDirection.RIGHT`).
+            where_from (ListDirection): The direction to remove the element from
+                (`ListDirection.LEFT` or `ListDirection.RIGHT`).
+            where_to (ListDirection): The direction to add the element to
+                (`ListDirection.LEFT` or `ListDirection.RIGHT`).
 
         Returns:
-            Optional[bytes]: The popped element, or None if `source` does not exist.
+            Optional[bytes]: The popped element.
+
+            `None` if `source` does not exist.
 
         Examples:
             >>> client.lpush("testKey1", ["two", "one"])
@@ -1875,19 +2041,26 @@ class CoreCommands(Protocol):
 
         Notes:
             1. When in cluster mode, both `source` and `destination` must map to the same hash slot.
-            2. `BLMOVE` is a client blocking command, see https://github.com/valkey-io/valkey-glide/wiki/General-Concepts#blocking-commands for more details and best practices.
+            2. `BLMOVE` is a client blocking command, see
+               [blocking commands](https://github.com/valkey-io/valkey-glide/wiki/General-Concepts#blocking-commands)
+               for more details and best practices.
 
-        See https://valkey.io/commands/blmove/ for details.
+        See [valkey.io](https://valkey.io/commands/blmove/) for details.
 
         Args:
             source (TEncodable): The key to the source list.
             destination (TEncodable): The key to the destination list.
-            where_from (ListDirection): The direction to remove the element from (`ListDirection.LEFT` or `ListDirection.RIGHT`).
-            where_to (ListDirection): The direction to add the element to (`ListDirection.LEFT` or `ListDirection.RIGHT`).
-            timeout (float): The number of seconds to wait for a blocking operation to complete. A value of `0` will block indefinitely.
+            where_from (ListDirection): The direction to remove the element from
+                (`ListDirection.LEFT` or `ListDirection.RIGHT`).
+            where_to (ListDirection): The direction to add the element to
+                (`ListDirection.LEFT` or `ListDirection.RIGHT`).
+            timeout (float): The number of seconds to wait for a blocking operation to complete.
+                A value of `0` will block indefinitely.
 
         Returns:
-            Optional[bytes]: The popped element, or None if `source` does not exist or if the operation timed-out.
+            Optional[bytes]: The popped element.
+
+            `None` if `source` does not exist or if the operation timed-out.
 
         Examples:
             >>> await client.lpush("testKey1", ["two", "one"])
@@ -1914,7 +2087,8 @@ class CoreCommands(Protocol):
         Add specified members to the set stored at `key`.
         Specified members that are already a member of this set are ignored.
         If `key` does not exist, a new set is created before adding `members`.
-        See https://valkey.io/commands/sadd/ for more details.
+
+        See [valkey.io](https://valkey.io/commands/sadd/) for more details.
 
         Args:
             key (TEncodable): The key where members will be added to its set.
@@ -1933,7 +2107,8 @@ class CoreCommands(Protocol):
         """
         Remove specified members from the set stored at `key`.
         Specified members that are not a member of this set are ignored.
-        See https://valkey.io/commands/srem/ for details.
+
+        See [valkey.io](https://valkey.io/commands/srem/) for details.
 
         Args:
             key (TEncodable): The key from which members will be removed.
@@ -1941,7 +2116,8 @@ class CoreCommands(Protocol):
 
         Returns:
             int: The number of members that were removed from the set, excluding non-existing members.
-                If `key` does not exist, it is treated as an empty set and this command returns 0.
+
+            If `key` does not exist, it is treated as an empty set and this command returns 0.
 
         Examples:
             >>> await client.srem("my_set", ["member1", "member2"])
@@ -1952,14 +2128,16 @@ class CoreCommands(Protocol):
     async def smembers(self, key: TEncodable) -> Set[bytes]:
         """
         Retrieve all the members of the set value stored at `key`.
-        See https://valkey.io/commands/smembers/ for details.
+
+        See [valkey.io](https://valkey.io/commands/smembers/) for details.
 
         Args:
             key (TEncodable): The key from which to retrieve the set members.
 
         Returns:
             Set[bytes]: A set of all members of the set.
-                If `key` does not exist an empty set will be returned.
+
+            If `key` does not exist an empty set will be returned.
 
         Examples:
             >>> await client.smembers("my_set")
@@ -1972,13 +2150,16 @@ class CoreCommands(Protocol):
     async def scard(self, key: TEncodable) -> int:
         """
         Retrieve the set cardinality (number of elements) of the set stored at `key`.
-        See https://valkey.io/commands/scard/ for details.
+
+        See [valkey.io](https://valkey.io/commands/scard/) for details.
 
         Args:
             key (TEncodable): The key from which to retrieve the number of set members.
 
         Returns:
-            int: The cardinality (number of elements) of the set, or 0 if the key does not exist.
+            int: The cardinality (number of elements) of the set.
+
+            0 if the key does not exist.
 
         Examples:
             >>> await client.scard("my_set")
@@ -1990,7 +2171,8 @@ class CoreCommands(Protocol):
         """
         Removes and returns one random member from the set stored at `key`.
 
-        See https://valkey-io.github.io/commands/spop/ for more details.
+        See [valkey.io](https://valkey-io.github.io/commands/spop/) for more details.
+
         To pop multiple members, see `spop_count`.
 
         Args:
@@ -1998,6 +2180,7 @@ class CoreCommands(Protocol):
 
         Returns:
             Optional[bytes]: The value of the popped member.
+
             If `key` does not exist, None will be returned.
 
         Examples:
@@ -2014,7 +2197,8 @@ class CoreCommands(Protocol):
         """
         Removes and returns up to `count` random members from the set stored at `key`, depending on the set's length.
 
-        See https://valkey-io.github.io/commands/spop/ for more details.
+        See [valkey.io](https://valkey-io.github.io/commands/spop/) for more details.
+
         To pop a single member, see `spop`.
 
         Args:
@@ -2023,7 +2207,8 @@ class CoreCommands(Protocol):
 
         Returns:
             Set[bytes]: A set of popped elements will be returned depending on the set's length.
-                If `key` does not exist, an empty set will be returned.
+
+            If `key` does not exist, an empty set will be returned.
 
         Examples:
             >>> await client.spop_count("my_set", 2)
@@ -2043,7 +2228,7 @@ class CoreCommands(Protocol):
         """
         Returns if `member` is a member of the set stored at `key`.
 
-        See https://valkey.io/commands/sismember/ for more details.
+        See [valkey.io](https://valkey.io/commands/sismember/) for more details.
 
         Args:
             key (TEncodable): The key of the set.
@@ -2051,6 +2236,7 @@ class CoreCommands(Protocol):
 
         Returns:
             bool: True if the member exists in the set, False otherwise.
+
             If `key` doesn't exist, it is treated as an empty set and the command returns False.
 
         Examples:
@@ -2074,7 +2260,7 @@ class CoreCommands(Protocol):
         Moves `member` from the set at `source` to the set at `destination`, removing it from the source set. Creates a
         new destination set if needed. The operation is atomic.
 
-        See https://valkey.io/commands/smove for more details.
+        See [valkey.io](https://valkey.io/commands/smove) for more details.
 
         Note:
             When in cluster mode, `source` and `destination` must map to the same hash slot.
@@ -2085,7 +2271,9 @@ class CoreCommands(Protocol):
             member (TEncodable): The set element to move.
 
         Returns:
-            bool: True on success, or False if the `source` set does not exist or the element is not a member of the source set.
+            bool: `True` on success.
+
+            `False` if the `source` set does not exist or the element is not a member of the source set.
 
         Examples:
             >>> await client.smove("set1", "set2", "member1")
@@ -2102,7 +2290,7 @@ class CoreCommands(Protocol):
         """
         Gets the union of all the given sets.
 
-        See https://valkey.io/commands/sunion for more details.
+        See [valkey.io](https://valkey.io/commands/sunion) for more details.
 
         Note:
             When in cluster mode, all `keys` must map to the same hash slot.
@@ -2112,7 +2300,8 @@ class CoreCommands(Protocol):
 
         Returns:
             Set[bytes]: A set of members which are present in at least one of the given sets.
-                If none of the sets exist, an empty set will be returned.
+
+            If none of the sets exist, an empty set will be returned.
 
         Examples:
             >>> await client.sadd("my_set1", ["member1", "member2"])
@@ -2132,7 +2321,7 @@ class CoreCommands(Protocol):
         """
         Stores the members of the union of all given sets specified by `keys` into a new set at `destination`.
 
-        See https://valkey.io/commands/sunionstore for more details.
+        See [valkey.io](https://valkey.io/commands/sunionstore) for more details.
 
         Note:
             When in cluster mode, all keys in `keys` and `destination` must map to the same hash slot.
@@ -2160,7 +2349,7 @@ class CoreCommands(Protocol):
         Stores the difference between the first set and all the successive sets in `keys` into a new set at
         `destination`.
 
-        See https://valkey.io/commands/sdiffstore for more details.
+        See [valkey.io](https://valkey.io/commands/sdiffstore) for more details.
 
         Note:
             When in Cluster mode, all keys in `keys` and `destination` must map to the same hash slot.
@@ -2187,7 +2376,7 @@ class CoreCommands(Protocol):
         """
         Gets the intersection of all the given sets.
 
-        See https://valkey.io/commands/sinter for more details.
+        See [valkey.io](https://valkey.io/commands/sinter) for more details.
 
         Note:
             When in cluster mode, all `keys` must map to the same hash slot.
@@ -2197,7 +2386,8 @@ class CoreCommands(Protocol):
 
         Returns:
             Set[bytes]: A set of members which are present in all given sets.
-                If one or more sets do no exist, an empty set will be returned.
+
+            If one or more sets do no exist, an empty set will be returned.
 
         Examples:
             >>> await client.sadd("my_set1", ["member1", "member2"])
@@ -2213,7 +2403,7 @@ class CoreCommands(Protocol):
         """
         Stores the members of the intersection of all given sets specified by `keys` into a new set at `destination`.
 
-        See https://valkey.io/commands/sinterstore for more details.
+        See [valkey.io](https://valkey.io/commands/sinterstore) for more details.
 
         Note:
             When in Cluster mode, all `keys` and `destination` must map to the same hash slot.
@@ -2241,11 +2431,12 @@ class CoreCommands(Protocol):
     ) -> int:
         """
         Gets the cardinality of the intersection of all the given sets.
-        Optionally, a `limit` can be specified to stop the computation early if the intersection cardinality reaches the specified limit.
+        Optionally, a `limit` can be specified to stop the computation early if the intersection cardinality reaches the
+        specified limit.
 
         When in cluster mode, all keys in `keys` must map to the same hash slot.
 
-        See https://valkey.io/commands/sintercard for more details.
+        See [valkey.io](https://valkey.io/commands/sintercard) for more details.
 
         Args:
             keys (List[TEncodable]): A list of keys representing the sets to intersect.
@@ -2277,7 +2468,7 @@ class CoreCommands(Protocol):
         """
         Computes the difference between the first set and all the successive sets in `keys`.
 
-        See https://valkey.io/commands/sdiff for more details.
+        See [valkey.io](https://valkey.io/commands/sdiff) for more details.
 
         Note:
             When in cluster mode, all `keys` must map to the same hash slot.
@@ -2287,7 +2478,8 @@ class CoreCommands(Protocol):
 
         Returns:
             Set[bytes]: A set of elements representing the difference between the sets.
-                If any of the keys in `keys` do not exist, they are treated as empty sets.
+
+            If any of the keys in `keys` do not exist, they are treated as empty sets.
 
         Examples:
             >>> await client.sadd("set1", ["member1", "member2"])
@@ -2306,7 +2498,7 @@ class CoreCommands(Protocol):
         """
         Checks whether each member is contained in the members of the set stored at `key`.
 
-        See https://valkey.io/commands/smismember for more details.
+        See [valkey.io](https://valkey.io/commands/smismember) for more details.
 
         Args:
             key (TEncodable): The key of the set to check.
@@ -2332,7 +2524,8 @@ class CoreCommands(Protocol):
         element and so on.
         These offsets can also be negative numbers indicating offsets starting at the end of the list, with -1 being the last
         element of the list, -2 being the penultimate, and so on.
-        See https://valkey.io/commands/ltrim/ for more details.
+
+        See [valkey.io](https://valkey.io/commands/ltrim/) for more details.
 
         Args:
             key (TEncodable): The key of the list.
@@ -2341,10 +2534,13 @@ class CoreCommands(Protocol):
 
         Returns:
             TOK: A simple "OK" response.
-                If `start` exceeds the end of the list, or if `start` is greater than `end`, the result will be an empty list
-                (which causes `key` to be removed).
-                If `end` exceeds the actual end of the list, it will be treated like the last element of the list.
-                If `key` does not exist, "OK" will be returned without changes to the database.
+
+            If `start` exceeds the end of the list, or if `start` is greater than `end`, the result will be an empty list
+            (which causes `key` to be removed).
+
+            If `end` exceeds the actual end of the list, it will be treated like the last element of the list.
+
+            If `key` does not exist, "OK" will be returned without changes to the database.
 
         Examples:
             >>> await client.ltrim("my_list", 0, 1)
@@ -2362,7 +2558,8 @@ class CoreCommands(Protocol):
         If `count` is negative, it removes elements equal to `element` moving from tail to head.
         If `count` is 0 or greater than the occurrences of elements equal to `element`, it removes all elements
         equal to `element`.
-        See https://valkey.io/commands/lrem/ for more details.
+
+        See [valkey.io](https://valkey.io/commands/lrem/) for more details.
 
         Args:
             key (TEncodable): The key of the list.
@@ -2371,7 +2568,8 @@ class CoreCommands(Protocol):
 
         Returns:
             int: The number of removed elements.
-                If `key` does not exist, 0 is returned.
+
+            If `key` does not exist, 0 is returned.
 
         Examples:
             >>> await client.lrem("my_list", 2, "value")
@@ -2385,14 +2583,16 @@ class CoreCommands(Protocol):
     async def llen(self, key: TEncodable) -> int:
         """
         Get the length of the list stored at `key`.
-        See https://valkey.io/commands/llen/ for details.
+
+        See [valkey.io](https://valkey.io/commands/llen/) for details.
 
         Args:
             key (TEncodable): The key of the list.
 
         Returns:
             int: The length of the list at the specified key.
-                If `key` does not exist, it is interpreted as an empty list and 0 is returned.
+
+            If `key` does not exist, it is interpreted as an empty list and 0 is returned.
 
         Examples:
             >>> await client.llen("my_list")
@@ -2403,7 +2603,8 @@ class CoreCommands(Protocol):
     async def exists(self, keys: List[TEncodable]) -> int:
         """
         Returns the number of keys in `keys` that exist in the database.
-        See https://valkey.io/commands/exists/ for more details.
+
+        See [valkey.io](https://valkey.io/commands/exists/) for more details.
 
         Note:
             In cluster mode, if keys in `keys` map to different hash slots,
@@ -2419,7 +2620,7 @@ class CoreCommands(Protocol):
 
         Returns:
             int: The number of keys that exist. If the same existing key is mentioned in `keys` multiple times,
-                it will be counted multiple times.
+            it will be counted multiple times.
 
         Examples:
             >>> await client.exists(["key1", "key2", "key3"])
@@ -2433,7 +2634,8 @@ class CoreCommands(Protocol):
         A key is ignored if it does not exist.
         This command, similar to DEL, removes specified keys and ignores non-existent ones.
         However, this command does not block the server, while [DEL](https://valkey.io/commands/del) does.
-        See https://valkey.io/commands/unlink/ for more details.
+
+        See [valkey.io](https://valkey.io/commands/unlink/) for more details.
 
         Note:
             In cluster mode, if keys in `key_value_map` map to different hash slots,
@@ -2467,7 +2669,8 @@ class CoreCommands(Protocol):
         If `key` already has an existing expire set, the time to live is updated to the new value.
         If `seconds` is a non-positive number, the key will be deleted rather than expired.
         The timeout will only be cleared by commands that delete or overwrite the contents of `key`.
-        See https://valkey.io/commands/expire/ for more details.
+
+        See [valkey.io](https://valkey.io/commands/expire/) for more details.
 
         Args:
             key (TEncodable): The key to set a timeout on.
@@ -2475,8 +2678,10 @@ class CoreCommands(Protocol):
             option (ExpireOptions, optional): The expire option.
 
         Returns:
-            bool: 'True' if the timeout was set, 'False' if the timeout was not set (e.g., the key doesn't exist or the operation is
-                skipped due to the provided arguments).
+            bool: `True` if the timeout was set.
+
+            `False` if the timeout was not set (e.g., the key doesn't exist or the
+            operation is skipped due to the provided arguments).
 
         Examples:
             >>> await client.expire("my_key", 60)
@@ -2500,7 +2705,8 @@ class CoreCommands(Protocol):
         deleted.
         If `key` already has an existing expire set, the time to live is updated to the new value.
         The timeout will only be cleared by commands that delete or overwrite the contents of `key`.
-        See https://valkey.io/commands/expireat/ for more details.
+
+        See [valkey.io](https://valkey.io/commands/expireat/) for more details.
 
         Args:
             key (TEncodable): The key to set a timeout on.
@@ -2508,8 +2714,10 @@ class CoreCommands(Protocol):
             option (Optional[ExpireOptions]): The expire option.
 
         Returns:
-            bool: 'True' if the timeout was set, 'False' if the timeout was not set (e.g., the key doesn't exist or the operation is
-                skipped due to the provided arguments).
+            bool: `True` if the timeout was set.
+
+            `False` if the timeout was not set (e.g., the key doesn't exist or the
+            operation is skipped due to the provided arguments).
 
         Examples:
             >>> await client.expireAt("my_key", 1672531200, ExpireOptions.HasNoExpiry)
@@ -2533,7 +2741,8 @@ class CoreCommands(Protocol):
         If `key` already has an existing expire set, the time to live is updated to the new value.
         If `milliseconds` is a non-positive number, the key will be deleted rather than expired.
         The timeout will only be cleared by commands that delete or overwrite the contents of `key`.
-        See https://valkey.io/commands/pexpire/ for more details.
+
+        See [valkey.io](https://valkey.io/commands/pexpire/) for more details.
 
         Args:
             key (TEncodable): The key to set a timeout on.
@@ -2541,8 +2750,10 @@ class CoreCommands(Protocol):
             option (Optional[ExpireOptions]): The expire option.
 
         Returns:
-            bool: 'True' if the timeout was set, 'False' if the timeout was not set (e.g., the key doesn't exist or the operation is
-                skipped due to the provided arguments).
+            bool: `True` if the timeout was set
+
+            `False` if the timeout was not set (e.g., the key doesn't exist or the
+            operation is skipped due to the provided arguments).
 
         Examples:
             >>> await client.pexpire("my_key", 60000, ExpireOptions.HasNoExpiry)
@@ -2568,7 +2779,8 @@ class CoreCommands(Protocol):
         deleted.
         If `key` already has an existing expire set, the time to live is updated to the new value.
         The timeout will only be cleared by commands that delete or overwrite the contents of `key`.
-        See https://valkey.io/commands/pexpireat/ for more details.
+
+        See [valkey.io](https://valkey.io/commands/pexpireat/) for more details.
 
         Args:
             key (TEncodable): The key to set a timeout on.
@@ -2576,8 +2788,10 @@ class CoreCommands(Protocol):
             option (Optional[ExpireOptions]): The expire option.
 
         Returns:
-            bool: 'True' if the timeout was set, 'False' if the timeout was not set (e.g., the key doesn't exist or the operation is
-                skipped due to the provided arguments).
+            bool: `True` if the timeout was set.
+
+            `False` if the timeout was not set (e.g., the key doesn't exist or the
+            operation is skipped due to the provided arguments).
 
         Examples:
             >>> await client.pexpireAt("my_key", 1672531200000, ExpireOptions.HasNoExpiry)
@@ -2596,13 +2810,17 @@ class CoreCommands(Protocol):
         the given `key` will expire, in seconds.
         To get the expiration with millisecond precision, use `pexpiretime`.
 
-        See https://valkey.io/commands/expiretime/ for details.
+        See [valkey.io](https://valkey.io/commands/expiretime/) for details.
 
         Args:
             key (TEncodable): The `key` to determine the expiration value of.
 
         Returns:
-            int: The expiration Unix timestamp in seconds, -2 if `key` does not exist or -1 if `key` exists but has no associated expire.
+            int: The expiration Unix timestamp in seconds.
+
+            -2 if `key` does not exist.
+
+            -1 if `key` exists but has no associated expire.
 
         Examples:
             >>> await client.expiretime("my_key")
@@ -2623,13 +2841,17 @@ class CoreCommands(Protocol):
         Returns the absolute Unix timestamp (since January 1, 1970) at which
         the given `key` will expire, in milliseconds.
 
-        See https://valkey.io/commands/pexpiretime/ for details.
+        See [valkey.io](https://valkey.io/commands/pexpiretime/) for details.
 
         Args:
             key (TEncodable): The `key` to determine the expiration value of.
 
         Returns:
-            int: The expiration Unix timestamp in milliseconds, -2 if `key` does not exist, or -1 if `key` exists but has no associated expiration.
+            int: The expiration Unix timestamp in milliseconds.
+
+            -2 if `key` does not exist.
+
+            -1 if `key` exists but has no associated expiration.
 
         Examples:
             >>> await client.pexpiretime("my_key")
@@ -2648,13 +2870,18 @@ class CoreCommands(Protocol):
     async def ttl(self, key: TEncodable) -> int:
         """
         Returns the remaining time to live of `key` that has a timeout.
-        See https://valkey.io/commands/ttl/ for more details.
+
+        See [valkey.io](https://valkey.io/commands/ttl/) for more details.
 
         Args:
             key (TEncodable): The key to return its timeout.
 
         Returns:
-            int: TTL in seconds, -2 if `key` does not exist or -1 if `key` exists but has no associated expire.
+            int: TTL in seconds.
+
+            -2 if `key` does not exist.
+
+            -1 if `key` exists but has no associated expire.
 
         Examples:
             >>> await client.ttl("my_key")
@@ -2672,13 +2899,18 @@ class CoreCommands(Protocol):
     ) -> int:
         """
         Returns the remaining time to live of `key` that has a timeout, in milliseconds.
-        See https://valkey.io/commands/pttl for more details.
+
+        See [valkey.io](https://valkey.io/commands/pttl) for more details.
 
         Args:
             key (TEncodable): The key to return its timeout.
 
         Returns:
-            int: TTL in milliseconds. -2 if `key` does not exist, -1 if `key` exists but has no associated expire.
+            int: TTL in milliseconds.
+
+            -2 if `key` does not exist.
+
+            -1 if `key` exists but has no associated expire.
 
         Examples:
             >>> await client.pttl("my_key")
@@ -2699,13 +2931,15 @@ class CoreCommands(Protocol):
         Remove the existing timeout on `key`, turning the key from volatile (a key with an expire set) to
         persistent (a key that will never expire as no timeout is associated).
 
-        See https://valkey.io/commands/persist/ for more details.
+        See [valkey.io](https://valkey.io/commands/persist/) for more details.
 
         Args:
             key (TEncodable): The key to remove the existing timeout on.
 
         Returns:
-            bool: False if `key` does not exist or does not have an associated timeout, True if the timeout has been removed.
+            bool: `False` if `key` does not exist or does not have an associated timeout.
+
+            `True` if the timeout has been removed.
 
         Examples:
             >>> await client.persist("my_key")
@@ -2720,13 +2954,14 @@ class CoreCommands(Protocol):
         """
         Returns the bytes string representation of the type of the value stored at `key`.
 
-        See https://valkey.io/commands/type/ for more details.
+        See [valkey.io](https://valkey.io/commands/type/) for more details.
 
         Args:
             key (TEncodable): The key to check its data type.
 
         Returns:
             bytes: If the key exists, the type of the stored value is returned.
+
             Otherwise, a b"none" bytes string is returned.
 
         Examples:
@@ -2748,20 +2983,28 @@ class CoreCommands(Protocol):
         """
         Adds an entry to the specified stream stored at `key`. If the `key` doesn't exist, the stream is created.
 
-        See https://valkey.io/commands/xadd for more details.
+        See [valkey.io](https://valkey.io/commands/xadd) for more details.
 
         Args:
             key (TEncodable): The key of the stream.
             values (List[Tuple[TEncodable, TEncodable]]): Field-value pairs to be added to the entry.
-            options (Optional[StreamAddOptions]): Additional options for adding entries to the stream. Default to None. See `StreamAddOptions`.
+            options (Optional[StreamAddOptions]): Additional options for adding entries to the stream. Default to None.
+                See `StreamAddOptions`.
 
         Returns:
-            bytes: The id of the added entry, or None if `options.make_stream` is set to False and no stream with the matching `key` exists.
+            bytes: The id of the added entry.
+
+            `None` if `options.make_stream` is set to False and no stream with the matching
+            `key` exists.
 
         Example:
             >>> await client.xadd("mystream", [("field", "value"), ("field2", "value2")])
                 b"1615957011958-0"  # Example stream entry ID.
-            >>> await client.xadd("non_existing_stream", [(field, "foo1"), (field2, "bar1")], StreamAddOptions(id="0-1", make_stream=False))
+            >>> await client.xadd(
+            ...     "non_existing_stream",
+            ...     [(field, "foo1"), (field2, "bar1")],
+            ...     StreamAddOptions(id="0-1", make_stream=False)
+            ... )
                 None  # The key doesn't exist, therefore, None is returned.
             >>> await client.xadd("non_existing_stream", [(field, "foo1"), (field2, "bar1")], StreamAddOptions(id="0-1"))
                 b"0-1"  # Returns the stream id.
@@ -2781,7 +3024,7 @@ class CoreCommands(Protocol):
         """
         Removes the specified entries by id from a stream, and returns the number of entries deleted.
 
-        See https://valkey.io/commands/xdel for more details.
+        See [valkey.io](https://valkey.io/commands/xdel) for more details.
 
         Args:
             key (TEncodable): The key of the stream.
@@ -2789,7 +3032,7 @@ class CoreCommands(Protocol):
 
         Returns:
             int: The number of entries removed from the stream. This number may be less than the number of entries in
-                `ids`, if the specified `ids` don't exist in the stream.
+            `ids`, if the specified `ids` don't exist in the stream.
 
         Examples:
             >>> await client.xdel("key", ["1538561698944-0", "1538561698944-1"])
@@ -2810,14 +3053,16 @@ class CoreCommands(Protocol):
         """
         Trims the stream stored at `key` by evicting older entries.
 
-        See https://valkey.io/commands/xtrim for more details.
+        See [valkey.io](https://valkey.io/commands/xtrim) for more details.
 
         Args:
             key (TEncodable): The key of the stream.
             options (StreamTrimOptions): Options detailing how to trim the stream. See `StreamTrimOptions`.
 
         Returns:
-            int: TThe number of entries deleted from the stream. If `key` doesn't exist, 0 is returned.
+            int: TThe number of entries deleted from the stream.
+
+            If `key` doesn't exist, 0 is returned.
 
         Example:
             >>> await client.xadd("mystream", [("field", "value"), ("field2", "value2")], StreamAddOptions(id="0-1"))
@@ -2834,13 +3079,15 @@ class CoreCommands(Protocol):
         """
         Returns the number of entries in the stream stored at `key`.
 
-        See https://valkey.io/commands/xlen for more details.
+        See [valkey.io](https://valkey.io/commands/xlen) for more details.
 
         Args:
             key (TEncodable): The key of the stream.
 
         Returns:
-            int: The number of entries in the stream. If `key` does not exist, returns 0.
+            int: The number of entries in the stream.
+
+            If `key` does not exist, returns 0.
 
         Examples:
             >>> await client.xadd("mystream", [("field", "value")])
@@ -2863,25 +3110,30 @@ class CoreCommands(Protocol):
         """
         Returns stream entries matching a given range of IDs.
 
-        See https://valkey.io/commands/xrange for more details.
+        See [valkey.io](https://valkey.io/commands/xrange) for more details.
 
         Args:
             key (TEncodable): The key of the stream.
             start (StreamRangeBound): The starting stream ID bound for the range.
+
                 - Use `IdBound` to specify a stream ID.
                 - Use `ExclusiveIdBound` to specify an exclusive bounded stream ID.
                 - Use `MinId` to start with the minimum available ID.
+
             end (StreamRangeBound): The ending stream ID bound for the range.
+
                 - Use `IdBound` to specify a stream ID.
                 - Use `ExclusiveIdBound` to specify an exclusive bounded stream ID.
                 - Use `MaxId` to end with the maximum available ID.
+
             count (Optional[int]): An optional argument specifying the maximum count of stream entries to return.
                 If `count` is not provided, all stream entries in the range will be returned.
 
         Returns:
             Optional[Mapping[bytes, List[List[bytes]]]]: A mapping of stream IDs to stream entry data, where entry data is a
-                list of pairings with format `[[field, entry], [field, entry], ...]`. Returns None if the range
-                arguments are not applicable.
+            list of pairings with format `[[field, entry], [field, entry], ...]`.
+
+            Returns None if the range arguments are not applicable.
 
         Examples:
             >>> await client.xadd("mystream", [("field1", "value1")], StreamAddOptions(id="0-1"))
@@ -2912,25 +3164,30 @@ class CoreCommands(Protocol):
         Returns stream entries matching a given range of IDs in reverse order. Equivalent to `XRANGE` but returns the
         entries in reverse order.
 
-        See https://valkey.io/commands/xrevrange for more details.
+        See [valkey.io](https://valkey.io/commands/xrevrange) for more details.
 
         Args:
             key (TEncodable): The key of the stream.
             end (StreamRangeBound): The ending stream ID bound for the range.
+
                 - Use `IdBound` to specify a stream ID.
                 - Use `ExclusiveIdBound` to specify an exclusive bounded stream ID.
                 - Use `MaxId` to end with the maximum available ID.
+
             start (StreamRangeBound): The starting stream ID bound for the range.
+
                 - Use `IdBound` to specify a stream ID.
                 - Use `ExclusiveIdBound` to specify an exclusive bounded stream ID.
                 - Use `MinId` to start with the minimum available ID.
+
             count (Optional[int]): An optional argument specifying the maximum count of stream entries to return.
                 If `count` is not provided, all stream entries in the range will be returned.
 
         Returns:
             Optional[Mapping[bytes, List[List[bytes]]]]: A mapping of stream IDs to stream entry data, where entry data is a
-                list of pairings with format `[[field, entry], [field, entry], ...]`. Returns None if the range
-                arguments are not applicable.
+            list of pairings with format `[[field, entry], [field, entry], ...]`.
+
+            Returns None if the range arguments are not applicable.
 
         Examples:
             >>> await client.xadd("mystream", [("field1", "value1")], StreamAddOptions(id="0-1"))
@@ -2958,7 +3215,7 @@ class CoreCommands(Protocol):
         """
         Reads entries from the given streams.
 
-        See https://valkey.io/commands/xread for more details.
+        See [valkey.io](https://valkey.io/commands/xread) for more details.
 
         Note:
             When in cluster mode, all keys in `keys_and_ids` must map to the same hash slot.
@@ -2969,9 +3226,12 @@ class CoreCommands(Protocol):
 
         Returns:
             Optional[Mapping[bytes, Mapping[bytes, List[List[bytes]]]]]: A mapping of stream keys, to a mapping of stream IDs,
-                to a list of pairings with format `[[field, entry], [field, entry], ...]`.
-                None will be returned under the following conditions:
-                - All key-ID pairs in `keys_and_ids` have either a non-existing key or a non-existing ID, or there are no entries after the given ID.
+            to a list of pairings with format `[[field, entry], [field, entry], ...]`.
+
+            None will be returned under the following conditions:
+
+                - All key-ID pairs in `keys_and_ids` have either a non-existing key or a non-existing ID, or there are no
+                  entries after the given ID.
                 - The `BLOCK` option is specified and the timeout is hit.
 
         Examples:
@@ -3007,7 +3267,7 @@ class CoreCommands(Protocol):
         """
         Creates a new consumer group uniquely identified by `group_name` for the stream stored at `key`.
 
-        See https://valkey.io/commands/xgroup-create for more details.
+        See [valkey.io](https://valkey.io/commands/xgroup-create) for more details.
 
         Args:
             key (TEncodable): The key of the stream.
@@ -3038,14 +3298,16 @@ class CoreCommands(Protocol):
         """
         Destroys the consumer group `group_name` for the stream stored at `key`.
 
-        See https://valkey.io/commands/xgroup-destroy for more details.
+        See [valkey.io](https://valkey.io/commands/xgroup-destroy) for more details.
 
         Args:
             key (TEncodable): The key of the stream.
             group_name (TEncodable): The consumer group name to delete.
 
         Returns:
-            bool: True if the consumer group was destroyed. Otherwise, returns False.
+            bool: True if the consumer group was destroyed.
+
+            Otherwise, returns False.
 
         Examples:
             >>> await client.xgroup_destroy("mystream", "mygroup")
@@ -3065,7 +3327,7 @@ class CoreCommands(Protocol):
         """
         Creates a consumer named `consumer_name` in the consumer group `group_name` for the stream stored at `key`.
 
-        See https://valkey.io/commands/xgroup-createconsumer for more details.
+        See [valkey.io](https://valkey.io/commands/xgroup-createconsumer) for more details.
 
         Args:
             key (TEncodable): The key of the stream.
@@ -3073,7 +3335,9 @@ class CoreCommands(Protocol):
             consumer_name (TEncodable): The newly created consumer.
 
         Returns:
-            bool: True if the consumer is created. Otherwise, returns False.
+            bool: True if the consumer is created.
+
+            Otherwise, returns False.
 
         Examples:
             >>> await client.xgroup_create_consumer("mystream", "mygroup", "myconsumer")
@@ -3095,7 +3359,7 @@ class CoreCommands(Protocol):
         """
         Deletes a consumer named `consumer_name` in the consumer group `group_name` for the stream stored at `key`.
 
-        See https://valkey.io/commands/xgroup-delconsumer for more details.
+        See [valkey.io](https://valkey.io/commands/xgroup-delconsumer) for more details.
 
         Args:
             key (TEncodable): The key of the stream.
@@ -3126,7 +3390,7 @@ class CoreCommands(Protocol):
         """
         Set the last delivered ID for a consumer group.
 
-        See https://valkey.io/commands/xgroup-setid for more details.
+        See [valkey.io](https://valkey.io/commands/xgroup-setid) for more details.
 
         Args:
             key (TEncodable): The key of the stream.
@@ -3161,7 +3425,7 @@ class CoreCommands(Protocol):
         """
         Reads entries from the given streams owned by a consumer group.
 
-        See https://valkey.io/commands/xreadgroup for more details.
+        See [valkey.io](https://valkey.io/commands/xreadgroup) for more details.
 
         Note:
             When in cluster mode, all keys in `keys_and_ids` must map to the same hash slot.
@@ -3175,8 +3439,9 @@ class CoreCommands(Protocol):
 
         Returns:
             Optional[Mapping[bytes, Mapping[bytes, Optional[List[List[bytes]]]]]]: A mapping of stream keys, to a mapping of
-                stream IDs, to a list of pairings with format `[[field, entry], [field, entry], ...]`.
-                Returns None if the BLOCK option is given and a timeout occurs, or if there is no stream that can be served.
+            stream IDs, to a list of pairings with format `[[field, entry], [field, entry], ...]`.
+
+            Returns None if the BLOCK option is given and a timeout occurs, or if there is no stream that can be served.
 
         Examples:
             >>> await client.xadd("mystream", [("field1", "value1")], StreamAddOptions(id="1-0"))
@@ -3212,7 +3477,7 @@ class CoreCommands(Protocol):
         This command should be called on pending messages so that such messages do not get processed again by the
         consumer group.
 
-        See https://valkey.io/commands/xack for more details.
+        See [valkey.io](https://valkey.io/commands/xack) for more details.
 
         Args:
             key (TEncodable): The key of the stream.
@@ -3249,7 +3514,7 @@ class CoreCommands(Protocol):
         """
         Returns stream message summary information for pending messages for the given consumer group.
 
-        See https://valkey.io/commands/xpending for more details.
+        See [valkey.io](https://valkey.io/commands/xpending) for more details.
 
         Args:
             key (TEncodable): The key of the stream.
@@ -3257,14 +3522,15 @@ class CoreCommands(Protocol):
 
         Returns:
             List[Union[int, bytes, List[List[bytes]], None]]: A list that includes the summary of pending messages, with the
-                format `[num_group_messages, start_id, end_id, [[consumer_name, num_consumer_messages]]]`, where:
+            format `[num_group_messages, start_id, end_id, [[consumer_name, num_consumer_messages]]]`, where:
+
                 - `num_group_messages`: The total number of pending messages for this consumer group.
                 - `start_id`: The smallest ID among the pending messages.
                 - `end_id`: The greatest ID among the pending messages.
                 - `[[consumer_name, num_consumer_messages]]`: A 2D list of every consumer in the consumer group with at
-                least one pending message, and the number of pending messages it has.
+                  least one pending message, and the number of pending messages it has.
 
-                If there are no pending messages for the given consumer group, `[0, None, None, None]` will be returned.
+            If there are no pending messages for the given consumer group, `[0, None, None, None]` will be returned.
 
         Examples:
             >>> await client.xpending("my_stream", "my_group")
@@ -3287,34 +3553,46 @@ class CoreCommands(Protocol):
         """
         Returns an extended form of stream message information for pending messages matching a given range of IDs.
 
-        See https://valkey.io/commands/xpending for more details.
+        See [valkey.io](https://valkey.io/commands/xpending) for more details.
 
         Args:
             key (TEncodable): The key of the stream.
             group_name (TEncodable): The consumer group name.
             start (StreamRangeBound): The starting stream ID bound for the range.
+
                 - Use `IdBound` to specify a stream ID.
                 - Use `ExclusiveIdBound` to specify an exclusive bounded stream ID.
                 - Use `MinId` to start with the minimum available ID.
+
             end (StreamRangeBound): The ending stream ID bound for the range.
+
                 - Use `IdBound` to specify a stream ID.
                 - Use `ExclusiveIdBound` to specify an exclusive bounded stream ID.
                 - Use `MaxId` to end with the maximum available ID.
+
             count (int): Limits the number of messages returned.
             options (Optional[StreamPendingOptions]): The stream pending options.
 
         Returns:
             List[List[Union[bytes, int]]]: A list of lists, where each inner list is a length 4 list containing extended
-                message information with the format `[[id, consumer_name, time_elapsed, num_delivered]]`, where:
+            message information with the format `[[id, consumer_name, time_elapsed, num_delivered]]`, where:
+
                 - `id`: The ID of the message.
                 - `consumer_name`: The name of the consumer that fetched the message and has still to acknowledge it. We
-                call it the current owner of the message.
+                  call it the current owner of the message.
                 - `time_elapsed`: The number of milliseconds that elapsed since the last time this message was delivered
-                to this consumer.
+                  to this consumer.
                 - `num_delivered`: The number of times this message was delivered.
 
         Examples:
-            >>> await client.xpending_range("my_stream", "my_group", MinId(), MaxId(), 10, StreamPendingOptions(consumer_name="my_consumer"))
+            >>> await client.xpending_range(
+            ...     "my_stream",
+            ...     "my_group",
+            ...     MinId(),
+            ...     MaxId(),
+            ...     10,
+            ...     StreamPendingOptions(consumer_name="my_consumer")
+            ... )
                 [[b"1-0", b"my_consumer", 1234, 1], [b"1-1", b"my_consumer", 1123, 1]]
                 # Extended stream entry information for the pending entries associated with "my_consumer".
         """
@@ -3336,7 +3614,7 @@ class CoreCommands(Protocol):
         """
         Changes the ownership of a pending message.
 
-        See https://valkey.io/commands/xclaim for more details.
+        See [valkey.io](https://valkey.io/commands/xclaim) for more details.
 
         Args:
             key (TEncodable): The key of the stream.
@@ -3347,11 +3625,15 @@ class CoreCommands(Protocol):
             options (Optional[StreamClaimOptions]): Stream claim options.
 
         Returns:
-            Mapping[bytes, List[List[bytes]]]: A Mapping of message entries with the format
-                {"entryId": [["entry", "data"], ...], ...} that are claimed by the consumer.
+            Mapping[bytes, List[List[bytes]]]: A Mapping of message entries with the format::
+
+                {"entryId": [["entry", "data"], ...], ...}
+
+            that are claimed by the consumer.
 
         Examples:
-            # read messages from streamId for consumer1
+            read messages from streamId for consumer1:
+
             >>> await client.xreadgroup({"mystream": ">"}, "mygroup", "consumer1")
                 {
                     b"mystream": {
@@ -3386,7 +3668,7 @@ class CoreCommands(Protocol):
         Changes the ownership of a pending message. This function returns a List with
         only the message/entry IDs, and is equivalent to using JUSTID in the Valkey API.
 
-        See https://valkey.io/commands/xclaim for more details.
+        See [valkey.io](https://valkey.io/commands/xclaim) for more details.
 
         Args:
             key (TEncodable): The key of the stream.
@@ -3400,7 +3682,8 @@ class CoreCommands(Protocol):
             List[bytes]: A List of message ids claimed by the consumer.
 
         Examples:
-            # read messages from streamId for consumer1
+            read messages from streamId for consumer1:
+
             >>> await client.xreadgroup({"mystream": ">"}, "mygroup", "consumer1")
                 {
                     b"mystream": {
@@ -3441,7 +3724,7 @@ class CoreCommands(Protocol):
         """
         Transfers ownership of pending stream entries that match the specified criteria.
 
-        See https://valkey.io/commands/xautoclaim for more details.
+        See [valkey.io](https://valkey.io/commands/xautoclaim) for more details.
 
         Args:
             key (TEncodable): The key of the stream.
@@ -3454,17 +3737,19 @@ class CoreCommands(Protocol):
 
         Returns:
             List[Union[bytes, Mapping[bytes, List[List[bytes]]], List[bytes]]]: A list containing the following elements:
+
                 - A stream ID to be used as the start argument for the next call to `XAUTOCLAIM`. This ID is equivalent
-                to the next ID in the stream after the entries that were scanned, or "0-0" if the entire stream was
-                scanned.
+                  to the next ID in the stream after the entries that were scanned, or "0-0" if the entire stream was
+                  scanned.
                 - A mapping of the claimed entries, with the keys being the claimed entry IDs and the values being a
-                2D list of the field-value pairs in the format `[[field1, value1], [field2, value2], ...]`.
+                  2D list of the field-value pairs in the format `[[field1, value1], [field2, value2], ...]`.
                 - If you are using Valkey 7.0.0 or above, the response list will also include a list containing the
-                message IDs that were in the Pending Entries List but no longer exist in the stream. These IDs are
-                deleted from the Pending Entries List.
+                  message IDs that were in the Pending Entries List but no longer exist in the stream. These IDs are
+                  deleted from the Pending Entries List.
 
         Examples:
-            # Valkey version < 7.0.0:
+            Valkey version < 7.0.0:
+
             >>> await client.xautoclaim("my_stream", "my_group", "my_consumer", 3_600_000, "0-0")
                 [
                     b"0-0",
@@ -3478,7 +3763,8 @@ class CoreCommands(Protocol):
                 # Stream entry "1-1" was idle for over an hour and was thus claimed by "my_consumer". The entire stream
                 # was scanned.
 
-            # Valkey version 7.0.0 and above:
+            Valkey version 7.0.0 and above:
+
             >>> await client.xautoclaim("my_stream", "my_group", "my_consumer", 3_600_000, "0-0")
                 [
                     b"0-0",
@@ -3525,7 +3811,7 @@ class CoreCommands(Protocol):
         argument to further specify that the return value should contain a list of claimed IDs without their
         field-value info.
 
-        See https://valkey.io/commands/xautoclaim for more details.
+        See [valkey.io](https://valkey.io/commands/xautoclaim) for more details.
 
         Args:
             key (TEncodable): The key of the stream.
@@ -3538,22 +3824,25 @@ class CoreCommands(Protocol):
 
         Returns:
             List[Union[bytes, List[bytes]]]: A list containing the following elements:
+
                 - A stream ID to be used as the start argument for the next call to `XAUTOCLAIM`. This ID is equivalent
-                to the next ID in the stream after the entries that were scanned, or "0-0" if the entire stream was
-                scanned.
+                  to the next ID in the stream after the entries that were scanned, or "0-0" if the entire stream was
+                  scanned.
                 - A list of the IDs for the claimed entries.
                 - If you are using Valkey 7.0.0 or above, the response list will also include a list containing the
-                message IDs that were in the Pending Entries List but no longer exist in the stream. These IDs are
-                deleted from the Pending Entries List.
+                  message IDs that were in the Pending Entries List but no longer exist in the stream. These IDs are
+                  deleted from the Pending Entries List.
 
         Examples:
-            # Valkey version < 7.0.0:
+            Valkey version < 7.0.0:
+
             >>> await client.xautoclaim_just_id("my_stream", "my_group", "my_consumer", 3_600_000, "0-0")
                 [b"0-0", [b"1-1"]]
                 # Stream entry "1-1" was idle for over an hour and was thus claimed by "my_consumer". The entire stream
                 # was scanned.
 
-            # Valkey version 7.0.0 and above:
+            Valkey version 7.0.0 and above:
+
             >>> await client.xautoclaim_just_id("my_stream", "my_group", "my_consumer", 3_600_000, "0-0")
                 [b"0-0", [b"1-1"], [b"1-2"]]
                 # Stream entry "1-1" was idle for over an hour and was thus claimed by "my_consumer". The entire stream
@@ -3586,14 +3875,14 @@ class CoreCommands(Protocol):
         """
         Returns the list of all consumer groups and their attributes for the stream stored at `key`.
 
-        See https://valkey.io/commands/xinfo-groups for more details.
+        See [valkey.io](https://valkey.io/commands/xinfo-groups) for more details.
 
         Args:
             key (TEncodable): The key of the stream.
 
         Returns:
             List[Mapping[bytes, Union[bytes, int, None]]]: A list of mappings, where each mapping represents the
-                attributes of a consumer group for the stream at `key`.
+            attributes of a consumer group for the stream at `key`.
 
         Examples:
             >>> await client.xinfo_groups("my_stream")
@@ -3631,7 +3920,7 @@ class CoreCommands(Protocol):
         Returns the list of all consumers and their attributes for the given consumer group of the stream stored at
         `key`.
 
-        See https://valkey.io/commands/xinfo-consumers for more details.
+        See [valkey.io](https://valkey.io/commands/xinfo-consumers) for more details.
 
         Args:
             key (TEncodable): The key of the stream.
@@ -3639,7 +3928,7 @@ class CoreCommands(Protocol):
 
         Returns:
             List[Mapping[bytes, Union[bytes, int]]]: A list of mappings, where each mapping contains the attributes of a
-                consumer for the given consumer group of the stream at `key`.
+            consumer for the given consumer group of the stream at `key`.
 
         Examples:
             >>> await client.xinfo_consumers("my_stream", "my_group")
@@ -3671,14 +3960,14 @@ class CoreCommands(Protocol):
         """
         Returns information about the stream stored at `key`. To get more detailed information, use `xinfo_stream_full`.
 
-        See https://valkey.io/commands/xinfo-stream for more details.
+        See [valkey.io](https://valkey.io/commands/xinfo-stream) for more details.
 
         Args:
             key (TEncodable): The key of the stream.
 
         Returns:
             TXInfoStreamResponse: A mapping of stream information for the given `key`. See the example for a sample
-                response.
+            response.
 
         Examples:
             >>> await client.xinfo_stream("my_stream")
@@ -3716,7 +4005,7 @@ class CoreCommands(Protocol):
         """
         Returns verbose information about the stream stored at `key`.
 
-        See https://valkey.io/commands/xinfo-stream for more details.
+        See [valkey.io](https://valkey.io/commands/xinfo-stream) for more details.
 
         Args:
             key (TEncodable): The key of the stream.
@@ -3725,7 +4014,7 @@ class CoreCommands(Protocol):
 
         Returns:
             TXInfoStreamFullResponse: A mapping of detailed stream information for the given `key`. See the example for
-                a sample response.
+            a sample response.
 
         Examples:
             >>> await client.xinfo_stream_full("my_stream")
@@ -3815,25 +4104,43 @@ class CoreCommands(Protocol):
         Adds geospatial members with their positions to the specified sorted set stored at `key`.
         If a member is already a part of the sorted set, its position is updated.
 
-        See https://valkey.io/commands/geoadd for more details.
+        See [valkey.io](https://valkey.io/commands/geoadd) for more details.
 
         Args:
             key (TEncodable): The key of the sorted set.
-            members_geospatialdata (Mapping[TEncodable, GeospatialData]): A mapping of member names to their corresponding positions. See `GeospatialData`.
-            The command will report an error when the user attempts to index coordinates outside the specified ranges.
+            members_geospatialdata (Mapping[TEncodable, GeospatialData]): A mapping of member names to their corresponding
+                positions. See `GeospatialData`. The command will report an error when the user attempts to index coordinates
+                outside the specified ranges.
             existing_options (Optional[ConditionalChange]): Options for handling existing members.
+
                 - NX: Only add new elements.
                 - XX: Only update existing elements.
-            changed (bool): Modify the return value to return the number of changed elements, instead of the number of new elements added.
+
+            changed (bool): Modify the return value to return the number of changed elements, instead of the number of new
+                elements added.
 
         Returns:
             int: The number of elements added to the sorted set.
+
             If `changed` is set, returns the number of elements updated in the sorted set.
 
         Examples:
-            >>> await client.geoadd("my_sorted_set", {"Palermo": GeospatialData(13.361389, 38.115556), "Catania": GeospatialData(15.087269, 37.502669)})
+            >>> await client.geoadd(
+            ...     "my_sorted_set",
+            ...     {
+            ...         "Palermo": GeospatialData(13.361389, 38.115556),
+            ...         "Catania": GeospatialData(15.087269, 37.502669)
+            ...     }
+            ... )
                 2  # Indicates that two elements have been added to the sorted set "my_sorted_set".
-            >>> await client.geoadd("my_sorted_set", {"Palermo": GeospatialData(14.361389, 38.115556)}, existing_options=ConditionalChange.XX, changed=True)
+            >>> await client.geoadd(
+            ...     "my_sorted_set",
+            ...     {
+            ...         "Palermo": GeospatialData(14.361389, 38.115556)
+            ...     },
+            ...     existing_options=ConditionalChange.XX,
+            ...     changed=True
+            ... )
                 1  # Updates the position of an existing member in the sorted set "my_sorted_set".
         """
         args = [key]
@@ -3865,7 +4172,7 @@ class CoreCommands(Protocol):
         """
         Returns the distance between two members in the geospatial index stored at `key`.
 
-        See https://valkey.io/commands/geodist for more details.
+        See [valkey.io](https://valkey.io/commands/geodist) for more details.
 
         Args:
             key (TEncodable): The key of the sorted set.
@@ -3876,10 +4183,17 @@ class CoreCommands(Protocol):
 
         Returns:
             Optional[float]: The distance between `member1` and `member2`.
+
             If one or both members do not exist, or if the key does not exist, returns None.
 
         Examples:
-            >>> await client.geoadd("my_geo_set", {"Palermo": GeospatialData(13.361389, 38.115556), "Catania": GeospatialData(15.087269, 37.502669)})
+            >>> await client.geoadd(
+            ...     "my_geo_set",
+            ...     {
+            ...         "Palermo": GeospatialData(13.361389, 38.115556),
+            ...         "Catania": GeospatialData(15.087269, 37.502669)
+            ...     }
+            ... )
             >>> await client.geodist("my_geo_set", "Palermo", "Catania")
                 166274.1516  # Indicates the distance between "Palermo" and "Catania" in meters.
             >>> await client.geodist("my_geo_set", "Palermo", "Palermo", unit=GeoUnit.KILOMETERS)
@@ -3903,18 +4217,26 @@ class CoreCommands(Protocol):
         Returns the GeoHash bytes strings representing the positions of all the specified members in the sorted set stored at
         `key`.
 
-        See https://valkey.io/commands/geohash for more details.
+        See [valkey.io](https://valkey.io/commands/geohash) for more details.
 
         Args:
             key (TEncodable): The key of the sorted set.
             members (List[TEncodable]): The list of members whose GeoHash bytes strings are to be retrieved.
 
         Returns:
-            List[Optional[bytes]]: A list of GeoHash bytes strings representing the positions of the specified members stored at `key`.
+            List[Optional[bytes]]: A list of GeoHash bytes strings representing the positions of the specified members stored
+            at `key`.
+
             If a member does not exist in the sorted set, a None value is returned for that member.
 
         Examples:
-            >>> await client.geoadd("my_geo_sorted_set", {"Palermo": GeospatialData(13.361389, 38.115556), "Catania": GeospatialData(15.087269, 37.502669)})
+            >>> await client.geoadd(
+            ...     "my_geo_sorted_set",
+            ...     {
+            ...         "Palermo": GeospatialData(13.361389, 38.115556),
+            ...         "Catania": GeospatialData(15.087269, 37.502669)
+            ...     }
+            ... )
             >>> await client.geohash("my_geo_sorted_set", ["Palermo", "Catania", "some city])
                 ["sqc8b49rny0", "sqdtr74hyu0", None]  # Indicates the GeoHash bytes strings for the specified members.
         """
@@ -3929,10 +4251,10 @@ class CoreCommands(Protocol):
         members: List[TEncodable],
     ) -> List[Optional[List[float]]]:
         """
-        Returns the positions (longitude and latitude) of all the given members of a geospatial index in the sorted set stored at
-        `key`.
+        Returns the positions (longitude and latitude) of all the given members of a geospatial index in the sorted set stored
+        at `key`.
 
-        See https://valkey.io/commands/geopos for more details.
+        See [valkey.io](https://valkey.io/commands/geopos) for more details.
 
         Args:
             key (TEncodable): The key of the sorted set.
@@ -3940,10 +4262,17 @@ class CoreCommands(Protocol):
 
         Returns:
             List[Optional[List[float]]]: A list of positions (longitude and latitude) corresponding to the given members.
+
             If a member does not exist, its position will be None.
 
         Example:
-            >>> await client.geoadd("my_geo_sorted_set", {"Palermo": GeospatialData(13.361389, 38.115556), "Catania": GeospatialData(15.087269, 37.502669)})
+            >>> await client.geoadd(
+            ...     "my_geo_sorted_set",
+            ...     {
+            ...         "Palermo": GeospatialData(13.361389, 38.115556),
+            ...         "Catania": GeospatialData(15.087269, 37.502669)
+            ...     }
+            ... )
             >>> await client.geopos("my_geo_sorted_set", ["Palermo", "Catania", "NonExisting"])
                 [[13.36138933897018433, 38.11555639549629859], [15.08726745843887329, 37.50266842333162032], None]
         """
@@ -3964,9 +4293,10 @@ class CoreCommands(Protocol):
         with_hash: bool = False,
     ) -> List[Union[bytes, List[Union[bytes, float, int, List[float]]]]]:
         """
-        Searches for members in a sorted set stored at `key` representing geospatial data within a circular or rectangular area.
+        Searches for members in a sorted set stored at `key` representing geospatial data within a circular or rectangular
+        area.
 
-        See https://valkey.io/commands/geosearch/ for more details.
+        See [valkey.io](https://valkey.io/commands/geosearch/) for more details.
 
         Args:
             key (TEncodable): The key of the sorted set representing geospatial data.
@@ -3976,8 +4306,10 @@ class CoreCommands(Protocol):
                 For circular area search, see `GeoSearchByRadius`.
                 For rectangular area search, see `GeoSearchByBox`.
             order_by (Optional[OrderBy]): Specifies the order in which the results should be returned.
-                    - `ASC`: Sorts items from the nearest to the farthest, relative to the center point.
-                    - `DESC`: Sorts items from the farthest to the nearest, relative to the center point.
+
+                - `ASC`: Sorts items from the nearest to the farthest, relative to the center point.
+                - `DESC`: Sorts items from the farthest to the nearest, relative to the center point.
+
                 If not specified, the results would be unsorted.
             count (Optional[GeoSearchCount]): Specifies the maximum number of results to return. See `GeoSearchCount`.
                 If not specified, return all results.
@@ -3987,19 +4319,45 @@ class CoreCommands(Protocol):
             with_hash (bool): Whether to include geohash of the returned items. Defaults to False.
 
         Returns:
-            List[Union[bytes, List[Union[bytes, float, int, List[float]]]]]: By default, returns a list of members (locations) names.
-            If any of `with_coord`, `with_dist` or `with_hash` are True, returns an array of arrays, we're each sub array represents a single item in the following order:
-                (bytes): The member (location) name.
-                (float): The distance from the center as a floating point number, in the same unit specified in the radius, if `with_dist` is set to True.
-                (int): The Geohash integer, if `with_hash` is set to True.
-                List[float]: The coordinates as a two item [longitude,latitude] array, if `with_coord` is set to True.
-
-        Examples:
-            >>> await client.geoadd("my_geo_sorted_set", {"edge1": GeospatialData(12.758489, 38.788135), "edge2": GeospatialData(17.241510, 38.788135)}})
-            >>> await client.geoadd("my_geo_sorted_set", {"Palermo": GeospatialData(13.361389, 38.115556), "Catania": GeospatialData(15.087269, 37.502669)})
+            List[Union[bytes, List[Union[bytes, float, int, List[float]]]]]: By default, returns a list of members (locations)
+            names.
+
+            If any of `with_coord`, `with_dist` or `with_hash` are True, returns an array of arrays, we're each sub array
+            represents a single item in the following order:
+
+                - (bytes): The member (location) name.
+                - (float): The distance from the center as a floating point number, in the same unit specified in the radius,
+                  if `with_dist` is set to True.
+                - (int): The Geohash integer, if `with_hash` is set to True.
+                - List[float]: The coordinates as a two item [longitude,latitude] array, if `with_coord` is set to True.
+
+        Examples:
+            >>> await client.geoadd(
+            ...     "my_geo_sorted_set",
+            ...     {
+            ...         "edge1": GeospatialData(12.758489, 38.788135),
+            ...         "edge2": GeospatialData(17.241510, 38.788135)
+            ...     }
+            ... )
+            >>> await client.geoadd(
+            ...     "my_geo_sorted_set",
+            ...     {
+            ...         "Palermo": GeospatialData(13.361389, 38.115556),
+            ...         "Catania": GeospatialData(15.087269, 37.502669)
+            ...     }
+            ... )
             >>> await client.geosearch("my_geo_sorted_set", "Catania", GeoSearchByRadius(175, GeoUnit.MILES), OrderBy.DESC)
-                ['Palermo', 'Catania'] # Returned the locations names within the radius of 175 miles, with the center being 'Catania' from farthest to nearest.
-            >>> await client.geosearch("my_geo_sorted_set", GeospatialData(15, 37), GeoSearchByBox(400, 400, GeoUnit.KILOMETERS), OrderBy.DESC, with_coord=true, with_dist=true, with_hash=true)
+                ['Palermo', 'Catania'] # Returned the locations names within the radius of 175 miles, with the center being
+                                       # 'Catania' from farthest to nearest.
+            >>> await client.geosearch(
+            ...     "my_geo_sorted_set",
+            ...     GeospatialData(15, 37),
+            ...     GeoSearchByBox(400, 400, GeoUnit.KILOMETERS),
+            ...     OrderBy.DESC,
+            ...     with_coord=true,
+            ...     with_dist=true,
+            ...     with_hash=true
+            ... )
                 [
                     [
                         b"Catania",
@@ -4017,7 +4375,8 @@ class CoreCommands(Protocol):
                         b"edge1",
                         [279.7405, 3479273021651468, [12.75848776102066, 38.78813451624225]],
                     ],
-                ]  # Returns locations within the square box of 400 km, with the center being a specific point, from nearest to farthest with the dist, hash and coords.
+                ]  # Returns locations within the square box of 400 km, with the center being a specific point, from nearest
+                   # to farthest with the dist, hash and coords.
 
         Since: Valkey version 6.2.0.
         """
@@ -4047,7 +4406,8 @@ class CoreCommands(Protocol):
         store_dist: bool = False,
     ) -> int:
         """
-        Searches for members in a sorted set stored at `key` representing geospatial data within a circular or rectangular area and stores the result in `destination`.
+        Searches for members in a sorted set stored at `key` representing geospatial data within a circular or rectangular
+        area and stores the result in `destination`.
         If `destination` already exists, it is overwritten. Otherwise, a new sorted set will be created.
 
         To get the result directly, see `geosearch`.
@@ -4055,34 +4415,55 @@ class CoreCommands(Protocol):
         Note:
             When in cluster mode, both `source` and `destination` must map to the same hash slot.
 
-            Args:
-                destination (TEncodable): The key to store the search results.
-                source (TEncodable): The key of the sorted set representing geospatial data to search from.
-                search_from (Union[str, bytes, GeospatialData]): The location to search from. Can be specified either as a member
-                    from the sorted set or as a geospatial data (see `GeospatialData`).
-                search_by (Union[GeoSearchByRadius, GeoSearchByBox]): The search criteria.
-                    For circular area search, see `GeoSearchByRadius`.
-                    For rectangular area search, see `GeoSearchByBox`.
-                count (Optional[GeoSearchCount]): Specifies the maximum number of results to store. See `GeoSearchCount`.
-                    If not specified, stores all results.
-                store_dist (bool): Determines what is stored as the sorted set score. Defaults to False.
-                    - If set to False, the geohash of the location will be stored as the sorted set score.
-                    - If set to True, the distance from the center of the shape (circle or box) will be stored as the sorted set score.
-                        The distance is represented as a floating-point number in the same unit specified for that shape.
+        Args:
+            destination (TEncodable): The key to store the search results.
+            source (TEncodable): The key of the sorted set representing geospatial data to search from.
+            search_from (Union[str, bytes, GeospatialData]): The location to search from. Can be specified either as a
+                member from the sorted set or as a geospatial data (see `GeospatialData`).
+            search_by (Union[GeoSearchByRadius, GeoSearchByBox]): The search criteria.
+                For circular area search, see `GeoSearchByRadius`.
+                For rectangular area search, see `GeoSearchByBox`.
+            count (Optional[GeoSearchCount]): Specifies the maximum number of results to store. See `GeoSearchCount`.
+                If not specified, stores all results.
+            store_dist (bool): Determines what is stored as the sorted set score. Defaults to False.
+
+                - If set to False, the geohash of the location will be stored as the sorted set score.
+                - If set to True, the distance from the center of the shape (circle or box) will be stored as the sorted
+                  set score.
+                  The distance is represented as a floating-point number in the same unit specified for that shape.
 
         Returns:
             int: The number of elements in the resulting sorted set stored at `destination`.
 
         Examples:
-            >>> await client.geoadd("my_geo_sorted_set", {"Palermo": GeospatialData(13.361389, 38.115556), "Catania": GeospatialData(15.087269, 37.502669)})
-            >>> await client.geosearchstore("my_dest_sorted_set", "my_geo_sorted_set", "Catania", GeoSearchByRadius(175, GeoUnit.MILES))
+            >>> await client.geoadd(
+            ...     "my_geo_sorted_set",
+            ...     {
+            ...         "Palermo": GeospatialData(13.361389, 38.115556),
+            ...         "Catania": GeospatialData(15.087269, 37.502669)
+            ...     }
+            ... )
+            >>> await client.geosearchstore(
+            ...     "my_dest_sorted_set",
+            ...     "my_geo_sorted_set",
+            ...     "Catania",
+            ...     GeoSearchByRadius(175, GeoUnit.MILES)
+            ... )
                 2 # Number of elements stored in "my_dest_sorted_set".
             >>> await client.zrange_withscores("my_dest_sorted_set", RangeByIndex(0, -1))
-                {b"Palermo": 3479099956230698.0, b"Catania": 3479447370796909.0} # The elements within te search area, with their geohash as score.
-            >>> await client.geosearchstore("my_dest_sorted_set", "my_geo_sorted_set", GeospatialData(15, 37), GeoSearchByBox(400, 400, GeoUnit.KILOMETERS), store_dist=True)
+                {b"Palermo": 3479099956230698.0, b"Catania": 3479447370796909.0} # The elements within te search area, with
+                                                                                 # their geohash as score.
+            >>> await client.geosearchstore(
+            ...     "my_dest_sorted_set",
+            ...     "my_geo_sorted_set",
+            ...     GeospatialData(15, 37),
+            ...     GeoSearchByBox(400, 400, GeoUnit.KILOMETERS),
+            ...     store_dist=True
+            ... )
                 2 # Number of elements stored in "my_dest_sorted_set", with distance as score.
             >>> await client.zrange_withscores("my_dest_sorted_set", RangeByIndex(0, -1))
-                {b"Catania": 56.4412578701582, b"Palermo": 190.44242984775784} # The elements within te search area, with the distance as score.
+                {b"Catania": 56.4412578701582, b"Palermo": 190.44242984775784} # The elements within te search area, with the
+                                                                               # distance as score.
 
         Since: Valkey version 6.2.0.
         """
@@ -4115,27 +4496,41 @@ class CoreCommands(Protocol):
         Adds members with their scores to the sorted set stored at `key`.
         If a member is already a part of the sorted set, its score is updated.
 
-        See https://valkey.io/commands/zadd/ for more details.
+        See [valkey.io](https://valkey.io/commands/zadd/) for more details.
 
         Args:
             key (TEncodable): The key of the sorted set.
             members_scores (Mapping[TEncodable, float]): A mapping of members to their corresponding scores.
             existing_options (Optional[ConditionalChange]): Options for handling existing members.
+
                 - NX: Only add new elements.
                 - XX: Only update existing elements.
+
             update_condition (Optional[UpdateOptions]): Options for updating scores.
+
                 - GT: Only update scores greater than the current values.
                 - LT: Only update scores less than the current values.
-            changed (bool): Modify the return value to return the number of changed elements, instead of the number of new elements added.
+
+            changed (bool): Modify the return value to return the number of changed elements, instead of the number of new
+                elements added.
 
         Returns:
             int: The number of elements added to the sorted set.
+
             If `changed` is set, returns the number of elements updated in the sorted set.
 
         Examples:
             >>> await client.zadd("my_sorted_set", {"member1": 10.5, "member2": 8.2})
                 2  # Indicates that two elements have been added to the sorted set "my_sorted_set."
-            >>> await client.zadd("existing_sorted_set", {"member1": 15.0, "member2": 5.5}, existing_options=ConditionalChange.XX, changed=True)
+            >>> await client.zadd(
+            ...     "existing_sorted_set",
+            ...     {
+            ...         "member1": 15.0,
+            ...         "member2": 5.5
+            ...     },
+            ...     existing_options=ConditionalChange.XX,
+            ...     changed=True
+            ... )
                 2  # Updates the scores of two existing members in the sorted set "existing_sorted_set."
         """
         args = [key]
@@ -4175,24 +4570,29 @@ class CoreCommands(Protocol):
     ) -> Optional[float]:
         """
         Increments the score of member in the sorted set stored at `key` by `increment`.
-        If `member` does not exist in the sorted set, it is added with `increment` as its score (as if its previous score was 0.0).
+        If `member` does not exist in the sorted set, it is added with `increment` as its score (as if its previous score
+        was 0.0).
         If `key` does not exist, a new sorted set with the specified member as its sole member is created.
 
-        See https://valkey.io/commands/zadd/ for more details.
+        See [valkey.io](https://valkey.io/commands/zadd/) for more details.
 
         Args:
             key (TEncodable): The key of the sorted set.
             member (TEncodable): A member in the sorted set to increment.
             increment (float): The score to increment the member.
             existing_options (Optional[ConditionalChange]): Options for handling the member's existence.
+
                 - NX: Only increment a member that doesn't exist.
                 - XX: Only increment an existing member.
+
             update_condition (Optional[UpdateOptions]): Options for updating the score.
+
                 - GT: Only increment the score of the member if the new score will be greater than the current score.
                 - LT: Only increment (decrement) the score of the member if the new score will be less than the current score.
 
         Returns:
             Optional[float]: The score of the member.
+
             If there was a conflict with choosing the XX/NX/LT/GT options, the operation aborts and None is returned.
 
         Examples:
@@ -4227,13 +4627,14 @@ class CoreCommands(Protocol):
         """
         Returns the cardinality (number of elements) of the sorted set stored at `key`.
 
-        See https://valkey.io/commands/zcard/ for more details.
+        See [valkey.io](https://valkey.io/commands/zcard/) for more details.
 
         Args:
             key (TEncodable): The key of the sorted set.
 
         Returns:
             int: The number of elements in the sorted set.
+
             If `key` does not exist, it is treated as an empty sorted set, and the command returns 0.
 
         Examples:
@@ -4253,7 +4654,7 @@ class CoreCommands(Protocol):
         """
         Returns the number of members in the sorted set stored at `key` with scores between `min_score` and `max_score`.
 
-        See https://valkey.io/commands/zcount/ for more details.
+        See [valkey.io](https://valkey.io/commands/zcount/) for more details.
 
         Args:
             key (TEncodable): The key of the sorted set.
@@ -4266,23 +4667,30 @@ class CoreCommands(Protocol):
 
         Returns:
             int: The number of members in the specified score range.
+
             If `key` does not exist, it is treated as an empty sorted set, and the command returns 0.
+
             If `max_score` < `min_score`, 0 is returned.
 
         Examples:
             >>> await client.zcount("my_sorted_set", ScoreBoundary(5.0 , is_inclusive=true) , InfBound.POS_INF)
-                2  # Indicates that there are 2 members with scores between 5.0 (not exclusive) and +inf in the sorted set "my_sorted_set".
-            >>> await client.zcount("my_sorted_set", ScoreBoundary(5.0 , is_inclusive=true) , ScoreBoundary(10.0 , is_inclusive=false))
+                2  # Indicates that there are 2 members with scores between 5.0 (not exclusive) and +inf in the sorted set
+                   # "my_sorted_set".
+            >>> await client.zcount(
+            ...     "my_sorted_set",
+            ...     ScoreBoundary(5.0 , is_inclusive=true),
+            ...     ScoreBoundary(10.0 , is_inclusive=false)
+            ... )
                 1  # Indicates that there is one ScoreBoundary with 5.0 < score <= 10.0 in the sorted set "my_sorted_set".
         """
         score_min = (
             min_score.value["score_arg"]
-            if type(min_score) == InfBound
+            if isinstance(min_score, InfBound)
             else min_score.value
         )
         score_max = (
             max_score.value["score_arg"]
-            if type(max_score) == InfBound
+            if isinstance(max_score, InfBound)
             else max_score.value
         )
         return cast(
@@ -4300,7 +4708,7 @@ class CoreCommands(Protocol):
         If `member` does not exist in the sorted set, it is added with `increment` as its score.
         If `key` does not exist, a new sorted set is created with the specified member as its sole member.
 
-        See https://valkey.io/commands/zincrby/ for more details.
+        See [valkey.io](https://valkey.io/commands/zincrby/) for more details.
 
         Args:
             key (TEncodable): The key of the sorted set.
@@ -4334,22 +4742,26 @@ class CoreCommands(Protocol):
         If `count` is provided, up to `count` members with the highest scores are removed and returned.
         Otherwise, only one member with the highest score is removed and returned.
 
-        See https://valkey.io/commands/zpopmax for more details.
+        See [valkey.io](https://valkey.io/commands/zpopmax) for more details.
 
         Args:
             key (TEncodable): The key of the sorted set.
             count (Optional[int]): Specifies the quantity of members to pop. If not specified, pops one member.
-            If `count` is higher than the sorted set's cardinality, returns all members and their scores, ordered from highest to lowest.
+                If `count` is higher than the sorted set's cardinality, returns all members and their scores, ordered from
+                highest to lowest.
 
         Returns:
-            Mapping[bytes, float]: A map of the removed members and their scores, ordered from the one with the highest score to the one with the lowest.
-            If `key` doesn't exist, it will be treated as an empy sorted set and the command returns an empty map.
+            Mapping[bytes, float]: A map of the removed members and their scores, ordered from the one with the highest score
+            to the one with the lowest.
+
+            If `key` doesn't exist, it will be treated as an empty sorted set and the command returns an empty map.
 
         Examples:
             >>> await client.zpopmax("my_sorted_set")
                 {b'member1': 10.0}  # Indicates that 'member1' with a score of 10.0 has been removed from the sorted set.
             >>> await client.zpopmax("my_sorted_set", 2)
-                {b'member2': 8.0, b'member3': 7.5}  # Indicates that 'member2' with a score of 8.0 and 'member3' with a score of 7.5 have been removed from the sorted set.
+                {b'member2': 8.0, b'member3': 7.5}  # Indicates that 'member2' with a score of 8.0 and 'member3' with a score
+                                                    # of 7.5 have been removed from the sorted set.
         """
         return cast(
             Mapping[bytes, float],
@@ -4366,13 +4778,14 @@ class CoreCommands(Protocol):
         the order that they are given. Blocks the connection when there are no members to remove from any of the given
         sorted sets.
 
-        When in cluster mode, all keys must map to the same hash slot.
-
-        `BZPOPMAX` is the blocking variant of `ZPOPMAX`.
-
-        `BZPOPMAX` is a client blocking command, see https://github.com/valkey-io/valkey-glide/wiki/General-Concepts#blocking-commands for more details and best practices.
+        Note:
+            1. When in cluster mode, all keys must map to the same hash slot.
+            2. `BZPOPMAX` is the blocking variant of `ZPOPMAX`.
+            3. `BZPOPMAX` is a client blocking command, see
+               [blocking commands](https://github.com/valkey-io/valkey-glide/wiki/General-Concepts#blocking-commands)
+               for more details and best practices.
 
-        See https://valkey.io/commands/bzpopmax for more details.
+        See [valkey.io](https://valkey.io/commands/bzpopmax) for more details.
 
         Args:
             keys (List[TEncodable]): The keys of the sorted sets.
@@ -4380,8 +4793,10 @@ class CoreCommands(Protocol):
                 A value of 0 will block indefinitely.
 
         Returns:
-            Optional[List[Union[bytes, float]]]: An array containing the key where the member was popped out, the member itself,
-                and the member score. If no member could be popped and the `timeout` expired, returns None.
+            Optional[List[Union[bytes, float]]]: An array containing the key where the member was popped out, the member
+            itself, and the member score.
+
+            If no member could be popped and the `timeout` expired, returns None.
 
         Examples:
             >>> await client.zadd("my_sorted_set1", {"member1": 10.0, "member2": 5.0})
@@ -4402,22 +4817,25 @@ class CoreCommands(Protocol):
         If `count` is provided, up to `count` members with the lowest scores are removed and returned.
         Otherwise, only one member with the lowest score is removed and returned.
 
-        See https://valkey.io/commands/zpopmin for more details.
+        See [valkey.io](https://valkey.io/commands/zpopmin) for more details.
 
         Args:
             key (TEncodable): The key of the sorted set.
             count (Optional[int]): Specifies the quantity of members to pop. If not specified, pops one member.
-            If `count` is higher than the sorted set's cardinality, returns all members and their scores.
+                If `count` is higher than the sorted set's cardinality, returns all members and their scores.
 
         Returns:
-            Mapping[bytes, float]: A map of the removed members and their scores, ordered from the one with the lowest score to the one with the highest.
-            If `key` doesn't exist, it will be treated as an empy sorted set and the command returns an empty map.
+            Mapping[bytes, float]: A map of the removed members and their scores, ordered from the one with the lowest score
+            to the one with the highest.
+
+            If `key` doesn't exist, it will be treated as an empty sorted set and the command returns an empty map.
 
         Examples:
             >>> await client.zpopmin("my_sorted_set")
                 {b'member1': 5.0}  # Indicates that 'member1' with a score of 5.0 has been removed from the sorted set.
             >>> await client.zpopmin("my_sorted_set", 2)
-                {b'member3': 7.5 , b'member2': 8.0}  # Indicates that 'member3' with a score of 7.5 and 'member2' with a score of 8.0 have been removed from the sorted set.
+                {b'member3': 7.5 , b'member2': 8.0}  # Indicates that 'member3' with a score of 7.5 and 'member2' with a score
+                                                     # of 8.0 have been removed from the sorted set.
         """
         args: List[TEncodable] = [key, str(count)] if count else [key]
         return cast(
@@ -4433,13 +4851,14 @@ class CoreCommands(Protocol):
         the order that they are given. Blocks the connection when there are no members to remove from any of the given
         sorted sets.
 
-        When in cluster mode, all keys must map to the same hash slot.
-
-        `BZPOPMIN` is the blocking variant of `ZPOPMIN`.
-
-        `BZPOPMIN` is a client blocking command, see https://github.com/valkey-io/valkey-glide/wiki/General-Concepts#blocking-commands for more details and best practices.
+        Note:
+            1. When in cluster mode, all keys must map to the same hash slot.
+            2. `BZPOPMIN` is the blocking variant of `ZPOPMIN`.
+            3. `BZPOPMIN` is a client blocking command, see
+               [blocking commands](https://github.com/valkey-io/valkey-glide/wiki/General-Concepts#blocking-commands)
+               for more details and best practices.
 
-        See https://valkey.io/commands/bzpopmin for more details.
+        See [valkey.io](https://valkey.io/commands/bzpopmin) for more details.
 
         Args:
             keys (List[TEncodable]): The keys of the sorted sets.
@@ -4447,8 +4866,10 @@ class CoreCommands(Protocol):
                 A value of 0 will block indefinitely.
 
         Returns:
-            Optional[List[Union[bytes, float]]]: An array containing the key where the member was popped out, the member itself,
-                and the member score. If no member could be popped and the `timeout` expired, returns None.
+            Optional[List[Union[bytes, float]]]: An array containing the key where the member was popped out, the member
+            itself, and the member score.
+
+            If no member could be popped and the `timeout` expired, returns None.
 
         Examples:
             >>> await client.zadd("my_sorted_set1", {"member1": 10.0, "member2": 5.0})
@@ -4473,27 +4894,32 @@ class CoreCommands(Protocol):
 
         ZRANGE can perform different types of range queries: by index (rank), by the score, or by lexicographical order.
 
-        See https://valkey.io/commands/zrange/ for more details.
+        See [valkey.io](https://valkey.io/commands/zrange/) for more details.
 
         To get the elements with their scores, see zrange_withscores.
 
         Args:
             key (TEncodable): The key of the sorted set.
-            range_query (Union[RangeByIndex, RangeByLex, RangeByScore]): The range query object representing the type of range query to perform.
-                - For range queries by index (rank), use RangeByIndex.
-                - For range queries by lexicographical order, use RangeByLex.
-                - For range queries by score, use RangeByScore.
+            range_query (Union[RangeByIndex, RangeByLex, RangeByScore]): The range query object representing the type of range
+                query to perform.
+
+                    - For range queries by index (rank), use RangeByIndex.
+                    - For range queries by lexicographical order, use RangeByLex.
+                    - For range queries by score, use RangeByScore.
+
             reverse (bool): If True, reverses the sorted set, with index 0 as the element with the highest score.
 
         Returns:
             List[bytes]: A list of elements within the specified range.
+
             If `key` does not exist, it is treated as an empty sorted set, and the command returns an empty array.
 
         Examples:
             >>> await client.zrange("my_sorted_set", RangeByIndex(0, -1))
                 [b'member1', b'member2', b'member3']  # Returns all members in ascending order.
             >>> await client.zrange("my_sorted_set", RangeByScore(InfBound.NEG_INF, ScoreBoundary(3)))
-                [b'member2', b'member3'] # Returns members with scores within the range of negative infinity to 3, in ascending order.
+                [b'member2', b'member3'] # Returns members with scores within the range of negative infinity to 3, in
+                                         # ascending order.
         """
         args = _create_zrange_args(key, range_query, reverse, with_scores=False)
 
@@ -4509,24 +4935,29 @@ class CoreCommands(Protocol):
         Returns the specified range of elements with their scores in the sorted set stored at `key`.
         Similar to ZRANGE but with a WITHSCORE flag.
 
-        See https://valkey.io/commands/zrange/ for more details.
+        See [valkey.io](https://valkey.io/commands/zrange/) for more details.
 
         Args:
             key (TEncodable): The key of the sorted set.
-            range_query (Union[RangeByIndex, RangeByScore]): The range query object representing the type of range query to perform.
-                - For range queries by index (rank), use RangeByIndex.
-                - For range queries by score, use RangeByScore.
+            range_query (Union[RangeByIndex, RangeByScore]): The range query object representing the type of range query to
+                perform.
+
+                    - For range queries by index (rank), use RangeByIndex.
+                    - For range queries by score, use RangeByScore.
+
             reverse (bool): If True, reverses the sorted set, with index 0 as the element with the highest score.
 
         Returns:
             Mapping[bytes , float]: A map of elements and their scores within the specified range.
+
             If `key` does not exist, it is treated as an empty sorted set, and the command returns an empty map.
 
         Examples:
             >>> await client.zrange_withscores("my_sorted_set", RangeByScore(ScoreBoundary(10), ScoreBoundary(20)))
                 {b'member1': 10.5, b'member2': 15.2}  # Returns members with scores between 10 and 20 with their scores.
            >>> await client.zrange_withscores("my_sorted_set", RangeByScore(InfBound.NEG_INF, ScoreBoundary(3)))
-                {b'member4': -2.0, b'member7': 1.5} # Returns members with with scores within the range of negative infinity to 3, with their scores.
+                {b'member4': -2.0, b'member7': 1.5} # Returns members with with scores within the range of negative infinity
+                                                    # to 3, with their scores.
         """
         args = _create_zrange_args(key, range_query, reverse, with_scores=True)
 
@@ -4548,7 +4979,7 @@ class CoreCommands(Protocol):
         ZRANGESTORE can perform different types of range queries: by index (rank), by the score, or by lexicographical
         order.
 
-        See https://valkey.io/commands/zrangestore for more details.
+        See [valkey.io](https://valkey.io/commands/zrangestore) for more details.
 
         Note:
             When in Cluster mode, `source` and `destination` must map to the same hash slot.
@@ -4556,10 +4987,13 @@ class CoreCommands(Protocol):
         Args:
             destination (TEncodable): The key for the destination sorted set.
             source (TEncodable): The key of the source sorted set.
-            range_query (Union[RangeByIndex, RangeByLex, RangeByScore]): The range query object representing the type of range query to perform.
-                - For range queries by index (rank), use RangeByIndex.
-                - For range queries by lexicographical order, use RangeByLex.
-                - For range queries by score, use RangeByScore.
+            range_query (Union[RangeByIndex, RangeByLex, RangeByScore]): The range query object representing the type of range
+                query to perform.
+
+                    - For range queries by index (rank), use RangeByIndex.
+                    - For range queries by lexicographical order, use RangeByLex.
+                    - For range queries by score, use RangeByScore.
+
             reverse (bool): If True, reverses the sorted set, with index 0 as the element with the highest score.
 
         Returns:
@@ -4567,9 +5001,11 @@ class CoreCommands(Protocol):
 
         Examples:
             >>> await client.zrangestore("destination_key", "my_sorted_set", RangeByIndex(0, 2), True)
-                3  # The 3 members with the highest scores from "my_sorted_set" were stored in the sorted set at "destination_key".
+                3  # The 3 members with the highest scores from "my_sorted_set" were stored in the sorted set at
+                   # "destination_key".
             >>> await client.zrangestore("destination_key", "my_sorted_set", RangeByScore(InfBound.NEG_INF, ScoreBoundary(3)))
-                2  # The 2 members with scores between negative infinity and 3 (inclusive) from "my_sorted_set" were stored in the sorted set at "destination_key".
+                2  # The 2 members with scores between negative infinity and 3 (inclusive) from "my_sorted_set" were stored in
+                   # the sorted set at "destination_key".
         """
         args = _create_zrange_args(source, range_query, reverse, False, destination)
 
@@ -4583,7 +5019,7 @@ class CoreCommands(Protocol):
         """
         Returns the rank of `member` in the sorted set stored at `key`, with scores ordered from low to high.
 
-        See https://valkey.io/commands/zrank for more details.
+        See [valkey.io](https://valkey.io/commands/zrank) for more details.
 
         To get the rank of `member` with its score, see `zrank_withscore`.
 
@@ -4593,9 +5029,10 @@ class CoreCommands(Protocol):
 
         Returns:
             Optional[int]: The rank of `member` in the sorted set.
+
             If `key` doesn't exist, or if `member` is not present in the set, None will be returned.
 
-            Examples:
+        Examples:
             >>> await client.zrank("my_sorted_set", "member2")
                 1  # Indicates that "member2" has the second-lowest score in the sorted set "my_sorted_set".
             >>> await client.zrank("my_sorted_set", "non_existing_member")
@@ -4611,9 +5048,10 @@ class CoreCommands(Protocol):
         member: TEncodable,
     ) -> Optional[List[Union[int, float]]]:
         """
-        Returns the rank of `member` in the sorted set stored at `key` with its score, where scores are ordered from the lowest to highest.
+        Returns the rank of `member` in the sorted set stored at `key` with its score, where scores are ordered from the
+        lowest to highest.
 
-        See https://valkey.io/commands/zrank for more details.
+        See [valkey.io](https://valkey.io/commands/zrank) for more details.
 
         Args:
             key (TEncodable): The key of the sorted set.
@@ -4621,11 +5059,13 @@ class CoreCommands(Protocol):
 
         Returns:
             Optional[List[Union[int, float]]]: A list containing the rank and score of `member` in the sorted set.
+
             If `key` doesn't exist, or if `member` is not present in the set, None will be returned.
 
         Examples:
             >>> await client.zrank_withscore("my_sorted_set", "member2")
-                [1 , 6.0]  # Indicates that "member2" with score 6.0 has the second-lowest score in the sorted set "my_sorted_set".
+                [1 , 6.0]  # Indicates that "member2" with score 6.0 has the second-lowest score in the sorted set
+                           # "my_sorted_set".
             >>> await client.zrank_withscore("my_sorted_set", "non_existing_member")
                 None  # Indicates that "non_existing_member" is not present in the sorted set "my_sorted_set".
 
@@ -4643,7 +5083,7 @@ class CoreCommands(Protocol):
 
         To get the rank of `member` with its score, see `zrevrank_withscore`.
 
-        See https://valkey.io/commands/zrevrank for more details.
+        See [valkey.io](https://valkey.io/commands/zrevrank) for more details.
 
         Args:
             key (TEncodable): The key of the sorted set.
@@ -4651,7 +5091,8 @@ class CoreCommands(Protocol):
 
         Returns:
             Optional[int]: The rank of `member` in the sorted set, where ranks are ordered from high to low based on scores.
-                If `key` doesn't exist, or if `member` is not present in the set, `None` will be returned.
+
+            If `key` doesn't exist, or if `member` is not present in the set, `None` will be returned.
 
         Examples:
             >>> await client.zadd("my_sorted_set", {"member1": 10.5, "member2": 8.2, "member3": 9.6})
@@ -4670,7 +5111,7 @@ class CoreCommands(Protocol):
         Returns the rank of `member` in the sorted set stored at `key` with its score, where scores are ordered from the
         highest to lowest, starting from `0`.
 
-        See https://valkey.io/commands/zrevrank for more details.
+        See [valkey.io](https://valkey.io/commands/zrevrank) for more details.
 
         Args:
             key (TEncodable): The key of the sorted set.
@@ -4678,8 +5119,9 @@ class CoreCommands(Protocol):
 
         Returns:
             Optional[List[Union[int, float]]]: A list containing the rank (as `int`) and score (as `float`) of `member`
-                in the sorted set, where ranks are ordered from high to low based on scores.
-                If `key` doesn't exist, or if `member` is not present in the set, `None` will be returned.
+            in the sorted set, where ranks are ordered from high to low based on scores.
+
+            If `key` doesn't exist, or if `member` is not present in the set, `None` will be returned.
 
         Examples:
             >>> await client.zadd("my_sorted_set", {"member1": 10.5, "member2": 8.2, "member3": 9.6})
@@ -4704,7 +5146,7 @@ class CoreCommands(Protocol):
         Removes the specified members from the sorted set stored at `key`.
         Specified members that are not a member of this set are ignored.
 
-        See https://valkey.io/commands/zrem/ for more details.
+        See [valkey.io](https://valkey.io/commands/zrem/) for more details.
 
         Args:
             key (TEncodable): The key of the sorted set.
@@ -4712,6 +5154,7 @@ class CoreCommands(Protocol):
 
         Returns:
             int: The number of members that were removed from the sorted set, not including non-existing members.
+
             If `key` does not exist, it is treated as an empty sorted set, and the command returns 0.
 
         Examples:
@@ -4734,7 +5177,7 @@ class CoreCommands(Protocol):
         """
         Removes all elements in the sorted set stored at `key` with a score between `min_score` and `max_score`.
 
-        See https://valkey.io/commands/zremrangebyscore/ for more details.
+        See [valkey.io](https://valkey.io/commands/zremrangebyscore/) for more details.
 
         Args:
             key (TEncodable): The key of the sorted set.
@@ -4746,23 +5189,30 @@ class CoreCommands(Protocol):
                 or ScoreBoundary representing a specific score and inclusivity.
         Returns:
             int: The number of members that were removed from the sorted set.
+
             If `key` does not exist, it is treated as an empty sorted set, and the command returns 0.
+
             If `min_score` is greater than `max_score`, 0 is returned.
 
         Examples:
             >>> await client.zremrangebyscore("my_sorted_set",  ScoreBoundary(5.0 , is_inclusive=true) , InfBound.POS_INF)
-                2  # Indicates that  2 members with scores between 5.0 (not exclusive) and +inf have been removed from the sorted set "my_sorted_set".
-            >>> await client.zremrangebyscore("non_existing_sorted_set", ScoreBoundary(5.0 , is_inclusive=true) , ScoreBoundary(10.0 , is_inclusive=false))
+                2  # Indicates that  2 members with scores between 5.0 (not exclusive) and +inf have been removed from the
+                   # sorted set "my_sorted_set".
+            >>> await client.zremrangebyscore(
+            ...     "non_existing_sorted_set",
+            ...     ScoreBoundary(5.0 , is_inclusive=true),
+            ...     ScoreBoundary(10.0 , is_inclusive=false)
+            ... )
                 0  # Indicates that no members were removed as the sorted set "non_existing_sorted_set" does not exist.
         """
         score_min = (
             min_score.value["score_arg"]
-            if type(min_score) == InfBound
+            if isinstance(min_score, InfBound)
             else min_score.value
         )
         score_max = (
             max_score.value["score_arg"]
-            if type(max_score) == InfBound
+            if isinstance(max_score, InfBound)
             else max_score.value
         )
 
@@ -4783,7 +5233,7 @@ class CoreCommands(Protocol):
         Removes all elements in the sorted set stored at `key` with a lexicographical order between `min_lex` and
         `max_lex`.
 
-        See https://valkey.io/commands/zremrangebylex/ for more details.
+        See [valkey.io](https://valkey.io/commands/zremrangebylex/) for more details.
 
         Args:
             key (TEncodable): The key of the sorted set.
@@ -4796,20 +5246,23 @@ class CoreCommands(Protocol):
 
         Returns:
             int: The number of members that were removed from the sorted set.
-                If `key` does not exist, it is treated as an empty sorted set, and the command returns `0`.
-                If `min_lex` is greater than `max_lex`, `0` is returned.
+
+            If `key` does not exist, it is treated as an empty sorted set, and the command returns `0`.
+
+            If `min_lex` is greater than `max_lex`, `0` is returned.
 
         Examples:
             >>> await client.zremrangebylex("my_sorted_set",  LexBoundary("a", is_inclusive=False), LexBoundary("e"))
-                4  # Indicates that 4 members, with lexicographical values ranging from "a" (exclusive) to "e" (inclusive), have been removed from "my_sorted_set".
+                4  # Indicates that 4 members, with lexicographical values ranging from "a" (exclusive) to "e" (inclusive),
+                   # have been removed from "my_sorted_set".
             >>> await client.zremrangebylex("non_existing_sorted_set", InfBound.NEG_INF, LexBoundary("e"))
                 0  # Indicates that no members were removed as the sorted set "non_existing_sorted_set" does not exist.
         """
         min_lex_arg = (
-            min_lex.value["lex_arg"] if type(min_lex) == InfBound else min_lex.value
+            min_lex.value["lex_arg"] if isinstance(min_lex, InfBound) else min_lex.value
         )
         max_lex_arg = (
-            max_lex.value["lex_arg"] if type(max_lex) == InfBound else max_lex.value
+            max_lex.value["lex_arg"] if isinstance(max_lex, InfBound) else max_lex.value
         )
 
         return cast(
@@ -4830,7 +5283,7 @@ class CoreCommands(Protocol):
         Both `start` and `end` are zero-based indexes with 0 being the element with the lowest score.
         These indexes can be negative numbers, where they indicate offsets starting at the element with the highest score.
 
-        See https://valkey.io/commands/zremrangebyrank/ for more details.
+        See [valkey.io](https://valkey.io/commands/zremrangebyrank/) for more details.
 
         Args:
             key (TEncodable): The key of the sorted set.
@@ -4839,13 +5292,17 @@ class CoreCommands(Protocol):
 
         Returns:
             int: The number of elements that were removed.
-                If `start` exceeds the end of the sorted set, or if `start` is greater than `end`, `0` is returned.
-                If `end` exceeds the actual end of the sorted set, the range will stop at the actual end of the sorted set.
-                If `key` does not exist, `0` is returned.
+
+            If `start` exceeds the end of the sorted set, or if `start` is greater than `end`, `0` is returned.
+
+            If `end` exceeds the actual end of the sorted set, the range will stop at the actual end of the sorted set.
+
+            If `key` does not exist, `0` is returned.
 
         Examples:
             >>> await client.zremrangebyrank("my_sorted_set", 0, 4)
-                5  # Indicates that 5 elements, with ranks ranging from 0 to 4 (inclusive), have been removed from "my_sorted_set".
+                5  # Indicates that 5 elements, with ranks ranging from 0 to 4 (inclusive), have been removed from
+                   # "my_sorted_set".
             >>> await client.zremrangebyrank("my_sorted_set", 0, 4)
                 0  # Indicates that nothing was removed.
         """
@@ -4863,9 +5320,10 @@ class CoreCommands(Protocol):
         max_lex: Union[InfBound, LexBoundary],
     ) -> int:
         """
-        Returns the number of members in the sorted set stored at `key` with lexicographical values between `min_lex` and `max_lex`.
+        Returns the number of members in the sorted set stored at `key` with lexicographical values between `min_lex` and
+        `max_lex`.
 
-        See https://valkey.io/commands/zlexcount/ for more details.
+        See [valkey.io](https://valkey.io/commands/zlexcount/) for more details.
 
         Args:
             key (TEncodable): The key of the sorted set.
@@ -4878,20 +5336,28 @@ class CoreCommands(Protocol):
 
         Returns:
             int: The number of members in the specified lexicographical range.
-                If `key` does not exist, it is treated as an empty sorted set, and the command returns `0`.
-                If `max_lex < min_lex`, `0` is returned.
+
+            If `key` does not exist, it is treated as an empty sorted set, and the command returns `0`.
+
+            If `max_lex < min_lex`, `0` is returned.
 
         Examples:
             >>> await client.zlexcount("my_sorted_set",  LexBoundary("c" , is_inclusive=True), InfBound.POS_INF)
-                2  # Indicates that there are 2 members with lexicographical values between "c" (inclusive) and positive infinity in the sorted set "my_sorted_set".
-            >>> await client.zlexcount("my_sorted_set", LexBoundary("c" , is_inclusive=True), LexBoundary("k" , is_inclusive=False))
-                1  # Indicates that there is one member with LexBoundary "c" <= lexicographical value < "k" in the sorted set "my_sorted_set".
+                2  # Indicates that there are 2 members with lexicographical values between "c" (inclusive) and positive
+                   # infinity in the sorted set "my_sorted_set".
+            >>> await client.zlexcount(
+            ...     "my_sorted_set",
+            ...     LexBoundary("c" , is_inclusive=True),
+            ...     LexBoundary("k" , is_inclusive=False)
+            ... )
+                1  # Indicates that there is one member with LexBoundary "c" <= lexicographical value < "k" in the sorted set
+                   # "my_sorted_set".
         """
         min_lex_arg = (
-            min_lex.value["lex_arg"] if type(min_lex) == InfBound else min_lex.value
+            min_lex.value["lex_arg"] if isinstance(min_lex, InfBound) else min_lex.value
         )
         max_lex_arg = (
-            max_lex.value["lex_arg"] if type(max_lex) == InfBound else max_lex.value
+            max_lex.value["lex_arg"] if isinstance(max_lex, InfBound) else max_lex.value
         )
 
         return cast(
@@ -4905,7 +5371,7 @@ class CoreCommands(Protocol):
         """
         Returns the score of `member` in the sorted set stored at `key`.
 
-        See https://valkey.io/commands/zscore/ for more details.
+        See [valkey.io](https://valkey.io/commands/zscore/) for more details.
 
         Args:
             key (TEncodable): The key of the sorted set.
@@ -4913,7 +5379,9 @@ class CoreCommands(Protocol):
 
         Returns:
             Optional[float]: The score of the member.
+
             If `member` does not exist in the sorted set, None is returned.
+
             If `key` does not exist,  None is returned.
 
         Examples:
@@ -4935,7 +5403,7 @@ class CoreCommands(Protocol):
         """
         Returns the scores associated with the specified `members` in the sorted set stored at `key`.
 
-        See https://valkey.io/commands/zmscore for more details.
+        See [valkey.io](https://valkey.io/commands/zmscore) for more details.
 
         Args:
             key (TEncodable): The key of the sorted set.
@@ -4943,7 +5411,8 @@ class CoreCommands(Protocol):
 
         Returns:
             List[Optional[float]]: A list of scores corresponding to `members`.
-                If a member does not exist in the sorted set, the corresponding value in the list will be None.
+
+            If a member does not exist in the sorted set, the corresponding value in the list will be None.
 
         Examples:
             >>> await client.zmscore("my_sorted_set", ["one", "non_existent_member", "three"])
@@ -4959,17 +5428,19 @@ class CoreCommands(Protocol):
         Returns the difference between the first sorted set and all the successive sorted sets.
         To get the elements with their scores, see `zdiff_withscores`.
 
-        When in Cluster mode, all keys must map to the same hash slot.
+        Note:
+            When in Cluster mode, all keys must map to the same hash slot.
 
-        See https://valkey.io/commands/zdiff for more details.
+        See [valkey.io](https://valkey.io/commands/zdiff) for more details.
 
         Args:
             keys (List[TEncodable]): The keys of the sorted sets.
 
         Returns:
             List[bytes]: A list of elements representing the difference between the sorted sets.
-                If the first key does not exist, it is treated as an empty sorted set, and the command returns an
-                empty list.
+
+            If the first key does not exist, it is treated as an empty sorted set, and the command returns an
+            empty list.
 
         Examples:
             >>> await client.zadd("sorted_set1", {"element1":1.0, "element2": 2.0, "element3": 3.0})
@@ -4988,18 +5459,21 @@ class CoreCommands(Protocol):
     async def zdiff_withscores(self, keys: List[TEncodable]) -> Mapping[bytes, float]:
         """
         Returns the difference between the first sorted set and all the successive sorted sets, with the associated scores.
-        When in Cluster mode, all keys must map to the same hash slot.
 
-        See https://valkey.io/commands/zdiff for more details.
+        Note:
+            When in Cluster mode, all keys must map to the same hash slot.
+
+        See [valkey.io](https://valkey.io/commands/zdiff) for more details.
 
         Args:
             keys (List[TEncodable]): The keys of the sorted sets.
 
         Returns:
             Mapping[bytes, float]: A mapping of elements and their scores representing the difference between the sorted
-                sets.
-                If the first `key` does not exist, it is treated as an empty sorted set, and the command returns an
-                empty list.
+            sets.
+
+            If the first `key` does not exist, it is treated as an empty sorted set, and the command returns an
+            empty list.
 
         Examples:
             >>> await client.zadd("sorted_set1", {"element1":1.0, "element2": 2.0, "element3": 3.0})
@@ -5020,11 +5494,12 @@ class CoreCommands(Protocol):
         Calculates the difference between the first sorted set and all the successive sorted sets at `keys` and stores
         the difference as a sorted set to `destination`, overwriting it if it already exists. Non-existent keys are
         treated as empty sets.
-        See https://valkey.io/commands/zdiffstore for more details.
 
         Note:
             When in Cluster mode, all keys in `keys` and `destination` must map to the same hash slot.
 
+        See [valkey.io](https://valkey.io/commands/zdiffstore) for more details.
+
         Args:
             destination (TEncodable): The key for the resulting sorted set.
             keys (List[TEncodable]): The keys of the sorted sets to compare.
@@ -5058,9 +5533,10 @@ class CoreCommands(Protocol):
         To get the scores as well, see `zinter_withscores`.
         To store the result in a key as a sorted set, see `zinterstore`.
 
-        When in cluster mode, all keys in `keys` must map to the same hash slot.
+        Note:
+            When in cluster mode, all keys in `keys` must map to the same hash slot.
 
-        See https://valkey.io/commands/zinter/ for more details.
+        See [valkey.io](https://valkey.io/commands/zinter/) for more details.
 
         Args:
             keys (List[TEncodable]): The keys of the sorted sets.
@@ -5087,18 +5563,22 @@ class CoreCommands(Protocol):
         aggregation_type: Optional[AggregationType] = None,
     ) -> Mapping[bytes, float]:
         """
-        Computes the intersection of sorted sets given by the specified `keys` and returns a sorted set of intersecting elements with scores.
+        Computes the intersection of sorted sets given by the specified `keys` and returns a sorted set of intersecting
+        elements with scores.
         To get the elements only, see `zinter`.
         To store the result in a key as a sorted set, see `zinterstore`.
 
-        When in cluster mode, all keys in `keys` must map to the same hash slot.
+        Note:
+            When in cluster mode, all keys in `keys` must map to the same hash slot.
 
-        See https://valkey.io/commands/zinter/ for more details.
+        See [valkey.io](https://valkey.io/commands/zinter/) for more details.
 
         Args:
             keys (Union[List[TEncodable], List[Tuple[TEncodable, float]]]): The keys of the sorted sets with possible formats:
-                List[TEncodable] - for keys only.
-                List[Tuple[TEncodable, float]] - for weighted keys with score multipliers.
+
+                - List[TEncodable] - for keys only.
+                - List[Tuple[TEncodable, float]] - for weighted keys with score multipliers.
+
             aggregation_type (Optional[AggregationType]): Specifies the aggregation strategy to apply
                 when combining the scores of elements. See `AggregationType`.
 
@@ -5131,15 +5611,18 @@ class CoreCommands(Protocol):
         If `destination` already exists, it is overwritten. Otherwise, a new sorted set will be created.
         To get the result directly, see `zinter_withscores`.
 
-        When in cluster mode, `destination` and all keys in `keys` must map to the same hash slot.
+        Note:
+            When in cluster mode, `destination` and all keys in `keys` must map to the same hash slot.
 
-        See https://valkey.io/commands/zinterstore/ for more details.
+        See [valkey.io](https://valkey.io/commands/zinterstore/) for more details.
 
         Args:
             destination (TEncodable): The key of the destination sorted set.
             keys (Union[List[TEncodable], List[Tuple[TEncodable, float]]]): The keys of the sorted sets with possible formats:
-                List[TEncodable] - for keys only.
-                List[Tuple[TEncodable, float]] - for weighted keys with score multipliers.
+
+                - List[TEncodable] - for keys only.
+                - List[Tuple[TEncodable, float]] - for weighted keys with score multipliers.
+
             aggregation_type (Optional[AggregationType]): Specifies the aggregation strategy to apply
                 when combining the scores of elements. See `AggregationType`.
 
@@ -5154,7 +5637,8 @@ class CoreCommands(Protocol):
             >>> await client.zrange_withscores("my_sorted_set", RangeByIndex(0, -1))
                 {b'member1': 20}  # "member1" is now stored in "my_sorted_set" with score of 20.
             >>> await client.zinterstore("my_sorted_set", ["key1", "key2"], AggregationType.MAX)
-                1 # Indicates that the sorted set "my_sorted_set" contains one element, and its score is the maximum score between the sets.
+                1 # Indicates that the sorted set "my_sorted_set" contains one element, and its score is the maximum score
+                  # between the sets.
             >>> await client.zrange_withscores("my_sorted_set", RangeByIndex(0, -1))
                 {b'member1': 10.5}  # "member1" is now stored in "my_sorted_set" with score of 10.5.
         """
@@ -5173,9 +5657,10 @@ class CoreCommands(Protocol):
         To get the scores as well, see `zunion_withscores`.
         To store the result in a key as a sorted set, see `zunionstore`.
 
-        When in cluster mode, all keys in `keys` must map to the same hash slot.
+        Note:
+            When in cluster mode, all keys in `keys` must map to the same hash slot.
 
-        See https://valkey.io/commands/zunion/ for more details.
+        See [valkey.io](https://valkey.io/commands/zunion/) for more details.
 
         Args:
             keys (List[TEncodable]): The keys of the sorted sets.
@@ -5206,14 +5691,17 @@ class CoreCommands(Protocol):
         To get the elements only, see `zunion`.
         To store the result in a key as a sorted set, see `zunionstore`.
 
-        When in cluster mode, all keys in `keys` must map to the same hash slot.
+        Note:
+            When in cluster mode, all keys in `keys` must map to the same hash slot.
 
-        See https://valkey.io/commands/zunion/ for more details.
+        See [valkey.io](https://valkey.io/commands/zunion/) for more details.
 
         Args:
             keys (Union[List[TEncodable], List[Tuple[TEncodable, float]]]): The keys of the sorted sets with possible formats:
-                List[TEncodable] - for keys only.
-                List[Tuple[TEncodable, float]] - for weighted keys with score multipliers.
+
+                - List[TEncodable] - for keys only.
+                - List[Tuple[TEncodable, float]] - for weighted keys with score multipliers.
+
             aggregation_type (Optional[AggregationType]): Specifies the aggregation strategy to apply
                 when combining the scores of elements. See `AggregationType`.
 
@@ -5246,15 +5734,18 @@ class CoreCommands(Protocol):
         If `destination` already exists, it is overwritten. Otherwise, a new sorted set will be created.
         To get the result directly, see `zunion_withscores`.
 
-        When in cluster mode, `destination` and all keys in `keys` must map to the same hash slot.
+        Note:
+            When in cluster mode, `destination` and all keys in `keys` must map to the same hash slot.
 
-        See https://valkey.io/commands/zunionstore/ for more details.
+        See [valkey.io](https://valkey.io/commands/zunionstore/) for more details.
 
         Args:
             destination (TEncodable): The key of the destination sorted set.
             keys (Union[List[TEncodable], List[Tuple[TEncodable, float]]]): The keys of the sorted sets with possible formats:
-                List[TEncodable] - for keys only.
-                List[Tuple[TEncodable, float]] - for weighted keys with score multipliers.
+
+                - List[TEncodable] - for keys only.
+                - List[Tuple[TEncodable, float]] - for weighted keys with score multipliers.
+
             aggregation_type (Optional[AggregationType]): Specifies the aggregation strategy to apply
                 when combining the scores of elements. See `AggregationType`.
 
@@ -5269,7 +5760,8 @@ class CoreCommands(Protocol):
             >>> await client.zrange_withscores("my_sorted_set", RangeByIndex(0, -1))
                 {b'member1': 20, b'member2': 8.2}
             >>> await client.zunionstore("my_sorted_set", ["key1", "key2"], AggregationType.MAX)
-                2 # Indicates that the sorted set "my_sorted_set" contains two elements, and each score is the maximum score between the sets.
+                2 # Indicates that the sorted set "my_sorted_set" contains two elements, and each score is the maximum score
+                  # between the sets.
             >>> await client.zrange_withscores("my_sorted_set", RangeByIndex(0, -1))
                 {b'member1': 10.5, b'member2': 8.2}
         """
@@ -5283,14 +5775,15 @@ class CoreCommands(Protocol):
         """
         Returns a random member from the sorted set stored at 'key'.
 
-        See https://valkey.io/commands/zrandmember for more details.
+        See [valkey.io](https://valkey.io/commands/zrandmember) for more details.
 
         Args:
             key (TEncodable): The key of the sorted set.
 
         Returns:
             Optional[bytes]: A random member from the sorted set.
-                If the sorted set does not exist or is empty, the response will be None.
+
+            If the sorted set does not exist or is empty, the response will be None.
 
         Examples:
             >>> await client.zadd("my_sorted_set", {"member1": 1.0, "member2": 2.0})
@@ -5299,7 +5792,6 @@ class CoreCommands(Protocol):
             >>> await client.zrandmember("non_existing_sorted_set")
                 None  # "non_existing_sorted_set" is not an existing key, so None was returned.
         """
-        args: List[TEncodable] = [key]
         return cast(
             Optional[bytes],
             await self._execute_command(RequestType.ZRandMember, [key]),
@@ -5309,17 +5801,19 @@ class CoreCommands(Protocol):
         """
         Retrieves up to the absolute value of `count` random members from the sorted set stored at 'key'.
 
-        See https://valkey.io/commands/zrandmember for more details.
+        See [valkey.io](https://valkey.io/commands/zrandmember) for more details.
 
         Args:
             key (TEncodable): The key of the sorted set.
             count (int): The number of members to return.
-                If `count` is positive, returns unique members.
-                If `count` is negative, allows for duplicates members.
+
+                - If `count` is positive, returns unique members.
+                - If `count` is negative, allows for duplicates members.
 
         Returns:
             List[bytes]: A list of members from the sorted set.
-                If the sorted set does not exist or is empty, the response will be an empty list.
+
+            If the sorted set does not exist or is empty, the response will be an empty list.
 
         Examples:
             >>> await client.zadd("my_sorted_set", {"member1": 1.0, "member2": 2.0})
@@ -5341,23 +5835,27 @@ class CoreCommands(Protocol):
         Retrieves up to the absolute value of `count` random members along with their scores from the sorted set
         stored at 'key'.
 
-        See https://valkey.io/commands/zrandmember for more details.
+        See [valkey.io](https://valkey.io/commands/zrandmember) for more details.
 
         Args:
             key (TEncodable): The key of the sorted set.
             count (int): The number of members to return.
-                If `count` is positive, returns unique members.
-                If `count` is negative, allows for duplicates members.
+
+                - If `count` is positive, returns unique members.
+                - If `count` is negative, allows for duplicates members.
 
         Returns:
             List[List[Union[bytes, float]]]: A list of `[member, score]` lists, where `member` is a random member from
-                the sorted set and `score` is the associated score.
-                If the sorted set does not exist or is empty, the response will be an empty list.
+            the sorted set and `score` is the associated score.
+
+            If the sorted set does not exist or is empty, the response will be an empty list.
 
         Examples:
             >>> await client.zadd("my_sorted_set", {"member1": 1.0, "member2": 2.0})
             >>> await client.zrandmember_withscores("my_sorted_set", -3)
-                [[b"member1", 1.0], [b"member1", 1.0], [b"member2", 2.0]]  # "member1" and "member2" are random members of "my_sorted_set", and have scores of 1.0 and 2.0, respectively.
+                [[b"member1", 1.0], [b"member1", 1.0], [b"member2", 2.0]]  # "member1" and "member2" are random members of
+                                                                           # "my_sorted_set", and have scores of 1.0 and 2.0,
+                                                                           # respectively.
             >>> await client.zrandmember_withscores("non_existing_sorted_set", 3)
                 []  # "non_existing_sorted_set" is not an existing key, so an empty list was returned.
         """
@@ -5382,7 +5880,7 @@ class CoreCommands(Protocol):
 
         The number of popped elements is the minimum from the sorted set's cardinality and `count`.
 
-        See https://valkey.io/commands/zmpop for more details.
+        See [valkey.io](https://valkey.io/commands/zmpop) for more details.
 
         Note:
             When in cluster mode, all `keys` must map to the same hash slot.
@@ -5395,14 +5893,16 @@ class CoreCommands(Protocol):
 
         Returns:
             Optional[List[Union[bytes, Mapping[bytes, float]]]]: A two-element list containing the key name of the set from
-                which elements were popped, and a member-score mapping of the popped elements. If no members could be
-                popped, returns None.
+            which elements were popped, and a member-score mapping of the popped elements.
+
+            If no members could be popped, returns None.
 
         Examples:
             >>> await client.zadd("zSet1", {"one": 1.0, "two": 2.0, "three": 3.0})
             >>> await client.zadd("zSet2", {"four": 4.0})
             >>> await client.zmpop(["zSet1", "zSet2"], ScoreFilter.MAX, 2)
-                [b'zSet1', {b'three': 3.0, b'two': 2.0}]  # "three" with score 3.0 and "two" with score 2.0 were popped from "zSet1".
+                [b'zSet1', {b'three': 3.0, b'two': 2.0}]  # "three" with score 3.0 and "two" with score 2.0 were
+                                                          # popped from "zSet1".
 
         Since: Valkey version 7.0.0.
         """
@@ -5432,11 +5932,13 @@ class CoreCommands(Protocol):
 
         `BZMPOP` is the blocking variant of `ZMPOP`.
 
-        See https://valkey.io/commands/bzmpop for more details.
+        See [valkey.io](https://valkey.io/commands/bzmpop) for more details.
 
         Notes:
             1. When in cluster mode, all `keys` must map to the same hash slot.
-            2. `BZMPOP` is a client blocking command, see https://github.com/valkey-io/valkey-glide/wiki/General-Concepts#blocking-commands for more details and best practices.
+            2. `BZMPOP` is a client blocking command, see
+               [blocking commands](https://github.com/valkey-io/valkey-glide/wiki/General-Concepts#blocking-commands)
+               for more details and best practices.
 
         Args:
             keys (List[TEncodable]): The keys of the sorted sets.
@@ -5448,14 +5950,16 @@ class CoreCommands(Protocol):
 
         Returns:
             Optional[List[Union[bytes, Mapping[bytes, float]]]]: A two-element list containing the key name of the set from
-                which elements were popped, and a member-score mapping of the popped elements. If no members could be
-                popped and the timeout expired, returns None.
+            which elements were popped, and a member-score mapping of the popped elements.
+
+            If no members could be popped and the timeout expired, returns None.
 
         Examples:
             >>> await client.zadd("zSet1", {"one": 1.0, "two": 2.0, "three": 3.0})
             >>> await client.zadd("zSet2", {"four": 4.0})
             >>> await client.bzmpop(["zSet1", "zSet2"], ScoreFilter.MAX, 0.5, 2)
-                [b'zSet1', {b'three': 3.0, b'two': 2.0}]  # "three" with score 3.0 and "two" with score 2.0 were popped from "zSet1".
+                [b'zSet1', {b'three': 3.0, b'two': 2.0}]  # "three" with score 3.0 and "two" with score 2.0 were
+                                                          # popped from "zSet1".
 
         Since: Valkey version 7.0.0.
         """
@@ -5476,16 +5980,16 @@ class CoreCommands(Protocol):
         optional `limit` argument, if the intersection cardinality reaches `limit` partway through the computation, the
         algorithm will exit early and yield `limit` as the cardinality.
 
-        See https://valkey.io/commands/zintercard for more details.
+        Note:
+            When in cluster mode, all `keys` must map to the same hash slot.
+
+        See [valkey.io](https://valkey.io/commands/zintercard) for more details.
 
         Args:
             keys (List[TEncodable]): The keys of the sorted sets to intersect.
             limit (Optional[int]): An optional argument that can be used to specify a maximum number for the
                 intersection cardinality. If limit is not supplied, or if it is set to 0, there will be no limit.
 
-        Note:
-            When in cluster mode, all `keys` must map to the same hash slot.
-
         Returns:
             int: The cardinality of the intersection of the given sorted sets, or the `limit` if reached.
 
@@ -5495,7 +5999,8 @@ class CoreCommands(Protocol):
             >>> await client.zintercard(["key1", "key2"])
                 2  # Indicates that the intersection of the sorted sets at "key1" and "key2" has a cardinality of 2.
             >>> await client.zintercard(["key1", "key2"], 1)
-                1  # A `limit` of 1 was provided, so the intersection computation exits early and yields the `limit` value of 1.
+                1  # A `limit` of 1 was provided, so the intersection computation exits early and yields the `limit` value
+                   # of 1.
 
         Since: Valkey version 7.0.0.
         """
@@ -5512,14 +6017,15 @@ class CoreCommands(Protocol):
         """
         Returns the original source code of a script in the script cache.
 
-        See https://valkey.io/commands/script-show for more details.
+        See [valkey.io](https://valkey.io/commands/script-show) for more details.
 
         Args:
             sha1 (TEncodable): The SHA1 digest of the script.
 
         Returns:
             bytes: The original source code of the script, if present in the cache.
-                If the script is not found in the cache, an error is thrown.
+
+            If the script is not found in the cache, an error is thrown.
 
         Example:
             >>> await client.script_show(script.get_hash())
@@ -5535,7 +6041,7 @@ class CoreCommands(Protocol):
         Creates a new structure if the `key` does not exist.
         When no elements are provided, and `key` exists and is a HyperLogLog, then no operation is performed.
 
-        See https://valkey.io/commands/pfadd/ for more details.
+        See [valkey.io](https://valkey.io/commands/pfadd/) for more details.
 
         Args:
             key (TEncodable): The key of the HyperLogLog data structure to add elements into.
@@ -5543,7 +6049,9 @@ class CoreCommands(Protocol):
 
         Returns:
             int: If the HyperLogLog is newly created, or if the HyperLogLog approximated cardinality is
-            altered, then returns 1. Otherwise, returns 0.
+            altered, then returns 1.
+
+            Otherwise, returns 0.
 
         Examples:
             >>> await client.pfadd("hll_1", ["a", "b", "c" ])
@@ -5561,7 +6069,7 @@ class CoreCommands(Protocol):
         Estimates the cardinality of the data stored in a HyperLogLog structure for a single key or
         calculates the combined cardinality of multiple keys by merging their HyperLogLogs temporarily.
 
-        See https://valkey.io/commands/pfcount for more details.
+        See [valkey.io](https://valkey.io/commands/pfcount) for more details.
 
         Note:
             When in Cluster mode, all `keys` must map to the same hash slot.
@@ -5571,7 +6079,8 @@ class CoreCommands(Protocol):
 
         Returns:
             int: The approximated cardinality of given HyperLogLog data structures.
-                The cardinality of a key that does not exist is 0.
+
+            The cardinality of a key that does not exist is 0.
 
         Examples:
             >>> await client.pfcount(["hll_1", "hll_2"])
@@ -5589,7 +6098,7 @@ class CoreCommands(Protocol):
         Merges multiple HyperLogLog values into a unique value. If the destination variable exists, it is treated as one
         of the source HyperLogLog data sets, otherwise a new HyperLogLog is created.
 
-        See https://valkey.io/commands/pfmerge for more details.
+        See [valkey.io](https://valkey.io/commands/pfmerge) for more details.
 
         Note:
             When in Cluster mode, all keys in `source_keys` and `destination` must map to the same hash slot.
@@ -5623,7 +6132,7 @@ class CoreCommands(Protocol):
         Counts the number of set bits (population counting) in the string stored at `key`. The `options` argument can
         optionally be provided to count the number of bits in a specific string interval.
 
-        See https://valkey.io/commands/bitcount for more details.
+        See [valkey.io](https://valkey.io/commands/bitcount) for more details.
 
         Args:
             key (TEncodable): The key for the string to count the set bits of.
@@ -5631,8 +6140,10 @@ class CoreCommands(Protocol):
 
         Returns:
             int: If `options` is provided, returns the number of set bits in the string interval specified by `options`.
-                If `options` is not provided, returns the number of set bits in the string stored at `key`.
-                Otherwise, if `key` is missing, returns `0` as it is treated as an empty string.
+
+            If `options` is not provided, returns the number of set bits in the string stored at `key`.
+
+            Otherwise, if `key` is missing, returns `0` as it is treated as an empty string.
 
         Examples:
             >>> await client.bitcount("my_key1")
@@ -5662,7 +6173,7 @@ class CoreCommands(Protocol):
         than `2^32` and greater than or equal to `0`. If a key is non-existent then the bit at `offset` is set to
         `value` and the preceding bits are set to `0`.
 
-        See https://valkey.io/commands/setbit for more details.
+        See [valkey.io](https://valkey.io/commands/setbit) for more details.
 
         Args:
             key (TEncodable): The key of the string.
@@ -5688,15 +6199,16 @@ class CoreCommands(Protocol):
         Returns the bit value at `offset` in the string value stored at `key`.
         `offset` should be greater than or equal to zero.
 
-        See https://valkey.io/commands/getbit for more details.
+        See [valkey.io](https://valkey.io/commands/getbit) for more details.
 
         Args:
             key (TEncodable): The key of the string.
             offset (int): The index of the bit to return.
 
         Returns:
-            int: The bit at the given `offset` of the string. Returns `0` if the key is empty or if the `offset` exceeds
-                the length of the string.
+            int: The bit at the given `offset` of the string.
+
+            Returns `0` if the key is empty or if the `offset` exceeds the length of the string.
 
         Examples:
             >>> await client.getbit("my_key", 1)
@@ -5721,7 +6233,7 @@ class CoreCommands(Protocol):
         are assumed. If BIT is specified, `start=0` and `end=2` means to look at the first three bits. If BYTE is
         specified, `start=0` and `end=2` means to look at the first three bytes.
 
-        See https://valkey.io/commands/bitpos for more details.
+        See [valkey.io](https://valkey.io/commands/bitpos) for more details.
 
         Args:
             key (TEncodable): The key of the string.
@@ -5730,20 +6242,24 @@ class CoreCommands(Protocol):
 
         Returns:
             int: The position of the first occurrence of `bit` in the binary value of the string held at `key`.
-                If `start` was provided, the search begins at the offset indicated by `start`.
+
+            If `start` was provided, the search begins at the offset indicated by `start`.
 
         Examples:
             >>> await client.set("key1", "A1")  # "A1" has binary value 01000001 00110001
             >>> await client.bitpos("key1", 1)
                 1  # The first occurrence of bit value 1 in the string stored at "key1" is at the second position.
             >>> await client.bitpos("key1", 1, OffsetOptions(-1))
-                10  # The first occurrence of bit value 1, starting at the last byte in the string stored at "key1", is at the eleventh position.
+                10  # The first occurrence of bit value 1, starting at the last byte in the string stored at "key1",
+                    # is at the eleventh position.
 
             >>> await client.set("key2", "A12")  # "A12" has binary value 01000001 00110001 00110010
             >>> await client.bitpos("key2", 1, OffsetOptions(1, -1))
-                10  # The first occurrence of bit value 1 in the second byte to the last byte of the string stored at "key1" is at the eleventh position.
+                10  # The first occurrence of bit value 1 in the second byte to the last byte of the string stored at "key1"
+                    # is at the eleventh position.
             >>> await client.bitpos("key2", 1, OffsetOptions(2, 9, BitmapIndexType.BIT))
-                7  # The first occurrence of bit value 1 in the third to tenth bits of the string stored at "key1" is at the eighth position.
+                7  # The first occurrence of bit value 1 in the third to tenth bits of the string stored at "key1"
+                   # is at the eighth position.
         """
         args: List[TEncodable] = [key, str(bit)]
         if options is not None:
@@ -5764,7 +6280,7 @@ class CoreCommands(Protocol):
         Perform a bitwise operation between multiple keys (containing string values) and store the result in the
         `destination`.
 
-        See https://valkey.io/commands/bitop for more details.
+        See [valkey.io](https://valkey.io/commands/bitop) for more details.
 
         Note:
             When in cluster mode, `destination` and all `keys` must map to the same hash slot.
@@ -5799,12 +6315,13 @@ class CoreCommands(Protocol):
         Reads or modifies the array of bits representing the string that is held at `key` based on the specified
         `subcommands`.
 
-        See https://valkey.io/commands/bitfield for more details.
+        See [valkey.io](https://valkey.io/commands/bitfield) for more details.
 
         Args:
             key (TEncodable): The key of the string.
             subcommands (List[BitFieldSubCommands]): The subcommands to be performed on the binary value of the string
                 at `key`, which could be any of the following:
+
                     - `BitFieldGet`
                     - `BitFieldSet`
                     - `BitFieldIncrBy`
@@ -5812,6 +6329,7 @@ class CoreCommands(Protocol):
 
         Returns:
             List[Optional[int]]: An array of results from the executed subcommands:
+
                 - `BitFieldGet` returns the value in `BitOffset` or `BitOffsetMultiplier`.
                 - `BitFieldSet` returns the old value in `BitOffset` or `BitOffsetMultiplier`.
                 - `BitFieldIncrBy` returns the new value in `BitOffset` or `BitOffsetMultiplier`.
@@ -5821,8 +6339,12 @@ class CoreCommands(Protocol):
 
         Examples:
             >>> await client.set("my_key", "A")  # "A" has binary value 01000001
-            >>> await client.bitfield("my_key", [BitFieldSet(UnsignedEncoding(2), BitOffset(1), 3), BitFieldGet(UnsignedEncoding(2), BitOffset(1))])
-                [2, 3]  # The old value at offset 1 with an unsigned encoding of 2 was 2. The new value at offset 1 with an unsigned encoding of 2 is 3.
+            >>> await client.bitfield(
+            ...     "my_key",
+            ...     [BitFieldSet(UnsignedEncoding(2), BitOffset(1), 3), BitFieldGet(UnsignedEncoding(2), BitOffset(1))]
+            ... )
+                [2, 3]  # The old value at offset 1 with an unsigned encoding of 2 was 2. The new value at offset 1 with an
+                        # unsigned encoding of 2 is 3.
         """
         args = [key] + _create_bitfield_args(subcommands)
         return cast(
@@ -5836,7 +6358,7 @@ class CoreCommands(Protocol):
         """
         Reads the array of bits representing the string that is held at `key` based on the specified `subcommands`.
 
-        See https://valkey.io/commands/bitfield_ro for more details.
+        See [valkey.io](https://valkey.io/commands/bitfield_ro) for more details.
 
         Args:
             key (TEncodable): The key of the string.
@@ -5862,14 +6384,16 @@ class CoreCommands(Protocol):
         """
         Returns the internal encoding for the Valkey object stored at `key`.
 
-        See https://valkey.io/commands/object-encoding for more details.
+        See [valkey.io](https://valkey.io/commands/object-encoding) for more details.
 
         Args:
             key (TEncodable): The `key` of the object to get the internal encoding of.
 
         Returns:
             Optional[bytes]: If `key` exists, returns the internal encoding of the object stored at
-                `key` as a bytes string. Otherwise, returns None.
+            `key` as a bytes string.
+
+            Otherwise, returns None.
 
         Examples:
             >>> await client.object_encoding("my_hash")
@@ -5884,14 +6408,16 @@ class CoreCommands(Protocol):
         """
         Returns the logarithmic access frequency counter of a Valkey object stored at `key`.
 
-        See https://valkey.io/commands/object-freq for more details.
+        See [valkey.io](https://valkey.io/commands/object-freq) for more details.
 
         Args:
             key (TEncodable): The key of the object to get the logarithmic access frequency counter of.
 
         Returns:
-            Optional[int]: If `key` exists, returns the logarithmic access frequency counter of the object stored at `key` as an
-                integer. Otherwise, returns None.
+            Optional[int]: If `key` exists, returns the logarithmic access frequency counter of the object stored at `key` as
+            an integer.
+
+            Otherwise, returns None.
 
         Examples:
             >>> await client.object_freq("my_hash")
@@ -5906,13 +6432,15 @@ class CoreCommands(Protocol):
         """
         Returns the time in seconds since the last access to the value stored at `key`.
 
-        See https://valkey.io/commands/object-idletime for more details.
+        See [valkey.io](https://valkey.io/commands/object-idletime) for more details.
 
         Args:
             key (TEncodable): The key of the object to get the idle time of.
 
         Returns:
-            Optional[int]: If `key` exists, returns the idle time in seconds. Otherwise, returns None.
+            Optional[int]: If `key` exists, returns the idle time in seconds.
+
+            Otherwise, returns None.
 
         Examples:
             >>> await client.object_idletime("my_hash")
@@ -5927,14 +6455,15 @@ class CoreCommands(Protocol):
         """
         Returns the reference count of the object stored at `key`.
 
-        See https://valkey.io/commands/object-refcount for more details.
+        See [valkey.io](https://valkey.io/commands/object-refcount) for more details.
 
         Args:
             key (TEncodable): The key of the object to get the reference count of.
 
         Returns:
             Optional[int]: If `key` exists, returns the reference count of the object stored at `key` as an integer.
-                Otherwise, returns None.
+
+            Otherwise, returns None.
 
         Examples:
             >>> await client.object_refcount("my_hash")
@@ -5949,13 +6478,15 @@ class CoreCommands(Protocol):
         """
         Returns a random element from the set value stored at 'key'.
 
-        See https://valkey.io/commands/srandmember for more details.
+        See [valkey.io](https://valkey.io/commands/srandmember) for more details.
 
         Args:
             key (TEncodable): The key from which to retrieve the set member.
 
         Returns:
-            Optional[bytes]: A random element from the set, or None if 'key' does not exist.
+            Optional[bytes]: A random element from the set.
+
+            `None` if 'key' does not exist.
 
         Examples:
             >>> await client.sadd("my_set", {"member1": 1.0, "member2": 2.0})
@@ -5974,17 +6505,19 @@ class CoreCommands(Protocol):
         """
         Returns one or more random elements from the set value stored at 'key'.
 
-        See https://valkey.io/commands/srandmember for more details.
+        See [valkey.io](https://valkey.io/commands/srandmember) for more details.
 
         Args:
             key (TEncodable): The key of the sorted set.
             count (int): The number of members to return.
-                If `count` is positive, returns unique members.
-                If `count` is negative, allows for duplicates members.
+
+                - If `count` is positive, returns unique members.
+                - If `count` is negative, allows for duplicates members.
 
         Returns:
             List[bytes]: A list of members from the set.
-                If the set does not exist or is empty, the response will be an empty list.
+
+            If the set does not exist or is empty, the response will be an empty list.
 
         Examples:
             >>> await client.sadd("my_set", {"member1": 1.0, "member2": 2.0})
@@ -6005,7 +6538,8 @@ class CoreCommands(Protocol):
     ) -> Optional[bytes]:
         """
         Get the value of `key` and optionally set its expiration. `GETEX` is similar to `GET`.
-        See https://valkey.io/commands/getex for more details.
+
+        See [valkey.io](https://valkey.io/commands/getex) for more details.
 
         Args:
             key (TEncodable): The key to get.
@@ -6013,9 +6547,9 @@ class CoreCommands(Protocol):
                 Equivalent to [`EX` | `PX` | `EXAT` | `PXAT` | `PERSIST`] in the Valkey API.
 
         Returns:
-            Optional[bytes]:
-                If `key` exists, return the value stored at `key`
-                If `key` does not exist, return `None`
+            Optional[bytes]: If `key` exists, return the value stored at `key`
+
+            If `key` does not exist, return `None`
 
         Examples:
             >>> await client.set("key", "value")
@@ -6045,14 +6579,15 @@ class CoreCommands(Protocol):
         """
         Serialize the value stored at `key` in a Valkey-specific format and return it to the user.
 
-        See https://valkey.io/commands/dump for more details.
+        See [valkey.io](https://valkey.io/commands/dump) for more details.
 
         Args:
             key (TEncodable): The `key` to serialize.
 
         Returns:
             Optional[bytes]: The serialized value of the data stored at `key`.
-                If `key` does not exist, `None` will be returned.
+
+            If `key` does not exist, `None` will be returned.
 
         Examples:
             >>> await client.dump("key")
@@ -6079,14 +6614,15 @@ class CoreCommands(Protocol):
         Create a `key` associated with a `value` that is obtained by deserializing the provided
         serialized `value` obtained via `dump`.
 
-        See https://valkey.io/commands/restore for more details.
+        See [valkey.io](https://valkey.io/commands/restore) for more details.
 
-        Note: `IDLETIME` and `FREQ` modifiers cannot be set at the same time.
+        Note:
+            `IDLETIME` and `FREQ` modifiers cannot be set at the same time.
 
         Args:
             key (TEncodable): The `key` to create.
             ttl (int): The expiry time (in milliseconds). If `0`, the `key` will persist.
-            value (TEncodable) The serialized value to deserialize and assign to `key`.
+            value (TEncodable): The serialized value to deserialize and assign to `key`.
             replace (bool): Set to `True` to replace the key if it exists.
             absttl (bool): Set to `True` to specify that `ttl` represents an absolute Unix
                 timestamp (in milliseconds).
@@ -6132,29 +6668,30 @@ class CoreCommands(Protocol):
         """
         Iterates incrementally over a set.
 
-        See https://valkey.io/commands/sscan for more details.
+        See [valkey.io](https://valkey.io/commands/sscan) for more details.
 
         Args:
             key (TEncodable): The key of the set.
             cursor (TEncodable): The cursor that points to the next iteration of results. A value of "0" indicates the start of
                 the search.
             match (Optional[TEncodable]): The match filter is applied to the result of the command and will only include
-                strings or byte strings that match the pattern specified. If the set is large enough for scan commands to return only a
-                subset of the set then there could be a case where the result is empty although there are items that
-                match the pattern specified. This is due to the default `COUNT` being `10` which indicates that it will
-                only fetch and match `10` items from the list.
+                strings or byte strings that match the pattern specified. If the set is large enough for scan commands to
+                return only a subset of the set then there could be a case where the result is empty although there are
+                items that match the pattern specified. This is due to the default `COUNT` being `10` which indicates
+                that it will only fetch and match `10` items from the list.
             count (Optional[int]): `COUNT` is a just a hint for the command for how many elements to fetch from the set.
                 `COUNT` could be ignored until the set is large enough for the `SCAN` commands to represent the results
                 as compact single-allocation packed encoding.
 
         Returns:
             List[Union[bytes, List[bytes]]]: An `Array` of the `cursor` and the subset of the set held by `key`.
-                The first element is always the `cursor` for the next iteration of results. `0` will be the `cursor`
-                returned on the last iteration of the set. The second element is always an `Array` of the subset of the
-                set held in `key`.
+            The first element is always the `cursor` for the next iteration of results. `0` will be the `cursor`
+            returned on the last iteration of the set. The second element is always an `Array` of the subset of the
+            set held in `key`.
 
         Examples:
-            # Assume "key" contains a set with 130 members
+            Assume "key" contains a set with 130 members:
+
             >>> result_cursor = "0"
             >>> while True:
             ...     result = await client.sscan("key", "0", match="*")
@@ -6193,16 +6730,16 @@ class CoreCommands(Protocol):
         """
         Iterates incrementally over a sorted set.
 
-        See https://valkey.io/commands/zscan for more details.
+        See [valkey.io](https://valkey.io/commands/zscan) for more details.
 
         Args:
             key (TEncodable): The key of the sorted set.
             cursor (TEncodable): The cursor that points to the next iteration of results. A value of "0" indicates the start of
                 the search.
             match (Optional[TEncodable]): The match filter is applied to the result of the command and will only include
-                strings or byte strings that match the pattern specified. If the sorted set is large enough for scan commands to return
-                only a subset of the sorted set then there could be a case where the result is empty although there are
-                items that match the pattern specified. This is due to the default `COUNT` being `10` which indicates
+                strings or byte strings that match the pattern specified. If the sorted set is large enough for scan commands
+                to return only a subset of the sorted set then there could be a case where the result is empty although there
+                are items that match the pattern specified. This is due to the default `COUNT` being `10` which indicates
                 that it will only fetch and match `10` items from the list.
             count (Optional[int]): `COUNT` is a just a hint for the command for how many elements to fetch from the
                 sorted set. `COUNT` could be ignored until the sorted set is large enough for the `SCAN` commands to
@@ -6215,10 +6752,12 @@ class CoreCommands(Protocol):
             returned on the last iteration of the sorted set. The second element is always an `Array` of the subset
             of the sorted set held in `key`. The `Array` in the second element is a flattened series of
             `String` pairs, where the value is at even indices and the score is at odd indices.
-            If `no_scores` is set to`True`, the second element will only contain the members without scores.
+
+            If `no_scores` is set to `True`, the second element will only contain the members without scores.
 
         Examples:
-            # Assume "key" contains a sorted set with multiple members
+            Assume "key" contains a sorted set with multiple members:
+
             >>> result_cursor = "0"
             >>> while True:
             ...     result = await client.zscan("key", "0", match="*", count=5)
@@ -6235,7 +6774,8 @@ class CoreCommands(Protocol):
             Cursor: 0
             Members: [b'value 55', b'55', b'value 24', b'24', b'value 90', b'90', b'value 113', b'113']
 
-            # Using no-score
+            Using no-score:
+
             >>> result_cursor = "0"
             >>> while True:
             ...     result = await client.zscan("key", "0", match="*", count=5, no_scores=True)
@@ -6276,17 +6816,17 @@ class CoreCommands(Protocol):
         """
         Iterates incrementally over a hash.
 
-        See https://valkey.io/commands/hscan for more details.
+        See [valkey.io](https://valkey.io/commands/hscan) for more details.
 
         Args:
             key (TEncodable): The key of the set.
             cursor (TEncodable): The cursor that points to the next iteration of results. A value of "0" indicates the start of
                 the search.
             match (Optional[TEncodable]): The match filter is applied to the result of the command and will only include
-                strings or byte strings that match the pattern specified. If the hash is large enough for scan commands to return only a
-                subset of the hash then there could be a case where the result is empty although there are items that
-                match the pattern specified. This is due to the default `COUNT` being `10` which indicates that it will
-                only fetch and match `10` items from the list.
+                strings or byte strings that match the pattern specified. If the hash is large enough for scan commands to
+                return only a subset of the hash then there could be a case where the result is empty although there are
+                items that match the pattern specified. This is due to the default `COUNT` being `10` which indicates that it
+                will only fetch and match `10` items from the list.
             count (Optional[int]): `COUNT` is a just a hint for the command for how many elements to fetch from the hash.
                 `COUNT` could be ignored until the hash is large enough for the `SCAN` commands to represent the results
                 as compact single-allocation packed encoding.
@@ -6294,14 +6834,16 @@ class CoreCommands(Protocol):
 
         Returns:
             List[Union[bytes, List[bytes]]]: An `Array` of the `cursor` and the subset of the hash held by `key`.
-                The first element is always the `cursor` for the next iteration of results. `0` will be the `cursor`
-                returned on the last iteration of the hash. The second element is always an `Array` of the subset of the
-                hash held in `key`. The `Array` in the second element is a flattened series of `String` pairs,
-                where the value is at even indices and the score is at odd indices.
-                If `no_values` is set to `True`, the second element will only contain the fields without the values.
+            The first element is always the `cursor` for the next iteration of results. `0` will be the `cursor`
+            returned on the last iteration of the hash. The second element is always an `Array` of the subset of the
+            hash held in `key`. The `Array` in the second element is a flattened series of `String` pairs,
+            where the value is at even indices and the score is at odd indices.
+
+            If `no_values` is set to `True`, the second element will only contain the fields without the values.
 
         Examples:
-            # Assume "key" contains a hash with multiple members
+            Assume "key" contains a hash with multiple members:
+
             >>> result_cursor = "0"
             >>> while True:
             ...     result = await client.hscan("key", "0", match="*", count=3)
@@ -6318,7 +6860,8 @@ class CoreCommands(Protocol):
             Cursor: 0
             Members: [b'field 420', b'value 420', b'field 221', b'value 221']
 
-            # Use no-values
+            Use no-values:
+
             >>> result_cursor = "0"
             >>> while True:
             ...     result = await client.hscan("key", "0", match="*", count=3, no_values=True)
@@ -6356,8 +6899,12 @@ class CoreCommands(Protocol):
     ) -> TResult:
         """
         Invokes a previously loaded function.
-        See https://valkey.io/commands/fcall/ for more details.
-        When in cluster mode, all keys in `keys` must map to the same hash slot.
+
+        See [valkey.io](https://valkey.io/commands/fcall/) for more details.
+
+        Note:
+            When in cluster mode, all keys in `keys` must map to the same hash slot.
+
         Args:
             function (TEncodable): The function name.
             keys (Optional[List[TEncodable]]): A list of keys accessed by the function. To ensure the correct
@@ -6365,9 +6912,10 @@ class CoreCommands(Protocol):
                 that a function accesses must be explicitly provided as `keys`.
             arguments (Optional[List[TEncodable]]): A list of `function` arguments. `Arguments`
                 should not represent names of keys.
+
         Returns:
-            TResult:
-                The invoked function's return value.
+            TResult: The invoked function's return value.
+
         Example:
             >>> await client.fcall("Deep_Thought")
                 b'new_value' # Returns the function's return value.
@@ -6395,9 +6943,10 @@ class CoreCommands(Protocol):
         """
         Invokes a previously loaded read-only function.
 
-        See https://valkey.io/commands/fcall_ro for more details.
+        See [valkey.io](https://valkey.io/commands/fcall_ro) for more details.
 
-        When in cluster mode, all keys in `keys` must map to the same hash slot.
+        Note:
+            When in cluster mode, all keys in `keys` must map to the same hash slot.
 
         Args:
             function (TEncodable): The function name.
@@ -6431,11 +6980,11 @@ class CoreCommands(Protocol):
 
     async def watch(self, keys: List[TEncodable]) -> TOK:
         """
-        Marks the given keys to be watched for conditional execution of a transaction. Transactions
-        will only execute commands if the watched keys are not modified before execution of the
+        Marks the given keys to be watched for conditional execution of an atomic batch (Transaction).
+        Transactions will only execute commands if the watched keys are not modified before execution of the
         transaction.
 
-        See https://valkey.io/commands/watch for more details.
+        See [valkey.io](https://valkey.io/commands/watch) for more details.
 
         Note:
             In cluster mode, if keys in `key_value_map` map to different hash slots,
@@ -6492,10 +7041,11 @@ class CoreCommands(Protocol):
         """
         Returns the next pubsub message.
         Throws WrongConfiguration in cases:
-        1. No pubsub subscriptions are configured for the client
-        2. Callback is configured with the pubsub subsciptions
 
-        See https://valkey.io/docs/topics/pubsub/ for more details.
+            1. No pubsub subscriptions are configured for the client
+            2. Callback is configured with the pubsub subsciptions
+
+        See [valkey.io](https://valkey.io/docs/topics/pubsub/) for more details.
 
         Returns:
             PubSubMsg: The next pubsub message
@@ -6509,10 +7059,11 @@ class CoreCommands(Protocol):
         """
         Tries to return the next pubsub message.
         Throws WrongConfiguration in cases:
-        1. No pubsub subscriptions are configured for the client
-        2. Callback is configured with the pubsub subsciptions
 
-        See https://valkey.io/docs/topics/pubsub/ for more details.
+            1. No pubsub subscriptions are configured for the client
+            2. Callback is configured with the pubsub subsciptions
+
+        See [valkey.io](https://valkey.io/docs/topics/pubsub/) for more details.
 
         Returns:
             Optional[PubSubMsg]: The next pubsub message or None
@@ -6530,20 +7081,22 @@ class CoreCommands(Protocol):
         """
         Returns the longest common subsequence between strings stored at key1 and key2.
 
-        Note that this is different than the longest common string algorithm, since
-        matching characters in the two strings do not need to be contiguous.
+        Note:
+            This is different than the longest common string algorithm, since
+            matching characters in the two strings do not need to be contiguous.
 
-        For instance the LCS between "foo" and "fao" is "fo", since scanning the two strings
-        from left to right, the longest common set of characters is composed of the first "f" and then the "o".
+            For instance the LCS between "foo" and "fao" is "fo", since scanning the two strings
+            from left to right, the longest common set of characters is composed of the first "f" and then the "o".
 
-        See https://valkey.io/commands/lcs for more details.
+        See [valkey.io](https://valkey.io/commands/lcs) for more details.
 
         Args:
             key1 (TEncodable): The key that stores the first string.
             key2 (TEncodable): The key that stores the second string.
 
         Returns:
-            A Bytes String containing the longest common subsequence between the 2 strings.
+            bytes: A Bytes String containing the longest common subsequence between the 2 strings.
+
             An empty String is returned if the keys do not exist or have no common subsequences.
 
         Examples:
@@ -6569,13 +7122,14 @@ class CoreCommands(Protocol):
         """
         Returns the length of the longest common subsequence between strings stored at key1 and key2.
 
-        Note that this is different than the longest common string algorithm, since
-        matching characters in the two strings do not need to be contiguous.
+        Note:
+            This is different than the longest common string algorithm, since
+            matching characters in the two strings do not need to be contiguous.
 
-        For instance the LCS between "foo" and "fao" is "fo", since scanning the two strings
-        from left to right, the longest common set of characters is composed of the first "f" and then the "o".
+            For instance the LCS between "foo" and "fao" is "fo", since scanning the two strings
+            from left to right, the longest common set of characters is composed of the first "f" and then the "o".
 
-        See https://valkey.io/commands/lcs for more details.
+        See [valkey.io](https://valkey.io/commands/lcs) for more details.
 
         Args:
             key1 (TEncodable): The key that stores the first string value.
@@ -6609,13 +7163,14 @@ class CoreCommands(Protocol):
         """
         Returns the indices and length of the longest common subsequence between strings stored at key1 and key2.
 
-        Note that this is different than the longest common string algorithm, since
-        matching characters in the two strings do not need to be contiguous.
+        Note:
+            This is different than the longest common string algorithm, since
+            matching characters in the two strings do not need to be contiguous.
 
-        For instance the LCS between "foo" and "fao" is "fo", since scanning the two strings
-        from left to right, the longest common set of characters is composed of the first "f" and then the "o".
+            For instance the LCS between "foo" and "fao" is "fo", since scanning the two strings
+            from left to right, the longest common set of characters is composed of the first "f" and then the "o".
 
-        See https://valkey.io/commands/lcs for more details.
+        See [valkey.io](https://valkey.io/commands/lcs) for more details.
 
         Args:
             key1 (TEncodable): The key that stores the first string value.
@@ -6627,6 +7182,7 @@ class CoreCommands(Protocol):
             A Mapping containing the indices of the longest common subsequence between the
             2 strings and the length of the longest common subsequence. The resulting map contains two
             keys, "matches" and "len":
+
                 - "len" is mapped to the length of the longest common subsequence between the 2 strings.
                 - "matches" is mapped to a three dimensional int array that stores pairs of indices that
                   represent the location of the common subsequences in the strings held by key1 and key2,
@@ -6704,7 +7260,7 @@ class CoreCommands(Protocol):
         Returns the index or indexes of element(s) matching `element` in the `key` list. If no match is found,
         None is returned.
 
-        See https://valkey.io/commands/lpos for more details.
+        See [valkey.io](https://valkey.io/commands/lpos) for more details.
 
         Args:
             key (TEncodable): The name of the list.
@@ -6712,11 +7268,13 @@ class CoreCommands(Protocol):
             rank (Optional[int]): The rank of the match to return.
             count (Optional[int]): The number of matches wanted. A `count` of 0 returns all the matches.
             max_len (Optional[int]): The maximum number of comparisons to make between the element and the items
-                                     in the list. A `max_len` of 0 means unlimited amount of comparisons.
+                in the list. A `max_len` of 0 means unlimited amount of comparisons.
 
         Returns:
-            Union[int, List[int], None]: The index of the first occurrence of `element`,
-            or None if `element` is not in the list.
+            Union[int, List[int], None]: The index of the first occurrence of `element`.
+
+            `None` if `element` is not in the list.
+
             With the `count` option, a list of indices of matching elements will be returned.
 
         Examples:
@@ -6757,15 +7315,16 @@ class CoreCommands(Protocol):
         Lists the currently active channels.
         The command is routed to all nodes, and aggregates the response to a single array.
 
-        See https://valkey.io/commands/pubsub-channels for more details.
+        See [valkey.io](https://valkey.io/commands/pubsub-channels) for more details.
 
         Args:
             pattern (Optional[TEncodable]): A glob-style pattern to match active channels.
-                                If not provided, all active channels are returned.
+                If not provided, all active channels are returned.
 
         Returns:
             List[bytes]: A list of currently active channels matching the given pattern.
-                    If no pattern is specified, all active channels are returned.
+
+            If no pattern is specified, all active channels are returned.
 
         Examples:
             >>> await client.pubsub_channels()
@@ -6786,11 +7345,13 @@ class CoreCommands(Protocol):
         """
         Returns the number of unique patterns that are subscribed to by clients.
 
-        Note: This is the total number of unique patterns all the clients are subscribed to,
-        not the count of clients subscribed to patterns.
-        The command is routed to all nodes, and aggregates the response the sum of all pattern subscriptions.
+        Note:
+            This is the total number of unique patterns all the clients are subscribed to,
+            not the count of clients subscribed to patterns.
+
+            The command is routed to all nodes, and aggregates the response the sum of all pattern subscriptions.
 
-        See https://valkey.io/commands/pubsub-numpat for more details.
+        See [valkey.io](https://valkey.io/commands/pubsub-numpat) for more details.
 
         Returns:
             int: The number of unique patterns.
@@ -6807,14 +7368,17 @@ class CoreCommands(Protocol):
         """
         Returns the number of subscribers (exclusive of clients subscribed to patterns) for the specified channels.
 
-        Note that it is valid to call this command without channels. In this case, it will just return an empty map.
-        The command is routed to all nodes, and aggregates the response to a single map of the channels and their number of subscriptions.
+        Note:
+            It is valid to call this command without channels. In this case, it will just return an empty map.
+
+            The command is routed to all nodes, and aggregates the response to a single map of the channels and their number
+            of subscriptions.
 
-        See https://valkey.io/commands/pubsub-numsub for more details.
+        See [valkey.io](https://valkey.io/commands/pubsub-numsub) for more details.
 
         Args:
             channels (Optional[List[TEncodable]]): The list of channels to query for the number of subscribers.
-                                            If not provided, returns an empty map.
+                If not provided, returns an empty map.
 
         Returns:
             Mapping[bytes, int]: A map where keys are the channel names and values are the number of subscribers.
@@ -6844,19 +7408,22 @@ class CoreCommands(Protocol):
     ) -> List[Optional[bytes]]:
         """
         Sorts the elements in the list, set, or sorted set at `key` and returns the result.
-        The `sort` command can be used to sort elements based on different criteria and apply transformations on sorted elements.
+        The `sort` command can be used to sort elements based on different criteria and apply transformations on sorted
+        elements.
         This command is routed to primary nodes only.
         To store the result into a new key, see `sort_store`.
 
-        Note: When in cluster mode, `key`, and any patterns specified in `by_pattern` or `get_patterns`
+        Note:
+            When in cluster mode, `key`, and any patterns specified in `by_pattern` or `get_patterns`
             must map to the same hash slot. The use of `by_pattern` and `get_patterns` in cluster mode is supported
             only since Valkey version 8.0.
 
-        See https://valkey.io/commands/sort for more details.
+        See [valkey.io](https://valkey.io/commands/sort) for more details.
 
         Args:
             key (TEncodable): The key of the list, set, or sorted set to be sorted.
-            by_pattern (Optional[TEncodable]): A pattern to sort by external keys instead of by the elements stored at the key themselves.
+            by_pattern (Optional[TEncodable]): A pattern to sort by external keys instead of by the elements stored at the key
+                themselves.
                 The pattern should contain an asterisk (*) as a placeholder for the element values, where the value
                 from the key replaces the asterisk to create the key name. For example, if `key` contains IDs of objects,
                 `by_pattern` can be used to sort these IDs based on an attribute of the objects, like their weights or
@@ -6865,8 +7432,10 @@ class CoreCommands(Protocol):
                 keys `weight_<element>`.
                 If not provided, elements are sorted by their value.
                 Supported in cluster mode since Valkey version 8.0.
-            limit (Optional[Limit]): Limiting the range of the query by setting offset and result count. See `Limit` class for more information.
-            get_patterns (Optional[List[TEncodable]]): A pattern used to retrieve external keys' values, instead of the elements at `key`.
+            limit (Optional[Limit]): Limiting the range of the query by setting offset and result count. See `Limit` class for
+                more information.
+            get_patterns (Optional[List[TEncodable]]): A pattern used to retrieve external keys' values, instead of the
+                elements at `key`.
                 The pattern should contain an asterisk (*) as a placeholder for the element values, where the value
                 from `key` replaces the asterisk to create the key name. This allows the sorted elements to be
                 transformed based on the related keys values. For example, if `key` contains IDs of users, `get_pattern`
@@ -6878,8 +7447,10 @@ class CoreCommands(Protocol):
                 Supported in cluster mode since Valkey version 8.0.
             order (Optional[OrderBy]): Specifies the order to sort the elements.
                 Can be `OrderBy.ASC` (ascending) or `OrderBy.DESC` (descending).
-            alpha (Optional[bool]): When `True`, sorts elements lexicographically. When `False` (default), sorts elements numerically.
-                Use this when the list, set, or sorted set contains string values that cannot be converted into double precision floating point
+            alpha (Optional[bool]): When `True`, sorts elements lexicographically. When `False` (default), sorts elements
+                numerically.
+                Use this when the list, set, or sorted set contains string values that cannot be converted into double
+                precision floating point
 
         Returns:
             List[Optional[bytes]]: Returns a list of sorted elements.
@@ -6914,18 +7485,21 @@ class CoreCommands(Protocol):
     ) -> List[Optional[bytes]]:
         """
         Sorts the elements in the list, set, or sorted set at `key` and returns the result.
-        The `sort_ro` command can be used to sort elements based on different criteria and apply transformations on sorted elements.
+        The `sort_ro` command can be used to sort elements based on different criteria and apply transformations on
+        sorted elements.
         This command is routed depending on the client's `ReadFrom` strategy.
 
-        See https://valkey.io/commands/sort for more details.
+        See [valkey.io](https://valkey.io/commands/sort) for more details.
 
-        Note: When in cluster mode, `key`, and any patterns specified in `by_pattern` or `get_patterns`
+        Note:
+            When in cluster mode, `key`, and any patterns specified in `by_pattern` or `get_patterns`
             must map to the same hash slot. The use of `by_pattern` and `get_patterns` in cluster mode is supported
             only since Valkey version 8.0.
 
         Args:
             key (TEncodable): The key of the list, set, or sorted set to be sorted.
-            by_pattern (Optional[TEncodable]): A pattern to sort by external keys instead of by the elements stored at the key themselves.
+            by_pattern (Optional[TEncodable]): A pattern to sort by external keys instead of by the elements stored at the
+                key themselves.
                 The pattern should contain an asterisk (*) as a placeholder for the element values, where the value
                 from the key replaces the asterisk to create the key name. For example, if `key` contains IDs of objects,
                 `by_pattern` can be used to sort these IDs based on an attribute of the objects, like their weights or
@@ -6934,8 +7508,10 @@ class CoreCommands(Protocol):
                 keys `weight_<element>`.
                 If not provided, elements are sorted by their value.
                 Supported in cluster mode since Valkey version 8.0.
-            limit (Optional[Limit]): Limiting the range of the query by setting offset and result count. See `Limit` class for more information.
-            get_pattern (Optional[TEncodable]): A pattern used to retrieve external keys' values, instead of the elements at `key`.
+            limit (Optional[Limit]): Limiting the range of the query by setting offset and result count. See `Limit` class for
+                more information.
+            get_patterns (Optional[List[TEncodable]]): A pattern used to retrieve external keys' values, instead of the
+                elements at `key`.
                 The pattern should contain an asterisk (*) as a placeholder for the element values, where the value
                 from `key` replaces the asterisk to create the key name. This allows the sorted elements to be
                 transformed based on the related keys values. For example, if `key` contains IDs of users, `get_pattern`
@@ -6947,8 +7523,10 @@ class CoreCommands(Protocol):
                 Supported in cluster mode since Valkey version 8.0.
             order (Optional[OrderBy]): Specifies the order to sort the elements.
                 Can be `OrderBy.ASC` (ascending) or `OrderBy.DESC` (descending).
-            alpha (Optional[bool]): When `True`, sorts elements lexicographically. When `False` (default), sorts elements numerically.
-                Use this when the list, set, or sorted set contains string values that cannot be converted into double precision floating point
+            alpha (Optional[bool]): When `True`, sorts elements lexicographically. When `False` (default), sorts elements
+                numerically.
+                Use this when the list, set, or sorted set contains string values that cannot be converted into double
+                precision floating point
 
         Returns:
             List[Optional[bytes]]: Returns a list of sorted elements.
@@ -6986,19 +7564,22 @@ class CoreCommands(Protocol):
     ) -> int:
         """
         Sorts the elements in the list, set, or sorted set at `key` and stores the result in `store`.
-        The `sort` command can be used to sort elements based on different criteria, apply transformations on sorted elements, and store the result in a new key.
+        The `sort` command can be used to sort elements based on different criteria, apply transformations on sorted elements,
+        and store the result in a new key.
         To get the sort result without storing it into a key, see `sort`.
 
-        See https://valkey.io/commands/sort for more details.
+        See [valkey.io](https://valkey.io/commands/sort) for more details.
 
-        Note: When in cluster mode, `key`, `destination`, and any patterns specified in `by_pattern` or `get_patterns`
+        Note:
+            When in cluster mode, `key`, `destination`, and any patterns specified in `by_pattern` or `get_patterns`
             must map to the same hash slot. The use of `by_pattern` and `get_patterns` in cluster mode is supported
             only since Valkey version 8.0.
 
         Args:
             key (TEncodable): The key of the list, set, or sorted set to be sorted.
             destination (TEncodable): The key where the sorted result will be stored.
-            by_pattern (Optional[TEncodable]): A pattern to sort by external keys instead of by the elements stored at the key themselves.
+            by_pattern (Optional[TEncodable]): A pattern to sort by external keys instead of by the elements stored at the key
+                themselves.
                 The pattern should contain an asterisk (*) as a placeholder for the element values, where the value
                 from the key replaces the asterisk to create the key name. For example, if `key` contains IDs of objects,
                 `by_pattern` can be used to sort these IDs based on an attribute of the objects, like their weights or
@@ -7007,8 +7588,10 @@ class CoreCommands(Protocol):
                 keys `weight_<element>`.
                 If not provided, elements are sorted by their value.
                 Supported in cluster mode since Valkey version 8.0.
-            limit (Optional[Limit]): Limiting the range of the query by setting offset and result count. See `Limit` class for more information.
-            get_patterns (Optional[List[TEncodable]]): A pattern used to retrieve external keys' values, instead of the elements at `key`.
+            limit (Optional[Limit]): Limiting the range of the query by setting offset and result count. See `Limit` class for
+                more information.
+            get_patterns (Optional[List[TEncodable]]): A pattern used to retrieve external keys' values, instead of the
+                elements at `key`.
                 The pattern should contain an asterisk (*) as a placeholder for the element values, where the value
                 from `key` replaces the asterisk to create the key name. This allows the sorted elements to be
                 transformed based on the related keys values. For example, if `key` contains IDs of users, `get_pattern`
@@ -7020,8 +7603,10 @@ class CoreCommands(Protocol):
                 Supported in cluster mode since Valkey version 8.0.
             order (Optional[OrderBy]): Specifies the order to sort the elements.
                 Can be `OrderBy.ASC` (ascending) or `OrderBy.DESC` (descending).
-            alpha (Optional[bool]): When `True`, sorts elements lexicographically. When `False` (default), sorts elements numerically.
-                Use this when the list, set, or sorted set contains string values that cannot be converted into double precision floating point
+            alpha (Optional[bool]): When `True`, sorts elements lexicographically. When `False` (default), sorts elements
+                numerically.
+                Use this when the list, set, or sorted set contains string values that cannot be converted into double
+                precision floating point
 
         Returns:
             int: The number of elements in the sorted key stored at `store`.