pyfect-dev 0.1.0__py3-none-any.whl

pyfect/stream/_fanout_methods.py

@@ -0,0 +1,183 @@
+"""``Stream`` methods that split one stream into several: grouping by
+key, partitioning, broadcasting and sharing."""
+
+from __future__ import annotations
+
+from collections.abc import Callable, Hashable
+from typing import TYPE_CHECKING, Literal, Never, overload
+
+from pyfect.stream._base import A_co, E_co, R_co, StreamBase
+
+if TYPE_CHECKING:
+    from pyfect._concurrency import Concurrency
+    from pyfect._core import Effect
+    from pyfect.duration import Duration
+    from pyfect.errors import Done
+    from pyfect.queue import Dequeue, Strategy
+    from pyfect.result import Result
+    from pyfect.scope import Scope
+    from pyfect.stream._stream import Stream
+
+type Capacity = int | Literal["unbounded"]
+
+GROUP_BUFFER_SIZE = 4096
+"""How many items each ``group_by`` group holds before upstream waits."""
+
+
+class FanOutMethods(StreamBase[A_co, E_co, R_co]):
+    __slots__ = ()
+
+    # --- grouping -------------------------------------------------------------
+
+    def group_by[K: Hashable, V, E2 = Never, R2 = Never](
+        self,
+        f: Callable[[A_co], Effect[tuple[K, V], E2, R2]],
+        *,
+        buffer_size: int = GROUP_BUFFER_SIZE,
+        idle_time_to_live: Duration | None = None,
+    ) -> Stream[tuple[K, Stream[V]], E_co | E2, R_co | R2]:
+        """Write ``(key, group)`` once per new key ``f(item)`` gives, where
+        ``group`` is the stream of that key's values. Upstream runs on a
+        fiber and waits while a group holds ``buffer_size`` values; a group
+        read by nobody for ``idle_time_to_live`` ends, and the key's next
+        value starts a new one. A group that stops early drops its values."""
+        from pyfect.stream import _grouping
+
+        return _grouping.group_by(self, f, buffer_size, idle_time_to_live)
+
+    def group_by_key[K: Hashable](
+        self,
+        f: Callable[[A_co], K],
+        *,
+        buffer_size: int = GROUP_BUFFER_SIZE,
+        idle_time_to_live: Duration | None = None,
+    ) -> Stream[tuple[K, Stream[A_co]], E_co, R_co]:
+        """``group_by`` with the items as values, keyed by ``f(item)``."""
+        from pyfect.stream import _grouping
+
+        return _grouping.group_by_key(self, f, buffer_size, idle_time_to_live)
+
+    def group_adjacent_by[K](
+        self, f: Callable[[A_co], K]
+    ) -> Stream[tuple[K, tuple[A_co, ...]], E_co, R_co]:
+        """Write each run of neighbouring items with equal keys ``f(item)``
+        as ``(key, items)``; a key that comes back later starts a new run."""
+        from pyfect.stream import _grouping
+
+        return _grouping.group_adjacent_by(self, f)
+
+    # --- partitioning ---------------------------------------------------------
+
+    def partition[P, F](
+        self, f: Callable[[A_co], Result[P, F]], *, capacity: Capacity = 16
+    ) -> Effect[tuple[Stream[P, E_co], Stream[F, E_co]], Never, R_co | Scope]:
+        """Split the items into the ``Ok`` values of ``f(item)`` and the
+        ``Err`` ones. Upstream runs on a fiber in the current ``Scope``; the
+        faster reader gets at most ``capacity`` items ahead of the slower."""
+        from pyfect.stream import _fanout
+
+        return _fanout.partition(self, f, capacity)
+
+    def partition_effect[P, F, E2 = Never, R2 = Never](
+        self,
+        f: Callable[[A_co], Effect[Result[P, F], E2, R2]],
+        *,
+        capacity: Capacity = 4096,
+        concurrency: Concurrency = None,
+    ) -> Effect[tuple[Stream[P, E_co | E2], Stream[F, E_co | E2]], Never, R_co | R2 | Scope]:
+        """``partition`` with an effectful ``f``, run on up to
+        ``concurrency`` items at once (in order)."""
+        from pyfect.stream import _fanout
+
+        return _fanout.partition_effect(self, f, capacity, concurrency)
+
+    def partition_queue[P, F](
+        self, f: Callable[[A_co], Result[P, F]], *, capacity: Capacity = 4096
+    ) -> Effect[tuple[Dequeue[P, E_co | Done], Dequeue[F, E_co | Done]], Never, R_co | Scope]:
+        """``partition`` into two queues, which end (or fail) as the stream
+        does."""
+        from pyfect.stream import _fanout
+
+        return _fanout.partition_queue(self, f, capacity)
+
+    # --- broadcasting ---------------------------------------------------------
+
+    @overload
+    def broadcast(
+        self, *, capacity: Literal["unbounded"], replay: int | None = None
+    ) -> Effect[Stream[A_co, E_co], Never, R_co | Scope]: ...
+    @overload
+    def broadcast(
+        self, *, capacity: int, strategy: Strategy = "suspend", replay: int | None = None
+    ) -> Effect[Stream[A_co, E_co], Never, R_co | Scope]: ...
+    def broadcast(
+        self, *, capacity: Capacity, strategy: Strategy = "suspend", replay: int | None = None
+    ) -> Effect[Stream[A_co, E_co], Never, R_co | Scope]:
+        """Run the stream on a fiber in the current ``Scope``, publishing its
+        chunks to a pubsub of ``capacity`` chunks; each run of the returned
+        stream reads what is published from then on (and the last
+        ``replay`` chunks), then the end or failure."""
+        from pyfect.stream import _fanout
+
+        return _fanout.broadcast(self, capacity, strategy, replay)
+
+    @overload
+    def broadcast_n(
+        self, n: int, *, capacity: Literal["unbounded"], replay: int | None = None
+    ) -> Effect[tuple[Stream[A_co, E_co], ...], Never, R_co | Scope]: ...
+    @overload
+    def broadcast_n(
+        self,
+        n: int,
+        *,
+        capacity: int,
+        strategy: Strategy = "suspend",
+        replay: int | None = None,
+    ) -> Effect[tuple[Stream[A_co, E_co], ...], Never, R_co | Scope]: ...
+    def broadcast_n(
+        self,
+        n: int,
+        *,
+        capacity: Capacity,
+        strategy: Strategy = "suspend",
+        replay: int | None = None,
+    ) -> Effect[tuple[Stream[A_co, E_co], ...], Never, R_co | Scope]:
+        """``n`` streams (none below 1) each reading every chunk. They
+        subscribe now, so none misses the start; with ``"suspend"`` the
+        upstream stays at most ``capacity`` chunks ahead of the slowest. A
+        stream that stops unsubscribes."""
+        from pyfect.stream import _fanout
+
+        return _fanout.broadcast_n(self, n, capacity, strategy, replay)
+
+    @overload
+    def share(
+        self,
+        *,
+        capacity: Literal["unbounded"],
+        replay: int | None = None,
+        idle_time_to_live: Duration | None = None,
+    ) -> Effect[Stream[A_co, E_co], Never, R_co | Scope]: ...
+    @overload
+    def share(
+        self,
+        *,
+        capacity: int,
+        strategy: Strategy = "suspend",
+        replay: int | None = None,
+        idle_time_to_live: Duration | None = None,
+    ) -> Effect[Stream[A_co, E_co], Never, R_co | Scope]: ...
+    def share(
+        self,
+        *,
+        capacity: Capacity,
+        strategy: Strategy = "suspend",
+        replay: int | None = None,
+        idle_time_to_live: Duration | None = None,
+    ) -> Effect[Stream[A_co, E_co], Never, R_co | Scope]:
+        """A stream that ``broadcast``s this one when its first reader
+        starts and stops it when the last one stops (or ``idle_time_to_live``
+        after, so a later reader continues where it left off)."""
+        from pyfect.stream import _fanout
+
+        return _fanout.share(self, capacity, strategy, replay, idle_time_to_live)

pyfect/stream/_filter_methods.py

@@ -0,0 +1,203 @@
+"""``Stream`` methods that keep some items: filtering, taking, dropping and
+dropping repeats.
+
+Counts are ``int``s; a count below zero counts as zero. Predicates take
+the item only (``enumerate`` the stream with ``zip_with_index`` for its
+position). A filter is a function returning ``Ok(value)`` to keep
+``value`` or ``Err(...)`` to drop the item (Effect's ``Filter``).
+"""
+
+from __future__ import annotations
+
+from collections.abc import Callable
+from typing import TYPE_CHECKING, Never, TypeIs, overload
+
+from pyfect._equal import equals
+from pyfect.result import Ok, Result
+from pyfect.stream._base import A_co, E_co, R_co, StreamBase
+
+if TYPE_CHECKING:
+    from pyfect._core import Effect
+    from pyfect.stream._stream import Stream
+
+
+class FilterMethods(StreamBase[A_co, E_co, R_co]):
+    __slots__ = ()
+
+    # --- filtering ------------------------------------------------------------
+
+    @overload
+    def filter[B](self, predicate: Callable[[A_co], TypeIs[B]]) -> Stream[B, E_co, R_co]: ...
+    @overload
+    def filter(self, predicate: Callable[[A_co], bool]) -> Stream[A_co, E_co, R_co]: ...
+    def filter(self, predicate: Callable[[A_co], bool]) -> Stream[object, E_co, R_co]:
+        """Keep the items that pass ``predicate``."""
+        from pyfect.stream._stream import Stream
+
+        return Stream(self._channel.filter_array(predicate))
+
+    def filter_map[B](self, f: Callable[[A_co], Result[B, object]]) -> Stream[B, E_co, R_co]:
+        """Write ``value`` for each item ``f`` maps to ``Ok(value)``; drop
+        the items it maps to ``Err``."""
+        from pyfect.stream import _taking
+
+        return _taking.filter_map(self, f)
+
+    def filter_effect[E2 = Never, R2 = Never](
+        self, predicate: Callable[[A_co], Effect[bool, E2, R2]]
+    ) -> Stream[A_co, E_co | E2, R_co | R2]:
+        """Keep the items whose ``predicate`` succeeds with ``True``."""
+        from pyfect.stream._stream import Stream
+
+        return Stream(self._channel.filter_array_effect(predicate))
+
+    def filter_map_effect[B, E2 = Never, R2 = Never](
+        self, f: Callable[[A_co], Effect[Result[B, object], E2, R2]]
+    ) -> Stream[B, E_co | E2, R_co | R2]:
+        """``filter_map`` with an effectful ``f``."""
+        from pyfect.stream import _taking
+
+        return _taking.filter_map_effect(self, f)
+
+    # --- taking ---------------------------------------------------------------
+
+    def take(self, n: int) -> Stream[A_co, E_co, R_co]:
+        """The first ``n`` items; then end without pulling again."""
+        from pyfect.stream import _taking
+
+        return _taking.take(self, n)
+
+    def take_right(self, n: int) -> Stream[A_co, E_co, R_co]:
+        """The last ``n`` items, written when the stream ends."""
+        from pyfect.stream import _taking
+
+        return _taking.take_right(self, n)
+
+    def take_until(
+        self, predicate: Callable[[A_co], bool], *, exclude_last: bool = False
+    ) -> Stream[A_co, E_co, R_co]:
+        """Items up to and including the first that passes ``predicate``
+        (excluding it with ``exclude_last``); then end."""
+        from pyfect.stream import _taking
+
+        return _taking.take_until(self, predicate, exclude_last)
+
+    def take_until_effect[E2 = Never, R2 = Never](
+        self, predicate: Callable[[A_co], Effect[bool, E2, R2]], *, exclude_last: bool = False
+    ) -> Stream[A_co, E_co | E2, R_co | R2]:
+        """``take_until`` with an effectful ``predicate``."""
+        from pyfect.stream import _taking
+
+        return _taking.take_until_effect(self, predicate, exclude_last)
+
+    @overload
+    def take_while[B](self, predicate: Callable[[A_co], TypeIs[B]]) -> Stream[B, E_co, R_co]: ...
+    @overload
+    def take_while(self, predicate: Callable[[A_co], bool]) -> Stream[A_co, E_co, R_co]: ...
+    def take_while(self, predicate: Callable[[A_co], bool]) -> Stream[object, E_co, R_co]:
+        """Items while they pass ``predicate``; end at the first that fails."""
+        from pyfect.stream import _taking
+
+        return _taking.take_while(self, predicate)
+
+    def take_while_filter[B](self, f: Callable[[A_co], Result[B, object]]) -> Stream[B, E_co, R_co]:
+        """Write ``value`` while ``f`` maps items to ``Ok(value)``; end at the
+        first ``Err``."""
+        from pyfect.stream import _taking
+
+        return _taking.take_while_filter(self, f)
+
+    def take_while_effect[E2 = Never, R2 = Never](
+        self, predicate: Callable[[A_co], Effect[bool, E2, R2]]
+    ) -> Stream[A_co, E_co | E2, R_co | R2]:
+        """``take_while`` with an effectful ``predicate``."""
+        from pyfect.stream import _taking
+
+        return _taking.take_until_effect(self, lambda a: predicate(a).map(_not), True)
+
+    def limit_bytes[E, R](
+        self: FilterMethods[bytes, E, R],
+        limit: int,
+        on_limit_reached: Callable[[], Stream[bytes, E, R]],
+    ) -> Stream[bytes, E, R]:
+        """Byte strings while their total length stays within ``limit``;
+        the first one that would cross it is dropped and the stream goes on
+        with ``on_limit_reached()`` instead."""
+        from pyfect.stream import _taking
+
+        return _taking.limit_bytes(self, limit, on_limit_reached)
+
+    # --- dropping -------------------------------------------------------------
+
+    def drop(self, n: int) -> Stream[A_co, E_co, R_co]:
+        """All but the first ``n`` items."""
+        from pyfect.stream import _taking
+
+        return _taking.drop(self, n)
+
+    def drop_right(self, n: int) -> Stream[A_co, E_co, R_co]:
+        """All but the last ``n`` items (each written once ``n`` later ones
+        have come)."""
+        from pyfect.stream import _taking
+
+        return _taking.drop_right(self, n)
+
+    def drop_while(self, predicate: Callable[[A_co], bool]) -> Stream[A_co, E_co, R_co]:
+        """Drop items while they pass ``predicate``; write the rest."""
+        from pyfect.stream import _taking
+
+        return _taking.drop_while(self, predicate)
+
+    def drop_while_filter(
+        self, f: Callable[[A_co], Result[object, object]]
+    ) -> Stream[A_co, E_co, R_co]:
+        """Drop items while ``f`` maps them to ``Ok``; write the rest."""
+        from pyfect.stream import _taking
+
+        return _taking.drop_while(self, lambda a: isinstance(f(a), Ok))
+
+    def drop_while_effect[E2 = Never, R2 = Never](
+        self, predicate: Callable[[A_co], Effect[bool, E2, R2]]
+    ) -> Stream[A_co, E_co | E2, R_co | R2]:
+        """``drop_while`` with an effectful ``predicate``."""
+        from pyfect.stream import _taking
+
+        return _taking.drop_while_effect(self, predicate)
+
+    def drop_until(self, predicate: Callable[[A_co], bool]) -> Stream[A_co, E_co, R_co]:
+        """Drop items up to and including the first that passes
+        ``predicate``."""
+        return self.drop_while(lambda a: not predicate(a)).drop(1)
+
+    def drop_until_effect[E2 = Never, R2 = Never](
+        self, predicate: Callable[[A_co], Effect[bool, E2, R2]]
+    ) -> Stream[A_co, E_co | E2, R_co | R2]:
+        """``drop_until`` with an effectful ``predicate``."""
+        return self.drop_while_effect(lambda a: predicate(a).map(_not)).drop(1)
+
+    # --- repeats --------------------------------------------------------------
+
+    def changes(self) -> Stream[A_co, E_co, R_co]:
+        """Drop each item ``Equal.equals`` calls equal to the one written
+        before it (``True`` is not ``1``, NaN is NaN)."""
+        from pyfect.stream import _taking
+
+        return _taking.changes_with(self, equals)
+
+    def changes_with(self, f: Callable[[A_co, A_co], bool]) -> Stream[A_co, E_co, R_co]:
+        """Drop each item ``f(item, last_written)`` calls the same."""
+        from pyfect.stream import _taking
+
+        return _taking.changes_with(self, f)
+
+    def changes_with_effect[E2 = Never, R2 = Never](
+        self, f: Callable[[A_co, A_co], Effect[bool, E2, R2]]
+    ) -> Stream[A_co, E_co | E2, R_co | R2]:
+        """``changes_with`` with an effectful ``f``."""
+        from pyfect.stream import _taking
+
+        return _taking.changes_with_effect(self, f)
+
+
+def _not(value: bool) -> bool:
+    return not value

pyfect/stream/_grouping.py

@@ -0,0 +1,168 @@
+"""The work behind ``Stream.group_by``, ``group_by_key`` and
+``group_adjacent_by``.
+
+``group_by`` and ``group_by_key`` run the upstream on a fiber in the
+stream's scope. Each new key gets a queue of ``buffer_size`` (an ``RcMap``
+entry, ended when the entry is released) and the outer stream writes
+``(key, group)`` once, where ``group`` reads that queue and shuts it down
+when it stops, so a group that stops early never blocks the others.
+"""
+# pyright: reportPrivateUsage=false
+
+from __future__ import annotations
+
+import math
+from collections.abc import Callable, Generator, Hashable
+from typing import Any
+
+from pyfect import channel
+from pyfect._core import Effect, _FlatMap, _Gen, _Succeed, _Suspend, _Sync
+from pyfect.channel._base import end_with
+from pyfect.duration import Duration, to_seconds
+from pyfect.effect import provide_service
+from pyfect.errors import Done
+from pyfect.pull import catch_done
+from pyfect.queue import Queue
+from pyfect.rc_map import RcMap
+from pyfect.scope import CloseableScope, Scope, acquire_release, fork_in, scoped
+from pyfect.stream._base import AnyStream
+from pyfect.stream._stream import Stream, transform_pull, transform_pull_bracket
+
+type AnyEffect = Effect[Any, Any, Any]
+type Chunk = tuple[Any, ...]
+type AnyStream_ = Stream[Any, Any, Any]
+type Groups = RcMap[Any, Queue[Any, Done], Any]
+type OfferChunk = Callable[[Chunk, Groups, dict[Any, Queue[Any, Done]]], AnyEffect]
+
+_ENDED: AnyEffect = end_with(None)
+
+
+def from_queue_shutdown_on_end(queue: Queue[Any, Any]) -> AnyStream_:
+    """A stream taking everything waiting in ``queue`` at each pull; it
+    shuts the queue down when it stops."""
+
+    def transform(_upstream: object, scope: CloseableScope) -> AnyEffect:
+        take = queue.take_all().map(tuple)
+        return scope.add_finalizer(lambda _: queue.shutdown()).as_(take)
+
+    built: channel.Channel[Any, Any, Any, Any, Any, Any, Any] = channel.from_transform(transform)
+    return Stream(built)
+
+
+def _queue_for(key: Any, groups: Groups, open_queues: dict[Any, Queue[Any, Done]]) -> AnyEffect:
+    queue = open_queues.get(key)
+    found = _Succeed(queue) if queue is not None else scoped(groups.get(key))
+    return found.tap(lambda _: groups.touch(key))
+
+
+def _group_by(
+    self: AnyStream,
+    offer_chunk: OfferChunk,
+    buffer_size: int,
+    idle_time_to_live: Duration | None,
+) -> AnyStream_:
+    ttl = math.inf if idle_time_to_live is None else to_seconds(idle_time_to_live)
+
+    def build(pull: AnyEffect, scope: CloseableScope, forked: CloseableScope) -> AnyEffect:
+        def body() -> Generator[AnyEffect, Any, AnyEffect]:
+            out: Queue[Any, Any] = Queue(None)
+            yield scope.add_finalizer(lambda _: out.shutdown())
+            open_queues: dict[Any, Queue[Any, Done]] = {}
+
+            def lookup(key: Any) -> AnyEffect:
+                def opened(queue: Queue[Any, Done]) -> AnyEffect:
+                    open_queues[key] = queue
+                    return out.offer((key, from_queue_shutdown_on_end(queue)))
+
+                def release(queue: Queue[Any, Done], _: object) -> AnyEffect:
+                    open_queues.pop(key, None)
+                    return queue.end()
+
+                made: Effect[Queue[Any, Done]] = _Sync(lambda: Queue(buffer_size))
+                return acquire_release(made.tap(opened), release)
+
+            make_groups = RcMap.make(lookup, idle_time_to_live=ttl)
+            groups: Groups = yield make_groups.pipe(provide_service(Scope, forked))
+            run = _FlatMap(pull, lambda chunk: offer_chunk(chunk, groups, open_queues)).forever(
+                disable_yield=True
+            )
+            yield fork_in(run.catch_cause(out.fail_cause), scope)
+            return out.take_all().map(tuple)
+
+        return _Gen(body)
+
+    return transform_pull_bracket(self, build)
+
+
+def group_by(
+    self: AnyStream,
+    f: Callable[[Any], Effect[tuple[Hashable, Any], Any, Any]],
+    buffer_size: int,
+    idle_time_to_live: Duration | None,
+) -> AnyStream_:
+    def offer_chunk(
+        chunk: Chunk, groups: Groups, open_queues: dict[Any, Queue[Any, Done]]
+    ) -> AnyEffect:
+        def body() -> Generator[AnyEffect, Any]:
+            for item in chunk:
+                key, value = yield f(item)
+                queue = yield _queue_for(key, groups, open_queues)
+                yield queue.offer(value)
+
+        return _Gen(body)
+
+    return _group_by(self, offer_chunk, buffer_size, idle_time_to_live)
+
+
+def group_by_key(
+    self: AnyStream,
+    f: Callable[[Any], Hashable],
+    buffer_size: int,
+    idle_time_to_live: Duration | None,
+) -> AnyStream_:
+    def offer_chunk(
+        chunk: Chunk, groups: Groups, open_queues: dict[Any, Queue[Any, Done]]
+    ) -> AnyEffect:
+        batch: dict[Any, list[Any]] = {}
+        for item in chunk:
+            batch.setdefault(f(item), []).append(item)
+
+        def body() -> Generator[AnyEffect, Any]:
+            for key, values in batch.items():
+                queue = yield _queue_for(key, groups, open_queues)
+                yield queue.offer_all(values)
+
+        return _Gen(body)
+
+    return _group_by(self, offer_chunk, buffer_size, idle_time_to_live)
+
+
+def group_adjacent_by(self: AnyStream, f: Callable[[Any], object]) -> AnyStream_:
+    def build(pull: AnyEffect, _scope: CloseableScope) -> AnyEffect:
+        key: object = None
+        group: list[Any] = []
+        done = False
+
+        def split(chunk: Chunk) -> AnyEffect:
+            nonlocal key, group
+            ready: list[tuple[object, Chunk]] = []
+            for item in chunk:
+                item_key = f(item)
+                if group and item_key != key:
+                    ready.append((key, tuple(group)))
+                    group = []
+                if not group:
+                    key = item_key
+                group.append(item)
+            return _Succeed(tuple(ready)) if ready else loop
+
+        def flush(_: None) -> AnyEffect:
+            nonlocal done, group
+            done = True
+            last, group = group, []
+            return _Succeed(((key, tuple(last)),)) if last else _ENDED
+
+        loop: AnyEffect = _FlatMap(pull, split)
+        return _Succeed(catch_done(_Suspend(lambda: _ENDED if done else loop), flush))
+
+    return transform_pull(self, build)

pyfect/stream/_many.py

@@ -0,0 +1,65 @@
+"""Functions combining any number of streams: ``merge_all``,
+``zip_latest_all`` and ``race_all``. Each uses one shared error and
+service type for all its streams."""
+
+from __future__ import annotations
+
+from collections.abc import Iterable
+from typing import TYPE_CHECKING, Any, Never, overload
+
+from pyfect.stream._base import StreamBase, require_stream, require_streams
+
+if TYPE_CHECKING:
+    from pyfect._concurrency import Concurrency
+    from pyfect.stream._stream import Stream
+
+
+def merge_all[A, EE = Never, RR = Never](
+    streams: Iterable[StreamBase[A, EE, RR]], *, concurrency: Concurrency, buffer_size: int = 16
+) -> Stream[A, EE, RR]:
+    """Run ``streams``, up to ``concurrency`` at once, writing their items
+    as they come (at most ``buffer_size`` waiting)."""
+    from pyfect.stream._constructors import from_iterable
+
+    parts = list(streams)
+    for part in parts:
+        require_stream(part, "streams")
+    return from_iterable(parts).flatten(concurrency=concurrency, buffer_size=buffer_size)
+
+
+@overload
+def zip_latest_all() -> Stream[Never]: ...
+@overload
+def zip_latest_all[A1, EE = Never, RR = Never](
+    s1: StreamBase[A1, EE, RR], /
+) -> Stream[tuple[A1], EE, RR]: ...
+@overload
+def zip_latest_all[A1, A2, EE = Never, RR = Never](
+    s1: StreamBase[A1, EE, RR], s2: StreamBase[A2, EE, RR], /
+) -> Stream[tuple[A1, A2], EE, RR]: ...
+@overload
+def zip_latest_all[A1, A2, A3, EE = Never, RR = Never](
+    s1: StreamBase[A1, EE, RR], s2: StreamBase[A2, EE, RR], s3: StreamBase[A3, EE, RR], /
+) -> Stream[tuple[A1, A2, A3], EE, RR]: ...
+@overload
+def zip_latest_all[A, EE = Never, RR = Never](
+    *streams: StreamBase[A, EE, RR],
+) -> Stream[tuple[A, ...], EE, RR]: ...
+def zip_latest_all(*streams: StreamBase[Any, Any, Any]) -> Stream[Any, Any, Any]:
+    """Once every stream has written, write a tuple of each one's latest
+    item whenever any writes; end when any ends (at once if one ends
+    without writing)."""
+    from pyfect.stream import _constructors, _zipping
+
+    require_streams(streams, "streams")
+    if not streams:
+        return _constructors.empty
+    return _zipping.zip_latest_all(*streams)
+
+
+def race_all[A, EE = Never, RR = Never](*streams: StreamBase[A, EE, RR]) -> Stream[A, EE, RR]:
+    """The stream that writes first; the others are interrupted."""
+    from pyfect.stream import _zipping
+
+    require_streams(streams, "streams")
+    return _zipping.race_all(*streams)