asyncstdlib 3.12.5__tar.gz → 3.13.1__tar.gz

{asyncstdlib-3.12.5 → asyncstdlib-3.13.1}/LICENSE

@@ -1,6 +1,6 @@
 MIT License
 
-Copyright (c) 2019 - 2020 Max Fischer
+Copyright (c) 2019 - 2024 Max Kühn
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

{asyncstdlib-3.12.5 → asyncstdlib-3.13.1}/PKG-INFO

@@ -1,9 +1,9 @@
-Metadata-Version: 2.1
+Metadata-Version: 2.4
 Name: asyncstdlib
-Version: 3.12.5
+Version: 3.13.1
 Summary: The missing async toolbox
 Keywords: async,enumerate,itertools,builtins,functools,contextlib
-Author-email: Max Fischer <maxfischer2781@gmail.com>
+Author-email: Max Kühn <maxfischer2781@gmail.com>
 Requires-Python: ~=3.8
 Description-Content-Type: text/x-rst
 Classifier: Development Status :: 5 - Production/Stable
@@ -17,6 +17,7 @@ Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
 Classifier: Programming Language :: Python :: 3.13
+License-File: LICENSE
 Requires-Dist: sphinx ; extra == "doc"
 Requires-Dist: sphinxcontrib-trio ; extra == "doc"
 Requires-Dist: pytest ; extra == "test"

{asyncstdlib-3.12.5 → asyncstdlib-3.13.1}/asyncstdlib/__init__.py

@@ -45,7 +45,7 @@ from .itertools import (
 from .asynctools import borrow, scoped_iter, await_each, any_iter, apply, sync
 from .heapq import merge, nlargest, nsmallest
 
-__version__ = "3.12.5"
+__version__ = "3.13.1"
 
 __all__ = [
     "anext",

{asyncstdlib-3.12.5 → asyncstdlib-3.13.1}/asyncstdlib/_lrucache.pyi

@@ -9,6 +9,7 @@ from typing import (
     overload,
     Protocol,
 )
+from types import CoroutineType
 from typing_extensions import ParamSpec, Concatenate
 
 from ._typing import AC, TypedDict
@@ -42,6 +43,12 @@ class LRUAsyncCallable(Protocol[AC]):
         owner: type | None = ...,
     ) -> LRUAsyncBoundCallable[S, P, R]: ...
     @overload
+    def __get__(
+        self: LRUAsyncCallable[Callable[Concatenate[S, P], CoroutineType[Any, Any, R]]],
+        instance: S,
+        owner: type | None = ...,
+    ) -> LRUAsyncBoundCallable[S, P, R]: ...
+    @overload
     def __get__(
         self: LRUAsyncCallable[Callable[Concatenate[S, P], Awaitable[R]]],
         instance: S,

{asyncstdlib-3.12.5 → asyncstdlib-3.13.1}/asyncstdlib/asynctools.py

@@ -35,7 +35,7 @@ class _BorrowedAsyncIterator(AsyncGenerator[T, S]):
     __slots__ = "__wrapped__", "__anext__", "asend", "athrow", "_wrapper"
 
     # Type checker does not understand `__slot__` definitions
-    __anext__: Callable[[Any], Awaitable[T]]
+    __anext__: Callable[[Any], Coroutine[Any, Any, T]]
     asend: Any
     athrow: Any
 

{asyncstdlib-3.12.5 → asyncstdlib-3.13.1}/asyncstdlib/builtins.py

@@ -164,7 +164,7 @@ async def zip(
 
 
 async def _zip_inner(
-    aiters: Tuple[AsyncIterator[T], ...]
+    aiters: Tuple[AsyncIterator[T], ...],
 ) -> AsyncIterator[Tuple[T, ...]]:
     """Direct zip transposing tuple-of-iterators to iterator-of-tuples"""
     try:
@@ -175,7 +175,7 @@ async def _zip_inner(
 
 
 async def _zip_inner_strict(
-    aiters: Tuple[AsyncIterator[T], ...]
+    aiters: Tuple[AsyncIterator[T], ...],
 ) -> AsyncIterator[Tuple[T, ...]]:
     """Length aware zip checking that all iterators are equal length"""
     # track index of the last iterator we tried to anext

{asyncstdlib-3.12.5 → asyncstdlib-3.13.1}/asyncstdlib/builtins.pyi

@@ -231,7 +231,7 @@ async def tuple(iterable: AnyIterable[T]) -> builtins.tuple[T, ...]: ...
 async def dict() -> builtins.dict[Any, Any]: ...
 @overload
 async def dict(
-    iterable: AnyIterable[builtins.tuple[HK, T]]
+    iterable: AnyIterable[builtins.tuple[HK, T]],
 ) -> builtins.dict[HK, T]: ...
 @overload
 async def dict(

{asyncstdlib-3.12.5 → asyncstdlib-3.13.1}/asyncstdlib/contextlib.py

@@ -28,7 +28,7 @@ AbstractContextManager = AsyncContextManager
 
 
 def contextmanager(
-    func: Callable[..., AsyncGenerator[T, None]]
+    func: Callable[..., AsyncGenerator[T, None]],
 ) -> Callable[..., AsyncContextManager[T]]:
     r"""
     Create an asynchronous context manager out of an asynchronous generator function
@@ -328,18 +328,15 @@ class ExitStack:
             If a context manager must also be entered, use :py:meth:`~.enter_context`
             instead.
         """
-        try:
+        aexit: Callable[..., Awaitable[Union[None, bool]]]
+        if hasattr(exit, "__aexit__"):
             aexit = exit.__aexit__  # type: ignore
-        except AttributeError:
-            try:
-                aexit = awaitify(
-                    exit.__exit__,  # type: ignore
-                )
-            except AttributeError:
-                assert callable(
-                    exit
-                ), f"Expected (async) context manager or callable, got {exit}"
-                aexit = awaitify(exit)
+        elif hasattr(exit, "__exit__"):
+            aexit = awaitify(exit.__exit__)  # type: ignore
+        elif callable(exit):
+            aexit = awaitify(exit)  # type: ignore
+        else:
+            raise TypeError(f"Expected (async) context manager or callable, got {exit}")
         self._exit_callbacks.append(aexit)  # pyright: ignore[reportUnknownArgumentType]
         return exit
 

{asyncstdlib-3.12.5 → asyncstdlib-3.13.1}/asyncstdlib/contextlib.pyi

@@ -55,12 +55,12 @@ class ContextDecorator(AsyncContextManager[T], metaclass=ABCMeta):
 P = ParamSpec("P")
 
 def contextmanager(
-    func: Callable[P, AsyncGenerator[T, None]]
+    func: Callable[P, AsyncGenerator[T, None]],
 ) -> Callable[P, ContextDecorator[T]]: ...
 
 class closing(Generic[AClose]):
     def __init__(self, thing: AClose) -> None: ...
-    async def __aenter__(self: Self) -> Self: ...
+    async def __aenter__(self: Self) -> AClose: ...
     async def __aexit__(
         self,
         exc_type: type[BaseException] | None,

{asyncstdlib-3.12.5 → asyncstdlib-3.13.1}/asyncstdlib/functools.py

@@ -7,7 +7,6 @@ from typing import (
     Generic,
     Generator,
     Optional,
-    Coroutine,
     AsyncContextManager,
     Type,
     cast,
@@ -66,25 +65,25 @@ class AwaitableValue(Generic[R]):
         return f"{self.__class__.__name__}({self.value!r})"
 
 
-class _FutureCachedValue(Generic[R, T]):
-    """A placeholder object to control concurrent access to a cached awaitable value.
+class _FutureCachedPropertyValue(Generic[R, T]):
+    """
+    A placeholder object to control concurrent access to a cached awaitable value
 
     When given a lock to coordinate access, only the first task to await on a
     cached property triggers the underlying coroutine. Once a value has been
     produced, all tasks are unblocked and given the same, single value.
-
     """
 
-    __slots__ = ("_get_attribute", "_instance", "_name", "_lock")
+    __slots__ = ("_func", "_instance", "_name", "_lock")
 
     def __init__(
         self,
-        get_attribute: Callable[[T], Coroutine[Any, Any, R]],
+        func: Callable[[T], Awaitable[R]],
         instance: T,
         name: str,
         lock: AsyncContextManager[Any],
     ):
-        self._get_attribute = get_attribute
+        self._func = func
         self._instance = instance
         self._name = name
         self._lock = lock
@@ -98,7 +97,6 @@ class _FutureCachedValue(Generic[R, T]):
 
         If the instance (no longer) has this attribute, it was deleted and the
         process is restarted by delegating to the descriptor.
-
         """
         try:
             return self._instance.__dict__[self._name]
@@ -116,12 +114,17 @@ class _FutureCachedValue(Generic[R, T]):
                     # the instance attribute is still this placeholder, and we
                     # hold the lock. Start the getter to store the value on the
                     # instance and return the value.
-                    return await self._get_attribute(self._instance)
+                    return await self._get_attribute()
 
         # another task produced a value, or the instance.__dict__ object was
         # deleted in the interim.
         return await stored
 
+    async def _get_attribute(self) -> R:
+        value = await self._func(self._instance)
+        self._instance.__dict__[self._name] = AwaitableValue(value)
+        return value
+
     def __repr__(self) -> str:
         return (
             f"<{type(self).__name__} for '{type(self._instance).__name__}."
@@ -135,9 +138,10 @@ class CachedProperty(Generic[T, R]):
         getter: Callable[[T], Awaitable[R]],
         asynccontextmanager_type: Type[AsyncContextManager[Any]] = nullcontext,
     ):
-        self.func = getter
+        self.func = self.__wrapped__ = getter
         self.attrname = None
         self.__doc__ = getter.__doc__
+        self.__module__ = getter.__module__
         self._asynccontextmanager_type = asynccontextmanager_type
 
     def __set_name__(self, owner: Any, name: str) -> None:
@@ -175,19 +179,12 @@ class CachedProperty(Generic[T, R]):
         # on this instance. It takes care of coordinating between different
         # tasks awaiting on the placeholder until the cached value has been
         # produced.
-        wrapper = _FutureCachedValue(
-            self._get_attribute, instance, name, self._asynccontextmanager_type()
+        wrapper = _FutureCachedPropertyValue(
+            self.func, instance, name, self._asynccontextmanager_type()
         )
         cache[name] = wrapper
         return wrapper
 
-    async def _get_attribute(self, instance: T) -> R:
-        value = await self.func(instance)
-        name = self.attrname
-        assert name is not None  # enforced in __get__
-        instance.__dict__[name] = AwaitableValue(value)
-        return value
-
 
 def cached_property(
     type_or_getter: Union[Type[AsyncContextManager[Any]], Callable[[T], Awaitable[R]]],
@@ -257,7 +254,9 @@ def cached_property(
         Instances on which a value is to be cached must have a
         ``__dict__`` attribute that is a mutable mapping.
     """
-    if isinstance(type_or_getter, type) and issubclass(
+    if iscoroutinefunction(type_or_getter):
+        return CachedProperty(type_or_getter)
+    elif isinstance(type_or_getter, type) and issubclass(
         type_or_getter, AsyncContextManager
     ):
 
@@ -272,12 +271,9 @@ def cached_property(
             )
 
         return decorator
-
-    if not iscoroutinefunction(type_or_getter):
+    else:
         raise ValueError("cached_property can only be used with a coroutine function")
 
-    return CachedProperty(type_or_getter)
-
 
 __REDUCE_SENTINEL = Sentinel("<no default>")
 

{asyncstdlib-3.12.5 → asyncstdlib-3.13.1}/asyncstdlib/itertools.py

@@ -32,7 +32,6 @@ from .builtins import (
     zip,
     enumerate as aenumerate,
     iter as aiter,
-    tuple as atuple,
 )
 
 S = TypeVar("S")
@@ -122,17 +121,31 @@ async def accumulate(
             yield value
 
 
-async def batched(iterable: AnyIterable[T], n: int) -> AsyncIterator[Tuple[T, ...]]:
+async def batched(
+    iterable: AnyIterable[T], n: int, strict: bool = False
+) -> AsyncIterator[Tuple[T, ...]]:
     """
     Batch the ``iterable`` to tuples of the length ``n``.
 
-    This lazily exhausts ``iterable`` and returns each batch as soon as it's ready.
+    This lazily exhausts ``iterable`` and returns each batch as soon as it is ready.
+    If ``strict`` is :py:data:`True` and the last batch is smaller than ``n``,
+    :py:exc:`ValueError` is raised.
     """
     if n < 1:
         raise ValueError("n must be at least one")
     async with ScopedIter(iterable) as item_iter:
-        while batch := await atuple(islice(_borrow(item_iter), n)):
-            yield batch
+        batch: list[T] = []
+        try:
+            while True:
+                batch.clear()
+                for _ in range(n):
+                    batch.append(await anext(item_iter))
+                yield tuple(batch)
+        except StopAsyncIteration:
+            if batch:
+                if strict and len(batch) < n:
+                    raise ValueError("batched(): incomplete batch") from None
+                yield tuple(batch)
 
 
 class chain(AsyncIterator[T]):

{asyncstdlib-3.12.5 → asyncstdlib-3.13.1}/asyncstdlib/itertools.pyi

@@ -32,27 +32,33 @@ def accumulate(
     initial: T1,
 ) -> AsyncIterator[T1]: ...
 @overload
-def batched(iterable: AnyIterable[T], n: Literal[1]) -> AsyncIterator[tuple[T]]: ...
+def batched(
+    iterable: AnyIterable[T], n: Literal[1], strict: bool = ...
+) -> AsyncIterator[tuple[T]]: ...
 @overload
-def batched(iterable: AnyIterable[T], n: Literal[2]) -> AsyncIterator[tuple[T, T]]: ...
+def batched(
+    iterable: AnyIterable[T], n: Literal[2], strict: bool = ...
+) -> AsyncIterator[tuple[T, T]]: ...
 @overload
 def batched(
-    iterable: AnyIterable[T], n: Literal[3]
+    iterable: AnyIterable[T], n: Literal[3], strict: bool = ...
 ) -> AsyncIterator[tuple[T, T, T]]: ...
 @overload
 def batched(
-    iterable: AnyIterable[T], n: Literal[4]
+    iterable: AnyIterable[T], n: Literal[4], strict: bool = ...
 ) -> AsyncIterator[tuple[T, T, T, T]]: ...
 @overload
 def batched(
-    iterable: AnyIterable[T], n: Literal[5]
+    iterable: AnyIterable[T], n: Literal[5], strict: bool = ...
 ) -> AsyncIterator[tuple[T, T, T, T, T]]: ...
 @overload
 def batched(
-    iterable: AnyIterable[T], n: Literal[6]
+    iterable: AnyIterable[T], n: Literal[6], strict: bool = ...
 ) -> AsyncIterator[tuple[T, T, T, T, T, T]]: ...
 @overload
-def batched(iterable: AnyIterable[T], n: int) -> AsyncIterator[tuple[T, ...]]: ...
+def batched(
+    iterable: AnyIterable[T], n: int, strict: bool = ...
+) -> AsyncIterator[tuple[T, ...]]: ...
 
 class chain(AsyncIterator[T]):
     __slots__: tuple[str, ...]

{asyncstdlib-3.12.5 → asyncstdlib-3.13.1}/pyproject.toml

@@ -6,7 +6,7 @@ build-backend = "flit_core.buildapi"
 dynamic = ["version", "description"]
 name = "asyncstdlib"
 authors = [
-    {name = "Max Fischer", email = "maxfischer2781@gmail.com"},
+    {name = "Max Kühn", email = "maxfischer2781@gmail.com"},
 ]
 readme = "README.rst"
 classifiers = [

{asyncstdlib-3.12.5 → asyncstdlib-3.13.1}/unittests/test_builtins.py

@@ -4,7 +4,7 @@ import pytest
 
 import asyncstdlib as a
 
-from .utility import sync, asyncify, awaitify, inside_loop
+from .utility import sync, asyncify, awaitify
 
 
 def hide_coroutine(corofunc):
@@ -83,8 +83,7 @@ async def test_zip_close_immediately():
                     yield 1
             finally:
                 nonlocal closed
-                if await inside_loop():
-                    closed = True
+                closed = True
 
     zip_iter = a.zip(asyncify(range(-5, 0)), SomeIterable())
     async for va, vb in zip_iter:

{asyncstdlib-3.12.5 → asyncstdlib-3.13.1}/unittests/test_functools.py

@@ -5,7 +5,7 @@ import pytest
 import asyncstdlib as a
 from asyncstdlib.functools import CachedProperty
 
-from .utility import Lock, Schedule, Switch, asyncify, multi_sync, sync
+from .utility import Lock, Schedule, Switch, asyncify, sync
 
 
 @sync
@@ -44,7 +44,7 @@ async def test_cache_property_nodict():
         Foo().bar
 
 
-@multi_sync
+@sync
 async def test_cache_property_order():
     class Value:
         def __init__(self, value):
@@ -66,7 +66,7 @@ async def test_cache_property_order():
     assert (await val.cached) == 1337  # last value fetched
 
 
-@multi_sync
+@sync
 async def test_cache_property_lock_order():
     class Value:
         def __init__(self, value):
@@ -87,7 +87,7 @@ async def test_cache_property_lock_order():
     assert (await val.cached) == 5  # first value fetched
 
 
-@multi_sync
+@sync
 async def test_cache_property_lock_deletion():
     class Value:
         def __init__(self, value):
@@ -300,7 +300,7 @@ async def test_lru_cache_misuse():
 
 
 @pytest.mark.parametrize("size", [16, None])
-@multi_sync
+@sync
 async def test_lru_cache_concurrent(size):
     current = 0
 

{asyncstdlib-3.12.5 → asyncstdlib-3.13.1}/unittests/test_itertools.py

@@ -6,7 +6,7 @@ import pytest
 
 import asyncstdlib as a
 
-from .utility import sync, asyncify, awaitify, multi_sync, Schedule, Switch, Lock
+from .utility import sync, asyncify, awaitify, Schedule, Switch, Lock
 
 
 @sync
@@ -79,6 +79,19 @@ async def test_batched_invalid(length):
         await a.list(a.batched(range(10), length))
 
 
+@sync
+@pytest.mark.parametrize("values", ([1, 2, 3, 4], [1, 2, 3, 4, 5], [1]))
+async def test_batched_strict(values: "list[int]"):
+    for n in range(1, len(values) + 1):
+        batches = a.batched(values, n, strict=True)
+        if len(values) % n == 0:
+            assert values == list(await a.reduce(lambda a, b: a + b, batches))
+        else:
+            assert await a.anext(batches)
+            with pytest.raises(ValueError):
+                await a.list(batches)
+
+
 @sync
 async def test_cycle():
     async for _ in a.cycle([]):
@@ -314,7 +327,7 @@ async def test_tee():
             assert await a.list(iterator) == iterable
 
 
-@multi_sync
+@sync
 async def test_tee_concurrent_locked():
     """Test that properly uses a lock for synchronisation"""
     items = [1, 2, 3, -5, 12, 78, -1, 111]
@@ -322,8 +335,7 @@ async def test_tee_concurrent_locked():
     async def iter_values():
         for item in items:
             # switch to other tasks a few times to guarantees another runs
-            for _ in range(5):
-                await Switch()
+            await Switch(5)
             yield item
 
     async def test_peer(peer_tee):
@@ -345,7 +357,7 @@ async def test_tee_concurrent_locked():
     platform.python_implementation() != "CPython",
     reason="async generators only protect against concurrent access on CPython",
 )
-@multi_sync
+@sync
 async def test_tee_concurrent_unlocked():
     """Test that tee does not prevent concurrency without a lock"""
     items = list(range(12))
@@ -354,8 +366,7 @@ async def test_tee_concurrent_unlocked():
     async def iter_values():
         for item in items:
             # switch to other tasks a few times to guarantee another runs
-            for _ in range(5):
-                await Switch()
+            await Switch(5)
             yield item
 
     async def test_peer(peer_tee):

asyncstdlib-3.13.1/unittests/utility.py

@@ -0,0 +1,150 @@
+from typing import (
+    Callable,
+    Coroutine,
+    Iterable,
+    AsyncIterator,
+    TypeVar,
+    Awaitable,
+    Deque,
+    Tuple,
+    Any,
+)
+from functools import wraps
+from collections import deque
+from random import randint
+
+
+T = TypeVar("T")
+
+
+async def asyncify(iterable: Iterable[T]) -> AsyncIterator[T]:
+    """
+    Convert an iterable into an async iterable
+
+    This is intended to sequence literals like lists to `async` iterators
+    in order to force usage of `async` code paths. There is no functional
+    or other advantage otherwise.
+    """
+    for value in iterable:
+        yield value
+
+
+def awaitify(call: Callable[..., T]) -> Callable[..., Awaitable[T]]:
+    """
+    Convert a callable (`foo()`) into an async callable (`await foo()`)
+
+    This is intended to convert `lambda` expressions to `async` functions
+    in order to force usage of `async` code paths. There is no functional
+    or other advantage otherwise.
+    """
+
+    async def await_wrapper(*args: Any, **kwargs: Any) -> T:
+        return call(*args, **kwargs)
+
+    return await_wrapper
+
+
+class Schedule:
+    r"""
+    Signal to the event loop to adopt and run new coroutines
+
+    :param coros: The coroutines to start running
+
+    In order to communicate with the event loop and start the coroutines,
+    the :py:class:`Schedule` must be `await`\ ed.
+    """
+
+    def __init__(self, *coros: Coroutine[Any, Any, Any]):
+        self.coros = coros
+
+    def __await__(self):
+        yield self
+
+
+class Switch:
+    """
+    Signal to the event loop to run another coroutine
+
+    Pauses the coroutine but immediately continues after
+    all other runnable coroutines of the event loop.
+    This is similar to the common ``sleep(0)`` function
+    of regular event loop frameworks.
+
+    If a single argument is given, this specifies how many
+    turns should be skipped. The default corresponds to `0`.
+    If two arguments are given, this is interpreted as an
+    inclusive interval to randomly select the skip count.
+    """
+
+    def __init__(self, skip: int = 0, limit: int = 0, /) -> None:
+        if limit <= 0:
+            self._idle_count = skip
+        else:
+            self._idle_count = randint(skip, limit)
+
+    def __await__(self):
+        yield self
+        for _ in range(self._idle_count):
+            yield self
+
+
+class Lock:
+    """Simple lock for exclusive access"""
+
+    def __init__(self):
+        self._owned = False
+        self._waiting: list[object] = []
+
+    async def __aenter__(self):
+        if self._owned:
+            # wait until it is our turn to take the lock
+            token = object()
+            self._waiting.append(token)
+            # a spin-lock should be fine since tests are short anyways
+            while self._owned or self._waiting[0] is not token:
+                await Switch()
+            # we will take the lock now, remove our wait claim
+            self._waiting.pop(0)
+        self._owned = True
+
+    async def __aexit__(self, exc_type: Any, exc_val: Any, exc_tb: Any):
+        self._owned = False
+
+
+def sync(test_case: Callable[..., Coroutine[None, Any, Any]], /) -> Callable[..., None]:
+    """
+    Mark an ``async def`` test case to be run synchronously with children
+
+    This provides a primitive "event loop" which only responds
+    to :py:class:`Schedule`, :py:class:`Switch` and :py:class:`Lock`.
+
+    It should be applied as a decorator on an ``async def`` function, which
+    is then turned into a synchronous callable that will run the ``async def``
+    function and all tasks it spawns.
+    Other decorators, most prominently :py:func:`pytest.mark.parametrize`,
+    can be applied around it.
+    """
+
+    @wraps(test_case)
+    def run_sync(*args: Any, **kwargs: Any):
+        run_queue: Deque[Tuple[Coroutine[Any, Any, Any], Any]] = deque()
+        run_queue.append((test_case(*args, **kwargs), None))
+        while run_queue:
+            coro, event = run_queue.popleft()
+            try:
+                event = coro.send(event)
+            except StopIteration as e:
+                result = e.args[0] if e.args else None
+                assert result is None, f"got '{result!r}' expected 'None'"
+            else:
+                if isinstance(event, Schedule):
+                    run_queue.extend((new_coro, None) for new_coro in event.coros)
+                    run_queue.append((coro, event))
+                elif isinstance(event, Switch):
+                    run_queue.append((coro, event))
+                else:  # pragma: no cover
+                    raise RuntimeError(
+                        f"test case {test_case} yielded an unexpected event {event}"
+                    )
+
+    return run_sync

asyncstdlib-3.12.5/unittests/utility.py

@@ -1,142 +0,0 @@
-from typing import (
-    Callable,
-    Coroutine,
-    Iterable,
-    AsyncIterator,
-    TypeVar,
-    Awaitable,
-    Deque,
-    Tuple,
-    Any,
-)
-from functools import wraps
-from collections import deque
-
-
-T = TypeVar("T")
-
-
-async def asyncify(iterable: Iterable[T]) -> AsyncIterator[T]:
-    """Convert an iterable to async iterable"""
-    for value in iterable:
-        yield value
-
-
-def awaitify(call: Callable[..., T]) -> Callable[..., Awaitable[T]]:
-    async def await_wrapper(*args, **kwargs):
-        return call(*args, **kwargs)
-
-    return await_wrapper
-
-
-class PingPong:
-    """Signal to the event loop which gets returned unchanged"""
-
-    def __await__(self):
-        return (yield self)
-
-
-async def inside_loop():
-    """Test whether there is an active event loop available"""
-    signal = PingPong()
-    return await signal is signal
-
-
-def sync(test_case: Callable[..., Coroutine[T, Any, Any]]) -> Callable[..., T]:
-    """
-    Mark an ``async def`` test case to be run synchronously
-
-    This emulates a primitive "event loop" which only responds
-    to the :py:class:`PingPong` by sending it back.
-    """
-
-    @wraps(test_case)
-    def run_sync(*args: Any, **kwargs: Any) -> T:
-        coro = test_case(*args, **kwargs)
-        try:
-            event = None
-            while True:
-                event = coro.send(event)
-                if not isinstance(event, PingPong):  # pragma: no cover
-                    raise RuntimeError(
-                        f"test case {test_case} yielded an unexpected event {event}"
-                    )
-        except StopIteration as e:
-            result = e.args[0] if e.args else None
-        return result
-
-    return run_sync
-
-
-class Schedule:
-    """Signal to the event loop to adopt and run a new coroutine"""
-
-    def __init__(self, *coros: Coroutine[Any, Any, Any]):
-        self.coros = coros
-
-    def __await__(self):
-        yield self
-
-
-class Switch:
-    """Signal to the event loop to run another coroutine"""
-
-    def __await__(self):
-        yield self
-
-
-class Lock:
-    def __init__(self):
-        self._owned = False
-        self._waiting: list[object] = []
-
-    async def __aenter__(self):
-        if self._owned:
-            # wait until it is our turn to take the lock
-            token = object()
-            self._waiting.append(token)
-            while self._owned or self._waiting[0] is not token:
-                await Switch()
-            # take the lock and remove our wait claim
-            self._owned = True
-            self._waiting.pop(0)
-        self._owned = True
-
-    async def __aexit__(self, exc_type: Any, exc_val: Any, exc_tb: Any):
-        self._owned = False
-
-
-def multi_sync(test_case: Callable[..., Coroutine[T, Any, Any]]) -> Callable[..., T]:
-    """
-    Mark an ``async def`` test case to be run synchronously with children
-
-    This emulates a primitive "event loop" which only responds
-    to the :py:class:`PingPong`, :py:class:`Schedule`, :py:class:`Switch`
-    and :py:class:`Lock`.
-    """
-
-    @wraps(test_case)
-    def run_sync(*args: Any, **kwargs: Any):
-        run_queue: Deque[Tuple[Coroutine[Any, Any, Any], Any]] = deque()
-        run_queue.append((test_case(*args, **kwargs), None))
-        while run_queue:
-            coro, event = run_queue.popleft()
-            try:
-                event = coro.send(event)
-            except StopIteration as e:
-                result = e.args[0] if e.args else None
-                assert result is None, f"got '{result!r}' expected 'None'"
-            else:
-                if isinstance(event, PingPong):
-                    run_queue.appendleft((coro, event))
-                elif isinstance(event, Schedule):
-                    run_queue.extend((new_coro, None) for new_coro in event.coros)
-                    run_queue.append((coro, event))
-                elif isinstance(event, Switch):
-                    run_queue.append((coro, event))
-                else:  # pragma: no cover
-                    raise RuntimeError(
-                        f"test case {test_case} yielded an unexpected event {event}"
-                    )
-
-    return run_sync