GitHub

RegistryService

API reference for RegistryService.

Handlers, compactors, remotes and reactivity keys of an event log (Effect's EventLog.Registry).

Attributes

AttributeTypeDescription
handlersdict[str, HandlerItem] = {}
compactorsdict[str, RegisteredCompactor] = {}
reactivity_keysdict[str, Sequence[str]] = {}
remotesMapping[RemoteId, EventLogRemoteService]

The remotes registered now, by id.

Functions

__init__

__init__(remote_fibers) -> None
ParameterTypeDescription
remote_fibersFiberMap[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) -> None

Makes handler the handler of the event tagged event at once, replacing any earlier one.

ParameterTypeDescription
eventstr
handlerHandlerItem
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] = handler

register_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.

ParameterTypeDescription
eventsSequence[str]
effectCompactFn
remotebool = 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.

ParameterTypeDescription
remoteEventLogRemoteService

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.

ParameterTypeDescription
handlerCallable[[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.

ParameterTypeDescription
keysMapping[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))