GitHub

AtomRpcClient

API reference for AtomRpcClient.

class AtomRpcClient[G: RpcGroup, T]

Atoms over a client of the RPC group G provided as T.

Attributes

AttributeTypeDescription
tag= tag
group= group
runtime= runtime
idstr

Functions

__init__

__init__(tag, group, runtime) -> None
ParameterTypeDescription
tagTagLike[G, T]
grouptype[G]
runtimeAtomRuntime[T, Never]
def __init__(self, tag: TagLike[G, T], group: type[G], runtime: AtomRuntime[T, Never]) -> None:
    self.tag = tag
    self.group = group
    self.runtime = runtime
    self._mutations: Callable[[str], Writable[Any, Any]] = family(self._make_mutation)
    self._queries: Callable[[_QueryKey], Atom[Any]] = family(self._make_query)

mutation

mutation[P, A, E](rpc: Rpc[P, A, E, Never], /) -> AtomResultFn[MutationRequest[P], A, E | RpcClientError]
mutation[P, A, E, ME](rpc: Rpc[P, A, E, RpcMiddleware[Any, ME, Any]], /) -> AtomResultFn[MutationRequest[P], A, E | ME | RpcClientError]

A function atom calling rpc with each request written to it.

ParameterTypeDescription
rpc
@overload
def mutation[P, A, E](
    self, rpc: Rpc[P, A, E, Never], /
) -> AtomResultFn[MutationRequest[P], A, E | RpcClientError]: ...
@overload
def mutation[P, A, E, ME](
    self, rpc: Rpc[P, A, E, RpcMiddleware[Any, ME, Any]], /
) -> AtomResultFn[MutationRequest[P], A, E | ME | RpcClientError]: ...
def mutation(self, rpc: AnyRpc, /) -> Writable[Any, Any]:
    """A function atom calling ``rpc`` with each request written to it."""
    return self._mutations(self._own(rpc).tag)

query

query[P, A, E](rpc: Rpc[P, A, E, Never], payload: P, /, *, headers: HeadersInput | None = None, reactivity_keys: Keys | None = None, time_to_live: DurationInput | None = None, serialization_key: str | None = None) -> Atom[AsyncResult[A, E | RpcClientError]]
query[P, A, E, ME](rpc: Rpc[P, A, E, RpcMiddleware[Any, ME, Any]], payload: P, /, *, headers: HeadersInput | None = None, reactivity_keys: Keys | None = None, time_to_live: DurationInput | None = None, serialization_key: str | None = None) -> Atom[AsyncResult[A, E | ME | RpcClientError]]
query[P, A, E](rpc: StreamRpc[P, A, E, Never], payload: P, /, *, headers: HeadersInput | None = None, reactivity_keys: Keys | None = None, time_to_live: DurationInput | None = None, serialization_key: str | None = None) -> Writable[PullResult[A, E | RpcClientError], None]
query[P, A, E, ME](rpc: StreamRpc[P, A, E, RpcMiddleware[Any, ME, Any]], payload: P, /, *, headers: HeadersInput | None = None, reactivity_keys: Keys | None = None, time_to_live: DurationInput | None = None, serialization_key: str | None = None) -> Writable[PullResult[A, E | ME | RpcClientError], None]

An atom holding the result of calling rpc with payload (for a streaming RPC, a pull atom reading its stream). reactivity_keys refresh it when invalidated, time_to_live keeps it that long after its last use (infinite: always), and serialization_key makes it serializable.

ParameterTypeDescription
rpc
payload
headers= None
reactivity_keys= None
time_to_live= None
serialization_key= None
@overload
def query[P, A, E](
    self,
    rpc: Rpc[P, A, E, Never],
    payload: P,
    /,
    *,
    headers: HeadersInput | None = None,
    reactivity_keys: Keys | None = None,
    time_to_live: DurationInput | None = None,
    serialization_key: str | None = None,
) -> Atom[AsyncResult[A, E | RpcClientError]]: ...
@overload
def query[P, A, E, ME](
    self,
    rpc: Rpc[P, A, E, RpcMiddleware[Any, ME, Any]],
    payload: P,
    /,
    *,
    headers: HeadersInput | None = None,
    reactivity_keys: Keys | None = None,
    time_to_live: DurationInput | None = None,
    serialization_key: str | None = None,
) -> Atom[AsyncResult[A, E | ME | RpcClientError]]: ...
@overload
def query[P, A, E](
    self,
    rpc: StreamRpc[P, A, E, Never],
    payload: P,
    /,
    *,
    headers: HeadersInput | None = None,
    reactivity_keys: Keys | None = None,
    time_to_live: DurationInput | None = None,
    serialization_key: str | None = None,
) -> Writable[PullResult[A, E | RpcClientError], None]: ...
@overload
def query[P, A, E, ME](
    self,
    rpc: StreamRpc[P, A, E, RpcMiddleware[Any, ME, Any]],
    payload: P,
    /,
    *,
    headers: HeadersInput | None = None,
    reactivity_keys: Keys | None = None,
    time_to_live: DurationInput | None = None,
    serialization_key: str | None = None,
) -> Writable[PullResult[A, E | ME | RpcClientError], None]: ...
def query(
    self,
    rpc: AnyRpc,
    payload: object,
    /,
    *,
    headers: HeadersInput | None = None,
    reactivity_keys: Keys | None = None,
    time_to_live: DurationInput | None = None,
    serialization_key: str | None = None,
) -> Atom[Any]:
    """An atom holding the result of calling ``rpc`` with ``payload``
    (for a streaming RPC, a pull atom reading its stream).
    ``reactivity_keys`` refresh it when invalidated, ``time_to_live``
    keeps it that long after its last use (infinite: always), and
    ``serialization_key`` makes it serializable."""
    key = _QueryKey(
        self._own(rpc).tag,
        payload,
        None if headers is None else http_headers.from_input(headers),
        reactivity_keys,
        None if time_to_live is None else from_input_unsafe(time_to_live),
        serialization_key,
    )
    return self._queries(key)