class AtomHttpApiClient[T, G: HttpApiGroup[Any] = Any]
Atoms over the client of an HttpApi[G] provided as T.
query and mutation take only the api's groups G.
Attributes#
| Attribute | Type | Description |
|---|---|---|
tag | = tag | |
api | = api | |
runtime | = runtime | |
id | str |
Functions#
__init__#
__init__(tag, api, runtime) -> None| Parameter | Type | Description |
|---|---|---|
tag | TagLike[Any, T] | |
api | HttpApi[G] | |
runtime | AtomRuntime[T, Never] |
def __init__(
self, tag: TagLike[Any, T], api: HttpApi[G], runtime: AtomRuntime[T, Never]
) -> None:
self.tag = tag
self.api = api
self.runtime = runtime
self._mutations: Callable[[_MutationKey], Writable[Any, Any]] = family(self._make_mutation)
self._queries: Callable[[_QueryKey], Atom[Any]] = family(self._make_query)mutation#
mutation[P, Q, B, CB, H, S1, CS, E](group: type[G], endpoint: HttpApiEndpoint[P, Q, B, CB, H, S1, CS, E, Never], /, *, response_mode: Literal['decoded-only'] = 'decoded-only') -> AtomResultFn[MutationRequest[P, Q, CB, H], CS, E]
mutation[P, Q, B, CB, H, S1, CS, E, ME](group: type[G], endpoint: HttpApiEndpoint[P, Q, B, CB, H, S1, CS, E, HttpApiMiddleware[Any, ME, Any]], /, *, response_mode: Literal['decoded-only'] = 'decoded-only') -> AtomResultFn[MutationRequest[P, Q, CB, H], CS, E | ME]
mutation[P, Q, B, CB, H, S1, CS, E](group: type[G], endpoint: HttpApiEndpoint[P, Q, B, CB, H, S1, CS, E, Never], /, *, response_mode: Literal['decoded-and-response']) -> AtomResultFn[MutationRequest[P, Q, CB, H], tuple[CS, HttpClientResponse], E]
mutation[P, Q, B, CB, H, S1, CS, E, ME](group: type[G], endpoint: HttpApiEndpoint[P, Q, B, CB, H, S1, CS, E, HttpApiMiddleware[Any, ME, Any]], /, *, response_mode: Literal['decoded-and-response']) -> AtomResultFn[MutationRequest[P, Q, CB, H], tuple[CS, HttpClientResponse], E | ME]
mutation[P, Q, B, CB, H, S1, CS, E](group: type[G], endpoint: HttpApiEndpoint[P, Q, B, CB, H, S1, CS, E, Never], /, *, response_mode: Literal['response-only']) -> AtomResultFn[MutationRequest[P, Q, CB, H], HttpClientResponse]
mutation[P, Q, B, CB, H, S1, CS, E, ME](group: type[G], endpoint: HttpApiEndpoint[P, Q, B, CB, H, S1, CS, E, HttpApiMiddleware[Any, ME, Any]], /, *, response_mode: Literal['response-only']) -> AtomResultFn[MutationRequest[P, Q, CB, H], HttpClientResponse, ME]A function atom calling endpoint of group with each
request written to it, reading the response in response_mode.
| Parameter | Type | Description |
|---|---|---|
group | ||
endpoint | ||
response_mode | = 'decoded-only' |
@overload
def mutation[P, Q, B, CB, H, S1, CS, E](
self,
group: type[G],
endpoint: HttpApiEndpoint[P, Q, B, CB, H, S1, CS, E, Never],
/,
*,
response_mode: Literal["decoded-only"] = "decoded-only",
) -> AtomResultFn[MutationRequest[P, Q, CB, H], CS, E]: ...
@overload
def mutation[P, Q, B, CB, H, S1, CS, E, ME](
self,
group: type[G],
endpoint: HttpApiEndpoint[P, Q, B, CB, H, S1, CS, E, HttpApiMiddleware[Any, ME, Any]],
/,
*,
response_mode: Literal["decoded-only"] = "decoded-only",
) -> AtomResultFn[MutationRequest[P, Q, CB, H], CS, E | ME]: ...
@overload
def mutation[P, Q, B, CB, H, S1, CS, E](
self,
group: type[G],
endpoint: HttpApiEndpoint[P, Q, B, CB, H, S1, CS, E, Never],
/,
*,
response_mode: Literal["decoded-and-response"],
) -> AtomResultFn[MutationRequest[P, Q, CB, H], tuple[CS, HttpClientResponse], E]: ...
@overload
def mutation[P, Q, B, CB, H, S1, CS, E, ME](
self,
group: type[G],
endpoint: HttpApiEndpoint[P, Q, B, CB, H, S1, CS, E, HttpApiMiddleware[Any, ME, Any]],
/,
*,
response_mode: Literal["decoded-and-response"],
) -> AtomResultFn[MutationRequest[P, Q, CB, H], tuple[CS, HttpClientResponse], E | ME]: ...
@overload
def mutation[P, Q, B, CB, H, S1, CS, E](
self,
group: type[G],
endpoint: HttpApiEndpoint[P, Q, B, CB, H, S1, CS, E, Never],
/,
*,
response_mode: Literal["response-only"],
) -> AtomResultFn[MutationRequest[P, Q, CB, H], HttpClientResponse]: ...
@overload
def mutation[P, Q, B, CB, H, S1, CS, E, ME](
self,
group: type[G],
endpoint: HttpApiEndpoint[P, Q, B, CB, H, S1, CS, E, HttpApiMiddleware[Any, ME, Any]],
/,
*,
response_mode: Literal["response-only"],
) -> AtomResultFn[MutationRequest[P, Q, CB, H], HttpClientResponse, ME]: ...
def mutation(
self,
group: type[G],
endpoint: AnyEndpoint,
/,
*,
response_mode: ResponseMode = "decoded-only",
) -> Writable[Any, Any]:
"""A function atom calling ``endpoint`` of ``group`` with each
request written to it, reading the response in ``response_mode``."""
group_id, endpoint_id = self._own(group, endpoint)
return self._mutations(_MutationKey(group_id, endpoint_id, response_mode))mutate#
mutate[P, Q, B, CB, H, S1, CS, E](group: type[G], endpoint: HttpApiEndpoint[P, Q, B, CB, H, S1, CS, E, Never], /, *, response_mode: Literal['decoded-only'] = 'decoded-only') -> Mutate[P, Q, CB, H, CS, E]
mutate[P, Q, B, CB, H, S1, CS, E, ME](group: type[G], endpoint: HttpApiEndpoint[P, Q, B, CB, H, S1, CS, E, HttpApiMiddleware[Any, ME, Any]], /, *, response_mode: Literal['decoded-only'] = 'decoded-only') -> Mutate[P, Q, CB, H, CS, E | ME]
mutate[P, Q, B, CB, H, S1, CS, E](group: type[G], endpoint: HttpApiEndpoint[P, Q, B, CB, H, S1, CS, E, Never], /, *, response_mode: Literal['decoded-and-response']) -> Mutate[P, Q, CB, H, tuple[CS, HttpClientResponse], E]
mutate[P, Q, B, CB, H, S1, CS, E, ME](group: type[G], endpoint: HttpApiEndpoint[P, Q, B, CB, H, S1, CS, E, HttpApiMiddleware[Any, ME, Any]], /, *, response_mode: Literal['decoded-and-response']) -> Mutate[P, Q, CB, H, tuple[CS, HttpClientResponse], E | ME]
mutate[P, Q, B, CB, H, S1, CS, E](group: type[G], endpoint: HttpApiEndpoint[P, Q, B, CB, H, S1, CS, E, Never], /, *, response_mode: Literal['response-only']) -> Mutate[P, Q, CB, H, HttpClientResponse, Never]
mutate[P, Q, B, CB, H, S1, CS, E, ME](group: type[G], endpoint: HttpApiEndpoint[P, Q, B, CB, H, S1, CS, E, HttpApiMiddleware[Any, ME, Any]], /, *, response_mode: Literal['response-only']) -> Mutate[P, Q, CB, H, HttpClientResponse, ME]endpoint of group as a function of its request parts,
typed by the endpoint, giving the effect that writes them to the
mutation atom and waits for its result::
yield from client.mutate(Users, Users.create)(payload=user, reactivity_keys=["users"])(A MutationRequest dict literal written to the atom leaves the
parts the endpoint lacks unsolved under pyright.)
| Parameter | Type | Description |
|---|---|---|
group | ||
endpoint | ||
response_mode | = 'decoded-only' |
@overload
def mutate[P, Q, B, CB, H, S1, CS, E](
self,
group: type[G],
endpoint: HttpApiEndpoint[P, Q, B, CB, H, S1, CS, E, Never],
/,
*,
response_mode: Literal["decoded-only"] = "decoded-only",
) -> Mutate[P, Q, CB, H, CS, E]: ...
@overload
def mutate[P, Q, B, CB, H, S1, CS, E, ME](
self,
group: type[G],
endpoint: HttpApiEndpoint[P, Q, B, CB, H, S1, CS, E, HttpApiMiddleware[Any, ME, Any]],
/,
*,
response_mode: Literal["decoded-only"] = "decoded-only",
) -> Mutate[P, Q, CB, H, CS, E | ME]: ...
@overload
def mutate[P, Q, B, CB, H, S1, CS, E](
self,
group: type[G],
endpoint: HttpApiEndpoint[P, Q, B, CB, H, S1, CS, E, Never],
/,
*,
response_mode: Literal["decoded-and-response"],
) -> Mutate[P, Q, CB, H, tuple[CS, HttpClientResponse], E]: ...
@overload
def mutate[P, Q, B, CB, H, S1, CS, E, ME](
self,
group: type[G],
endpoint: HttpApiEndpoint[P, Q, B, CB, H, S1, CS, E, HttpApiMiddleware[Any, ME, Any]],
/,
*,
response_mode: Literal["decoded-and-response"],
) -> Mutate[P, Q, CB, H, tuple[CS, HttpClientResponse], E | ME]: ...
@overload
def mutate[P, Q, B, CB, H, S1, CS, E](
self,
group: type[G],
endpoint: HttpApiEndpoint[P, Q, B, CB, H, S1, CS, E, Never],
/,
*,
response_mode: Literal["response-only"],
) -> Mutate[P, Q, CB, H, HttpClientResponse, Never]: ...
@overload
def mutate[P, Q, B, CB, H, S1, CS, E, ME](
self,
group: type[G],
endpoint: HttpApiEndpoint[P, Q, B, CB, H, S1, CS, E, HttpApiMiddleware[Any, ME, Any]],
/,
*,
response_mode: Literal["response-only"],
) -> Mutate[P, Q, CB, H, HttpClientResponse, ME]: ...
def mutate(
self,
group: type[G],
endpoint: AnyEndpoint,
/,
*,
response_mode: ResponseMode = "decoded-only",
) -> Mutate[Any, Any, Any, Any, Any, Any]:
"""``endpoint`` of ``group`` as a function of its request parts,
typed by the endpoint, giving the effect that writes them to the
``mutation`` atom and waits for its result::
yield from client.mutate(Users, Users.create)(payload=user, reactivity_keys=["users"])
(A ``MutationRequest`` dict literal written to the atom leaves the
parts the endpoint lacks unsolved under pyright.)"""
return Mutate(self.mutation(group, endpoint, response_mode=response_mode))query#
query[P, Q, B, CB, H, S1, CS, E](group: type[G], endpoint: HttpApiEndpoint[P, Q, B, CB, H, S1, CS, E, Never], /, *, params: P | None = None, query: Q | None = None, payload: CB | None = None, headers: H | None = None, response_mode: Literal['decoded-only'] = 'decoded-only', sse_options: SseOptions | None = None, reactivity_keys: Keys | None = None, time_to_live: DurationInput | None = None, serialization_key: str | None = None) -> Atom[AsyncResult[CS, E]]
query[P, Q, B, CB, H, S1, CS, E, ME](group: type[G], endpoint: HttpApiEndpoint[P, Q, B, CB, H, S1, CS, E, HttpApiMiddleware[Any, ME, Any]], /, *, params: P | None = None, query: Q | None = None, payload: CB | None = None, headers: H | None = None, response_mode: Literal['decoded-only'] = 'decoded-only', sse_options: SseOptions | None = None, reactivity_keys: Keys | None = None, time_to_live: DurationInput | None = None, serialization_key: str | None = None) -> Atom[AsyncResult[CS, E | ME]]
query[P, Q, B, CB, H, S1, CS, E](group: type[G], endpoint: HttpApiEndpoint[P, Q, B, CB, H, S1, CS, E, Never], /, *, params: P | None = None, query: Q | None = None, payload: CB | None = None, headers: H | None = None, response_mode: Literal['decoded-and-response'], sse_options: SseOptions | None = None, reactivity_keys: Keys | None = None, time_to_live: DurationInput | None = None, serialization_key: str | None = None) -> Atom[AsyncResult[tuple[CS, HttpClientResponse], E]]
query[P, Q, B, CB, H, S1, CS, E, ME](group: type[G], endpoint: HttpApiEndpoint[P, Q, B, CB, H, S1, CS, E, HttpApiMiddleware[Any, ME, Any]], /, *, params: P | None = None, query: Q | None = None, payload: CB | None = None, headers: H | None = None, response_mode: Literal['decoded-and-response'], sse_options: SseOptions | None = None, reactivity_keys: Keys | None = None, time_to_live: DurationInput | None = None, serialization_key: str | None = None) -> Atom[AsyncResult[tuple[CS, HttpClientResponse], E | ME]]
query[P, Q, B, CB, H, S1, CS, E](group: type[G], endpoint: HttpApiEndpoint[P, Q, B, CB, H, S1, CS, E, Never], /, *, params: P | None = None, query: Q | None = None, payload: CB | None = None, headers: H | None = None, response_mode: Literal['response-only'], sse_options: SseOptions | None = None, reactivity_keys: Keys | None = None, time_to_live: DurationInput | None = None, serialization_key: str | None = None) -> Atom[AsyncResult[HttpClientResponse]]
query[P, Q, B, CB, H, S1, CS, E, ME](group: type[G], endpoint: HttpApiEndpoint[P, Q, B, CB, H, S1, CS, E, HttpApiMiddleware[Any, ME, Any]], /, *, params: P | None = None, query: Q | None = None, payload: CB | None = None, headers: H | None = None, response_mode: Literal['response-only'], sse_options: SseOptions | None = None, reactivity_keys: Keys | None = None, time_to_live: DurationInput | None = None, serialization_key: str | None = None) -> Atom[AsyncResult[HttpClientResponse, ME]]An atom holding the result of calling endpoint of group
with the given request parts. reactivity_keys refresh it when
invalidated, time_to_live keeps it that long after its last use
(infinite: always), and serialization_key makes a decoded-only
query serializable.
| Parameter | Type | Description |
|---|---|---|
group | ||
endpoint | ||
params | = None | |
query | = None | |
payload | = None | |
headers | = None | |
response_mode | = 'decoded-only' | |
sse_options | = None | |
reactivity_keys | = None | |
time_to_live | = None | |
serialization_key | = None |
@overload
def query[P, Q, B, CB, H, S1, CS, E](
self,
group: type[G],
endpoint: HttpApiEndpoint[P, Q, B, CB, H, S1, CS, E, Never],
/,
*,
params: P | None = None,
query: Q | None = None,
payload: CB | None = None,
headers: H | None = None,
response_mode: Literal["decoded-only"] = "decoded-only",
sse_options: SseOptions | None = None,
reactivity_keys: Keys | None = None,
time_to_live: DurationInput | None = None,
serialization_key: str | None = None,
) -> Atom[AsyncResult[CS, E]]: ...
@overload
def query[P, Q, B, CB, H, S1, CS, E, ME](
self,
group: type[G],
endpoint: HttpApiEndpoint[P, Q, B, CB, H, S1, CS, E, HttpApiMiddleware[Any, ME, Any]],
/,
*,
params: P | None = None,
query: Q | None = None,
payload: CB | None = None,
headers: H | None = None,
response_mode: Literal["decoded-only"] = "decoded-only",
sse_options: SseOptions | None = None,
reactivity_keys: Keys | None = None,
time_to_live: DurationInput | None = None,
serialization_key: str | None = None,
) -> Atom[AsyncResult[CS, E | ME]]: ...
@overload
def query[P, Q, B, CB, H, S1, CS, E](
self,
group: type[G],
endpoint: HttpApiEndpoint[P, Q, B, CB, H, S1, CS, E, Never],
/,
*,
params: P | None = None,
query: Q | None = None,
payload: CB | None = None,
headers: H | None = None,
response_mode: Literal["decoded-and-response"],
sse_options: SseOptions | None = None,
reactivity_keys: Keys | None = None,
time_to_live: DurationInput | None = None,
serialization_key: str | None = None,
) -> Atom[AsyncResult[tuple[CS, HttpClientResponse], E]]: ...
@overload
def query[P, Q, B, CB, H, S1, CS, E, ME](
self,
group: type[G],
endpoint: HttpApiEndpoint[P, Q, B, CB, H, S1, CS, E, HttpApiMiddleware[Any, ME, Any]],
/,
*,
params: P | None = None,
query: Q | None = None,
payload: CB | None = None,
headers: H | None = None,
response_mode: Literal["decoded-and-response"],
sse_options: SseOptions | None = None,
reactivity_keys: Keys | None = None,
time_to_live: DurationInput | None = None,
serialization_key: str | None = None,
) -> Atom[AsyncResult[tuple[CS, HttpClientResponse], E | ME]]: ...
@overload
def query[P, Q, B, CB, H, S1, CS, E](
self,
group: type[G],
endpoint: HttpApiEndpoint[P, Q, B, CB, H, S1, CS, E, Never],
/,
*,
params: P | None = None,
query: Q | None = None,
payload: CB | None = None,
headers: H | None = None,
response_mode: Literal["response-only"],
sse_options: SseOptions | None = None,
reactivity_keys: Keys | None = None,
time_to_live: DurationInput | None = None,
serialization_key: str | None = None,
) -> Atom[AsyncResult[HttpClientResponse]]: ...
@overload
def query[P, Q, B, CB, H, S1, CS, E, ME](
self,
group: type[G],
endpoint: HttpApiEndpoint[P, Q, B, CB, H, S1, CS, E, HttpApiMiddleware[Any, ME, Any]],
/,
*,
params: P | None = None,
query: Q | None = None,
payload: CB | None = None,
headers: H | None = None,
response_mode: Literal["response-only"],
sse_options: SseOptions | None = None,
reactivity_keys: Keys | None = None,
time_to_live: DurationInput | None = None,
serialization_key: str | None = None,
) -> Atom[AsyncResult[HttpClientResponse, ME]]: ...
def query(
self,
group: type[G],
endpoint: AnyEndpoint,
/,
*,
params: object = None,
query: object = None,
payload: object = None,
headers: object = None,
response_mode: ResponseMode = "decoded-only",
sse_options: SseOptions | 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 ``endpoint`` of ``group``
with the given request parts. ``reactivity_keys`` refresh it when
invalidated, ``time_to_live`` keeps it that long after its last use
(infinite: always), and ``serialization_key`` makes a decoded-only
query serializable."""
group_id, endpoint_id = self._own(group, endpoint)
given = {
"params": params,
"query": query,
"payload": payload,
"headers": headers,
"sse_options": sse_options,
}
request = tuple((k, v) for k, v in given.items() if v is not None)
key = _QueryKey(
group_id,
endpoint_id,
request,
response_mode,
reactivity_keys,
None if time_to_live is None else from_input_unsafe(time_to_live),
serialization_key,
)
return self._queries(key)query_of#
query_of[P, Q, B, CB, H, S1, CS, E](group: type[G], endpoint: HttpApiEndpoint[P, Q, B, CB, H, S1, CS, E, Never], /, *, response_mode: Literal['decoded-only'] = 'decoded-only') -> Query[P, Q, CB, H, CS, E]
query_of[P, Q, B, CB, H, S1, CS, E, ME](group: type[G], endpoint: HttpApiEndpoint[P, Q, B, CB, H, S1, CS, E, HttpApiMiddleware[Any, ME, Any]], /, *, response_mode: Literal['decoded-only'] = 'decoded-only') -> Query[P, Q, CB, H, CS, E | ME]
query_of[P, Q, B, CB, H, S1, CS, E](group: type[G], endpoint: HttpApiEndpoint[P, Q, B, CB, H, S1, CS, E, Never], /, *, response_mode: Literal['decoded-and-response']) -> Query[P, Q, CB, H, tuple[CS, HttpClientResponse], E]
query_of[P, Q, B, CB, H, S1, CS, E, ME](group: type[G], endpoint: HttpApiEndpoint[P, Q, B, CB, H, S1, CS, E, HttpApiMiddleware[Any, ME, Any]], /, *, response_mode: Literal['decoded-and-response']) -> Query[P, Q, CB, H, tuple[CS, HttpClientResponse], E | ME]
query_of[P, Q, B, CB, H, S1, CS, E](group: type[G], endpoint: HttpApiEndpoint[P, Q, B, CB, H, S1, CS, E, Never], /, *, response_mode: Literal['response-only']) -> Query[P, Q, CB, H, HttpClientResponse, Never]
query_of[P, Q, B, CB, H, S1, CS, E, ME](group: type[G], endpoint: HttpApiEndpoint[P, Q, B, CB, H, S1, CS, E, HttpApiMiddleware[Any, ME, Any]], /, *, response_mode: Literal['response-only']) -> Query[P, Q, CB, H, HttpClientResponse, ME]query as a function of the request parts, typed by the
endpoint alone::
client.query_of(Users, Users.get_user)(params={"id": 1})query(group, endpoint, params=...) solves the parts' types from
the endpoint and the parts together, and the endpoint is covariant,
so a wrong part widens them and is accepted; here it is an error.
| Parameter | Type | Description |
|---|---|---|
group | ||
endpoint | ||
response_mode | = 'decoded-only' |
@overload
def query_of[P, Q, B, CB, H, S1, CS, E](
self,
group: type[G],
endpoint: HttpApiEndpoint[P, Q, B, CB, H, S1, CS, E, Never],
/,
*,
response_mode: Literal["decoded-only"] = "decoded-only",
) -> Query[P, Q, CB, H, CS, E]: ...
@overload
def query_of[P, Q, B, CB, H, S1, CS, E, ME](
self,
group: type[G],
endpoint: HttpApiEndpoint[P, Q, B, CB, H, S1, CS, E, HttpApiMiddleware[Any, ME, Any]],
/,
*,
response_mode: Literal["decoded-only"] = "decoded-only",
) -> Query[P, Q, CB, H, CS, E | ME]: ...
@overload
def query_of[P, Q, B, CB, H, S1, CS, E](
self,
group: type[G],
endpoint: HttpApiEndpoint[P, Q, B, CB, H, S1, CS, E, Never],
/,
*,
response_mode: Literal["decoded-and-response"],
) -> Query[P, Q, CB, H, tuple[CS, HttpClientResponse], E]: ...
@overload
def query_of[P, Q, B, CB, H, S1, CS, E, ME](
self,
group: type[G],
endpoint: HttpApiEndpoint[P, Q, B, CB, H, S1, CS, E, HttpApiMiddleware[Any, ME, Any]],
/,
*,
response_mode: Literal["decoded-and-response"],
) -> Query[P, Q, CB, H, tuple[CS, HttpClientResponse], E | ME]: ...
@overload
def query_of[P, Q, B, CB, H, S1, CS, E](
self,
group: type[G],
endpoint: HttpApiEndpoint[P, Q, B, CB, H, S1, CS, E, Never],
/,
*,
response_mode: Literal["response-only"],
) -> Query[P, Q, CB, H, HttpClientResponse, Never]: ...
@overload
def query_of[P, Q, B, CB, H, S1, CS, E, ME](
self,
group: type[G],
endpoint: HttpApiEndpoint[P, Q, B, CB, H, S1, CS, E, HttpApiMiddleware[Any, ME, Any]],
/,
*,
response_mode: Literal["response-only"],
) -> Query[P, Q, CB, H, HttpClientResponse, ME]: ...
def query_of(
self,
group: type[G],
endpoint: AnyEndpoint,
/,
*,
response_mode: ResponseMode = "decoded-only",
) -> Query[Any, Any, Any, Any, Any, Any]:
"""``query`` as a function of the request parts, typed by the
endpoint alone::
client.query_of(Users, Users.get_user)(params={"id": 1})
``query(group, endpoint, params=...)`` solves the parts' types from
the endpoint and the parts together, and the endpoint is covariant,
so a wrong part widens them and is accepted; here it is an error."""
self._own(group, endpoint)
query = cast("Callable[..., Atom[Any]]", self.query)
return Query(partial(query, group, endpoint, response_mode=response_mode))