GitHub

AtomHttpApiClient

API reference for AtomHttpApiClient.

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

AttributeTypeDescription
tag= tag
api= api
runtime= runtime
idstr

Functions

__init__

__init__(tag, api, runtime) -> None
ParameterTypeDescription
tagTagLike[Any, T]
apiHttpApi[G]
runtimeAtomRuntime[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.

ParameterTypeDescription
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.)

ParameterTypeDescription
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.

ParameterTypeDescription
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.

ParameterTypeDescription
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))