GitHub

RuntimeFactory

API reference for RuntimeFactory.

Makes runtimes sharing one memo map and one global layer (Effect's Atom.context()).

Attributes

AttributeTypeDescription
memo_mapAtom[MemoMap] | MemoMap = remove_ttl(readable(lambda _get: MemoMap())) if memo_map is None else memo_map
global_layerLayer[Any, Any, Any] = _reactivity.layer

Functions

__init__

__init__(memo_map=None) -> None
ParameterTypeDescription
memo_mapAtom[MemoMap] | MemoMap | None = None
def __init__(self, memo_map: Atom[MemoMap] | MemoMap | None = None) -> None:
    self.memo_map: Atom[MemoMap] | MemoMap = (
        remove_ttl(readable(lambda _get: MemoMap())) if memo_map is None else memo_map
    )
    self.global_layer: Layer[Any, Any, Any] = _reactivity.layer

    self._reactivity_atom: Atom[AsyncResult[Any, Any]] = remove_ttl(
        readable(partial(_build_reactivity, self.memo_map))
    )

__call__

__call__[R, E = Never](create) -> AtomRuntime[R, E]

A runtime of create's layer.

ParameterTypeDescription
createLayer[R, E, AtomRegistry | Reactivity] | Callable[[AtomContext], Layer[R, E, AtomRegistry | Reactivity]]

Returns AtomRuntime[R, E]

def __call__[R, E = Never](
    self,
    create: Layer[R, E, AtomRegistry | Reactivity]
    | Callable[[AtomContext], Layer[R, E, AtomRegistry | Reactivity]],
) -> AtomRuntime[R, E]:
    """A runtime of ``create``'s layer."""
    layer_atom: Atom[Layer[Any, Any, Any]] = readable(
        create if callable(create) else lambda _get: create
    ).keep_alive()

    def read(get: AtomContext) -> AsyncResult[Context[Any], Any]:
        layer = provide_merge(self.global_layer)(get(layer_atom))
        built: list[Context[Any]] = [Context.empty()]
        memo = self._resolve_memo_map(get)

        def build(scope: Any) -> Effect[Context[Any], Any, Any]:
            def keep(services: Context[Any]) -> Context[Any]:
                built[0] = services
                return services

            return layer.build_with_memo_map(memo, cast("CloseableScope", scope)).map(keep)

        return make_effect(
            get, Scope().flat_map(build), async_result.initial(), lambda: built[0], True
        )

    return AtomRuntime(read, self, layer_atom)

add_global_layer

add_global_layer(layer) -> None

Add layer (given Reactivity) to every runtime this factory makes from now on.

ParameterTypeDescription
layerLayer[Any, Any, AtomRegistry | Reactivity]
def add_global_layer(self, layer: Layer[Any, Any, AtomRegistry | Reactivity]) -> None:
    """Add ``layer`` (given ``Reactivity``) to every runtime this
    factory makes from now on."""
    require_layer(layer, "layer")
    with_reactivity = provide(_reactivity.layer)(cast("Layer[Any, Any, Any]", layer))
    self.global_layer = provide_merge(with_reactivity)(self.global_layer)

with_reactivity

with_reactivity[T: Atom[Any]](keys) -> Callable[[T], T]

Refresh an atom whenever keys are invalidated.

ParameterTypeDescription
keysKeys

Returns Callable[[T], T]

def with_reactivity[T: Atom[Any]](self, keys: Keys) -> Callable[[T], T]:
    """Refresh an atom whenever ``keys`` are invalidated."""
    reactivity_atom = self._reactivity_atom

    def apply(atom: T) -> T:
        def read(get: AtomContext, source: Atom[Any]) -> Any:
            reactivity = async_result.get_or_raise(get(reactivity_atom))
            get.add_finalizer(reactivity.register_unsafe(keys, lambda: get.refresh(source)))
            get.subscribe(source, get.set_self)
            return get.once(source)

        return cast("T", transform(atom, read, initial_value_target=atom))

    return apply