aiomisc 17.7.8__tar.gz → 17.8.1__tar.gz

{aiomisc-17.7.8 → aiomisc-17.8.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: aiomisc
-Version: 17.7.8
+Version: 17.8.1
 Summary: aiomisc - miscellaneous utils for asyncio
 License: MIT
 Author: Dmitry Orlov

{aiomisc-17.7.8 → aiomisc-17.8.1}/aiomisc/entrypoint.py

@@ -419,7 +419,7 @@ class Entrypoint:
         handle = loop.call_later(self.shutdown_timeout, task.cancel)
 
         def on_shutdown_finish(task: asyncio.Future) -> None:
-            nonlocal handle, loop
+            nonlocal handle, loop   # noqa
 
             if task.cancelled():
                 log.warning(

{aiomisc-17.7.8 → aiomisc-17.8.1}/aiomisc/iterator_wrapper.py

@@ -9,7 +9,7 @@ from time import time
 from types import TracebackType
 from typing import (
     Any, AsyncIterator, Awaitable, Callable, Deque, Generator, NoReturn,
-    Optional, Type, TypeVar, Union,
+    Optional, Type, TypeVar, Union, Generic, ParamSpec,
 )
 from weakref import finalize
 
@@ -19,8 +19,9 @@ from aiomisc.counters import Statistic
 
 T = TypeVar("T")
 R = TypeVar("R")
+P = ParamSpec("P")
 
-GenType = Generator[T, R, None]
+GenType = Generator[T, None, None]
 FuncType = Callable[[], GenType]
 
 
@@ -144,7 +145,7 @@ class IteratorWrapperStatistic(Statistic):
     enqueued: int
 
 
-class IteratorWrapper(AsyncIterator, EventLoopMixin):
+class IteratorWrapper(Generic[P, T], AsyncIterator, EventLoopMixin):
     __slots__ = (
         "__channel",
         "__close_event",
@@ -155,9 +156,11 @@ class IteratorWrapper(AsyncIterator, EventLoopMixin):
     ) + EventLoopMixin.__slots__
 
     def __init__(
-        self, gen_func: FuncType,
+        self,
+        gen_func: Callable[P, Generator[T, None, None]],
         loop: Optional[asyncio.AbstractEventLoop] = None,
-        max_size: int = 0, executor: Optional[Executor] = None,
+        max_size: int = 0,
+        executor: Optional[Executor] = None,
         statistic_name: Optional[str] = None,
     ):
 
@@ -227,11 +230,9 @@ class IteratorWrapper(AsyncIterator, EventLoopMixin):
             await asyncio.gather(self.__gen_task, return_exceptions=True)
 
     def _run(self) -> Any:
-        return self.loop.run_in_executor(
-            self.executor, self._in_thread,
-        )
+        return self.loop.run_in_executor(self.executor, self._in_thread)
 
-    def __aiter__(self) -> AsyncIterator[Any]:
+    def __aiter__(self) -> AsyncIterator[T]:
         if not self.loop.is_running():
             raise RuntimeError("Event loop is not running")
 
@@ -242,7 +243,7 @@ class IteratorWrapper(AsyncIterator, EventLoopMixin):
             self.__gen_task = gen_task
         return IteratorProxy(self, self.close)
 
-    async def __anext__(self) -> Awaitable[T]:
+    async def __anext__(self) -> T:
         try:
             item, is_exc = await self.__channel.get()
         except ChannelClosed:
@@ -269,13 +270,13 @@ class IteratorWrapper(AsyncIterator, EventLoopMixin):
         await self.close()
 
 
-class IteratorProxy(AsyncIterator):
+class IteratorProxy(Generic[T], AsyncIterator):
     def __init__(
-        self, iterator: AsyncIterator,
+        self, iterator: AsyncIterator[T],
         finalizer: Callable[[], Any],
     ):
         self.__iterator = iterator
         finalize(self, finalizer)
 
-    def __anext__(self) -> Awaitable[Any]:
+    def __anext__(self) -> Awaitable[T]:
         return self.__iterator.__anext__()

{aiomisc-17.7.8 → aiomisc-17.8.1}/aiomisc/service/base.py

@@ -1,15 +1,13 @@
 import asyncio
 from abc import ABC, ABCMeta, abstractmethod
-from typing import (
-    Any, Coroutine, Dict, Generator, Optional, Set, Tuple, TypeVar, Union,
-)
+from typing import Any, Coroutine, Dict, Optional, Set, Tuple, TypeVar, Union
 
 from ..context import Context, get_context
 from ..utils import cancel_tasks
 
 
 T = TypeVar("T")
-CoroutineType = Union[Coroutine[Any, Any, T], Generator[Any, None, T]]
+CoroutineType = Union[Coroutine[Any, Any, T]]
 
 
 class ServiceMeta(ABCMeta):

{aiomisc-17.7.8 → aiomisc-17.8.1}/aiomisc/thread_pool.py

@@ -2,18 +2,19 @@ import asyncio
 import contextvars
 import inspect
 import logging
+import os
 import threading
 import time
 import warnings
 from concurrent.futures import ThreadPoolExecutor as ThreadPoolExecutorBase
 from dataclasses import dataclass, field
-from functools import partial, wraps
+from functools import partial
 from multiprocessing import cpu_count
 from queue import SimpleQueue
 from types import MappingProxyType
 from typing import (
-    Any, Awaitable, Callable, Coroutine, Dict, FrozenSet, Optional, Set, Tuple,
-    TypeVar,
+    Any, Awaitable, Callable, Coroutine, Dict, FrozenSet, Generic,
+    Optional, Set, Tuple, TypeVar, Generator, overload, Union
 )
 
 from ._context_vars import EVENT_LOOP
@@ -21,12 +22,15 @@ from .compat import ParamSpec
 from .counters import Statistic
 from .iterator_wrapper import IteratorWrapper
 
-
 P = ParamSpec("P")
 T = TypeVar("T")
 F = TypeVar("F", bound=Callable[..., Any])
 log = logging.getLogger(__name__)
 
+THREADED_ITERABLE_DEFAULT_MAX_SIZE = int(
+    os.getenv("THREADED_ITERABLE_DEFAULT_MAX_SIZE", 1024)
+)
+
 
 def context_partial(
     func: F, *args: Any,
@@ -327,6 +331,7 @@ def run_in_executor(
             return await loop.run_in_executor(
                 executor, partial(func, *args, **kwargs),
             )
+
         return lazy_wrapper()
 
 
@@ -340,22 +345,56 @@ async def _awaiter(future: asyncio.Future) -> T:
         raise
 
 
+class Threaded(Generic[P, T]):
+    __slots__ = ("func",)
+
+    def __init__(self, func: Callable[P, T]) -> None:
+        if asyncio.iscoroutinefunction(func):
+            raise TypeError("Can not wrap coroutine")
+        if inspect.isgeneratorfunction(func):
+            raise TypeError("Can not wrap generator function")
+        self.func = func
+
+    def sync_call(self, *args: P.args, **kwargs: P.kwargs) -> T:
+        return self.func(*args, **kwargs)
+
+    def async_call(self, *args: P.args, **kwargs: P.kwargs) -> Awaitable[T]:
+        return run_in_executor(func=self.func, args=args, kwargs=kwargs)
+
+    def __repr__(self) -> str:
+        return f"<Threaded {self.func.__name__} at {id(self):#x}>"
+
+    def __call__(self, *args: P.args, **kwargs: P.kwargs) -> Awaitable[T]:
+        return self.async_call(*args, **kwargs)
+
+    def __get__(self, instance: Any, owner: Optional[type] = None) -> Any:
+        if instance is None:
+            return self
+        return partial(self.async_call, instance)
+
+
+@overload
+def threaded(func: Callable[P, T]) -> Threaded[P, T]:
+    ...
+
+
+@overload
 def threaded(
-    func: Callable[P, T],
-) -> Callable[P, Awaitable[T]]:
-    if asyncio.iscoroutinefunction(func):
-        raise TypeError("Can not wrap coroutine")
+    func: Callable[P, Generator[T, None, None]]
+) -> Callable[P, IteratorWrapper[P, T]]:
+    ...
 
-    if inspect.isgeneratorfunction(func):
-        return threaded_iterable(func)
 
-    @wraps(func)
-    def wrap(
-        *args: P.args, **kwargs: P.kwargs,
-    ) -> Awaitable[T]:
-        return run_in_executor(func=func, args=args, kwargs=kwargs)
+def threaded(
+    func: Callable[P, T] | Callable[P, Generator[T, None, None]]
+) -> Threaded[P, T] | Callable[P, IteratorWrapper[P, T]]:
+    if inspect.isgeneratorfunction(func):
+        return threaded_iterable(
+            func,
+            max_size=THREADED_ITERABLE_DEFAULT_MAX_SIZE
+        )
 
-    return wrap
+    return Threaded(func)   # type: ignore
 
 
 def run_in_new_thread(
@@ -390,43 +429,112 @@ def run_in_new_thread(
     return future
 
 
+class ThreadedSeparate(Threaded[P, T]):
+    """
+    A decorator to run a function in a separate thread.
+    It returns an `asyncio.Future` that can be awaited.
+    """
+
+    def __init__(self, func: Callable[P, T], detach: bool = True) -> None:
+        super().__init__(func)
+        self.detach = detach
+
+    def async_call(self, *args: P.args, **kwargs: P.kwargs) -> Awaitable[T]:
+        return run_in_new_thread(
+            self.func, args=args, kwargs=kwargs, detach=self.detach,
+        )
+
+
 def threaded_separate(
-    func: F,
+    func: Callable[P, T],
     detach: bool = True,
-) -> Callable[..., Awaitable[Any]]:
+) -> ThreadedSeparate[P, T]:
     if isinstance(func, bool):
         return partial(threaded_separate, detach=detach)
 
     if asyncio.iscoroutinefunction(func):
         raise TypeError("Can not wrap coroutine")
 
-    @wraps(func)
-    def wrap(*args: Any, **kwargs: Any) -> Any:
-        future = run_in_new_thread(
-            func, args=args, kwargs=kwargs, detach=detach,
+    return ThreadedSeparate(func, detach=detach)
+
+
+class ThreadedIterable(Generic[P, T]):
+    def __init__(
+        self,
+        func: Callable[P, Generator[T, None, None]],
+        max_size: int = 0
+    ) -> None:
+        self.func = func
+        self.max_size = max_size
+
+    def sync_call(
+        self, *args: P.args, **kwargs: P.kwargs
+    ) -> Generator[T, None, None]:
+        return self.func(*args, **kwargs)
+
+    def async_call(
+        self, *args: P.args, **kwargs: P.kwargs
+    ) -> IteratorWrapper[P, T]:
+        return self.create_wrapper(*args, **kwargs)
+
+    def create_wrapper(
+        self, *args: P.args, **kwargs: P.kwargs
+    ) -> IteratorWrapper[P, T]:
+        return IteratorWrapper(
+            partial(self.func, *args, **kwargs),
+            max_size=self.max_size,
         )
-        return future
 
-    return wrap
+    def __call__(
+        self,
+        *args: P.args,
+        **kwargs: P.kwargs
+    ) -> IteratorWrapper[P, T]:
+        return self.async_call(*args, **kwargs)
+
+    def __get__(
+        self,
+        instance: Any,
+        owner: Optional[type] = None
+    ) -> Any:
+        if instance is None:
+            return self
+        return partial(self.async_call, instance)
 
 
+@overload
 def threaded_iterable(
-    func: Optional[F] = None,
+    func: Callable[P, Generator[T, None, None]],
+    *,
     max_size: int = 0,
-) -> Any:
-    if isinstance(func, int):
-        return partial(threaded_iterable, max_size=func)
-    if func is None:
-        return partial(threaded_iterable, max_size=max_size)
+) -> "ThreadedIterable[P, T]":
+    ...
 
-    @wraps(func)
-    def wrap(*args: Any, **kwargs: Any) -> Any:
-        return IteratorWrapper(
-            partial(func, *args, **kwargs),
-            max_size=max_size,
-        )
 
-    return wrap
+@overload
+def threaded_iterable(
+    *,
+    max_size: int = 0,
+) -> Callable[
+    [Callable[P, Generator[T, None, None]]], ThreadedIterable[P, T]
+]:
+    ...
+
+
+def threaded_iterable(
+    func: Optional[Callable[P, Generator[T, None, None]]] = None,
+    *,
+    max_size: int = 0,
+) -> Union[
+    ThreadedIterable[P, T],
+    Callable[
+        [Callable[P, Generator[T, None, None]]], ThreadedIterable[P, T]
+    ]
+]:
+    if func is None:
+        return lambda f: ThreadedIterable(f, max_size=max_size)
+
+    return ThreadedIterable(func, max_size=max_size)
 
 
 class IteratorWrapperSeparate(IteratorWrapper):
@@ -434,23 +542,50 @@ class IteratorWrapperSeparate(IteratorWrapper):
         return run_in_new_thread(self._in_thread)
 
 
+class ThreadedIterableSeparate(ThreadedIterable[P, T]):
+    def create_wrapper(
+        self, *args: P.args, **kwargs: P.kwargs
+    ) -> IteratorWrapperSeparate:
+        return IteratorWrapperSeparate(
+            partial(self.func, *args, **kwargs),
+            max_size=self.max_size,
+        )
+
+
+@overload
 def threaded_iterable_separate(
-    func: Optional[F] = None,
+    func: Callable[P, Generator[T, None, None]],
+    *,
     max_size: int = 0,
-) -> Any:
-    if isinstance(func, int):
-        return partial(threaded_iterable_separate, max_size=func)
-    if func is None:
-        return partial(threaded_iterable_separate, max_size=max_size)
+) -> "ThreadedIterable[P, T]":
+    ...
 
-    @wraps(func)
-    def wrap(*args: Any, **kwargs: Any) -> Any:
-        return IteratorWrapperSeparate(
-            partial(func, *args, **kwargs),
-            max_size=max_size,
-        )
 
-    return wrap
+@overload
+def threaded_iterable_separate(
+    *,
+    max_size: int = 0,
+) -> Callable[
+    [Callable[P, Generator[T, None, None]]],
+    ThreadedIterableSeparate[P, T]
+]:
+    ...
+
+
+def threaded_iterable_separate(
+    func: Optional[Callable[P, Generator[T, None, None]]] = None,
+    *,
+    max_size: int = 0,
+) -> Union[
+    ThreadedIterable[P, T],
+    Callable[
+        [Callable[P, Generator[T, None, None]]], ThreadedIterableSeparate[P, T]
+    ]
+]:
+    if func is None:
+        return lambda f: ThreadedIterableSeparate(f, max_size=max_size)
+
+    return ThreadedIterableSeparate(func, max_size=max_size)
 
 
 class CoroutineWaiter:
@@ -509,4 +644,5 @@ def sync_await(
 ) -> T:
     async def awaiter() -> T:
         return await func(*args, **kwargs)
+
     return wait_coroutine(awaiter())

{aiomisc-17.7.8 → aiomisc-17.8.1}/aiomisc/version.py

@@ -2,5 +2,5 @@
 # BY: poem-plugins "git" plugin
 # NEVER EDIT THIS FILE MANUALLY
 
-version_info = (17, 7, 8)
-__version__ = "17.7.8"
+version_info = (17, 8, 1)
+__version__ = "17.8.1"

{aiomisc-17.7.8 → aiomisc-17.8.1}/aiomisc_worker/forking.py

@@ -20,7 +20,7 @@ EXIT_LOCK = Lock()
 
 
 def at_exit() -> None:
-    global PROCESSES
+    global PROCESSES    # noqa
 
     with EXIT_LOCK:
         pids = tuple(PROCESSES.keys())
@@ -61,7 +61,7 @@ def fork(worker_id: bytes, cookie: bytes, address: AddressType) -> None:
 
 
 def main() -> int:
-    global STOPPING
+    global STOPPING     # noqa
 
     proto_stdin = FileIOProtocol(sys.stdin.buffer)
 

{aiomisc-17.7.8 → aiomisc-17.8.1}/aiomisc_worker/process.py

@@ -86,7 +86,7 @@ def main() -> int:
     env["AIOMISC_NO_PLUGINS"] = ""
 
     def create_worker() -> Worker:
-        nonlocal env
+        nonlocal env        # noqa
         return Worker(
             log_level, log_format, address, cookie, worker_id, env,
             initializer, initializer_args, initializer_kwargs,

{aiomisc-17.7.8 → aiomisc-17.8.1}/pyproject.toml

@@ -1,7 +1,7 @@
 [tool.poetry]
 name = "aiomisc"
 # This is a dummy version which will be rewritten with poem-plugins
-version = "17.7.8"
+version = "17.8.1"
 description = "aiomisc - miscellaneous utils for asyncio"
 authors = ["Dmitry Orlov <me@mosquito.su>"]
 readme = "README.rst"
@@ -24,7 +24,6 @@ classifiers = [
     "Operating System :: POSIX :: Linux",
     "Operating System :: POSIX",
     "Programming Language :: Python :: 3",
-    "Programming Language :: Python :: 3.9",
     "Programming Language :: Python :: 3.10",
     "Programming Language :: Python :: 3.11",
     "Programming Language :: Python :: 3.12",