GitHub

ReactivityService

API reference for ReactivityService.

Registers handlers on keys and runs them when the keys are invalidated.

Functions

__init__

__init__() -> None
def __init__(self) -> None:
    self._handlers: dict[_Hash, dict[Callable[[], None], None]] = {}

invalidate_unsafe

invalidate_unsafe(keys) -> None

Run the handlers of keys now, each once.

ParameterTypeDescription
keysKeys
def invalidate_unsafe(self, keys: Keys) -> None:
    """Run the handlers of ``keys`` now, each once."""
    self._run_handlers(dict.fromkeys(_keys_to_hashes(keys)))

register_unsafe

register_unsafe(keys, handler) -> Callable[[], None]

Run handler whenever one of keys is invalidated; returns the function that unregisters it.

ParameterTypeDescription
keysKeys
handlerCallable[[], None]

Returns Callable[[], None]

def register_unsafe(self, keys: Keys, handler: Callable[[], None]) -> Callable[[], None]:
    """Run ``handler`` whenever one of ``keys`` is invalidated; returns
    the function that unregisters it."""
    resolved = list(_keys_to_hashes(keys))
    for hash_ in resolved:
        self._handlers.setdefault(hash_, {})[handler] = None

    def unregister() -> None:
        for hash_ in resolved:
            handlers = self._handlers.get(hash_)
            if handlers is None:
                continue
            handlers.pop(handler, None)
            if not handlers:
                del self._handlers[hash_]

    return unregister

invalidate

invalidate(keys) -> Effect[None]

Invalidate keys: now, or when the enclosing with_batch ends.

ParameterTypeDescription
keysKeys

Returns Effect[None]

def invalidate(self, keys: Keys) -> Effect[None]:
    """Invalidate ``keys``: now, or when the enclosing ``with_batch``
    ends."""

    def body(fiber: Fiber[Any, Any]) -> Effect[None]:
        found, pending = fiber._context.lookup(_PendingInvalidation)
        if found:
            pending.update(dict.fromkeys(_keys_to_hashes(keys)))
        else:
            self.invalidate_unsafe(keys)
        return _Succeed(None)

    return _WithFiber(body)

mutation

mutation[A, E, R](keys, effect) -> Effect[A, E, R]

Run effect, then invalidate keys if it succeeded.

ParameterTypeDescription
keysKeys
effectEffect[A, E, R]

Returns Effect[A, E, R]

def mutation[A, E, R](self, keys: Keys, effect: Effect[A, E, R]) -> Effect[A, E, R]:
    """Run ``effect``, then invalidate ``keys`` if it succeeded."""
    require_effect(effect, "effect")
    return effect.tap(lambda _: self.invalidate(keys))

query

query[A, E, R](keys, effect) -> Effect[Dequeue[A, E | Done], Never, R | Scope]

A queue of effect's results: it runs now, and again after each invalidation of keys (once more if invalidated while running), until the scope closes. A failure fails the queue and stops it.

ParameterTypeDescription
keysKeys
effectEffect[A, E, R]

Returns Effect[Dequeue[A, E | Done], Never, R | Scope]

def query[A, E, R](
    self, keys: Keys, effect: Effect[A, E, R]
) -> Effect[Dequeue[A, E | Done], Never, R | Scope]:
    """A queue of ``effect``'s results: it runs now, and again after each
    invalidation of ``keys`` (once more if invalidated while running),
    until the scope closes. A failure fails the queue and stops it."""
    require_effect(effect, "effect")

    def body(fiber: Fiber[Any, Any]) -> Effect[Dequeue[A, E | Done], Never, R | Scope]:
        services: Context[Any] = fiber._context
        scope: CloseableScope = services.get_unsafe(Scope)
        query = _Query[A, E](effect, services, scope)
        query.cancel = self.register_unsafe(keys, query.run)

        def start() -> Dequeue[A, E | Done]:
            query.run()
            return query.results

        return scope.add_finalizer(lambda _: _Sync(query.unregister)).and_then(_Sync(start))

    return _WithFiber(body)

stream

stream[A, E, R](keys, effect) -> Stream[A, E, R]

query's results as a stream.

ParameterTypeDescription
keysKeys
effectEffect[A, E, R]

Returns Stream[A, E, R]

def stream[A, E, R](self, keys: Keys, effect: Effect[A, E, R]) -> Stream[A, E, R]:
    """``query``'s results as a stream."""
    from pyfect import stream

    require_effect(effect, "effect")

    streams = self.query(keys, effect).map(stream.from_queue)
    return stream.unwrap(cast("Effect[Stream[A, E, R], E, Scope | R]", streams))

with_batch

with_batch[A, E, R](effect) -> Effect[A, E, R]

Run effect, collecting its invalidations, and run their handlers once when it ends.

ParameterTypeDescription
effectEffect[A, E, R]

Returns Effect[A, E, R]

def with_batch[A, E, R](self, effect: Effect[A, E, R]) -> Effect[A, E, R]:
    """Run ``effect``, collecting its invalidations, and run their
    handlers once when it ends."""
    require_effect(effect, "effect")

    def body() -> Effect[A, E, R]:
        # ordered: handlers run in the order keys were invalidated
        pending: dict[_Hash, None] = {}
        batched: Effect[A, E, R] = _Locally(
            effect, lambda ctx: ctx.add(_PendingInvalidation, pending)
        )
        return batched.on_exit(lambda _: _Sync(lambda: self._run_handlers(pending)))

    return _Suspend(body)