Repository: redis/redis-py
File: redis/commands/core.py (Python)

Code before:

    def tfunction_delete(self, lib_name: str) -> ResponseT:
        """
        Delete a library from RedisGears.

        ``lib_name`` the library name to delete.

        For more information see https://redis.io/commands/tfunction-delete/
        # TODO: check link when it will be available
        """
        return self.execute_command("TFUNCTION DELETE", lib_name)

    def tfunction_list(
        self, with_code: bool = False, verbose: int = 0, lib_name: str = None
    ) -> ResponseT:
        """
        List the functions with additional information about each function.

        ``with_code`` Show libraries code.
        ``verbose`` output verbosity level, higher number will increase verbosity level
        ``lib_name`` specifying a library name (can be used multiple times to show multiple libraries in a single command) # noqa

        For more information see https://redis.io/commands/tfunction-list/
        # TODO: check link when it will be available
        """
        pices: list[EncodableT] = []
        if with_code:
            pices.append("WITHCODE")
        if verbose > 0 and verbose < 4:
            pices.append("v" * verbose)
        elif verbose != 0:  # verbose == 0 is the default so no need to throw an error
            raise DataError("verbose can be 1, 2 or 3")
        if lib_name is not None:
            pices.append("LIBRARY")
            pices.append(lib_name)

        return self.execute_command("TFUNCTION LIST", *pices)

    def tfcall(
        self,
        lib_name: str,
        func_name: str,
        keys: KeysT = None,
        *args: List,
        _async: bool = False,
    ) -> ResponseT:
        """
        Trigger a sync or async (Coroutine) function.

        ``lib_name`` - the library name contains the function.
        ``func_name`` - the function name to run.

Review comment (suggestion):
Variable name should be ```pieces``` not ```pices```
Also - same encodabel comment

Code after:
        """
        Returns the type of key ``name``

        For more information see https://redis.io/commands/type
        """
        return self.execute_command("TYPE", name)

    def watch(self, *names: KeyT) -> None:
        """
        Watches the values at keys ``names``, or None if the key doesn't exist

        For more information see https://redis.io/commands/watch
        """
        warnings.warn(DeprecationWarning("Call WATCH from a Pipeline object"))

    def unwatch(self) -> None:
        """
        Unwatches the value at key ``name``, or None of the key doesn't exist

        For more information see https://redis.io/commands/unwatch
        """
        warnings.warn(DeprecationWarning("Call UNWATCH from a Pipeline object"))

    def unlink(self, *names: KeyT) -> ResponseT:
        """
        Unlink one or more keys specified by ``names``

        For more information see https://redis.io/commands/unlink
        """
        return self.execute_command("UNLINK", *names)

    def lcs(
        self,
        key1: str,
        key2: str,
        len: Optional[bool] = False,
        idx: Optional[bool] = False,
        minmatchlen: Optional[int] = 0,
        withmatchlen: Optional[bool] = False,
    ) -> Union[str, int, list]:
        """
        Find the longest common subsequence between ``key1`` and ``key2``.
        If ``len`` is true the length of the match will will be returned.
        If ``idx`` is true the match position in each strings will be returned.
        ``minmatchlen`` restrict the list of matches to the ones of
        the given ``minmatchlen``.
        If ``withmatchlen`` the length of the match also will be returned.
        For more information see https://redis.io/commands/lcs
        """
        pieces = [key1, key2]
        if len: