Handlers, compactors, remotes and reactivity keys of an event log
(Effect's EventLog.Registry).
Attributes#
| Attribute | Type | Description |
|---|---|---|
handlers | dict[str, HandlerItem] = {} | |
compactors | dict[str, RegisteredCompactor] = {} | |
reactivity_keys | dict[str, Sequence[str]] = {} | |
remotes | Mapping[RemoteId, EventLogRemoteService] | The remotes registered now, by id. |
Functions#
__init__#
__init__(remote_fibers) -> None| Parameter | Type | Description |
|---|---|---|
remote_fibers | FiberMap[RemoteId, Any, Any] |
def __init__(self, remote_fibers: FiberMap[RemoteId, Any, Any]) -> None:
self.handlers: dict[str, HandlerItem] = {}
self.compactors: dict[str, RegisteredCompactor] = {}
self.reactivity_keys: dict[str, Sequence[str]] = {}
self._remote_fibers = remote_fibers
self._remotes: dict[RemoteId, EventLogRemoteService] = {}
self._remote_handler: Callable[[EventLogRemoteService], Effect[None]] = lambda _: succeed(
None
)register_handler_unsafe#
register_handler_unsafe(event, handler) -> NoneMakes handler the handler of the event tagged event at
once, replacing any earlier one.
| Parameter | Type | Description |
|---|---|---|
event | str | |
handler | HandlerItem |
def register_handler_unsafe(self, event: str, handler: HandlerItem) -> None:
"""Makes ``handler`` the handler of the event tagged ``event`` at
once, replacing any earlier one."""
self.handlers[event] = handlerregister_compaction#
register_compaction(events, effect, *, remote=False) -> Effect[None, Never, Scope]Compact events with effect. With remote, it also runs
over a remote's history to build snapshots: the entries it keeps must
depend only on the set of input entries and compose (drop(drop(a) + b) keeps what drop(a + b) keeps, even when b holds entries
older than a), and a call that writes an entry it was not given
keeps its whole input.
| Parameter | Type | Description |
|---|---|---|
events | Sequence[str] | |
effect | CompactFn | |
remote | bool = False |
Returns Effect[None, Never, Scope]
def register_compaction(
self, events: Sequence[str], effect: CompactFn, *, remote: bool = False
) -> Effect[None, Never, Scope]:
"""Compact ``events`` with ``effect``. With ``remote``, it also runs
over a remote's history to build snapshots: the entries it keeps must
depend only on the set of input entries and compose (``drop(drop(a) +
b)`` keeps what ``drop(a + b)`` keeps, even when ``b`` holds entries
older than ``a``), and a call that writes an entry it was not given
keeps its whole input."""
def register() -> None:
compactor = RegisteredCompactor(frozenset(events), effect, remote)
for event in events:
self.compactors[event] = compactor
return sync(register)register_remote#
register_remote(remote) -> Effect[None, Never, Scope]Run the log's remote handler on remote until the scope
closes.
| Parameter | Type | Description |
|---|---|---|
remote | EventLogRemoteService |
Returns Effect[None, Never, Scope]
def register_remote(self, remote: EventLogRemoteService) -> Effect[None, Never, Scope]:
"""Run the log's remote handler on ``remote`` until the scope
closes."""
def acquire() -> Effect[None]:
self._remotes[remote.id] = remote
return self._remote_fibers.run(remote.id, self._remote_handler(remote)).as_void()
def release(_: object, __: object) -> Effect[None]:
self._remotes.pop(remote.id, None)
return self._remote_fibers.remove(remote.id)
return acquire_release(suspend(acquire), release)handle_remote#
handle_remote(handler) -> Effect[None]Run handler on each remote, registered now or later.
| Parameter | Type | Description |
|---|---|---|
handler | Callable[[EventLogRemoteService], Effect[None]] |
Returns Effect[None]
def handle_remote(
self, handler: Callable[[EventLogRemoteService], Effect[None]]
) -> Effect[None]:
"""Run ``handler`` on each remote, registered now or later."""
from pyfect._concurrency import for_each
self._remote_handler = handler
return for_each(
list(self._remotes.items()),
lambda item: self._remote_fibers.run(item[0], handler(item[1])),
).as_void()register_reactivity#
register_reactivity(keys) -> Effect[None, Never, Scope]Adds keys: the reactivity keys to invalidate when an event of
each tag is written (replacing a tag's earlier keys). They stay
registered after the Scope closes, as in Effect. Never fails.
| Parameter | Type | Description |
|---|---|---|
keys | Mapping[str, Sequence[str]] |
Returns Effect[None, Never, Scope]
def register_reactivity(self, keys: Mapping[str, Sequence[str]]) -> Effect[None, Never, Scope]:
"""Adds ``keys``: the reactivity keys to invalidate when an event of
each tag is written (replacing a tag's earlier keys). They stay
registered after the ``Scope`` closes, as in Effect. Never fails."""
return sync(lambda: self.reactivity_keys.update(keys))