GitHub

reactivity

API reference for reactivity.

Queries that run again when what they read changes (Effect's effect/reactivity/Reactivity), and atoms (atom, atom_registry, hydration; atom_rpc and atom_http_api over RPC and HttpApi clients, imported on first use).

Values

AttributeTypeDescription
layerLayer[Reactivity]

Provides a new ReactivityService.

makeEffect[ReactivityService]

A new ReactivityService.

Types

TypeDefinitionDescription
Keystype Keys = Sequence[object] | Mapping[str, Sequence[object]]

What a query reads or a mutation changes: values, or ids by name.

Classes

Functions

invalidate

invalidate(keys) -> Effect[None, Never, Reactivity]

Invalidate keys.

ParameterTypeDescription
keysKeys

Returns Effect[None, Never, Reactivity]

def invalidate(keys: Keys) -> Effect[None, Never, Reactivity]:
    """Invalidate ``keys``."""
    return Reactivity().flat_map(lambda r: r.invalidate(keys))

mutation

mutation[A, E, R](effect, keys) -> Effect[A, E, R | Reactivity]

Run effect, then invalidate keys if it succeeded.

ParameterTypeDescription
effectEffect[A, E, R]
keysKeys

Returns Effect[A, E, R | Reactivity]

def mutation[A, E, R](effect: Effect[A, E, R], keys: Keys) -> Effect[A, E, R | Reactivity]:
    """Run ``effect``, then invalidate ``keys`` if it succeeded."""
    require_effect(effect, "effect")
    return Reactivity().flat_map(lambda r: r.mutation(keys, effect))

query

query[A, E, R](effect, keys) -> Effect[Dequeue[A, E | Done], Never, R | Scope | Reactivity]

A queue of effect's results, refreshed when keys are invalidated (see ReactivityService.query).

ParameterTypeDescription
effectEffect[A, E, R]
keysKeys

Returns Effect[Dequeue[A, E | Done], Never, R | Scope | Reactivity]

def query[A, E, R](
    effect: Effect[A, E, R], keys: Keys
) -> Effect[Dequeue[A, E | Done], Never, R | Scope | Reactivity]:
    """A queue of ``effect``'s results, refreshed when ``keys`` are
    invalidated (see ``ReactivityService.query``)."""
    require_effect(effect, "effect")
    return Reactivity().flat_map(lambda r: r.query(keys, effect))

stream

stream[A, E, R](effect, keys) -> Stream[A, E, R | Reactivity]

query's results as a stream.

ParameterTypeDescription
effectEffect[A, E, R]
keysKeys

Returns Stream[A, E, R | Reactivity]

def stream[A, E, R](effect: Effect[A, E, R], keys: Keys) -> Stream[A, E, R | Reactivity]:
    """``query``'s results as a stream."""
    from pyfect import stream as stream_

    require_effect(effect, "effect")

    streams = query(effect, keys).map(stream_.from_queue)
    return stream_.unwrap(
        cast("Effect[Stream[A, E, R | Reactivity], E, Scope | R | Reactivity]", streams)
    )

Modules