GitHub

API reference for stream.

Streams from drivers that push rows (Effect's effect/sql/SqlStream).

Classes

Functions

async_pause_resume

async_pause_resume[A, E, R](register, buffer_size=128) -> Stream[A, E, R]

A stream of what the source pushes through Emit. When the buffer of buffer_size rows is full, the source is paused until the rows it pushed meanwhile fit.

ParameterTypeDescription
registerCallable[[Emit[A, E]], Effect[PauseResume, E, R | Scope]]
buffer_sizeint = 128

Returns Stream[A, E, R]

def async_pause_resume[A, E, R](
    register: Callable[[Emit[A, E]], Effect[PauseResume, E, R | Scope]],
    buffer_size: int = 128,
) -> Stream[A, E, R]:
    """A stream of what the source pushes through ``Emit``. When the
    buffer of ``buffer_size`` rows is full, the source is paused until the
    rows it pushed meanwhile fit."""
    from pyfect import stream

    def start(queue: Queue[A, E | Done]) -> Effect[None, E, R | Scope]:
        def body(fiber: Fiber[Any, Any]) -> Effect[None, E, R | Scope]:
            scheduler = fiber.get_ref(CurrentScheduler)
            callbacks: list[PauseResume] = []
            paused = [False]

            def resumed() -> None:
                callbacks[0].on_resume()
                paused[0] = False

            def offer(items: Sequence[A]) -> None:
                if not items:
                    return
                full = queue.is_full_unsafe()
                if not full or paused[0]:
                    run_fork(queue.offer_all(items), scheduler=scheduler)
                    return
                paused[0] = True
                callbacks[0].on_pause()
                run_fork(queue.offer_all(items).tap(lambda _: _Sync(resumed)), scheduler=scheduler)

            emit = Emit[A, E](
                single=lambda item: offer((item,)),
                array=offer,
                fail=lambda error: _discard(queue.fail_cause_unsafe(fail(error))),
                end=lambda: _discard(queue.fail_cause_unsafe(fail(Done()))),
            )
            return register(emit).map(callbacks.append)

        return _WithFiber(body)

    return stream.callback(lambda queue: _Suspend(lambda: start(queue)), buffer_size=buffer_size)