asyncstdlib 3.13.0__tar.gz → 3.13.2__tar.gz

{asyncstdlib-3.13.0 → asyncstdlib-3.13.2}/PKG-INFO

@@ -1,6 +1,6 @@
-Metadata-Version: 2.1
+Metadata-Version: 2.4
 Name: asyncstdlib
-Version: 3.13.0
+Version: 3.13.2
 Summary: The missing async toolbox
 Keywords: async,enumerate,itertools,builtins,functools,contextlib
 Author-email: Max Kühn <maxfischer2781@gmail.com>
@@ -17,6 +17,8 @@ Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
 Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+License-File: LICENSE
 Requires-Dist: sphinx ; extra == "doc"
 Requires-Dist: sphinxcontrib-trio ; extra == "doc"
 Requires-Dist: pytest ; extra == "test"

{asyncstdlib-3.13.0 → asyncstdlib-3.13.2}/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.13.0"
+__version__ = "3.13.2"
 
 __all__ = [
     "anext",

{asyncstdlib-3.13.0 → asyncstdlib-3.13.2}/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.13.0 → asyncstdlib-3.13.2}/asyncstdlib/_typing.py

@@ -55,12 +55,19 @@ AC = TypeVar("AC", bound=Callable[..., Awaitable[Any]])
 #: Hashable Key
 HK = TypeVar("HK", bound=Hashable)
 
+
+# bool(...)
+class SupportsBool(Protocol):
+    def __bool__(self) -> bool:
+        raise NotImplementedError
+
+
 # LT < LT
 LT = TypeVar("LT", bound="SupportsLT")
 
 
 class SupportsLT(Protocol):
-    def __lt__(self: LT, other: LT) -> bool:
+    def __lt__(self, __other: Any) -> SupportsBool:
         raise NotImplementedError
 
 
@@ -69,7 +76,7 @@ ADD = TypeVar("ADD", bound="SupportsAdd")
 
 
 class SupportsAdd(Protocol):
-    def __add__(self: ADD, other: ADD, /) -> ADD:
+    def __add__(self, __other: Any, /) -> Any:
         raise NotImplementedError
 
 

{asyncstdlib-3.13.0 → asyncstdlib-3.13.2}/asyncstdlib/asynctools.py

@@ -20,7 +20,6 @@ from ._typing import T, T1, T2, T3, T4, T5, AnyIterable
 from ._core import aiter
 from .contextlib import nullcontext
 
-
 S = TypeVar("S")
 
 
@@ -35,7 +34,7 @@ class _BorrowedAsyncIterator(AsyncGenerator[T, S]):
     __slots__ = "__wrapped__", "__anext__", "asend", "athrow", "_wrapper"
 
     # Type checker does not understand `__slot__` definitions
-    __anext__: Callable[[Any], Coroutine[Any, Any, T]]
+    __anext__: Callable[..., Coroutine[Any, Any, T]]
     asend: Any
     athrow: Any
 
@@ -49,7 +48,7 @@ class _BorrowedAsyncIterator(AsyncGenerator[T, S]):
         # An async *iterator* (e.g. `async def: yield`) must return
         # itself from __aiter__. If we do not shadow this then
         # running aiter(self).aclose closes the underlying iterator.
-        self.__anext__ = self._wrapper.__anext__  # type: ignore
+        self.__anext__ = self._wrapper.__anext__
         if hasattr(iterator, "asend"):
             self.asend = (
                 iterator.asend  # pyright: ignore[reportUnknownMemberType,reportAttributeAccessIssue]

{asyncstdlib-3.13.0 → asyncstdlib-3.13.2}/asyncstdlib/builtins.py

@@ -22,7 +22,6 @@ from ._core import (
     Sentinel,
 )
 
-
 __ANEXT_DEFAULT = Sentinel("<no default>")
 
 
@@ -55,7 +54,7 @@ __ITER_DEFAULT = Sentinel("<no default>")
 
 
 def iter(
-    subject: Union[AnyIterable[T], Callable[[], Awaitable[T]]],
+    subject: Union[AnyIterable[T], Callable[[], Awaitable[T]], Callable[[], T]],
     sentinel: Union[Sentinel, T] = __ITER_DEFAULT,
 ) -> AsyncIterator[T]:
     """
@@ -84,13 +83,12 @@ def iter(
         raise TypeError("iter(v, w): v must be callable")
     else:
         assert not isinstance(sentinel, Sentinel)
-        return acallable_iterator(subject, sentinel)
+        return acallable_iterator(_awaitify(subject), sentinel)
 
 
 async def acallable_iterator(
     subject: Callable[[], Awaitable[T]], sentinel: T
 ) -> AsyncIterator[T]:
-    subject = _awaitify(subject)
     value = await subject()
     while value != sentinel:
         yield value
@@ -164,7 +162,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 +173,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
@@ -306,7 +304,7 @@ async def _min_max(
             raise ValueError(f"{name}() arg is an empty sequence")
         elif key is None:
             async for item in item_iter:
-                if invert ^ (item < best):
+                if invert ^ bool(item < best):
                     best = item
         else:
             key = _awaitify(key)

{asyncstdlib-3.13.0 → asyncstdlib-3.13.2}/asyncstdlib/builtins.pyi

@@ -2,7 +2,7 @@ from typing import Any, AsyncIterator, Awaitable, Callable, overload
 from typing_extensions import TypeGuard
 import builtins
 
-from ._typing import ADD, AnyIterable, HK, LT, R, T, T1, T2, T3, T4, T5
+from ._typing import ADD, AnyIterable, HK, LT, R, T, T1, T2, T3, T4, T5, SupportsLT
 
 @overload
 async def anext(iterator: AsyncIterator[T]) -> T: ...
@@ -16,6 +16,10 @@ def iter(
 ) -> AsyncIterator[T]: ...
 @overload
 def iter(subject: Callable[[], Awaitable[T]], sentinel: T) -> AsyncIterator[T]: ...
+@overload
+def iter(subject: Callable[[], T | None], sentinel: None) -> AsyncIterator[T]: ...
+@overload
+def iter(subject: Callable[[], T], sentinel: T) -> AsyncIterator[T]: ...
 async def all(iterable: AnyIterable[Any]) -> bool: ...
 async def any(iterable: AnyIterable[Any]) -> bool: ...
 @overload
@@ -180,20 +184,42 @@ async def max(iterable: AnyIterable[LT], *, key: None = ...) -> LT: ...
 @overload
 async def max(iterable: AnyIterable[LT], *, key: None = ..., default: T) -> LT | T: ...
 @overload
-async def max(iterable: AnyIterable[T1], *, key: Callable[[T1], LT] = ...) -> T1: ...
+async def max(
+    iterable: AnyIterable[T1], *, key: Callable[[T1], Awaitable[SupportsLT]]
+) -> T1: ...
+@overload
+async def max(
+    iterable: AnyIterable[T1],
+    *,
+    key: Callable[[T1], Awaitable[SupportsLT]],
+    default: T2,
+) -> T1 | T2: ...
+@overload
+async def max(iterable: AnyIterable[T1], *, key: Callable[[T1], SupportsLT]) -> T1: ...
 @overload
 async def max(
-    iterable: AnyIterable[T1], *, key: Callable[[T1], LT] = ..., default: T2
+    iterable: AnyIterable[T1], *, key: Callable[[T1], SupportsLT], default: T2
 ) -> T1 | T2: ...
 @overload
 async def min(iterable: AnyIterable[LT], *, key: None = ...) -> LT: ...
 @overload
 async def min(iterable: AnyIterable[LT], *, key: None = ..., default: T) -> LT | T: ...
 @overload
-async def min(iterable: AnyIterable[T1], *, key: Callable[[T1], LT] = ...) -> T1: ...
+async def min(
+    iterable: AnyIterable[T1], *, key: Callable[[T1], Awaitable[SupportsLT]]
+) -> T1: ...
 @overload
 async def min(
-    iterable: AnyIterable[T1], *, key: Callable[[T1], LT] = ..., default: T2
+    iterable: AnyIterable[T1],
+    *,
+    key: Callable[[T1], Awaitable[SupportsLT]],
+    default: T2,
+) -> T1 | T2: ...
+@overload
+async def min(iterable: AnyIterable[T1], *, key: Callable[[T1], SupportsLT]) -> T1: ...
+@overload
+async def min(
+    iterable: AnyIterable[T1], *, key: Callable[[T1], SupportsLT], default: T2
 ) -> T1 | T2: ...
 @overload
 def filter(
@@ -231,7 +257,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(
@@ -247,5 +273,12 @@ async def sorted(
 ) -> builtins.list[LT]: ...
 @overload
 async def sorted(
-    iterable: AnyIterable[T], *, key: Callable[[T], LT], reverse: bool = ...
+    iterable: AnyIterable[T],
+    *,
+    key: Callable[[T], Awaitable[SupportsLT]],
+    reverse: bool = ...,
+) -> builtins.list[T]: ...
+@overload
+async def sorted(
+    iterable: AnyIterable[T], *, key: Callable[[T], SupportsLT], reverse: bool = ...
 ) -> builtins.list[T]: ...

{asyncstdlib-3.13.0 → asyncstdlib-3.13.2}/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

{asyncstdlib-3.13.0 → asyncstdlib-3.13.2}/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.13.0 → asyncstdlib-3.13.2}/asyncstdlib/functools.py

@@ -254,8 +254,10 @@ 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(
-        type_or_getter, AsyncContextManager
+    if iscoroutinefunction(type_or_getter):
+        return CachedProperty(type_or_getter)
+    elif isinstance(type_or_getter, type) and issubclass(
+        type_or_getter, AsyncContextManager  # pyright: ignore[reportGeneralTypeIssues]
     ):
 
         def decorator(
@@ -269,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.13.0 → asyncstdlib-3.13.2}/asyncstdlib/functools.pyi

@@ -33,6 +33,14 @@ def cached_property(
     asynccontextmanager_type: type[AsyncContextManager[Any]], /
 ) -> Callable[[Callable[[T], Awaitable[R]]], CachedProperty[T, R]]: ...
 @overload
+async def reduce(
+    function: Callable[[T1, T2], Awaitable[T1]], iterable: AnyIterable[T2], initial: T1
+) -> T1: ...
+@overload
+async def reduce(
+    function: Callable[[T, T], Awaitable[T]], iterable: AnyIterable[T]
+) -> T: ...
+@overload
 async def reduce(
     function: Callable[[T1, T2], T1], iterable: AnyIterable[T2], initial: T1
 ) -> T1: ...

{asyncstdlib-3.13.0 → asyncstdlib-3.13.2}/asyncstdlib/heapq.py

@@ -92,7 +92,7 @@ class _KeyIter(Generic[LT]):
             return True
 
     def __lt__(self, other: _KeyIter[LT]) -> bool:
-        return self.reverse ^ (self.head_key < other.head_key)
+        return self.reverse ^ bool(self.head_key < other.head_key)
 
     def __eq__(self, other: _KeyIter[LT]) -> bool:  # type: ignore[override]
         return not (self.head_key < other.head_key or other.head_key < self.head_key)
@@ -161,7 +161,7 @@ class ReverseLT(Generic[LT]):
         self.key = key
 
     def __lt__(self, other: ReverseLT[LT]) -> bool:
-        return other.key < self.key
+        return bool(other.key < self.key)
 
 
 # Python's heapq provides a *min*-heap

{asyncstdlib-3.13.0 → asyncstdlib-3.13.2}/asyncstdlib/itertools.py

@@ -8,7 +8,6 @@ from typing import (
     Union,
     Callable,
     Optional,
-    Deque,
     Generic,
     Iterable,
     Iterator,
@@ -17,14 +16,13 @@ from typing import (
     overload,
     AsyncGenerator,
 )
-from collections import deque
+from typing_extensions import TypeAlias
 
 from ._typing import ACloseable, R, T, AnyIterable, ADD
 from ._utility import public_module
 from ._core import (
     ScopedIter,
     awaitify as _awaitify,
-    Sentinel,
     borrow as _borrow,
 )
 from .builtins import (
@@ -33,6 +31,7 @@ from .builtins import (
     enumerate as aenumerate,
     iter as aiter,
 )
+from itertools import count as _counter
 
 S = TypeVar("S")
 T_co = TypeVar("T_co", covariant=True)
@@ -64,9 +63,6 @@ async def cycle(iterable: AnyIterable[T]) -> AsyncIterator[T]:
             yield item
 
 
-__ACCUMULATE_SENTINEL = Sentinel("<no default>")
-
-
 async def add(x: ADD, y: ADD) -> ADD:
     """The default reduction of :py:func:`~.accumulate`"""
     return x + y
@@ -78,7 +74,7 @@ async def accumulate(
         Callable[[Any, Any], Any], Callable[[Any, Any], Awaitable[Any]]
     ] = add,
     *,
-    initial: Any = __ACCUMULATE_SENTINEL,
+    initial: Any = None,
 ) -> AsyncIterator[Any]:
     """
     An :term:`asynchronous iterator` on the running reduction of ``iterable``
@@ -105,11 +101,7 @@ async def accumulate(
     """
     async with ScopedIter(iterable) as item_iter:
         try:
-            value = (
-                initial
-                if initial is not __ACCUMULATE_SENTINEL
-                else await anext(item_iter)
-            )
+            value = initial if initial is not None else await anext(item_iter)
         except StopAsyncIteration:
             raise TypeError(
                 "accumulate() of empty sequence with no initial value"
@@ -354,57 +346,79 @@ class NoLock:
         return None
 
 
-async def tee_peer(
-    iterator: AsyncIterator[T],
-    # the buffer specific to this peer
-    buffer: Deque[T],
-    # the buffers of all peers, including our own
-    peers: List[Deque[T]],
-    lock: AsyncContextManager[Any],
-) -> AsyncGenerator[T, None]:
-    """An individual iterator of a :py:func:`~.tee`"""
-    try:
-        while True:
-            if not buffer:
-                async with lock:
-                    # Another peer produced an item while we were waiting for the lock.
-                    # Proceed with the next loop iteration to yield the item.
-                    if buffer:
-                        continue
-                    try:
-                        item = await iterator.__anext__()
-                    except StopAsyncIteration:
-                        break
-                    else:
-                        # Append to all buffers, including our own. We'll fetch our
-                        # item from the buffer again, instead of yielding it directly.
-                        # This ensures the proper item ordering if any of our peers
-                        # are fetching items concurrently. They may have buffered their
-                        # item already.
-                        for peer_buffer in peers:
-                            peer_buffer.append(item)
-            yield buffer.popleft()
-    finally:
-        # this peer is done – remove its buffer
-        for idx, peer_buffer in enumerate(peers):  # pragma: no branch
-            if peer_buffer is buffer:
-                peers.pop(idx)
-                break
-        # if we are the last peer, try and close the iterator
-        if not peers and isinstance(iterator, ACloseable):
-            await iterator.aclose()
+_get_tee_index = _counter().__next__
+
+
+_TeeNode: TypeAlias = "list[T | _TeeNode[T]]"
+
+
+class TeePeer(Generic[T]):
+    def __init__(
+        self,
+        iterator: AsyncIterator[T],
+        buffer: "_TeeNode[T]",
+        lock: AsyncContextManager[Any],
+        tee_peers: "set[int]",
+    ) -> None:
+        self._iterator = iterator
+        self._lock = lock
+        self._buffer: _TeeNode[T] = buffer
+        self._tee_peers = tee_peers
+        self._tee_idx = _get_tee_index()
+        self._tee_peers.add(self._tee_idx)
+
+    def __aiter__(self):
+        return self
+
+    async def __anext__(self) -> T:
+        # the buffer is a singly-linked list as [value, [value, [...]]] | []
+        next_node = self._buffer
+        value: T
+        # for any most advanced TeePeer, the node is just []
+        # fetch the next value so we can mutate the node to [value, [...]]
+        if not next_node:
+            async with self._lock:
+                # Check if another peer produced an item while we were waiting for the lock
+                if not next_node:
+                    await self._extend_buffer(next_node)
+        # for any other TeePeer, the node is already some [value, [...]]
+        value, self._buffer = next_node  # type: ignore
+        return value
+
+    async def _extend_buffer(self, next_node: "_TeeNode[T]") -> None:
+        """Extend the buffer by fetching a new item from the iterable"""
+        try:
+            # another peer may fill the buffer while we wait here
+            next_value = await self._iterator.__anext__()
+        except StopAsyncIteration:
+            # no one else managed to fetch a value either
+            if not next_node:
+                raise
+        else:
+            # skip nodes that were filled in the meantime
+            while next_node:
+                _, next_node = next_node  # type: ignore
+            next_node[:] = next_value, []
+
+    async def aclose(self) -> None:
+        self._tee_peers.discard(self._tee_idx)
+        if not self._tee_peers and isinstance(self._iterator, ACloseable):
+            await self._iterator.aclose()
+
+    def __del__(self) -> None:
+        self._tee_peers.discard(self._tee_idx)
 
 
 @public_module(__name__, "tee")
 class Tee(Generic[T]):
-    """
+    r"""
     Create ``n`` separate asynchronous iterators over ``iterable``
 
     This splits a single ``iterable`` into multiple iterators, each providing
     the same items in the same order.
     All child iterators may advance separately but share the same items
     from ``iterable`` -- when the most advanced iterator retrieves an item,
-    it is buffered until the least advanced iterator has yielded it as well.
+    it is buffered until all other iterators have yielded it as well.
     A ``tee`` works lazily and can handle an infinite ``iterable``, provided
     that all iterators advance.
 
@@ -415,16 +429,9 @@ class Tee(Generic[T]):
             await a.anext(previous)  # advance one iterator
             return a.map(operator.sub, previous, current)
 
-    Unlike :py:func:`itertools.tee`, :py:func:`~.tee` returns a custom type instead
-    of a :py:class:`tuple`. Like a tuple, it can be indexed, iterated and unpacked
-    to get the child iterators. In addition, its :py:meth:`~.tee.aclose` method
-    immediately closes all children, and it can be used in an ``async with`` context
-    for the same effect.
-
-    If ``iterable`` is an iterator and read elsewhere, ``tee`` will *not*
-    provide these items. Also, ``tee`` must internally buffer each item until the
-    last iterator has yielded it; if the most and least advanced iterator differ
-    by most data, using a :py:class:`list` is more efficient (but not lazy).
+    If ``iterable`` is an iterator and read elsewhere, ``tee`` will generally *not*
+    provide these items. However, a ``tee`` of a ``tee`` shares its buffer with parent,
+    sibling and child ``tee``\ s so that each sees the same items.
 
     If the underlying iterable is concurrency safe (``anext`` may be awaited
     concurrently) the resulting iterators are concurrency safe as well. Otherwise,
@@ -432,9 +439,15 @@ class Tee(Generic[T]):
     To enforce sequential use of ``anext``, provide a ``lock``
     - e.g. an :py:class:`asyncio.Lock` instance in an :py:mod:`asyncio` application -
     and access is automatically synchronised.
+
+    Unlike :py:func:`itertools.tee`, :py:func:`~.tee` returns a custom type instead
+    of a :py:class:`tuple`. Like a tuple, it can be indexed, iterated and unpacked
+    to get the child iterators. In addition, its :py:meth:`~.tee.aclose` method
+    immediately closes all children, and it can be used in an ``async with`` context
+    for the same effect.
     """
 
-    __slots__ = ("_iterator", "_buffers", "_children")
+    __slots__ = ("_children",)
 
     def __init__(
         self,
@@ -443,16 +456,24 @@ class Tee(Generic[T]):
         *,
         lock: Optional[AsyncContextManager[Any]] = None,
     ):
-        self._iterator = aiter(iterable)
-        self._buffers: List[Deque[T]] = [deque() for _ in range(n)]
+        buffer: _TeeNode[T]
+        peers: set[int]
+        if not isinstance(iterable, TeePeer):
+            iterator = aiter(iterable)
+            buffer = []
+            peers = set()
+        else:
+            iterator = iterable._iterator  # pyright: ignore[reportPrivateUsage]
+            buffer = iterable._buffer  # pyright: ignore[reportPrivateUsage]
+            peers = iterable._tee_peers  # pyright: ignore[reportPrivateUsage]
         self._children = tuple(
-            tee_peer(
-                iterator=self._iterator,
-                buffer=buffer,
-                peers=self._buffers,
-                lock=lock if lock is not None else NoLock(),
+            TeePeer(
+                iterator,
+                buffer,
+                lock if lock is not None else NoLock(),
+                peers,
             )
-            for buffer in self._buffers
+            for _ in range(n)
         )
 
     def __len__(self) -> int:

{asyncstdlib-3.13.0 → asyncstdlib-3.13.2}/asyncstdlib/itertools.pyi

@@ -16,13 +16,17 @@ from ._typing import AnyIterable, ADD, T, T1, T2, T3, T4, T5
 
 def cycle(iterable: AnyIterable[T]) -> AsyncIterator[T]: ...
 @overload
-def accumulate(iterable: AnyIterable[ADD]) -> AsyncIterator[ADD]: ...
+def accumulate(
+    iterable: AnyIterable[ADD], *, initial: None = ...
+) -> AsyncIterator[ADD]: ...
 @overload
 def accumulate(iterable: AnyIterable[ADD], *, initial: ADD) -> AsyncIterator[ADD]: ...
 @overload
 def accumulate(
     iterable: AnyIterable[T],
     function: Callable[[T, T], T] | Callable[[T, T], Awaitable[T]],
+    *,
+    initial: None = ...,
 ) -> AsyncIterator[T]: ...
 @overload
 def accumulate(
@@ -76,7 +80,7 @@ def filterfalse(
     predicate: Callable[[T], Any] | None, iterable: AnyIterable[T]
 ) -> AsyncIterator[T]: ...
 @overload
-def islice(iterable: AnyIterable[T], start: int | None, /) -> AsyncIterator[T]: ...
+def islice(iterable: AnyIterable[T], stop: int | None, /) -> AsyncIterator[T]: ...
 @overload
 def islice(
     iterable: AnyIterable[T],

{asyncstdlib-3.13.0 → asyncstdlib-3.13.2}/pyproject.toml

@@ -21,6 +21,7 @@ classifiers = [
     "Programming Language :: Python :: 3.11",
     "Programming Language :: Python :: 3.12",
     "Programming Language :: Python :: 3.13",
+    "Programming Language :: Python :: 3.14",
 ]
 license = {"file" = "LICENSE"}
 keywords = ["async", "enumerate", "itertools", "builtins", "functools", "contextlib"]
@@ -80,3 +81,6 @@ verboseOutput = true
 testpaths = [
     "unittests",
 ]
+
+[tool.black]
+target-version = ["py38", "py39","py310", "py311", "py312", "py313", "py314"]

{asyncstdlib-3.13.0 → asyncstdlib-3.13.2}/unittests/test_asynctools.py

@@ -4,7 +4,6 @@ import asyncstdlib as a
 
 from .utility import sync, asyncify
 
-
 CLOSED = "closed"
 
 

{asyncstdlib-3.13.0 → asyncstdlib-3.13.2}/unittests/test_functools_lru.py

@@ -2,6 +2,7 @@ from typing import Callable, Any
 import sys
 
 import pytest
+from typing_extensions import get_annotations, Format
 
 import asyncstdlib as a
 
@@ -175,5 +176,7 @@ def test_wrapper_attributes(size: "int | None"):
             if name != "method":
                 continue
             # test direct and literal annotation styles
-            assert Bar.method.__annotations__["int_arg"] in {int, "int"}
-            assert Bar().method.__annotations__["int_arg"] in {int, "int"}
+            assert get_annotations(Bar.method, format=Format.STRING)["int_arg"] == "int"
+            assert (
+                get_annotations(Bar().method, format=Format.STRING)["int_arg"] == "int"
+            )

{asyncstdlib-3.13.0 → asyncstdlib-3.13.2}/unittests/test_heapq.py

@@ -7,7 +7,6 @@ import asyncstdlib as a
 
 from .utility import sync, asyncify, awaitify
 
-
 MERGE_SAMPLES = [
     [[1, 2], [3, 4]],
     [[1, 2, 3], [4, 5, 6], [7, 8, 9]],

{asyncstdlib-3.13.0 → asyncstdlib-3.13.2}/unittests/test_itertools.py

@@ -1,3 +1,4 @@
+from typing import AsyncIterator
 import itertools
 import sys
 import platform
@@ -34,6 +35,7 @@ async def test_accumulate():
 
 @sync
 async def test_accumulate_default():
+    """Test the default function of accumulate"""
     for itertype in (asyncify, list):
         assert await a.list(a.accumulate(itertype([0, 1]))) == list(
             itertools.accumulate([0, 1])
@@ -53,10 +55,21 @@ async def test_accumulate_default():
 
 @sync
 async def test_accumulate_misuse():
+    """Test wrong arguments to accumulate"""
     with pytest.raises(TypeError):
         assert await a.list(a.accumulate([]))
 
 
+@sync
+async def test_accumulate_initial():
+    """Test the `initial` argument to accumulate"""
+    assert (
+        await a.list(a.accumulate(asyncify([1, 2, 3]), initial=None))
+        == await a.list(a.accumulate(asyncify([1, 2, 3])))
+        == list(itertools.accumulate([1, 2, 3], initial=None))
+    )
+
+
 batched_cases = [
     (range(10), 2, [(0, 1), (2, 3), (4, 5), (6, 7), (8, 9)]),
     (range(10), 3, [(0, 1, 2), (3, 4, 5), (6, 7, 8), (9,)]),
@@ -329,7 +342,7 @@ async def test_tee():
 
 @sync
 async def test_tee_concurrent_locked():
-    """Test that properly uses a lock for synchronisation"""
+    """Test that tee properly uses a lock for synchronisation"""
     items = [1, 2, 3, -5, 12, 78, -1, 111]
 
     async def iter_values():
@@ -348,6 +361,52 @@ async def test_tee_concurrent_locked():
     assert results == items
 
 
+@pytest.mark.parametrize("concurrency", (1, 2, 4, 7))
+@sync
+async def test_tee_share(concurrency: int) -> None:
+    """Test that related tees share their buffer and see all items"""
+    items = [1, 2, 3, -5, 12, 78, -1, 111]
+
+    async def tee_test(tee_state: AsyncIterator[int]) -> None:
+        """Asynchronously check that `tee_state` includes all `items`"""
+        for expected in items:
+            assert expected == await a.anext(tee_state)
+            await Switch(0, concurrency)
+
+    # create tees that are multiple times removed from an initial iterator
+    item_iter = a.iter(items)
+    for tee_peer in a.tee(item_iter, n=concurrency):
+        await Schedule(tee_test(a.tee(tee_peer)[0]))
+
+
+@sync
+async def test_tee_share_deep() -> None:
+    """Test that related tees share their buffer and see all items no matter when spawned"""
+    items = [1, 2, 3, -5, 12, 78, -1, 111]
+
+    async def tee_spawn_walker(
+        tee_state: AsyncIterator[int], start_idx: int = 0
+    ) -> None:
+        """Walk and check `tee_state` elements and spawn new walkers on every step"""
+        for idx in range(start_idx, len(items)):
+            await Switch(0, 3)
+            assert await a.anext(tee_state) == items[idx]
+            tee_state, *child_states = a.tee(tee_state, n=3)
+            await Schedule(
+                *(
+                    tee_spawn_walker(child_state, idx + 1)
+                    for child_state in child_states
+                )
+            )
+            await Switch()
+
+    head_peer, *child_peers = a.tee(items, n=3)
+    await Schedule(*(tee_spawn_walker(child, 0) for child in child_peers))
+    await Switch(len(items) // 2)
+    results = [item async for item in head_peer]
+    assert results == items
+
+
 # see https://github.com/python/cpython/issues/74956
 @pytest.mark.skipif(
     sys.version_info < (3, 8),
@@ -381,6 +440,41 @@ async def test_tee_concurrent_unlocked():
         await test_peer(this)
 
 
+@pytest.mark.parametrize("size", [2, 3, 5, 9, 12])
+@sync
+async def test_tee_concurrent_ordering(size: int):
+    """Test that tee respects concurrent ordering for all peers"""
+
+    class ConcurrentInvertedIterable:
+        """Helper that concurrently iterates with earlier items taking longer"""
+
+        def __init__(self, count: int) -> None:
+            self.count = count
+            self._counter = itertools.count()
+
+        def __aiter__(self):
+            return self
+
+        async def __anext__(self):
+            value = next(self._counter)
+            if value >= self.count:
+                raise StopAsyncIteration()
+            await Switch(self.count - value)
+            return value
+
+    async def test_peer(peer_tee: AsyncIterator[int]):
+        # consume items from the tee with a delay so that slower items can arrive
+        seen_items: list[int] = []
+        async for item in peer_tee:
+            seen_items.append(item)
+            await Switch()
+        assert seen_items == expected_items
+
+    expected_items = list(range(size)[::-1])
+    peers = a.tee(ConcurrentInvertedIterable(size), n=size)
+    await Schedule(*map(test_peer, peers))
+
+
 @sync
 async def test_pairwise():
     assert await a.list(a.pairwise(range(5))) == [(0, 1), (1, 2), (2, 3), (3, 4)]

{asyncstdlib-3.13.0 → asyncstdlib-3.13.2}/unittests/utility.py

@@ -13,7 +13,6 @@ from functools import wraps
 from collections import deque
 from random import randint
 
-
 T = TypeVar("T")