GitHub

UrlBuilder

API reference for UrlBuilder.

The URL of an endpoint of an API, as its client would request it (Effect's urlBuilder)::

urls = url_builder(api, base_url="https://api.example.com")
urls(Users.get_user, params={"id": "123"})  # "https://api.example.com/users/123"

Functions

__init__

__init__(api, base_url) -> None
ParameterTypeDescription
apiAnyApi
base_urlstr | Url | None
def __init__(self, api: AnyApi, base_url: str | Url | None) -> None:
    self._api = api
    self._base_url = base_url
    self._endpoints: dict[int, tuple[AnyGroup, AnyEndpoint]] = {}
    for g in api.groups.values():
        for klass in g.__mro__:
            for value in vars(klass).values():
                if isinstance(value, HttpApiEndpoint):
                    declared = cast("AnyEndpoint", value)
                    canonical = g.endpoints.get(declared.identifier)
                    if canonical is not None:
                        self._endpoints.setdefault(id(declared), (g, canonical))
        for e in g.endpoints.values():
            self._endpoints.setdefault(id(e), (g, e))

__call__

__call__[P, Q](endpoint, *, params=None, query=None) -> str
ParameterTypeDescription
endpointHttpApiEndpoint[P, Q, Any, Any, Any, Any, Any, Any, Any]
paramsP | None = None
queryQ | None = None

Returns str

def __call__[P, Q](
    self,
    endpoint: HttpApiEndpoint[P, Q, Any, Any, Any, Any, Any, Any, Any],
    *,
    params: P | None = None,
    query: Q | None = None,
) -> str:
    g, declared = self._endpoints[id(endpoint)]
    options = get_slot_parse_options(
        self._api.annotations.merge(g.annotations).merge(declared.annotations)
    )
    path = declared.path
    if params is not None:
        encoded = (
            params
            if declared.params is None
            else S.encode_sync(_codec(declared.params), **options.params)(params)
        )
        path = compile_path(path, declared.params)(cast("Mapping[str, Any]", encoded))
    query_input: Any = (
        None
        if query is None
        else query
        if declared.query is None
        else S.encode_sync(_codec(declared.query), **options.query)(query)
    )
    params_ = (
        url_params.UrlParams() if query_input is None else url_params.from_input(query_input)
    )
    if self._base_url is None:
        text = url_params.to_string(params_)
        return path if text == "" else f"{path}?{text}"
    request = (
        client_request.get(path).prepend_url(str(self._base_url)).append_url_params(params_)
    )
    url = request.to_url()
    if url is None:
        raise ValueError(f"Invalid URL: {request.url}")
    return href(url)