Registers handlers on keys and runs them when the keys are invalidated.
Functions#
__init__#
__init__() -> Nonedef __init__(self) -> None:
self._handlers: dict[_Hash, dict[Callable[[], None], None]] = {}invalidate_unsafe#
invalidate_unsafe(keys) -> NoneRun the handlers of keys now, each once.
| Parameter | Type | Description |
|---|---|---|
keys | Keys |
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.
| Parameter | Type | Description |
|---|---|---|
keys | Keys | |
handler | Callable[[], 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 unregisterinvalidate#
invalidate(keys) -> Effect[None]Invalidate keys: now, or when the enclosing with_batch
ends.
| Parameter | Type | Description |
|---|---|---|
keys | Keys |
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.
| Parameter | Type | Description |
|---|---|---|
keys | Keys | |
effect | Effect[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.
| Parameter | Type | Description |
|---|---|---|
keys | Keys | |
effect | Effect[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.
| Parameter | Type | Description |
|---|---|---|
keys | Keys | |
effect | Effect[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.
| Parameter | Type | Description |
|---|---|---|
effect | Effect[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)