reykit 1.1.11__py3-none-any.whl → 1.1.13__py3-none-any.whl

reykit/rmultitask.py

@@ -10,362 +10,51 @@
 
 
 from __future__ import annotations
-from typing import Any, Literal
+from typing import Any, Literal, overload
 from collections.abc import Callable, Iterable, Generator, Coroutine
 from threading import RLock as TRLock, get_ident as threading_get_ident
 from concurrent.futures import ThreadPoolExecutor, Future as CFuture, as_completed as concurrent_as_completed
+from queue import Queue as QQueue
 from asyncio import (
     Future as AFuture,
-    Queue as AQueue,
     Lock as ALock,
+    Task as ATask,
+    Queue as AQueue,
+    sleep as asyncio_sleep,
     run as asyncio_run,
     gather as asyncio_gather,
-    iscoroutine
+    iscoroutine as asyncio_iscoroutine,
+    iscoroutinefunction as asyncio_iscoroutinefunction,
+    run_coroutine_threadsafe as asyncio_run_coroutine_threadsafe,
+    new_event_loop as asyncio_new_event_loop,
+    set_event_loop as asyncio_set_event_loop
 )
-from asyncio.queues import QueueEmpty
 from aiohttp import ClientSession, ClientResponse
 
 from .rexception import throw, check_most_one, check_response_code
-from .rtime import sleep, RTimeMark
+from .rtime import randn, RTimeMark
+from .rtype import T
 from .rwrap import wrap_thread
 
 
 __all__ = (
+    'RThreadPool',
     'async_run',
+    'async_sleep',
+    'async_wait',
     'async_request',
-    'RThreadLock',
-    'RAsyncLock',
-    'RThreadPool',
     'RAsyncPool'
 )
 
 
-def async_run(*coroutines: Coroutine) -> list:
-    """
-    Asynchronous run `Coroutine` instances.
-
-    Parameters
-    ----------
-    coroutines : `Coroutine` instances.
-
-    Returns
-    -------
-    Run result list.
-    """
-
-
-    # Define.
-    async def gather_coroutine() -> AFuture:
-        """
-        Get `Future` instance.
-
-        Returns
-        -------
-        Future instance.
-        """
-
-        # Gather.
-        future = await asyncio_gather(*coroutines)
-
-        return future
-
-
-    # Run.
-    result = asyncio_run(gather_coroutine())
-
-    return result
-
-
-async def async_request(
-    url: str,
-    params: dict | None = None,
-    data: dict | str | bytes | None = None,
-    json: dict | None = None,
-    headers: dict[str, str] = {},
-    timeout: float | None = None,
-    proxy: str | None = None,
-    method: Literal['get', 'post', 'put', 'patch', 'delete', 'options', 'head'] | None = None,
-    check: bool | int | Iterable[int] = False,
-    handler: str | tuple[str] | Callable[[ClientResponse], Coroutine | Any] | None = None
-) -> Any:
-    """
-    Get asynchronous `Coroutine` instance of send request.
-
-    Parameters
-    ----------
-    url : Request URL.
-    params : Request URL add parameters.
-    data : Request body data. Conflict with parameter `json`.
-        - `dict`, Convert to `key=value&...`: format bytes.
-            Automatic set `Content-Type` to `application/x-www-form-urlencoded`.
-        - `dict and a certain value is 'bytes' type`: Key is parameter name and file name, value is file data.
-            Automatic set `Content-Type` to `multipart/form-data`.
-        - `str`: File path to read file bytes data.
-            Automatic set `Content-Type` to file media type, and `filename` to file name.
-        - `bytes`: File bytes data.
-            Automatic set `Content-Type` to file media type.
-    json : Request body data, convert to `JSON` format. Conflict with parameter `data`.
-        Automatic set `Content-Type` to `application/json`.
-    headers : Request header data.
-    timeout : Request maximun waiting time.
-    proxy : Proxy URL.
-    method : Request method.
-        - `None`: Automatic judge.
-            When parameter `data` or `json` not has value, then request method is `get`.
-            When parameter `data` or `json` has value, then request method is `post`.
-        - `Literal['get', 'post', 'put', 'patch', 'delete', 'options', 'head']`: Use this request method.
-    check : Check response code, and throw exception.
-        - `Literal[False]`: Not check.
-        - `Literal[True]`: Check if is between 200 and 299.
-        - `int`: Check if is this value.
-        - `Iterable`: Check if is in sequence.
-    handler : Response handler.
-        - `None`: Automatic handle.
-            `Response 'Content-Type' is 'application/json'`: Use `ClientResponse.json` method.
-            `Response 'Content-Type' is 'text/plain; charset=utf-8'`: Use `ClientResponse.text` method.
-            `Other`: Use `ClientResponse.read` method.
-        - `str`: Get this attribute.
-            `Callable`: Execute this method. When return `Coroutine`, then use `await` syntax execute `Coroutine`.
-            `Any`: Return this value.
-        - `tuple[str]`: Get these attribute.
-            `Callable`: Execute this method. When return `Coroutine`, then use `await` syntax execute `Coroutine`.
-            `Any`: Return this value.
-        - `Callable`, Execute this method. When return `Coroutine`, then use `await`: syntax execute `Coroutine`.
-
-    Returns
-    -------
-    Response handler result.
-    """
-
-    # Check.
-    check_most_one(data, json)
-
-    # Handle parameter.
-    if method is None:
-        if data is None and json is None:
-            method = 'get'
-        else:
-            method = 'post'
-
-    # Session.
-    async with ClientSession() as session:
-
-        # Request.
-        async with session.request(
-            method,
-            url,
-            params=params,
-            data=data,
-            json=json,
-            headers=headers,
-            timeout=timeout,
-            proxy=proxy
-        ) as response:
-
-            # Check code.
-            if check is not False:
-                if check is True:
-                    range_ = None
-                else:
-                    range_ = check
-                check_response_code(response.status, range_)
-
-            # Receive.
-            match handler:
-
-                ## Auto.
-                case None:
-                    match response.content_type:
-                        case 'application/json':
-                            result = await response.json()
-                        case 'text/plain; charset=utf-8':
-
-                            # Set encode type.
-                            if response.get_encoding() == 'ISO-8859-1':
-                                encoding = 'utf-8'
-                            else:
-                                encoding = None
-
-                            result = await response.text(encoding=encoding)
-                        case _:
-                            result = await response.read()
-
-                ## Attribute.
-                case str():
-                    result = getattr(response, handler)
-
-                    ### Method.
-                    if callable(result):
-                        result = result()
-
-                        #### Coroutine.
-                        if iscoroutine(result):
-                            result = await result
-
-                ## Attributes.
-                case tuple():
-                    result = []
-                    for key in handler:
-                        result_element = getattr(response, key)
-
-                        ### Method.
-                        if callable(result_element):
-                            result_element = result_element()
-
-                            #### Coroutine.
-                            if iscoroutine(result_element):
-                                result_element = await result_element
-
-                        result.append(result_element)
-
-                ## Method.
-                case _ if callable(handler):
-                    result = handler(response)
-
-                    ### Coroutine.
-                    if iscoroutine(result):
-                        result = await result
-
-                ## Throw exception.
-                case _:
-                    throw(TypeError, handler)
-
-            return result
-
-
-class RThreadLock():
-    """
-    Rey's `thread lock` type.
-    """
-
-
-    def __init__(self) -> None:
-        """
-        Build `thread lock` attributes.
-        """
-
-        # Set attribute.
-        self.lock = TRLock()
-        self.acquire_thread_id: int | None = None
-
-
-    def acquire(
-        self,
-        timeout: float = None
-    ) -> bool:
-        """
-        Wait and acquire thread lock.
-
-        Parameters
-        ----------
-        timeout : Maximum wait seconds.
-            - `None`: Not limit.
-            - `float`: Use this value.
-
-        Returns
-        -------
-        Whether acquire success.
-        """
-
-        # Handle parameter.
-        if timeout is None:
-            timeout = -1
-
-        # Acquire.
-        result = self.lock.acquire(timeout=timeout)
-
-        # Update attribute.
-        if result:
-            thread_id = threading_get_ident()
-            self.acquire_thread_id = thread_id
-
-        return result
-
-
-    def release(self) -> None:
-        """
-        Release thread lock.
-        """
-
-        # Release.
-        self.lock.release()
-
-        # Update attribute.
-        self.acquire_thread_id = None
-
-
-    def __call__(self) -> None:
-        """
-        Automatic judge, wait and acquire thread lock, or release thread lock.
-        """
-
-        # Release.
-        thread_id = threading_get_ident()
-        if thread_id == self.acquire_thread_id:
-            self.release()
-
-        # Acquire.
-        else:
-            self.acquire()
-
-
-class RAsyncLock():
-    """
-    Rey's `asynchronous lock` type.
-    """
-
-
-    def __init__(self) -> None:
-        """
-        Build `asynchronous lock` attributes.
-        """
-
-        # Set attribute.
-        self.lock = ALock()
-
-
-    def acquire(
-        self,
-        timeout: float = None
-    ) -> bool:
-        """
-        Wait and acquire thread lock.
-
-        Parameters
-        ----------
-        timeout : Maximum wait seconds.
-            - `None`: Not limit.
-            - `float`: Use this value.
-
-        Returns
-        -------
-        Whether acquire success.
-        """
-
-        # Handle parameter.
-        if timeout is None:
-            timeout = -1
-
-        # Acquire.
-        result = self.lock.acquire()
-
-        return result
-
-
-    def release(self) -> None:
-        """
-        Release thread lock.
-        """
-
-        # Release.
-        self.lock.release()
-
-
 class RThreadPool(object):
     """
     Rey's `thread pool` type.
     """
 
+    Queue = QQueue
+    Lock = TRLock
+
 
     def __init__(
         self,
@@ -380,18 +69,18 @@ class RThreadPool(object):
         Parameters
         ----------
         task : Thread task.
-        args : Task default position arguments.
+        args : ATask default position arguments.
         _max_workers : Maximum number of threads.
             - `None`: Number of CPU + 4, 32 maximum.
             - `int`: Use this value, no maximum limit.
-        kwargs : Task default keyword arguments.
+        kwargs : ATask default keyword arguments.
         """
 
         # Set attribute.
         self.task = task
         self.args = args
         self.kwargs = kwargs
-        self.thread_pool = ThreadPoolExecutor(
+        self.pool = ThreadPoolExecutor(
             _max_workers,
             task.__name__
         )
@@ -404,16 +93,16 @@ class RThreadPool(object):
         **kwargs: Any
     ) -> CFuture:
         """
-        Add and start a task to the thread pool.
+        Start a task.
 
         Parameters
         ----------
-        args : Task position arguments, after default position arguments.
-        kwargs : Task keyword arguments, after default keyword arguments.
+        args : ATask position arguments, after default position arguments.
+        kwargs : ATask keyword arguments, after default keyword arguments.
 
         Returns
         -------
-        Task instance.
+        ATask instance.
         """
 
         # Set parameter.
@@ -426,8 +115,8 @@ class RThreadPool(object):
             **kwargs
         }
 
-        # Submit.
-        future = self.thread_pool.submit(
+        # Add.
+        future = self.pool.submit(
             self.task,
             *func_args,
             **func_kwargs
@@ -445,7 +134,7 @@ class RThreadPool(object):
         **kwargs: tuple
     ) -> list[CFuture]:
         """
-        Add and start a batch of tasks to the thread pool.
+        Batch start tasks.
         parameters sequence will combine one by one, and discard excess parameters.
 
         Parameters
@@ -455,7 +144,7 @@ class RThreadPool(object):
 
         Returns
         -------
-        Task instance list.
+        ATask instance list.
 
         Examples
         --------
@@ -483,7 +172,7 @@ class RThreadPool(object):
         )
         params_zip = zip(args_zip, kwargs_zip)
 
-        # Batch submit.
+        # Batch add.
         futures = [
             self.one(*args_, **dict(kwargs_))
             for args_, kwargs_ in params_zip
@@ -495,6 +184,34 @@ class RThreadPool(object):
         return futures
 
 
+    def repeat(
+        self,
+        number: int
+    ) -> list[CFuture]:
+        """
+        Batch start tasks, and only with default parameters.
+
+        Parameters
+        ----------
+        number : Number of add.
+
+        Returns
+        -------
+        ATask instance list.
+        """
+
+        # Batch add.
+        futures = [
+            self.one()
+            for _ in range(number)
+        ]
+
+        # Save.
+        self.futures.extend(futures)
+
+        return futures
+
+
     def generate(
         self,
         timeout: float | None = None
@@ -508,85 +225,444 @@ class RThreadPool(object):
             - `None`: Infinite.
             - `float`: Set this seconds.
 
-        Returns
-        -------
-        Generator of added task instance.
-        """
+        Returns
+        -------
+        Generator of added task instance.
+        """
+
+        # Build.
+        generator = concurrent_as_completed(
+            self.futures,
+            timeout
+        )
+
+        return generator
+
+
+    def join(
+        self,
+        timeout: float | None = None
+    ) -> None:
+        """
+        Block until all tasks are done.
+
+        Parameters
+        ----------
+        timeout : Call generator maximum waiting seconds, timeout throw exception.
+            - `None`: Infinite.
+            - `float`: Set this seconds.
+        """
+
+        # Generator.
+        generator = self.generate(timeout)
+
+        # Wait.
+        for _ in generator:
+            pass
+
+
+    def __iter__(self) -> Generator:
+        """
+        Return the generator of task result.
+
+        Returns
+        -------
+        Generator of task result.
+        """
+
+        # Generator.
+        generator = self.generate()
+        self.futures.clear()
+
+        # Generate.
+        for future in generator:
+            yield future.result()
+
+
+    @property
+    def thread_id(self) -> int:
+        """
+        Get current thread ID.
+
+        Returns
+        -------
+        Current thread ID.
+        """
+
+        # Get.
+        thread_id = threading_get_ident()
+
+        return thread_id
+
+
+    __call__ = one
+
+
+    __mul__ = repeat
+
+
+@overload
+def async_run(
+    coroutine: Coroutine[Any, Any, T] | ATask[Any, Any, T] | Callable[[], Coroutine[Any, Any, T]],
+    *,
+    return_exceptions: bool = False
+) -> T: ...
+
+@overload
+def async_run(
+    *coroutines: Coroutine[Any, Any, T] | ATask[Any, Any, T] |  Callable[[], Coroutine[Any, Any, T]],
+    return_exceptions: bool = False
+) -> list[T]: ...
+
+def async_run(
+    *coroutines: Coroutine[Any, Any, T] | ATask[Any, Any, T] |  Callable[[], Coroutine[Any, Any, T]],
+    return_exceptions: bool = False
+) -> T | list[T]:
+    """
+    Asynchronous run coroutines.
+
+    Parameters
+    ----------
+    coroutines : `Coroutine` instances or `ATask` instances or `Coroutine` function.
+    return_exceptions : Whether return exception instances, otherwise throw first exception.
+
+    Returns
+    -------
+    run results.
+    """
+
+    # Handle parameter.
+    coroutines = [
+        coroutine()
+        if asyncio_iscoroutinefunction(coroutine)
+        else coroutine
+        for coroutine in coroutines
+    ]
+
+    # Define.
+    async def async_run_coroutine() -> list:
+        """
+        Asynchronous run coroutines.
+
+        Returns
+        -------
+        Run result list.
+        """
+
+        # Gather.
+        results = await asyncio_gather(*coroutines, return_exceptions=return_exceptions)
+
+        return results
+
+
+    # Run.
+    coroutine = async_run_coroutine()
+    results = asyncio_run(coroutine)
+
+    # One.
+    if len(results) == 1:
+        results = results[0]
+
+    return results
+
+
+@overload
+async def async_sleep(
+    *,
+    precision: None = None
+) -> int: ...
+
+@overload
+async def async_sleep(
+    second: int,
+    *,
+    precision: None = None
+) -> int: ...
+
+@overload
+async def async_sleep(
+    low: int = 0,
+    high: int = 10,
+    *,
+    precision: None = None
+) -> int: ...
+
+@overload
+async def async_sleep(
+    *thresholds: float,
+    precision: None = None
+) -> float: ...
+
+@overload
+async def async_sleep(
+    *thresholds: float,
+    precision: Literal[0] = None
+) -> int: ...
+
+@overload
+async def async_sleep(
+    *thresholds: float,
+    precision: int = None
+) -> float: ...
+
+async def async_sleep(
+    *thresholds: float,
+    precision: int | None = None
+) -> float:
+    """
+    Sleep random seconds, in the coroutine.
+
+    Parameters
+    ----------
+    thresholds : Low and high thresholds of random range, range contains thresholds.
+        - When `length is 0`, then low and high thresholds is `0` and `10`.
+        - When `length is 1`, then sleep this value.
+        - When `length is 2`, then low and high thresholds is `thresholds[0]` and `thresholds[1]`.
+    
+    precision : Precision of random range, that is maximum decimal digits of sleep seconds.
+        - `None`: Set to Maximum decimal digits of element of parameter `thresholds`.
+        - `int`: Set to this value.
+    
+    Returns
+    -------
+    Random seconds.
+        - When parameters `precision` is `0`, then return int.
+        - When parameters `precision` is `greater than 0`, then return float.
+    """
+
+    # Handle parameter.
+    if len(thresholds) == 1:
+        second = thresholds[0]
+    else:
+        second = randn(*thresholds, precision=precision)
+
+    # Sleep.
+    await asyncio_sleep(second)
+
+    return second
+
+
+async def async_wait(
+    func: Callable[..., bool],
+    *args: Any,
+    _interval: float = 1,
+    _timeout: float | None = None,
+    _raising: bool = True,
+    **kwargs: Any
+) -> float | None:
+    """
+    Wait success.
+
+    Parameters
+    ----------
+    func : Function to be decorated, must return `bool` value.
+    args : Position arguments of decorated function.
+    _interval : Interval seconds.
+    _timeout : Timeout seconds, timeout throw exception.
+        - `None`: Infinite time.
+        - `float`: Use this time.
+    _raising : When timeout, whether throw exception, otherwise return None.
+    kwargs : Keyword arguments of decorated function.
+
+    Returns
+    -------
+    Total spend seconds or None.
+    """
+
+    # Set parameter.
+    rtm = RTimeMark()
+    rtm()
+
+    # Not set timeout.
+    if _timeout is None:
+
+        ## Wait.
+        while True:
+            success = func(*args, **kwargs)
+            if success: break
+            await async_sleep(_interval)
+
+    # Set timeout.
+    else:
+
+        ## Wait.
+        while True:
+            success = func(*args, **kwargs)
+            if success: break
+
+            ## Timeout.
+            rtm()
+            if rtm.total_spend > _timeout:
+
+                ### Throw exception.
+                if _raising:
+                    throw(TimeoutError, _timeout)
+
+                return
+
+            ## Sleep.
+            await async_sleep(_interval)
 
-        # Get parameter.
-        self.futures, futures = [], self.futures
+    ## Return.
+    rtm()
+    return rtm.total_spend
 
-        # Build.
-        generator = concurrent_as_completed(
-            futures,
-            timeout
-        )
 
-        return generator
+async def async_request(
+    url: str,
+    params: dict | None = None,
+    data: dict | str | bytes | None = None,
+    json: dict | None = None,
+    headers: dict[str, str] = {},
+    timeout: float | None = None,
+    proxy: str | None = None,
+    method: Literal['get', 'post', 'put', 'patch', 'delete', 'options', 'head'] | None = None,
+    check: bool | int | Iterable[int] = False,
+    handler: str | tuple[str] | Callable[[ClientResponse], Coroutine | Any] | None = None
+) -> Any:
+    """
+    Get asynchronous `Coroutine` instance of send request.
 
+    Parameters
+    ----------
+    url : Request URL.
+    params : Request URL add parameters.
+    data : Request body data. Conflict with parameter `json`.
+        - `dict`, Convert to `key=value&...`: format bytes.
+            Automatic set `Content-Type` to `application/x-www-form-urlencoded`.
+        - `dict and a certain value is 'bytes' type`: Key is parameter name and file name, value is file data.
+            Automatic set `Content-Type` to `multipart/form-data`.
+        - `str`: File path to read file bytes data.
+            Automatic set `Content-Type` to file media type, and `filename` to file name.
+        - `bytes`: File bytes data.
+            Automatic set `Content-Type` to file media type.
+    json : Request body data, convert to `JSON` format. Conflict with parameter `data`.
+        Automatic set `Content-Type` to `application/json`.
+    headers : Request header data.
+    timeout : Request maximun waiting time.
+    proxy : Proxy URL.
+    method : Request method.
+        - `None`: Automatic judge.
+            When parameter `data` or `json` not has value, then request method is `get`.
+            When parameter `data` or `json` has value, then request method is `post`.
+        - `Literal['get', 'post', 'put', 'patch', 'delete', 'options', 'head']`: Use this request method.
+    check : Check response code, and throw exception.
+        - `Literal[False]`: Not check.
+        - `Literal[True]`: Check if is between 200 and 299.
+        - `int`: Check if is this value.
+        - `Iterable`: Check if is in sequence.
+    handler : Response handler.
+        - `None`: Automatic handle.
+            `Response 'Content-Type' is 'application/json'`: Use `ClientResponse.json` method.
+            `Response 'Content-Type' is 'text/plain; charset=utf-8'`: Use `ClientResponse.text` method.
+            `Other`: Use `ClientResponse.read` method.
+        - `str`: Get this attribute.
+            `Callable`: Execute this method. When return `Coroutine`, then use `await` syntax execute `Coroutine`.
+            `Any`: Return this value.
+        - `tuple[str]`: Get these attribute.
+            `Callable`: Execute this method. When return `Coroutine`, then use `await` syntax execute `Coroutine`.
+            `Any`: Return this value.
+        - `Callable`, Execute this method. When return `Coroutine`, then use `await`: syntax execute `Coroutine`.
 
-    def repeat(
-        self,
-        number: int
-    ) -> list[CFuture]:
-        """
-        Add and start a batch of tasks to the thread pool, and only with default parameters.
+    Returns
+    -------
+    Response handler result.
+    """
 
-        Parameters
-        ----------
-        number : Number of add.
+    # Check.
+    check_most_one(data, json)
 
-        Returns
-        -------
-        Task instance list.
-        """
+    # Handle parameter.
+    if method is None:
+        if data is None and json is None:
+            method = 'get'
+        else:
+            method = 'post'
 
-        # Batch submit.
-        futures = [
-            self.one()
-            for _ in range(number)
-        ]
+    # Session.
+    async with ClientSession() as session:
 
-        # Save.
-        self.futures.extend(futures)
+        # Request.
+        async with session.request(
+            method,
+            url,
+            params=params,
+            data=data,
+            json=json,
+            headers=headers,
+            timeout=timeout,
+            proxy=proxy
+        ) as response:
 
-        return futures
+            # Check code.
+            if check is not False:
+                if check is True:
+                    range_ = None
+                else:
+                    range_ = check
+                check_response_code(response.status, range_)
 
+            # Receive.
+            match handler:
 
-    def join(self) -> None:
-        """
-        Block until all tasks are done.
-        """
+                ## Auto.
+                case None:
+                    match response.content_type:
+                        case 'application/json':
+                            result = await response.json()
+                        case 'text/plain; charset=utf-8':
 
-        # Generator.
-        generator = self.generate()
+                            # Set encode type.
+                            if response.get_encoding() == 'ISO-8859-1':
+                                encoding = 'utf-8'
+                            else:
+                                encoding = None
 
-        # Wait.
-        for _ in generator:
-            pass
+                            result = await response.text(encoding=encoding)
+                        case _:
+                            result = await response.read()
 
+                ## Attribute.
+                case str():
+                    result = getattr(response, handler)
 
-    def __iter__(self) -> Generator:
-        """
-        Return the generator of task result.
+                    ### Method.
+                    if callable(result):
+                        result = result()
 
-        Returns
-        -------
-        Generator of task result.
-        """
+                        #### Coroutine.
+                        if asyncio_iscoroutine(result):
+                            result = await result
 
-        # Generator.
-        generator = self.generate()
+                ## Attributes.
+                case tuple():
+                    result = []
+                    for key in handler:
+                        result_element = getattr(response, key)
 
-        # Generate.
-        for future in generator:
-            yield future.result()
+                        ### Method.
+                        if callable(result_element):
+                            result_element = result_element()
 
+                            #### Coroutine.
+                            if asyncio_iscoroutine(result_element):
+                                result_element = await result_element
 
-    __call__ = one
+                        result.append(result_element)
+
+                ## Method.
+                case _ if callable(handler):
+                    result = handler(response)
 
+                    ### Coroutine.
+                    if asyncio_iscoroutine(result):
+                        result = await result
 
-    __mul__ = repeat
+                ## Throw exception.
+                case _:
+                    throw(TypeError, handler)
+
+            return result
 
 
 class RAsyncPool(object):
@@ -594,13 +670,14 @@ class RAsyncPool(object):
     Rey's `asynchronous pool` type.
     """
 
+    Queue = AQueue
+    Lock = ALock
+
 
     def __init__(
         self,
-        async_func: Callable[..., Coroutine],
+        task: Callable[..., Coroutine],
         *args: Any,
-        _max_async: int = 10,
-        _exc_handler: Callable | None = None,
         **kwargs: Any
     ) -> None:
         """
@@ -610,76 +687,31 @@ class RAsyncPool(object):
         ----------
         async_func : Function of create asynchronous `Coroutine`.
         args : Function default position arguments.
-        _max_async : Maximum number of asynchronous.
-        _exc_handler : `Coroutine` execution exception handler, will return value.
         kwargs : Function default keyword arguments.
         """
 
         # Set attribute.
-        self.async_func = async_func
+        self.task = task
         self.args = args
         self.kwargs = kwargs
-        self.exc_handler = _exc_handler
-        self.queue_input: AQueue[tuple[tuple, dict]] = AQueue()
-        self.queue_output = AQueue()
-        self.queue_count = 0
+        self.loop = asyncio_new_event_loop()
+        self.futures: list[AFuture] = []
 
         # Start.
-        self._start_workers(_max_async)
+        self._start_loop()
 
 
     @wrap_thread
-    def _start_workers(
-        self,
-        worker_n: int
-    ) -> None:
+    def _start_loop(self) -> None:
         """
-        Start workers of execute asynchronous `Coroutine`.
-
-        Parameters
-        ----------
-        worker_n : Number of execute asynchronous `Coroutine` workers.
+        Start event loop.
         """
 
+        # Set.
+        asyncio_set_event_loop(self.loop)
 
-        # Define.
-        async def async_worker() -> None:
-            """
-            Worker of execute asynchronous `Coroutine`.
-            """
-
-            # Loop.
-            while True:
-
-                # Get parameter.
-                args, kwargs = await self.queue_input.get()
-
-                # Execute.
-                try:
-                    result = await self.async_func(*args, **kwargs)
-
-                # Handle exception.
-                except:
-                    if self.exc_handler is not None:
-                        result = self.exc_handler()
-                        await self.queue_output.put(result)
-
-                    ## Count.
-                    else:
-                        self.queue_count -= 1
-
-                else:
-                    await self.queue_output.put(result)
-
-
-        # Create.
-        coroutines = [
-            async_worker()
-            for _ in range(worker_n)
-        ]
-
-        # Start.
-        async_run(*coroutines)
+        ## Start and block.
+        self.loop.run_forever()
 
 
     def one(
@@ -688,7 +720,7 @@ class RAsyncPool(object):
         **kwargs: Any
     ) -> None:
         """
-        Add and start a task to the pool.
+        Start a task.
 
         Parameters
         ----------
@@ -705,16 +737,15 @@ class RAsyncPool(object):
             **self.kwargs,
             **kwargs
         }
-        item = (
-            func_args,
-            func_kwargs
-        )
 
-        # Count.
-        self.queue_count += 1
+        # Create.
+        coroutine = self.task(*func_args, **func_kwargs)
+
+        # Add.
+        future = asyncio_run_coroutine_threadsafe(coroutine, self.loop)
 
-        # Put.
-        self.queue_input.put_nowait(item)
+        # Save.
+        self.futures.append(future)
 
 
     def batch(
@@ -723,7 +754,7 @@ class RAsyncPool(object):
         **kwargs: tuple
     ) -> None:
         """
-        Add and start a batch of tasks to the pool.
+        Batch start tasks.
         parameters sequence will combine one by one, and discard excess parameters.
 
         Parameters
@@ -758,7 +789,7 @@ class RAsyncPool(object):
         )
         params_zip = zip(args_zip, kwargs_zip)
 
-        # Batch submit.
+        # Batch add.
         for args_, kwargs_ in params_zip:
             self.one(*args_, **dict(kwargs_))
 
@@ -768,100 +799,92 @@ class RAsyncPool(object):
         number: int
     ) -> list[CFuture]:
         """
-        Add and start a batch of tasks to the pool, and only with default parameters.
+        Batch start tasks, and only with default parameters.
 
         Parameters
         ----------
         number : Number of add.
         """
 
-        # Batch submit.
+        # Batch add.
         for _ in range(number):
             self.one()
 
 
-    def get(
+    def generate(
         self,
         timeout: float | None = None
-    ) -> Any:
+    ) -> Generator[CFuture]:
         """
-        Get one execution result of asynchronous `Coroutine`, will block.
+        Return the generator of added task instance.
 
         Parameters
         ----------
-        timeout : Maximum seconds of block.
+        timeout : Call generator maximum waiting seconds, timeout throw exception.
+            - `None`: Infinite.
+            - `float`: Set this seconds.
 
         Returns
         -------
-        One execution result.
+        Generator of added task instance.
         """
 
-        # Set parameter.
-        if timeout is not None:
-            rtm = RTimeMark()
-            rtm()
-
-        # Loop.
-        while True:
-
-            # Judge.
-            if not self.queue_output.empty():
-
-                # Get.
-                try:
-                    result = self.queue_output.get_nowait()
-                except QueueEmpty:
-                    pass
-                else:
-
-                    # Count.
-                    self.queue_count -= 1
-
-                    return result
-
-            # Timeout.
-            if timeout is not None:
-                rtm()
-                if rtm.total_spend > timeout:
-                    throw(TimeoutError, timeout)
+        # Build.
+        generator = concurrent_as_completed(
+            self.futures,
+            timeout
+        )
 
-            # Sleep.
-            sleep(0.01)
+        return generator
 
 
-    def join(self) -> None:
-        """
-        Block until all asynchronous `Coroutine` are done.
+    def join(
+        self,
+        timeout: float | None = None
+    ) -> None:
         """
+        Block until all tasks are done.
 
-        # Generate.
-        while True:
+        Parameters
+        ----------
+        timeout : Call generator maximum waiting seconds, timeout throw exception.
+            - `None`: Infinite.
+            - `float`: Set this seconds.
+        """
 
-            # Break.
-            if self.queue_count == 0:
-                break
+        # Generator.
+        generator = self.generate(timeout)
 
-            self.get()
+        # Wait.
+        for _ in generator:
+            pass
 
 
     def __iter__(self) -> Generator:
         """
-        Return the generator of result of asynchronous `Coroutine`.
+        Return the generator of task result.
 
         Returns
         -------
-        Generator of result of asynchronous `Coroutine`.
+        Generator of task result.
         """
 
+        # Generator.
+        generator = self.generate()
+        self.futures.clear()
+
         # Generate.
-        while True:
+        for future in generator:
+            yield future.result()
+
 
-            # Break.
-            if self.queue_count == 0:
-                break
+    def __del__(self) -> None:
+        """
+        End loop.
+        """
 
-            result = self.get()
-            yield result
+        # Stop.
+        self.loop.stop()
 
 
     __call__ = one