class AtomRpcClient[G: RpcGroup, T]
Atoms over a client of the RPC group G provided as T.
Attributes#
| Attribute | Type | Description |
|---|---|---|
tag | = tag | |
group | = group | |
runtime | = runtime | |
id | str |
Functions#
__init__#
__init__(tag, group, runtime) -> None| Parameter | Type | Description |
|---|---|---|
tag | TagLike[G, T] | |
group | type[G] | |
runtime | AtomRuntime[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.
| Parameter | Type | Description |
|---|---|---|
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.
| Parameter | Type | Description |
|---|---|---|
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)