Makes runtimes sharing one memo map and one global layer (Effect's
Atom.context()).
Attributes#
| Attribute | Type | Description |
|---|---|---|
memo_map | Atom[MemoMap] | MemoMap = remove_ttl(readable(lambda _get: MemoMap())) if memo_map is None else memo_map | |
global_layer | Layer[Any, Any, Any] = _reactivity.layer |
Functions#
__init__#
__init__(memo_map=None) -> None| Parameter | Type | Description |
|---|---|---|
memo_map | Atom[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.
| Parameter | Type | Description |
|---|---|---|
create | Layer[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) -> NoneAdd layer (given Reactivity) to every runtime this
factory makes from now on.
| Parameter | Type | Description |
|---|---|---|
layer | Layer[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.
| Parameter | Type | Description |
|---|---|---|
keys | Keys |
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