aiomisc 17.5.10__py3-none-any.whl → 17.5.15__py3-none-any.whl

aiomisc/aggregate.py

@@ -1,10 +1,21 @@
 import asyncio
+import functools
 import inspect
 import logging
 from asyncio import CancelledError, Event, Future, Lock, wait_for
 from dataclasses import dataclass
 from inspect import Parameter
-from typing import Any, Awaitable, Callable, Iterable, List, Optional, Union
+from typing import (
+    Any,
+    Awaitable,
+    Callable,
+    Generic,
+    Iterable,
+    List,
+    Optional,
+    Protocol,
+    TypeVar,
+)
 
 from .compat import EventLoopMixin
 from .counters import Statistic
@@ -13,19 +24,25 @@ from .counters import Statistic
 log = logging.getLogger(__name__)
 
 
+V = TypeVar("V")
+R = TypeVar("R")
+
+
 @dataclass(frozen=True)
-class Arg:
-    value: Any
-    future: Future
+class Arg(Generic[V, R]):
+    value: V
+    future: "Future[R]"
 
 
 class ResultNotSetError(Exception):
     pass
 
 
-AggFuncHighLevel = Callable[[Any], Awaitable[Iterable]]
-AggFuncAsync = Callable[[Arg], Awaitable]
-AggFunc = Union[AggFuncHighLevel, AggFuncAsync]
+class AggregateAsyncFunc(Protocol, Generic[V, R]):
+    __name__: str
+
+    async def __call__(self, *args: Arg[V, R]) -> None:
+        ...
 
 
 class AggregateStatistic(Statistic):
@@ -36,27 +53,30 @@ class AggregateStatistic(Statistic):
     done: int
 
 
-class Aggregator(EventLoopMixin):
+def _has_variadic_positional(func: Callable[..., Any]) -> bool:
+    return any(
+        parameter.kind == Parameter.VAR_POSITIONAL
+        for parameter in inspect.signature(func).parameters.values()
+    )
 
-    _func: AggFunc
+
+class AggregatorAsync(EventLoopMixin, Generic[V, R]):
+
+    _func: AggregateAsyncFunc[V, R]
     _max_count: Optional[int]
     _leeway: float
     _first_call_at: Optional[float]
     _args: list
-    _futures: List[Future]
+    _futures: "List[Future[R]]"
     _event: Event
     _lock: Lock
 
     def __init__(
-        self, func: AggFunc, *, leeway_ms: float,
+        self, func: AggregateAsyncFunc[V, R], *, leeway_ms: float,
         max_count: Optional[int] = None,
         statistic_name: Optional[str] = None,
     ):
-        has_variadic_positional = any(
-            parameter.kind == Parameter.VAR_POSITIONAL
-            for parameter in inspect.signature(func).parameters.values()
-        )
-        if not has_variadic_positional:
+        if not _has_variadic_positional(func):
             raise ValueError(
                 "Function must accept variadic positional arguments",
             )
@@ -94,9 +114,18 @@ class Aggregator(EventLoopMixin):
     def count(self) -> int:
         return len(self._args)
 
-    async def _execute(self, *, args: list, futures: List[Future]) -> None:
+    async def _execute(
+        self,
+        *,
+        args: List[V],
+        futures: "List[Future[R]]",
+    ) -> None:
+        args_ = [
+            Arg(value=arg, future=future)
+            for arg, future in zip(args, futures)
+        ]
         try:
-            results = await self._func(*args)
+            await self._func(*args_)
             self._statistic.success += 1
         except CancelledError:
             # Other waiting tasks can try to finish the job instead.
@@ -108,31 +137,29 @@ class Aggregator(EventLoopMixin):
         finally:
             self._statistic.done += 1
 
-        self._set_results(results, futures)
-
-    def _set_results(self, results: Iterable, futures: List[Future]) -> None:
-        for future, result in zip(futures, results):
+        # Validate that all results/exceptions are set by the func
+        for future in futures:
             if not future.done():
-                future.set_result(result)
+                future.set_exception(ResultNotSetError)
 
     def _set_exception(
-            self, exc: Exception, futures: List[Future],
+            self, exc: Exception, futures: List["Future[R]"],
     ) -> None:
         for future in futures:
             if not future.done():
                 future.set_exception(exc)
 
-    async def aggregate(self, arg: Any) -> Any:
+    async def aggregate(self, arg: V) -> R:
         if self._first_call_at is None:
             self._first_call_at = self.loop.time()
         first_call_at = self._first_call_at
 
         args: list = self._args
-        futures: List[Future] = self._futures
+        futures: "List[Future[R]]" = self._futures
         event: Event = self._event
         lock: Lock = self._lock
         args.append(arg)
-        future: Future = Future()
+        future: "Future[R]" = Future()
         futures.append(future)
 
         if self.count == self.max_count:
@@ -165,33 +192,61 @@ class Aggregator(EventLoopMixin):
         return future.result()
 
 
-class AggregatorAsync(Aggregator):
+S = TypeVar("S", contravariant=True)
+T = TypeVar("T", covariant=True)
 
-    async def _execute(self, *, args: list, futures: List[Future]) -> None:
-        args = [
-            Arg(value=arg, future=future)
-            for arg, future in zip(args, futures)
-        ]
-        try:
-            await self._func(*args)
-            self._statistic.success += 1
-        except CancelledError:
-            # Other waiting tasks can try to finish the job instead.
-            raise
-        except Exception as e:
-            self._set_exception(e, futures)
-            self._statistic.error += 1
-            return
-        finally:
-            self._statistic.done += 1
 
-        # Validate that all results/exceptions are set by the func
-        for future in futures:
-            if not future.done():
-                future.set_exception(ResultNotSetError)
+class AggregateFunc(Protocol, Generic[S, T]):
+    __name__: str
+
+    async def __call__(self, *args: S) -> Iterable[T]:
+        ...
+
+
+def _to_async_aggregate(func: AggregateFunc[V, R]) -> AggregateAsyncFunc[V, R]:
+    @functools.wraps(
+        func,
+        assigned=tuple(
+            item
+            for item in functools.WRAPPER_ASSIGNMENTS
+            if item != "__annotations__"
+        ),
+    )
+    async def wrapper(*args: Arg[V, R]) -> None:
+        args_ = [item.value for item in args]
+        results = await func(*args_)
+        for res, arg in zip(results, args):
+            if not arg.future.done():
+                arg.future.set_result(res)
+
+    return wrapper
+
+
+class Aggregator(AggregatorAsync[V, R], Generic[V, R]):
+    def __init__(
+        self,
+        func: AggregateFunc[V, R],
+        *,
+        leeway_ms: float,
+        max_count: Optional[int] = None,
+        statistic_name: Optional[str] = None,
+    ) -> None:
+        if not _has_variadic_positional(func):
+            raise ValueError(
+                "Function must accept variadic positional arguments",
+            )
+
+        super().__init__(
+            _to_async_aggregate(func),
+            leeway_ms=leeway_ms,
+            max_count=max_count,
+            statistic_name=statistic_name,
+        )
 
 
-def aggregate(leeway_ms: float, max_count: Optional[int] = None) -> Callable:
+def aggregate(
+    leeway_ms: float, max_count: Optional[int] = None
+) -> Callable[[AggregateFunc[V, R]], Callable[[V], Awaitable[R]]]:
     """
     Parametric decorator that aggregates multiple
     (but no more than ``max_count`` defaulting to ``None``) single-argument
@@ -220,7 +275,7 @@ def aggregate(leeway_ms: float, max_count: Optional[int] = None) -> Callable:
 
     :return:
     """
-    def decorator(func: AggFuncHighLevel) -> Callable[[Any], Awaitable]:
+    def decorator(func: AggregateFunc[V, R]) -> Callable[[V], Awaitable[R]]:
         aggregator = Aggregator(
             func, max_count=max_count, leeway_ms=leeway_ms,
         )
@@ -229,8 +284,8 @@ def aggregate(leeway_ms: float, max_count: Optional[int] = None) -> Callable:
 
 
 def aggregate_async(
-        leeway_ms: float, max_count: Optional[int] = None,
-) -> Callable:
+    leeway_ms: float, max_count: Optional[int] = None,
+) -> Callable[[AggregateAsyncFunc[V, R]], Callable[[V], Awaitable[R]]]:
     """
     Same as ``aggregate``, but with ``func`` arguments of type ``Arg``
     containing ``value`` and ``future`` attributes instead. In this setting
@@ -241,7 +296,9 @@ def aggregate_async(
 
     :return:
     """
-    def decorator(func: AggFuncAsync) -> Callable[[Any], Awaitable]:
+    def decorator(
+        func: AggregateAsyncFunc[V, R]
+    ) -> Callable[[V], Awaitable[R]]:
         aggregator = AggregatorAsync(
             func, max_count=max_count, leeway_ms=leeway_ms,
         )

aiomisc/version.py

@@ -2,5 +2,5 @@
 # BY: poem-plugins "git" plugin
 # NEVER EDIT THIS FILE MANUALLY
 
-version_info = (17, 5, 10)
-__version__ = "17.5.10"
+version_info = (17, 5, 15)
+__version__ = "17.5.15"

{aiomisc-17.5.10.dist-info → aiomisc-17.5.15.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: aiomisc
-Version: 17.5.10
+Version: 17.5.15
 Summary: aiomisc - miscellaneous utils for asyncio
 Home-page: https://github.com/aiokitchen/aiomisc
 License: MIT

{aiomisc-17.5.10.dist-info → aiomisc-17.5.15.dist-info}/RECORD

@@ -1,6 +1,6 @@
 aiomisc/__init__.py,sha256=mgLaoGB3-WTAnrUfEN9nM_0Z_XU6xojkx1ISmW204UA,2253
 aiomisc/_context_vars.py,sha256=28A7j_NABitKMtpxuFvxQ2wCr-Fq79dAC3YjqVLLeTQ,689
-aiomisc/aggregate.py,sha256=srcL3_hwD3noLYo65wx3mI0mTjDyv9B5DsO_3C1XLfs,7819
+aiomisc/aggregate.py,sha256=HU_kVLzA-BdySOH3UIfTEuB2Ty1uUC200hZf4upI504,8834
 aiomisc/backoff.py,sha256=BgdT_MEByFJPyEHjfghC7WhnEen2Lpf4p2VLZV_KVi0,5605
 aiomisc/circuit_breaker.py,sha256=nZVLuGg4rKxn84CHaIvRfBYumgdwx2VZloF8OprQKuk,12581
 aiomisc/compat.py,sha256=aYVe0J-2CvAzUHPAULNhrfMLFYNKN-z3Sg7nlBkzfxw,3291
@@ -39,7 +39,7 @@ aiomisc/signal.py,sha256=_iiC2jukXg7-LLirIl1YATlKIIsKLbmTNFr1Ezheu7g,1728
 aiomisc/thread_pool.py,sha256=Wx0LskSv1dGWoen1lEFRacjVco62hHn6oDaM_XKH6uo,14035
 aiomisc/timeout.py,sha256=rTipPBz0GOqDZG2euVxU_6PjI63nFD_bDsy_DOHHBDQ,863
 aiomisc/utils.py,sha256=6yTfTpeRCVzfZp-MJCmB1oayOHUBVwQwzC3U5PBAjn8,11919
-aiomisc/version.py,sha256=8Z7YshoTGuWHLRL9q31SiCrrQAqccn2XqbYNb-r7Y4Q,156
+aiomisc/version.py,sha256=3CjPNeI8EmqIvEF59PTZGYfu6jqFp-DP1QFO8gJ6w_s,156
 aiomisc/worker_pool.py,sha256=GA91KdOrBlqHthbVSTxu_d6BsBIbl-uKqW2NxqSafG0,11107
 aiomisc_log/__init__.py,sha256=ZD-Q-YTWoZdxJpMqMNMIraA_gaN0QawgnVpXz6mxd2o,4855
 aiomisc_log/enum.py,sha256=_zfCZPYCGyI9KL6TqHiYVlOfA5U5MCbsuCuDKxDHdxg,1549
@@ -57,8 +57,8 @@ aiomisc_worker/process_inner.py,sha256=8ZtjCSLrgySW57OIbuGrpEWxfysRLYKx1or1YaAqx
 aiomisc_worker/protocol.py,sha256=1smmlBbdreSmnrxuhHaUMUC10FO9xMIEcedhweQJX_A,2705
 aiomisc_worker/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 aiomisc_worker/worker.py,sha256=f8nCFhlKh84UUBUaEgCllwMRvVZiD8_UUXaeit6g3T8,3236
-aiomisc-17.5.10.dist-info/COPYING,sha256=Ky_8CQMaIixfyOreUBsl0hKN6A5fLnPF8KPQ9molMYA,1125
-aiomisc-17.5.10.dist-info/METADATA,sha256=_5kK7CJi6HtRI5SentrIy1GQn2ceWHoB1NT0jNJ6bY4,15664
-aiomisc-17.5.10.dist-info/WHEEL,sha256=sP946D7jFCHeNz5Iq4fL4Lu-PrWrFsgfLXbbkciIZwg,88
-aiomisc-17.5.10.dist-info/entry_points.txt,sha256=KRsSPCwKJyGTWrvzpwbS0yIDwzsgDA2X6f0CBWYmNao,55
-aiomisc-17.5.10.dist-info/RECORD,,
+aiomisc-17.5.15.dist-info/COPYING,sha256=Ky_8CQMaIixfyOreUBsl0hKN6A5fLnPF8KPQ9molMYA,1125
+aiomisc-17.5.15.dist-info/METADATA,sha256=74u26dLlBO_yNtGagNvQTMN-ZT2KNMl-rUhV0aUJIfY,15664
+aiomisc-17.5.15.dist-info/WHEEL,sha256=sP946D7jFCHeNz5Iq4fL4Lu-PrWrFsgfLXbbkciIZwg,88
+aiomisc-17.5.15.dist-info/entry_points.txt,sha256=KRsSPCwKJyGTWrvzpwbS0yIDwzsgDA2X6f0CBWYmNao,55
+aiomisc-17.5.15.dist-info/RECORD,,