GitHub

event_log_server_unencrypted

API reference for event_log_server_unencrypted.

An event log server that reads the entries it stores (Effect's eventlog/EventLogServerUnencrypted).

Writes are authorized, mapped to a store, run through the server's own group handlers (with their conflicts) and stored; change streams compact the backlog with the registered compactors. EventLogServerUnencrypted writes events from the server itself.

Values

AttributeTypeDescription
layer_rpc_handlersLayer[HandlersFor[EventLogRemoteRpcs] | EventLogAuthentication, Never, Storage | StoreMapping | EventLogServerAuthorization | Registry]

The RPC handlers of an unencrypted server.

make_storage_memoryEffect[StorageService, Never, Scope]

Storage kept in memory (sequences start at 1), its pubsubs shut down when the scope closes.

layer_storage_memoryLayer[Storage]

Storage kept in memory (make_storage_memory).

layer_serverLayer[EventLogServerUnencrypted | Registry, Never, Storage]

EventLogServerUnencrypted and its Registry.

Classes

Functions

layer_store_mapping_static

layer_store_mapping_static(*, store_id) -> Layer[StoreMapping]

Every public key maps store_id to itself; other stores are not found.

ParameterTypeDescription
store_idStoreId

Returns Layer[StoreMapping]

def layer_store_mapping_static(*, store_id: StoreId) -> Layer[StoreMapping]:
    """Every public key maps ``store_id`` to itself; other stores are not found."""
    return layer_succeed(StoreMapping, _StaticMapping(store_id))

compact_backlog

compact_backlog(remote_entries, compactors) -> Effect[list[RemoteEntry]]

Runs of entries sharing a compactor, compacted; outputs take the sequences of their run's first entries and its last (a run that cannot be renumbered stays as it was).

ParameterTypeDescription
remote_entriesSequence[RemoteEntry]
compactorsMapping[str, RegisteredCompactor]

Returns Effect[list[RemoteEntry]]

def compact_backlog(
    remote_entries: Sequence[RemoteEntry], compactors: Mapping[str, RegisteredCompactor]
) -> Effect[list[RemoteEntry]]:
    """Runs of entries sharing a compactor, compacted; outputs take the
    sequences of their run's first entries and its last (a run that
    cannot be renumbered stays as it was)."""
    if not compactors or not remote_entries:
        return succeed(list(remote_entries))

    def body():
        result: list[RemoteEntry] = []
        index = 0
        while index < len(remote_entries):
            compactor = compactors.get(remote_entries[index].entry.event)
            if compactor is None:
                result.append(remote_entries[index])
                index += 1
                continue
            group: list[RemoteEntry] = []
            while index < len(remote_entries) and (
                compactors.get(remote_entries[index].entry.event) is compactor
            ):
                group.append(remote_entries[index])
                index += 1
            entries = [e.entry for e in group]
            positions: dict[bytes, int] = {e.id: i for i, e in enumerate(entries)}
            compacted: list[list[Entry]] = [[] for _ in entries]

            def write(
                entry: Entry,
                source: Entry | None,
                positions: dict[bytes, int] = positions,
                compacted: list[list[Entry]] = compacted,
            ) -> Effect[None]:
                return sync(lambda: compacted[positions.get((source or entry).id, 0)].append(entry))

            yield from compactor.effect(entries, write)
            flat = [e for part in compacted for e in part]
            sequences = _representative_sequences(group, len(flat))
            if sequences is None:
                result.extend(group)
            else:
                unchecked = new(RemoteEntry, disable_checks=True)
                result.extend(
                    unchecked(remote_sequence=s, entry=e)
                    for s, e in zip(sequences, flat, strict=True)
                )
        return result

    return gen(body)

make_write

make_write(schema) -> Effect[ServerWrite, Never, EventLogServerUnencrypted]

The server's write(store_id=, event=, payload=) for schema.

ParameterTypeDescription
schemaEventLogSchema[EventGroup[AnyEvent]]

Returns Effect[ServerWrite, Never, EventLogServerUnencrypted]

def make_write(
    schema: EventLogSchema[EventGroup[AnyEvent]],
) -> Effect[ServerWrite, Never, EventLogServerUnencrypted]:
    """The server's ``write(store_id=, event=, payload=)`` for ``schema``."""
    return EventLogServerUnencrypted().map(lambda server: server.make_write(schema))

layer

layer[E = Never](schema: EventLogSchema[EventGroup[AnyEvent]], handlers: Layer[Never, E, Registry]) -> Layer[Never, E, EventLogServerAuthorization | ServerProtocol | Storage | StoreMapping]
layer[E = Never, R = Never](schema: EventLogSchema[EventGroup[AnyEvent]], handlers: Layer[Never, E, R | Registry]) -> Layer[Never, E, R | EventLogServerAuthorization | ServerProtocol | Storage | StoreMapping]

An unencrypted server of schema with the group handlers, over the ServerProtocol. The server gives the handlers its Registry.

ParameterTypeDescription
schema
handlers
@overload
def layer[E = Never](
    schema: EventLogSchema[EventGroup[AnyEvent]], handlers: Layer[Never, E, Registry]
) -> Layer[Never, E, EventLogServerAuthorization | ServerProtocol | Storage | StoreMapping]: ...
@overload
def layer[E = Never, R = Never](
    schema: EventLogSchema[EventGroup[AnyEvent]], handlers: Layer[Never, E, R | Registry]
) -> Layer[Never, E, R | EventLogServerAuthorization | ServerProtocol | Storage | StoreMapping]: ...
def layer[E = Never, R = Never](
    schema: EventLogSchema[EventGroup[AnyEvent]], handlers: Layer[Never, E, R | Registry]
) -> Layer[
    Never,
    E,
    R | EventLogServerAuthorization | ServerProtocol | Storage | StoreMapping,
]:
    """An unencrypted server of ``schema`` with the group ``handlers``,
    over the ``ServerProtocol``. The server gives the handlers its
    ``Registry``."""
    require_layer(handlers, "handlers")
    del schema
    # pyright cannot take Registry out of ``R | Registry``; layer_server gives it.
    erased = cast("Layer[Any, E, Any]", handlers)
    return (
        rpc_server_layer(EventLogRemoteRpcs)
        .pipe(layer_provide(layer_rpc_handlers))
        .pipe(layer_provide(erased))
        .pipe(layer_provide(layer_server))
    )

layer_no_rpc_server

layer_no_rpc_server[E = Never](schema: EventLogSchema[EventGroup[AnyEvent]], handlers: Layer[Never, E, Registry]) -> Layer[HandlersFor[EventLogRemoteRpcs] | EventLogAuthentication, E, EventLogServerAuthorization | Storage | StoreMapping]
layer_no_rpc_server[E = Never, R = Never](schema: EventLogSchema[EventGroup[AnyEvent]], handlers: Layer[Never, E, R | Registry]) -> Layer[HandlersFor[EventLogRemoteRpcs] | EventLogAuthentication, E, R | EventLogServerAuthorization | Storage | StoreMapping]

The RPC handlers of an unencrypted server, without the server.

ParameterTypeDescription
schema
handlers
@overload
def layer_no_rpc_server[E = Never](
    schema: EventLogSchema[EventGroup[AnyEvent]], handlers: Layer[Never, E, Registry]
) -> Layer[
    HandlersFor[EventLogRemoteRpcs] | EventLogAuthentication,
    E,
    EventLogServerAuthorization | Storage | StoreMapping,
]: ...
@overload
def layer_no_rpc_server[E = Never, R = Never](
    schema: EventLogSchema[EventGroup[AnyEvent]], handlers: Layer[Never, E, R | Registry]
) -> Layer[
    HandlersFor[EventLogRemoteRpcs] | EventLogAuthentication,
    E,
    R | EventLogServerAuthorization | Storage | StoreMapping,
]: ...
def layer_no_rpc_server[E = Never, R = Never](
    schema: EventLogSchema[EventGroup[AnyEvent]], handlers: Layer[Never, E, R | Registry]
) -> Layer[
    HandlersFor[EventLogRemoteRpcs] | EventLogAuthentication,
    E,
    R | EventLogServerAuthorization | Storage | StoreMapping,
]:
    """The RPC handlers of an unencrypted server, without the server."""
    require_layer(handlers, "handlers")
    del schema
    rpc_handlers = cast(
        "Layer[HandlersFor[EventLogRemoteRpcs] | EventLogAuthentication, E, Any]",
        layer_rpc_handlers,
    )
    erased = cast("Layer[Any, E, Any]", handlers)
    return merge(rpc_handlers, erased).pipe(layer_provide(layer_server))