reykit 1.1.39__py3-none-any.whl → 1.1.41__py3-none-any.whl

reykit/rbase.py

@@ -946,7 +946,7 @@ def at_exit(*contents: str | Callable | tuple[Callable, Iterable, Mapping]) -> l
         args = ()
         kwargs = {}
         if type(content) == str:
-            func = lambda : print(content)
+            func = lambda: print(content)
         elif callable(content):
             func = content
         elif type(content) == tuple:

reykit/rdata.py

@@ -362,7 +362,7 @@ def default_dict(default: T = null, data: dict[KT, VT] | None = None) -> Default
 
     ## Not callable.
     else:
-        default_factory = lambda : default
+        default_factory = lambda: default
 
     if data is None:
         data = {}
@@ -409,10 +409,10 @@ class FunctionGenerator(Base):
         self.args = args
         self.kwargs = kwargs
         self.params: list[tuple[tuple, dict]] = []
-        self.generator = self._generator()
+        self.generator = self.__generator()
 
 
-    def _generator(self) -> Generator[Any, Any, None]:
+    def __generator(self) -> Generator[Any, Any, None]:
         """
         Create generator.
 

reykit/rlog.py

@@ -106,7 +106,7 @@ class Log(Base):
         self.logger.setLevel(self.DEBUG)
 
 
-    def _get_message_stack(self) -> dict:
+    def __get_message_stack(self) -> dict:
         """
         Get message stack parameters.
 
@@ -145,7 +145,7 @@ class Log(Base):
         return stack_param
 
 
-    def _supply_format_standard(
+    def __supply_format_standard(
         self,
         format_: str,
         record: LogRecord
@@ -171,7 +171,7 @@ class Log(Base):
 
         # Format 'format_path'.
         if '%(format_path)s' in format_:
-            message_stack = self._get_message_stack()
+            message_stack = self.__get_message_stack()
             record.format_path = '%s:%s' % (
                 message_stack['filename'],
                 message_stack['lineno']
@@ -213,7 +213,7 @@ class Log(Base):
         return color_code
 
 
-    def _supply_format_print(
+    def __supply_format_print(
         self,
         format_: str,
         record: LogRecord
@@ -267,7 +267,7 @@ class Log(Base):
             )
 
 
-    def _supply_format_file(
+    def __supply_format_file(
         self,
         format_: str,
         record: LogRecord
@@ -326,17 +326,17 @@ class Log(Base):
             """
 
             # Format standard.
-            self._supply_format_standard(format_, record)
+            self.__supply_format_standard(format_, record)
 
             match mode:
 
                 # Format print.
                 case 'print':
-                    self._supply_format_print(format_, record)
+                    self.__supply_format_print(format_, record)
 
                 # Format file.
                 case 'file':
-                    self._supply_format_file(format_, record)
+                    self.__supply_format_file(format_, record)
 
             return True
 

reykit/rmonkey.py

@@ -259,7 +259,7 @@ def monkey_patch_pprint_modify_width_judgment() -> None:
 
 
     # Define.
-    def _format(_self, obj, stream, indent, allowance, context, level):
+    def __format(_self, obj, stream, indent, allowance, context, level):
 
         from .rtext import get_width
 
@@ -289,7 +289,7 @@ def monkey_patch_pprint_modify_width_judgment() -> None:
 
 
     # Modify.
-    PrettyPrinter._format = _format
+    PrettyPrinter.__format = __format
 
 
 def monkey_path_pil_image_get_bytes():

reykit/rnet.py

@@ -9,7 +9,7 @@
 """
 
 
-from typing import Any, Literal, TypedDict, NotRequired
+from typing import Any, Literal, TypedDict, NotRequired, overload
 from collections.abc import Callable, Iterable
 from warnings import filterwarnings
 from os.path import abspath as os_abspath, isfile as os_isfile
@@ -206,6 +206,67 @@ def get_content_type(file: str | bytes) -> str | None:
     return file_type
 
 
+@overload
+def request(
+    url: str,
+    params: dict | None = None,
+    *,
+    headers: dict[str, str] = {},
+    timeout: float | None = None,
+    proxies: dict[str, str] = {},
+    stream: bool = False,
+    verify: bool = False,
+    method: Literal['get', 'post', 'put', 'patch', 'delete', 'options', 'head'] = Literal['get'],
+    check: bool | int | Iterable[int] = False
+) -> Response: ...
+
+@overload
+def request(
+    url: str,
+    params: dict | None = None,
+    *,
+    data: dict | str | bytes,
+    files: dict[str, str | bytes | tuple[str | bytes, dict]] | None = None,
+    headers: dict[str, str] = {},
+    timeout: float | None = None,
+    proxies: dict[str, str] = {},
+    stream: bool = False,
+    verify: bool = False,
+    method: Literal['get', 'post', 'put', 'patch', 'delete', 'options', 'head'] | None = Literal['post'],
+    check: bool | int | Iterable[int] = False
+) -> Response: ...
+
+@overload
+def request(
+    url: str,
+    params: dict | None = None,
+    *,
+    data: dict | str | bytes | None = None,
+    files: dict[str, str | bytes | tuple[str | bytes, dict]],
+    headers: dict[str, str] = {},
+    timeout: float | None = None,
+    proxies: dict[str, str] = {},
+    stream: bool = False,
+    verify: bool = False,
+    method: Literal['get', 'post', 'put', 'patch', 'delete', 'options', 'head'] | None = Literal['post'],
+    check: bool | int | Iterable[int] = False
+) -> Response: ...
+
+@overload
+def request(
+    url: str,
+    params: dict | None = None,
+    *,
+    json: dict,
+    headers: dict[str, str] = {},
+    timeout: float | None = None,
+    proxies: dict[str, str] = {},
+    stream: bool = False,
+    verify: bool = False,
+    method: Literal['get', 'post', 'put', 'patch', 'delete', 'options', 'head'] | None = Literal['post'],
+    check: bool | int | Iterable[int] = False
+) -> Response: ...
+
 def request(
     url: str,
     params: dict | None = None,
@@ -498,7 +559,7 @@ class RequestCache(Base):
 
 
     @property
-    def _start_params(self) -> RequestCacheParameters:
+    def __start_params(self) -> RequestCacheParameters:
         """
         Get cache start parameters.
 
@@ -537,7 +598,7 @@ class RequestCache(Base):
         """
 
         # Start.
-        requests_cache_install_cache(**self._start_params)
+        requests_cache_install_cache(**self.__start_params)
 
 
     def stop(self) -> None:

reykit/rtask.py

@@ -684,11 +684,11 @@ class AsyncPool(Base):
         self.futures: list[AFuture] = []
 
         # Start.
-        self._start_loop()
+        self.__start_loop()
 
 
     @wrap_thread
-    def _start_loop(self) -> None:
+    def __start_loop(self) -> None:
         """
         Start event loop.
         """

reykit/rwrap.py

@@ -10,21 +10,23 @@
 
 
 from typing import Any, Literal, overload
+from types import TracebackType
 from collections.abc import Callable
 from io import IOBase, StringIO
-from inspect import getdoc
-from functools import wraps as functools_wraps
+from inspect import getdoc as inspect_getdoc
+from functools import wraps as functools_wraps, partial as functools_partial
+from datetime import datetime as Datetime, timedelta as Timedelta
 from threading import Thread
 from argparse import ArgumentParser
 from contextlib import redirect_stdout
 
-from .rbase import catch_exc, get_arg_info
+from .rbase import T, U, V, catch_exc, get_arg_info
 from .rstdout import echo
 from .rtime import now, time_to, TimeMark
 
 
 __all__ = (
-    'wrap_frame',
+    'wrap_wrap',
     'wrap_runtime',
     'wrap_thread',
     'wrap_exc',
@@ -36,13 +38,17 @@ __all__ = (
 )
 
 
-def wrap_frame(decorator: Callable) -> Callable:
+type Decorated = Callable
+type Decorator = Callable[..., Decorated]
+
+
+def wrap_wrap(decorator: Decorator) -> Decorator:
     """
-    Decorative frame.
+    Decorate decorator.
 
     Parameters
     ----------
-    decorator : Decorator function.
+    decorator : Decorator.
 
     Retuens
     -------
@@ -50,140 +56,138 @@ def wrap_frame(decorator: Callable) -> Callable:
 
     Examples
     --------
-    Decoration function method one.
+    >>> @wrap_wrap
+    >>> def wrap_func(func, args, kwargs, **wrap_kwargs): ...
+
+    Method one.
     >>> @wrap_func
-    >>> def func(): ...
-    >>> result = func(param_a, param_b, param_c=1, param_d=2)
-
-    Decoration function method two.
-    >>> def func(): ...
-    >>> result = wrap_func(func, param_a, param_b, param_c=1, param_d=2)
-
-    Decoration function method three.
-    >>> def func(): ...
-    >>> result = wrap_func(func, _execute=True)
-    
-    Decoration function method four.
-    >>> def func(): ...
+    >>> def func(*args, **kwargs): ...
+
+    Method two.
+    >>> @wrap_func(**wrap_kwargs)
+    >>> def func(*args, **kwargs): ...
+
+    Method three.
+    >>> def func(*args, **kwargs): ...
+    >>> func = wrap_func(func, **wrap_kwargs)
+
+    Method four.
+    >>> def func(*args, **kwargs): ...
+    >>> wrap_func = wrap_func(**wrap_kwargs)
     >>> func = wrap_func(func)
-    >>> result = func(param_a, param_b, param_c=1, param_d=2)
 
-    Decoration function method five.
-    >>> def func(): ...
-    >>> func = wrap_func(func, param_a, param_c=1, _execute=False)
-    >>> result = func(param_b, param_d=2)
+    >>> func(*args, **kwargs)
     """
 
 
     # Decorate Decorator.
     @overload
-    def wrap(func: Callable, /, *args: Any, **kwargs: Any) -> Callable | Any: ...
-
-    @overload
-    def wrap(func: Callable, /, *args: Any, _execute: Literal[True], **kwargs: Any) -> Any: ...
+    def _wrap(func: Callable, **wrap_kwargs: Any) -> Decorated: ...
 
     @overload
-    def wrap(func: Callable, /, *args: Any, _execute: Literal[False], **kwargs: Any) -> Callable: ...
+    def _wrap(**wrap_kwargs: Any) -> Decorator: ...
 
     @functools_wraps(decorator)
-    def wrap(func: Callable, /, *args: Any, _execute: bool | None = None, **kwargs: Any) -> Callable | Any:
+    def _wrap(func: Callable | None = None, **wrap_kwargs: Any) -> Decorated | Decorator:
         """
-        Decorative shell.
+        Decorated decorator.
 
         Parameters
         ----------
         func : Function.
-        args : Position arguments of function.
-        _execute : Whether execute function, otherwise decorate function.
-            - `None`, When parameter `args` or `kwargs`: have values, then True, otherwise False.
-            - `bool`: Use this value.
-        kwargs : Keyword arguments of function.
+        wrap_kwargs : Keyword arguments of decorator.
 
         Returns
         -------
-        Decorated function or function return.
+        Decorated function or decorated self.
         """
 
-        # Handle parameter.
-        if _execute is None:
-            if args != () or kwargs != {}:
-                _execute = True
-            else:
-                _execute = False
+        # Method one and three.
+        if func is not None:
 
-        # Direct execution.
-        if _execute:
-            result = decorator(func, *args, **kwargs)
-            return result
 
+            @functools_wraps(func)
+            def _func(*args: Any, **kwargs: Any) -> Any:
+                """
+                Decorated function.
 
-        # Decorate function.
-        @functools_wraps(func)
-        def wrap_sub(*_args: Any, **_kwargs: Any) -> Any:
-            """
-            Decorative sub shell.
+                Parameters
+                ----------
+                args : Position arguments of function.
+                kwargs : Keyword arguments of function.
 
-            Parameters
-            ----------
-            args : Position arguments of function.
-            kwargs : Keyword arguments of function.
+                Returns
+                -------
+                Function return.
+                """
 
-            Returns
-            -------
-            Function return.
-            """
+                # Decorate function.
+                result = decorator(func, args, kwargs, **wrap_kwargs)
 
-            # Decorate function.
-            result = decorator(func, *args, *_args, **kwargs, **_kwargs)
+                return result
 
-            return result
+
+            return _func
 
 
-        return wrap_sub
+        # Method two and four.
+        else:
+            __wrap = functools_partial(_wrap, **wrap_kwargs)
+            return __wrap
 
 
-    return wrap
+    return _wrap
 
 
 @overload
 def wrap_runtime(
-    func: Callable,
-    /,
-    *args: Any,
-    _return_report: Literal[False] = False,
-    **kwargs: Any
-) -> Any: ...
+    func: Callable[..., T],
+    *,
+    to_print: bool = True
+) -> Callable[..., T]: ...
 
 @overload
 def wrap_runtime(
-    func: Callable,
-    /,
-    *args: Any,
-    _return_report: Literal[True],
-    **kwargs: Any
-) -> tuple[Any, str]: ...
+    func: Callable[..., T],
+    to_return: Literal[True],
+    to_print: bool = True
+) -> Callable[..., tuple[T, str, Datetime, Timedelta, Datetime]]: ...
 
-@wrap_frame
+@overload
 def wrap_runtime(
-    func: Callable,
-    /,
-    *args: Any,
-    _return_report: bool = False,
-    **kwargs: Any
-) -> Any | tuple[Any, str]:
+    *,
+    to_print: bool = True
+) -> Callable[[Callable[..., T]], T]: ...
+
+@overload
+def wrap_runtime(
+    *,
+    to_return: Literal[True],
+    to_print: bool = True
+) -> Callable[[Callable[..., T]], tuple[T, str, Datetime, Timedelta, Datetime]]: ...
+
+@wrap_wrap
+def wrap_runtime(
+    func: Callable[..., T],
+    args: Any,
+    kwargs: Any,
+    to_return: bool = False,
+    to_print: bool = True
+) -> T | tuple[T, str, Datetime, Timedelta, Datetime]:
     """
-    Decorator, print or return runtime report of the function.
+    Decorator, print or return runtime data of the function.
 
     Parameters
     ----------
-    func : Function to be decorated.
-    args : Position arguments of decorated function.
-    _return_report : Whether return report, otherwise print report.
-    kwargs : Keyword arguments of decorated function.
+    func : Function.
+    args : Position arguments of function.
+    kwargs : Keyword arguments of function.
+    to_print : Whether to print runtime.
+    to_return : Whether to return runtime.
 
     Returns
     -------
-    Function execution result and runtime report.
+    Function return or runtime data.
     """
 
     # Execute function and marking time.
@@ -194,7 +198,7 @@ def wrap_runtime(
 
     # Generate report.
     start_time = rtm.record[0]['datetime']
-    spend_time = rtm.record[1]['timedelta']
+    spend_time: Timedelta = rtm.record[1]['timedelta']
     end_time = rtm.record[1]['datetime']
     start_str = time_to(start_time, True)[:-3]
     spend_str = time_to(spend_time, True)[:-3]
@@ -206,12 +210,13 @@ def wrap_runtime(
     )
     title = func.__name__
 
-    # Return report.
-    if _return_report:
-        return result, report
+    # Print.
+    if to_print:
+        echo(report, title=title)
 
-    # Print report.
-    echo(report, title=title)
+    # Return.
+    if to_return:
+        return result, report, start_time, spend_time, end_time
 
     return result
 
@@ -219,33 +224,35 @@ def wrap_runtime(
 @overload
 def wrap_thread(
     func: Callable,
-    /,
-    *args: Any,
-    _daemon: bool = True,
-    **kwargs: Any
-) -> Thread: ...
+    daemon: bool = True
+) -> Callable[..., Thread]: ...
 
-@wrap_frame
+@overload
+def wrap_thread(
+    *,
+    daemon: bool = True
+) -> Callable[[Callable], Thread]: ...
+
+@wrap_wrap
 def wrap_thread(
     func: Callable,
-    /,
-    *args: Any,
-    _daemon: bool = True,
-    **kwargs: Any
+    args: Any,
+    kwargs: Any,
+    daemon: bool = True
 ) -> Thread:
     """
     Decorator, function start in thread.
 
     Parameters
     ----------
-    func : Function to be decorated.
-    args : Position arguments of decorated function.
-    _daemon : Whether it is a daemon thread.
-    kwargs : Keyword arguments of decorated function.
+    func : Function.
+    args : Position arguments of function.
+    kwargs : Keyword arguments of function.
+    daemon : Whether it is a daemon thread.
 
     Returns
     -------
-    Thread object.
+    Thread instance.
     """
 
     # Handle parameter.
@@ -253,7 +260,7 @@ def wrap_thread(
 
     # Create thread.
     thread = Thread(target=func, name=thread_name, args=args, kwargs=kwargs)
-    thread.daemon = _daemon
+    thread.daemon = daemon
 
     # Start thread.
     thread.start()
@@ -263,37 +270,40 @@ def wrap_thread(
 
 @overload
 def wrap_exc(
-    func: Callable,
-    /,
-    *args: Any,
-    _exception: BaseException | tuple[BaseException, ...] = BaseException,
-    _handler: Callable | None = None,
-    **kwargs: Any
-) -> Any | None: ...
-
-@wrap_frame
+    func: Callable[..., T],
+    handler: Callable[[tuple[str, type[BaseException], BaseException, TracebackType]], Any],
+    exception: BaseException | tuple[BaseException, ...] | None = BaseException
+) -> Callable[..., T | None]: ...
+
+@overload
 def wrap_exc(
-    func: Callable,
-    /,
-    *args: Any,
-    _exception: BaseException | tuple[BaseException, ...] = BaseException,
-    _handler: Callable | None = None,
-    **kwargs: Any
-) -> Any | None:
+    *,
+    handler: Callable[[tuple[str, type[BaseException], BaseException, TracebackType]], Any],
+    exception: BaseException | tuple[BaseException, ...] | None = BaseException
+) -> Callable[[Callable[..., T]], T | None]: ...
+
+@wrap_wrap
+def wrap_exc(
+    func: Callable[..., T],
+    args: Any,
+    kwargs: Any,
+    handler: Callable[[tuple[str, type[BaseException], BaseException, TracebackType]], Any],
+    exception: BaseException | tuple[BaseException, ...] | None = BaseException
+) -> T | None:
     """
-    Decorator, execute function with `try` and `except` syntax.
+    Decorator, execute function with `try` syntax and handle exception.
 
     Parameters
     ----------
-    func : Function to be decorated.
-    args : Position arguments of decorated function.
-    _exception : Catch exception types.
-    _handler : Exception handler, will return value.
-    kwargs : Keyword arguments of decorated function.
+    func : Function.
+    args : Position arguments of function.
+    kwargs : Keyword arguments of function.
+    handler : Exception handler.
+    exception : Catch exception type.
 
     Returns
     -------
-    Execution result of function or exception handle method.
+    Function return.
     """
 
     # Execute function.
@@ -301,130 +311,112 @@ def wrap_exc(
         result = func(*args, **kwargs)
 
     # Handle exception.
-    except _exception:
-        if _handler is not None:
-            result = _handler()
-        else:
-            result = None
+    except exception:
+        exc_report, exc_type, exc_instance, exc_traceback = catch_exc()
+        handler(exc_report, exc_type, exc_instance, exc_traceback)
 
-    return result
+    else:
+        return result
 
 
 @overload
 def wrap_retry(
-    func: Callable,
-    /,
-    *args: Any,
-    _report: str | None = None,
-    _exception: BaseException | tuple[BaseException, ...] = BaseException,
-    _try_total: int = 1,
-    _try_count: int = 0,
-    **kwargs: Any
-) -> Any: ...
-
-@wrap_frame
+    func: Callable[..., T],
+    total: int = 1,
+    handler: Callable[[tuple[str, type[BaseException], BaseException, TracebackType]], Any] | None = None,
+    exception: BaseException | tuple[BaseException, ...] = BaseException
+) -> Callable[..., T]: ...
+
+@overload
 def wrap_retry(
-    func: Callable,
-    /,
-    *args: Any,
-    _report: str | None = None,
-    _exception: BaseException | tuple[BaseException, ...] = BaseException,
-    _try_total: int = 1,
-    _try_count: int = 0,
-    **kwargs: Any
-) -> Any:
+    *,
+    total: int = 1,
+    handler: Callable[[tuple[str, type[BaseException], BaseException, TracebackType]], Any] | None = None,
+    exception: BaseException | tuple[BaseException, ...] = BaseException
+) -> Callable[[Callable[..., T]], T]: ...
+
+@wrap_wrap
+def wrap_retry(
+    func: Callable[..., T],
+    args: Any,
+    kwargs: Any,
+    total: int = 2,
+    handler: Callable[[tuple[str, type[BaseException], BaseException, TracebackType]], Any] | None = None,
+    exception: BaseException | tuple[BaseException, ...] = BaseException
+) -> T:
     """
-    Decorator, try again.
+    Decorator, try again and handle exception.
 
     Parameters
     ----------
-    func : Function to be decorated.
-    args : Position arguments of decorated function.
-    _report : Print report title.
-        - `None`: Not print.
-        - `str`: Print and use this title.
-    _exception : Catch exception types.
-    _try_total : Retry total.
-    _try_count : Retry count.
-    kwargs : Keyword arguments of decorated function.
+    func : Function.
+    args : Position arguments of function.
+    kwargs : Keyword arguments of function.
+    total : Retry total.
+    handler : Exception handler.
+    exception : Catch exception type.
 
     Returns
     -------
-    Function execution result.
+    Function return.
     """
 
-    # Try count not full.
-    if _try_count < _try_total:
+    # Loop.
+    for _ in range(0, total - 1):
 
-        ## Try.
+        # Try.
         try:
             result = func(*args, **kwargs)
-        except _exception:
-
-            ## Report.
-            if _report is not None:
-                exc_report, *_ = catch_exc()
-                echo(
-                    exc_report,
-                    'Retrying...',
-                    title=_report,
-                    frame='half'
-                )
-
-            ### Retry.
-            _try_count += 1
-            result = wrap_retry(
-                func,
-                *args,
-                _report=_report,
-                _exception=_exception,
-                _try_total=_try_total,
-                _try_count=_try_count,
-                **kwargs
-            )
 
-    # Try count full.
-    else:
-        result = func(*args, **kwargs)
+        ## Handle.
+        except exception:
+            if handler is not None:
+                exc_report, exc_type, exc_instance, exc_traceback = catch_exc()
+                handler(exc_report, exc_type, exc_instance, exc_traceback)
+
+        else:
+            return result
+
+    # Last.
+    result = func(*args, **kwargs)
 
     return result
 
 
 @overload
 def wrap_dos_command(
-    func: Callable,
-    /,
-    *args: Any,
-    **kwargs: Any
-) -> Any: ...
+    func: Callable[..., T]
+) -> Callable[..., T]: ...
+
+@overload
+def wrap_dos_command() -> Callable[[Callable[..., T]], T]: ...
 
-@wrap_frame
+@wrap_wrap
 def wrap_dos_command(
-    func: Callable,
-    /,
-    *args: Any,
-    **kwargs: Any
-) -> Any:
+    func: Callable[..., T],
+    args: Any,
+    kwargs: Any,
+) -> T:
     """
     Decorator, use DOS command to input arguments to function.
     Use DOS command `python file --help` to view help information.
 
     Parameters
     ----------
-    func : Function to be decorated.
-    args : Position arguments of decorated function.
-    kwargs : Keyword arguments of decorated function.
+    func : Function.
+    args : Position arguments of function.
+    kwargs : Keyword arguments of function.
 
     Returns
     -------
-    Function execution result.
+    Function return.
     """
 
     # Get parameter.
     arg_info = get_arg_info(func)
 
     # Set DOS command.
-    usage = getdoc(func)
+    usage = inspect_getdoc(func)
     if usage is not None:
         usage = 'input arguments to function "%s"\n\n%s' % (func.__name__, usage)
     parser = ArgumentParser(usage=usage)
@@ -519,21 +511,23 @@ wrap_cache_data: dict[Callable, list[tuple[Any, Any, Any]]] = {}
 
 @overload
 def wrap_cache(
-    func: Callable,
-    /,
-    *args: Any,
-    _overwrite: bool = False,
-    **kwargs: Any
-) -> Any: ...
+    func: Callable[..., T],
+    overwrite: bool = False
+) -> Callable[..., T]: ...
 
-@wrap_frame
+@overload
 def wrap_cache(
-    func: Callable,
-    /,
-    *args: Any,
-    _overwrite: bool = False,
-    **kwargs: Any
-) -> Any:
+    *,
+    overwrite: bool = False
+) -> Callable[[Callable[..., T]], T]: ...
+
+@wrap_wrap
+def wrap_cache(
+    func: Callable[..., T],
+    args: Any,
+    kwargs: Any,
+    overwrite: bool = False
+) -> T:
     """
     Decorator, Cache the return result of function input.
     if no cache, cache it.
@@ -541,14 +535,14 @@ def wrap_cache(
 
     Parameters
     ----------
-    func : Function to be decorated.
-    args : Position arguments of decorated function.
-    _overwrite : Whether to overwrite cache.
-    kwargs : Keyword arguments of decorated function.
+    func : Function.
+    args : Position arguments of function.
+    kwargs : Keyword arguments of function.
+    overwrite : Whether to overwrite cache.
 
     Returns
     -------
-    Function execution result.
+    Function return.
     """
 
     # Index.
@@ -559,7 +553,7 @@ def wrap_cache(
             cache_args == args
             and cache_kwargs == kwargs
         ):
-            if _overwrite:
+            if overwrite:
                 cache_index = index
                 break
             else:
@@ -580,39 +574,42 @@ def wrap_cache(
 
 @overload
 def wrap_redirect_stdout(
-    func: Callable,
-    /,
-    *args: Any,
-    _redirect: list | IOBase | None = None,
-    **kwargs: Any
-) -> Any: ...
+    func: Callable[..., T],
+    *,
+    redirect: list | IOBase | None = None
+) -> Callable[..., T]: ...
 
-@wrap_frame
+@overload
 def wrap_redirect_stdout(
-    func: Callable,
-    /,
-    *args: Any,
-    _redirect: list | IOBase | None = None,
-    **kwargs: Any
-) -> Any:
+    *,
+    redirect: list | IOBase | None = None
+) -> Callable[[Callable[..., T]], T]: ...
+
+@wrap_wrap
+def wrap_redirect_stdout(
+    func: Callable[..., T],
+    args: Any,
+    kwargs: Any,
+    redirect: list | IOBase | None = None
+) -> T:
     """
     Redirect standard output.
 
     Parameters
     ----------
-    func : Function to be decorated.
-    args : Position arguments of decorated function.
-    _redirect : Redirect output list or IO object.
-    kwargs : Keyword arguments of decorated function.
+    func : Function.
+    args : Position arguments of function.
+    kwargs : Keyword arguments of function.
+    redirect : Redirect output list or IO object.
 
     Returns
     -------
-    Function execution result.
+    Function return.
     """
 
     # Get parameter.
-    if isinstance(_redirect, IOBase):
-        str_io = _redirect
+    if isinstance(redirect, IOBase):
+        str_io = redirect
     else:
         str_io = StringIO()
 
@@ -621,8 +618,8 @@ def wrap_redirect_stdout(
         result = func(*args, **kwargs)
 
     # Save.
-    if type(_redirect) == list:
+    if type(redirect) == list:
         value = str_io.getvalue()
-        _redirect.append(value)
+        redirect.append(value)
 
     return result

{reykit-1.1.39.dist-info → reykit-1.1.41.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: reykit
-Version: 1.1.39
+Version: 1.1.41
 Summary: Kit method set.
 Project-URL: homepage, https://github.com/reyxbo/reykit/
 Author-email: Rey <reyxbo@163.com>

{reykit-1.1.39.dist-info → reykit-1.1.41.dist-info}/RECORD

@@ -1,12 +1,12 @@
 reykit/__init__.py,sha256=V86CHqPAAVkooVx3_QIOKpDIFVneQCTTSwfJ-uWgBno,788
 reykit/rall.py,sha256=7Hip02YOkIDm3_xkoSDjvvYV2LhdBV2r4UKzWWnIfIo,628
-reykit/rbase.py,sha256=UBlu1-uOl3ZOeVIK6DvFbR3lZmthmGKjpbF-9vwQCpc,22116
-reykit/rdata.py,sha256=cRUXIYEp-hq56ShclarXE1RoQpaPTPGiBjnabTBft50,10307
+reykit/rbase.py,sha256=KDiGiMwj-7u5sfGOPMEb4AgrWfJbUZqpFCYHIKs3O9w,22115
+reykit/rdata.py,sha256=DqxoWkbN3WqGZ5FC9VRlhXAwpTGebv1M5VSeOeR2YnQ,10308
 reykit/remail.py,sha256=s7TXbLgEWEqNoeM42c6FpPufB2LajHgQuahfZri3urQ,6706
 reykit/rimage.py,sha256=p7caatLE71yy7GUTkTKyMOaJTeBfl6pZr_7BFjcDvY8,6159
-reykit/rlog.py,sha256=ykZ8tmMJtwEaAgXmtgtU3SghJG8-ArCIiw0ZawXastg,25564
-reykit/rmonkey.py,sha256=f5vA4t9R6Nz2xfTRUSo2NJ140eg9kT12eaNkKat2AGo,8140
-reykit/rnet.py,sha256=uS27Ownt9ELsjVKpGMPVN1Endc9s7z7CfIBkfE8bPMs,15033
+reykit/rlog.py,sha256=krjeLPptPiYgbXd9h4umx4Nf34Bt6jQBT0MEvatVKL4,25572
+reykit/rmonkey.py,sha256=M-W19Q9OwuYWebLlJK4kpYhUOWufgtahDTAZVPbn83s,8143
+reykit/rnet.py,sha256=zvEWAM42jAdQT868FFDrm-OPn5f3SNfMZP-bU8Sbx0A,16934
 reykit/rnum.py,sha256=PhG4V_BkVfCJUsbpMDN1umGZly1Hsus80TW8bpyBtyY,3653
 reykit/ros.py,sha256=xR79PnSlpHvHsoVKHWvEagreQB24N41XHq-psHQhlMI,40818
 reykit/rrand.py,sha256=9QPXCsREIu45g6WP-XN67X05kmW3cTmctn3InvqYxuY,8947
@@ -15,14 +15,14 @@ reykit/rschedule.py,sha256=_nrfrXYxlFAKCDbM8ibTTb60zNDlHxyE310cv-A19Kw,5799
 reykit/rstdout.py,sha256=Vgqm66rtjIaYWO-EFEm9PGzgXDzZXZGq-BS1Lg6zD40,8197
 reykit/rsys.py,sha256=8Q9ZdggxRHXHMOwjMQa_kBN3gTkmpduHoXrKfa5UXqs,24933
 reykit/rtable.py,sha256=Ua6R1eHMtq4jAaWvfFTsgk-KQmtz5KwuYq4kguzRKaY,12198
-reykit/rtask.py,sha256=Jl2s3cc5i_oKsGu0XJwhzwVwL6LNCULPthlS9N17aeg,22846
+reykit/rtask.py,sha256=98iCzNdJ_fFRDyOLjXEFNW3tzdAwXcCF7JkZ7Gf0fEE,22848
 reykit/rtext.py,sha256=sFp5n5ykD6B812Bywhe6gqzscNmx-U6w80Zf8p1y-Ow,12859
 reykit/rtime.py,sha256=PfhsXZLmSsKY2W1A0VrjhaVbMKVBHBD86AZ8nowNGig,17008
-reykit/rwrap.py,sha256=RK3wlc2cd-lnAvzqzvKsS21EtCmBNTA3i8HRbaolWE4,15275
+reykit/rwrap.py,sha256=gerzOTixYv4uufu3u6VnHhrjNaUZbaTZgVCLzsGaRGQ,15329
 reykit/rzip.py,sha256=ABUDLwEHQIpcvZbJE_oV78H7dik6nC7kaRz660Ro9Os,3481
 reykit/rdll/__init__.py,sha256=1VRawI2vCsLH7KK0PcBRWNc-bwseM-M05wkc_eamwJM,696
 reykit/rdll/rdll_core.py,sha256=o6-rKcTQgxZQe0kD3GnwyNb3KL9IogzgCQNOmYLMm7A,5086
-reykit-1.1.39.dist-info/METADATA,sha256=lRgcs7Kxgo07DEl3rUz2JQXMsbyQACJRdikXeLICUIU,1872
-reykit-1.1.39.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-reykit-1.1.39.dist-info/licenses/LICENSE,sha256=UYLPqp7BvPiH8yEZduJqmmyEl6hlM3lKrFIefiD4rvk,1059
-reykit-1.1.39.dist-info/RECORD,,
+reykit-1.1.41.dist-info/METADATA,sha256=k5-h63vlGnc4U_Owg4cN1PVW77U8RrDrnhWjd9oZgVs,1872
+reykit-1.1.41.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+reykit-1.1.41.dist-info/licenses/LICENSE,sha256=UYLPqp7BvPiH8yEZduJqmmyEl6hlM3lKrFIefiD4rvk,1059
+reykit-1.1.41.dist-info/RECORD,,