diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml index a240c4e..8d64a6f 100644 --- a/.github/workflows/ci.yml +++ b/.github/workflows/ci.yml @@ -60,7 +60,7 @@ jobs: with: python-version: "3.10" - run: >- - uv run --isolated --resolution lowest-direct --with-editable '.[pty]' + uv run --isolated --resolution lowest-direct --with-editable '.[pty,aiohttp]' --with pytest --with respx --with trio pytest -m "not live" -p no:cacheprovider diff --git a/CHANGELOG.md b/CHANGELOG.md index 754a664..0396e36 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -11,6 +11,15 @@ Releases are published automatically on every merge to `main`. Release notes for - `client.rpc(Definition)`: typed plugin RPC calls and event subscriptions declared with `RpcDefinition`, `rpc_method` and `rpc_event`; RPC failures raise `RpcCallError` / `RpcCallInternalError`. - `Stream.on_activity` and `Stream.interrupt()`. +- `client.copy(...)`, an alias of `client.with_options(...)`; documented that copies share the connection pool + and do not close it. +- `OPENCODE_LOG=debug|info` sends the `opencode` logger to stderr at that level. +- `DefaultAioHttpClient`: an optional aiohttp transport for `AsyncOpencode`, installed with the `aiohttp` extra + (`pip install 'opencode-python-sdk[aiohttp]'`) and passed as `http_client=`. +- `.with_raw_response` and `.with_streaming_response` on every resource (sync and async): return an + `APIResponse` / `AsyncAPIResponse` with `headers`, `status_code`, `http_response`, `request`, `text`, `json()`, + `iter_bytes()` / `iter_lines()` and `parse()` for the usual typed value. +- `client.get` / `post` / `put` / `patch` / `delete` for endpoints the client has no method for. ## 0.1.0 diff --git a/README.md b/README.md index 05ba03d..30d2e8f 100644 --- a/README.md +++ b/README.md @@ -79,6 +79,27 @@ async def main() -> None: asyncio.run(main()) ``` +### aiohttp transport + +For high-concurrency asyncio code you can swap httpx's networking for [aiohttp](https://docs.aiohttp.org). Install +the extra and pass `DefaultAioHttpClient` as `http_client`: + +```bash +pip install 'opencode-python-sdk[aiohttp]' +``` + +```python +from opencode import AsyncOpencode, DefaultAioHttpClient + + +async def main() -> None: + async with DefaultAioHttpClient() as http, AsyncOpencode("http://127.0.0.1:4096", http_client=http) as client: + info = await client.server.info() +``` + +Retries, timeouts and event streams work the same. aiohttp runs on asyncio only, not trio. The client does not close +an `http_client` you pass in, so close it yourself as above. + ## Calling the API Methods mirror the official TypeScript client: `client..()`, with names in `snake_case`. Path @@ -313,6 +334,15 @@ client.session.get("ses_...", timeout=5.0) # per call The default timeout is 10 minutes with a 10 second connect timeout. +`with_options` (alias `copy`) returns a client with some options changed: `timeout`, `max_retries`, `base_url`, +`password`, `directory`, `default_headers` and `default_query` (headers and query are merged over the current +ones). The copy shares the original's connection pool, and closing it leaves the pool open. + +```python +client.with_options(max_retries=0).session.create() # no retries for this call +scoped = client.with_options(directory="/other/repo", default_headers={"X-Trace": "1"}) +``` + ## Running an agent headless `client.session.run` does the usual "prompt an agent and wait" round trip in one call: it creates a session (or @@ -420,7 +450,63 @@ client.session.create(title="t", extra_headers={"X-Trace": "1"}, extra_body={"fu ``` Logs go to the `opencode` logger. `logging.getLogger("opencode").setLevel(logging.DEBUG)` shows every request and -retry; credentials are never logged. +retry; credentials are never logged. Set `OPENCODE_LOG=debug` (or `info`) to have the SDK attach a stderr handler at +that level on import, without touching your own logging config. + +### Accessing raw response data + +Prefix any method with `.with_raw_response` to get the HTTP response (headers, status, request) instead of the +parsed value. `.parse()` returns what the plain call would have returned: + +```python +response = client.session.with_raw_response.get("ses_...") +print(response.status_code, response.headers.get("content-type")) +session = response.parse() # SessionInfo +``` + +`.with_raw_response` reads the body before returning. `.with_streaming_response` does not: it is a context manager +that sends the request on entry and closes the connection on exit, so you can read large bodies incrementally with +`iter_bytes()`, `iter_text()` or `iter_lines()`, or still call `parse()`: + +```python +with client.file.with_streaming_response.read("big.log") as response: + for line in response.iter_lines(): + ... +``` + +Both exist on every resource and sub-resource of both clients (`async with` and `await response.parse()` on +`AsyncOpencode`). `APIResponse` also has `.http_response`, `.request`, `.text`, `.json()` and `.read()`. + +- **List methods** give the response of the first page; `parse()` returns a `SyncCursorPage` / `AsyncCursorPage` + that fetches the following pages as usual. +- **Event streams** are never read eagerly: `parse()` returns the `Stream` / `AsyncStream`, which reads events as + you iterate. Close the stream (or the response) when done. +- Error statuses still raise `APIStatusError` subclasses; the response is on the exception as `error.response`. +- Hand-written helpers such as `client.session.run()` and `client.pty.attach()` are not wrapped. + +### Making custom/undocumented requests + +Undocumented parameters go through `extra_headers`, `extra_query` and `extra_body` on every method (see above). For +an endpoint the client has no method for, `client.get`, `post`, `put`, `patch` and `delete` send a request relative +to `base_url` with the client's authentication, retries and typed errors, and return the decoded JSON: + +```python +data = client.post("/api/new-endpoint", body={"key": "value"}, query={"directory": "/repo"}) + +# Validate into a type, e.g. a response wrapped in {"data": ...}: +from opencode.types import SessionInfo + +payload = client.get("/api/session/ses_...", cast_to=dict[str, SessionInfo]) +``` + +### Determining the installed version + +```python +import opencode + +print(opencode.__version__) # this package +print(opencode.API_VERSION) # the OpenCode server version it was generated from +``` ## Versioning diff --git a/codegen/render.py b/codegen/render.py index a0a9b50..3a9588b 100644 --- a/codegen/render.py +++ b/codegen/render.py @@ -359,7 +359,13 @@ def _render_method(operation: Operation, errors: dict[str, dict[str, Any]], *, i " )", ] elif operation.kind == "void": - lines += [f" {awaiting}self._client.request(", *request_options, ' kind="void",', " )"] + # Returned so ``with_raw_response`` can hand back the response; a plain call returns ``None``. + lines += [ + f' return cast("None", {awaiting}self._client.request(', + *request_options, + ' kind="void",', + " ))", + ] elif operation.kind == "binary": lines += [ f' return cast("bytes", {awaiting}self._client.request(', @@ -412,13 +418,67 @@ def _resource_classes(resource: Resource, errors: dict[str, dict[str, Any]], *, f' """Operations under ``client.{_attr_path(child)}``."""', f" return {prefix}{child.class_name}Resource(self._client)\n", ] + for kind, summary in _WRAPPERS: + lines += [ + " @cached_property", + f" def {kind}(self) -> {prefix}{resource.class_name}Resource{_WRAPPER_SUFFIX[kind]}:", + f' """{summary}"""', + f" return {prefix}{resource.class_name}Resource{_WRAPPER_SUFFIX[kind]}(self)\n", + ] for operation in resource.operations: lines += _render_method(operation, errors, is_async=is_async) lines.append("") blocks.append("\n".join(lines).rstrip() + "\n") + for kind, _ in _WRAPPERS: + blocks.append(_wrapper_class(resource, kind, is_async=is_async)) return blocks +_WRAPPERS = ( + ( + "with_raw_response", + "Same methods, returning the raw HTTP response; call ``.parse()`` on it for the usual value.", + ), + ( + "with_streaming_response", + "Same methods, returning a context manager over the HTTP response without reading the body.", + ), +) +_WRAPPER_SUFFIX = {"with_raw_response": "WithRawResponse", "with_streaming_response": "WithStreamingResponse"} +_WRAPPER_FUNCTION = { + ("with_raw_response", False): "to_raw_response_wrapper", + ("with_streaming_response", False): "to_streamed_response_wrapper", + ("with_raw_response", True): "async_to_raw_response_wrapper", + ("with_streaming_response", True): "async_to_streamed_response_wrapper", +} + + +def _wrapper_class(resource: Resource, kind: str, *, is_async: bool) -> str: + prefix = "Async" if is_async else "" + suffix = _WRAPPER_SUFFIX[kind] + name = f"{prefix}{resource.class_name}Resource" + wrap = _WRAPPER_FUNCTION[(kind, is_async)] + lines = [ + f"class {name}{suffix}:", + f' """``client.{_attr_path(resource)}.{kind}``."""\n', + f" def __init__(self, resource: {name}) -> None:", + " self._resource = resource", + *[ + f" self.{operation.method_name} = {wrap}(resource.{operation.method_name})" + for operation in resource.operations + ], + "", + ] + for child_name, child in resource.children.items(): + lines += [ + " @cached_property", + f" def {child_name}(self) -> {prefix}{child.class_name}Resource{suffix}:", + f' """``client.{_attr_path(child)}.{kind}``."""', + f" return {prefix}{child.class_name}Resource{suffix}(self._resource.{child_name})\n", + ] + return "\n".join(lines).rstrip() + "\n" + + def _attr_path(resource: Resource) -> str: return ".".join(safe_identifier(snake(part)) for part in resource.path) @@ -478,6 +538,12 @@ def render_resource_module( *[f"from ..{module} import {', '.join(sorted({sync, async_}))}" for module, sync, async_ in _mixins(resource)], *([f"from .._qs import {', '.join(runtime)}"] if runtime else []), "from .._resource import AsyncAPIResource, SyncAPIResource", + "from .._response import (", + " async_to_raw_response_wrapper,", + " async_to_streamed_response_wrapper,", + " to_raw_response_wrapper,", + " to_streamed_response_wrapper,", + ")", *(["from .._streaming import AsyncStream, Stream"] if any(op.kind == "stream" for op in operations) else []), "from .._types import NOT_GIVEN, Body, Headers, NotGiven, Query, Timeout" + (", OpenEnum" if "OpenEnum" in uses else ""), diff --git a/docs/guides/async.md b/docs/guides/async.md index ef7c8bf..9466ed8 100644 --- a/docs/guides/async.md +++ b/docs/guides/async.md @@ -66,3 +66,24 @@ async with await client.event.subscribe() as events: # (3)! 1. `await` the paginator for the first page. 2. `async for` over it for every item across pages. 3. `subscribe()` returns an `AsyncStream` once awaited. + +## aiohttp transport + +For high-concurrency asyncio code you can swap httpx's networking for [aiohttp](https://docs.aiohttp.org). Install +the extra and pass `DefaultAioHttpClient` as `http_client`: + +```bash +pip install 'opencode-python-sdk[aiohttp]' +``` + +```python +from opencode import AsyncOpencode, DefaultAioHttpClient + + +async def main() -> None: + async with DefaultAioHttpClient() as http, AsyncOpencode("http://127.0.0.1:4096", http_client=http) as client: + info = await client.server.info() +``` + +Retries, timeouts and event streams work the same. aiohttp runs on asyncio only, not trio. The client does not close +an `http_client` you pass in, so close it yourself as above. diff --git a/docs/hooks/types_reference.py b/docs/hooks/types_reference.py index a577071..e77a272 100644 --- a/docs/hooks/types_reference.py +++ b/docs/hooks/types_reference.py @@ -121,7 +121,11 @@ def resources_page() -> str: if path.name.startswith("_"): continue tree = ast.parse(path.read_text()) - classes = [n.name for n in tree.body if isinstance(n, ast.ClassDef) and not n.name.startswith("Async")] + classes = [ + n.name + for n in tree.body + if isinstance(n, ast.ClassDef) and not n.name.startswith("Async") and n.name.endswith("Resource") + ] for cls in classes: lines += [f"::: opencode.resources.{path.stem}.{cls}", " options:", " show_bases: false", ""] return "\n".join(lines) diff --git a/docs/reference/clients.md b/docs/reference/clients.md index 91a9e82..3ddf89f 100644 --- a/docs/reference/clients.md +++ b/docs/reference/clients.md @@ -2,12 +2,17 @@ ::: opencode.Opencode options: - members: [with_options, close, wait_until_ready, fake] + members: [with_options, copy, close, wait_until_ready, fake, get, post, put, patch, delete] show_bases: false ::: opencode.AsyncOpencode options: - members: [with_options, close, wait_until_ready, fake] + members: [with_options, copy, close, wait_until_ready, fake, get, post, put, patch, delete] + show_bases: false + +::: opencode.DefaultAioHttpClient + options: + members: false show_bases: false ## Module constants diff --git a/docs/reference/index.md b/docs/reference/index.md index 83ca3b0..bbf20d7 100644 --- a/docs/reference/index.md +++ b/docs/reference/index.md @@ -8,7 +8,7 @@ Generated from the docstrings in `src/opencode`. | [Server launcher](server.md) | `OpencodeServer`, `AsyncOpencodeServer` | | [Background service](service.md) | `opencode.service`, `Endpoint`, `ServiceError` | | [Resources](resources.md) | Every `client.` and its methods | -| [Pagination and streams](pagination.md) | `SyncCursorPage`, `AsyncPaginator`, `Stream`, `AsyncStream` | +| [Pagination and streams](pagination.md) | `SyncCursorPage`, `AsyncPaginator`, `Stream`, `AsyncStream`, `APIResponse` | | [Shared events and RPC](events.md) | `EventHub`, `Subscription`, `RpcDefinition`, `RpcClient` | | [Exceptions](exceptions.md) | Status errors and every declared server error | | [Types](types/index.md) | The models in `opencode.types`, grouped by domain | diff --git a/docs/reference/pagination.md b/docs/reference/pagination.md index 4a83486..25c7a1d 100644 --- a/docs/reference/pagination.md +++ b/docs/reference/pagination.md @@ -9,3 +9,12 @@ ::: opencode.Stream ::: opencode.AsyncStream + +## Raw responses + +Returned by `with_raw_response` and `with_streaming_response` on every resource. See +[Accessing raw response data](https://github.com/shrijayan/opencode-python-sdk#accessing-raw-response-data). + +::: opencode.APIResponse + +::: opencode.AsyncAPIResponse diff --git a/pyproject.toml b/pyproject.toml index e37e3de..b6c2ad9 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -43,12 +43,16 @@ Changelog = "https://github.com/shrijayan/opencode-python-sdk/blob/main/CHANGELO pty = [ "websockets>=14,<17", ] +aiohttp = [ + "httpx-aiohttp>=0.1.9,<0.3", +] [dependency-groups] dev = [ "mypy>=1.18", "pyright>=1.1.408", "pytest>=8.4", + "httpx-aiohttp>=0.1.9", "pytest-cov>=7", "respx>=0.22", "ruff>=0.14", diff --git a/src/opencode/__init__.py b/src/opencode/__init__.py index ef6ef34..7c3b309 100644 --- a/src/opencode/__init__.py +++ b/src/opencode/__init__.py @@ -17,6 +17,7 @@ from typing import TYPE_CHECKING, Any from . import service +from ._aiohttp import DefaultAioHttpClient from ._client import AsyncOpencode, Opencode # @@ -75,9 +76,11 @@ ServiceUnavailableError, UnprocessableEntityError, ) +from ._logs import setup_logging as _setup_logging from ._models import BaseModel from ._pagination import AsyncCursorPage, AsyncPaginator, SyncCursorPage from ._pty import AsyncPtyConnection, PtyConnection, PtyConnectionError +from ._response import APIResponse, AsyncAPIResponse from ._server import AsyncOpencodeServer, OpencodeServer, ServerStartError from ._service import Endpoint, ServiceError from ._streaming import AsyncStream, Stream @@ -123,10 +126,12 @@ "API_VERSION", "NOT_GIVEN", "APIConnectionError", + "APIResponse", "APIError", "APIResponseValidationError", "APIStatusError", "APITimeoutError", + "AsyncAPIResponse", "AsyncCursorPage", "AsyncOpencode", "AsyncOpencodeServer", @@ -138,6 +143,7 @@ "BaseModel", "ConflictError", "ContentTooLargeError", + "DefaultAioHttpClient", "Endpoint", "InternalServerError", "NotFoundError", @@ -224,3 +230,6 @@ def __getattr__(name: str) -> Any: return importlib.import_module(".types", __name__) raise AttributeError(f"module {__name__!r} has no attribute {name!r}") + + +_setup_logging() diff --git a/src/opencode/_aiohttp.py b/src/opencode/_aiohttp.py new file mode 100644 index 0000000..476756b --- /dev/null +++ b/src/opencode/_aiohttp.py @@ -0,0 +1,44 @@ +"""Optional aiohttp-backed HTTP client for `AsyncOpencode`. + +Install the extra with ``pip install 'opencode-python-sdk[aiohttp]'`` and pass the client in:: + + async with AsyncOpencode(http_client=DefaultAioHttpClient()) as client: + ... + +The SDK still speaks httpx: ``httpx-aiohttp`` swaps the transport underneath, so retries, timeouts and event +streams behave the same. aiohttp only runs on asyncio, so this client does not work under trio. +""" + +from __future__ import annotations + +from typing import TYPE_CHECKING, Any + +import httpx + +from . import _constants as constants + +if TYPE_CHECKING: + _Base = httpx.AsyncClient +else: + try: + from httpx_aiohttp import HttpxAiohttpClient as _Base + except ImportError: # pragma: no cover - only without the extra + _Base = httpx.AsyncClient + + +class DefaultAioHttpClient(_Base): + """aiohttp-backed `httpx.AsyncClient` with the SDK's default connection limits and redirect handling. + + Pass it to `AsyncOpencode` as ``http_client``. Keyword arguments go to `httpx.AsyncClient`. The SDK does not + close a client it was given, so close it yourself (``async with`` it) when you are done. Creating one without + the ``aiohttp`` extra installed raises `RuntimeError`. + """ + + def __init__(self, **kwargs: Any) -> None: + if _Base is httpx.AsyncClient: + raise RuntimeError( + "DefaultAioHttpClient needs the aiohttp extra: pip install 'opencode-python-sdk[aiohttp]'" + ) + kwargs.setdefault("limits", constants.DEFAULT_CONNECTION_LIMITS) + kwargs.setdefault("follow_redirects", True) + super().__init__(**kwargs) diff --git a/src/opencode/_base_client.py b/src/opencode/_base_client.py index 4e998fc..2e81b9e 100644 --- a/src/opencode/_base_client.py +++ b/src/opencode/_base_client.py @@ -37,12 +37,13 @@ validation_summary, ) from ._qs import encode_query, to_jsonable +from ._response import APIResponse, AsyncAPIResponse, raw_mode from ._streaming import AsyncStream, Stream from ._types import NOT_GIVEN, Body, Headers, NotGiven, Query, Timeout from ._version import __version__ if TYPE_CHECKING: - from collections.abc import Mapping + from collections.abc import Callable, Coroutine, Mapping from types import TracebackType from ._pagination import AsyncPaginator, SyncCursorPage @@ -354,13 +355,13 @@ def __exit__( ) -> None: self.close() - def _send(self, options: RequestOptions) -> httpx.Response: + def _send(self, options: RequestOptions, *, stream_body: bool = False) -> httpx.Response: attempt = 0 while True: request = self._build_request(options) log.debug("Request %s %s (attempt %d)", request.method, request.url, attempt + 1) try: - response = self._http.send(request, stream=options.stream) + response = self._http.send(request, stream=options.stream or stream_body) except httpx.TransportError as exc: if attempt < self.max_retries and self._should_retry_error(options, exc): delay = self._retry_delay(attempt, None) @@ -384,7 +385,7 @@ def _send(self, options: RequestOptions) -> httpx.Response: time.sleep(delay) attempt += 1 continue - if options.stream: + if options.stream or stream_body: response.read() raise self._status_error(response, self._decode_error_body(response)) @@ -397,13 +398,23 @@ def request( unwrap: bool = False, ) -> Any: """Sends a request and returns the decoded response.""" + if raw_mode() is not None: + return self._raw(options, lambda response: self._parse(response, kind, response_type, unwrap)) response = self._send(options) return self._parse(response, kind, response_type, unwrap) + def _raw(self, options: RequestOptions, parser: Callable[[httpx.Response], Any]) -> APIResponse[Any]: + response = self._send(options, stream_body=raw_mode() == "stream") + return APIResponse(response, parser, event_stream=options.stream) + def stream(self, options: RequestOptions, *, item_type: type[_T] | Any) -> Stream[Any]: """Opens a server-sent event stream.""" options.stream = True - response = self._send(options) + if raw_mode() is not None: + return cast("Stream[Any]", self._raw(options, lambda response: self._open_stream(response, item_type))) + return self._open_stream(self._send(options), item_type) + + def _open_stream(self, response: httpx.Response, item_type: Any) -> Stream[Any]: content_type = response.headers.get("content-type", "") if content_type.split(";", 1)[0].strip().lower() != "text/event-stream": response.read() @@ -413,10 +424,109 @@ def stream(self, options: RequestOptions, *, item_type: type[_T] | Any) -> Strea ) return Stream(response, type_adapter(item_type)) + def get( + self, + path: str, + *, + cast_to: Any = object, + query: Query | None = None, + headers: Headers | None = None, + timeout: Timeout | NotGiven = NOT_GIVEN, + ) -> Any: + """Sends ``GET path`` (relative to ``base_url``) with the client's auth, retries and error mapping. + + For endpoints this client does not cover yet. The JSON response is validated against ``cast_to``. + """ + options = RequestOptions(method="GET", path=path, extra_query=query, extra_headers=headers, timeout=timeout) + return self.request(options, response_type=cast_to) + + def post( + self, + path: str, + *, + cast_to: Any = object, + body: object | NotGiven = NOT_GIVEN, + query: Query | None = None, + headers: Headers | None = None, + timeout: Timeout | NotGiven = NOT_GIVEN, + ) -> Any: + """Sends ``POST path`` (relative to ``base_url``) with the client's auth, retries and error mapping. + + For endpoints this client does not cover yet. The JSON response is validated against ``cast_to``. + """ + options = RequestOptions( + method="POST", path=path, body=body, extra_query=query, extra_headers=headers, timeout=timeout + ) + return self.request(options, response_type=cast_to) + + def put( + self, + path: str, + *, + cast_to: Any = object, + body: object | NotGiven = NOT_GIVEN, + query: Query | None = None, + headers: Headers | None = None, + timeout: Timeout | NotGiven = NOT_GIVEN, + ) -> Any: + """Sends ``PUT path`` (relative to ``base_url``) with the client's auth, retries and error mapping. + + For endpoints this client does not cover yet. The JSON response is validated against ``cast_to``. + """ + options = RequestOptions( + method="PUT", path=path, body=body, extra_query=query, extra_headers=headers, timeout=timeout + ) + return self.request(options, response_type=cast_to) + + def patch( + self, + path: str, + *, + cast_to: Any = object, + body: object | NotGiven = NOT_GIVEN, + query: Query | None = None, + headers: Headers | None = None, + timeout: Timeout | NotGiven = NOT_GIVEN, + ) -> Any: + """Sends ``PATCH path`` (relative to ``base_url``) with the client's auth, retries and error mapping. + + For endpoints this client does not cover yet. The JSON response is validated against ``cast_to``. + """ + options = RequestOptions( + method="PATCH", path=path, body=body, extra_query=query, extra_headers=headers, timeout=timeout + ) + return self.request(options, response_type=cast_to) + + def delete( + self, + path: str, + *, + cast_to: Any = object, + query: Query | None = None, + headers: Headers | None = None, + timeout: Timeout | NotGiven = NOT_GIVEN, + ) -> Any: + """Sends ``DELETE path`` (relative to ``base_url``) with the client's auth, retries and error mapping. + + For endpoints this client does not cover yet. The JSON response is validated against ``cast_to``. + """ + options = RequestOptions(method="DELETE", path=path, extra_query=query, extra_headers=headers, timeout=timeout) + return self.request(options, response_type=cast_to) + def page(self, options: RequestOptions, *, response_type: Any) -> SyncCursorPage[Any]: """Fetches the first page of a cursor-paginated list.""" from ._pagination import SyncCursorPage + if raw_mode() is not None: + return cast( + "SyncCursorPage[Any]", + self._raw( + options, + lambda response: SyncCursorPage.build( + self, options, response_type, self._parse(response, "json", response_type, False) + ), + ), + ) return SyncCursorPage.fetch(self, options, response_type) @@ -473,13 +583,13 @@ async def __aexit__( ) -> None: await self.close() - async def _send(self, options: RequestOptions) -> httpx.Response: + async def _send(self, options: RequestOptions, *, stream_body: bool = False) -> httpx.Response: attempt = 0 while True: request = self._build_request(options) log.debug("Request %s %s (attempt %d)", request.method, request.url, attempt + 1) try: - response = await self._http.send(request, stream=options.stream) + response = await self._http.send(request, stream=options.stream or stream_body) except httpx.TransportError as exc: if attempt < self.max_retries and self._should_retry_error(options, exc): delay = self._retry_delay(attempt, None) @@ -503,7 +613,7 @@ async def _send(self, options: RequestOptions) -> httpx.Response: await anyio.sleep(delay) attempt += 1 continue - if options.stream: + if options.stream or stream_body: await response.aread() raise self._status_error(response, self._decode_error_body(response)) @@ -516,13 +626,31 @@ async def request( unwrap: bool = False, ) -> Any: """Sends a request and returns the decoded response.""" + if raw_mode() is not None: + return await self._raw(options, lambda response: self._parse(response, kind, response_type, unwrap)) response = await self._send(options) return self._parse(response, kind, response_type, unwrap) + async def _raw(self, options: RequestOptions, parser: Callable[[httpx.Response], Any]) -> AsyncAPIResponse[Any]: + response = await self._send(options, stream_body=raw_mode() == "stream") + return AsyncAPIResponse(response, parser, event_stream=options.stream) + async def stream(self, options: RequestOptions, *, item_type: type[_T] | Any) -> AsyncStream[Any]: """Opens a server-sent event stream.""" options.stream = True - response = await self._send(options) + if raw_mode() is not None: + raw = await self._raw(options, lambda response: self._open_stream(response, item_type)) + return cast("AsyncStream[Any]", raw) + return await self._open_async_stream(await self._send(options), item_type) + + @staticmethod + def _open_stream(response: httpx.Response, item_type: Any) -> AsyncStream[Any]: + content_type = response.headers.get("content-type", "") + if content_type.split(";", 1)[0].strip().lower() != "text/event-stream": + raise APIResponseValidationError(response, None, message=f"Expected an event stream, got {content_type!r}") + return AsyncStream(response, type_adapter(item_type)) + + async def _open_async_stream(self, response: httpx.Response, item_type: Any) -> AsyncStream[Any]: content_type = response.headers.get("content-type", "") if content_type.split(";", 1)[0].strip().lower() != "text/event-stream": await response.aread() @@ -532,8 +660,106 @@ async def stream(self, options: RequestOptions, *, item_type: type[_T] | Any) -> ) return AsyncStream(response, type_adapter(item_type)) + async def get( + self, + path: str, + *, + cast_to: Any = object, + query: Query | None = None, + headers: Headers | None = None, + timeout: Timeout | NotGiven = NOT_GIVEN, + ) -> Any: + """Sends ``GET path`` (relative to ``base_url``) with the client's auth, retries and error mapping. + + For endpoints this client does not cover yet. The JSON response is validated against ``cast_to``. + """ + options = RequestOptions(method="GET", path=path, extra_query=query, extra_headers=headers, timeout=timeout) + return await self.request(options, response_type=cast_to) + + async def post( + self, + path: str, + *, + cast_to: Any = object, + body: object | NotGiven = NOT_GIVEN, + query: Query | None = None, + headers: Headers | None = None, + timeout: Timeout | NotGiven = NOT_GIVEN, + ) -> Any: + """Sends ``POST path`` (relative to ``base_url``) with the client's auth, retries and error mapping. + + For endpoints this client does not cover yet. The JSON response is validated against ``cast_to``. + """ + options = RequestOptions( + method="POST", path=path, body=body, extra_query=query, extra_headers=headers, timeout=timeout + ) + return await self.request(options, response_type=cast_to) + + async def put( + self, + path: str, + *, + cast_to: Any = object, + body: object | NotGiven = NOT_GIVEN, + query: Query | None = None, + headers: Headers | None = None, + timeout: Timeout | NotGiven = NOT_GIVEN, + ) -> Any: + """Sends ``PUT path`` (relative to ``base_url``) with the client's auth, retries and error mapping. + + For endpoints this client does not cover yet. The JSON response is validated against ``cast_to``. + """ + options = RequestOptions( + method="PUT", path=path, body=body, extra_query=query, extra_headers=headers, timeout=timeout + ) + return await self.request(options, response_type=cast_to) + + async def patch( + self, + path: str, + *, + cast_to: Any = object, + body: object | NotGiven = NOT_GIVEN, + query: Query | None = None, + headers: Headers | None = None, + timeout: Timeout | NotGiven = NOT_GIVEN, + ) -> Any: + """Sends ``PATCH path`` (relative to ``base_url``) with the client's auth, retries and error mapping. + + For endpoints this client does not cover yet. The JSON response is validated against ``cast_to``. + """ + options = RequestOptions( + method="PATCH", path=path, body=body, extra_query=query, extra_headers=headers, timeout=timeout + ) + return await self.request(options, response_type=cast_to) + + async def delete( + self, + path: str, + *, + cast_to: Any = object, + query: Query | None = None, + headers: Headers | None = None, + timeout: Timeout | NotGiven = NOT_GIVEN, + ) -> Any: + """Sends ``DELETE path`` (relative to ``base_url``) with the client's auth, retries and error mapping. + + For endpoints this client does not cover yet. The JSON response is validated against ``cast_to``. + """ + options = RequestOptions(method="DELETE", path=path, extra_query=query, extra_headers=headers, timeout=timeout) + return await self.request(options, response_type=cast_to) + def page(self, options: RequestOptions, *, response_type: Any) -> AsyncPaginator[Any]: """Returns an awaitable, async-iterable paginator over a cursor-paginated list.""" - from ._pagination import AsyncPaginator - + from ._pagination import AsyncCursorPage, AsyncPaginator + + if raw_mode() is not None: + # Awaited by the raw-response wrapper: the raw form of a list call is the first page's response. + raw: Coroutine[Any, Any, AsyncAPIResponse[Any]] = self._raw( + options, + lambda response: AsyncCursorPage.build( + self, options, response_type, self._parse(response, "json", response_type, False) + ), + ) + return cast("AsyncPaginator[Any]", raw) return AsyncPaginator(self, options, response_type) diff --git a/src/opencode/_client.py b/src/opencode/_client.py index a419dd7..655ad80 100644 --- a/src/opencode/_client.py +++ b/src/opencode/_client.py @@ -202,7 +202,8 @@ def with_options( ) -> Self: """Returns a client with some options changed. It shares this client's connection pool. - ``default_headers`` and ``default_query`` are merged over the current values. + ``default_headers`` and ``default_query`` are merged over the current values. Closing the copy leaves the + pool open; it closes with this client. Also available as ``copy``. """ client = type(self)( base_url=base_url or self.base_url, @@ -217,6 +218,8 @@ def with_options( ) return client + copy = with_options + class AsyncOpencode(AsyncAPIClient, AsyncResources): """Asynchronous client for an OpenCode server. Works with asyncio and trio. @@ -345,7 +348,8 @@ def with_options( ) -> Self: """Returns a client with some options changed. It shares this client's connection pool. - ``default_headers`` and ``default_query`` are merged over the current values. + ``default_headers`` and ``default_query`` are merged over the current values. Closing the copy leaves the + pool open; it closes with this client. Also available as ``copy``. """ client = type(self)( base_url=base_url or self.base_url, @@ -359,3 +363,5 @@ def with_options( http_client=self._http, ) return client + + copy = with_options diff --git a/src/opencode/_logs.py b/src/opencode/_logs.py new file mode 100644 index 0000000..687de12 --- /dev/null +++ b/src/opencode/_logs.py @@ -0,0 +1,29 @@ +"""``OPENCODE_LOG`` support: configure the ``opencode`` logger from the environment.""" + +from __future__ import annotations + +import logging +import os + +logger = logging.getLogger("opencode") + +_LEVELS = {"debug": logging.DEBUG, "info": logging.INFO} + + +def setup_logging() -> None: + """Attach a stderr handler to the ``opencode`` logger when ``OPENCODE_LOG`` is ``debug`` or ``info``. + + Does nothing when the variable is unset or has any other value. The OpenCode CLI reads + ``OPENCODE_LOG_LEVEL``, not ``OPENCODE_LOG``, so the two do not clash. + """ + level = _LEVELS.get(os.environ.get("OPENCODE_LOG", "").strip().lower()) + if level is None: + return + if not any(getattr(h, "_opencode_env", False) for h in logger.handlers): + handler = logging.StreamHandler() + handler.setFormatter( + logging.Formatter("[%(asctime)s - %(name)s:%(lineno)d - %(levelname)s] %(message)s", "%Y-%m-%d %H:%M:%S") + ) + handler._opencode_env = True # type: ignore[attr-defined] + logger.addHandler(handler) + logger.setLevel(level) diff --git a/src/opencode/_pagination.py b/src/opencode/_pagination.py index 5bc08fb..484cfbe 100644 --- a/src/opencode/_pagination.py +++ b/src/opencode/_pagination.py @@ -79,6 +79,13 @@ def __init__( @classmethod def fetch(cls, client: SyncAPIClient, options: RequestOptions, response_type: Any) -> SyncCursorPage[Any]: payload = client.request(options, response_type=response_type) + return cls.build(client, options, response_type, payload) + + @classmethod + def build( + cls, client: SyncAPIClient, options: RequestOptions, response_type: Any, payload: Any + ) -> SyncCursorPage[Any]: + """Builds a page from an already parsed response.""" data, next_cursor, previous_cursor = _page_parts(payload) return cls( client=client, @@ -134,6 +141,13 @@ def __init__( @classmethod async def fetch(cls, client: AsyncAPIClient, options: RequestOptions, response_type: Any) -> AsyncCursorPage[Any]: payload = await client.request(options, response_type=response_type) + return cls.build(client, options, response_type, payload) + + @classmethod + def build( + cls, client: AsyncAPIClient, options: RequestOptions, response_type: Any, payload: Any + ) -> AsyncCursorPage[Any]: + """Builds a page from an already parsed response.""" data, next_cursor, previous_cursor = _page_parts(payload) return cls( client=client, diff --git a/src/opencode/_response.py b/src/opencode/_response.py new file mode 100644 index 0000000..df07601 --- /dev/null +++ b/src/opencode/_response.py @@ -0,0 +1,316 @@ +"""Raw HTTP response access for generated methods. + +``client.session.with_raw_response.get(...)`` calls the same method, but returns an :class:`APIResponse` with the +status, headers and request instead of the parsed value; :meth:`APIResponse.parse` gives the value the plain call +would have returned. ``with_streaming_response`` does the same without reading the body, inside a context manager:: + + with client.file.with_streaming_response.content(...) as response: + for chunk in response.iter_bytes(): + ... + +The generated methods are unchanged: a context variable tells the transport to hand back the response instead of +parsing it. +""" + +from __future__ import annotations + +import contextvars +import functools +import json +from typing import TYPE_CHECKING, Any, Generic, Literal, TypeVar, cast, overload + +from typing_extensions import ParamSpec, override + +if TYPE_CHECKING: + from collections.abc import AsyncIterator, Awaitable, Callable, Iterator + from types import TracebackType + + import httpx + + from ._pagination import AsyncCursorPage, AsyncPaginator + +__all__ = [ + "APIResponse", + "AsyncAPIResponse", + "AsyncResponseContextManager", + "ResponseContextManager", +] + +_P = ParamSpec("_P") +_R = TypeVar("_R") +_T = TypeVar("_T") + +RawMode = Literal["raw", "stream"] + +_raw_mode: contextvars.ContextVar[RawMode | None] = contextvars.ContextVar("opencode_raw_mode", default=None) + + +def raw_mode() -> RawMode | None: + """The raw-response mode of the current call, or ``None`` for a normal call.""" + return _raw_mode.get() + + +class _BaseAPIResponse(Generic[_R]): + http_response: httpx.Response + """The underlying ``httpx.Response``.""" + + def __init__( + self, response: httpx.Response, parser: Callable[[httpx.Response], Any], *, event_stream: bool + ) -> None: + self.http_response = response + self._parser = parser + self._event_stream = event_stream + self._parsed: Any = _UNSET + + @property + def headers(self) -> httpx.Headers: + """Response headers.""" + return self.http_response.headers + + @property + def status_code(self) -> int: + """HTTP status code.""" + return self.http_response.status_code + + @property + def request(self) -> httpx.Request: + """The request that was sent (the last attempt, when it was retried).""" + return self.http_response.request + + @property + def url(self) -> httpx.URL: + """The request URL.""" + return self.http_response.url + + @property + def method(self) -> str: + """The request method.""" + return self.http_response.request.method + + @property + def elapsed(self) -> Any: + """Time from sending the request to receiving the response headers.""" + return self.http_response.elapsed + + @property + def is_closed(self) -> bool: + """Whether the connection has been released.""" + return self.http_response.is_closed + + @override + def __repr__(self) -> str: + return f"<{type(self).__name__} [{self.status_code} {self.http_response.reason_phrase}]>" + + +class _Unset: + pass + + +_UNSET = _Unset() + + +class APIResponse(_BaseAPIResponse[_R]): + """An HTTP response from a sync ``with_raw_response`` / ``with_streaming_response`` call.""" + + def parse(self) -> _R: + """Returns the value the plain method call would have returned, reading the body first if needed. + + For event-stream endpoints this is the :class:`~opencode.Stream`, which consumes the body as you iterate. + """ + if isinstance(self._parsed, _Unset): + if not self._event_stream: + self.read() + self._parsed = self._parser(self.http_response) + return cast("_R", self._parsed) + + def read(self) -> bytes: + """Reads and returns the whole body.""" + return self.http_response.read() + + @property + def content(self) -> bytes: + """The whole body, read on first access.""" + return self.read() + + @property + def text(self) -> str: + """The body decoded as text.""" + self.read() + return self.http_response.text + + def json(self) -> Any: + """The body decoded as JSON.""" + return json.loads(self.read()) + + def iter_bytes(self, chunk_size: int | None = None) -> Iterator[bytes]: + """Iterates over the body in byte chunks, decoding any content encoding.""" + yield from self.http_response.iter_bytes(chunk_size) + + def iter_text(self, chunk_size: int | None = None) -> Iterator[str]: + """Iterates over the body as decoded text chunks.""" + yield from self.http_response.iter_text(chunk_size) + + def iter_lines(self) -> Iterator[str]: + """Iterates over the body line by line.""" + yield from self.http_response.iter_lines() + + def close(self) -> None: + """Releases the connection without reading the rest of the body.""" + self.http_response.close() + + +class AsyncAPIResponse(_BaseAPIResponse[_R]): + """An HTTP response from an async ``with_raw_response`` / ``with_streaming_response`` call.""" + + async def parse(self) -> _R: + """Returns the value the plain method call would have returned, reading the body first if needed. + + For event-stream endpoints this is the :class:`~opencode.AsyncStream`, which consumes the body as you + iterate. + """ + if isinstance(self._parsed, _Unset): + if not self._event_stream: + await self.read() + self._parsed = self._parser(self.http_response) + return cast("_R", self._parsed) + + async def read(self) -> bytes: + """Reads and returns the whole body.""" + return await self.http_response.aread() + + async def text(self) -> str: + """The body decoded as text.""" + await self.read() + return self.http_response.text + + async def json(self) -> Any: + """The body decoded as JSON.""" + return json.loads(await self.read()) + + async def iter_bytes(self, chunk_size: int | None = None) -> AsyncIterator[bytes]: + """Iterates over the body in byte chunks, decoding any content encoding.""" + async for chunk in self.http_response.aiter_bytes(chunk_size): + yield chunk + + async def iter_text(self, chunk_size: int | None = None) -> AsyncIterator[str]: + """Iterates over the body as decoded text chunks.""" + async for chunk in self.http_response.aiter_text(chunk_size): + yield chunk + + async def iter_lines(self) -> AsyncIterator[str]: + """Iterates over the body line by line.""" + async for line in self.http_response.aiter_lines(): + yield line + + async def close(self) -> None: + """Releases the connection without reading the rest of the body.""" + await self.http_response.aclose() + + +class ResponseContextManager(Generic[_R]): + """Sends the request on ``__enter__`` and closes the response on ``__exit__``.""" + + def __init__(self, send: Callable[[], APIResponse[_R]]) -> None: + self._send = send + self._response: APIResponse[_R] | None = None + + def __enter__(self) -> APIResponse[_R]: + self._response = self._send() + return self._response + + def __exit__( + self, exc_type: type[BaseException] | None, exc: BaseException | None, tb: TracebackType | None + ) -> None: + if self._response is not None: + self._response.close() + + +class AsyncResponseContextManager(Generic[_R]): + """Sends the request on ``__aenter__`` and closes the response on ``__aexit__``.""" + + def __init__(self, send: Callable[[], Awaitable[AsyncAPIResponse[_R]]]) -> None: + self._send = send + self._response: AsyncAPIResponse[_R] | None = None + + async def __aenter__(self) -> AsyncAPIResponse[_R]: + self._response = await self._send() + return self._response + + async def __aexit__( + self, exc_type: type[BaseException] | None, exc: BaseException | None, tb: TracebackType | None + ) -> None: + if self._response is not None: + await self._response.close() + + +def _call_sync(mode: RawMode, func: Callable[..., Any], args: Any, kwargs: Any) -> Any: + token = _raw_mode.set(mode) + try: + return func(*args, **kwargs) + finally: + _raw_mode.reset(token) + + +async def _call_async(mode: RawMode, func: Callable[..., Any], args: Any, kwargs: Any) -> Any: + token = _raw_mode.set(mode) + try: + # Async list methods are plain functions; in raw mode they return a coroutine for the first page. + return await func(*args, **kwargs) + finally: + _raw_mode.reset(token) + + +def to_raw_response_wrapper(func: Callable[_P, _R]) -> Callable[_P, APIResponse[_R]]: + """Wraps a sync generated method so it returns an :class:`APIResponse`.""" + + @functools.wraps(func) + def wrapped(*args: _P.args, **kwargs: _P.kwargs) -> APIResponse[_R]: + return cast("APIResponse[_R]", _call_sync("raw", func, args, kwargs)) + + return wrapped + + +def to_streamed_response_wrapper(func: Callable[_P, _R]) -> Callable[_P, ResponseContextManager[_R]]: + """Wraps a sync generated method so it returns a context manager over an unread :class:`APIResponse`.""" + + @functools.wraps(func) + def wrapped(*args: _P.args, **kwargs: _P.kwargs) -> ResponseContextManager[_R]: + return ResponseContextManager(lambda: cast("APIResponse[_R]", _call_sync("stream", func, args, kwargs))) + + return wrapped + + +@overload +def async_to_raw_response_wrapper( + func: Callable[_P, AsyncPaginator[_T]], +) -> Callable[_P, Awaitable[AsyncAPIResponse[AsyncCursorPage[_T]]]]: ... +@overload +def async_to_raw_response_wrapper( + func: Callable[_P, Awaitable[_R]], +) -> Callable[_P, Awaitable[AsyncAPIResponse[_R]]]: ... +def async_to_raw_response_wrapper(func: Callable[_P, Any]) -> Callable[_P, Awaitable[AsyncAPIResponse[Any]]]: + """Wraps an async generated method so it returns an :class:`AsyncAPIResponse`.""" + + @functools.wraps(func) + async def wrapped(*args: _P.args, **kwargs: _P.kwargs) -> AsyncAPIResponse[Any]: + return cast("AsyncAPIResponse[Any]", await _call_async("raw", func, args, kwargs)) + + return wrapped + + +@overload +def async_to_streamed_response_wrapper( + func: Callable[_P, AsyncPaginator[_T]], +) -> Callable[_P, AsyncResponseContextManager[AsyncCursorPage[_T]]]: ... +@overload +def async_to_streamed_response_wrapper( + func: Callable[_P, Awaitable[_R]], +) -> Callable[_P, AsyncResponseContextManager[_R]]: ... +def async_to_streamed_response_wrapper(func: Callable[_P, Any]) -> Callable[_P, AsyncResponseContextManager[Any]]: + """Wraps an async generated method so it returns an async context manager over an unread response.""" + + @functools.wraps(func) + def wrapped(*args: _P.args, **kwargs: _P.kwargs) -> AsyncResponseContextManager[Any]: + return AsyncResponseContextManager(lambda: _call_async("stream", func, args, kwargs)) + + return wrapped diff --git a/src/opencode/resources/agent.py b/src/opencode/resources/agent.py index 7399dcf..65193de 100644 --- a/src/opencode/resources/agent.py +++ b/src/opencode/resources/agent.py @@ -5,11 +5,18 @@ from __future__ import annotations +from functools import cached_property from typing import TYPE_CHECKING, cast from .._base_client import RequestOptions from .._qs import encode_path_segment from .._resource import AsyncAPIResource, SyncAPIResource +from .._response import ( + async_to_raw_response_wrapper, + async_to_streamed_response_wrapper, + to_raw_response_wrapper, + to_streamed_response_wrapper, +) from .._types import NOT_GIVEN, Body, Headers, NotGiven, Query, Timeout if TYPE_CHECKING: @@ -26,6 +33,16 @@ class AgentResource(SyncAPIResource): """Operations under ``client.agent`` (OpenCode ``agent``).""" + @cached_property + def with_raw_response(self) -> AgentResourceWithRawResponse: + """Same methods, returning the raw HTTP response; call ``.parse()`` on it for the usual value.""" + return AgentResourceWithRawResponse(self) + + @cached_property + def with_streaming_response(self) -> AgentResourceWithStreamingResponse: + """Same methods, returning a context manager over the HTTP response without reading the body.""" + return AgentResourceWithStreamingResponse(self) + def list( self, *, @@ -101,9 +118,37 @@ def get( ) +class AgentResourceWithRawResponse: + """``client.agent.with_raw_response``.""" + + def __init__(self, resource: AgentResource) -> None: + self._resource = resource + self.list = to_raw_response_wrapper(resource.list) + self.get = to_raw_response_wrapper(resource.get) + + +class AgentResourceWithStreamingResponse: + """``client.agent.with_streaming_response``.""" + + def __init__(self, resource: AgentResource) -> None: + self._resource = resource + self.list = to_streamed_response_wrapper(resource.list) + self.get = to_streamed_response_wrapper(resource.get) + + class AsyncAgentResource(AsyncAPIResource): """Operations under ``client.agent`` (OpenCode ``agent``).""" + @cached_property + def with_raw_response(self) -> AsyncAgentResourceWithRawResponse: + """Same methods, returning the raw HTTP response; call ``.parse()`` on it for the usual value.""" + return AsyncAgentResourceWithRawResponse(self) + + @cached_property + def with_streaming_response(self) -> AsyncAgentResourceWithStreamingResponse: + """Same methods, returning a context manager over the HTTP response without reading the body.""" + return AsyncAgentResourceWithStreamingResponse(self) + async def list( self, *, @@ -177,3 +222,21 @@ async def get( response_type="AgentGetResponse", ), ) + + +class AsyncAgentResourceWithRawResponse: + """``client.agent.with_raw_response``.""" + + def __init__(self, resource: AsyncAgentResource) -> None: + self._resource = resource + self.list = async_to_raw_response_wrapper(resource.list) + self.get = async_to_raw_response_wrapper(resource.get) + + +class AsyncAgentResourceWithStreamingResponse: + """``client.agent.with_streaming_response``.""" + + def __init__(self, resource: AsyncAgentResource) -> None: + self._resource = resource + self.list = async_to_streamed_response_wrapper(resource.list) + self.get = async_to_streamed_response_wrapper(resource.get) diff --git a/src/opencode/resources/command.py b/src/opencode/resources/command.py index c653b65..720ab18 100644 --- a/src/opencode/resources/command.py +++ b/src/opencode/resources/command.py @@ -5,10 +5,17 @@ from __future__ import annotations +from functools import cached_property from typing import TYPE_CHECKING, cast from .._base_client import RequestOptions from .._resource import AsyncAPIResource, SyncAPIResource +from .._response import ( + async_to_raw_response_wrapper, + async_to_streamed_response_wrapper, + to_raw_response_wrapper, + to_streamed_response_wrapper, +) from .._types import NOT_GIVEN, Body, Headers, NotGiven, Query, Timeout if TYPE_CHECKING: @@ -23,6 +30,16 @@ class CommandResource(SyncAPIResource): """Operations under ``client.command`` (OpenCode ``command``).""" + @cached_property + def with_raw_response(self) -> CommandResourceWithRawResponse: + """Same methods, returning the raw HTTP response; call ``.parse()`` on it for the usual value.""" + return CommandResourceWithRawResponse(self) + + @cached_property + def with_streaming_response(self) -> CommandResourceWithStreamingResponse: + """Same methods, returning a context manager over the HTTP response without reading the body.""" + return CommandResourceWithStreamingResponse(self) + def list( self, *, @@ -60,9 +77,35 @@ def list( ) +class CommandResourceWithRawResponse: + """``client.command.with_raw_response``.""" + + def __init__(self, resource: CommandResource) -> None: + self._resource = resource + self.list = to_raw_response_wrapper(resource.list) + + +class CommandResourceWithStreamingResponse: + """``client.command.with_streaming_response``.""" + + def __init__(self, resource: CommandResource) -> None: + self._resource = resource + self.list = to_streamed_response_wrapper(resource.list) + + class AsyncCommandResource(AsyncAPIResource): """Operations under ``client.command`` (OpenCode ``command``).""" + @cached_property + def with_raw_response(self) -> AsyncCommandResourceWithRawResponse: + """Same methods, returning the raw HTTP response; call ``.parse()`` on it for the usual value.""" + return AsyncCommandResourceWithRawResponse(self) + + @cached_property + def with_streaming_response(self) -> AsyncCommandResourceWithStreamingResponse: + """Same methods, returning a context manager over the HTTP response without reading the body.""" + return AsyncCommandResourceWithStreamingResponse(self) + async def list( self, *, @@ -98,3 +141,19 @@ async def list( response_type="CommandListResponse", ), ) + + +class AsyncCommandResourceWithRawResponse: + """``client.command.with_raw_response``.""" + + def __init__(self, resource: AsyncCommandResource) -> None: + self._resource = resource + self.list = async_to_raw_response_wrapper(resource.list) + + +class AsyncCommandResourceWithStreamingResponse: + """``client.command.with_streaming_response``.""" + + def __init__(self, resource: AsyncCommandResource) -> None: + self._resource = resource + self.list = async_to_streamed_response_wrapper(resource.list) diff --git a/src/opencode/resources/config.py b/src/opencode/resources/config.py index 751c4e0..ecc24d3 100644 --- a/src/opencode/resources/config.py +++ b/src/opencode/resources/config.py @@ -6,10 +6,17 @@ from __future__ import annotations import builtins +from functools import cached_property from typing import TYPE_CHECKING, cast from .._base_client import RequestOptions from .._resource import AsyncAPIResource, SyncAPIResource +from .._response import ( + async_to_raw_response_wrapper, + async_to_streamed_response_wrapper, + to_raw_response_wrapper, + to_streamed_response_wrapper, +) from .._types import NOT_GIVEN, Body, Headers, NotGiven, Query, Timeout if TYPE_CHECKING: @@ -25,6 +32,16 @@ class ConfigResource(SyncAPIResource): """Operations under ``client.config`` (OpenCode ``config``).""" + @cached_property + def with_raw_response(self) -> ConfigResourceWithRawResponse: + """Same methods, returning the raw HTTP response; call ``.parse()`` on it for the usual value.""" + return ConfigResourceWithRawResponse(self) + + @cached_property + def with_streaming_response(self) -> ConfigResourceWithStreamingResponse: + """Same methods, returning a context manager over the HTTP response without reading the body.""" + return ConfigResourceWithStreamingResponse(self) + def get( self, *, @@ -117,23 +134,56 @@ def update( ``PATCH /api/experimental/config`` """ - self._client.request( - RequestOptions( - method="PATCH", - path="/api/experimental/config", - body={"shell": shell}, - extra_headers=extra_headers, - extra_query=extra_query, - extra_body=extra_body, - timeout=timeout, + return cast( + "None", + self._client.request( + RequestOptions( + method="PATCH", + path="/api/experimental/config", + body={"shell": shell}, + extra_headers=extra_headers, + extra_query=extra_query, + extra_body=extra_body, + timeout=timeout, + ), + kind="void", ), - kind="void", ) +class ConfigResourceWithRawResponse: + """``client.config.with_raw_response``.""" + + def __init__(self, resource: ConfigResource) -> None: + self._resource = resource + self.get = to_raw_response_wrapper(resource.get) + self.shells = to_raw_response_wrapper(resource.shells) + self.update = to_raw_response_wrapper(resource.update) + + +class ConfigResourceWithStreamingResponse: + """``client.config.with_streaming_response``.""" + + def __init__(self, resource: ConfigResource) -> None: + self._resource = resource + self.get = to_streamed_response_wrapper(resource.get) + self.shells = to_streamed_response_wrapper(resource.shells) + self.update = to_streamed_response_wrapper(resource.update) + + class AsyncConfigResource(AsyncAPIResource): """Operations under ``client.config`` (OpenCode ``config``).""" + @cached_property + def with_raw_response(self) -> AsyncConfigResourceWithRawResponse: + """Same methods, returning the raw HTTP response; call ``.parse()`` on it for the usual value.""" + return AsyncConfigResourceWithRawResponse(self) + + @cached_property + def with_streaming_response(self) -> AsyncConfigResourceWithStreamingResponse: + """Same methods, returning a context manager over the HTTP response without reading the body.""" + return AsyncConfigResourceWithStreamingResponse(self) + async def get( self, *, @@ -226,15 +276,38 @@ async def update( ``PATCH /api/experimental/config`` """ - await self._client.request( - RequestOptions( - method="PATCH", - path="/api/experimental/config", - body={"shell": shell}, - extra_headers=extra_headers, - extra_query=extra_query, - extra_body=extra_body, - timeout=timeout, + return cast( + "None", + await self._client.request( + RequestOptions( + method="PATCH", + path="/api/experimental/config", + body={"shell": shell}, + extra_headers=extra_headers, + extra_query=extra_query, + extra_body=extra_body, + timeout=timeout, + ), + kind="void", ), - kind="void", ) + + +class AsyncConfigResourceWithRawResponse: + """``client.config.with_raw_response``.""" + + def __init__(self, resource: AsyncConfigResource) -> None: + self._resource = resource + self.get = async_to_raw_response_wrapper(resource.get) + self.shells = async_to_raw_response_wrapper(resource.shells) + self.update = async_to_raw_response_wrapper(resource.update) + + +class AsyncConfigResourceWithStreamingResponse: + """``client.config.with_streaming_response``.""" + + def __init__(self, resource: AsyncConfigResource) -> None: + self._resource = resource + self.get = async_to_streamed_response_wrapper(resource.get) + self.shells = async_to_streamed_response_wrapper(resource.shells) + self.update = async_to_streamed_response_wrapper(resource.update) diff --git a/src/opencode/resources/credential.py b/src/opencode/resources/credential.py index f7468d8..75a4739 100644 --- a/src/opencode/resources/credential.py +++ b/src/opencode/resources/credential.py @@ -6,11 +6,18 @@ from __future__ import annotations import builtins +from functools import cached_property from typing import TYPE_CHECKING, cast from .._base_client import RequestOptions from .._qs import encode_path_segment from .._resource import AsyncAPIResource, SyncAPIResource +from .._response import ( + async_to_raw_response_wrapper, + async_to_streamed_response_wrapper, + to_raw_response_wrapper, + to_streamed_response_wrapper, +) from .._types import NOT_GIVEN, Body, Headers, NotGiven, Query, Timeout if TYPE_CHECKING: @@ -27,6 +34,16 @@ class CredentialResource(SyncAPIResource): """Operations under ``client.credential`` (OpenCode ``credential``).""" + @cached_property + def with_raw_response(self) -> CredentialResourceWithRawResponse: + """Same methods, returning the raw HTTP response; call ``.parse()`` on it for the usual value.""" + return CredentialResourceWithRawResponse(self) + + @cached_property + def with_streaming_response(self) -> CredentialResourceWithStreamingResponse: + """Same methods, returning a context manager over the HTTP response without reading the body.""" + return CredentialResourceWithStreamingResponse(self) + def list( self, *, @@ -128,17 +145,20 @@ def update( ``PATCH /api/credential/:credentialID`` """ - self._client.request( - RequestOptions( - method="PATCH", - path=f"/api/credential/{encode_path_segment(credential_id)}", - body={"label": label}, - extra_headers=extra_headers, - extra_query=extra_query, - extra_body=extra_body, - timeout=timeout, + return cast( + "None", + self._client.request( + RequestOptions( + method="PATCH", + path=f"/api/credential/{encode_path_segment(credential_id)}", + body={"label": label}, + extra_headers=extra_headers, + extra_query=extra_query, + extra_body=extra_body, + timeout=timeout, + ), + kind="void", ), - kind="void", ) def activate( @@ -160,16 +180,19 @@ def activate( ``POST /api/credential/:credentialID/activate`` """ - self._client.request( - RequestOptions( - method="POST", - path=f"/api/credential/{encode_path_segment(credential_id)}/activate", - extra_headers=extra_headers, - extra_query=extra_query, - extra_body=extra_body, - timeout=timeout, + return cast( + "None", + self._client.request( + RequestOptions( + method="POST", + path=f"/api/credential/{encode_path_segment(credential_id)}/activate", + extra_headers=extra_headers, + extra_query=extra_query, + extra_body=extra_body, + timeout=timeout, + ), + kind="void", ), - kind="void", ) def remove( @@ -191,22 +214,59 @@ def remove( ``DELETE /api/credential/:credentialID`` """ - self._client.request( - RequestOptions( - method="DELETE", - path=f"/api/credential/{encode_path_segment(credential_id)}", - extra_headers=extra_headers, - extra_query=extra_query, - extra_body=extra_body, - timeout=timeout, + return cast( + "None", + self._client.request( + RequestOptions( + method="DELETE", + path=f"/api/credential/{encode_path_segment(credential_id)}", + extra_headers=extra_headers, + extra_query=extra_query, + extra_body=extra_body, + timeout=timeout, + ), + kind="void", ), - kind="void", ) +class CredentialResourceWithRawResponse: + """``client.credential.with_raw_response``.""" + + def __init__(self, resource: CredentialResource) -> None: + self._resource = resource + self.list = to_raw_response_wrapper(resource.list) + self.create = to_raw_response_wrapper(resource.create) + self.update = to_raw_response_wrapper(resource.update) + self.activate = to_raw_response_wrapper(resource.activate) + self.remove = to_raw_response_wrapper(resource.remove) + + +class CredentialResourceWithStreamingResponse: + """``client.credential.with_streaming_response``.""" + + def __init__(self, resource: CredentialResource) -> None: + self._resource = resource + self.list = to_streamed_response_wrapper(resource.list) + self.create = to_streamed_response_wrapper(resource.create) + self.update = to_streamed_response_wrapper(resource.update) + self.activate = to_streamed_response_wrapper(resource.activate) + self.remove = to_streamed_response_wrapper(resource.remove) + + class AsyncCredentialResource(AsyncAPIResource): """Operations under ``client.credential`` (OpenCode ``credential``).""" + @cached_property + def with_raw_response(self) -> AsyncCredentialResourceWithRawResponse: + """Same methods, returning the raw HTTP response; call ``.parse()`` on it for the usual value.""" + return AsyncCredentialResourceWithRawResponse(self) + + @cached_property + def with_streaming_response(self) -> AsyncCredentialResourceWithStreamingResponse: + """Same methods, returning a context manager over the HTTP response without reading the body.""" + return AsyncCredentialResourceWithStreamingResponse(self) + async def list( self, *, @@ -308,17 +368,20 @@ async def update( ``PATCH /api/credential/:credentialID`` """ - await self._client.request( - RequestOptions( - method="PATCH", - path=f"/api/credential/{encode_path_segment(credential_id)}", - body={"label": label}, - extra_headers=extra_headers, - extra_query=extra_query, - extra_body=extra_body, - timeout=timeout, + return cast( + "None", + await self._client.request( + RequestOptions( + method="PATCH", + path=f"/api/credential/{encode_path_segment(credential_id)}", + body={"label": label}, + extra_headers=extra_headers, + extra_query=extra_query, + extra_body=extra_body, + timeout=timeout, + ), + kind="void", ), - kind="void", ) async def activate( @@ -340,16 +403,19 @@ async def activate( ``POST /api/credential/:credentialID/activate`` """ - await self._client.request( - RequestOptions( - method="POST", - path=f"/api/credential/{encode_path_segment(credential_id)}/activate", - extra_headers=extra_headers, - extra_query=extra_query, - extra_body=extra_body, - timeout=timeout, + return cast( + "None", + await self._client.request( + RequestOptions( + method="POST", + path=f"/api/credential/{encode_path_segment(credential_id)}/activate", + extra_headers=extra_headers, + extra_query=extra_query, + extra_body=extra_body, + timeout=timeout, + ), + kind="void", ), - kind="void", ) async def remove( @@ -371,14 +437,41 @@ async def remove( ``DELETE /api/credential/:credentialID`` """ - await self._client.request( - RequestOptions( - method="DELETE", - path=f"/api/credential/{encode_path_segment(credential_id)}", - extra_headers=extra_headers, - extra_query=extra_query, - extra_body=extra_body, - timeout=timeout, + return cast( + "None", + await self._client.request( + RequestOptions( + method="DELETE", + path=f"/api/credential/{encode_path_segment(credential_id)}", + extra_headers=extra_headers, + extra_query=extra_query, + extra_body=extra_body, + timeout=timeout, + ), + kind="void", ), - kind="void", ) + + +class AsyncCredentialResourceWithRawResponse: + """``client.credential.with_raw_response``.""" + + def __init__(self, resource: AsyncCredentialResource) -> None: + self._resource = resource + self.list = async_to_raw_response_wrapper(resource.list) + self.create = async_to_raw_response_wrapper(resource.create) + self.update = async_to_raw_response_wrapper(resource.update) + self.activate = async_to_raw_response_wrapper(resource.activate) + self.remove = async_to_raw_response_wrapper(resource.remove) + + +class AsyncCredentialResourceWithStreamingResponse: + """``client.credential.with_streaming_response``.""" + + def __init__(self, resource: AsyncCredentialResource) -> None: + self._resource = resource + self.list = async_to_streamed_response_wrapper(resource.list) + self.create = async_to_streamed_response_wrapper(resource.create) + self.update = async_to_streamed_response_wrapper(resource.update) + self.activate = async_to_streamed_response_wrapper(resource.activate) + self.remove = async_to_streamed_response_wrapper(resource.remove) diff --git a/src/opencode/resources/debug.py b/src/opencode/resources/debug.py index b296dd8..6df94ba 100644 --- a/src/opencode/resources/debug.py +++ b/src/opencode/resources/debug.py @@ -11,6 +11,12 @@ from .._base_client import RequestOptions from .._resource import AsyncAPIResource, SyncAPIResource +from .._response import ( + async_to_raw_response_wrapper, + async_to_streamed_response_wrapper, + to_raw_response_wrapper, + to_streamed_response_wrapper, +) from .._types import NOT_GIVEN, Body, Headers, NotGiven, Query, Timeout if TYPE_CHECKING: @@ -25,6 +31,16 @@ class DebugLocationResource(SyncAPIResource): """Operations under ``client.debug.location`` (OpenCode ``debug.location``).""" + @cached_property + def with_raw_response(self) -> DebugLocationResourceWithRawResponse: + """Same methods, returning the raw HTTP response; call ``.parse()`` on it for the usual value.""" + return DebugLocationResourceWithRawResponse(self) + + @cached_property + def with_streaming_response(self) -> DebugLocationResourceWithStreamingResponse: + """Same methods, returning a context manager over the HTTP response without reading the body.""" + return DebugLocationResourceWithStreamingResponse(self) + def list( self, *, @@ -77,20 +93,41 @@ def evict( ``DELETE /api/debug/location`` """ - self._client.request( - RequestOptions( - method="DELETE", - path="/api/debug/location", - query={"location": self._location(location)}, - extra_headers=extra_headers, - extra_query=extra_query, - extra_body=extra_body, - timeout=timeout, + return cast( + "None", + self._client.request( + RequestOptions( + method="DELETE", + path="/api/debug/location", + query={"location": self._location(location)}, + extra_headers=extra_headers, + extra_query=extra_query, + extra_body=extra_body, + timeout=timeout, + ), + kind="void", ), - kind="void", ) +class DebugLocationResourceWithRawResponse: + """``client.debug.location.with_raw_response``.""" + + def __init__(self, resource: DebugLocationResource) -> None: + self._resource = resource + self.list = to_raw_response_wrapper(resource.list) + self.evict = to_raw_response_wrapper(resource.evict) + + +class DebugLocationResourceWithStreamingResponse: + """``client.debug.location.with_streaming_response``.""" + + def __init__(self, resource: DebugLocationResource) -> None: + self._resource = resource + self.list = to_streamed_response_wrapper(resource.list) + self.evict = to_streamed_response_wrapper(resource.evict) + + class DebugResource(SyncAPIResource): """Operations under ``client.debug`` (OpenCode ``debug``).""" @@ -99,10 +136,54 @@ def location(self) -> DebugLocationResource: """Operations under ``client.debug.location``.""" return DebugLocationResource(self._client) + @cached_property + def with_raw_response(self) -> DebugResourceWithRawResponse: + """Same methods, returning the raw HTTP response; call ``.parse()`` on it for the usual value.""" + return DebugResourceWithRawResponse(self) + + @cached_property + def with_streaming_response(self) -> DebugResourceWithStreamingResponse: + """Same methods, returning a context manager over the HTTP response without reading the body.""" + return DebugResourceWithStreamingResponse(self) + + +class DebugResourceWithRawResponse: + """``client.debug.with_raw_response``.""" + + def __init__(self, resource: DebugResource) -> None: + self._resource = resource + + @cached_property + def location(self) -> DebugLocationResourceWithRawResponse: + """``client.debug.location.with_raw_response``.""" + return DebugLocationResourceWithRawResponse(self._resource.location) + + +class DebugResourceWithStreamingResponse: + """``client.debug.with_streaming_response``.""" + + def __init__(self, resource: DebugResource) -> None: + self._resource = resource + + @cached_property + def location(self) -> DebugLocationResourceWithStreamingResponse: + """``client.debug.location.with_streaming_response``.""" + return DebugLocationResourceWithStreamingResponse(self._resource.location) + class AsyncDebugLocationResource(AsyncAPIResource): """Operations under ``client.debug.location`` (OpenCode ``debug.location``).""" + @cached_property + def with_raw_response(self) -> AsyncDebugLocationResourceWithRawResponse: + """Same methods, returning the raw HTTP response; call ``.parse()`` on it for the usual value.""" + return AsyncDebugLocationResourceWithRawResponse(self) + + @cached_property + def with_streaming_response(self) -> AsyncDebugLocationResourceWithStreamingResponse: + """Same methods, returning a context manager over the HTTP response without reading the body.""" + return AsyncDebugLocationResourceWithStreamingResponse(self) + async def list( self, *, @@ -155,20 +236,41 @@ async def evict( ``DELETE /api/debug/location`` """ - await self._client.request( - RequestOptions( - method="DELETE", - path="/api/debug/location", - query={"location": self._location(location)}, - extra_headers=extra_headers, - extra_query=extra_query, - extra_body=extra_body, - timeout=timeout, + return cast( + "None", + await self._client.request( + RequestOptions( + method="DELETE", + path="/api/debug/location", + query={"location": self._location(location)}, + extra_headers=extra_headers, + extra_query=extra_query, + extra_body=extra_body, + timeout=timeout, + ), + kind="void", ), - kind="void", ) +class AsyncDebugLocationResourceWithRawResponse: + """``client.debug.location.with_raw_response``.""" + + def __init__(self, resource: AsyncDebugLocationResource) -> None: + self._resource = resource + self.list = async_to_raw_response_wrapper(resource.list) + self.evict = async_to_raw_response_wrapper(resource.evict) + + +class AsyncDebugLocationResourceWithStreamingResponse: + """``client.debug.location.with_streaming_response``.""" + + def __init__(self, resource: AsyncDebugLocationResource) -> None: + self._resource = resource + self.list = async_to_streamed_response_wrapper(resource.list) + self.evict = async_to_streamed_response_wrapper(resource.evict) + + class AsyncDebugResource(AsyncAPIResource): """Operations under ``client.debug`` (OpenCode ``debug``).""" @@ -176,3 +278,37 @@ class AsyncDebugResource(AsyncAPIResource): def location(self) -> AsyncDebugLocationResource: """Operations under ``client.debug.location``.""" return AsyncDebugLocationResource(self._client) + + @cached_property + def with_raw_response(self) -> AsyncDebugResourceWithRawResponse: + """Same methods, returning the raw HTTP response; call ``.parse()`` on it for the usual value.""" + return AsyncDebugResourceWithRawResponse(self) + + @cached_property + def with_streaming_response(self) -> AsyncDebugResourceWithStreamingResponse: + """Same methods, returning a context manager over the HTTP response without reading the body.""" + return AsyncDebugResourceWithStreamingResponse(self) + + +class AsyncDebugResourceWithRawResponse: + """``client.debug.with_raw_response``.""" + + def __init__(self, resource: AsyncDebugResource) -> None: + self._resource = resource + + @cached_property + def location(self) -> AsyncDebugLocationResourceWithRawResponse: + """``client.debug.location.with_raw_response``.""" + return AsyncDebugLocationResourceWithRawResponse(self._resource.location) + + +class AsyncDebugResourceWithStreamingResponse: + """``client.debug.with_streaming_response``.""" + + def __init__(self, resource: AsyncDebugResource) -> None: + self._resource = resource + + @cached_property + def location(self) -> AsyncDebugLocationResourceWithStreamingResponse: + """``client.debug.location.with_streaming_response``.""" + return AsyncDebugLocationResourceWithStreamingResponse(self._resource.location) diff --git a/src/opencode/resources/event.py b/src/opencode/resources/event.py index ede6671..c6583f9 100644 --- a/src/opencode/resources/event.py +++ b/src/opencode/resources/event.py @@ -5,10 +5,17 @@ from __future__ import annotations +from functools import cached_property from typing import TYPE_CHECKING from .._base_client import RequestOptions from .._resource import AsyncAPIResource, SyncAPIResource +from .._response import ( + async_to_raw_response_wrapper, + async_to_streamed_response_wrapper, + to_raw_response_wrapper, + to_streamed_response_wrapper, +) from .._streaming import AsyncStream, Stream from .._types import NOT_GIVEN, Body, Headers, NotGiven, Query, Timeout @@ -23,6 +30,16 @@ class EventResource(SyncAPIResource): """Operations under ``client.event`` (OpenCode ``event``).""" + @cached_property + def with_raw_response(self) -> EventResourceWithRawResponse: + """Same methods, returning the raw HTTP response; call ``.parse()`` on it for the usual value.""" + return EventResourceWithRawResponse(self) + + @cached_property + def with_streaming_response(self) -> EventResourceWithStreamingResponse: + """Same methods, returning a context manager over the HTTP response without reading the body.""" + return EventResourceWithStreamingResponse(self) + def subscribe( self, *, @@ -54,9 +71,35 @@ def subscribe( ) +class EventResourceWithRawResponse: + """``client.event.with_raw_response``.""" + + def __init__(self, resource: EventResource) -> None: + self._resource = resource + self.subscribe = to_raw_response_wrapper(resource.subscribe) + + +class EventResourceWithStreamingResponse: + """``client.event.with_streaming_response``.""" + + def __init__(self, resource: EventResource) -> None: + self._resource = resource + self.subscribe = to_streamed_response_wrapper(resource.subscribe) + + class AsyncEventResource(AsyncAPIResource): """Operations under ``client.event`` (OpenCode ``event``).""" + @cached_property + def with_raw_response(self) -> AsyncEventResourceWithRawResponse: + """Same methods, returning the raw HTTP response; call ``.parse()`` on it for the usual value.""" + return AsyncEventResourceWithRawResponse(self) + + @cached_property + def with_streaming_response(self) -> AsyncEventResourceWithStreamingResponse: + """Same methods, returning a context manager over the HTTP response without reading the body.""" + return AsyncEventResourceWithStreamingResponse(self) + async def subscribe( self, *, @@ -86,3 +129,19 @@ async def subscribe( ), item_type="Event", ) + + +class AsyncEventResourceWithRawResponse: + """``client.event.with_raw_response``.""" + + def __init__(self, resource: AsyncEventResource) -> None: + self._resource = resource + self.subscribe = async_to_raw_response_wrapper(resource.subscribe) + + +class AsyncEventResourceWithStreamingResponse: + """``client.event.with_streaming_response``.""" + + def __init__(self, resource: AsyncEventResource) -> None: + self._resource = resource + self.subscribe = async_to_streamed_response_wrapper(resource.subscribe) diff --git a/src/opencode/resources/experimental.py b/src/opencode/resources/experimental.py index 4a59398..ae3049f 100644 --- a/src/opencode/resources/experimental.py +++ b/src/opencode/resources/experimental.py @@ -14,6 +14,12 @@ from .._pty import AsyncPersistentPtyAttachMixin, PersistentPtyAttachMixin from .._qs import encode_path_segment from .._resource import AsyncAPIResource, SyncAPIResource +from .._response import ( + async_to_raw_response_wrapper, + async_to_streamed_response_wrapper, + to_raw_response_wrapper, + to_streamed_response_wrapper, +) from .._types import NOT_GIVEN, Body, Headers, NotGiven, Query, Timeout if TYPE_CHECKING: @@ -36,6 +42,16 @@ class ExperimentalPersistentPtyResource(PersistentPtyAttachMixin): """Operations under ``client.experimental.persistent_pty`` (OpenCode ``experimental.persistentPty``).""" + @cached_property + def with_raw_response(self) -> ExperimentalPersistentPtyResourceWithRawResponse: + """Same methods, returning the raw HTTP response; call ``.parse()`` on it for the usual value.""" + return ExperimentalPersistentPtyResourceWithRawResponse(self) + + @cached_property + def with_streaming_response(self) -> ExperimentalPersistentPtyResourceWithStreamingResponse: + """Same methods, returning a context manager over the HTTP response without reading the body.""" + return ExperimentalPersistentPtyResourceWithStreamingResponse(self) + def read( self, session_id: SessionID, @@ -168,16 +184,19 @@ def shutdown( ``POST /api/experimental/persistent-pty/shutdown`` """ - self._client.request( - RequestOptions( - method="POST", - path="/api/experimental/persistent-pty/shutdown", - extra_headers=extra_headers, - extra_query=extra_query, - extra_body=extra_body, - timeout=timeout, + return cast( + "None", + self._client.request( + RequestOptions( + method="POST", + path="/api/experimental/persistent-pty/shutdown", + extra_headers=extra_headers, + extra_query=extra_query, + extra_body=extra_body, + timeout=timeout, + ), + kind="void", ), - kind="void", ) def handoff( @@ -339,16 +358,19 @@ def remove( ``DELETE /api/experimental/persistent-pty/:ptyID`` """ - self._client.request( - RequestOptions( - method="DELETE", - path=f"/api/experimental/persistent-pty/{encode_path_segment(pty_id)}", - extra_headers=extra_headers, - extra_query=extra_query, - extra_body=extra_body, - timeout=timeout, + return cast( + "None", + self._client.request( + RequestOptions( + method="DELETE", + path=f"/api/experimental/persistent-pty/{encode_path_segment(pty_id)}", + extra_headers=extra_headers, + extra_query=extra_query, + extra_body=extra_body, + timeout=timeout, + ), + kind="void", ), - kind="void", ) def connect_token( @@ -390,6 +412,40 @@ def connect_token( ) +class ExperimentalPersistentPtyResourceWithRawResponse: + """``client.experimental.persistent_pty.with_raw_response``.""" + + def __init__(self, resource: ExperimentalPersistentPtyResource) -> None: + self._resource = resource + self.read = to_raw_response_wrapper(resource.read) + self.list = to_raw_response_wrapper(resource.list) + self.create = to_raw_response_wrapper(resource.create) + self.shutdown = to_raw_response_wrapper(resource.shutdown) + self.handoff = to_raw_response_wrapper(resource.handoff) + self.get = to_raw_response_wrapper(resource.get) + self.update = to_raw_response_wrapper(resource.update) + self.snapshot = to_raw_response_wrapper(resource.snapshot) + self.remove = to_raw_response_wrapper(resource.remove) + self.connect_token = to_raw_response_wrapper(resource.connect_token) + + +class ExperimentalPersistentPtyResourceWithStreamingResponse: + """``client.experimental.persistent_pty.with_streaming_response``.""" + + def __init__(self, resource: ExperimentalPersistentPtyResource) -> None: + self._resource = resource + self.read = to_streamed_response_wrapper(resource.read) + self.list = to_streamed_response_wrapper(resource.list) + self.create = to_streamed_response_wrapper(resource.create) + self.shutdown = to_streamed_response_wrapper(resource.shutdown) + self.handoff = to_streamed_response_wrapper(resource.handoff) + self.get = to_streamed_response_wrapper(resource.get) + self.update = to_streamed_response_wrapper(resource.update) + self.snapshot = to_streamed_response_wrapper(resource.snapshot) + self.remove = to_streamed_response_wrapper(resource.remove) + self.connect_token = to_streamed_response_wrapper(resource.connect_token) + + class ExperimentalResource(SyncAPIResource): """Operations under ``client.experimental`` (OpenCode ``experimental``).""" @@ -398,10 +454,54 @@ def persistent_pty(self) -> ExperimentalPersistentPtyResource: """Operations under ``client.experimental.persistent_pty``.""" return ExperimentalPersistentPtyResource(self._client) + @cached_property + def with_raw_response(self) -> ExperimentalResourceWithRawResponse: + """Same methods, returning the raw HTTP response; call ``.parse()`` on it for the usual value.""" + return ExperimentalResourceWithRawResponse(self) + + @cached_property + def with_streaming_response(self) -> ExperimentalResourceWithStreamingResponse: + """Same methods, returning a context manager over the HTTP response without reading the body.""" + return ExperimentalResourceWithStreamingResponse(self) + + +class ExperimentalResourceWithRawResponse: + """``client.experimental.with_raw_response``.""" + + def __init__(self, resource: ExperimentalResource) -> None: + self._resource = resource + + @cached_property + def persistent_pty(self) -> ExperimentalPersistentPtyResourceWithRawResponse: + """``client.experimental.persistent_pty.with_raw_response``.""" + return ExperimentalPersistentPtyResourceWithRawResponse(self._resource.persistent_pty) + + +class ExperimentalResourceWithStreamingResponse: + """``client.experimental.with_streaming_response``.""" + + def __init__(self, resource: ExperimentalResource) -> None: + self._resource = resource + + @cached_property + def persistent_pty(self) -> ExperimentalPersistentPtyResourceWithStreamingResponse: + """``client.experimental.persistent_pty.with_streaming_response``.""" + return ExperimentalPersistentPtyResourceWithStreamingResponse(self._resource.persistent_pty) + class AsyncExperimentalPersistentPtyResource(AsyncPersistentPtyAttachMixin): """Operations under ``client.experimental.persistent_pty`` (OpenCode ``experimental.persistentPty``).""" + @cached_property + def with_raw_response(self) -> AsyncExperimentalPersistentPtyResourceWithRawResponse: + """Same methods, returning the raw HTTP response; call ``.parse()`` on it for the usual value.""" + return AsyncExperimentalPersistentPtyResourceWithRawResponse(self) + + @cached_property + def with_streaming_response(self) -> AsyncExperimentalPersistentPtyResourceWithStreamingResponse: + """Same methods, returning a context manager over the HTTP response without reading the body.""" + return AsyncExperimentalPersistentPtyResourceWithStreamingResponse(self) + async def read( self, session_id: SessionID, @@ -534,16 +634,19 @@ async def shutdown( ``POST /api/experimental/persistent-pty/shutdown`` """ - await self._client.request( - RequestOptions( - method="POST", - path="/api/experimental/persistent-pty/shutdown", - extra_headers=extra_headers, - extra_query=extra_query, - extra_body=extra_body, - timeout=timeout, + return cast( + "None", + await self._client.request( + RequestOptions( + method="POST", + path="/api/experimental/persistent-pty/shutdown", + extra_headers=extra_headers, + extra_query=extra_query, + extra_body=extra_body, + timeout=timeout, + ), + kind="void", ), - kind="void", ) async def handoff( @@ -705,16 +808,19 @@ async def remove( ``DELETE /api/experimental/persistent-pty/:ptyID`` """ - await self._client.request( - RequestOptions( - method="DELETE", - path=f"/api/experimental/persistent-pty/{encode_path_segment(pty_id)}", - extra_headers=extra_headers, - extra_query=extra_query, - extra_body=extra_body, - timeout=timeout, + return cast( + "None", + await self._client.request( + RequestOptions( + method="DELETE", + path=f"/api/experimental/persistent-pty/{encode_path_segment(pty_id)}", + extra_headers=extra_headers, + extra_query=extra_query, + extra_body=extra_body, + timeout=timeout, + ), + kind="void", ), - kind="void", ) async def connect_token( @@ -756,6 +862,40 @@ async def connect_token( ) +class AsyncExperimentalPersistentPtyResourceWithRawResponse: + """``client.experimental.persistent_pty.with_raw_response``.""" + + def __init__(self, resource: AsyncExperimentalPersistentPtyResource) -> None: + self._resource = resource + self.read = async_to_raw_response_wrapper(resource.read) + self.list = async_to_raw_response_wrapper(resource.list) + self.create = async_to_raw_response_wrapper(resource.create) + self.shutdown = async_to_raw_response_wrapper(resource.shutdown) + self.handoff = async_to_raw_response_wrapper(resource.handoff) + self.get = async_to_raw_response_wrapper(resource.get) + self.update = async_to_raw_response_wrapper(resource.update) + self.snapshot = async_to_raw_response_wrapper(resource.snapshot) + self.remove = async_to_raw_response_wrapper(resource.remove) + self.connect_token = async_to_raw_response_wrapper(resource.connect_token) + + +class AsyncExperimentalPersistentPtyResourceWithStreamingResponse: + """``client.experimental.persistent_pty.with_streaming_response``.""" + + def __init__(self, resource: AsyncExperimentalPersistentPtyResource) -> None: + self._resource = resource + self.read = async_to_streamed_response_wrapper(resource.read) + self.list = async_to_streamed_response_wrapper(resource.list) + self.create = async_to_streamed_response_wrapper(resource.create) + self.shutdown = async_to_streamed_response_wrapper(resource.shutdown) + self.handoff = async_to_streamed_response_wrapper(resource.handoff) + self.get = async_to_streamed_response_wrapper(resource.get) + self.update = async_to_streamed_response_wrapper(resource.update) + self.snapshot = async_to_streamed_response_wrapper(resource.snapshot) + self.remove = async_to_streamed_response_wrapper(resource.remove) + self.connect_token = async_to_streamed_response_wrapper(resource.connect_token) + + class AsyncExperimentalResource(AsyncAPIResource): """Operations under ``client.experimental`` (OpenCode ``experimental``).""" @@ -763,3 +903,37 @@ class AsyncExperimentalResource(AsyncAPIResource): def persistent_pty(self) -> AsyncExperimentalPersistentPtyResource: """Operations under ``client.experimental.persistent_pty``.""" return AsyncExperimentalPersistentPtyResource(self._client) + + @cached_property + def with_raw_response(self) -> AsyncExperimentalResourceWithRawResponse: + """Same methods, returning the raw HTTP response; call ``.parse()`` on it for the usual value.""" + return AsyncExperimentalResourceWithRawResponse(self) + + @cached_property + def with_streaming_response(self) -> AsyncExperimentalResourceWithStreamingResponse: + """Same methods, returning a context manager over the HTTP response without reading the body.""" + return AsyncExperimentalResourceWithStreamingResponse(self) + + +class AsyncExperimentalResourceWithRawResponse: + """``client.experimental.with_raw_response``.""" + + def __init__(self, resource: AsyncExperimentalResource) -> None: + self._resource = resource + + @cached_property + def persistent_pty(self) -> AsyncExperimentalPersistentPtyResourceWithRawResponse: + """``client.experimental.persistent_pty.with_raw_response``.""" + return AsyncExperimentalPersistentPtyResourceWithRawResponse(self._resource.persistent_pty) + + +class AsyncExperimentalResourceWithStreamingResponse: + """``client.experimental.with_streaming_response``.""" + + def __init__(self, resource: AsyncExperimentalResource) -> None: + self._resource = resource + + @cached_property + def persistent_pty(self) -> AsyncExperimentalPersistentPtyResourceWithStreamingResponse: + """``client.experimental.persistent_pty.with_streaming_response``.""" + return AsyncExperimentalPersistentPtyResourceWithStreamingResponse(self._resource.persistent_pty) diff --git a/src/opencode/resources/file.py b/src/opencode/resources/file.py index 8a96de9..4685232 100644 --- a/src/opencode/resources/file.py +++ b/src/opencode/resources/file.py @@ -5,11 +5,18 @@ from __future__ import annotations +from functools import cached_property from typing import TYPE_CHECKING, Literal, cast from .._base_client import RequestOptions from .._qs import encode_path from .._resource import AsyncAPIResource, SyncAPIResource +from .._response import ( + async_to_raw_response_wrapper, + async_to_streamed_response_wrapper, + to_raw_response_wrapper, + to_streamed_response_wrapper, +) from .._types import NOT_GIVEN, Body, Headers, NotGiven, OpenEnum, Query, Timeout if TYPE_CHECKING: @@ -26,6 +33,16 @@ class FileResource(SyncAPIResource): """Operations under ``client.file`` (OpenCode ``file``).""" + @cached_property + def with_raw_response(self) -> FileResourceWithRawResponse: + """Same methods, returning the raw HTTP response; call ``.parse()`` on it for the usual value.""" + return FileResourceWithRawResponse(self) + + @cached_property + def with_streaming_response(self) -> FileResourceWithStreamingResponse: + """Same methods, returning a context manager over the HTTP response without reading the body.""" + return FileResourceWithStreamingResponse(self) + def read( self, path: str, @@ -189,9 +206,41 @@ def write( ) +class FileResourceWithRawResponse: + """``client.file.with_raw_response``.""" + + def __init__(self, resource: FileResource) -> None: + self._resource = resource + self.read = to_raw_response_wrapper(resource.read) + self.list = to_raw_response_wrapper(resource.list) + self.find = to_raw_response_wrapper(resource.find) + self.write = to_raw_response_wrapper(resource.write) + + +class FileResourceWithStreamingResponse: + """``client.file.with_streaming_response``.""" + + def __init__(self, resource: FileResource) -> None: + self._resource = resource + self.read = to_streamed_response_wrapper(resource.read) + self.list = to_streamed_response_wrapper(resource.list) + self.find = to_streamed_response_wrapper(resource.find) + self.write = to_streamed_response_wrapper(resource.write) + + class AsyncFileResource(AsyncAPIResource): """Operations under ``client.file`` (OpenCode ``file``).""" + @cached_property + def with_raw_response(self) -> AsyncFileResourceWithRawResponse: + """Same methods, returning the raw HTTP response; call ``.parse()`` on it for the usual value.""" + return AsyncFileResourceWithRawResponse(self) + + @cached_property + def with_streaming_response(self) -> AsyncFileResourceWithStreamingResponse: + """Same methods, returning a context manager over the HTTP response without reading the body.""" + return AsyncFileResourceWithStreamingResponse(self) + async def read( self, path: str, @@ -353,3 +402,25 @@ async def write( response_type="FileWriteResponse", ), ) + + +class AsyncFileResourceWithRawResponse: + """``client.file.with_raw_response``.""" + + def __init__(self, resource: AsyncFileResource) -> None: + self._resource = resource + self.read = async_to_raw_response_wrapper(resource.read) + self.list = async_to_raw_response_wrapper(resource.list) + self.find = async_to_raw_response_wrapper(resource.find) + self.write = async_to_raw_response_wrapper(resource.write) + + +class AsyncFileResourceWithStreamingResponse: + """``client.file.with_streaming_response``.""" + + def __init__(self, resource: AsyncFileResource) -> None: + self._resource = resource + self.read = async_to_streamed_response_wrapper(resource.read) + self.list = async_to_streamed_response_wrapper(resource.list) + self.find = async_to_streamed_response_wrapper(resource.find) + self.write = async_to_streamed_response_wrapper(resource.write) diff --git a/src/opencode/resources/form.py b/src/opencode/resources/form.py index 4c6f2de..005257e 100644 --- a/src/opencode/resources/form.py +++ b/src/opencode/resources/form.py @@ -5,10 +5,17 @@ from __future__ import annotations +from functools import cached_property from typing import TYPE_CHECKING, cast from .._base_client import RequestOptions from .._resource import AsyncAPIResource, SyncAPIResource +from .._response import ( + async_to_raw_response_wrapper, + async_to_streamed_response_wrapper, + to_raw_response_wrapper, + to_streamed_response_wrapper, +) from .._types import NOT_GIVEN, Body, Headers, NotGiven, Query, Timeout if TYPE_CHECKING: @@ -23,6 +30,16 @@ class FormResource(SyncAPIResource): """Operations under ``client.form`` (OpenCode ``form``).""" + @cached_property + def with_raw_response(self) -> FormResourceWithRawResponse: + """Same methods, returning the raw HTTP response; call ``.parse()`` on it for the usual value.""" + return FormResourceWithRawResponse(self) + + @cached_property + def with_streaming_response(self) -> FormResourceWithStreamingResponse: + """Same methods, returning a context manager over the HTTP response without reading the body.""" + return FormResourceWithStreamingResponse(self) + def list( self, *, @@ -60,9 +77,35 @@ def list( ) +class FormResourceWithRawResponse: + """``client.form.with_raw_response``.""" + + def __init__(self, resource: FormResource) -> None: + self._resource = resource + self.list = to_raw_response_wrapper(resource.list) + + +class FormResourceWithStreamingResponse: + """``client.form.with_streaming_response``.""" + + def __init__(self, resource: FormResource) -> None: + self._resource = resource + self.list = to_streamed_response_wrapper(resource.list) + + class AsyncFormResource(AsyncAPIResource): """Operations under ``client.form`` (OpenCode ``form``).""" + @cached_property + def with_raw_response(self) -> AsyncFormResourceWithRawResponse: + """Same methods, returning the raw HTTP response; call ``.parse()`` on it for the usual value.""" + return AsyncFormResourceWithRawResponse(self) + + @cached_property + def with_streaming_response(self) -> AsyncFormResourceWithStreamingResponse: + """Same methods, returning a context manager over the HTTP response without reading the body.""" + return AsyncFormResourceWithStreamingResponse(self) + async def list( self, *, @@ -98,3 +141,19 @@ async def list( response_type="FormListResponse", ), ) + + +class AsyncFormResourceWithRawResponse: + """``client.form.with_raw_response``.""" + + def __init__(self, resource: AsyncFormResource) -> None: + self._resource = resource + self.list = async_to_raw_response_wrapper(resource.list) + + +class AsyncFormResourceWithStreamingResponse: + """``client.form.with_streaming_response``.""" + + def __init__(self, resource: AsyncFormResource) -> None: + self._resource = resource + self.list = async_to_streamed_response_wrapper(resource.list) diff --git a/src/opencode/resources/generate.py b/src/opencode/resources/generate.py index 6788e63..17df697 100644 --- a/src/opencode/resources/generate.py +++ b/src/opencode/resources/generate.py @@ -5,10 +5,17 @@ from __future__ import annotations +from functools import cached_property from typing import TYPE_CHECKING, cast from .._base_client import RequestOptions from .._resource import AsyncAPIResource, SyncAPIResource +from .._response import ( + async_to_raw_response_wrapper, + async_to_streamed_response_wrapper, + to_raw_response_wrapper, + to_streamed_response_wrapper, +) from .._types import NOT_GIVEN, Body, Headers, NotGiven, Query, Timeout if TYPE_CHECKING: @@ -23,6 +30,16 @@ class GenerateResource(SyncAPIResource): """Operations under ``client.generate`` (OpenCode ``generate``).""" + @cached_property + def with_raw_response(self) -> GenerateResourceWithRawResponse: + """Same methods, returning the raw HTTP response; call ``.parse()`` on it for the usual value.""" + return GenerateResourceWithRawResponse(self) + + @cached_property + def with_streaming_response(self) -> GenerateResourceWithStreamingResponse: + """Same methods, returning a context manager over the HTTP response without reading the body.""" + return GenerateResourceWithStreamingResponse(self) + def text( self, *, @@ -65,9 +82,35 @@ def text( ) +class GenerateResourceWithRawResponse: + """``client.generate.with_raw_response``.""" + + def __init__(self, resource: GenerateResource) -> None: + self._resource = resource + self.text = to_raw_response_wrapper(resource.text) + + +class GenerateResourceWithStreamingResponse: + """``client.generate.with_streaming_response``.""" + + def __init__(self, resource: GenerateResource) -> None: + self._resource = resource + self.text = to_streamed_response_wrapper(resource.text) + + class AsyncGenerateResource(AsyncAPIResource): """Operations under ``client.generate`` (OpenCode ``generate``).""" + @cached_property + def with_raw_response(self) -> AsyncGenerateResourceWithRawResponse: + """Same methods, returning the raw HTTP response; call ``.parse()`` on it for the usual value.""" + return AsyncGenerateResourceWithRawResponse(self) + + @cached_property + def with_streaming_response(self) -> AsyncGenerateResourceWithStreamingResponse: + """Same methods, returning a context manager over the HTTP response without reading the body.""" + return AsyncGenerateResourceWithStreamingResponse(self) + async def text( self, *, @@ -108,3 +151,19 @@ async def text( unwrap=True, ), ) + + +class AsyncGenerateResourceWithRawResponse: + """``client.generate.with_raw_response``.""" + + def __init__(self, resource: AsyncGenerateResource) -> None: + self._resource = resource + self.text = async_to_raw_response_wrapper(resource.text) + + +class AsyncGenerateResourceWithStreamingResponse: + """``client.generate.with_streaming_response``.""" + + def __init__(self, resource: AsyncGenerateResource) -> None: + self._resource = resource + self.text = async_to_streamed_response_wrapper(resource.text) diff --git a/src/opencode/resources/integration.py b/src/opencode/resources/integration.py index bef4518..dee1c27 100644 --- a/src/opencode/resources/integration.py +++ b/src/opencode/resources/integration.py @@ -11,6 +11,12 @@ from .._base_client import RequestOptions from .._qs import encode_path_segment from .._resource import AsyncAPIResource, SyncAPIResource +from .._response import ( + async_to_raw_response_wrapper, + async_to_streamed_response_wrapper, + to_raw_response_wrapper, + to_streamed_response_wrapper, +) from .._types import NOT_GIVEN, Body, Headers, NotGiven, Query, Timeout if TYPE_CHECKING: @@ -34,6 +40,16 @@ class IntegrationWellknownResource(SyncAPIResource): """Operations under ``client.integration.wellknown`` (OpenCode ``integration.wellknown``).""" + @cached_property + def with_raw_response(self) -> IntegrationWellknownResourceWithRawResponse: + """Same methods, returning the raw HTTP response; call ``.parse()`` on it for the usual value.""" + return IntegrationWellknownResourceWithRawResponse(self) + + @cached_property + def with_streaming_response(self) -> IntegrationWellknownResourceWithStreamingResponse: + """Same methods, returning a context manager over the HTTP response without reading the body.""" + return IntegrationWellknownResourceWithStreamingResponse(self) + def add( self, *, @@ -57,24 +73,53 @@ def add( ``POST /api/experimental/integration/wellknown`` """ - self._client.request( - RequestOptions( - method="POST", - path="/api/experimental/integration/wellknown", - query={"location": self._location(location)}, - body={"url": url}, - extra_headers=extra_headers, - extra_query=extra_query, - extra_body=extra_body, - timeout=timeout, + return cast( + "None", + self._client.request( + RequestOptions( + method="POST", + path="/api/experimental/integration/wellknown", + query={"location": self._location(location)}, + body={"url": url}, + extra_headers=extra_headers, + extra_query=extra_query, + extra_body=extra_body, + timeout=timeout, + ), + kind="void", ), - kind="void", ) +class IntegrationWellknownResourceWithRawResponse: + """``client.integration.wellknown.with_raw_response``.""" + + def __init__(self, resource: IntegrationWellknownResource) -> None: + self._resource = resource + self.add = to_raw_response_wrapper(resource.add) + + +class IntegrationWellknownResourceWithStreamingResponse: + """``client.integration.wellknown.with_streaming_response``.""" + + def __init__(self, resource: IntegrationWellknownResource) -> None: + self._resource = resource + self.add = to_streamed_response_wrapper(resource.add) + + class IntegrationConnectResource(SyncAPIResource): """Operations under ``client.integration.connect`` (OpenCode ``integration.connect``).""" + @cached_property + def with_raw_response(self) -> IntegrationConnectResourceWithRawResponse: + """Same methods, returning the raw HTTP response; call ``.parse()`` on it for the usual value.""" + return IntegrationConnectResourceWithRawResponse(self) + + @cached_property + def with_streaming_response(self) -> IntegrationConnectResourceWithStreamingResponse: + """Same methods, returning a context manager over the HTTP response without reading the body.""" + return IntegrationConnectResourceWithStreamingResponse(self) + def key( self, integration_id: IntegrationID, @@ -100,18 +145,21 @@ def key( ``POST /api/integration/:integrationID/connect/key`` """ - self._client.request( - RequestOptions( - method="POST", - path=f"/api/integration/{encode_path_segment(integration_id)}/connect/key", - query={"location": self._location(location)}, - body={"key": key, "answer": answer, "label": label}, - extra_headers=extra_headers, - extra_query=extra_query, - extra_body=extra_body, - timeout=timeout, + return cast( + "None", + self._client.request( + RequestOptions( + method="POST", + path=f"/api/integration/{encode_path_segment(integration_id)}/connect/key", + query={"location": self._location(location)}, + body={"key": key, "answer": answer, "label": label}, + extra_headers=extra_headers, + extra_query=extra_query, + extra_body=extra_body, + timeout=timeout, + ), + kind="void", ), - kind="void", ) def external( @@ -139,24 +187,55 @@ def external( ``POST /api/integration/:integrationID/connect/external`` """ - self._client.request( - RequestOptions( - method="POST", - path=f"/api/integration/{encode_path_segment(integration_id)}/connect/external", - query={"location": self._location(location)}, - body={"methodID": method_id, "answer": answer, "label": label}, - extra_headers=extra_headers, - extra_query=extra_query, - extra_body=extra_body, - timeout=timeout, + return cast( + "None", + self._client.request( + RequestOptions( + method="POST", + path=f"/api/integration/{encode_path_segment(integration_id)}/connect/external", + query={"location": self._location(location)}, + body={"methodID": method_id, "answer": answer, "label": label}, + extra_headers=extra_headers, + extra_query=extra_query, + extra_body=extra_body, + timeout=timeout, + ), + kind="void", ), - kind="void", ) +class IntegrationConnectResourceWithRawResponse: + """``client.integration.connect.with_raw_response``.""" + + def __init__(self, resource: IntegrationConnectResource) -> None: + self._resource = resource + self.key = to_raw_response_wrapper(resource.key) + self.external = to_raw_response_wrapper(resource.external) + + +class IntegrationConnectResourceWithStreamingResponse: + """``client.integration.connect.with_streaming_response``.""" + + def __init__(self, resource: IntegrationConnectResource) -> None: + self._resource = resource + self.key = to_streamed_response_wrapper(resource.key) + self.external = to_streamed_response_wrapper(resource.external) + + class IntegrationOauthResource(SyncAPIResource): """Operations under ``client.integration.oauth`` (OpenCode ``integration.oauth``).""" + @cached_property + def with_raw_response(self) -> IntegrationOauthResourceWithRawResponse: + """Same methods, returning the raw HTTP response; call ``.parse()`` on it for the usual value.""" + return IntegrationOauthResourceWithRawResponse(self) + + @cached_property + def with_streaming_response(self) -> IntegrationOauthResourceWithStreamingResponse: + """Same methods, returning a context manager over the HTTP response without reading the body.""" + return IntegrationOauthResourceWithStreamingResponse(self) + def connect( self, integration_id: IntegrationID, @@ -263,18 +342,21 @@ def complete( ``POST /api/integration/:integrationID/connect/oauth/:attemptID/complete`` """ - self._client.request( - RequestOptions( - method="POST", - path=f"/api/integration/{encode_path_segment(integration_id)}/connect/oauth/{encode_path_segment(attempt_id)}/complete", - query={"location": self._location(location)}, - body={"code": code}, - extra_headers=extra_headers, - extra_query=extra_query, - extra_body=extra_body, - timeout=timeout, + return cast( + "None", + self._client.request( + RequestOptions( + method="POST", + path=f"/api/integration/{encode_path_segment(integration_id)}/connect/oauth/{encode_path_segment(attempt_id)}/complete", + query={"location": self._location(location)}, + body={"code": code}, + extra_headers=extra_headers, + extra_query=extra_query, + extra_body=extra_body, + timeout=timeout, + ), + kind="void", ), - kind="void", ) def cancel( @@ -299,23 +381,58 @@ def cancel( ``DELETE /api/integration/:integrationID/connect/oauth/:attemptID`` """ - self._client.request( - RequestOptions( - method="DELETE", - path=f"/api/integration/{encode_path_segment(integration_id)}/connect/oauth/{encode_path_segment(attempt_id)}", - query={"location": self._location(location)}, - extra_headers=extra_headers, - extra_query=extra_query, - extra_body=extra_body, - timeout=timeout, + return cast( + "None", + self._client.request( + RequestOptions( + method="DELETE", + path=f"/api/integration/{encode_path_segment(integration_id)}/connect/oauth/{encode_path_segment(attempt_id)}", + query={"location": self._location(location)}, + extra_headers=extra_headers, + extra_query=extra_query, + extra_body=extra_body, + timeout=timeout, + ), + kind="void", ), - kind="void", ) +class IntegrationOauthResourceWithRawResponse: + """``client.integration.oauth.with_raw_response``.""" + + def __init__(self, resource: IntegrationOauthResource) -> None: + self._resource = resource + self.connect = to_raw_response_wrapper(resource.connect) + self.status = to_raw_response_wrapper(resource.status) + self.complete = to_raw_response_wrapper(resource.complete) + self.cancel = to_raw_response_wrapper(resource.cancel) + + +class IntegrationOauthResourceWithStreamingResponse: + """``client.integration.oauth.with_streaming_response``.""" + + def __init__(self, resource: IntegrationOauthResource) -> None: + self._resource = resource + self.connect = to_streamed_response_wrapper(resource.connect) + self.status = to_streamed_response_wrapper(resource.status) + self.complete = to_streamed_response_wrapper(resource.complete) + self.cancel = to_streamed_response_wrapper(resource.cancel) + + class IntegrationCommandResource(SyncAPIResource): """Operations under ``client.integration.command`` (OpenCode ``integration.command``).""" + @cached_property + def with_raw_response(self) -> IntegrationCommandResourceWithRawResponse: + """Same methods, returning the raw HTTP response; call ``.parse()`` on it for the usual value.""" + return IntegrationCommandResourceWithRawResponse(self) + + @cached_property + def with_streaming_response(self) -> IntegrationCommandResourceWithStreamingResponse: + """Same methods, returning a context manager over the HTTP response without reading the body.""" + return IntegrationCommandResourceWithStreamingResponse(self) + def connect( self, integration_id: IntegrationID, @@ -420,20 +537,43 @@ def cancel( ``DELETE /api/integration/:integrationID/connect/command/:attemptID`` """ - self._client.request( - RequestOptions( - method="DELETE", - path=f"/api/integration/{encode_path_segment(integration_id)}/connect/command/{encode_path_segment(attempt_id)}", - query={"location": self._location(location)}, - extra_headers=extra_headers, - extra_query=extra_query, - extra_body=extra_body, - timeout=timeout, + return cast( + "None", + self._client.request( + RequestOptions( + method="DELETE", + path=f"/api/integration/{encode_path_segment(integration_id)}/connect/command/{encode_path_segment(attempt_id)}", + query={"location": self._location(location)}, + extra_headers=extra_headers, + extra_query=extra_query, + extra_body=extra_body, + timeout=timeout, + ), + kind="void", ), - kind="void", ) +class IntegrationCommandResourceWithRawResponse: + """``client.integration.command.with_raw_response``.""" + + def __init__(self, resource: IntegrationCommandResource) -> None: + self._resource = resource + self.connect = to_raw_response_wrapper(resource.connect) + self.status = to_raw_response_wrapper(resource.status) + self.cancel = to_raw_response_wrapper(resource.cancel) + + +class IntegrationCommandResourceWithStreamingResponse: + """``client.integration.command.with_streaming_response``.""" + + def __init__(self, resource: IntegrationCommandResource) -> None: + self._resource = resource + self.connect = to_streamed_response_wrapper(resource.connect) + self.status = to_streamed_response_wrapper(resource.status) + self.cancel = to_streamed_response_wrapper(resource.cancel) + + class IntegrationResource(SyncAPIResource): """Operations under ``client.integration`` (OpenCode ``integration``).""" @@ -457,6 +597,16 @@ def command(self) -> IntegrationCommandResource: """Operations under ``client.integration.command``.""" return IntegrationCommandResource(self._client) + @cached_property + def with_raw_response(self) -> IntegrationResourceWithRawResponse: + """Same methods, returning the raw HTTP response; call ``.parse()`` on it for the usual value.""" + return IntegrationResourceWithRawResponse(self) + + @cached_property + def with_streaming_response(self) -> IntegrationResourceWithStreamingResponse: + """Same methods, returning a context manager over the HTTP response without reading the body.""" + return IntegrationResourceWithStreamingResponse(self) + def list( self, *, @@ -532,9 +682,77 @@ def get( ) +class IntegrationResourceWithRawResponse: + """``client.integration.with_raw_response``.""" + + def __init__(self, resource: IntegrationResource) -> None: + self._resource = resource + self.list = to_raw_response_wrapper(resource.list) + self.get = to_raw_response_wrapper(resource.get) + + @cached_property + def wellknown(self) -> IntegrationWellknownResourceWithRawResponse: + """``client.integration.wellknown.with_raw_response``.""" + return IntegrationWellknownResourceWithRawResponse(self._resource.wellknown) + + @cached_property + def connect(self) -> IntegrationConnectResourceWithRawResponse: + """``client.integration.connect.with_raw_response``.""" + return IntegrationConnectResourceWithRawResponse(self._resource.connect) + + @cached_property + def oauth(self) -> IntegrationOauthResourceWithRawResponse: + """``client.integration.oauth.with_raw_response``.""" + return IntegrationOauthResourceWithRawResponse(self._resource.oauth) + + @cached_property + def command(self) -> IntegrationCommandResourceWithRawResponse: + """``client.integration.command.with_raw_response``.""" + return IntegrationCommandResourceWithRawResponse(self._resource.command) + + +class IntegrationResourceWithStreamingResponse: + """``client.integration.with_streaming_response``.""" + + def __init__(self, resource: IntegrationResource) -> None: + self._resource = resource + self.list = to_streamed_response_wrapper(resource.list) + self.get = to_streamed_response_wrapper(resource.get) + + @cached_property + def wellknown(self) -> IntegrationWellknownResourceWithStreamingResponse: + """``client.integration.wellknown.with_streaming_response``.""" + return IntegrationWellknownResourceWithStreamingResponse(self._resource.wellknown) + + @cached_property + def connect(self) -> IntegrationConnectResourceWithStreamingResponse: + """``client.integration.connect.with_streaming_response``.""" + return IntegrationConnectResourceWithStreamingResponse(self._resource.connect) + + @cached_property + def oauth(self) -> IntegrationOauthResourceWithStreamingResponse: + """``client.integration.oauth.with_streaming_response``.""" + return IntegrationOauthResourceWithStreamingResponse(self._resource.oauth) + + @cached_property + def command(self) -> IntegrationCommandResourceWithStreamingResponse: + """``client.integration.command.with_streaming_response``.""" + return IntegrationCommandResourceWithStreamingResponse(self._resource.command) + + class AsyncIntegrationWellknownResource(AsyncAPIResource): """Operations under ``client.integration.wellknown`` (OpenCode ``integration.wellknown``).""" + @cached_property + def with_raw_response(self) -> AsyncIntegrationWellknownResourceWithRawResponse: + """Same methods, returning the raw HTTP response; call ``.parse()`` on it for the usual value.""" + return AsyncIntegrationWellknownResourceWithRawResponse(self) + + @cached_property + def with_streaming_response(self) -> AsyncIntegrationWellknownResourceWithStreamingResponse: + """Same methods, returning a context manager over the HTTP response without reading the body.""" + return AsyncIntegrationWellknownResourceWithStreamingResponse(self) + async def add( self, *, @@ -558,24 +776,53 @@ async def add( ``POST /api/experimental/integration/wellknown`` """ - await self._client.request( - RequestOptions( - method="POST", - path="/api/experimental/integration/wellknown", - query={"location": self._location(location)}, - body={"url": url}, - extra_headers=extra_headers, - extra_query=extra_query, - extra_body=extra_body, - timeout=timeout, + return cast( + "None", + await self._client.request( + RequestOptions( + method="POST", + path="/api/experimental/integration/wellknown", + query={"location": self._location(location)}, + body={"url": url}, + extra_headers=extra_headers, + extra_query=extra_query, + extra_body=extra_body, + timeout=timeout, + ), + kind="void", ), - kind="void", ) +class AsyncIntegrationWellknownResourceWithRawResponse: + """``client.integration.wellknown.with_raw_response``.""" + + def __init__(self, resource: AsyncIntegrationWellknownResource) -> None: + self._resource = resource + self.add = async_to_raw_response_wrapper(resource.add) + + +class AsyncIntegrationWellknownResourceWithStreamingResponse: + """``client.integration.wellknown.with_streaming_response``.""" + + def __init__(self, resource: AsyncIntegrationWellknownResource) -> None: + self._resource = resource + self.add = async_to_streamed_response_wrapper(resource.add) + + class AsyncIntegrationConnectResource(AsyncAPIResource): """Operations under ``client.integration.connect`` (OpenCode ``integration.connect``).""" + @cached_property + def with_raw_response(self) -> AsyncIntegrationConnectResourceWithRawResponse: + """Same methods, returning the raw HTTP response; call ``.parse()`` on it for the usual value.""" + return AsyncIntegrationConnectResourceWithRawResponse(self) + + @cached_property + def with_streaming_response(self) -> AsyncIntegrationConnectResourceWithStreamingResponse: + """Same methods, returning a context manager over the HTTP response without reading the body.""" + return AsyncIntegrationConnectResourceWithStreamingResponse(self) + async def key( self, integration_id: IntegrationID, @@ -601,18 +848,21 @@ async def key( ``POST /api/integration/:integrationID/connect/key`` """ - await self._client.request( - RequestOptions( - method="POST", - path=f"/api/integration/{encode_path_segment(integration_id)}/connect/key", - query={"location": self._location(location)}, - body={"key": key, "answer": answer, "label": label}, - extra_headers=extra_headers, - extra_query=extra_query, - extra_body=extra_body, - timeout=timeout, + return cast( + "None", + await self._client.request( + RequestOptions( + method="POST", + path=f"/api/integration/{encode_path_segment(integration_id)}/connect/key", + query={"location": self._location(location)}, + body={"key": key, "answer": answer, "label": label}, + extra_headers=extra_headers, + extra_query=extra_query, + extra_body=extra_body, + timeout=timeout, + ), + kind="void", ), - kind="void", ) async def external( @@ -640,24 +890,55 @@ async def external( ``POST /api/integration/:integrationID/connect/external`` """ - await self._client.request( - RequestOptions( - method="POST", - path=f"/api/integration/{encode_path_segment(integration_id)}/connect/external", - query={"location": self._location(location)}, - body={"methodID": method_id, "answer": answer, "label": label}, - extra_headers=extra_headers, - extra_query=extra_query, - extra_body=extra_body, - timeout=timeout, + return cast( + "None", + await self._client.request( + RequestOptions( + method="POST", + path=f"/api/integration/{encode_path_segment(integration_id)}/connect/external", + query={"location": self._location(location)}, + body={"methodID": method_id, "answer": answer, "label": label}, + extra_headers=extra_headers, + extra_query=extra_query, + extra_body=extra_body, + timeout=timeout, + ), + kind="void", ), - kind="void", ) +class AsyncIntegrationConnectResourceWithRawResponse: + """``client.integration.connect.with_raw_response``.""" + + def __init__(self, resource: AsyncIntegrationConnectResource) -> None: + self._resource = resource + self.key = async_to_raw_response_wrapper(resource.key) + self.external = async_to_raw_response_wrapper(resource.external) + + +class AsyncIntegrationConnectResourceWithStreamingResponse: + """``client.integration.connect.with_streaming_response``.""" + + def __init__(self, resource: AsyncIntegrationConnectResource) -> None: + self._resource = resource + self.key = async_to_streamed_response_wrapper(resource.key) + self.external = async_to_streamed_response_wrapper(resource.external) + + class AsyncIntegrationOauthResource(AsyncAPIResource): """Operations under ``client.integration.oauth`` (OpenCode ``integration.oauth``).""" + @cached_property + def with_raw_response(self) -> AsyncIntegrationOauthResourceWithRawResponse: + """Same methods, returning the raw HTTP response; call ``.parse()`` on it for the usual value.""" + return AsyncIntegrationOauthResourceWithRawResponse(self) + + @cached_property + def with_streaming_response(self) -> AsyncIntegrationOauthResourceWithStreamingResponse: + """Same methods, returning a context manager over the HTTP response without reading the body.""" + return AsyncIntegrationOauthResourceWithStreamingResponse(self) + async def connect( self, integration_id: IntegrationID, @@ -764,18 +1045,21 @@ async def complete( ``POST /api/integration/:integrationID/connect/oauth/:attemptID/complete`` """ - await self._client.request( - RequestOptions( - method="POST", - path=f"/api/integration/{encode_path_segment(integration_id)}/connect/oauth/{encode_path_segment(attempt_id)}/complete", - query={"location": self._location(location)}, - body={"code": code}, - extra_headers=extra_headers, - extra_query=extra_query, - extra_body=extra_body, - timeout=timeout, + return cast( + "None", + await self._client.request( + RequestOptions( + method="POST", + path=f"/api/integration/{encode_path_segment(integration_id)}/connect/oauth/{encode_path_segment(attempt_id)}/complete", + query={"location": self._location(location)}, + body={"code": code}, + extra_headers=extra_headers, + extra_query=extra_query, + extra_body=extra_body, + timeout=timeout, + ), + kind="void", ), - kind="void", ) async def cancel( @@ -800,23 +1084,58 @@ async def cancel( ``DELETE /api/integration/:integrationID/connect/oauth/:attemptID`` """ - await self._client.request( - RequestOptions( - method="DELETE", - path=f"/api/integration/{encode_path_segment(integration_id)}/connect/oauth/{encode_path_segment(attempt_id)}", - query={"location": self._location(location)}, - extra_headers=extra_headers, - extra_query=extra_query, - extra_body=extra_body, - timeout=timeout, + return cast( + "None", + await self._client.request( + RequestOptions( + method="DELETE", + path=f"/api/integration/{encode_path_segment(integration_id)}/connect/oauth/{encode_path_segment(attempt_id)}", + query={"location": self._location(location)}, + extra_headers=extra_headers, + extra_query=extra_query, + extra_body=extra_body, + timeout=timeout, + ), + kind="void", ), - kind="void", ) +class AsyncIntegrationOauthResourceWithRawResponse: + """``client.integration.oauth.with_raw_response``.""" + + def __init__(self, resource: AsyncIntegrationOauthResource) -> None: + self._resource = resource + self.connect = async_to_raw_response_wrapper(resource.connect) + self.status = async_to_raw_response_wrapper(resource.status) + self.complete = async_to_raw_response_wrapper(resource.complete) + self.cancel = async_to_raw_response_wrapper(resource.cancel) + + +class AsyncIntegrationOauthResourceWithStreamingResponse: + """``client.integration.oauth.with_streaming_response``.""" + + def __init__(self, resource: AsyncIntegrationOauthResource) -> None: + self._resource = resource + self.connect = async_to_streamed_response_wrapper(resource.connect) + self.status = async_to_streamed_response_wrapper(resource.status) + self.complete = async_to_streamed_response_wrapper(resource.complete) + self.cancel = async_to_streamed_response_wrapper(resource.cancel) + + class AsyncIntegrationCommandResource(AsyncAPIResource): """Operations under ``client.integration.command`` (OpenCode ``integration.command``).""" + @cached_property + def with_raw_response(self) -> AsyncIntegrationCommandResourceWithRawResponse: + """Same methods, returning the raw HTTP response; call ``.parse()`` on it for the usual value.""" + return AsyncIntegrationCommandResourceWithRawResponse(self) + + @cached_property + def with_streaming_response(self) -> AsyncIntegrationCommandResourceWithStreamingResponse: + """Same methods, returning a context manager over the HTTP response without reading the body.""" + return AsyncIntegrationCommandResourceWithStreamingResponse(self) + async def connect( self, integration_id: IntegrationID, @@ -921,20 +1240,43 @@ async def cancel( ``DELETE /api/integration/:integrationID/connect/command/:attemptID`` """ - await self._client.request( - RequestOptions( - method="DELETE", - path=f"/api/integration/{encode_path_segment(integration_id)}/connect/command/{encode_path_segment(attempt_id)}", - query={"location": self._location(location)}, - extra_headers=extra_headers, - extra_query=extra_query, - extra_body=extra_body, - timeout=timeout, + return cast( + "None", + await self._client.request( + RequestOptions( + method="DELETE", + path=f"/api/integration/{encode_path_segment(integration_id)}/connect/command/{encode_path_segment(attempt_id)}", + query={"location": self._location(location)}, + extra_headers=extra_headers, + extra_query=extra_query, + extra_body=extra_body, + timeout=timeout, + ), + kind="void", ), - kind="void", ) +class AsyncIntegrationCommandResourceWithRawResponse: + """``client.integration.command.with_raw_response``.""" + + def __init__(self, resource: AsyncIntegrationCommandResource) -> None: + self._resource = resource + self.connect = async_to_raw_response_wrapper(resource.connect) + self.status = async_to_raw_response_wrapper(resource.status) + self.cancel = async_to_raw_response_wrapper(resource.cancel) + + +class AsyncIntegrationCommandResourceWithStreamingResponse: + """``client.integration.command.with_streaming_response``.""" + + def __init__(self, resource: AsyncIntegrationCommandResource) -> None: + self._resource = resource + self.connect = async_to_streamed_response_wrapper(resource.connect) + self.status = async_to_streamed_response_wrapper(resource.status) + self.cancel = async_to_streamed_response_wrapper(resource.cancel) + + class AsyncIntegrationResource(AsyncAPIResource): """Operations under ``client.integration`` (OpenCode ``integration``).""" @@ -958,6 +1300,16 @@ def command(self) -> AsyncIntegrationCommandResource: """Operations under ``client.integration.command``.""" return AsyncIntegrationCommandResource(self._client) + @cached_property + def with_raw_response(self) -> AsyncIntegrationResourceWithRawResponse: + """Same methods, returning the raw HTTP response; call ``.parse()`` on it for the usual value.""" + return AsyncIntegrationResourceWithRawResponse(self) + + @cached_property + def with_streaming_response(self) -> AsyncIntegrationResourceWithStreamingResponse: + """Same methods, returning a context manager over the HTTP response without reading the body.""" + return AsyncIntegrationResourceWithStreamingResponse(self) + async def list( self, *, @@ -1031,3 +1383,61 @@ async def get( response_type="IntegrationGetResponse", ), ) + + +class AsyncIntegrationResourceWithRawResponse: + """``client.integration.with_raw_response``.""" + + def __init__(self, resource: AsyncIntegrationResource) -> None: + self._resource = resource + self.list = async_to_raw_response_wrapper(resource.list) + self.get = async_to_raw_response_wrapper(resource.get) + + @cached_property + def wellknown(self) -> AsyncIntegrationWellknownResourceWithRawResponse: + """``client.integration.wellknown.with_raw_response``.""" + return AsyncIntegrationWellknownResourceWithRawResponse(self._resource.wellknown) + + @cached_property + def connect(self) -> AsyncIntegrationConnectResourceWithRawResponse: + """``client.integration.connect.with_raw_response``.""" + return AsyncIntegrationConnectResourceWithRawResponse(self._resource.connect) + + @cached_property + def oauth(self) -> AsyncIntegrationOauthResourceWithRawResponse: + """``client.integration.oauth.with_raw_response``.""" + return AsyncIntegrationOauthResourceWithRawResponse(self._resource.oauth) + + @cached_property + def command(self) -> AsyncIntegrationCommandResourceWithRawResponse: + """``client.integration.command.with_raw_response``.""" + return AsyncIntegrationCommandResourceWithRawResponse(self._resource.command) + + +class AsyncIntegrationResourceWithStreamingResponse: + """``client.integration.with_streaming_response``.""" + + def __init__(self, resource: AsyncIntegrationResource) -> None: + self._resource = resource + self.list = async_to_streamed_response_wrapper(resource.list) + self.get = async_to_streamed_response_wrapper(resource.get) + + @cached_property + def wellknown(self) -> AsyncIntegrationWellknownResourceWithStreamingResponse: + """``client.integration.wellknown.with_streaming_response``.""" + return AsyncIntegrationWellknownResourceWithStreamingResponse(self._resource.wellknown) + + @cached_property + def connect(self) -> AsyncIntegrationConnectResourceWithStreamingResponse: + """``client.integration.connect.with_streaming_response``.""" + return AsyncIntegrationConnectResourceWithStreamingResponse(self._resource.connect) + + @cached_property + def oauth(self) -> AsyncIntegrationOauthResourceWithStreamingResponse: + """``client.integration.oauth.with_streaming_response``.""" + return AsyncIntegrationOauthResourceWithStreamingResponse(self._resource.oauth) + + @cached_property + def command(self) -> AsyncIntegrationCommandResourceWithStreamingResponse: + """``client.integration.command.with_streaming_response``.""" + return AsyncIntegrationCommandResourceWithStreamingResponse(self._resource.command) diff --git a/src/opencode/resources/location.py b/src/opencode/resources/location.py index 1a54f18..9f819da 100644 --- a/src/opencode/resources/location.py +++ b/src/opencode/resources/location.py @@ -5,10 +5,17 @@ from __future__ import annotations +from functools import cached_property from typing import TYPE_CHECKING, cast from .._base_client import RequestOptions from .._resource import AsyncAPIResource, SyncAPIResource +from .._response import ( + async_to_raw_response_wrapper, + async_to_streamed_response_wrapper, + to_raw_response_wrapper, + to_streamed_response_wrapper, +) from .._types import NOT_GIVEN, Body, Headers, NotGiven, Query, Timeout if TYPE_CHECKING: @@ -23,6 +30,16 @@ class LocationResource(SyncAPIResource): """Operations under ``client.location`` (OpenCode ``location``).""" + @cached_property + def with_raw_response(self) -> LocationResourceWithRawResponse: + """Same methods, returning the raw HTTP response; call ``.parse()`` on it for the usual value.""" + return LocationResourceWithRawResponse(self) + + @cached_property + def with_streaming_response(self) -> LocationResourceWithStreamingResponse: + """Same methods, returning a context manager over the HTTP response without reading the body.""" + return LocationResourceWithStreamingResponse(self) + def get( self, *, @@ -78,22 +95,53 @@ def reload( ``POST /api/location/reload`` """ - self._client.request( - RequestOptions( - method="POST", - path="/api/location/reload", - extra_headers=extra_headers, - extra_query=extra_query, - extra_body=extra_body, - timeout=timeout, + return cast( + "None", + self._client.request( + RequestOptions( + method="POST", + path="/api/location/reload", + extra_headers=extra_headers, + extra_query=extra_query, + extra_body=extra_body, + timeout=timeout, + ), + kind="void", ), - kind="void", ) +class LocationResourceWithRawResponse: + """``client.location.with_raw_response``.""" + + def __init__(self, resource: LocationResource) -> None: + self._resource = resource + self.get = to_raw_response_wrapper(resource.get) + self.reload = to_raw_response_wrapper(resource.reload) + + +class LocationResourceWithStreamingResponse: + """``client.location.with_streaming_response``.""" + + def __init__(self, resource: LocationResource) -> None: + self._resource = resource + self.get = to_streamed_response_wrapper(resource.get) + self.reload = to_streamed_response_wrapper(resource.reload) + + class AsyncLocationResource(AsyncAPIResource): """Operations under ``client.location`` (OpenCode ``location``).""" + @cached_property + def with_raw_response(self) -> AsyncLocationResourceWithRawResponse: + """Same methods, returning the raw HTTP response; call ``.parse()`` on it for the usual value.""" + return AsyncLocationResourceWithRawResponse(self) + + @cached_property + def with_streaming_response(self) -> AsyncLocationResourceWithStreamingResponse: + """Same methods, returning a context manager over the HTTP response without reading the body.""" + return AsyncLocationResourceWithStreamingResponse(self) + async def get( self, *, @@ -149,14 +197,35 @@ async def reload( ``POST /api/location/reload`` """ - await self._client.request( - RequestOptions( - method="POST", - path="/api/location/reload", - extra_headers=extra_headers, - extra_query=extra_query, - extra_body=extra_body, - timeout=timeout, + return cast( + "None", + await self._client.request( + RequestOptions( + method="POST", + path="/api/location/reload", + extra_headers=extra_headers, + extra_query=extra_query, + extra_body=extra_body, + timeout=timeout, + ), + kind="void", ), - kind="void", ) + + +class AsyncLocationResourceWithRawResponse: + """``client.location.with_raw_response``.""" + + def __init__(self, resource: AsyncLocationResource) -> None: + self._resource = resource + self.get = async_to_raw_response_wrapper(resource.get) + self.reload = async_to_raw_response_wrapper(resource.reload) + + +class AsyncLocationResourceWithStreamingResponse: + """``client.location.with_streaming_response``.""" + + def __init__(self, resource: AsyncLocationResource) -> None: + self._resource = resource + self.get = async_to_streamed_response_wrapper(resource.get) + self.reload = async_to_streamed_response_wrapper(resource.reload) diff --git a/src/opencode/resources/mcp.py b/src/opencode/resources/mcp.py index 5d8d6e5..4f60a15 100644 --- a/src/opencode/resources/mcp.py +++ b/src/opencode/resources/mcp.py @@ -11,6 +11,12 @@ from .._base_client import RequestOptions from .._qs import encode_path_segment from .._resource import AsyncAPIResource, SyncAPIResource +from .._response import ( + async_to_raw_response_wrapper, + async_to_streamed_response_wrapper, + to_raw_response_wrapper, + to_streamed_response_wrapper, +) from .._types import NOT_GIVEN, Body, Headers, NotGiven, Query, Timeout if TYPE_CHECKING: @@ -27,6 +33,16 @@ class McpResourceResource(SyncAPIResource): """Operations under ``client.mcp.resource`` (OpenCode ``mcp.resource``).""" + @cached_property + def with_raw_response(self) -> McpResourceResourceWithRawResponse: + """Same methods, returning the raw HTTP response; call ``.parse()`` on it for the usual value.""" + return McpResourceResourceWithRawResponse(self) + + @cached_property + def with_streaming_response(self) -> McpResourceResourceWithStreamingResponse: + """Same methods, returning a context manager over the HTTP response without reading the body.""" + return McpResourceResourceWithStreamingResponse(self) + def catalog( self, *, @@ -64,6 +80,22 @@ def catalog( ) +class McpResourceResourceWithRawResponse: + """``client.mcp.resource.with_raw_response``.""" + + def __init__(self, resource: McpResourceResource) -> None: + self._resource = resource + self.catalog = to_raw_response_wrapper(resource.catalog) + + +class McpResourceResourceWithStreamingResponse: + """``client.mcp.resource.with_streaming_response``.""" + + def __init__(self, resource: McpResourceResource) -> None: + self._resource = resource + self.catalog = to_streamed_response_wrapper(resource.catalog) + + class McpResource(SyncAPIResource): """Operations under ``client.mcp`` (OpenCode ``mcp``).""" @@ -72,6 +104,16 @@ def resource(self) -> McpResourceResource: """Operations under ``client.mcp.resource``.""" return McpResourceResource(self._client) + @cached_property + def with_raw_response(self) -> McpResourceWithRawResponse: + """Same methods, returning the raw HTTP response; call ``.parse()`` on it for the usual value.""" + return McpResourceWithRawResponse(self) + + @cached_property + def with_streaming_response(self) -> McpResourceWithStreamingResponse: + """Same methods, returning a context manager over the HTTP response without reading the body.""" + return McpResourceWithStreamingResponse(self) + def list( self, *, @@ -132,18 +174,21 @@ def add( ``PUT /api/experimental/mcp/:server`` """ - self._client.request( - RequestOptions( - method="PUT", - path=f"/api/experimental/mcp/{encode_path_segment(server)}", - query={"location": self._location(location)}, - body={"config": config}, - extra_headers=extra_headers, - extra_query=extra_query, - extra_body=extra_body, - timeout=timeout, + return cast( + "None", + self._client.request( + RequestOptions( + method="PUT", + path=f"/api/experimental/mcp/{encode_path_segment(server)}", + query={"location": self._location(location)}, + body={"config": config}, + extra_headers=extra_headers, + extra_query=extra_query, + extra_body=extra_body, + timeout=timeout, + ), + kind="void", ), - kind="void", ) def remove( @@ -170,17 +215,20 @@ def remove( ``DELETE /api/experimental/mcp/:server`` """ - self._client.request( - RequestOptions( - method="DELETE", - path=f"/api/experimental/mcp/{encode_path_segment(server)}", - query={"location": self._location(location)}, - extra_headers=extra_headers, - extra_query=extra_query, - extra_body=extra_body, - timeout=timeout, + return cast( + "None", + self._client.request( + RequestOptions( + method="DELETE", + path=f"/api/experimental/mcp/{encode_path_segment(server)}", + query={"location": self._location(location)}, + extra_headers=extra_headers, + extra_query=extra_query, + extra_body=extra_body, + timeout=timeout, + ), + kind="void", ), - kind="void", ) def connect( @@ -207,17 +255,20 @@ def connect( ``POST /api/experimental/mcp/:server/connect`` """ - self._client.request( - RequestOptions( - method="POST", - path=f"/api/experimental/mcp/{encode_path_segment(server)}/connect", - query={"location": self._location(location)}, - extra_headers=extra_headers, - extra_query=extra_query, - extra_body=extra_body, - timeout=timeout, + return cast( + "None", + self._client.request( + RequestOptions( + method="POST", + path=f"/api/experimental/mcp/{encode_path_segment(server)}/connect", + query={"location": self._location(location)}, + extra_headers=extra_headers, + extra_query=extra_query, + extra_body=extra_body, + timeout=timeout, + ), + kind="void", ), - kind="void", ) def disconnect( @@ -244,23 +295,70 @@ def disconnect( ``POST /api/experimental/mcp/:server/disconnect`` """ - self._client.request( - RequestOptions( - method="POST", - path=f"/api/experimental/mcp/{encode_path_segment(server)}/disconnect", - query={"location": self._location(location)}, - extra_headers=extra_headers, - extra_query=extra_query, - extra_body=extra_body, - timeout=timeout, + return cast( + "None", + self._client.request( + RequestOptions( + method="POST", + path=f"/api/experimental/mcp/{encode_path_segment(server)}/disconnect", + query={"location": self._location(location)}, + extra_headers=extra_headers, + extra_query=extra_query, + extra_body=extra_body, + timeout=timeout, + ), + kind="void", ), - kind="void", ) +class McpResourceWithRawResponse: + """``client.mcp.with_raw_response``.""" + + def __init__(self, resource: McpResource) -> None: + self._resource = resource + self.list = to_raw_response_wrapper(resource.list) + self.add = to_raw_response_wrapper(resource.add) + self.remove = to_raw_response_wrapper(resource.remove) + self.connect = to_raw_response_wrapper(resource.connect) + self.disconnect = to_raw_response_wrapper(resource.disconnect) + + @cached_property + def resource(self) -> McpResourceResourceWithRawResponse: + """``client.mcp.resource.with_raw_response``.""" + return McpResourceResourceWithRawResponse(self._resource.resource) + + +class McpResourceWithStreamingResponse: + """``client.mcp.with_streaming_response``.""" + + def __init__(self, resource: McpResource) -> None: + self._resource = resource + self.list = to_streamed_response_wrapper(resource.list) + self.add = to_streamed_response_wrapper(resource.add) + self.remove = to_streamed_response_wrapper(resource.remove) + self.connect = to_streamed_response_wrapper(resource.connect) + self.disconnect = to_streamed_response_wrapper(resource.disconnect) + + @cached_property + def resource(self) -> McpResourceResourceWithStreamingResponse: + """``client.mcp.resource.with_streaming_response``.""" + return McpResourceResourceWithStreamingResponse(self._resource.resource) + + class AsyncMcpResourceResource(AsyncAPIResource): """Operations under ``client.mcp.resource`` (OpenCode ``mcp.resource``).""" + @cached_property + def with_raw_response(self) -> AsyncMcpResourceResourceWithRawResponse: + """Same methods, returning the raw HTTP response; call ``.parse()`` on it for the usual value.""" + return AsyncMcpResourceResourceWithRawResponse(self) + + @cached_property + def with_streaming_response(self) -> AsyncMcpResourceResourceWithStreamingResponse: + """Same methods, returning a context manager over the HTTP response without reading the body.""" + return AsyncMcpResourceResourceWithStreamingResponse(self) + async def catalog( self, *, @@ -298,6 +396,22 @@ async def catalog( ) +class AsyncMcpResourceResourceWithRawResponse: + """``client.mcp.resource.with_raw_response``.""" + + def __init__(self, resource: AsyncMcpResourceResource) -> None: + self._resource = resource + self.catalog = async_to_raw_response_wrapper(resource.catalog) + + +class AsyncMcpResourceResourceWithStreamingResponse: + """``client.mcp.resource.with_streaming_response``.""" + + def __init__(self, resource: AsyncMcpResourceResource) -> None: + self._resource = resource + self.catalog = async_to_streamed_response_wrapper(resource.catalog) + + class AsyncMcpResource(AsyncAPIResource): """Operations under ``client.mcp`` (OpenCode ``mcp``).""" @@ -306,6 +420,16 @@ def resource(self) -> AsyncMcpResourceResource: """Operations under ``client.mcp.resource``.""" return AsyncMcpResourceResource(self._client) + @cached_property + def with_raw_response(self) -> AsyncMcpResourceWithRawResponse: + """Same methods, returning the raw HTTP response; call ``.parse()`` on it for the usual value.""" + return AsyncMcpResourceWithRawResponse(self) + + @cached_property + def with_streaming_response(self) -> AsyncMcpResourceWithStreamingResponse: + """Same methods, returning a context manager over the HTTP response without reading the body.""" + return AsyncMcpResourceWithStreamingResponse(self) + async def list( self, *, @@ -366,18 +490,21 @@ async def add( ``PUT /api/experimental/mcp/:server`` """ - await self._client.request( - RequestOptions( - method="PUT", - path=f"/api/experimental/mcp/{encode_path_segment(server)}", - query={"location": self._location(location)}, - body={"config": config}, - extra_headers=extra_headers, - extra_query=extra_query, - extra_body=extra_body, - timeout=timeout, + return cast( + "None", + await self._client.request( + RequestOptions( + method="PUT", + path=f"/api/experimental/mcp/{encode_path_segment(server)}", + query={"location": self._location(location)}, + body={"config": config}, + extra_headers=extra_headers, + extra_query=extra_query, + extra_body=extra_body, + timeout=timeout, + ), + kind="void", ), - kind="void", ) async def remove( @@ -404,17 +531,20 @@ async def remove( ``DELETE /api/experimental/mcp/:server`` """ - await self._client.request( - RequestOptions( - method="DELETE", - path=f"/api/experimental/mcp/{encode_path_segment(server)}", - query={"location": self._location(location)}, - extra_headers=extra_headers, - extra_query=extra_query, - extra_body=extra_body, - timeout=timeout, + return cast( + "None", + await self._client.request( + RequestOptions( + method="DELETE", + path=f"/api/experimental/mcp/{encode_path_segment(server)}", + query={"location": self._location(location)}, + extra_headers=extra_headers, + extra_query=extra_query, + extra_body=extra_body, + timeout=timeout, + ), + kind="void", ), - kind="void", ) async def connect( @@ -441,17 +571,20 @@ async def connect( ``POST /api/experimental/mcp/:server/connect`` """ - await self._client.request( - RequestOptions( - method="POST", - path=f"/api/experimental/mcp/{encode_path_segment(server)}/connect", - query={"location": self._location(location)}, - extra_headers=extra_headers, - extra_query=extra_query, - extra_body=extra_body, - timeout=timeout, + return cast( + "None", + await self._client.request( + RequestOptions( + method="POST", + path=f"/api/experimental/mcp/{encode_path_segment(server)}/connect", + query={"location": self._location(location)}, + extra_headers=extra_headers, + extra_query=extra_query, + extra_body=extra_body, + timeout=timeout, + ), + kind="void", ), - kind="void", ) async def disconnect( @@ -478,15 +611,52 @@ async def disconnect( ``POST /api/experimental/mcp/:server/disconnect`` """ - await self._client.request( - RequestOptions( - method="POST", - path=f"/api/experimental/mcp/{encode_path_segment(server)}/disconnect", - query={"location": self._location(location)}, - extra_headers=extra_headers, - extra_query=extra_query, - extra_body=extra_body, - timeout=timeout, + return cast( + "None", + await self._client.request( + RequestOptions( + method="POST", + path=f"/api/experimental/mcp/{encode_path_segment(server)}/disconnect", + query={"location": self._location(location)}, + extra_headers=extra_headers, + extra_query=extra_query, + extra_body=extra_body, + timeout=timeout, + ), + kind="void", ), - kind="void", ) + + +class AsyncMcpResourceWithRawResponse: + """``client.mcp.with_raw_response``.""" + + def __init__(self, resource: AsyncMcpResource) -> None: + self._resource = resource + self.list = async_to_raw_response_wrapper(resource.list) + self.add = async_to_raw_response_wrapper(resource.add) + self.remove = async_to_raw_response_wrapper(resource.remove) + self.connect = async_to_raw_response_wrapper(resource.connect) + self.disconnect = async_to_raw_response_wrapper(resource.disconnect) + + @cached_property + def resource(self) -> AsyncMcpResourceResourceWithRawResponse: + """``client.mcp.resource.with_raw_response``.""" + return AsyncMcpResourceResourceWithRawResponse(self._resource.resource) + + +class AsyncMcpResourceWithStreamingResponse: + """``client.mcp.with_streaming_response``.""" + + def __init__(self, resource: AsyncMcpResource) -> None: + self._resource = resource + self.list = async_to_streamed_response_wrapper(resource.list) + self.add = async_to_streamed_response_wrapper(resource.add) + self.remove = async_to_streamed_response_wrapper(resource.remove) + self.connect = async_to_streamed_response_wrapper(resource.connect) + self.disconnect = async_to_streamed_response_wrapper(resource.disconnect) + + @cached_property + def resource(self) -> AsyncMcpResourceResourceWithStreamingResponse: + """``client.mcp.resource.with_streaming_response``.""" + return AsyncMcpResourceResourceWithStreamingResponse(self._resource.resource) diff --git a/src/opencode/resources/message.py b/src/opencode/resources/message.py index f3e257b..9972f88 100644 --- a/src/opencode/resources/message.py +++ b/src/opencode/resources/message.py @@ -5,12 +5,19 @@ from __future__ import annotations +from functools import cached_property from typing import TYPE_CHECKING, Literal from .._base_client import RequestOptions from .._pagination import AsyncPaginator, SyncCursorPage from .._qs import encode_path_segment from .._resource import AsyncAPIResource, SyncAPIResource +from .._response import ( + async_to_raw_response_wrapper, + async_to_streamed_response_wrapper, + to_raw_response_wrapper, + to_streamed_response_wrapper, +) from .._types import NOT_GIVEN, Body, Headers, NotGiven, OpenEnum, Query, Timeout if TYPE_CHECKING: @@ -25,6 +32,16 @@ class MessageResource(SyncAPIResource): """Operations under ``client.message`` (OpenCode ``message``).""" + @cached_property + def with_raw_response(self) -> MessageResourceWithRawResponse: + """Same methods, returning the raw HTTP response; call ``.parse()`` on it for the usual value.""" + return MessageResourceWithRawResponse(self) + + @cached_property + def with_streaming_response(self) -> MessageResourceWithStreamingResponse: + """Same methods, returning a context manager over the HTTP response without reading the body.""" + return MessageResourceWithStreamingResponse(self) + def list( self, session_id: SessionID, @@ -87,9 +104,35 @@ def list( ) +class MessageResourceWithRawResponse: + """``client.message.with_raw_response``.""" + + def __init__(self, resource: MessageResource) -> None: + self._resource = resource + self.list = to_raw_response_wrapper(resource.list) + + +class MessageResourceWithStreamingResponse: + """``client.message.with_streaming_response``.""" + + def __init__(self, resource: MessageResource) -> None: + self._resource = resource + self.list = to_streamed_response_wrapper(resource.list) + + class AsyncMessageResource(AsyncAPIResource): """Operations under ``client.message`` (OpenCode ``message``).""" + @cached_property + def with_raw_response(self) -> AsyncMessageResourceWithRawResponse: + """Same methods, returning the raw HTTP response; call ``.parse()`` on it for the usual value.""" + return AsyncMessageResourceWithRawResponse(self) + + @cached_property + def with_streaming_response(self) -> AsyncMessageResourceWithStreamingResponse: + """Same methods, returning a context manager over the HTTP response without reading the body.""" + return AsyncMessageResourceWithStreamingResponse(self) + def list( self, session_id: SessionID, @@ -150,3 +193,19 @@ def list( ), response_type="SessionMessagesResponse", ) + + +class AsyncMessageResourceWithRawResponse: + """``client.message.with_raw_response``.""" + + def __init__(self, resource: AsyncMessageResource) -> None: + self._resource = resource + self.list = async_to_raw_response_wrapper(resource.list) + + +class AsyncMessageResourceWithStreamingResponse: + """``client.message.with_streaming_response``.""" + + def __init__(self, resource: AsyncMessageResource) -> None: + self._resource = resource + self.list = async_to_streamed_response_wrapper(resource.list) diff --git a/src/opencode/resources/migration.py b/src/opencode/resources/migration.py index f4ed895..5fb8f43 100644 --- a/src/opencode/resources/migration.py +++ b/src/opencode/resources/migration.py @@ -10,6 +10,12 @@ from .._base_client import RequestOptions from .._resource import AsyncAPIResource, SyncAPIResource +from .._response import ( + async_to_raw_response_wrapper, + async_to_streamed_response_wrapper, + to_raw_response_wrapper, + to_streamed_response_wrapper, +) from .._types import NOT_GIVEN, Body, Headers, NotGiven, Query, Timeout if TYPE_CHECKING: @@ -25,6 +31,16 @@ class MigrationV1Resource(SyncAPIResource): """Operations under ``client.migration.v1`` (OpenCode ``migration.v1``).""" + @cached_property + def with_raw_response(self) -> MigrationV1ResourceWithRawResponse: + """Same methods, returning the raw HTTP response; call ``.parse()`` on it for the usual value.""" + return MigrationV1ResourceWithRawResponse(self) + + @cached_property + def with_streaming_response(self) -> MigrationV1ResourceWithStreamingResponse: + """Same methods, returning a context manager over the HTTP response without reading the body.""" + return MigrationV1ResourceWithStreamingResponse(self) + def status( self, *, @@ -61,6 +77,22 @@ def status( ) +class MigrationV1ResourceWithRawResponse: + """``client.migration.v1.with_raw_response``.""" + + def __init__(self, resource: MigrationV1Resource) -> None: + self._resource = resource + self.status = to_raw_response_wrapper(resource.status) + + +class MigrationV1ResourceWithStreamingResponse: + """``client.migration.v1.with_streaming_response``.""" + + def __init__(self, resource: MigrationV1Resource) -> None: + self._resource = resource + self.status = to_streamed_response_wrapper(resource.status) + + class MigrationResource(SyncAPIResource): """Operations under ``client.migration`` (OpenCode ``migration``).""" @@ -69,10 +101,54 @@ def v1(self) -> MigrationV1Resource: """Operations under ``client.migration.v1``.""" return MigrationV1Resource(self._client) + @cached_property + def with_raw_response(self) -> MigrationResourceWithRawResponse: + """Same methods, returning the raw HTTP response; call ``.parse()`` on it for the usual value.""" + return MigrationResourceWithRawResponse(self) + + @cached_property + def with_streaming_response(self) -> MigrationResourceWithStreamingResponse: + """Same methods, returning a context manager over the HTTP response without reading the body.""" + return MigrationResourceWithStreamingResponse(self) + + +class MigrationResourceWithRawResponse: + """``client.migration.with_raw_response``.""" + + def __init__(self, resource: MigrationResource) -> None: + self._resource = resource + + @cached_property + def v1(self) -> MigrationV1ResourceWithRawResponse: + """``client.migration.v1.with_raw_response``.""" + return MigrationV1ResourceWithRawResponse(self._resource.v1) + + +class MigrationResourceWithStreamingResponse: + """``client.migration.with_streaming_response``.""" + + def __init__(self, resource: MigrationResource) -> None: + self._resource = resource + + @cached_property + def v1(self) -> MigrationV1ResourceWithStreamingResponse: + """``client.migration.v1.with_streaming_response``.""" + return MigrationV1ResourceWithStreamingResponse(self._resource.v1) + class AsyncMigrationV1Resource(AsyncAPIResource): """Operations under ``client.migration.v1`` (OpenCode ``migration.v1``).""" + @cached_property + def with_raw_response(self) -> AsyncMigrationV1ResourceWithRawResponse: + """Same methods, returning the raw HTTP response; call ``.parse()`` on it for the usual value.""" + return AsyncMigrationV1ResourceWithRawResponse(self) + + @cached_property + def with_streaming_response(self) -> AsyncMigrationV1ResourceWithStreamingResponse: + """Same methods, returning a context manager over the HTTP response without reading the body.""" + return AsyncMigrationV1ResourceWithStreamingResponse(self) + async def status( self, *, @@ -109,6 +185,22 @@ async def status( ) +class AsyncMigrationV1ResourceWithRawResponse: + """``client.migration.v1.with_raw_response``.""" + + def __init__(self, resource: AsyncMigrationV1Resource) -> None: + self._resource = resource + self.status = async_to_raw_response_wrapper(resource.status) + + +class AsyncMigrationV1ResourceWithStreamingResponse: + """``client.migration.v1.with_streaming_response``.""" + + def __init__(self, resource: AsyncMigrationV1Resource) -> None: + self._resource = resource + self.status = async_to_streamed_response_wrapper(resource.status) + + class AsyncMigrationResource(AsyncAPIResource): """Operations under ``client.migration`` (OpenCode ``migration``).""" @@ -116,3 +208,37 @@ class AsyncMigrationResource(AsyncAPIResource): def v1(self) -> AsyncMigrationV1Resource: """Operations under ``client.migration.v1``.""" return AsyncMigrationV1Resource(self._client) + + @cached_property + def with_raw_response(self) -> AsyncMigrationResourceWithRawResponse: + """Same methods, returning the raw HTTP response; call ``.parse()`` on it for the usual value.""" + return AsyncMigrationResourceWithRawResponse(self) + + @cached_property + def with_streaming_response(self) -> AsyncMigrationResourceWithStreamingResponse: + """Same methods, returning a context manager over the HTTP response without reading the body.""" + return AsyncMigrationResourceWithStreamingResponse(self) + + +class AsyncMigrationResourceWithRawResponse: + """``client.migration.with_raw_response``.""" + + def __init__(self, resource: AsyncMigrationResource) -> None: + self._resource = resource + + @cached_property + def v1(self) -> AsyncMigrationV1ResourceWithRawResponse: + """``client.migration.v1.with_raw_response``.""" + return AsyncMigrationV1ResourceWithRawResponse(self._resource.v1) + + +class AsyncMigrationResourceWithStreamingResponse: + """``client.migration.with_streaming_response``.""" + + def __init__(self, resource: AsyncMigrationResource) -> None: + self._resource = resource + + @cached_property + def v1(self) -> AsyncMigrationV1ResourceWithStreamingResponse: + """``client.migration.v1.with_streaming_response``.""" + return AsyncMigrationV1ResourceWithStreamingResponse(self._resource.v1) diff --git a/src/opencode/resources/model.py b/src/opencode/resources/model.py index e2484b4..0e6656a 100644 --- a/src/opencode/resources/model.py +++ b/src/opencode/resources/model.py @@ -5,10 +5,17 @@ from __future__ import annotations +from functools import cached_property from typing import TYPE_CHECKING, cast from .._base_client import RequestOptions from .._resource import AsyncAPIResource, SyncAPIResource +from .._response import ( + async_to_raw_response_wrapper, + async_to_streamed_response_wrapper, + to_raw_response_wrapper, + to_streamed_response_wrapper, +) from .._types import NOT_GIVEN, Body, Headers, NotGiven, Query, Timeout if TYPE_CHECKING: @@ -24,6 +31,16 @@ class ModelResource(SyncAPIResource): """Operations under ``client.model`` (OpenCode ``model``).""" + @cached_property + def with_raw_response(self) -> ModelResourceWithRawResponse: + """Same methods, returning the raw HTTP response; call ``.parse()`` on it for the usual value.""" + return ModelResourceWithRawResponse(self) + + @cached_property + def with_streaming_response(self) -> ModelResourceWithStreamingResponse: + """Same methods, returning a context manager over the HTTP response without reading the body.""" + return ModelResourceWithStreamingResponse(self) + def list( self, *, @@ -99,9 +116,37 @@ def default( ) +class ModelResourceWithRawResponse: + """``client.model.with_raw_response``.""" + + def __init__(self, resource: ModelResource) -> None: + self._resource = resource + self.list = to_raw_response_wrapper(resource.list) + self.default = to_raw_response_wrapper(resource.default) + + +class ModelResourceWithStreamingResponse: + """``client.model.with_streaming_response``.""" + + def __init__(self, resource: ModelResource) -> None: + self._resource = resource + self.list = to_streamed_response_wrapper(resource.list) + self.default = to_streamed_response_wrapper(resource.default) + + class AsyncModelResource(AsyncAPIResource): """Operations under ``client.model`` (OpenCode ``model``).""" + @cached_property + def with_raw_response(self) -> AsyncModelResourceWithRawResponse: + """Same methods, returning the raw HTTP response; call ``.parse()`` on it for the usual value.""" + return AsyncModelResourceWithRawResponse(self) + + @cached_property + def with_streaming_response(self) -> AsyncModelResourceWithStreamingResponse: + """Same methods, returning a context manager over the HTTP response without reading the body.""" + return AsyncModelResourceWithStreamingResponse(self) + async def list( self, *, @@ -175,3 +220,21 @@ async def default( response_type="ModelDefaultResponse", ), ) + + +class AsyncModelResourceWithRawResponse: + """``client.model.with_raw_response``.""" + + def __init__(self, resource: AsyncModelResource) -> None: + self._resource = resource + self.list = async_to_raw_response_wrapper(resource.list) + self.default = async_to_raw_response_wrapper(resource.default) + + +class AsyncModelResourceWithStreamingResponse: + """``client.model.with_streaming_response``.""" + + def __init__(self, resource: AsyncModelResource) -> None: + self._resource = resource + self.list = async_to_streamed_response_wrapper(resource.list) + self.default = async_to_streamed_response_wrapper(resource.default) diff --git a/src/opencode/resources/permission.py b/src/opencode/resources/permission.py index 7c850af..df8d1e0 100644 --- a/src/opencode/resources/permission.py +++ b/src/opencode/resources/permission.py @@ -13,6 +13,12 @@ from .._base_client import RequestOptions from .._qs import encode_path_segment from .._resource import AsyncAPIResource, SyncAPIResource +from .._response import ( + async_to_raw_response_wrapper, + async_to_streamed_response_wrapper, + to_raw_response_wrapper, + to_streamed_response_wrapper, +) from .._types import NOT_GIVEN, Body, Headers, NotGiven, Query, Timeout if TYPE_CHECKING: @@ -37,6 +43,16 @@ class PermissionRequestResource(SyncAPIResource): """Operations under ``client.permission.request`` (OpenCode ``permission.request``).""" + @cached_property + def with_raw_response(self) -> PermissionRequestResourceWithRawResponse: + """Same methods, returning the raw HTTP response; call ``.parse()`` on it for the usual value.""" + return PermissionRequestResourceWithRawResponse(self) + + @cached_property + def with_streaming_response(self) -> PermissionRequestResourceWithStreamingResponse: + """Same methods, returning a context manager over the HTTP response without reading the body.""" + return PermissionRequestResourceWithStreamingResponse(self) + def list( self, *, @@ -74,9 +90,35 @@ def list( ) +class PermissionRequestResourceWithRawResponse: + """``client.permission.request.with_raw_response``.""" + + def __init__(self, resource: PermissionRequestResource) -> None: + self._resource = resource + self.list = to_raw_response_wrapper(resource.list) + + +class PermissionRequestResourceWithStreamingResponse: + """``client.permission.request.with_streaming_response``.""" + + def __init__(self, resource: PermissionRequestResource) -> None: + self._resource = resource + self.list = to_streamed_response_wrapper(resource.list) + + class PermissionSavedResource(SyncAPIResource): """Operations under ``client.permission.saved`` (OpenCode ``permission.saved``).""" + @cached_property + def with_raw_response(self) -> PermissionSavedResourceWithRawResponse: + """Same methods, returning the raw HTTP response; call ``.parse()`` on it for the usual value.""" + return PermissionSavedResourceWithRawResponse(self) + + @cached_property + def with_streaming_response(self) -> PermissionSavedResourceWithStreamingResponse: + """Same methods, returning a context manager over the HTTP response without reading the body.""" + return PermissionSavedResourceWithStreamingResponse(self) + def list( self, *, @@ -175,19 +217,42 @@ def remove( ``DELETE /api/permission/saved/:id`` """ - self._client.request( - RequestOptions( - method="DELETE", - path=f"/api/permission/saved/{encode_path_segment(id)}", - extra_headers=extra_headers, - extra_query=extra_query, - extra_body=extra_body, - timeout=timeout, + return cast( + "None", + self._client.request( + RequestOptions( + method="DELETE", + path=f"/api/permission/saved/{encode_path_segment(id)}", + extra_headers=extra_headers, + extra_query=extra_query, + extra_body=extra_body, + timeout=timeout, + ), + kind="void", ), - kind="void", ) +class PermissionSavedResourceWithRawResponse: + """``client.permission.saved.with_raw_response``.""" + + def __init__(self, resource: PermissionSavedResource) -> None: + self._resource = resource + self.list = to_raw_response_wrapper(resource.list) + self.update = to_raw_response_wrapper(resource.update) + self.remove = to_raw_response_wrapper(resource.remove) + + +class PermissionSavedResourceWithStreamingResponse: + """``client.permission.saved.with_streaming_response``.""" + + def __init__(self, resource: PermissionSavedResource) -> None: + self._resource = resource + self.list = to_streamed_response_wrapper(resource.list) + self.update = to_streamed_response_wrapper(resource.update) + self.remove = to_streamed_response_wrapper(resource.remove) + + class PermissionResource(SyncAPIResource): """Operations under ``client.permission`` (OpenCode ``permission``).""" @@ -201,6 +266,16 @@ def saved(self) -> PermissionSavedResource: """Operations under ``client.permission.saved``.""" return PermissionSavedResource(self._client) + @cached_property + def with_raw_response(self) -> PermissionResourceWithRawResponse: + """Same methods, returning the raw HTTP response; call ``.parse()`` on it for the usual value.""" + return PermissionResourceWithRawResponse(self) + + @cached_property + def with_streaming_response(self) -> PermissionResourceWithStreamingResponse: + """Same methods, returning a context manager over the HTTP response without reading the body.""" + return PermissionResourceWithStreamingResponse(self) + def create( self, session_id: SessionID, @@ -355,23 +430,78 @@ def reply( ``POST /api/session/:sessionID/permission/:requestID/reply`` """ - self._client.request( - RequestOptions( - method="POST", - path=f"/api/session/{encode_path_segment(session_id)}/permission/{encode_path_segment(request_id)}/reply", - body={"decision": decision, "message": message}, - extra_headers=extra_headers, - extra_query=extra_query, - extra_body=extra_body, - timeout=timeout, + return cast( + "None", + self._client.request( + RequestOptions( + method="POST", + path=f"/api/session/{encode_path_segment(session_id)}/permission/{encode_path_segment(request_id)}/reply", + body={"decision": decision, "message": message}, + extra_headers=extra_headers, + extra_query=extra_query, + extra_body=extra_body, + timeout=timeout, + ), + kind="void", ), - kind="void", ) +class PermissionResourceWithRawResponse: + """``client.permission.with_raw_response``.""" + + def __init__(self, resource: PermissionResource) -> None: + self._resource = resource + self.create = to_raw_response_wrapper(resource.create) + self.list = to_raw_response_wrapper(resource.list) + self.get = to_raw_response_wrapper(resource.get) + self.reply = to_raw_response_wrapper(resource.reply) + + @cached_property + def request_(self) -> PermissionRequestResourceWithRawResponse: + """``client.permission.request.with_raw_response``.""" + return PermissionRequestResourceWithRawResponse(self._resource.request_) + + @cached_property + def saved(self) -> PermissionSavedResourceWithRawResponse: + """``client.permission.saved.with_raw_response``.""" + return PermissionSavedResourceWithRawResponse(self._resource.saved) + + +class PermissionResourceWithStreamingResponse: + """``client.permission.with_streaming_response``.""" + + def __init__(self, resource: PermissionResource) -> None: + self._resource = resource + self.create = to_streamed_response_wrapper(resource.create) + self.list = to_streamed_response_wrapper(resource.list) + self.get = to_streamed_response_wrapper(resource.get) + self.reply = to_streamed_response_wrapper(resource.reply) + + @cached_property + def request_(self) -> PermissionRequestResourceWithStreamingResponse: + """``client.permission.request.with_streaming_response``.""" + return PermissionRequestResourceWithStreamingResponse(self._resource.request_) + + @cached_property + def saved(self) -> PermissionSavedResourceWithStreamingResponse: + """``client.permission.saved.with_streaming_response``.""" + return PermissionSavedResourceWithStreamingResponse(self._resource.saved) + + class AsyncPermissionRequestResource(AsyncAPIResource): """Operations under ``client.permission.request`` (OpenCode ``permission.request``).""" + @cached_property + def with_raw_response(self) -> AsyncPermissionRequestResourceWithRawResponse: + """Same methods, returning the raw HTTP response; call ``.parse()`` on it for the usual value.""" + return AsyncPermissionRequestResourceWithRawResponse(self) + + @cached_property + def with_streaming_response(self) -> AsyncPermissionRequestResourceWithStreamingResponse: + """Same methods, returning a context manager over the HTTP response without reading the body.""" + return AsyncPermissionRequestResourceWithStreamingResponse(self) + async def list( self, *, @@ -409,9 +539,35 @@ async def list( ) +class AsyncPermissionRequestResourceWithRawResponse: + """``client.permission.request.with_raw_response``.""" + + def __init__(self, resource: AsyncPermissionRequestResource) -> None: + self._resource = resource + self.list = async_to_raw_response_wrapper(resource.list) + + +class AsyncPermissionRequestResourceWithStreamingResponse: + """``client.permission.request.with_streaming_response``.""" + + def __init__(self, resource: AsyncPermissionRequestResource) -> None: + self._resource = resource + self.list = async_to_streamed_response_wrapper(resource.list) + + class AsyncPermissionSavedResource(AsyncAPIResource): """Operations under ``client.permission.saved`` (OpenCode ``permission.saved``).""" + @cached_property + def with_raw_response(self) -> AsyncPermissionSavedResourceWithRawResponse: + """Same methods, returning the raw HTTP response; call ``.parse()`` on it for the usual value.""" + return AsyncPermissionSavedResourceWithRawResponse(self) + + @cached_property + def with_streaming_response(self) -> AsyncPermissionSavedResourceWithStreamingResponse: + """Same methods, returning a context manager over the HTTP response without reading the body.""" + return AsyncPermissionSavedResourceWithStreamingResponse(self) + async def list( self, *, @@ -510,19 +666,42 @@ async def remove( ``DELETE /api/permission/saved/:id`` """ - await self._client.request( - RequestOptions( - method="DELETE", - path=f"/api/permission/saved/{encode_path_segment(id)}", - extra_headers=extra_headers, - extra_query=extra_query, - extra_body=extra_body, - timeout=timeout, + return cast( + "None", + await self._client.request( + RequestOptions( + method="DELETE", + path=f"/api/permission/saved/{encode_path_segment(id)}", + extra_headers=extra_headers, + extra_query=extra_query, + extra_body=extra_body, + timeout=timeout, + ), + kind="void", ), - kind="void", ) +class AsyncPermissionSavedResourceWithRawResponse: + """``client.permission.saved.with_raw_response``.""" + + def __init__(self, resource: AsyncPermissionSavedResource) -> None: + self._resource = resource + self.list = async_to_raw_response_wrapper(resource.list) + self.update = async_to_raw_response_wrapper(resource.update) + self.remove = async_to_raw_response_wrapper(resource.remove) + + +class AsyncPermissionSavedResourceWithStreamingResponse: + """``client.permission.saved.with_streaming_response``.""" + + def __init__(self, resource: AsyncPermissionSavedResource) -> None: + self._resource = resource + self.list = async_to_streamed_response_wrapper(resource.list) + self.update = async_to_streamed_response_wrapper(resource.update) + self.remove = async_to_streamed_response_wrapper(resource.remove) + + class AsyncPermissionResource(AsyncAPIResource): """Operations under ``client.permission`` (OpenCode ``permission``).""" @@ -536,6 +715,16 @@ def saved(self) -> AsyncPermissionSavedResource: """Operations under ``client.permission.saved``.""" return AsyncPermissionSavedResource(self._client) + @cached_property + def with_raw_response(self) -> AsyncPermissionResourceWithRawResponse: + """Same methods, returning the raw HTTP response; call ``.parse()`` on it for the usual value.""" + return AsyncPermissionResourceWithRawResponse(self) + + @cached_property + def with_streaming_response(self) -> AsyncPermissionResourceWithStreamingResponse: + """Same methods, returning a context manager over the HTTP response without reading the body.""" + return AsyncPermissionResourceWithStreamingResponse(self) + async def create( self, session_id: SessionID, @@ -690,15 +879,60 @@ async def reply( ``POST /api/session/:sessionID/permission/:requestID/reply`` """ - await self._client.request( - RequestOptions( - method="POST", - path=f"/api/session/{encode_path_segment(session_id)}/permission/{encode_path_segment(request_id)}/reply", - body={"decision": decision, "message": message}, - extra_headers=extra_headers, - extra_query=extra_query, - extra_body=extra_body, - timeout=timeout, + return cast( + "None", + await self._client.request( + RequestOptions( + method="POST", + path=f"/api/session/{encode_path_segment(session_id)}/permission/{encode_path_segment(request_id)}/reply", + body={"decision": decision, "message": message}, + extra_headers=extra_headers, + extra_query=extra_query, + extra_body=extra_body, + timeout=timeout, + ), + kind="void", ), - kind="void", ) + + +class AsyncPermissionResourceWithRawResponse: + """``client.permission.with_raw_response``.""" + + def __init__(self, resource: AsyncPermissionResource) -> None: + self._resource = resource + self.create = async_to_raw_response_wrapper(resource.create) + self.list = async_to_raw_response_wrapper(resource.list) + self.get = async_to_raw_response_wrapper(resource.get) + self.reply = async_to_raw_response_wrapper(resource.reply) + + @cached_property + def request_(self) -> AsyncPermissionRequestResourceWithRawResponse: + """``client.permission.request.with_raw_response``.""" + return AsyncPermissionRequestResourceWithRawResponse(self._resource.request_) + + @cached_property + def saved(self) -> AsyncPermissionSavedResourceWithRawResponse: + """``client.permission.saved.with_raw_response``.""" + return AsyncPermissionSavedResourceWithRawResponse(self._resource.saved) + + +class AsyncPermissionResourceWithStreamingResponse: + """``client.permission.with_streaming_response``.""" + + def __init__(self, resource: AsyncPermissionResource) -> None: + self._resource = resource + self.create = async_to_streamed_response_wrapper(resource.create) + self.list = async_to_streamed_response_wrapper(resource.list) + self.get = async_to_streamed_response_wrapper(resource.get) + self.reply = async_to_streamed_response_wrapper(resource.reply) + + @cached_property + def request_(self) -> AsyncPermissionRequestResourceWithStreamingResponse: + """``client.permission.request.with_streaming_response``.""" + return AsyncPermissionRequestResourceWithStreamingResponse(self._resource.request_) + + @cached_property + def saved(self) -> AsyncPermissionSavedResourceWithStreamingResponse: + """``client.permission.saved.with_streaming_response``.""" + return AsyncPermissionSavedResourceWithStreamingResponse(self._resource.saved) diff --git a/src/opencode/resources/plugin.py b/src/opencode/resources/plugin.py index c71b0f3..f944c70 100644 --- a/src/opencode/resources/plugin.py +++ b/src/opencode/resources/plugin.py @@ -6,10 +6,17 @@ from __future__ import annotations from collections.abc import Sequence +from functools import cached_property from typing import TYPE_CHECKING, cast from .._base_client import RequestOptions from .._resource import AsyncAPIResource, SyncAPIResource +from .._response import ( + async_to_raw_response_wrapper, + async_to_streamed_response_wrapper, + to_raw_response_wrapper, + to_streamed_response_wrapper, +) from .._types import NOT_GIVEN, Body, Headers, NotGiven, Query, Timeout if TYPE_CHECKING: @@ -25,6 +32,16 @@ class PluginResource(SyncAPIResource): """Operations under ``client.plugin`` (OpenCode ``plugin``).""" + @cached_property + def with_raw_response(self) -> PluginResourceWithRawResponse: + """Same methods, returning the raw HTTP response; call ``.parse()`` on it for the usual value.""" + return PluginResourceWithRawResponse(self) + + @cached_property + def with_streaming_response(self) -> PluginResourceWithStreamingResponse: + """Same methods, returning a context manager over the HTTP response without reading the body.""" + return PluginResourceWithStreamingResponse(self) + def list( self, *, @@ -121,24 +138,57 @@ def update( ``POST /api/plugin/update`` """ - self._client.request( - RequestOptions( - method="POST", - path="/api/plugin/update", - query={"location": self._location(location)}, - body={"targets": targets}, - extra_headers=extra_headers, - extra_query=extra_query, - extra_body=extra_body, - timeout=timeout, + return cast( + "None", + self._client.request( + RequestOptions( + method="POST", + path="/api/plugin/update", + query={"location": self._location(location)}, + body={"targets": targets}, + extra_headers=extra_headers, + extra_query=extra_query, + extra_body=extra_body, + timeout=timeout, + ), + kind="void", ), - kind="void", ) +class PluginResourceWithRawResponse: + """``client.plugin.with_raw_response``.""" + + def __init__(self, resource: PluginResource) -> None: + self._resource = resource + self.list = to_raw_response_wrapper(resource.list) + self.check = to_raw_response_wrapper(resource.check) + self.update = to_raw_response_wrapper(resource.update) + + +class PluginResourceWithStreamingResponse: + """``client.plugin.with_streaming_response``.""" + + def __init__(self, resource: PluginResource) -> None: + self._resource = resource + self.list = to_streamed_response_wrapper(resource.list) + self.check = to_streamed_response_wrapper(resource.check) + self.update = to_streamed_response_wrapper(resource.update) + + class AsyncPluginResource(AsyncAPIResource): """Operations under ``client.plugin`` (OpenCode ``plugin``).""" + @cached_property + def with_raw_response(self) -> AsyncPluginResourceWithRawResponse: + """Same methods, returning the raw HTTP response; call ``.parse()`` on it for the usual value.""" + return AsyncPluginResourceWithRawResponse(self) + + @cached_property + def with_streaming_response(self) -> AsyncPluginResourceWithStreamingResponse: + """Same methods, returning a context manager over the HTTP response without reading the body.""" + return AsyncPluginResourceWithStreamingResponse(self) + async def list( self, *, @@ -235,16 +285,39 @@ async def update( ``POST /api/plugin/update`` """ - await self._client.request( - RequestOptions( - method="POST", - path="/api/plugin/update", - query={"location": self._location(location)}, - body={"targets": targets}, - extra_headers=extra_headers, - extra_query=extra_query, - extra_body=extra_body, - timeout=timeout, + return cast( + "None", + await self._client.request( + RequestOptions( + method="POST", + path="/api/plugin/update", + query={"location": self._location(location)}, + body={"targets": targets}, + extra_headers=extra_headers, + extra_query=extra_query, + extra_body=extra_body, + timeout=timeout, + ), + kind="void", ), - kind="void", ) + + +class AsyncPluginResourceWithRawResponse: + """``client.plugin.with_raw_response``.""" + + def __init__(self, resource: AsyncPluginResource) -> None: + self._resource = resource + self.list = async_to_raw_response_wrapper(resource.list) + self.check = async_to_raw_response_wrapper(resource.check) + self.update = async_to_raw_response_wrapper(resource.update) + + +class AsyncPluginResourceWithStreamingResponse: + """``client.plugin.with_streaming_response``.""" + + def __init__(self, resource: AsyncPluginResource) -> None: + self._resource = resource + self.list = async_to_streamed_response_wrapper(resource.list) + self.check = async_to_streamed_response_wrapper(resource.check) + self.update = async_to_streamed_response_wrapper(resource.update) diff --git a/src/opencode/resources/project.py b/src/opencode/resources/project.py index 327c48c..9d34230 100644 --- a/src/opencode/resources/project.py +++ b/src/opencode/resources/project.py @@ -6,11 +6,18 @@ from __future__ import annotations import builtins +from functools import cached_property from typing import TYPE_CHECKING, cast from .._base_client import RequestOptions from .._qs import encode_path_segment from .._resource import AsyncAPIResource, SyncAPIResource +from .._response import ( + async_to_raw_response_wrapper, + async_to_streamed_response_wrapper, + to_raw_response_wrapper, + to_streamed_response_wrapper, +) from .._types import NOT_GIVEN, Body, Headers, NotGiven, Query, Timeout if TYPE_CHECKING: @@ -28,6 +35,16 @@ class ProjectResource(SyncAPIResource): """Operations under ``client.project`` (OpenCode ``project``).""" + @cached_property + def with_raw_response(self) -> ProjectResourceWithRawResponse: + """Same methods, returning the raw HTTP response; call ``.parse()`` on it for the usual value.""" + return ProjectResourceWithRawResponse(self) + + @cached_property + def with_streaming_response(self) -> ProjectResourceWithStreamingResponse: + """Same methods, returning a context manager over the HTTP response without reading the body.""" + return ProjectResourceWithStreamingResponse(self) + def list( self, *, @@ -106,9 +123,37 @@ def update( ) +class ProjectResourceWithRawResponse: + """``client.project.with_raw_response``.""" + + def __init__(self, resource: ProjectResource) -> None: + self._resource = resource + self.list = to_raw_response_wrapper(resource.list) + self.update = to_raw_response_wrapper(resource.update) + + +class ProjectResourceWithStreamingResponse: + """``client.project.with_streaming_response``.""" + + def __init__(self, resource: ProjectResource) -> None: + self._resource = resource + self.list = to_streamed_response_wrapper(resource.list) + self.update = to_streamed_response_wrapper(resource.update) + + class AsyncProjectResource(AsyncAPIResource): """Operations under ``client.project`` (OpenCode ``project``).""" + @cached_property + def with_raw_response(self) -> AsyncProjectResourceWithRawResponse: + """Same methods, returning the raw HTTP response; call ``.parse()`` on it for the usual value.""" + return AsyncProjectResourceWithRawResponse(self) + + @cached_property + def with_streaming_response(self) -> AsyncProjectResourceWithStreamingResponse: + """Same methods, returning a context manager over the HTTP response without reading the body.""" + return AsyncProjectResourceWithStreamingResponse(self) + async def list( self, *, @@ -185,3 +230,21 @@ async def update( response_type="Project", ), ) + + +class AsyncProjectResourceWithRawResponse: + """``client.project.with_raw_response``.""" + + def __init__(self, resource: AsyncProjectResource) -> None: + self._resource = resource + self.list = async_to_raw_response_wrapper(resource.list) + self.update = async_to_raw_response_wrapper(resource.update) + + +class AsyncProjectResourceWithStreamingResponse: + """``client.project.with_streaming_response``.""" + + def __init__(self, resource: AsyncProjectResource) -> None: + self._resource = resource + self.list = async_to_streamed_response_wrapper(resource.list) + self.update = async_to_streamed_response_wrapper(resource.update) diff --git a/src/opencode/resources/provider.py b/src/opencode/resources/provider.py index 2caf21a..0f7f480 100644 --- a/src/opencode/resources/provider.py +++ b/src/opencode/resources/provider.py @@ -5,11 +5,18 @@ from __future__ import annotations +from functools import cached_property from typing import TYPE_CHECKING, cast from .._base_client import RequestOptions from .._qs import encode_path_segment from .._resource import AsyncAPIResource, SyncAPIResource +from .._response import ( + async_to_raw_response_wrapper, + async_to_streamed_response_wrapper, + to_raw_response_wrapper, + to_streamed_response_wrapper, +) from .._types import NOT_GIVEN, Body, Headers, NotGiven, Query, Timeout if TYPE_CHECKING: @@ -26,6 +33,16 @@ class ProviderResource(SyncAPIResource): """Operations under ``client.provider`` (OpenCode ``provider``).""" + @cached_property + def with_raw_response(self) -> ProviderResourceWithRawResponse: + """Same methods, returning the raw HTTP response; call ``.parse()`` on it for the usual value.""" + return ProviderResourceWithRawResponse(self) + + @cached_property + def with_streaming_response(self) -> ProviderResourceWithStreamingResponse: + """Same methods, returning a context manager over the HTTP response without reading the body.""" + return ProviderResourceWithStreamingResponse(self) + def list( self, *, @@ -103,9 +120,37 @@ def get( ) +class ProviderResourceWithRawResponse: + """``client.provider.with_raw_response``.""" + + def __init__(self, resource: ProviderResource) -> None: + self._resource = resource + self.list = to_raw_response_wrapper(resource.list) + self.get = to_raw_response_wrapper(resource.get) + + +class ProviderResourceWithStreamingResponse: + """``client.provider.with_streaming_response``.""" + + def __init__(self, resource: ProviderResource) -> None: + self._resource = resource + self.list = to_streamed_response_wrapper(resource.list) + self.get = to_streamed_response_wrapper(resource.get) + + class AsyncProviderResource(AsyncAPIResource): """Operations under ``client.provider`` (OpenCode ``provider``).""" + @cached_property + def with_raw_response(self) -> AsyncProviderResourceWithRawResponse: + """Same methods, returning the raw HTTP response; call ``.parse()`` on it for the usual value.""" + return AsyncProviderResourceWithRawResponse(self) + + @cached_property + def with_streaming_response(self) -> AsyncProviderResourceWithStreamingResponse: + """Same methods, returning a context manager over the HTTP response without reading the body.""" + return AsyncProviderResourceWithStreamingResponse(self) + async def list( self, *, @@ -181,3 +226,21 @@ async def get( response_type="ProviderGetResponse", ), ) + + +class AsyncProviderResourceWithRawResponse: + """``client.provider.with_raw_response``.""" + + def __init__(self, resource: AsyncProviderResource) -> None: + self._resource = resource + self.list = async_to_raw_response_wrapper(resource.list) + self.get = async_to_raw_response_wrapper(resource.get) + + +class AsyncProviderResourceWithStreamingResponse: + """``client.provider.with_streaming_response``.""" + + def __init__(self, resource: AsyncProviderResource) -> None: + self._resource = resource + self.list = async_to_streamed_response_wrapper(resource.list) + self.get = async_to_streamed_response_wrapper(resource.get) diff --git a/src/opencode/resources/pty.py b/src/opencode/resources/pty.py index e82e79f..b027611 100644 --- a/src/opencode/resources/pty.py +++ b/src/opencode/resources/pty.py @@ -13,6 +13,12 @@ from .._pty import AsyncPtyAttachMixin, PtyAttachMixin from .._qs import encode_path_segment from .._resource import AsyncAPIResource, SyncAPIResource +from .._response import ( + async_to_raw_response_wrapper, + async_to_streamed_response_wrapper, + to_raw_response_wrapper, + to_streamed_response_wrapper, +) from .._types import NOT_GIVEN, Body, Headers, NotGiven, Query, Timeout if TYPE_CHECKING: @@ -33,6 +39,16 @@ class PtyConnectResource(SyncAPIResource): """Operations under ``client.pty.connect`` (OpenCode ``pty.connect``).""" + @cached_property + def with_raw_response(self) -> PtyConnectResourceWithRawResponse: + """Same methods, returning the raw HTTP response; call ``.parse()`` on it for the usual value.""" + return PtyConnectResourceWithRawResponse(self) + + @cached_property + def with_streaming_response(self) -> PtyConnectResourceWithStreamingResponse: + """Same methods, returning a context manager over the HTTP response without reading the body.""" + return PtyConnectResourceWithStreamingResponse(self) + def token( self, pty_id: PtyID, @@ -75,6 +91,22 @@ def token( ) +class PtyConnectResourceWithRawResponse: + """``client.pty.connect.with_raw_response``.""" + + def __init__(self, resource: PtyConnectResource) -> None: + self._resource = resource + self.token = to_raw_response_wrapper(resource.token) + + +class PtyConnectResourceWithStreamingResponse: + """``client.pty.connect.with_streaming_response``.""" + + def __init__(self, resource: PtyConnectResource) -> None: + self._resource = resource + self.token = to_streamed_response_wrapper(resource.token) + + class PtyResource(PtyAttachMixin): """Operations under ``client.pty`` (OpenCode ``pty``).""" @@ -83,6 +115,16 @@ def connect(self) -> PtyConnectResource: """Operations under ``client.pty.connect``.""" return PtyConnectResource(self._client) + @cached_property + def with_raw_response(self) -> PtyResourceWithRawResponse: + """Same methods, returning the raw HTTP response; call ``.parse()`` on it for the usual value.""" + return PtyResourceWithRawResponse(self) + + @cached_property + def with_streaming_response(self) -> PtyResourceWithStreamingResponse: + """Same methods, returning a context manager over the HTTP response without reading the body.""" + return PtyResourceWithStreamingResponse(self) + def list( self, *, @@ -262,23 +304,70 @@ def remove( ``DELETE /api/pty/:ptyID`` """ - self._client.request( - RequestOptions( - method="DELETE", - path=f"/api/pty/{encode_path_segment(pty_id)}", - query={"location": self._location(location)}, - extra_headers=extra_headers, - extra_query=extra_query, - extra_body=extra_body, - timeout=timeout, + return cast( + "None", + self._client.request( + RequestOptions( + method="DELETE", + path=f"/api/pty/{encode_path_segment(pty_id)}", + query={"location": self._location(location)}, + extra_headers=extra_headers, + extra_query=extra_query, + extra_body=extra_body, + timeout=timeout, + ), + kind="void", ), - kind="void", ) +class PtyResourceWithRawResponse: + """``client.pty.with_raw_response``.""" + + def __init__(self, resource: PtyResource) -> None: + self._resource = resource + self.list = to_raw_response_wrapper(resource.list) + self.create = to_raw_response_wrapper(resource.create) + self.get = to_raw_response_wrapper(resource.get) + self.update = to_raw_response_wrapper(resource.update) + self.remove = to_raw_response_wrapper(resource.remove) + + @cached_property + def connect(self) -> PtyConnectResourceWithRawResponse: + """``client.pty.connect.with_raw_response``.""" + return PtyConnectResourceWithRawResponse(self._resource.connect) + + +class PtyResourceWithStreamingResponse: + """``client.pty.with_streaming_response``.""" + + def __init__(self, resource: PtyResource) -> None: + self._resource = resource + self.list = to_streamed_response_wrapper(resource.list) + self.create = to_streamed_response_wrapper(resource.create) + self.get = to_streamed_response_wrapper(resource.get) + self.update = to_streamed_response_wrapper(resource.update) + self.remove = to_streamed_response_wrapper(resource.remove) + + @cached_property + def connect(self) -> PtyConnectResourceWithStreamingResponse: + """``client.pty.connect.with_streaming_response``.""" + return PtyConnectResourceWithStreamingResponse(self._resource.connect) + + class AsyncPtyConnectResource(AsyncAPIResource): """Operations under ``client.pty.connect`` (OpenCode ``pty.connect``).""" + @cached_property + def with_raw_response(self) -> AsyncPtyConnectResourceWithRawResponse: + """Same methods, returning the raw HTTP response; call ``.parse()`` on it for the usual value.""" + return AsyncPtyConnectResourceWithRawResponse(self) + + @cached_property + def with_streaming_response(self) -> AsyncPtyConnectResourceWithStreamingResponse: + """Same methods, returning a context manager over the HTTP response without reading the body.""" + return AsyncPtyConnectResourceWithStreamingResponse(self) + async def token( self, pty_id: PtyID, @@ -321,6 +410,22 @@ async def token( ) +class AsyncPtyConnectResourceWithRawResponse: + """``client.pty.connect.with_raw_response``.""" + + def __init__(self, resource: AsyncPtyConnectResource) -> None: + self._resource = resource + self.token = async_to_raw_response_wrapper(resource.token) + + +class AsyncPtyConnectResourceWithStreamingResponse: + """``client.pty.connect.with_streaming_response``.""" + + def __init__(self, resource: AsyncPtyConnectResource) -> None: + self._resource = resource + self.token = async_to_streamed_response_wrapper(resource.token) + + class AsyncPtyResource(AsyncPtyAttachMixin): """Operations under ``client.pty`` (OpenCode ``pty``).""" @@ -329,6 +434,16 @@ def connect(self) -> AsyncPtyConnectResource: """Operations under ``client.pty.connect``.""" return AsyncPtyConnectResource(self._client) + @cached_property + def with_raw_response(self) -> AsyncPtyResourceWithRawResponse: + """Same methods, returning the raw HTTP response; call ``.parse()`` on it for the usual value.""" + return AsyncPtyResourceWithRawResponse(self) + + @cached_property + def with_streaming_response(self) -> AsyncPtyResourceWithStreamingResponse: + """Same methods, returning a context manager over the HTTP response without reading the body.""" + return AsyncPtyResourceWithStreamingResponse(self) + async def list( self, *, @@ -508,15 +623,52 @@ async def remove( ``DELETE /api/pty/:ptyID`` """ - await self._client.request( - RequestOptions( - method="DELETE", - path=f"/api/pty/{encode_path_segment(pty_id)}", - query={"location": self._location(location)}, - extra_headers=extra_headers, - extra_query=extra_query, - extra_body=extra_body, - timeout=timeout, + return cast( + "None", + await self._client.request( + RequestOptions( + method="DELETE", + path=f"/api/pty/{encode_path_segment(pty_id)}", + query={"location": self._location(location)}, + extra_headers=extra_headers, + extra_query=extra_query, + extra_body=extra_body, + timeout=timeout, + ), + kind="void", ), - kind="void", ) + + +class AsyncPtyResourceWithRawResponse: + """``client.pty.with_raw_response``.""" + + def __init__(self, resource: AsyncPtyResource) -> None: + self._resource = resource + self.list = async_to_raw_response_wrapper(resource.list) + self.create = async_to_raw_response_wrapper(resource.create) + self.get = async_to_raw_response_wrapper(resource.get) + self.update = async_to_raw_response_wrapper(resource.update) + self.remove = async_to_raw_response_wrapper(resource.remove) + + @cached_property + def connect(self) -> AsyncPtyConnectResourceWithRawResponse: + """``client.pty.connect.with_raw_response``.""" + return AsyncPtyConnectResourceWithRawResponse(self._resource.connect) + + +class AsyncPtyResourceWithStreamingResponse: + """``client.pty.with_streaming_response``.""" + + def __init__(self, resource: AsyncPtyResource) -> None: + self._resource = resource + self.list = async_to_streamed_response_wrapper(resource.list) + self.create = async_to_streamed_response_wrapper(resource.create) + self.get = async_to_streamed_response_wrapper(resource.get) + self.update = async_to_streamed_response_wrapper(resource.update) + self.remove = async_to_streamed_response_wrapper(resource.remove) + + @cached_property + def connect(self) -> AsyncPtyConnectResourceWithStreamingResponse: + """``client.pty.connect.with_streaming_response``.""" + return AsyncPtyConnectResourceWithStreamingResponse(self._resource.connect) diff --git a/src/opencode/resources/reference.py b/src/opencode/resources/reference.py index f9fba25..679d770 100644 --- a/src/opencode/resources/reference.py +++ b/src/opencode/resources/reference.py @@ -5,10 +5,17 @@ from __future__ import annotations +from functools import cached_property from typing import TYPE_CHECKING, cast from .._base_client import RequestOptions from .._resource import AsyncAPIResource, SyncAPIResource +from .._response import ( + async_to_raw_response_wrapper, + async_to_streamed_response_wrapper, + to_raw_response_wrapper, + to_streamed_response_wrapper, +) from .._types import NOT_GIVEN, Body, Headers, NotGiven, Query, Timeout if TYPE_CHECKING: @@ -23,6 +30,16 @@ class ReferenceResource(SyncAPIResource): """Operations under ``client.reference`` (OpenCode ``reference``).""" + @cached_property + def with_raw_response(self) -> ReferenceResourceWithRawResponse: + """Same methods, returning the raw HTTP response; call ``.parse()`` on it for the usual value.""" + return ReferenceResourceWithRawResponse(self) + + @cached_property + def with_streaming_response(self) -> ReferenceResourceWithStreamingResponse: + """Same methods, returning a context manager over the HTTP response without reading the body.""" + return ReferenceResourceWithStreamingResponse(self) + def list( self, *, @@ -60,9 +77,35 @@ def list( ) +class ReferenceResourceWithRawResponse: + """``client.reference.with_raw_response``.""" + + def __init__(self, resource: ReferenceResource) -> None: + self._resource = resource + self.list = to_raw_response_wrapper(resource.list) + + +class ReferenceResourceWithStreamingResponse: + """``client.reference.with_streaming_response``.""" + + def __init__(self, resource: ReferenceResource) -> None: + self._resource = resource + self.list = to_streamed_response_wrapper(resource.list) + + class AsyncReferenceResource(AsyncAPIResource): """Operations under ``client.reference`` (OpenCode ``reference``).""" + @cached_property + def with_raw_response(self) -> AsyncReferenceResourceWithRawResponse: + """Same methods, returning the raw HTTP response; call ``.parse()`` on it for the usual value.""" + return AsyncReferenceResourceWithRawResponse(self) + + @cached_property + def with_streaming_response(self) -> AsyncReferenceResourceWithStreamingResponse: + """Same methods, returning a context manager over the HTTP response without reading the body.""" + return AsyncReferenceResourceWithStreamingResponse(self) + async def list( self, *, @@ -98,3 +141,19 @@ async def list( response_type="ReferenceListResponse", ), ) + + +class AsyncReferenceResourceWithRawResponse: + """``client.reference.with_raw_response``.""" + + def __init__(self, resource: AsyncReferenceResource) -> None: + self._resource = resource + self.list = async_to_raw_response_wrapper(resource.list) + + +class AsyncReferenceResourceWithStreamingResponse: + """``client.reference.with_streaming_response``.""" + + def __init__(self, resource: AsyncReferenceResource) -> None: + self._resource = resource + self.list = async_to_streamed_response_wrapper(resource.list) diff --git a/src/opencode/resources/rpc.py b/src/opencode/resources/rpc.py index 85a9987..ce78f07 100644 --- a/src/opencode/resources/rpc.py +++ b/src/opencode/resources/rpc.py @@ -5,11 +5,18 @@ from __future__ import annotations +from functools import cached_property from typing import TYPE_CHECKING, Any, cast from .._base_client import RequestOptions from .._qs import encode_path_segment from .._resource import AsyncAPIResource, SyncAPIResource +from .._response import ( + async_to_raw_response_wrapper, + async_to_streamed_response_wrapper, + to_raw_response_wrapper, + to_streamed_response_wrapper, +) from .._types import NOT_GIVEN, Body, Headers, NotGiven, Query, Timeout if TYPE_CHECKING: @@ -24,6 +31,16 @@ class RpcResource(SyncAPIResource): """Operations under ``client.rpc`` (OpenCode ``rpc``).""" + @cached_property + def with_raw_response(self) -> RpcResourceWithRawResponse: + """Same methods, returning the raw HTTP response; call ``.parse()`` on it for the usual value.""" + return RpcResourceWithRawResponse(self) + + @cached_property + def with_streaming_response(self) -> RpcResourceWithStreamingResponse: + """Same methods, returning a context manager over the HTTP response without reading the body.""" + return RpcResourceWithStreamingResponse(self) + def call( self, rpc_id: str, @@ -67,9 +84,35 @@ def call( ) +class RpcResourceWithRawResponse: + """``client.rpc.with_raw_response``.""" + + def __init__(self, resource: RpcResource) -> None: + self._resource = resource + self.call = to_raw_response_wrapper(resource.call) + + +class RpcResourceWithStreamingResponse: + """``client.rpc.with_streaming_response``.""" + + def __init__(self, resource: RpcResource) -> None: + self._resource = resource + self.call = to_streamed_response_wrapper(resource.call) + + class AsyncRpcResource(AsyncAPIResource): """Operations under ``client.rpc`` (OpenCode ``rpc``).""" + @cached_property + def with_raw_response(self) -> AsyncRpcResourceWithRawResponse: + """Same methods, returning the raw HTTP response; call ``.parse()`` on it for the usual value.""" + return AsyncRpcResourceWithRawResponse(self) + + @cached_property + def with_streaming_response(self) -> AsyncRpcResourceWithStreamingResponse: + """Same methods, returning a context manager over the HTTP response without reading the body.""" + return AsyncRpcResourceWithStreamingResponse(self) + async def call( self, rpc_id: str, @@ -111,3 +154,19 @@ async def call( response_type="RpcOutput", ), ) + + +class AsyncRpcResourceWithRawResponse: + """``client.rpc.with_raw_response``.""" + + def __init__(self, resource: AsyncRpcResource) -> None: + self._resource = resource + self.call = async_to_raw_response_wrapper(resource.call) + + +class AsyncRpcResourceWithStreamingResponse: + """``client.rpc.with_streaming_response``.""" + + def __init__(self, resource: AsyncRpcResource) -> None: + self._resource = resource + self.call = async_to_streamed_response_wrapper(resource.call) diff --git a/src/opencode/resources/server.py b/src/opencode/resources/server.py index f5ac9c5..b2178de 100644 --- a/src/opencode/resources/server.py +++ b/src/opencode/resources/server.py @@ -5,11 +5,18 @@ from __future__ import annotations +from functools import cached_property from typing import TYPE_CHECKING, cast from .._base_client import RequestOptions from .._qs import encode_path_segment from .._resource import AsyncAPIResource, SyncAPIResource +from .._response import ( + async_to_raw_response_wrapper, + async_to_streamed_response_wrapper, + to_raw_response_wrapper, + to_streamed_response_wrapper, +) from .._types import NOT_GIVEN, Body, Headers, NotGiven, Query, Timeout if TYPE_CHECKING: @@ -25,6 +32,16 @@ class ServerResource(SyncAPIResource): """Operations under ``client.server`` (OpenCode ``server``).""" + @cached_property + def with_raw_response(self) -> ServerResourceWithRawResponse: + """Same methods, returning the raw HTTP response; call ``.parse()`` on it for the usual value.""" + return ServerResourceWithRawResponse(self) + + @cached_property + def with_streaming_response(self) -> ServerResourceWithStreamingResponse: + """Same methods, returning a context manager over the HTTP response without reading the body.""" + return ServerResourceWithStreamingResponse(self) + def info( self, *, @@ -126,9 +143,39 @@ def connect( ) +class ServerResourceWithRawResponse: + """``client.server.with_raw_response``.""" + + def __init__(self, resource: ServerResource) -> None: + self._resource = resource + self.info = to_raw_response_wrapper(resource.info) + self.pair = to_raw_response_wrapper(resource.pair) + self.connect = to_raw_response_wrapper(resource.connect) + + +class ServerResourceWithStreamingResponse: + """``client.server.with_streaming_response``.""" + + def __init__(self, resource: ServerResource) -> None: + self._resource = resource + self.info = to_streamed_response_wrapper(resource.info) + self.pair = to_streamed_response_wrapper(resource.pair) + self.connect = to_streamed_response_wrapper(resource.connect) + + class AsyncServerResource(AsyncAPIResource): """Operations under ``client.server`` (OpenCode ``server``).""" + @cached_property + def with_raw_response(self) -> AsyncServerResourceWithRawResponse: + """Same methods, returning the raw HTTP response; call ``.parse()`` on it for the usual value.""" + return AsyncServerResourceWithRawResponse(self) + + @cached_property + def with_streaming_response(self) -> AsyncServerResourceWithStreamingResponse: + """Same methods, returning a context manager over the HTTP response without reading the body.""" + return AsyncServerResourceWithStreamingResponse(self) + async def info( self, *, @@ -228,3 +275,23 @@ async def connect( response_type="PairingSession", ), ) + + +class AsyncServerResourceWithRawResponse: + """``client.server.with_raw_response``.""" + + def __init__(self, resource: AsyncServerResource) -> None: + self._resource = resource + self.info = async_to_raw_response_wrapper(resource.info) + self.pair = async_to_raw_response_wrapper(resource.pair) + self.connect = async_to_raw_response_wrapper(resource.connect) + + +class AsyncServerResourceWithStreamingResponse: + """``client.server.with_streaming_response``.""" + + def __init__(self, resource: AsyncServerResource) -> None: + self._resource = resource + self.info = async_to_streamed_response_wrapper(resource.info) + self.pair = async_to_streamed_response_wrapper(resource.pair) + self.connect = async_to_streamed_response_wrapper(resource.connect) diff --git a/src/opencode/resources/session.py b/src/opencode/resources/session.py index 6635edc..07ff0cf 100644 --- a/src/opencode/resources/session.py +++ b/src/opencode/resources/session.py @@ -14,6 +14,12 @@ from .._pagination import AsyncPaginator, SyncCursorPage from .._qs import encode_path_segment from .._resource import AsyncAPIResource, SyncAPIResource +from .._response import ( + async_to_raw_response_wrapper, + async_to_streamed_response_wrapper, + to_raw_response_wrapper, + to_streamed_response_wrapper, +) from .._streaming import AsyncStream, Stream from .._types import NOT_GIVEN, Body, Headers, NotGiven, OpenEnum, Query, Timeout from ..lib._session import AsyncSessionHelpers, SessionHelpers @@ -66,6 +72,16 @@ class SessionRevertResource(SyncAPIResource): """Operations under ``client.session.revert`` (OpenCode ``session.revert``).""" + @cached_property + def with_raw_response(self) -> SessionRevertResourceWithRawResponse: + """Same methods, returning the raw HTTP response; call ``.parse()`` on it for the usual value.""" + return SessionRevertResourceWithRawResponse(self) + + @cached_property + def with_streaming_response(self) -> SessionRevertResourceWithStreamingResponse: + """Same methods, returning a context manager over the HTTP response without reading the body.""" + return SessionRevertResourceWithStreamingResponse(self) + def stage( self, session_id: SessionID, @@ -130,16 +146,19 @@ def clear( ``DELETE /api/session/:sessionID/revert`` """ - self._client.request( - RequestOptions( - method="DELETE", - path=f"/api/session/{encode_path_segment(session_id)}/revert", - extra_headers=extra_headers, - extra_query=extra_query, - extra_body=extra_body, - timeout=timeout, + return cast( + "None", + self._client.request( + RequestOptions( + method="DELETE", + path=f"/api/session/{encode_path_segment(session_id)}/revert", + extra_headers=extra_headers, + extra_query=extra_query, + extra_body=extra_body, + timeout=timeout, + ), + kind="void", ), - kind="void", ) def commit( @@ -162,22 +181,55 @@ def commit( ``POST /api/session/:sessionID/revert/commit`` """ - self._client.request( - RequestOptions( - method="POST", - path=f"/api/session/{encode_path_segment(session_id)}/revert/commit", - extra_headers=extra_headers, - extra_query=extra_query, - extra_body=extra_body, - timeout=timeout, + return cast( + "None", + self._client.request( + RequestOptions( + method="POST", + path=f"/api/session/{encode_path_segment(session_id)}/revert/commit", + extra_headers=extra_headers, + extra_query=extra_query, + extra_body=extra_body, + timeout=timeout, + ), + kind="void", ), - kind="void", ) +class SessionRevertResourceWithRawResponse: + """``client.session.revert.with_raw_response``.""" + + def __init__(self, resource: SessionRevertResource) -> None: + self._resource = resource + self.stage = to_raw_response_wrapper(resource.stage) + self.clear = to_raw_response_wrapper(resource.clear) + self.commit = to_raw_response_wrapper(resource.commit) + + +class SessionRevertResourceWithStreamingResponse: + """``client.session.revert.with_streaming_response``.""" + + def __init__(self, resource: SessionRevertResource) -> None: + self._resource = resource + self.stage = to_streamed_response_wrapper(resource.stage) + self.clear = to_streamed_response_wrapper(resource.clear) + self.commit = to_streamed_response_wrapper(resource.commit) + + class SessionInboxResource(SyncAPIResource): """Operations under ``client.session.inbox`` (OpenCode ``session.inbox``).""" + @cached_property + def with_raw_response(self) -> SessionInboxResourceWithRawResponse: + """Same methods, returning the raw HTTP response; call ``.parse()`` on it for the usual value.""" + return SessionInboxResourceWithRawResponse(self) + + @cached_property + def with_streaming_response(self) -> SessionInboxResourceWithStreamingResponse: + """Same methods, returning a context manager over the HTTP response without reading the body.""" + return SessionInboxResourceWithStreamingResponse(self) + def list( self, session_id: SessionID, @@ -235,16 +287,19 @@ def cancel( ``DELETE /api/session/:sessionID/inbox/:inboxID`` """ - self._client.request( - RequestOptions( - method="DELETE", - path=f"/api/session/{encode_path_segment(session_id)}/inbox/{encode_path_segment(inbox_id)}", - extra_headers=extra_headers, - extra_query=extra_query, - extra_body=extra_body, - timeout=timeout, + return cast( + "None", + self._client.request( + RequestOptions( + method="DELETE", + path=f"/api/session/{encode_path_segment(session_id)}/inbox/{encode_path_segment(inbox_id)}", + extra_headers=extra_headers, + extra_query=extra_query, + extra_body=extra_body, + timeout=timeout, + ), + kind="void", ), - kind="void", ) def update( @@ -270,23 +325,56 @@ def update( ``PATCH /api/session/:sessionID/inbox/:inboxID`` """ - self._client.request( - RequestOptions( - method="PATCH", - path=f"/api/session/{encode_path_segment(session_id)}/inbox/{encode_path_segment(inbox_id)}", - body={"delivery": delivery}, - extra_headers=extra_headers, - extra_query=extra_query, - extra_body=extra_body, - timeout=timeout, + return cast( + "None", + self._client.request( + RequestOptions( + method="PATCH", + path=f"/api/session/{encode_path_segment(session_id)}/inbox/{encode_path_segment(inbox_id)}", + body={"delivery": delivery}, + extra_headers=extra_headers, + extra_query=extra_query, + extra_body=extra_body, + timeout=timeout, + ), + kind="void", ), - kind="void", ) +class SessionInboxResourceWithRawResponse: + """``client.session.inbox.with_raw_response``.""" + + def __init__(self, resource: SessionInboxResource) -> None: + self._resource = resource + self.list = to_raw_response_wrapper(resource.list) + self.cancel = to_raw_response_wrapper(resource.cancel) + self.update = to_raw_response_wrapper(resource.update) + + +class SessionInboxResourceWithStreamingResponse: + """``client.session.inbox.with_streaming_response``.""" + + def __init__(self, resource: SessionInboxResource) -> None: + self._resource = resource + self.list = to_streamed_response_wrapper(resource.list) + self.cancel = to_streamed_response_wrapper(resource.cancel) + self.update = to_streamed_response_wrapper(resource.update) + + class SessionInstructionsEntryResource(SyncAPIResource): """Operations under ``client.session.instructions.entry`` (OpenCode ``session.instructions.entry``).""" + @cached_property + def with_raw_response(self) -> SessionInstructionsEntryResourceWithRawResponse: + """Same methods, returning the raw HTTP response; call ``.parse()`` on it for the usual value.""" + return SessionInstructionsEntryResourceWithRawResponse(self) + + @cached_property + def with_streaming_response(self) -> SessionInstructionsEntryResourceWithStreamingResponse: + """Same methods, returning a context manager over the HTTP response without reading the body.""" + return SessionInstructionsEntryResourceWithStreamingResponse(self) + def list( self, session_id: SessionID, @@ -352,17 +440,20 @@ def put( ``PUT /api/experimental/session/:sessionID/instructions/entries/:key`` """ - self._client.request( - RequestOptions( - method="PUT", - path=f"/api/experimental/session/{encode_path_segment(session_id)}/instructions/entries/{encode_path_segment(key)}", - body={"value": value}, - extra_headers=extra_headers, - extra_query=extra_query, - extra_body=extra_body, - timeout=timeout, + return cast( + "None", + self._client.request( + RequestOptions( + method="PUT", + path=f"/api/experimental/session/{encode_path_segment(session_id)}/instructions/entries/{encode_path_segment(key)}", + body={"value": value}, + extra_headers=extra_headers, + extra_query=extra_query, + extra_body=extra_body, + timeout=timeout, + ), + kind="void", ), - kind="void", ) def remove( @@ -389,19 +480,42 @@ def remove( ``DELETE /api/experimental/session/:sessionID/instructions/entries/:key`` """ - self._client.request( - RequestOptions( - method="DELETE", - path=f"/api/experimental/session/{encode_path_segment(session_id)}/instructions/entries/{encode_path_segment(key)}", - extra_headers=extra_headers, - extra_query=extra_query, - extra_body=extra_body, - timeout=timeout, + return cast( + "None", + self._client.request( + RequestOptions( + method="DELETE", + path=f"/api/experimental/session/{encode_path_segment(session_id)}/instructions/entries/{encode_path_segment(key)}", + extra_headers=extra_headers, + extra_query=extra_query, + extra_body=extra_body, + timeout=timeout, + ), + kind="void", ), - kind="void", ) +class SessionInstructionsEntryResourceWithRawResponse: + """``client.session.instructions.entry.with_raw_response``.""" + + def __init__(self, resource: SessionInstructionsEntryResource) -> None: + self._resource = resource + self.list = to_raw_response_wrapper(resource.list) + self.put = to_raw_response_wrapper(resource.put) + self.remove = to_raw_response_wrapper(resource.remove) + + +class SessionInstructionsEntryResourceWithStreamingResponse: + """``client.session.instructions.entry.with_streaming_response``.""" + + def __init__(self, resource: SessionInstructionsEntryResource) -> None: + self._resource = resource + self.list = to_streamed_response_wrapper(resource.list) + self.put = to_streamed_response_wrapper(resource.put) + self.remove = to_streamed_response_wrapper(resource.remove) + + class SessionInstructionsResource(SyncAPIResource): """Operations under ``client.session.instructions`` (OpenCode ``session.instructions``).""" @@ -410,10 +524,54 @@ def entry(self) -> SessionInstructionsEntryResource: """Operations under ``client.session.instructions.entry``.""" return SessionInstructionsEntryResource(self._client) + @cached_property + def with_raw_response(self) -> SessionInstructionsResourceWithRawResponse: + """Same methods, returning the raw HTTP response; call ``.parse()`` on it for the usual value.""" + return SessionInstructionsResourceWithRawResponse(self) + + @cached_property + def with_streaming_response(self) -> SessionInstructionsResourceWithStreamingResponse: + """Same methods, returning a context manager over the HTTP response without reading the body.""" + return SessionInstructionsResourceWithStreamingResponse(self) + + +class SessionInstructionsResourceWithRawResponse: + """``client.session.instructions.with_raw_response``.""" + + def __init__(self, resource: SessionInstructionsResource) -> None: + self._resource = resource + + @cached_property + def entry(self) -> SessionInstructionsEntryResourceWithRawResponse: + """``client.session.instructions.entry.with_raw_response``.""" + return SessionInstructionsEntryResourceWithRawResponse(self._resource.entry) + + +class SessionInstructionsResourceWithStreamingResponse: + """``client.session.instructions.with_streaming_response``.""" + + def __init__(self, resource: SessionInstructionsResource) -> None: + self._resource = resource + + @cached_property + def entry(self) -> SessionInstructionsEntryResourceWithStreamingResponse: + """``client.session.instructions.entry.with_streaming_response``.""" + return SessionInstructionsEntryResourceWithStreamingResponse(self._resource.entry) + class SessionMessageResource(SyncAPIResource): """Operations under ``client.session.message`` (OpenCode ``session.message``).""" + @cached_property + def with_raw_response(self) -> SessionMessageResourceWithRawResponse: + """Same methods, returning the raw HTTP response; call ``.parse()`` on it for the usual value.""" + return SessionMessageResourceWithRawResponse(self) + + @cached_property + def with_streaming_response(self) -> SessionMessageResourceWithStreamingResponse: + """Same methods, returning a context manager over the HTTP response without reading the body.""" + return SessionMessageResourceWithStreamingResponse(self) + def get( self, session_id: SessionID, @@ -453,9 +611,35 @@ def get( ) +class SessionMessageResourceWithRawResponse: + """``client.session.message.with_raw_response``.""" + + def __init__(self, resource: SessionMessageResource) -> None: + self._resource = resource + self.get = to_raw_response_wrapper(resource.get) + + +class SessionMessageResourceWithStreamingResponse: + """``client.session.message.with_streaming_response``.""" + + def __init__(self, resource: SessionMessageResource) -> None: + self._resource = resource + self.get = to_streamed_response_wrapper(resource.get) + + class SessionFormResource(SyncAPIResource): """Operations under ``client.session.form`` (OpenCode ``session.form``).""" + @cached_property + def with_raw_response(self) -> SessionFormResourceWithRawResponse: + """Same methods, returning the raw HTTP response; call ``.parse()`` on it for the usual value.""" + return SessionFormResourceWithRawResponse(self) + + @cached_property + def with_streaming_response(self) -> SessionFormResourceWithStreamingResponse: + """Same methods, returning a context manager over the HTTP response without reading the body.""" + return SessionFormResourceWithStreamingResponse(self) + def list( self, session_id: str, @@ -601,17 +785,20 @@ def reply( ``POST /api/session/:sessionID/form/:formID/reply`` """ - self._client.request( - RequestOptions( - method="POST", - path=f"/api/session/{encode_path_segment(session_id)}/form/{encode_path_segment(form_id)}/reply", - body={"answer": answer}, - extra_headers=extra_headers, - extra_query=extra_query, - extra_body=extra_body, - timeout=timeout, + return cast( + "None", + self._client.request( + RequestOptions( + method="POST", + path=f"/api/session/{encode_path_segment(session_id)}/form/{encode_path_segment(form_id)}/reply", + body={"answer": answer}, + extra_headers=extra_headers, + extra_query=extra_query, + extra_body=extra_body, + timeout=timeout, + ), + kind="void", ), - kind="void", ) def cancel( @@ -639,20 +826,47 @@ def cancel( ``DELETE /api/session/:sessionID/form/:formID`` """ - self._client.request( - RequestOptions( - method="DELETE", - path=f"/api/session/{encode_path_segment(session_id)}/form/{encode_path_segment(form_id)}", - query={"message": message}, - extra_headers=extra_headers, - extra_query=extra_query, - extra_body=extra_body, - timeout=timeout, + return cast( + "None", + self._client.request( + RequestOptions( + method="DELETE", + path=f"/api/session/{encode_path_segment(session_id)}/form/{encode_path_segment(form_id)}", + query={"message": message}, + extra_headers=extra_headers, + extra_query=extra_query, + extra_body=extra_body, + timeout=timeout, + ), + kind="void", ), - kind="void", ) +class SessionFormResourceWithRawResponse: + """``client.session.form.with_raw_response``.""" + + def __init__(self, resource: SessionFormResource) -> None: + self._resource = resource + self.list = to_raw_response_wrapper(resource.list) + self.create = to_raw_response_wrapper(resource.create) + self.get = to_raw_response_wrapper(resource.get) + self.reply = to_raw_response_wrapper(resource.reply) + self.cancel = to_raw_response_wrapper(resource.cancel) + + +class SessionFormResourceWithStreamingResponse: + """``client.session.form.with_streaming_response``.""" + + def __init__(self, resource: SessionFormResource) -> None: + self._resource = resource + self.list = to_streamed_response_wrapper(resource.list) + self.create = to_streamed_response_wrapper(resource.create) + self.get = to_streamed_response_wrapper(resource.get) + self.reply = to_streamed_response_wrapper(resource.reply) + self.cancel = to_streamed_response_wrapper(resource.cancel) + + class SessionResource(SessionHelpers): """Operations under ``client.session`` (OpenCode ``session``).""" @@ -681,6 +895,16 @@ def form(self) -> SessionFormResource: """Operations under ``client.session.form``.""" return SessionFormResource(self._client) + @cached_property + def with_raw_response(self) -> SessionResourceWithRawResponse: + """Same methods, returning the raw HTTP response; call ``.parse()`` on it for the usual value.""" + return SessionResourceWithRawResponse(self) + + @cached_property + def with_streaming_response(self) -> SessionResourceWithStreamingResponse: + """Same methods, returning a context manager over the HTTP response without reading the body.""" + return SessionResourceWithStreamingResponse(self) + def list( self, *, @@ -1006,16 +1230,19 @@ def remove( ``DELETE /api/session/:sessionID`` """ - self._client.request( - RequestOptions( - method="DELETE", - path=f"/api/session/{encode_path_segment(session_id)}", - extra_headers=extra_headers, - extra_query=extra_query, - extra_body=extra_body, - timeout=timeout, + return cast( + "None", + self._client.request( + RequestOptions( + method="DELETE", + path=f"/api/session/{encode_path_segment(session_id)}", + extra_headers=extra_headers, + extra_query=extra_query, + extra_body=extra_body, + timeout=timeout, + ), + kind="void", ), - kind="void", ) def fork( @@ -1080,17 +1307,20 @@ def switch_agent( ``POST /api/session/:sessionID/agent`` """ - self._client.request( - RequestOptions( - method="POST", - path=f"/api/session/{encode_path_segment(session_id)}/agent", - body={"agent": agent}, - extra_headers=extra_headers, - extra_query=extra_query, - extra_body=extra_body, - timeout=timeout, + return cast( + "None", + self._client.request( + RequestOptions( + method="POST", + path=f"/api/session/{encode_path_segment(session_id)}/agent", + body={"agent": agent}, + extra_headers=extra_headers, + extra_query=extra_query, + extra_body=extra_body, + timeout=timeout, + ), + kind="void", ), - kind="void", ) def switch_model( @@ -1115,17 +1345,20 @@ def switch_model( ``POST /api/session/:sessionID/model`` """ - self._client.request( - RequestOptions( - method="POST", - path=f"/api/session/{encode_path_segment(session_id)}/model", - body={"model": model}, - extra_headers=extra_headers, - extra_query=extra_query, - extra_body=extra_body, - timeout=timeout, + return cast( + "None", + self._client.request( + RequestOptions( + method="POST", + path=f"/api/session/{encode_path_segment(session_id)}/model", + body={"model": model}, + extra_headers=extra_headers, + extra_query=extra_query, + extra_body=extra_body, + timeout=timeout, + ), + kind="void", ), - kind="void", ) def update( @@ -1156,17 +1389,20 @@ def update( ``PATCH /api/session/:sessionID`` """ - self._client.request( - RequestOptions( - method="PATCH", - path=f"/api/session/{encode_path_segment(session_id)}", - body={"title": title, "metadata": metadata, "permissions": permissions, "archived": archived}, - extra_headers=extra_headers, - extra_query=extra_query, - extra_body=extra_body, - timeout=timeout, + return cast( + "None", + self._client.request( + RequestOptions( + method="PATCH", + path=f"/api/session/{encode_path_segment(session_id)}", + body={"title": title, "metadata": metadata, "permissions": permissions, "archived": archived}, + extra_headers=extra_headers, + extra_query=extra_query, + extra_body=extra_body, + timeout=timeout, + ), + kind="void", ), - kind="void", ) def move( @@ -1191,17 +1427,20 @@ def move( ``POST /api/session/:sessionID/move`` """ - self._client.request( - RequestOptions( - method="POST", - path=f"/api/session/{encode_path_segment(session_id)}/move", - body={"directory": directory, "delivery": delivery}, - extra_headers=extra_headers, - extra_query=extra_query, - extra_body=extra_body, - timeout=timeout, + return cast( + "None", + self._client.request( + RequestOptions( + method="POST", + path=f"/api/session/{encode_path_segment(session_id)}/move", + body={"directory": directory, "delivery": delivery}, + extra_headers=extra_headers, + extra_query=extra_query, + extra_body=extra_body, + timeout=timeout, + ), + kind="void", ), - kind="void", ) def prompt( @@ -1289,24 +1528,27 @@ def command( ``POST /api/session/:sessionID/command`` """ - self._client.request( - RequestOptions( - method="POST", - path=f"/api/session/{encode_path_segment(session_id)}/command", - body={ - "name": name, - "text": text, - "files": files, - "agents": agents, - "skills": skills, - "delivery": delivery, - }, - extra_headers=extra_headers, - extra_query=extra_query, - extra_body=extra_body, - timeout=timeout, + return cast( + "None", + self._client.request( + RequestOptions( + method="POST", + path=f"/api/session/{encode_path_segment(session_id)}/command", + body={ + "name": name, + "text": text, + "files": files, + "agents": agents, + "skills": skills, + "delivery": delivery, + }, + extra_headers=extra_headers, + extra_query=extra_query, + extra_body=extra_body, + timeout=timeout, + ), + kind="void", ), - kind="void", ) def skill( @@ -1335,17 +1577,20 @@ def skill( ``POST /api/experimental/session/:sessionID/skill`` """ - self._client.request( - RequestOptions( - method="POST", - path=f"/api/experimental/session/{encode_path_segment(session_id)}/skill", - body={"id": id, "resume": resume}, - extra_headers=extra_headers, - extra_query=extra_query, - extra_body=extra_body, - timeout=timeout, + return cast( + "None", + self._client.request( + RequestOptions( + method="POST", + path=f"/api/experimental/session/{encode_path_segment(session_id)}/skill", + body={"id": id, "resume": resume}, + extra_headers=extra_headers, + extra_query=extra_query, + extra_body=extra_body, + timeout=timeout, + ), + kind="void", ), - kind="void", ) def synthetic( @@ -1423,17 +1668,20 @@ def shell( ``POST /api/session/:sessionID/shell`` """ - self._client.request( - RequestOptions( - method="POST", - path=f"/api/session/{encode_path_segment(session_id)}/shell", - body={"id": id, "command": command}, - extra_headers=extra_headers, - extra_query=extra_query, - extra_body=extra_body, - timeout=timeout, + return cast( + "None", + self._client.request( + RequestOptions( + method="POST", + path=f"/api/session/{encode_path_segment(session_id)}/shell", + body={"id": id, "command": command}, + extra_headers=extra_headers, + extra_query=extra_query, + extra_body=extra_body, + timeout=timeout, + ), + kind="void", ), - kind="void", ) def compact( @@ -1501,16 +1749,19 @@ def wait( ``POST /api/experimental/session/:sessionID/wait`` """ - self._client.request( - RequestOptions( - method="POST", - path=f"/api/experimental/session/{encode_path_segment(session_id)}/wait", - extra_headers=extra_headers, - extra_query=extra_query, - extra_body=extra_body, - timeout=timeout, + return cast( + "None", + self._client.request( + RequestOptions( + method="POST", + path=f"/api/experimental/session/{encode_path_segment(session_id)}/wait", + extra_headers=extra_headers, + extra_query=extra_query, + extra_body=extra_body, + timeout=timeout, + ), + kind="void", ), - kind="void", ) def context( @@ -1734,16 +1985,19 @@ def background( ``POST /api/session/:sessionID/background`` """ - self._client.request( - RequestOptions( - method="POST", - path=f"/api/session/{encode_path_segment(session_id)}/background", - extra_headers=extra_headers, - extra_query=extra_query, - extra_body=extra_body, - timeout=timeout, + return cast( + "None", + self._client.request( + RequestOptions( + method="POST", + path=f"/api/session/{encode_path_segment(session_id)}/background", + extra_headers=extra_headers, + extra_query=extra_query, + extra_body=extra_body, + timeout=timeout, + ), + kind="void", ), - kind="void", ) def environment( @@ -1767,17 +2021,20 @@ def environment( ``PUT /api/session/:sessionID/environment`` """ - self._client.request( - RequestOptions( - method="PUT", - path=f"/api/session/{encode_path_segment(session_id)}/environment", - body={"variables": variables}, - extra_headers=extra_headers, - extra_query=extra_query, - extra_body=extra_body, - timeout=timeout, + return cast( + "None", + self._client.request( + RequestOptions( + method="PUT", + path=f"/api/session/{encode_path_segment(session_id)}/environment", + body={"variables": variables}, + extra_headers=extra_headers, + extra_query=extra_query, + extra_body=extra_body, + timeout=timeout, + ), + kind="void", ), - kind="void", ) def view( @@ -1801,23 +2058,156 @@ def view( ``POST /api/session/:sessionID/view`` """ - self._client.request( - RequestOptions( - method="POST", - path=f"/api/session/{encode_path_segment(session_id)}/view", - body={"idle": idle}, - extra_headers=extra_headers, - extra_query=extra_query, - extra_body=extra_body, - timeout=timeout, + return cast( + "None", + self._client.request( + RequestOptions( + method="POST", + path=f"/api/session/{encode_path_segment(session_id)}/view", + body={"idle": idle}, + extra_headers=extra_headers, + extra_query=extra_query, + extra_body=extra_body, + timeout=timeout, + ), + kind="void", ), - kind="void", ) +class SessionResourceWithRawResponse: + """``client.session.with_raw_response``.""" + + def __init__(self, resource: SessionResource) -> None: + self._resource = resource + self.list = to_raw_response_wrapper(resource.list) + self.stats = to_raw_response_wrapper(resource.stats) + self.create = to_raw_response_wrapper(resource.create) + self.import_ = to_raw_response_wrapper(resource.import_) + self.export = to_raw_response_wrapper(resource.export) + self.active = to_raw_response_wrapper(resource.active) + self.get = to_raw_response_wrapper(resource.get) + self.remove = to_raw_response_wrapper(resource.remove) + self.fork = to_raw_response_wrapper(resource.fork) + self.switch_agent = to_raw_response_wrapper(resource.switch_agent) + self.switch_model = to_raw_response_wrapper(resource.switch_model) + self.update = to_raw_response_wrapper(resource.update) + self.move = to_raw_response_wrapper(resource.move) + self.prompt = to_raw_response_wrapper(resource.prompt) + self.command = to_raw_response_wrapper(resource.command) + self.skill = to_raw_response_wrapper(resource.skill) + self.synthetic = to_raw_response_wrapper(resource.synthetic) + self.shell = to_raw_response_wrapper(resource.shell) + self.compact = to_raw_response_wrapper(resource.compact) + self.wait = to_raw_response_wrapper(resource.wait) + self.context = to_raw_response_wrapper(resource.context) + self.diff = to_raw_response_wrapper(resource.diff) + self.generate = to_raw_response_wrapper(resource.generate) + self.log = to_raw_response_wrapper(resource.log) + self.interrupt = to_raw_response_wrapper(resource.interrupt) + self.background = to_raw_response_wrapper(resource.background) + self.environment = to_raw_response_wrapper(resource.environment) + self.view = to_raw_response_wrapper(resource.view) + + @cached_property + def revert(self) -> SessionRevertResourceWithRawResponse: + """``client.session.revert.with_raw_response``.""" + return SessionRevertResourceWithRawResponse(self._resource.revert) + + @cached_property + def inbox(self) -> SessionInboxResourceWithRawResponse: + """``client.session.inbox.with_raw_response``.""" + return SessionInboxResourceWithRawResponse(self._resource.inbox) + + @cached_property + def instructions(self) -> SessionInstructionsResourceWithRawResponse: + """``client.session.instructions.with_raw_response``.""" + return SessionInstructionsResourceWithRawResponse(self._resource.instructions) + + @cached_property + def message(self) -> SessionMessageResourceWithRawResponse: + """``client.session.message.with_raw_response``.""" + return SessionMessageResourceWithRawResponse(self._resource.message) + + @cached_property + def form(self) -> SessionFormResourceWithRawResponse: + """``client.session.form.with_raw_response``.""" + return SessionFormResourceWithRawResponse(self._resource.form) + + +class SessionResourceWithStreamingResponse: + """``client.session.with_streaming_response``.""" + + def __init__(self, resource: SessionResource) -> None: + self._resource = resource + self.list = to_streamed_response_wrapper(resource.list) + self.stats = to_streamed_response_wrapper(resource.stats) + self.create = to_streamed_response_wrapper(resource.create) + self.import_ = to_streamed_response_wrapper(resource.import_) + self.export = to_streamed_response_wrapper(resource.export) + self.active = to_streamed_response_wrapper(resource.active) + self.get = to_streamed_response_wrapper(resource.get) + self.remove = to_streamed_response_wrapper(resource.remove) + self.fork = to_streamed_response_wrapper(resource.fork) + self.switch_agent = to_streamed_response_wrapper(resource.switch_agent) + self.switch_model = to_streamed_response_wrapper(resource.switch_model) + self.update = to_streamed_response_wrapper(resource.update) + self.move = to_streamed_response_wrapper(resource.move) + self.prompt = to_streamed_response_wrapper(resource.prompt) + self.command = to_streamed_response_wrapper(resource.command) + self.skill = to_streamed_response_wrapper(resource.skill) + self.synthetic = to_streamed_response_wrapper(resource.synthetic) + self.shell = to_streamed_response_wrapper(resource.shell) + self.compact = to_streamed_response_wrapper(resource.compact) + self.wait = to_streamed_response_wrapper(resource.wait) + self.context = to_streamed_response_wrapper(resource.context) + self.diff = to_streamed_response_wrapper(resource.diff) + self.generate = to_streamed_response_wrapper(resource.generate) + self.log = to_streamed_response_wrapper(resource.log) + self.interrupt = to_streamed_response_wrapper(resource.interrupt) + self.background = to_streamed_response_wrapper(resource.background) + self.environment = to_streamed_response_wrapper(resource.environment) + self.view = to_streamed_response_wrapper(resource.view) + + @cached_property + def revert(self) -> SessionRevertResourceWithStreamingResponse: + """``client.session.revert.with_streaming_response``.""" + return SessionRevertResourceWithStreamingResponse(self._resource.revert) + + @cached_property + def inbox(self) -> SessionInboxResourceWithStreamingResponse: + """``client.session.inbox.with_streaming_response``.""" + return SessionInboxResourceWithStreamingResponse(self._resource.inbox) + + @cached_property + def instructions(self) -> SessionInstructionsResourceWithStreamingResponse: + """``client.session.instructions.with_streaming_response``.""" + return SessionInstructionsResourceWithStreamingResponse(self._resource.instructions) + + @cached_property + def message(self) -> SessionMessageResourceWithStreamingResponse: + """``client.session.message.with_streaming_response``.""" + return SessionMessageResourceWithStreamingResponse(self._resource.message) + + @cached_property + def form(self) -> SessionFormResourceWithStreamingResponse: + """``client.session.form.with_streaming_response``.""" + return SessionFormResourceWithStreamingResponse(self._resource.form) + + class AsyncSessionRevertResource(AsyncAPIResource): """Operations under ``client.session.revert`` (OpenCode ``session.revert``).""" + @cached_property + def with_raw_response(self) -> AsyncSessionRevertResourceWithRawResponse: + """Same methods, returning the raw HTTP response; call ``.parse()`` on it for the usual value.""" + return AsyncSessionRevertResourceWithRawResponse(self) + + @cached_property + def with_streaming_response(self) -> AsyncSessionRevertResourceWithStreamingResponse: + """Same methods, returning a context manager over the HTTP response without reading the body.""" + return AsyncSessionRevertResourceWithStreamingResponse(self) + async def stage( self, session_id: SessionID, @@ -1882,16 +2272,19 @@ async def clear( ``DELETE /api/session/:sessionID/revert`` """ - await self._client.request( - RequestOptions( - method="DELETE", - path=f"/api/session/{encode_path_segment(session_id)}/revert", - extra_headers=extra_headers, - extra_query=extra_query, - extra_body=extra_body, - timeout=timeout, + return cast( + "None", + await self._client.request( + RequestOptions( + method="DELETE", + path=f"/api/session/{encode_path_segment(session_id)}/revert", + extra_headers=extra_headers, + extra_query=extra_query, + extra_body=extra_body, + timeout=timeout, + ), + kind="void", ), - kind="void", ) async def commit( @@ -1914,22 +2307,55 @@ async def commit( ``POST /api/session/:sessionID/revert/commit`` """ - await self._client.request( - RequestOptions( - method="POST", - path=f"/api/session/{encode_path_segment(session_id)}/revert/commit", - extra_headers=extra_headers, - extra_query=extra_query, - extra_body=extra_body, - timeout=timeout, + return cast( + "None", + await self._client.request( + RequestOptions( + method="POST", + path=f"/api/session/{encode_path_segment(session_id)}/revert/commit", + extra_headers=extra_headers, + extra_query=extra_query, + extra_body=extra_body, + timeout=timeout, + ), + kind="void", ), - kind="void", ) +class AsyncSessionRevertResourceWithRawResponse: + """``client.session.revert.with_raw_response``.""" + + def __init__(self, resource: AsyncSessionRevertResource) -> None: + self._resource = resource + self.stage = async_to_raw_response_wrapper(resource.stage) + self.clear = async_to_raw_response_wrapper(resource.clear) + self.commit = async_to_raw_response_wrapper(resource.commit) + + +class AsyncSessionRevertResourceWithStreamingResponse: + """``client.session.revert.with_streaming_response``.""" + + def __init__(self, resource: AsyncSessionRevertResource) -> None: + self._resource = resource + self.stage = async_to_streamed_response_wrapper(resource.stage) + self.clear = async_to_streamed_response_wrapper(resource.clear) + self.commit = async_to_streamed_response_wrapper(resource.commit) + + class AsyncSessionInboxResource(AsyncAPIResource): """Operations under ``client.session.inbox`` (OpenCode ``session.inbox``).""" + @cached_property + def with_raw_response(self) -> AsyncSessionInboxResourceWithRawResponse: + """Same methods, returning the raw HTTP response; call ``.parse()`` on it for the usual value.""" + return AsyncSessionInboxResourceWithRawResponse(self) + + @cached_property + def with_streaming_response(self) -> AsyncSessionInboxResourceWithStreamingResponse: + """Same methods, returning a context manager over the HTTP response without reading the body.""" + return AsyncSessionInboxResourceWithStreamingResponse(self) + async def list( self, session_id: SessionID, @@ -1987,16 +2413,19 @@ async def cancel( ``DELETE /api/session/:sessionID/inbox/:inboxID`` """ - await self._client.request( - RequestOptions( - method="DELETE", - path=f"/api/session/{encode_path_segment(session_id)}/inbox/{encode_path_segment(inbox_id)}", - extra_headers=extra_headers, - extra_query=extra_query, - extra_body=extra_body, - timeout=timeout, + return cast( + "None", + await self._client.request( + RequestOptions( + method="DELETE", + path=f"/api/session/{encode_path_segment(session_id)}/inbox/{encode_path_segment(inbox_id)}", + extra_headers=extra_headers, + extra_query=extra_query, + extra_body=extra_body, + timeout=timeout, + ), + kind="void", ), - kind="void", ) async def update( @@ -2022,23 +2451,56 @@ async def update( ``PATCH /api/session/:sessionID/inbox/:inboxID`` """ - await self._client.request( - RequestOptions( - method="PATCH", - path=f"/api/session/{encode_path_segment(session_id)}/inbox/{encode_path_segment(inbox_id)}", - body={"delivery": delivery}, - extra_headers=extra_headers, - extra_query=extra_query, - extra_body=extra_body, - timeout=timeout, + return cast( + "None", + await self._client.request( + RequestOptions( + method="PATCH", + path=f"/api/session/{encode_path_segment(session_id)}/inbox/{encode_path_segment(inbox_id)}", + body={"delivery": delivery}, + extra_headers=extra_headers, + extra_query=extra_query, + extra_body=extra_body, + timeout=timeout, + ), + kind="void", ), - kind="void", ) +class AsyncSessionInboxResourceWithRawResponse: + """``client.session.inbox.with_raw_response``.""" + + def __init__(self, resource: AsyncSessionInboxResource) -> None: + self._resource = resource + self.list = async_to_raw_response_wrapper(resource.list) + self.cancel = async_to_raw_response_wrapper(resource.cancel) + self.update = async_to_raw_response_wrapper(resource.update) + + +class AsyncSessionInboxResourceWithStreamingResponse: + """``client.session.inbox.with_streaming_response``.""" + + def __init__(self, resource: AsyncSessionInboxResource) -> None: + self._resource = resource + self.list = async_to_streamed_response_wrapper(resource.list) + self.cancel = async_to_streamed_response_wrapper(resource.cancel) + self.update = async_to_streamed_response_wrapper(resource.update) + + class AsyncSessionInstructionsEntryResource(AsyncAPIResource): """Operations under ``client.session.instructions.entry`` (OpenCode ``session.instructions.entry``).""" + @cached_property + def with_raw_response(self) -> AsyncSessionInstructionsEntryResourceWithRawResponse: + """Same methods, returning the raw HTTP response; call ``.parse()`` on it for the usual value.""" + return AsyncSessionInstructionsEntryResourceWithRawResponse(self) + + @cached_property + def with_streaming_response(self) -> AsyncSessionInstructionsEntryResourceWithStreamingResponse: + """Same methods, returning a context manager over the HTTP response without reading the body.""" + return AsyncSessionInstructionsEntryResourceWithStreamingResponse(self) + async def list( self, session_id: SessionID, @@ -2104,17 +2566,20 @@ async def put( ``PUT /api/experimental/session/:sessionID/instructions/entries/:key`` """ - await self._client.request( - RequestOptions( - method="PUT", - path=f"/api/experimental/session/{encode_path_segment(session_id)}/instructions/entries/{encode_path_segment(key)}", - body={"value": value}, - extra_headers=extra_headers, - extra_query=extra_query, - extra_body=extra_body, - timeout=timeout, + return cast( + "None", + await self._client.request( + RequestOptions( + method="PUT", + path=f"/api/experimental/session/{encode_path_segment(session_id)}/instructions/entries/{encode_path_segment(key)}", + body={"value": value}, + extra_headers=extra_headers, + extra_query=extra_query, + extra_body=extra_body, + timeout=timeout, + ), + kind="void", ), - kind="void", ) async def remove( @@ -2141,31 +2606,98 @@ async def remove( ``DELETE /api/experimental/session/:sessionID/instructions/entries/:key`` """ - await self._client.request( - RequestOptions( - method="DELETE", - path=f"/api/experimental/session/{encode_path_segment(session_id)}/instructions/entries/{encode_path_segment(key)}", - extra_headers=extra_headers, - extra_query=extra_query, - extra_body=extra_body, - timeout=timeout, + return cast( + "None", + await self._client.request( + RequestOptions( + method="DELETE", + path=f"/api/experimental/session/{encode_path_segment(session_id)}/instructions/entries/{encode_path_segment(key)}", + extra_headers=extra_headers, + extra_query=extra_query, + extra_body=extra_body, + timeout=timeout, + ), + kind="void", ), - kind="void", ) -class AsyncSessionInstructionsResource(AsyncAPIResource): - """Operations under ``client.session.instructions`` (OpenCode ``session.instructions``).""" +class AsyncSessionInstructionsEntryResourceWithRawResponse: + """``client.session.instructions.entry.with_raw_response``.""" + + def __init__(self, resource: AsyncSessionInstructionsEntryResource) -> None: + self._resource = resource + self.list = async_to_raw_response_wrapper(resource.list) + self.put = async_to_raw_response_wrapper(resource.put) + self.remove = async_to_raw_response_wrapper(resource.remove) + + +class AsyncSessionInstructionsEntryResourceWithStreamingResponse: + """``client.session.instructions.entry.with_streaming_response``.""" + + def __init__(self, resource: AsyncSessionInstructionsEntryResource) -> None: + self._resource = resource + self.list = async_to_streamed_response_wrapper(resource.list) + self.put = async_to_streamed_response_wrapper(resource.put) + self.remove = async_to_streamed_response_wrapper(resource.remove) + + +class AsyncSessionInstructionsResource(AsyncAPIResource): + """Operations under ``client.session.instructions`` (OpenCode ``session.instructions``).""" + + @cached_property + def entry(self) -> AsyncSessionInstructionsEntryResource: + """Operations under ``client.session.instructions.entry``.""" + return AsyncSessionInstructionsEntryResource(self._client) + + @cached_property + def with_raw_response(self) -> AsyncSessionInstructionsResourceWithRawResponse: + """Same methods, returning the raw HTTP response; call ``.parse()`` on it for the usual value.""" + return AsyncSessionInstructionsResourceWithRawResponse(self) + + @cached_property + def with_streaming_response(self) -> AsyncSessionInstructionsResourceWithStreamingResponse: + """Same methods, returning a context manager over the HTTP response without reading the body.""" + return AsyncSessionInstructionsResourceWithStreamingResponse(self) + + +class AsyncSessionInstructionsResourceWithRawResponse: + """``client.session.instructions.with_raw_response``.""" + + def __init__(self, resource: AsyncSessionInstructionsResource) -> None: + self._resource = resource + + @cached_property + def entry(self) -> AsyncSessionInstructionsEntryResourceWithRawResponse: + """``client.session.instructions.entry.with_raw_response``.""" + return AsyncSessionInstructionsEntryResourceWithRawResponse(self._resource.entry) + + +class AsyncSessionInstructionsResourceWithStreamingResponse: + """``client.session.instructions.with_streaming_response``.""" + + def __init__(self, resource: AsyncSessionInstructionsResource) -> None: + self._resource = resource @cached_property - def entry(self) -> AsyncSessionInstructionsEntryResource: - """Operations under ``client.session.instructions.entry``.""" - return AsyncSessionInstructionsEntryResource(self._client) + def entry(self) -> AsyncSessionInstructionsEntryResourceWithStreamingResponse: + """``client.session.instructions.entry.with_streaming_response``.""" + return AsyncSessionInstructionsEntryResourceWithStreamingResponse(self._resource.entry) class AsyncSessionMessageResource(AsyncAPIResource): """Operations under ``client.session.message`` (OpenCode ``session.message``).""" + @cached_property + def with_raw_response(self) -> AsyncSessionMessageResourceWithRawResponse: + """Same methods, returning the raw HTTP response; call ``.parse()`` on it for the usual value.""" + return AsyncSessionMessageResourceWithRawResponse(self) + + @cached_property + def with_streaming_response(self) -> AsyncSessionMessageResourceWithStreamingResponse: + """Same methods, returning a context manager over the HTTP response without reading the body.""" + return AsyncSessionMessageResourceWithStreamingResponse(self) + async def get( self, session_id: SessionID, @@ -2205,9 +2737,35 @@ async def get( ) +class AsyncSessionMessageResourceWithRawResponse: + """``client.session.message.with_raw_response``.""" + + def __init__(self, resource: AsyncSessionMessageResource) -> None: + self._resource = resource + self.get = async_to_raw_response_wrapper(resource.get) + + +class AsyncSessionMessageResourceWithStreamingResponse: + """``client.session.message.with_streaming_response``.""" + + def __init__(self, resource: AsyncSessionMessageResource) -> None: + self._resource = resource + self.get = async_to_streamed_response_wrapper(resource.get) + + class AsyncSessionFormResource(AsyncAPIResource): """Operations under ``client.session.form`` (OpenCode ``session.form``).""" + @cached_property + def with_raw_response(self) -> AsyncSessionFormResourceWithRawResponse: + """Same methods, returning the raw HTTP response; call ``.parse()`` on it for the usual value.""" + return AsyncSessionFormResourceWithRawResponse(self) + + @cached_property + def with_streaming_response(self) -> AsyncSessionFormResourceWithStreamingResponse: + """Same methods, returning a context manager over the HTTP response without reading the body.""" + return AsyncSessionFormResourceWithStreamingResponse(self) + async def list( self, session_id: str, @@ -2353,17 +2911,20 @@ async def reply( ``POST /api/session/:sessionID/form/:formID/reply`` """ - await self._client.request( - RequestOptions( - method="POST", - path=f"/api/session/{encode_path_segment(session_id)}/form/{encode_path_segment(form_id)}/reply", - body={"answer": answer}, - extra_headers=extra_headers, - extra_query=extra_query, - extra_body=extra_body, - timeout=timeout, + return cast( + "None", + await self._client.request( + RequestOptions( + method="POST", + path=f"/api/session/{encode_path_segment(session_id)}/form/{encode_path_segment(form_id)}/reply", + body={"answer": answer}, + extra_headers=extra_headers, + extra_query=extra_query, + extra_body=extra_body, + timeout=timeout, + ), + kind="void", ), - kind="void", ) async def cancel( @@ -2391,20 +2952,47 @@ async def cancel( ``DELETE /api/session/:sessionID/form/:formID`` """ - await self._client.request( - RequestOptions( - method="DELETE", - path=f"/api/session/{encode_path_segment(session_id)}/form/{encode_path_segment(form_id)}", - query={"message": message}, - extra_headers=extra_headers, - extra_query=extra_query, - extra_body=extra_body, - timeout=timeout, + return cast( + "None", + await self._client.request( + RequestOptions( + method="DELETE", + path=f"/api/session/{encode_path_segment(session_id)}/form/{encode_path_segment(form_id)}", + query={"message": message}, + extra_headers=extra_headers, + extra_query=extra_query, + extra_body=extra_body, + timeout=timeout, + ), + kind="void", ), - kind="void", ) +class AsyncSessionFormResourceWithRawResponse: + """``client.session.form.with_raw_response``.""" + + def __init__(self, resource: AsyncSessionFormResource) -> None: + self._resource = resource + self.list = async_to_raw_response_wrapper(resource.list) + self.create = async_to_raw_response_wrapper(resource.create) + self.get = async_to_raw_response_wrapper(resource.get) + self.reply = async_to_raw_response_wrapper(resource.reply) + self.cancel = async_to_raw_response_wrapper(resource.cancel) + + +class AsyncSessionFormResourceWithStreamingResponse: + """``client.session.form.with_streaming_response``.""" + + def __init__(self, resource: AsyncSessionFormResource) -> None: + self._resource = resource + self.list = async_to_streamed_response_wrapper(resource.list) + self.create = async_to_streamed_response_wrapper(resource.create) + self.get = async_to_streamed_response_wrapper(resource.get) + self.reply = async_to_streamed_response_wrapper(resource.reply) + self.cancel = async_to_streamed_response_wrapper(resource.cancel) + + class AsyncSessionResource(AsyncSessionHelpers): """Operations under ``client.session`` (OpenCode ``session``).""" @@ -2433,6 +3021,16 @@ def form(self) -> AsyncSessionFormResource: """Operations under ``client.session.form``.""" return AsyncSessionFormResource(self._client) + @cached_property + def with_raw_response(self) -> AsyncSessionResourceWithRawResponse: + """Same methods, returning the raw HTTP response; call ``.parse()`` on it for the usual value.""" + return AsyncSessionResourceWithRawResponse(self) + + @cached_property + def with_streaming_response(self) -> AsyncSessionResourceWithStreamingResponse: + """Same methods, returning a context manager over the HTTP response without reading the body.""" + return AsyncSessionResourceWithStreamingResponse(self) + def list( self, *, @@ -2758,16 +3356,19 @@ async def remove( ``DELETE /api/session/:sessionID`` """ - await self._client.request( - RequestOptions( - method="DELETE", - path=f"/api/session/{encode_path_segment(session_id)}", - extra_headers=extra_headers, - extra_query=extra_query, - extra_body=extra_body, - timeout=timeout, + return cast( + "None", + await self._client.request( + RequestOptions( + method="DELETE", + path=f"/api/session/{encode_path_segment(session_id)}", + extra_headers=extra_headers, + extra_query=extra_query, + extra_body=extra_body, + timeout=timeout, + ), + kind="void", ), - kind="void", ) async def fork( @@ -2832,17 +3433,20 @@ async def switch_agent( ``POST /api/session/:sessionID/agent`` """ - await self._client.request( - RequestOptions( - method="POST", - path=f"/api/session/{encode_path_segment(session_id)}/agent", - body={"agent": agent}, - extra_headers=extra_headers, - extra_query=extra_query, - extra_body=extra_body, - timeout=timeout, + return cast( + "None", + await self._client.request( + RequestOptions( + method="POST", + path=f"/api/session/{encode_path_segment(session_id)}/agent", + body={"agent": agent}, + extra_headers=extra_headers, + extra_query=extra_query, + extra_body=extra_body, + timeout=timeout, + ), + kind="void", ), - kind="void", ) async def switch_model( @@ -2867,17 +3471,20 @@ async def switch_model( ``POST /api/session/:sessionID/model`` """ - await self._client.request( - RequestOptions( - method="POST", - path=f"/api/session/{encode_path_segment(session_id)}/model", - body={"model": model}, - extra_headers=extra_headers, - extra_query=extra_query, - extra_body=extra_body, - timeout=timeout, + return cast( + "None", + await self._client.request( + RequestOptions( + method="POST", + path=f"/api/session/{encode_path_segment(session_id)}/model", + body={"model": model}, + extra_headers=extra_headers, + extra_query=extra_query, + extra_body=extra_body, + timeout=timeout, + ), + kind="void", ), - kind="void", ) async def update( @@ -2908,17 +3515,20 @@ async def update( ``PATCH /api/session/:sessionID`` """ - await self._client.request( - RequestOptions( - method="PATCH", - path=f"/api/session/{encode_path_segment(session_id)}", - body={"title": title, "metadata": metadata, "permissions": permissions, "archived": archived}, - extra_headers=extra_headers, - extra_query=extra_query, - extra_body=extra_body, - timeout=timeout, + return cast( + "None", + await self._client.request( + RequestOptions( + method="PATCH", + path=f"/api/session/{encode_path_segment(session_id)}", + body={"title": title, "metadata": metadata, "permissions": permissions, "archived": archived}, + extra_headers=extra_headers, + extra_query=extra_query, + extra_body=extra_body, + timeout=timeout, + ), + kind="void", ), - kind="void", ) async def move( @@ -2943,17 +3553,20 @@ async def move( ``POST /api/session/:sessionID/move`` """ - await self._client.request( - RequestOptions( - method="POST", - path=f"/api/session/{encode_path_segment(session_id)}/move", - body={"directory": directory, "delivery": delivery}, - extra_headers=extra_headers, - extra_query=extra_query, - extra_body=extra_body, - timeout=timeout, + return cast( + "None", + await self._client.request( + RequestOptions( + method="POST", + path=f"/api/session/{encode_path_segment(session_id)}/move", + body={"directory": directory, "delivery": delivery}, + extra_headers=extra_headers, + extra_query=extra_query, + extra_body=extra_body, + timeout=timeout, + ), + kind="void", ), - kind="void", ) async def prompt( @@ -3041,24 +3654,27 @@ async def command( ``POST /api/session/:sessionID/command`` """ - await self._client.request( - RequestOptions( - method="POST", - path=f"/api/session/{encode_path_segment(session_id)}/command", - body={ - "name": name, - "text": text, - "files": files, - "agents": agents, - "skills": skills, - "delivery": delivery, - }, - extra_headers=extra_headers, - extra_query=extra_query, - extra_body=extra_body, - timeout=timeout, + return cast( + "None", + await self._client.request( + RequestOptions( + method="POST", + path=f"/api/session/{encode_path_segment(session_id)}/command", + body={ + "name": name, + "text": text, + "files": files, + "agents": agents, + "skills": skills, + "delivery": delivery, + }, + extra_headers=extra_headers, + extra_query=extra_query, + extra_body=extra_body, + timeout=timeout, + ), + kind="void", ), - kind="void", ) async def skill( @@ -3087,17 +3703,20 @@ async def skill( ``POST /api/experimental/session/:sessionID/skill`` """ - await self._client.request( - RequestOptions( - method="POST", - path=f"/api/experimental/session/{encode_path_segment(session_id)}/skill", - body={"id": id, "resume": resume}, - extra_headers=extra_headers, - extra_query=extra_query, - extra_body=extra_body, - timeout=timeout, + return cast( + "None", + await self._client.request( + RequestOptions( + method="POST", + path=f"/api/experimental/session/{encode_path_segment(session_id)}/skill", + body={"id": id, "resume": resume}, + extra_headers=extra_headers, + extra_query=extra_query, + extra_body=extra_body, + timeout=timeout, + ), + kind="void", ), - kind="void", ) async def synthetic( @@ -3175,17 +3794,20 @@ async def shell( ``POST /api/session/:sessionID/shell`` """ - await self._client.request( - RequestOptions( - method="POST", - path=f"/api/session/{encode_path_segment(session_id)}/shell", - body={"id": id, "command": command}, - extra_headers=extra_headers, - extra_query=extra_query, - extra_body=extra_body, - timeout=timeout, + return cast( + "None", + await self._client.request( + RequestOptions( + method="POST", + path=f"/api/session/{encode_path_segment(session_id)}/shell", + body={"id": id, "command": command}, + extra_headers=extra_headers, + extra_query=extra_query, + extra_body=extra_body, + timeout=timeout, + ), + kind="void", ), - kind="void", ) async def compact( @@ -3253,16 +3875,19 @@ async def wait( ``POST /api/experimental/session/:sessionID/wait`` """ - await self._client.request( - RequestOptions( - method="POST", - path=f"/api/experimental/session/{encode_path_segment(session_id)}/wait", - extra_headers=extra_headers, - extra_query=extra_query, - extra_body=extra_body, - timeout=timeout, + return cast( + "None", + await self._client.request( + RequestOptions( + method="POST", + path=f"/api/experimental/session/{encode_path_segment(session_id)}/wait", + extra_headers=extra_headers, + extra_query=extra_query, + extra_body=extra_body, + timeout=timeout, + ), + kind="void", ), - kind="void", ) async def context( @@ -3486,16 +4111,19 @@ async def background( ``POST /api/session/:sessionID/background`` """ - await self._client.request( - RequestOptions( - method="POST", - path=f"/api/session/{encode_path_segment(session_id)}/background", - extra_headers=extra_headers, - extra_query=extra_query, - extra_body=extra_body, - timeout=timeout, + return cast( + "None", + await self._client.request( + RequestOptions( + method="POST", + path=f"/api/session/{encode_path_segment(session_id)}/background", + extra_headers=extra_headers, + extra_query=extra_query, + extra_body=extra_body, + timeout=timeout, + ), + kind="void", ), - kind="void", ) async def environment( @@ -3519,17 +4147,20 @@ async def environment( ``PUT /api/session/:sessionID/environment`` """ - await self._client.request( - RequestOptions( - method="PUT", - path=f"/api/session/{encode_path_segment(session_id)}/environment", - body={"variables": variables}, - extra_headers=extra_headers, - extra_query=extra_query, - extra_body=extra_body, - timeout=timeout, + return cast( + "None", + await self._client.request( + RequestOptions( + method="PUT", + path=f"/api/session/{encode_path_segment(session_id)}/environment", + body={"variables": variables}, + extra_headers=extra_headers, + extra_query=extra_query, + extra_body=extra_body, + timeout=timeout, + ), + kind="void", ), - kind="void", ) async def view( @@ -3553,15 +4184,138 @@ async def view( ``POST /api/session/:sessionID/view`` """ - await self._client.request( - RequestOptions( - method="POST", - path=f"/api/session/{encode_path_segment(session_id)}/view", - body={"idle": idle}, - extra_headers=extra_headers, - extra_query=extra_query, - extra_body=extra_body, - timeout=timeout, + return cast( + "None", + await self._client.request( + RequestOptions( + method="POST", + path=f"/api/session/{encode_path_segment(session_id)}/view", + body={"idle": idle}, + extra_headers=extra_headers, + extra_query=extra_query, + extra_body=extra_body, + timeout=timeout, + ), + kind="void", ), - kind="void", ) + + +class AsyncSessionResourceWithRawResponse: + """``client.session.with_raw_response``.""" + + def __init__(self, resource: AsyncSessionResource) -> None: + self._resource = resource + self.list = async_to_raw_response_wrapper(resource.list) + self.stats = async_to_raw_response_wrapper(resource.stats) + self.create = async_to_raw_response_wrapper(resource.create) + self.import_ = async_to_raw_response_wrapper(resource.import_) + self.export = async_to_raw_response_wrapper(resource.export) + self.active = async_to_raw_response_wrapper(resource.active) + self.get = async_to_raw_response_wrapper(resource.get) + self.remove = async_to_raw_response_wrapper(resource.remove) + self.fork = async_to_raw_response_wrapper(resource.fork) + self.switch_agent = async_to_raw_response_wrapper(resource.switch_agent) + self.switch_model = async_to_raw_response_wrapper(resource.switch_model) + self.update = async_to_raw_response_wrapper(resource.update) + self.move = async_to_raw_response_wrapper(resource.move) + self.prompt = async_to_raw_response_wrapper(resource.prompt) + self.command = async_to_raw_response_wrapper(resource.command) + self.skill = async_to_raw_response_wrapper(resource.skill) + self.synthetic = async_to_raw_response_wrapper(resource.synthetic) + self.shell = async_to_raw_response_wrapper(resource.shell) + self.compact = async_to_raw_response_wrapper(resource.compact) + self.wait = async_to_raw_response_wrapper(resource.wait) + self.context = async_to_raw_response_wrapper(resource.context) + self.diff = async_to_raw_response_wrapper(resource.diff) + self.generate = async_to_raw_response_wrapper(resource.generate) + self.log = async_to_raw_response_wrapper(resource.log) + self.interrupt = async_to_raw_response_wrapper(resource.interrupt) + self.background = async_to_raw_response_wrapper(resource.background) + self.environment = async_to_raw_response_wrapper(resource.environment) + self.view = async_to_raw_response_wrapper(resource.view) + + @cached_property + def revert(self) -> AsyncSessionRevertResourceWithRawResponse: + """``client.session.revert.with_raw_response``.""" + return AsyncSessionRevertResourceWithRawResponse(self._resource.revert) + + @cached_property + def inbox(self) -> AsyncSessionInboxResourceWithRawResponse: + """``client.session.inbox.with_raw_response``.""" + return AsyncSessionInboxResourceWithRawResponse(self._resource.inbox) + + @cached_property + def instructions(self) -> AsyncSessionInstructionsResourceWithRawResponse: + """``client.session.instructions.with_raw_response``.""" + return AsyncSessionInstructionsResourceWithRawResponse(self._resource.instructions) + + @cached_property + def message(self) -> AsyncSessionMessageResourceWithRawResponse: + """``client.session.message.with_raw_response``.""" + return AsyncSessionMessageResourceWithRawResponse(self._resource.message) + + @cached_property + def form(self) -> AsyncSessionFormResourceWithRawResponse: + """``client.session.form.with_raw_response``.""" + return AsyncSessionFormResourceWithRawResponse(self._resource.form) + + +class AsyncSessionResourceWithStreamingResponse: + """``client.session.with_streaming_response``.""" + + def __init__(self, resource: AsyncSessionResource) -> None: + self._resource = resource + self.list = async_to_streamed_response_wrapper(resource.list) + self.stats = async_to_streamed_response_wrapper(resource.stats) + self.create = async_to_streamed_response_wrapper(resource.create) + self.import_ = async_to_streamed_response_wrapper(resource.import_) + self.export = async_to_streamed_response_wrapper(resource.export) + self.active = async_to_streamed_response_wrapper(resource.active) + self.get = async_to_streamed_response_wrapper(resource.get) + self.remove = async_to_streamed_response_wrapper(resource.remove) + self.fork = async_to_streamed_response_wrapper(resource.fork) + self.switch_agent = async_to_streamed_response_wrapper(resource.switch_agent) + self.switch_model = async_to_streamed_response_wrapper(resource.switch_model) + self.update = async_to_streamed_response_wrapper(resource.update) + self.move = async_to_streamed_response_wrapper(resource.move) + self.prompt = async_to_streamed_response_wrapper(resource.prompt) + self.command = async_to_streamed_response_wrapper(resource.command) + self.skill = async_to_streamed_response_wrapper(resource.skill) + self.synthetic = async_to_streamed_response_wrapper(resource.synthetic) + self.shell = async_to_streamed_response_wrapper(resource.shell) + self.compact = async_to_streamed_response_wrapper(resource.compact) + self.wait = async_to_streamed_response_wrapper(resource.wait) + self.context = async_to_streamed_response_wrapper(resource.context) + self.diff = async_to_streamed_response_wrapper(resource.diff) + self.generate = async_to_streamed_response_wrapper(resource.generate) + self.log = async_to_streamed_response_wrapper(resource.log) + self.interrupt = async_to_streamed_response_wrapper(resource.interrupt) + self.background = async_to_streamed_response_wrapper(resource.background) + self.environment = async_to_streamed_response_wrapper(resource.environment) + self.view = async_to_streamed_response_wrapper(resource.view) + + @cached_property + def revert(self) -> AsyncSessionRevertResourceWithStreamingResponse: + """``client.session.revert.with_streaming_response``.""" + return AsyncSessionRevertResourceWithStreamingResponse(self._resource.revert) + + @cached_property + def inbox(self) -> AsyncSessionInboxResourceWithStreamingResponse: + """``client.session.inbox.with_streaming_response``.""" + return AsyncSessionInboxResourceWithStreamingResponse(self._resource.inbox) + + @cached_property + def instructions(self) -> AsyncSessionInstructionsResourceWithStreamingResponse: + """``client.session.instructions.with_streaming_response``.""" + return AsyncSessionInstructionsResourceWithStreamingResponse(self._resource.instructions) + + @cached_property + def message(self) -> AsyncSessionMessageResourceWithStreamingResponse: + """``client.session.message.with_streaming_response``.""" + return AsyncSessionMessageResourceWithStreamingResponse(self._resource.message) + + @cached_property + def form(self) -> AsyncSessionFormResourceWithStreamingResponse: + """``client.session.form.with_streaming_response``.""" + return AsyncSessionFormResourceWithStreamingResponse(self._resource.form) diff --git a/src/opencode/resources/shell.py b/src/opencode/resources/shell.py index 6210b02..b7db519 100644 --- a/src/opencode/resources/shell.py +++ b/src/opencode/resources/shell.py @@ -6,11 +6,18 @@ from __future__ import annotations from collections.abc import Mapping +from functools import cached_property from typing import TYPE_CHECKING, Any, cast from .._base_client import RequestOptions from .._qs import encode_path_segment from .._resource import AsyncAPIResource, SyncAPIResource +from .._response import ( + async_to_raw_response_wrapper, + async_to_streamed_response_wrapper, + to_raw_response_wrapper, + to_streamed_response_wrapper, +) from .._types import NOT_GIVEN, Body, Headers, NotGiven, Query, Timeout if TYPE_CHECKING: @@ -29,6 +36,16 @@ class ShellResource(SyncAPIResource): """Operations under ``client.shell`` (OpenCode ``shell``).""" + @cached_property + def with_raw_response(self) -> ShellResourceWithRawResponse: + """Same methods, returning the raw HTTP response; call ``.parse()`` on it for the usual value.""" + return ShellResourceWithRawResponse(self) + + @cached_property + def with_streaming_response(self) -> ShellResourceWithStreamingResponse: + """Same methods, returning a context manager over the HTTP response without reading the body.""" + return ShellResourceWithStreamingResponse(self) + def list( self, *, @@ -205,23 +222,60 @@ def remove( ``DELETE /api/shell/:id`` """ - self._client.request( - RequestOptions( - method="DELETE", - path=f"/api/shell/{encode_path_segment(id)}", - query={"location": self._location(location)}, - extra_headers=extra_headers, - extra_query=extra_query, - extra_body=extra_body, - timeout=timeout, + return cast( + "None", + self._client.request( + RequestOptions( + method="DELETE", + path=f"/api/shell/{encode_path_segment(id)}", + query={"location": self._location(location)}, + extra_headers=extra_headers, + extra_query=extra_query, + extra_body=extra_body, + timeout=timeout, + ), + kind="void", ), - kind="void", ) +class ShellResourceWithRawResponse: + """``client.shell.with_raw_response``.""" + + def __init__(self, resource: ShellResource) -> None: + self._resource = resource + self.list = to_raw_response_wrapper(resource.list) + self.create = to_raw_response_wrapper(resource.create) + self.get = to_raw_response_wrapper(resource.get) + self.output = to_raw_response_wrapper(resource.output) + self.remove = to_raw_response_wrapper(resource.remove) + + +class ShellResourceWithStreamingResponse: + """``client.shell.with_streaming_response``.""" + + def __init__(self, resource: ShellResource) -> None: + self._resource = resource + self.list = to_streamed_response_wrapper(resource.list) + self.create = to_streamed_response_wrapper(resource.create) + self.get = to_streamed_response_wrapper(resource.get) + self.output = to_streamed_response_wrapper(resource.output) + self.remove = to_streamed_response_wrapper(resource.remove) + + class AsyncShellResource(AsyncAPIResource): """Operations under ``client.shell`` (OpenCode ``shell``).""" + @cached_property + def with_raw_response(self) -> AsyncShellResourceWithRawResponse: + """Same methods, returning the raw HTTP response; call ``.parse()`` on it for the usual value.""" + return AsyncShellResourceWithRawResponse(self) + + @cached_property + def with_streaming_response(self) -> AsyncShellResourceWithStreamingResponse: + """Same methods, returning a context manager over the HTTP response without reading the body.""" + return AsyncShellResourceWithStreamingResponse(self) + async def list( self, *, @@ -398,15 +452,42 @@ async def remove( ``DELETE /api/shell/:id`` """ - await self._client.request( - RequestOptions( - method="DELETE", - path=f"/api/shell/{encode_path_segment(id)}", - query={"location": self._location(location)}, - extra_headers=extra_headers, - extra_query=extra_query, - extra_body=extra_body, - timeout=timeout, + return cast( + "None", + await self._client.request( + RequestOptions( + method="DELETE", + path=f"/api/shell/{encode_path_segment(id)}", + query={"location": self._location(location)}, + extra_headers=extra_headers, + extra_query=extra_query, + extra_body=extra_body, + timeout=timeout, + ), + kind="void", ), - kind="void", ) + + +class AsyncShellResourceWithRawResponse: + """``client.shell.with_raw_response``.""" + + def __init__(self, resource: AsyncShellResource) -> None: + self._resource = resource + self.list = async_to_raw_response_wrapper(resource.list) + self.create = async_to_raw_response_wrapper(resource.create) + self.get = async_to_raw_response_wrapper(resource.get) + self.output = async_to_raw_response_wrapper(resource.output) + self.remove = async_to_raw_response_wrapper(resource.remove) + + +class AsyncShellResourceWithStreamingResponse: + """``client.shell.with_streaming_response``.""" + + def __init__(self, resource: AsyncShellResource) -> None: + self._resource = resource + self.list = async_to_streamed_response_wrapper(resource.list) + self.create = async_to_streamed_response_wrapper(resource.create) + self.get = async_to_streamed_response_wrapper(resource.get) + self.output = async_to_streamed_response_wrapper(resource.output) + self.remove = async_to_streamed_response_wrapper(resource.remove) diff --git a/src/opencode/resources/skill.py b/src/opencode/resources/skill.py index f4bab9b..e8f85d9 100644 --- a/src/opencode/resources/skill.py +++ b/src/opencode/resources/skill.py @@ -5,10 +5,17 @@ from __future__ import annotations +from functools import cached_property from typing import TYPE_CHECKING, cast from .._base_client import RequestOptions from .._resource import AsyncAPIResource, SyncAPIResource +from .._response import ( + async_to_raw_response_wrapper, + async_to_streamed_response_wrapper, + to_raw_response_wrapper, + to_streamed_response_wrapper, +) from .._types import NOT_GIVEN, Body, Headers, NotGiven, Query, Timeout if TYPE_CHECKING: @@ -23,6 +30,16 @@ class SkillResource(SyncAPIResource): """Operations under ``client.skill`` (OpenCode ``skill``).""" + @cached_property + def with_raw_response(self) -> SkillResourceWithRawResponse: + """Same methods, returning the raw HTTP response; call ``.parse()`` on it for the usual value.""" + return SkillResourceWithRawResponse(self) + + @cached_property + def with_streaming_response(self) -> SkillResourceWithStreamingResponse: + """Same methods, returning a context manager over the HTTP response without reading the body.""" + return SkillResourceWithStreamingResponse(self) + def list( self, *, @@ -60,9 +77,35 @@ def list( ) +class SkillResourceWithRawResponse: + """``client.skill.with_raw_response``.""" + + def __init__(self, resource: SkillResource) -> None: + self._resource = resource + self.list = to_raw_response_wrapper(resource.list) + + +class SkillResourceWithStreamingResponse: + """``client.skill.with_streaming_response``.""" + + def __init__(self, resource: SkillResource) -> None: + self._resource = resource + self.list = to_streamed_response_wrapper(resource.list) + + class AsyncSkillResource(AsyncAPIResource): """Operations under ``client.skill`` (OpenCode ``skill``).""" + @cached_property + def with_raw_response(self) -> AsyncSkillResourceWithRawResponse: + """Same methods, returning the raw HTTP response; call ``.parse()`` on it for the usual value.""" + return AsyncSkillResourceWithRawResponse(self) + + @cached_property + def with_streaming_response(self) -> AsyncSkillResourceWithStreamingResponse: + """Same methods, returning a context manager over the HTTP response without reading the body.""" + return AsyncSkillResourceWithStreamingResponse(self) + async def list( self, *, @@ -98,3 +141,19 @@ async def list( response_type="SkillListResponse", ), ) + + +class AsyncSkillResourceWithRawResponse: + """``client.skill.with_raw_response``.""" + + def __init__(self, resource: AsyncSkillResource) -> None: + self._resource = resource + self.list = async_to_raw_response_wrapper(resource.list) + + +class AsyncSkillResourceWithStreamingResponse: + """``client.skill.with_streaming_response``.""" + + def __init__(self, resource: AsyncSkillResource) -> None: + self._resource = resource + self.list = async_to_streamed_response_wrapper(resource.list) diff --git a/src/opencode/resources/vcs.py b/src/opencode/resources/vcs.py index c14ba5c..a913df1 100644 --- a/src/opencode/resources/vcs.py +++ b/src/opencode/resources/vcs.py @@ -10,6 +10,12 @@ from .._base_client import RequestOptions from .._resource import AsyncAPIResource, SyncAPIResource +from .._response import ( + async_to_raw_response_wrapper, + async_to_streamed_response_wrapper, + to_raw_response_wrapper, + to_streamed_response_wrapper, +) from .._types import NOT_GIVEN, Body, Headers, NotGiven, Query, Timeout if TYPE_CHECKING: @@ -29,6 +35,16 @@ class VcsBranchResource(SyncAPIResource): """Operations under ``client.vcs.branch`` (OpenCode ``vcs.branch``).""" + @cached_property + def with_raw_response(self) -> VcsBranchResourceWithRawResponse: + """Same methods, returning the raw HTTP response; call ``.parse()`` on it for the usual value.""" + return VcsBranchResourceWithRawResponse(self) + + @cached_property + def with_streaming_response(self) -> VcsBranchResourceWithStreamingResponse: + """Same methods, returning a context manager over the HTTP response without reading the body.""" + return VcsBranchResourceWithStreamingResponse(self) + def list( self, *, @@ -68,6 +84,22 @@ def list( ) +class VcsBranchResourceWithRawResponse: + """``client.vcs.branch.with_raw_response``.""" + + def __init__(self, resource: VcsBranchResource) -> None: + self._resource = resource + self.list = to_raw_response_wrapper(resource.list) + + +class VcsBranchResourceWithStreamingResponse: + """``client.vcs.branch.with_streaming_response``.""" + + def __init__(self, resource: VcsBranchResource) -> None: + self._resource = resource + self.list = to_streamed_response_wrapper(resource.list) + + class VcsResource(SyncAPIResource): """Operations under ``client.vcs`` (OpenCode ``vcs``).""" @@ -76,6 +108,16 @@ def branch(self) -> VcsBranchResource: """Operations under ``client.vcs.branch``.""" return VcsBranchResource(self._client) + @cached_property + def with_raw_response(self) -> VcsResourceWithRawResponse: + """Same methods, returning the raw HTTP response; call ``.parse()`` on it for the usual value.""" + return VcsResourceWithRawResponse(self) + + @cached_property + def with_streaming_response(self) -> VcsResourceWithStreamingResponse: + """Same methods, returning a context manager over the HTTP response without reading the body.""" + return VcsResourceWithStreamingResponse(self) + def init( self, *, @@ -100,17 +142,20 @@ def init( ``POST /api/vcs/init`` """ - self._client.request( - RequestOptions( - method="POST", - path="/api/vcs/init", - query={"location": self._location(location), "provider": provider}, - extra_headers=extra_headers, - extra_query=extra_query, - extra_body=extra_body, - timeout=timeout, + return cast( + "None", + self._client.request( + RequestOptions( + method="POST", + path="/api/vcs/init", + query={"location": self._location(location), "provider": provider}, + extra_headers=extra_headers, + extra_query=extra_query, + extra_body=extra_body, + timeout=timeout, + ), + kind="void", ), - kind="void", ) def get( @@ -263,9 +308,53 @@ def diff( ) +class VcsResourceWithRawResponse: + """``client.vcs.with_raw_response``.""" + + def __init__(self, resource: VcsResource) -> None: + self._resource = resource + self.init = to_raw_response_wrapper(resource.init) + self.get = to_raw_response_wrapper(resource.get) + self.base = to_raw_response_wrapper(resource.base) + self.status = to_raw_response_wrapper(resource.status) + self.diff = to_raw_response_wrapper(resource.diff) + + @cached_property + def branch(self) -> VcsBranchResourceWithRawResponse: + """``client.vcs.branch.with_raw_response``.""" + return VcsBranchResourceWithRawResponse(self._resource.branch) + + +class VcsResourceWithStreamingResponse: + """``client.vcs.with_streaming_response``.""" + + def __init__(self, resource: VcsResource) -> None: + self._resource = resource + self.init = to_streamed_response_wrapper(resource.init) + self.get = to_streamed_response_wrapper(resource.get) + self.base = to_streamed_response_wrapper(resource.base) + self.status = to_streamed_response_wrapper(resource.status) + self.diff = to_streamed_response_wrapper(resource.diff) + + @cached_property + def branch(self) -> VcsBranchResourceWithStreamingResponse: + """``client.vcs.branch.with_streaming_response``.""" + return VcsBranchResourceWithStreamingResponse(self._resource.branch) + + class AsyncVcsBranchResource(AsyncAPIResource): """Operations under ``client.vcs.branch`` (OpenCode ``vcs.branch``).""" + @cached_property + def with_raw_response(self) -> AsyncVcsBranchResourceWithRawResponse: + """Same methods, returning the raw HTTP response; call ``.parse()`` on it for the usual value.""" + return AsyncVcsBranchResourceWithRawResponse(self) + + @cached_property + def with_streaming_response(self) -> AsyncVcsBranchResourceWithStreamingResponse: + """Same methods, returning a context manager over the HTTP response without reading the body.""" + return AsyncVcsBranchResourceWithStreamingResponse(self) + async def list( self, *, @@ -305,6 +394,22 @@ async def list( ) +class AsyncVcsBranchResourceWithRawResponse: + """``client.vcs.branch.with_raw_response``.""" + + def __init__(self, resource: AsyncVcsBranchResource) -> None: + self._resource = resource + self.list = async_to_raw_response_wrapper(resource.list) + + +class AsyncVcsBranchResourceWithStreamingResponse: + """``client.vcs.branch.with_streaming_response``.""" + + def __init__(self, resource: AsyncVcsBranchResource) -> None: + self._resource = resource + self.list = async_to_streamed_response_wrapper(resource.list) + + class AsyncVcsResource(AsyncAPIResource): """Operations under ``client.vcs`` (OpenCode ``vcs``).""" @@ -313,6 +418,16 @@ def branch(self) -> AsyncVcsBranchResource: """Operations under ``client.vcs.branch``.""" return AsyncVcsBranchResource(self._client) + @cached_property + def with_raw_response(self) -> AsyncVcsResourceWithRawResponse: + """Same methods, returning the raw HTTP response; call ``.parse()`` on it for the usual value.""" + return AsyncVcsResourceWithRawResponse(self) + + @cached_property + def with_streaming_response(self) -> AsyncVcsResourceWithStreamingResponse: + """Same methods, returning a context manager over the HTTP response without reading the body.""" + return AsyncVcsResourceWithStreamingResponse(self) + async def init( self, *, @@ -337,17 +452,20 @@ async def init( ``POST /api/vcs/init`` """ - await self._client.request( - RequestOptions( - method="POST", - path="/api/vcs/init", - query={"location": self._location(location), "provider": provider}, - extra_headers=extra_headers, - extra_query=extra_query, - extra_body=extra_body, - timeout=timeout, + return cast( + "None", + await self._client.request( + RequestOptions( + method="POST", + path="/api/vcs/init", + query={"location": self._location(location), "provider": provider}, + extra_headers=extra_headers, + extra_query=extra_query, + extra_body=extra_body, + timeout=timeout, + ), + kind="void", ), - kind="void", ) async def get( @@ -498,3 +616,37 @@ async def diff( response_type="VcsDiffResponse", ), ) + + +class AsyncVcsResourceWithRawResponse: + """``client.vcs.with_raw_response``.""" + + def __init__(self, resource: AsyncVcsResource) -> None: + self._resource = resource + self.init = async_to_raw_response_wrapper(resource.init) + self.get = async_to_raw_response_wrapper(resource.get) + self.base = async_to_raw_response_wrapper(resource.base) + self.status = async_to_raw_response_wrapper(resource.status) + self.diff = async_to_raw_response_wrapper(resource.diff) + + @cached_property + def branch(self) -> AsyncVcsBranchResourceWithRawResponse: + """``client.vcs.branch.with_raw_response``.""" + return AsyncVcsBranchResourceWithRawResponse(self._resource.branch) + + +class AsyncVcsResourceWithStreamingResponse: + """``client.vcs.with_streaming_response``.""" + + def __init__(self, resource: AsyncVcsResource) -> None: + self._resource = resource + self.init = async_to_streamed_response_wrapper(resource.init) + self.get = async_to_streamed_response_wrapper(resource.get) + self.base = async_to_streamed_response_wrapper(resource.base) + self.status = async_to_streamed_response_wrapper(resource.status) + self.diff = async_to_streamed_response_wrapper(resource.diff) + + @cached_property + def branch(self) -> AsyncVcsBranchResourceWithStreamingResponse: + """``client.vcs.branch.with_streaming_response``.""" + return AsyncVcsBranchResourceWithStreamingResponse(self._resource.branch) diff --git a/src/opencode/resources/voice.py b/src/opencode/resources/voice.py index ae2f608..4647041 100644 --- a/src/opencode/resources/voice.py +++ b/src/opencode/resources/voice.py @@ -6,10 +6,17 @@ from __future__ import annotations from collections.abc import Mapping +from functools import cached_property from typing import TYPE_CHECKING, Any, cast from .._base_client import RequestOptions from .._resource import AsyncAPIResource, SyncAPIResource +from .._response import ( + async_to_raw_response_wrapper, + async_to_streamed_response_wrapper, + to_raw_response_wrapper, + to_streamed_response_wrapper, +) from .._types import NOT_GIVEN, Body, Headers, NotGiven, Query, Timeout if TYPE_CHECKING: @@ -24,6 +31,16 @@ class VoiceResource(SyncAPIResource): """Operations under ``client.voice`` (OpenCode ``voice``).""" + @cached_property + def with_raw_response(self) -> VoiceResourceWithRawResponse: + """Same methods, returning the raw HTTP response; call ``.parse()`` on it for the usual value.""" + return VoiceResourceWithRawResponse(self) + + @cached_property + def with_streaming_response(self) -> VoiceResourceWithStreamingResponse: + """Same methods, returning a context manager over the HTTP response without reading the body.""" + return VoiceResourceWithStreamingResponse(self) + def session( self, *, @@ -67,9 +84,35 @@ def session( ) +class VoiceResourceWithRawResponse: + """``client.voice.with_raw_response``.""" + + def __init__(self, resource: VoiceResource) -> None: + self._resource = resource + self.session = to_raw_response_wrapper(resource.session) + + +class VoiceResourceWithStreamingResponse: + """``client.voice.with_streaming_response``.""" + + def __init__(self, resource: VoiceResource) -> None: + self._resource = resource + self.session = to_streamed_response_wrapper(resource.session) + + class AsyncVoiceResource(AsyncAPIResource): """Operations under ``client.voice`` (OpenCode ``voice``).""" + @cached_property + def with_raw_response(self) -> AsyncVoiceResourceWithRawResponse: + """Same methods, returning the raw HTTP response; call ``.parse()`` on it for the usual value.""" + return AsyncVoiceResourceWithRawResponse(self) + + @cached_property + def with_streaming_response(self) -> AsyncVoiceResourceWithStreamingResponse: + """Same methods, returning a context manager over the HTTP response without reading the body.""" + return AsyncVoiceResourceWithStreamingResponse(self) + async def session( self, *, @@ -111,3 +154,19 @@ async def session( unwrap=True, ), ) + + +class AsyncVoiceResourceWithRawResponse: + """``client.voice.with_raw_response``.""" + + def __init__(self, resource: AsyncVoiceResource) -> None: + self._resource = resource + self.session = async_to_raw_response_wrapper(resource.session) + + +class AsyncVoiceResourceWithStreamingResponse: + """``client.voice.with_streaming_response``.""" + + def __init__(self, resource: AsyncVoiceResource) -> None: + self._resource = resource + self.session = async_to_streamed_response_wrapper(resource.session) diff --git a/src/opencode/resources/websearch.py b/src/opencode/resources/websearch.py index a232751..e245a42 100644 --- a/src/opencode/resources/websearch.py +++ b/src/opencode/resources/websearch.py @@ -5,10 +5,17 @@ from __future__ import annotations +from functools import cached_property from typing import TYPE_CHECKING, cast from .._base_client import RequestOptions from .._resource import AsyncAPIResource, SyncAPIResource +from .._response import ( + async_to_raw_response_wrapper, + async_to_streamed_response_wrapper, + to_raw_response_wrapper, + to_streamed_response_wrapper, +) from .._types import NOT_GIVEN, Body, Headers, NotGiven, Query, Timeout if TYPE_CHECKING: @@ -25,6 +32,16 @@ class WebsearchResource(SyncAPIResource): """Operations under ``client.websearch`` (OpenCode ``websearch``).""" + @cached_property + def with_raw_response(self) -> WebsearchResourceWithRawResponse: + """Same methods, returning the raw HTTP response; call ``.parse()`` on it for the usual value.""" + return WebsearchResourceWithRawResponse(self) + + @cached_property + def with_streaming_response(self) -> WebsearchResourceWithStreamingResponse: + """Same methods, returning a context manager over the HTTP response without reading the body.""" + return WebsearchResourceWithStreamingResponse(self) + def providers( self, *, @@ -103,9 +120,37 @@ def query( ) +class WebsearchResourceWithRawResponse: + """``client.websearch.with_raw_response``.""" + + def __init__(self, resource: WebsearchResource) -> None: + self._resource = resource + self.providers = to_raw_response_wrapper(resource.providers) + self.query = to_raw_response_wrapper(resource.query) + + +class WebsearchResourceWithStreamingResponse: + """``client.websearch.with_streaming_response``.""" + + def __init__(self, resource: WebsearchResource) -> None: + self._resource = resource + self.providers = to_streamed_response_wrapper(resource.providers) + self.query = to_streamed_response_wrapper(resource.query) + + class AsyncWebsearchResource(AsyncAPIResource): """Operations under ``client.websearch`` (OpenCode ``websearch``).""" + @cached_property + def with_raw_response(self) -> AsyncWebsearchResourceWithRawResponse: + """Same methods, returning the raw HTTP response; call ``.parse()`` on it for the usual value.""" + return AsyncWebsearchResourceWithRawResponse(self) + + @cached_property + def with_streaming_response(self) -> AsyncWebsearchResourceWithStreamingResponse: + """Same methods, returning a context manager over the HTTP response without reading the body.""" + return AsyncWebsearchResourceWithStreamingResponse(self) + async def providers( self, *, @@ -182,3 +227,21 @@ async def query( response_type="WebsearchQueryResponse", ), ) + + +class AsyncWebsearchResourceWithRawResponse: + """``client.websearch.with_raw_response``.""" + + def __init__(self, resource: AsyncWebsearchResource) -> None: + self._resource = resource + self.providers = async_to_raw_response_wrapper(resource.providers) + self.query = async_to_raw_response_wrapper(resource.query) + + +class AsyncWebsearchResourceWithStreamingResponse: + """``client.websearch.with_streaming_response``.""" + + def __init__(self, resource: AsyncWebsearchResource) -> None: + self._resource = resource + self.providers = async_to_streamed_response_wrapper(resource.providers) + self.query = async_to_streamed_response_wrapper(resource.query) diff --git a/src/opencode/resources/worktree.py b/src/opencode/resources/worktree.py index 4ddaaf2..d44b906 100644 --- a/src/opencode/resources/worktree.py +++ b/src/opencode/resources/worktree.py @@ -5,10 +5,17 @@ from __future__ import annotations +from functools import cached_property from typing import TYPE_CHECKING, cast from .._base_client import RequestOptions from .._resource import AsyncAPIResource, SyncAPIResource +from .._response import ( + async_to_raw_response_wrapper, + async_to_streamed_response_wrapper, + to_raw_response_wrapper, + to_streamed_response_wrapper, +) from .._types import NOT_GIVEN, Body, Headers, NotGiven, Query, Timeout if TYPE_CHECKING: @@ -25,6 +32,16 @@ class WorktreeResource(SyncAPIResource): """Operations under ``client.worktree`` (OpenCode ``worktree``).""" + @cached_property + def with_raw_response(self) -> WorktreeResourceWithRawResponse: + """Same methods, returning the raw HTTP response; call ``.parse()`` on it for the usual value.""" + return WorktreeResourceWithRawResponse(self) + + @cached_property + def with_streaming_response(self) -> WorktreeResourceWithStreamingResponse: + """Same methods, returning a context manager over the HTTP response without reading the body.""" + return WorktreeResourceWithStreamingResponse(self) + def list( self, *, @@ -131,17 +148,20 @@ def remove( ``DELETE /api/worktree`` """ - self._client.request( - RequestOptions( - method="DELETE", - path="/api/worktree", - body={"projectID": project_id, "directory": directory, "force": force}, - extra_headers=extra_headers, - extra_query=extra_query, - extra_body=extra_body, - timeout=timeout, + return cast( + "None", + self._client.request( + RequestOptions( + method="DELETE", + path="/api/worktree", + body={"projectID": project_id, "directory": directory, "force": force}, + extra_headers=extra_headers, + extra_query=extra_query, + extra_body=extra_body, + timeout=timeout, + ), + kind="void", ), - kind="void", ) def refresh( @@ -165,23 +185,58 @@ def refresh( ``POST /api/worktree/refresh`` """ - self._client.request( - RequestOptions( - method="POST", - path="/api/worktree/refresh", - body={"projectID": project_id}, - extra_headers=extra_headers, - extra_query=extra_query, - extra_body=extra_body, - timeout=timeout, + return cast( + "None", + self._client.request( + RequestOptions( + method="POST", + path="/api/worktree/refresh", + body={"projectID": project_id}, + extra_headers=extra_headers, + extra_query=extra_query, + extra_body=extra_body, + timeout=timeout, + ), + kind="void", ), - kind="void", ) +class WorktreeResourceWithRawResponse: + """``client.worktree.with_raw_response``.""" + + def __init__(self, resource: WorktreeResource) -> None: + self._resource = resource + self.list = to_raw_response_wrapper(resource.list) + self.create = to_raw_response_wrapper(resource.create) + self.remove = to_raw_response_wrapper(resource.remove) + self.refresh = to_raw_response_wrapper(resource.refresh) + + +class WorktreeResourceWithStreamingResponse: + """``client.worktree.with_streaming_response``.""" + + def __init__(self, resource: WorktreeResource) -> None: + self._resource = resource + self.list = to_streamed_response_wrapper(resource.list) + self.create = to_streamed_response_wrapper(resource.create) + self.remove = to_streamed_response_wrapper(resource.remove) + self.refresh = to_streamed_response_wrapper(resource.refresh) + + class AsyncWorktreeResource(AsyncAPIResource): """Operations under ``client.worktree`` (OpenCode ``worktree``).""" + @cached_property + def with_raw_response(self) -> AsyncWorktreeResourceWithRawResponse: + """Same methods, returning the raw HTTP response; call ``.parse()`` on it for the usual value.""" + return AsyncWorktreeResourceWithRawResponse(self) + + @cached_property + def with_streaming_response(self) -> AsyncWorktreeResourceWithStreamingResponse: + """Same methods, returning a context manager over the HTTP response without reading the body.""" + return AsyncWorktreeResourceWithStreamingResponse(self) + async def list( self, *, @@ -288,17 +343,20 @@ async def remove( ``DELETE /api/worktree`` """ - await self._client.request( - RequestOptions( - method="DELETE", - path="/api/worktree", - body={"projectID": project_id, "directory": directory, "force": force}, - extra_headers=extra_headers, - extra_query=extra_query, - extra_body=extra_body, - timeout=timeout, + return cast( + "None", + await self._client.request( + RequestOptions( + method="DELETE", + path="/api/worktree", + body={"projectID": project_id, "directory": directory, "force": force}, + extra_headers=extra_headers, + extra_query=extra_query, + extra_body=extra_body, + timeout=timeout, + ), + kind="void", ), - kind="void", ) async def refresh( @@ -322,15 +380,40 @@ async def refresh( ``POST /api/worktree/refresh`` """ - await self._client.request( - RequestOptions( - method="POST", - path="/api/worktree/refresh", - body={"projectID": project_id}, - extra_headers=extra_headers, - extra_query=extra_query, - extra_body=extra_body, - timeout=timeout, + return cast( + "None", + await self._client.request( + RequestOptions( + method="POST", + path="/api/worktree/refresh", + body={"projectID": project_id}, + extra_headers=extra_headers, + extra_query=extra_query, + extra_body=extra_body, + timeout=timeout, + ), + kind="void", ), - kind="void", ) + + +class AsyncWorktreeResourceWithRawResponse: + """``client.worktree.with_raw_response``.""" + + def __init__(self, resource: AsyncWorktreeResource) -> None: + self._resource = resource + self.list = async_to_raw_response_wrapper(resource.list) + self.create = async_to_raw_response_wrapper(resource.create) + self.remove = async_to_raw_response_wrapper(resource.remove) + self.refresh = async_to_raw_response_wrapper(resource.refresh) + + +class AsyncWorktreeResourceWithStreamingResponse: + """``client.worktree.with_streaming_response``.""" + + def __init__(self, resource: AsyncWorktreeResource) -> None: + self._resource = resource + self.list = async_to_streamed_response_wrapper(resource.list) + self.create = async_to_streamed_response_wrapper(resource.create) + self.remove = async_to_streamed_response_wrapper(resource.remove) + self.refresh = async_to_streamed_response_wrapper(resource.refresh) diff --git a/tests/test_aiohttp.py b/tests/test_aiohttp.py new file mode 100644 index 0000000..ff7cae3 --- /dev/null +++ b/tests/test_aiohttp.py @@ -0,0 +1,131 @@ +"""`DefaultAioHttpClient` against a real aiohttp server. Skipped unless the ``aiohttp`` extra is installed.""" + +from __future__ import annotations + +import asyncio +import importlib +import sys +from collections.abc import AsyncIterator, Awaitable, Callable + +import pytest + +from opencode import APITimeoutError, AsyncOpencode, DefaultAioHttpClient +from opencode.types import ServerConnectedEvent + +pytestmark = pytest.mark.anyio + +SESSION = { + "id": "ses_1", + "projectID": "prj_1", + "cost": 0, + "tokens": {"input": 0, "output": 0, "reasoning": 0, "cache": {"read": 0, "write": 0}}, + "time": {"created": 1, "updated": 1}, + "title": "Hello", + "location": {"directory": "/repo"}, +} +CONNECTED = '{"type":"server.connected","id":"evt_1","created":1,"data":{}}' + + +def test_missing_extra_raises(monkeypatch: pytest.MonkeyPatch) -> None: + monkeypatch.setitem(sys.modules, "httpx_aiohttp", None) + module = importlib.reload(importlib.import_module("opencode._aiohttp")) + try: + with pytest.raises(RuntimeError, match=r"opencode-python-sdk\[aiohttp\]"): + module.DefaultAioHttpClient() + finally: + monkeypatch.undo() + importlib.reload(module) + + +@pytest.fixture +async def server_url() -> AsyncIterator[str]: + pytest.importorskip("httpx_aiohttp") + from aiohttp import web + from aiohttp.test_utils import TestServer + + attempts = {"retry": 0} + + async def session(request: web.Request) -> web.Response: + body = await request.json() + return web.json_response({"data": {**SESSION, "title": body["title"]}}) + + async def flaky(request: web.Request) -> web.Response: + attempts["retry"] += 1 + if attempts["retry"] == 1: + return web.json_response({"_tag": "UnknownError", "message": "busy"}, status=503) + return web.json_response({"data": {**SESSION, "title": "retried"}}) + + async def slow(request: web.Request) -> web.Response: + await asyncio.sleep(5) + return web.json_response({"data": SESSION}) + + async def events(request: web.Request) -> web.StreamResponse: + response = web.StreamResponse(headers={"Content-Type": "text/event-stream"}) + await response.prepare(request) + await response.write(b": hi\n\n") + # Split one event across writes to check the decoder reassembles aiohttp's chunks. + await response.write(f"data: {CONNECTED[:20]}".encode()) + await response.write(f"{CONNECTED[20:]}\n\n".encode()) + await response.write_eof() + return response + + modes = {"retry": flaky, "slow": slow} + + # The retry and timeout cases reuse the session route, picked by a header. + @web.middleware + async def switch( + request: web.Request, handler: Callable[[web.Request], Awaitable[web.StreamResponse]] + ) -> web.StreamResponse: + mode = request.headers.get("X-Test-Mode") + return await modes[mode](request) if mode else await handler(request) + + app = web.Application(middlewares=[switch]) + app.router.add_post("/api/session", session) + app.router.add_get("/api/event", events) + server = TestServer(app, host="127.0.0.1") + await server.start_server() + try: + yield str(server.make_url("/")) + finally: + await server.close() + + +async def test_request_and_body(server_url: str) -> None: + async with DefaultAioHttpClient() as http, AsyncOpencode(server_url, password="", http_client=http) as client: + session = await client.session.create(title="Hello") + assert session.title == "Hello" + + +async def test_event_stream(server_url: str) -> None: + async with DefaultAioHttpClient() as http, AsyncOpencode(server_url, password="", http_client=http) as client: # noqa: SIM117 + async with await client.event.subscribe() as stream: + received = [event async for event in stream] + assert len(received) == 1 + assert isinstance(received[0], ServerConnectedEvent) + + +async def test_retries_server_errors(server_url: str) -> None: + async with ( + DefaultAioHttpClient() as http, + AsyncOpencode( + server_url, password="", http_client=http, max_retries=2, default_headers={"X-Test-Mode": "retry"} + ) as client, + ): + session = await client.session.create(title="ignored") + assert session.title == "retried" + + +async def test_timeout(server_url: str) -> None: + async with ( + DefaultAioHttpClient() as http, + AsyncOpencode( + server_url, + password="", + http_client=http, + max_retries=0, + timeout=0.2, + default_headers={"X-Test-Mode": "slow"}, + ) as client, + ): + with pytest.raises(APITimeoutError): + await client.session.create(title="slow") diff --git a/tests/test_logs.py b/tests/test_logs.py new file mode 100644 index 0000000..00d21d8 --- /dev/null +++ b/tests/test_logs.py @@ -0,0 +1,45 @@ +from __future__ import annotations + +import logging +from collections.abc import Iterator + +import pytest + +from opencode._logs import logger, setup_logging + + +@pytest.fixture(autouse=True) +def _restore_logger() -> Iterator[None]: + handlers, level = list(logger.handlers), logger.level + yield + logger.handlers[:] = handlers + logger.setLevel(level) + + +def _env_handlers() -> list[logging.Handler]: + return [h for h in logger.handlers if getattr(h, "_opencode_env", False)] + + +@pytest.mark.parametrize( + ("value", "level"), [("debug", logging.DEBUG), ("INFO", logging.INFO), (" Debug ", logging.DEBUG)] +) +def test_opencode_log_sets_level(monkeypatch: pytest.MonkeyPatch, value: str, level: int) -> None: + logger.handlers[:] = [] + monkeypatch.setenv("OPENCODE_LOG", value) + setup_logging() + setup_logging() + assert logger.level == level + assert len(_env_handlers()) == 1 + + +@pytest.mark.parametrize("value", [None, "", "warning", "verbose"]) +def test_opencode_log_ignored(monkeypatch: pytest.MonkeyPatch, value: str | None) -> None: + logger.handlers[:] = [] + logger.setLevel(logging.NOTSET) + if value is None: + monkeypatch.delenv("OPENCODE_LOG", raising=False) + else: + monkeypatch.setenv("OPENCODE_LOG", value) + setup_logging() + assert logger.level == logging.NOTSET + assert _env_handlers() == [] diff --git a/tests/test_response.py b/tests/test_response.py new file mode 100644 index 0000000..0cad3ee --- /dev/null +++ b/tests/test_response.py @@ -0,0 +1,155 @@ +from __future__ import annotations + +import pytest +import respx + +from opencode import ( + APIResponse, + AsyncAPIResponse, + AsyncCursorPage, + AsyncOpencode, + NotFoundError, + Opencode, + Stream, + SyncCursorPage, +) +from opencode.types import ServerConnectedEvent, SessionInfo + +from .test_client import SESSION + +CONNECTED = '{"type":"server.connected","id":"evt_1","created":1,"data":{}}' +SSE = {"content-type": "text/event-stream"} + + +def _page(ids: list[str], next_cursor: str | None) -> dict[str, object]: + return { + "data": [{"type": "user", "id": item, "time": {"created": 1}, "text": item} for item in ids], + "cursor": {"previous": None, "next": next_cursor}, + } + + +def test_raw_response(client: Opencode, mock_api: respx.MockRouter) -> None: + mock_api.get("/api/session/ses_1").respond(json={"data": SESSION}, headers={"x-request-id": "req_1"}) + response = client.session.with_raw_response.get("ses_1") + assert isinstance(response, APIResponse) + assert response.status_code == 200 + assert response.headers["x-request-id"] == "req_1" + assert response.request.method == "GET" + assert response.http_response.is_success + assert response.json() == {"data": SESSION} + assert '"ses_1"' in response.text + session = response.parse() + assert isinstance(session, SessionInfo) + assert session.id == "ses_1" + assert response.parse() is session + + +def test_raw_response_void_binary_and_nested(client: Opencode, mock_api: respx.MockRouter) -> None: + mock_api.delete("/api/session/ses_1/revert").respond(204) + mock_api.get("/api/fs/read/a.txt").respond(content=b"hello") + assert client.session.revert.with_raw_response.clear("ses_1").parse() is None + assert client.file.with_raw_response.read("a.txt").parse() == b"hello" + + +def test_raw_response_still_raises_status_errors(client: Opencode, mock_api: respx.MockRouter) -> None: + mock_api.get("/api/session/ses_9").respond(404, json={"message": "nope"}) + with pytest.raises(NotFoundError): + client.session.with_raw_response.get("ses_9") + + +def test_raw_mode_does_not_leak(client: Opencode, mock_api: respx.MockRouter) -> None: + mock_api.get("/api/session/ses_1").respond(json={"data": SESSION}) + client.session.with_raw_response.get("ses_1") + assert isinstance(client.session.get("ses_1"), SessionInfo) + + +def test_raw_page_parses_to_a_working_page(client: Opencode, mock_api: respx.MockRouter) -> None: + mock_api.get("/api/session/ses_1/message").mock( + side_effect=[respx.MockResponse(json=_page(["a"], "c1")), respx.MockResponse(json=_page(["b"], None))] + ) + response = client.message.with_raw_response.list("ses_1") + page = response.parse() + assert isinstance(page, SyncCursorPage) + assert [message.id for message in page] == ["a", "b"] + + +def test_streaming_response(client: Opencode, mock_api: respx.MockRouter) -> None: + mock_api.get("/api/fs/read/a.txt").respond(content=b"line 1\nline 2\n") + with client.file.with_streaming_response.read("a.txt") as response: + assert not response.http_response.is_stream_consumed + assert list(response.iter_lines()) == ["line 1", "line 2"] + assert response.is_closed + + +def test_streaming_response_parse(client: Opencode, mock_api: respx.MockRouter) -> None: + mock_api.get("/api/session/ses_1").respond(json={"data": SESSION}) + with client.session.with_streaming_response.get("ses_1") as response: + assert response.parse().id == "ses_1" + + +def test_raw_event_stream(client: Opencode, mock_api: respx.MockRouter) -> None: + mock_api.get("/api/event").respond(headers=SSE, content=f"data: {CONNECTED}\n\n".encode()) + response = client.event.with_raw_response.subscribe() + assert response.headers["content-type"] == "text/event-stream" + with response.parse() as events: + assert isinstance(events, Stream) + assert isinstance(next(iter(events)), ServerConnectedEvent) + + +@pytest.mark.anyio +async def test_async_raw_response(async_client: AsyncOpencode, mock_api: respx.MockRouter) -> None: + mock_api.get("/api/session/ses_1").respond(json={"data": SESSION}, headers={"x-request-id": "req_1"}) + response = await async_client.session.with_raw_response.get("ses_1") + assert isinstance(response, AsyncAPIResponse) + assert response.headers["x-request-id"] == "req_1" + assert (await response.json()) == {"data": SESSION} + assert (await response.parse()).id == "ses_1" + + +@pytest.mark.anyio +async def test_async_raw_page(async_client: AsyncOpencode, mock_api: respx.MockRouter) -> None: + mock_api.get("/api/session/ses_1/message").mock( + side_effect=[respx.MockResponse(json=_page(["a"], "c1")), respx.MockResponse(json=_page(["b"], None))] + ) + response = await async_client.message.with_raw_response.list("ses_1") + page = await response.parse() + assert isinstance(page, AsyncCursorPage) + assert [message.id async for message in page] == ["a", "b"] + + +@pytest.mark.anyio +async def test_async_streaming_response(async_client: AsyncOpencode, mock_api: respx.MockRouter) -> None: + mock_api.get("/api/fs/read/a.txt").respond(content=b"hello") + async with async_client.file.with_streaming_response.read("a.txt") as response: + assert b"".join([chunk async for chunk in response.iter_bytes()]) == b"hello" + assert response.is_closed + mock_api.get("/api/session/ses_1").respond(json={"data": SESSION}) + async with async_client.session.with_streaming_response.get("ses_1") as response: + assert (await response.parse()).id == "ses_1" + + +@pytest.mark.anyio +async def test_async_raw_event_stream(async_client: AsyncOpencode, mock_api: respx.MockRouter) -> None: + mock_api.get("/api/event").respond(headers=SSE, content=f"data: {CONNECTED}\n\n".encode()) + response = await async_client.event.with_raw_response.subscribe() + async with await response.parse() as events: + async for event in events: + assert isinstance(event, ServerConnectedEvent) + break + + +def test_custom_requests(client: Opencode, mock_api: respx.MockRouter) -> None: + route = mock_api.post("/api/custom").respond(json={"ok": True}) + assert client.post("/api/custom", body={"a": 1}, query={"q": "x"}, headers={"X-A": "b"}) == {"ok": True} + request = route.calls.last.request + assert request.content == b'{"a":1}' + assert request.url.params["q"] == "x" + assert request.headers["X-A"] == "b" + mock_api.get("/api/session/ses_1").respond(json={"data": SESSION}) + assert client.get("/api/session/ses_1", cast_to=dict[str, SessionInfo])["data"].id == "ses_1" + + +@pytest.mark.anyio +async def test_async_custom_requests(async_client: AsyncOpencode, mock_api: respx.MockRouter) -> None: + mock_api.delete("/api/custom").respond(json=[1]) + assert await async_client.delete("/api/custom", cast_to=list[int]) == [1] diff --git a/tests/test_with_options.py b/tests/test_with_options.py new file mode 100644 index 0000000..af57a4c --- /dev/null +++ b/tests/test_with_options.py @@ -0,0 +1,76 @@ +from __future__ import annotations + +import pytest +import respx + +from opencode import AsyncOpencode, Opencode + +from .conftest import BASE_URL + +AGENTS: dict[str, object] = {"location": {"directory": "/repo"}, "data": []} + + +@pytest.mark.parametrize("method", ["with_options", "copy"]) +def test_overrides_apply_and_original_unchanged(mock_api: respx.MockRouter, method: str) -> None: + route = mock_api.get("/api/agent").respond(json=AGENTS) + with Opencode( + BASE_URL, password="pw", directory="/repo", timeout=5.0, max_retries=3, default_headers={"X-A": "1"} + ) as client: + other = getattr(client, method)( + password="other", + directory="/elsewhere", + timeout=1.0, + max_retries=0, + default_headers={"X-B": "2"}, + default_query={"q": "2"}, + ) + assert isinstance(other, Opencode) + assert (other.max_retries, other.timeout, other.directory, other.password) == (0, 1.0, "/elsewhere", "other") + other.agent.list() + request = route.calls.last.request + assert request.headers["X-A"] == "1" + assert request.headers["X-B"] == "2" + assert request.url.params["q"] == "2" + assert request.url.params["location[directory]"] == "/elsewhere" + + assert (client.max_retries, client.timeout, client.directory, client.password) == (3, 5.0, "/repo", "pw") + assert "X-B" not in client._default_headers + + +def test_base_url_override(mock_api: respx.MockRouter) -> None: + with Opencode(BASE_URL, password="") as client: + other = client.with_options(base_url="http://other.test") + assert other.base_url.host == "other.test" + assert str(client.base_url).startswith(BASE_URL) + + +def test_copy_does_not_close_shared_pool(mock_api: respx.MockRouter) -> None: + route = mock_api.get("/api/agent").respond(json=AGENTS) + client = Opencode(BASE_URL, password="") + with client.copy(max_retries=0) as other: + assert other._http is client._http + assert not client._http.is_closed + client.agent.list() + assert route.called + client.close() + assert client._http.is_closed + + +@pytest.mark.anyio +@pytest.mark.parametrize("method", ["with_options", "copy"]) +async def test_async_overrides_and_shared_pool(mock_api: respx.MockRouter, method: str) -> None: + route = mock_api.get("/api/agent").respond(json=AGENTS) + client = AsyncOpencode(BASE_URL, password="", directory="/repo", max_retries=3, default_headers={"X-A": "1"}) + async with getattr(client, method)(directory="/elsewhere", max_retries=0, default_headers={"X-B": "2"}) as other: + assert isinstance(other, AsyncOpencode) + assert other._http is client._http + assert other.max_retries == 0 + await other.agent.list() + request = route.calls.last.request + assert (request.headers["X-A"], request.headers["X-B"]) == ("1", "2") + assert request.url.params["location[directory]"] == "/elsewhere" + assert not client._http.is_closed + assert (client.max_retries, client.directory) == (3, "/repo") + await client.agent.list() + await client.close() + assert client._http.is_closed diff --git a/uv.lock b/uv.lock index cc5e2c3..4310bb2 100644 --- a/uv.lock +++ b/uv.lock @@ -7,6 +7,207 @@ resolution-markers = [ "python_full_version < '3.11'", ] +[[package]] +name = "aiohappyeyeballs" +version = "2.7.1" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/ce/f4/eec0465c2f67b2664688d0240b3212d5196fd89e741df67ddb81f8d35658/aiohappyeyeballs-2.7.1.tar.gz", hash = "sha256:065665c041c42a5938ed220bdcd7230f22527fbec085e1853d2402c8a3615d9d", size = 24757, upload-time = "2026-07-01T17:11:55.501Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/71/43/1947f06babed6b3f1d7f38b0c767f52df66bfb2bc10b468c4a7de9eceff2/aiohappyeyeballs-2.7.1-py3-none-any.whl", hash = "sha256:9243213661e29250eb41368e5daa826fc017156c3b8a11440826b2e3ed376472", size = 15038, upload-time = "2026-07-01T17:11:54.055Z" }, +] + +[[package]] +name = "aiohttp" +version = "3.14.5" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "aiohappyeyeballs" }, + { name = "aiosignal" }, + { name = "async-timeout", marker = "python_full_version < '3.11'" }, + { name = "attrs" }, + { name = "frozenlist" }, + { name = "multidict" }, + { name = "propcache" }, + { name = "typing-extensions", marker = "python_full_version < '3.13'" }, + { name = "yarl" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/6c/4c/bdccd81e9ee225b69c60e7766c9a5b05364f118f4d383713b89a682d772d/aiohttp-3.14.5.tar.gz", hash = "sha256:5558a7f5a05af9ecf744af91e5baefc436f93c9333e656c27ec253f9a6bbe178", size = 8078052, upload-time = "2026-10-11T01:05:12.408Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/ca/82/f7f0652e3a845e095d8505a2807a0fe5782abb71f99b2f516c93ff0be492/aiohttp-3.14.5-cp310-cp310-macosx_10_9_universal2.whl", hash = "sha256:ef692a24087a699c0a4a26af45e746e0c1eae2116f6d8a5ff91d8aae2b867b45", size = 834351, upload-time = "2026-10-11T00:59:07.668Z" }, + { url = "https://files.pythonhosted.org/packages/95/c5/10cb0a5195bc3ec05a74ee494f8431a15e559800f2e869f3526ad4a16f04/aiohttp-3.14.5-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:1220353657ad49493551f089ce02f1a348fd57ffd585bfec77f2f3c4fe3a7346", size = 560663, upload-time = "2026-10-11T00:59:09.853Z" }, + { url = "https://files.pythonhosted.org/packages/32/dc/b7fefdd7dd64d080da2d69d609344191cc94b0e2eba70200c371014c9b36/aiohttp-3.14.5-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:330900acd0dc4cb8b27f9c127fbaad770964845338493e7906ae3822e82dbf8d", size = 553263, upload-time = "2026-10-11T00:59:11.5Z" }, + { url = "https://files.pythonhosted.org/packages/61/5f/3271cad1b34347e8bf27abee20d501ebdc56cec97e8ae59cd3fabb23d917/aiohttp-3.14.5-cp310-cp310-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:0684952aeae1f5dbfe02d46039338513b94009baecd15d8e4098a357c4c4a2a6", size = 1843813, upload-time = "2026-10-11T00:59:13.143Z" }, + { url = "https://files.pythonhosted.org/packages/67/af/2011b30fe61889af112ad380e6fd44a93cca4b51296f612cac666c177882/aiohttp-3.14.5-cp310-cp310-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:d94e44be379e569758fee8a9a58431cfc3c2598c708b92b1cfe96c66b4c94aef", size = 1811243, upload-time = "2026-10-11T00:59:15.091Z" }, + { url = "https://files.pythonhosted.org/packages/e3/ba/72f3ac523ed48d38cdfb169f1b2a2e93ce06d9fcf4f46d0f5692e9539bcc/aiohttp-3.14.5-cp310-cp310-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:5af42135fdfebdadbc2bcd9c0842a48ccf0d62794c36a260b21dc4b94d1e0119", size = 1898815, upload-time = "2026-10-11T00:59:17.224Z" }, + { url = "https://files.pythonhosted.org/packages/e6/69/bbf24f3b555ea1befa7db1e2510c728c8b0e80e61ce360beb7d94bc562b7/aiohttp-3.14.5-cp310-cp310-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:4f07fe3ac408d8b3f768be471dc3f56d43843c47d97c66120534467a15ead197", size = 2022390, upload-time = "2026-10-11T00:59:19.244Z" }, + { url = "https://files.pythonhosted.org/packages/5d/38/01f5fc732d5373d6c099db0343279cd4e6607287d336bab6ff6ae9085a0d/aiohttp-3.14.5-cp310-cp310-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:f375db73a39f5cf83696d500e21a67f418dc9a988955756f254be8f03b7b3651", size = 1856329, upload-time = "2026-10-11T00:59:21.19Z" }, + { url = "https://files.pythonhosted.org/packages/15/85/1f86fbd8fe34ad447c63e679404a1d5be435fe256a9d281b791fc1ed0d35/aiohttp-3.14.5-cp310-cp310-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:8df7d481654ac96fe1ba9a02a9f67770fdd367823e0d5ef01b922725c4bd2cfa", size = 1712763, upload-time = "2026-10-11T00:59:22.982Z" }, + { url = "https://files.pythonhosted.org/packages/39/1e/ced51cf47e427e7aa6142c3bf6f33022472703bc9061289329532d3c40c0/aiohttp-3.14.5-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:e95c8def4b81c5d68d5cf1f54c07acd7c0d2577af244e5b6da802120825737c6", size = 1812125, upload-time = "2026-10-11T00:59:25.032Z" }, + { url = "https://files.pythonhosted.org/packages/6a/f1/9610b4e263b554ca4191501ba72b952efe06556b647da74887abc5d41049/aiohttp-3.14.5-cp310-cp310-musllinux_1_2_armv7l.whl", hash = "sha256:f2ebb54b3f932210503072f09974b4fb574d823e497a944adfdcd140a6a00255", size = 1829550, upload-time = "2026-10-11T00:59:27.078Z" }, + { url = "https://files.pythonhosted.org/packages/ac/8a/1d1fb27cf9fa99b13133de33044c4d10d7705be0d4173d6d56abad1b67f9/aiohttp-3.14.5-cp310-cp310-musllinux_1_2_ppc64le.whl", hash = "sha256:038c2c7e8caa26b6c8423779b5eaf1893904048a512c19b32fe841ffa5592b50", size = 1868179, upload-time = "2026-10-11T00:59:29.315Z" }, + { url = "https://files.pythonhosted.org/packages/24/9f/3cfafa86ff025623dcca0d30335db7b8a6f3fa348148441208147e827e04/aiohttp-3.14.5-cp310-cp310-musllinux_1_2_riscv64.whl", hash = "sha256:b7806e804889231b0e06469fd4a5c06313d1c0a3377322b6d9237fa5e0fe4167", size = 1697721, upload-time = "2026-10-11T00:59:31.161Z" }, + { url = "https://files.pythonhosted.org/packages/62/1d/86439a23bf32296e715d8c75535f0cd701821d36719324baef65bcd6af9e/aiohttp-3.14.5-cp310-cp310-musllinux_1_2_s390x.whl", hash = "sha256:9bab2045550c4fe0f7baf89574db1b455c195750702ba96fef1f16972b146617", size = 1887000, upload-time = "2026-10-11T00:59:33.329Z" }, + { url = "https://files.pythonhosted.org/packages/1d/0f/6044f2d02b3874966d84cd119f9b8eda46aa2991230078aea4dd17750cc9/aiohttp-3.14.5-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:96a2e584f0b9ed8f1fa33211397dcf67bb7069866402cb405d191c2f0defb9a3", size = 1842020, upload-time = "2026-10-11T00:59:35.384Z" }, + { url = "https://files.pythonhosted.org/packages/18/64/b49d2a34428ff937631b07dde74d5879a7a2c8559aab39331d40769e8cb6/aiohttp-3.14.5-cp310-cp310-win32.whl", hash = "sha256:602c1e9b718a3275c580149f947e7fac65044c0a20e599553fb12e9700da9eca", size = 489282, upload-time = "2026-10-11T00:59:37.061Z" }, + { url = "https://files.pythonhosted.org/packages/a6/7c/1114e723f1c4a65597820b605a0ddcd7f3b28fdfde3ac8d520d517ca582c/aiohttp-3.14.5-cp310-cp310-win_amd64.whl", hash = "sha256:bea559ad70218d230663e4210875735076a9bfea5994cef34a55a25faeaf2544", size = 512021, upload-time = "2026-10-11T00:59:38.7Z" }, + { url = "https://files.pythonhosted.org/packages/48/97/e08c646f4bad63d77876b24591d013d7f33f02fda7c931eafe3224f38467/aiohttp-3.14.5-cp310-cp310-win_arm64.whl", hash = "sha256:dca3fa8d8a0a26679862eccb0b1a9151b2b9f1cd2c212e7a6335778faaff5833", size = 493016, upload-time = "2026-10-11T00:59:40.525Z" }, + { url = "https://files.pythonhosted.org/packages/d8/f3/8997f18890a92c79f77fcfbb4f78ca17c2d4ab109e9eb6d31b4e9de194a0/aiohttp-3.14.5-cp311-cp311-macosx_10_9_universal2.whl", hash = "sha256:d51db97c96384fbfcaf8f4c65922183a68b94f891c3c10c862ef5f6df2adbb1f", size = 832358, upload-time = "2026-10-11T00:59:42.195Z" }, + { url = "https://files.pythonhosted.org/packages/8e/42/084651e9efb5cadb99265f786df60f2a7b353cead7bfd2c87003cb4867ad/aiohttp-3.14.5-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:ae53924aa853a7a2ca20ed4142c7c6b56338e4d4cd999e2980075b9efc2e257a", size = 559636, upload-time = "2026-10-11T00:59:43.677Z" }, + { url = "https://files.pythonhosted.org/packages/3d/fe/92838944e601f0fe195fd3f3ada37e29fbee3d19bfd323fe15937ec79d36/aiohttp-3.14.5-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:a2c473a355f9239efcb72c92d5abfd8fcdb0cc78c8e9af607e72ca12dbb36593", size = 552588, upload-time = "2026-10-11T00:59:45.592Z" }, + { url = "https://files.pythonhosted.org/packages/8f/b8/dd9b95c5c20ceae1b47738e656bd79e9883e3117a9cc8b143901eb604e9a/aiohttp-3.14.5-cp311-cp311-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:32e8fa6644e541fcd7e02430588c7fc93b602c1778ea0bc345505db76b61cfb4", size = 1928224, upload-time = "2026-10-11T00:59:47.294Z" }, + { url = "https://files.pythonhosted.org/packages/c6/47/70010cd2ba8746968d53d433ff328c33f06a66c99da5f3de759c64a6b2eb/aiohttp-3.14.5-cp311-cp311-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:579f97d5120f2971876d2ddca2968135f6944d00c44c3a6590ad7d86ca9b403f", size = 1877674, upload-time = "2026-10-11T00:59:49.472Z" }, + { url = "https://files.pythonhosted.org/packages/c5/a1/b026f071dbd87f0bdba86b92d47e46f3899e3ad7143b6e0fe7e7887090b4/aiohttp-3.14.5-cp311-cp311-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:24409db442e2fb6e766bc7f3943851a8381dec3098140e43bb2e843b79e31b12", size = 1985850, upload-time = "2026-10-11T00:59:51.296Z" }, + { url = "https://files.pythonhosted.org/packages/36/d1/f7b6f6f8c3cb5a71b53baeddc2e70c224c28b12a23a55c42994c504019b7/aiohttp-3.14.5-cp311-cp311-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:5e8f97c0488ffda3082766ac0f2c8150a9a58c4d05788330e479cfd449b37939", size = 2105471, upload-time = "2026-10-11T00:59:53.191Z" }, + { url = "https://files.pythonhosted.org/packages/42/74/2a2b22953de15c6c8a80debf26db3047e4e8a5a5db6dd7c2c6c01eec0605/aiohttp-3.14.5-cp311-cp311-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:50a195903119008fe9cc68710535eb37f556ffffd6a7759afe70a2c145587045", size = 1929915, upload-time = "2026-10-11T00:59:55.609Z" }, + { url = "https://files.pythonhosted.org/packages/33/ad/f80e8d33933d0eacd0217efa3b7fb32c9f48ed480ed0db53cf9948bf474f/aiohttp-3.14.5-cp311-cp311-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:0133c3c3b54a0bf1e71fa5c1ad95c93f07fd54e24ef1fe182f5122e1573d2bf1", size = 1773832, upload-time = "2026-10-11T00:59:57.611Z" }, + { url = "https://files.pythonhosted.org/packages/04/a4/0273d239f3e3bb69438f209c64c82e1f98dc60d5db264795e41f7dd05dcb/aiohttp-3.14.5-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:c172db893e516e1358e65a95ee20b7ce7173963eefe318b6ab2a2220688b999e", size = 1901001, upload-time = "2026-10-11T01:00:00.605Z" }, + { url = "https://files.pythonhosted.org/packages/16/ed/7dd439d26c654645bc34ca3c9a822fc11c1c51801fed1cefdfe1cc41c1f6/aiohttp-3.14.5-cp311-cp311-musllinux_1_2_armv7l.whl", hash = "sha256:f2a7966bda23dd85051f1661ce0ace38d6890e05ec6c357ecae9d2479cba377e", size = 1907218, upload-time = "2026-10-11T01:00:02.699Z" }, + { url = "https://files.pythonhosted.org/packages/32/dd/86249c3b8248562a17fd3e22ee0c164378d65766f01aceef62cf52783710/aiohttp-3.14.5-cp311-cp311-musllinux_1_2_ppc64le.whl", hash = "sha256:4887d130a7bbfed3a85493bb5a25e5b5b558d40c1d986dd16970d2bb26d63793", size = 1958650, upload-time = "2026-10-11T01:00:04.851Z" }, + { url = "https://files.pythonhosted.org/packages/bc/0b/ca4d53d68f683ce195807fd0aeb063bf6d1c6b39343fff234c9524e8d5a9/aiohttp-3.14.5-cp311-cp311-musllinux_1_2_riscv64.whl", hash = "sha256:225c579c23b68b343cccea27a7e06e3bd8ec23a09c30b427eb3f1e4ca6239b20", size = 1760057, upload-time = "2026-10-11T01:00:06.978Z" }, + { url = "https://files.pythonhosted.org/packages/6b/42/005437ffd7fa56c2ce3347add40404b654a32754ce91f2e2a14b9e5ab2bc/aiohttp-3.14.5-cp311-cp311-musllinux_1_2_s390x.whl", hash = "sha256:ab52d8f1fc1b64821c1fbad64a647ed6203627004059a6d1ed4f0858a1499703", size = 1978081, upload-time = "2026-10-11T01:00:08.868Z" }, + { url = "https://files.pythonhosted.org/packages/03/71/3a5b66fe1b7b23d3c6524350817ed55de5feb7fbb4cccba7cbe044d118dd/aiohttp-3.14.5-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:cb131d775a1573c1aee66656bd78b023577bbdb6cb8349a07773bd4f73e68a6e", size = 1922954, upload-time = "2026-10-11T01:00:11.035Z" }, + { url = "https://files.pythonhosted.org/packages/69/84/d08a554f281d42fd7c6b2b6dd7738f3e3a7a9f657ddd87e11ca2091cdfe3/aiohttp-3.14.5-cp311-cp311-win32.whl", hash = "sha256:e87046c8ff77a8decdb6a41d8ab25824b47531b2da933aeab0c1e21c7acff329", size = 488101, upload-time = "2026-10-11T01:00:12.933Z" }, + { url = "https://files.pythonhosted.org/packages/0f/15/52b5e65f02b33686ae49f1518548ae4f5a7adaf31d9d3c54fa12a143137b/aiohttp-3.14.5-cp311-cp311-win_amd64.whl", hash = "sha256:6f275c11d1aa6d4c458e05a68be084efe3c55a113d99e3f46a318098e52948fc", size = 512575, upload-time = "2026-10-11T01:00:14.743Z" }, + { url = "https://files.pythonhosted.org/packages/b0/b9/bb75012635f3defb0f7cbb7c4ae391e36bb9cb3fbdca3b9944e2ebebf743/aiohttp-3.14.5-cp311-cp311-win_arm64.whl", hash = "sha256:b032a0023eb41d768ce77d83210ab2a3c389bc0b09313273c7e1eca48c10a755", size = 493179, upload-time = "2026-10-11T01:00:16.961Z" }, + { url = "https://files.pythonhosted.org/packages/d5/94/6ba86efddcb616c811b40e6a0dfdd862738f647e4e3860a961075d5e9ed8/aiohttp-3.14.5-cp312-cp312-macosx_10_13_universal2.whl", hash = "sha256:df37b620684e19b5e25724412518ccafc3b1a49cdac706fdbd2f983fad943450", size = 817499, upload-time = "2026-10-11T01:00:18.901Z" }, + { url = "https://files.pythonhosted.org/packages/5e/e1/7bca6d84dabd228aa8eb4b7f9feac2586aaa9be5505d7d65bf287a615c43/aiohttp-3.14.5-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:ef60869969180ec2464f1349aff07138ae35ca2200f0946cb3552e49e8f301a8", size = 549467, upload-time = "2026-10-11T01:00:20.854Z" }, + { url = "https://files.pythonhosted.org/packages/64/91/11b89f45ca486252dd67dd5f3231fec04bf5518da39a95cb3997619f17fb/aiohttp-3.14.5-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:d079c0a0135c36e7beb6f1c88087c8f108dc5891cdd0b5eafa778421bda70ed2", size = 548067, upload-time = "2026-10-11T01:00:22.659Z" }, + { url = "https://files.pythonhosted.org/packages/22/ff/c6615806c14aab34f82b9424ccde8ce6e417315fd57ce1c5b4d4747888e1/aiohttp-3.14.5-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:abfda5cb094a829f7bc25216a32f7db2e85cc65bd59910f8e7b40b3d9b224764", size = 1896245, upload-time = "2026-10-11T01:00:24.638Z" }, + { url = "https://files.pythonhosted.org/packages/39/b2/25a8c971ae6a92c8394d77e42422d7f38989e05cf41a5ceb92d73d67ab7e/aiohttp-3.14.5-cp312-cp312-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:9cc882cf8619109583c906b4d4a85d6a111a98afa34b7a450d1e08118d016820", size = 1872180, upload-time = "2026-10-11T01:00:26.838Z" }, + { url = "https://files.pythonhosted.org/packages/2f/d5/99f93ea36cc5205e47c1e5a803e087f2ad21b5430b5db2e942cb6e988a37/aiohttp-3.14.5-cp312-cp312-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:7457580535e019e1247ea35d6a02bf081ad30c26d0cbc210c93f6c3ab67a0835", size = 1937261, upload-time = "2026-10-11T01:00:28.74Z" }, + { url = "https://files.pythonhosted.org/packages/40/a6/9ac9c9e6695040bd73d2584a1b59a9388f6433c76d5294a7bf591e21ffe5/aiohttp-3.14.5-cp312-cp312-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:c5ed596aedb9c42afd3fe0aae3117725378ac73d2cc5ddc735056fbdb96c5d02", size = 2064994, upload-time = "2026-10-11T01:00:30.623Z" }, + { url = "https://files.pythonhosted.org/packages/da/e4/aa172eb534b7f02f1f8ff1c3213347eaf3cf218db91a727c6863c22f1035/aiohttp-3.14.5-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:20f085697d7e911f1f73c43ed03fafbed1e7121797e2eb5428efa80398060584", size = 1919630, upload-time = "2026-10-11T01:00:32.548Z" }, + { url = "https://files.pythonhosted.org/packages/06/7d/4eedafc5bababa8932636c141e346806966eade12c0b7e5946d43bf8218b/aiohttp-3.14.5-cp312-cp312-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:74b0a9c8270f9b0a11410e124ff8d4f18bfc1f1837440ec84da5ae7b50927b5d", size = 1710016, upload-time = "2026-10-11T01:00:34.471Z" }, + { url = "https://files.pythonhosted.org/packages/b2/94/eee018537ba19da0ceb2ac79cab83faed4ac49568e08376e2799043f2538/aiohttp-3.14.5-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:19e2ba471507c34f8252402ab50f5ab512398b9ea8c8f1cb26beb3f75793ba30", size = 1858112, upload-time = "2026-10-11T01:00:36.581Z" }, + { url = "https://files.pythonhosted.org/packages/68/76/354653a306547238f3427283905972d796ba7c292ba9977abec9f2b6f260/aiohttp-3.14.5-cp312-cp312-musllinux_1_2_armv7l.whl", hash = "sha256:d418ce2af40c6bb685b3f663e9e8de27cb0a22431d8e88a167348d7f01878073", size = 1896371, upload-time = "2026-10-11T01:00:38.478Z" }, + { url = "https://files.pythonhosted.org/packages/f2/ec/63e8c7136b570e356345ad3174e3820fdc973ea10712cb6c649bf875755a/aiohttp-3.14.5-cp312-cp312-musllinux_1_2_ppc64le.whl", hash = "sha256:70cb4008ac2ed1e0ca9e824deb4b53d3aa0d939109698ebf1e723a84337bd794", size = 1905836, upload-time = "2026-10-11T01:00:40.527Z" }, + { url = "https://files.pythonhosted.org/packages/57/d8/11365bda144b127928cd42533d0eff78a55613c9e28f81941bd6630ea887/aiohttp-3.14.5-cp312-cp312-musllinux_1_2_riscv64.whl", hash = "sha256:a23fe35d776bc03cb495938b9594450d047e3bc08c5255315a82323e9cb7d2dd", size = 1696534, upload-time = "2026-10-11T01:00:42.686Z" }, + { url = "https://files.pythonhosted.org/packages/2f/3d/82df0461b18e00b2998f205c03e0d3010222478c43640aceb8e03dcd7e8f/aiohttp-3.14.5-cp312-cp312-musllinux_1_2_s390x.whl", hash = "sha256:3e0eb43bed3c6801a6cee315195377789e90b2a72c2277a475b578535312488d", size = 1933970, upload-time = "2026-10-11T01:00:44.71Z" }, + { url = "https://files.pythonhosted.org/packages/03/ad/6ddfe0aacd931c17b53533336d97e9d11a98b96d6ae815a9da0b19f82ccf/aiohttp-3.14.5-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:3be7dd397d64ca3e1869626fa9318aaebb54b7bf93bc72d7a205448d83e4f748", size = 1899501, upload-time = "2026-10-11T01:00:46.629Z" }, + { url = "https://files.pythonhosted.org/packages/9e/8e/189bdd9ae4793059bb09f6dc880f211a6c6c7859cebcbf33912dbfab7dd7/aiohttp-3.14.5-cp312-cp312-win32.whl", hash = "sha256:eb324e2009fb54db30a071dad7caf6998ee2879c4704007efb244514dad1fec1", size = 480370, upload-time = "2026-10-11T01:00:48.468Z" }, + { url = "https://files.pythonhosted.org/packages/ae/ce/1f08114679d49655b30a6e0a29858375c94b82c1de1a0bd0a20c2fee8b02/aiohttp-3.14.5-cp312-cp312-win_amd64.whl", hash = "sha256:2cc38a4f2b516bef1714e690df87a0e043faf1a7693c82d860091684453d5111", size = 506141, upload-time = "2026-10-11T01:00:50.272Z" }, + { url = "https://files.pythonhosted.org/packages/79/d4/c7b4f60b16a1b7e43249fa9031ae05e7e8c341ba4b7d1866f914dafeaa0e/aiohttp-3.14.5-cp312-cp312-win_arm64.whl", hash = "sha256:a63afd1f757de949028387e65a7127b61ad0f775432dbb0e62816ae619fe69ac", size = 488108, upload-time = "2026-10-11T01:00:52.321Z" }, + { url = "https://files.pythonhosted.org/packages/d3/e1/2841e020ebb7aefae5513586193e011e06313d9a6bdbd296622afbbce204/aiohttp-3.14.5-cp313-cp313-android_24_arm64_v8a.whl", hash = "sha256:9ad7e6aa38c20da1be697874349c4c273c8a03b7887169665081706398d0439a", size = 538932, upload-time = "2026-10-11T01:00:54.3Z" }, + { url = "https://files.pythonhosted.org/packages/f7/a6/7fb8ea8fe96bcc7b7c7a36d10f021d99d01a8dc8a4b3f0ddacecfad9a80e/aiohttp-3.14.5-cp313-cp313-android_24_x86_64.whl", hash = "sha256:f59c7673465908cbe506117176156c127f29f917677afceada34957179221d91", size = 553329, upload-time = "2026-10-11T01:00:56.442Z" }, + { url = "https://files.pythonhosted.org/packages/de/64/d056e3c27647dc25af1a592cf356245382ea7c808171b9dac7677afedfc8/aiohttp-3.14.5-cp313-cp313-ios_13_0_arm64_iphoneos.whl", hash = "sha256:1b5416552740edf07234cc9437d0706f2acb67b93c198670b1a68e1b2b587dec", size = 521367, upload-time = "2026-10-11T01:00:58.345Z" }, + { url = "https://files.pythonhosted.org/packages/3e/e4/95226147e11d4db916fd1d495dcf85af8e3816e38333e42718241196e848/aiohttp-3.14.5-cp313-cp313-ios_13_0_arm64_iphonesimulator.whl", hash = "sha256:43351bdb5e4c3cb7d1772368e988534e869a74db7778079a83782c11c69535c7", size = 528322, upload-time = "2026-10-11T01:01:00.211Z" }, + { url = "https://files.pythonhosted.org/packages/17/cd/1d3c9192cafdb51cad62b2d3ded96cff9cc8af51893210aadd448a325389/aiohttp-3.14.5-cp313-cp313-ios_13_0_x86_64_iphonesimulator.whl", hash = "sha256:c8c4478bef6d57fcfda15dae461ea3c9f06aa7b257c58df3f2300174ccbb185a", size = 539874, upload-time = "2026-10-11T01:01:02.06Z" }, + { url = "https://files.pythonhosted.org/packages/f6/0c/dfa33aecc7d4d1dc75e05248f5eac5a0edf4d09e7b44d93ab62529b0c1db/aiohttp-3.14.5-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:c2c30484dd1417ef98b51021ffa2cc0d7f3c78918adaaaab7e70817335ab3e02", size = 813836, upload-time = "2026-10-11T01:01:04.01Z" }, + { url = "https://files.pythonhosted.org/packages/33/17/4a63738052d20567d55529d6daa1b9480d906fd52930fbcf6d3fbed618f0/aiohttp-3.14.5-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:dab9ac5a67c8d1f070c00fa8fccb7cbd1b8dcc1a8d6b42f37540df9b3d4cc603", size = 548070, upload-time = "2026-10-11T01:01:06.035Z" }, + { url = "https://files.pythonhosted.org/packages/15/e5/b57e58695a757fd4c02497c033fced96a69c631b13866c43d336530c9670/aiohttp-3.14.5-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:e1cc2bfaee8c214f06080a7c7d5772419b8a1108e8e5349236189811823fb02a", size = 545786, upload-time = "2026-10-11T01:01:07.817Z" }, + { url = "https://files.pythonhosted.org/packages/9a/68/8c2c67a3aedf46e00f3c42f04fbc6983de80d4ed5786151e33681ba45883/aiohttp-3.14.5-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:74efb69332b85675b1eabd760a8cfc2e2cf42c60607c66f88014c1bdfb40942d", size = 1886492, upload-time = "2026-10-11T01:01:09.834Z" }, + { url = "https://files.pythonhosted.org/packages/ab/4b/74aab5e8d28c62e8f795b4fe8f38cf5586fd264a9a27bd2141ef6490333d/aiohttp-3.14.5-cp313-cp313-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:42b5e616946dbaf505e2bff18c9af2cd4ef9e7ef300ee58a6e951a5b7cf147ae", size = 1870057, upload-time = "2026-10-11T01:01:12.045Z" }, + { url = "https://files.pythonhosted.org/packages/a8/f7/eafc3b1988302b1815d9fd4a21071be5c360d616c0a430d02fd92dc97688/aiohttp-3.14.5-cp313-cp313-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:f9033b43f511f27547c557dcaba0177649e10a3725336ccd2cce0fdc1dc4850d", size = 1925119, upload-time = "2026-10-11T01:01:14.09Z" }, + { url = "https://files.pythonhosted.org/packages/a1/04/78d8f294f74dd570f3898ff20402349fce524176045df98ba727d6846a68/aiohttp-3.14.5-cp313-cp313-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:15a310d3c71398e3d7bfc93a1a73fbe664315cd9e9016b8efc1cff85eeab7155", size = 2053137, upload-time = "2026-10-11T01:01:16.344Z" }, + { url = "https://files.pythonhosted.org/packages/32/51/395d225ef36f5a50d8e548dcd3141bfdbcd31fb6eed859022c573d2c4d66/aiohttp-3.14.5-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:1ffa3a523a36d8628f98c06492ae16a31a23d14c0b4ec721757b477319f656d6", size = 1911038, upload-time = "2026-10-11T01:01:18.653Z" }, + { url = "https://files.pythonhosted.org/packages/ff/a4/2aec1aa06d82e8a244843b5dae31d78061e5e76744270a86dd0ee051c889/aiohttp-3.14.5-cp313-cp313-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:5fb6a6e919bfb703227bc1ce6579281b84b1a2ba57deb9794dfdbec7dcd1e40c", size = 1702205, upload-time = "2026-10-11T01:01:20.904Z" }, + { url = "https://files.pythonhosted.org/packages/16/27/6051bfde7b6f418f70edd60d655fa426abb3355fa0981764739d87ecf160/aiohttp-3.14.5-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:43e1b7994a8b038125f722bff07492ef501110722c2727c408995d9fb864c421", size = 1848588, upload-time = "2026-10-11T01:01:22.918Z" }, + { url = "https://files.pythonhosted.org/packages/9e/44/55efc06fc26c4e6e1c095f231b4c222bf2d86d64a8eebbc24b2bb5958ea8/aiohttp-3.14.5-cp313-cp313-musllinux_1_2_armv7l.whl", hash = "sha256:5f3e96071686755d9cd3600c3880183eb94b012178e92746d68101800f0ed8a3", size = 1887540, upload-time = "2026-10-11T01:01:25.278Z" }, + { url = "https://files.pythonhosted.org/packages/48/dc/1502bfdc2a65760d386ac6a00090b0addaa8a3c9c60b3f8127fad3a9afb2/aiohttp-3.14.5-cp313-cp313-musllinux_1_2_ppc64le.whl", hash = "sha256:cd88b01f3d37b7a2a34f91d98f14720206f1ea3d540843fab2d649dd5fb91fec", size = 1895030, upload-time = "2026-10-11T01:01:27.316Z" }, + { url = "https://files.pythonhosted.org/packages/93/7e/44174bb6288264418c9eec07a5e35180969c0d5a796c7af544db3cb8a33a/aiohttp-3.14.5-cp313-cp313-musllinux_1_2_riscv64.whl", hash = "sha256:f2ed8b64dc0c651c0f5a9c926777719770021251b8f336d97c4b80b660836ce1", size = 1693244, upload-time = "2026-10-11T01:01:29.39Z" }, + { url = "https://files.pythonhosted.org/packages/47/dd/b507d64e50db23888582fff08eda13998b12f9dea70c072edaac19218380/aiohttp-3.14.5-cp313-cp313-musllinux_1_2_s390x.whl", hash = "sha256:a9918e58faf62ba2c7147927d06057aec78f42475aff5048047ec47e7265a600", size = 1926308, upload-time = "2026-10-11T01:01:31.634Z" }, + { url = "https://files.pythonhosted.org/packages/98/4b/5b51b4f63e3f2793151f4aea49c48fe1e00baeb7cec9c7a206de499f8de0/aiohttp-3.14.5-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:42f320d4a5b00b9af0bddcfec5407dc6f2d9816f006b2f79ebbaa31f16895df3", size = 1888406, upload-time = "2026-10-11T01:01:33.715Z" }, + { url = "https://files.pythonhosted.org/packages/ff/13/d5e818a5eaba9f822016727299f41c0e1075799f82a6433ec508a93ab867/aiohttp-3.14.5-cp313-cp313-win32.whl", hash = "sha256:3ae800a20947e2c2e53088047d021e6bf7d51560cc49f6a0737a1f79d2e3a13c", size = 479970, upload-time = "2026-10-11T01:01:35.677Z" }, + { url = "https://files.pythonhosted.org/packages/8d/d0/8eca2c65aa467320990d78fb2005f38ed3588944280c39ff9deb6423fef1/aiohttp-3.14.5-cp313-cp313-win_amd64.whl", hash = "sha256:d05e94cdfe0d15d0206f970722d2554780ce562787b21b218b275447f8751319", size = 505985, upload-time = "2026-10-11T01:01:37.574Z" }, + { url = "https://files.pythonhosted.org/packages/7a/f8/4cdd65305d2fca14b886bea9ed2abb1fe726287872524e56e3d26692b47d/aiohttp-3.14.5-cp313-cp313-win_arm64.whl", hash = "sha256:f001b571ead90ca1770f1e616db255351a1703317f20374c361ef22f12c06d09", size = 487629, upload-time = "2026-10-11T01:01:39.477Z" }, + { url = "https://files.pythonhosted.org/packages/43/be/3184a1d34a8be665569eadb7e9e764b4629e4f3413e241cb2e4d6fecf3b3/aiohttp-3.14.5-cp314-cp314-android_24_arm64_v8a.whl", hash = "sha256:939042d5cda21d41a6f512e7cc8b8e33a2aebff863352251da495fbd91b673b5", size = 540673, upload-time = "2026-10-11T01:01:41.354Z" }, + { url = "https://files.pythonhosted.org/packages/60/2a/d35f3ba4cf157b072e3b674bf9983047ca5ea5173c995d32d877e1191d36/aiohttp-3.14.5-cp314-cp314-android_24_x86_64.whl", hash = "sha256:6da32b5ff3fd78d244e37300463434c7145162bfd2b6e9e915ab164da37f7343", size = 554087, upload-time = "2026-10-11T01:01:43.719Z" }, + { url = "https://files.pythonhosted.org/packages/fc/d2/61a33880ca4eaca95a9c60ca3f6beed15555af1028652dfaac601627787b/aiohttp-3.14.5-cp314-cp314-ios_13_0_arm64_iphoneos.whl", hash = "sha256:1b438b73c38111818d0c9d6a5c2bfed8584c8e503a49ef085d70e874ec846738", size = 522613, upload-time = "2026-10-11T01:01:46.154Z" }, + { url = "https://files.pythonhosted.org/packages/31/1d/de579b299d2225dc2c6fd99d579d91f16c02a913fb5af9a3cf2fe9bd88ba/aiohttp-3.14.5-cp314-cp314-ios_13_0_arm64_iphonesimulator.whl", hash = "sha256:755933b107ea7a6a9ac916f635a70595a5b1a32fac10a8ff0b9f2ab88555550c", size = 529682, upload-time = "2026-10-11T01:01:48.477Z" }, + { url = "https://files.pythonhosted.org/packages/f4/4a/ddb923564e15e053b6e060b0036e1694dcadcb13aa476c5a87dcad20e336/aiohttp-3.14.5-cp314-cp314-ios_13_0_x86_64_iphonesimulator.whl", hash = "sha256:b3cc509327c7b27f6f4727a8830f4004f6df7766e179f2f4b8e54e65c0bec5d3", size = 540120, upload-time = "2026-10-11T01:01:50.474Z" }, + { url = "https://files.pythonhosted.org/packages/3d/36/a640fbecaa53727a5900b892bdbe17b5f3e8cc88903e22864fe41b654def/aiohttp-3.14.5-cp314-cp314-macosx_10_15_universal2.whl", hash = "sha256:7bd8ac754ebd6733a3e2a0dd1674c4d8ab086196803fd8dcd776f07b4e2607d9", size = 818795, upload-time = "2026-10-11T01:01:52.665Z" }, + { url = "https://files.pythonhosted.org/packages/ef/b6/d52ca608859e271b5fa7944074802dc45f60e52c318a4ddc34edbf73586e/aiohttp-3.14.5-cp314-cp314-macosx_10_15_x86_64.whl", hash = "sha256:e724a7b6091f0b1ac064f9d1b15ff9ec52e6033a86cdae649e5f086e32a3c0db", size = 549667, upload-time = "2026-10-11T01:01:54.65Z" }, + { url = "https://files.pythonhosted.org/packages/ce/b5/05b8ac39a76ff4bca89f42a4c2471560c71f894ff6e4bc16158c951874e3/aiohttp-3.14.5-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:c32e26310cc10e547f53cd13d39a369034f69dcb7d749d5cb0e5f67bc196b6ba", size = 548922, upload-time = "2026-10-11T01:01:56.547Z" }, + { url = "https://files.pythonhosted.org/packages/19/b0/5aa186d56ce2334dabe29b70bd99dc8ae926ee44184c0de64a53d415a4f3/aiohttp-3.14.5-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:1eb8167961ec4dfcc8cb9dd50bd0ee72519f7ef496be95203e49e27b01618382", size = 1882422, upload-time = "2026-10-11T01:01:59.258Z" }, + { url = "https://files.pythonhosted.org/packages/db/f7/7d5c91bb9620db300c8ddb05337a9014301acb626223faff3abcb8ea47d7/aiohttp-3.14.5-cp314-cp314-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:c1d60eafd9c7e8e74abd03a5b00df44e7febfe6d9b89b559c0a6551eef0699d4", size = 1843621, upload-time = "2026-10-11T01:02:01.417Z" }, + { url = "https://files.pythonhosted.org/packages/30/0a/b208953b96d8f24b75f6da704f508e6c5cf3022f52b60c61933df082e89c/aiohttp-3.14.5-cp314-cp314-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:137351bf20bbed9a65e839f4a4452ac377389bdb2f2857d2acffef38f5e9f2d1", size = 1927915, upload-time = "2026-10-11T01:02:03.697Z" }, + { url = "https://files.pythonhosted.org/packages/f6/79/90ebcccb55e2d1e11a1fed581d83bb966e38fb35fb4b2577fdc980f8707a/aiohttp-3.14.5-cp314-cp314-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:fba47bc2c3d7303c3d027c6cf4d07626c37b1314ac81f5820c31032e0ca1f677", size = 2036339, upload-time = "2026-10-11T01:02:06.046Z" }, + { url = "https://files.pythonhosted.org/packages/a6/66/55a8904b3a129fafdf94f9cc0a2e4ca09a3c914650be52355db7ad0bbdb6/aiohttp-3.14.5-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:94684b879ac1d71e4238850c99b62dc1b28d9086b156a2555f082010b85a865c", size = 1888041, upload-time = "2026-10-11T01:02:08.384Z" }, + { url = "https://files.pythonhosted.org/packages/0b/b8/96b25da7329a52e42c812b1e8b076386039ec4fc312afa043d173d8147fc/aiohttp-3.14.5-cp314-cp314-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:56572c42e3ecd636de8d2c3dd54cf5fc939cb5c32eb56297f176a0d366fac622", size = 1703849, upload-time = "2026-10-11T01:02:10.903Z" }, + { url = "https://files.pythonhosted.org/packages/1b/43/fbf976e3ae4c038d6f5c84945ab2150298c2d71201674d4e53d158063e75/aiohttp-3.14.5-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:a95529a92a446db351675f4aab518feaf5e99842f63f5dd17160c2b74f382db3", size = 1849703, upload-time = "2026-10-11T01:02:13.15Z" }, + { url = "https://files.pythonhosted.org/packages/8b/7d/218e912f4c1d89bde7ac551409be57ad2f6121638e56942d395a7cb1fa58/aiohttp-3.14.5-cp314-cp314-musllinux_1_2_armv7l.whl", hash = "sha256:3edbece0379b8b4aaa67619b8aa2399bb66fce372cd5911098a434ea77220aa0", size = 1852695, upload-time = "2026-10-11T01:02:15.295Z" }, + { url = "https://files.pythonhosted.org/packages/5a/42/252a1b9287e3b6e393a1c3bd1776f36af30f5f25f071bbf2b0cb7eba9116/aiohttp-3.14.5-cp314-cp314-musllinux_1_2_ppc64le.whl", hash = "sha256:56d9828f204331a5ca8850fcfe2bcce95a149f1f223f60cc7216e5524978e480", size = 1893493, upload-time = "2026-10-11T01:02:17.93Z" }, + { url = "https://files.pythonhosted.org/packages/78/97/71cae83d5100556fad1521684f7cd1e3e578432644f850245ed3bd969310/aiohttp-3.14.5-cp314-cp314-musllinux_1_2_riscv64.whl", hash = "sha256:20064a177a070d789ee64a50b01a9161d3468e989baacfc6c714aa685c4b332f", size = 1693468, upload-time = "2026-10-11T01:02:20.666Z" }, + { url = "https://files.pythonhosted.org/packages/1f/69/73d88e97a8b5f0ca7a946d0011c0de99fb188b1687c7948ecd0553dc5bf0/aiohttp-3.14.5-cp314-cp314-musllinux_1_2_s390x.whl", hash = "sha256:81c2b3dfd56c62bee6108e4852d5970b4cf9086390b6983f52b666e878c1f115", size = 1915398, upload-time = "2026-10-11T01:02:23.011Z" }, + { url = "https://files.pythonhosted.org/packages/05/f0/881644bcb15d4b258daea9b720a0af9dc4330496cc8d6ade9090cdd0cffc/aiohttp-3.14.5-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:09ec102b4b8c9a920275733bbc11fdbb615efe6f9231a06007c0218d336fb77a", size = 1871470, upload-time = "2026-10-11T01:02:25.278Z" }, + { url = "https://files.pythonhosted.org/packages/7f/de/19d9ebbcce5aedaa3242d8a99ff8816a60bdb7629fb0084bf4a45bfd1f62/aiohttp-3.14.5-cp314-cp314-win32.whl", hash = "sha256:9c428eb2bd8817588d16a0ab898aa4eb5d141f896aa2b394cc79a4cf61d9a8e2", size = 485517, upload-time = "2026-10-11T01:02:27.579Z" }, + { url = "https://files.pythonhosted.org/packages/a9/74/8cdaf0e58c2588371670d5a9a8215bbb971d36940b6e5d051967dd05c07d/aiohttp-3.14.5-cp314-cp314-win_amd64.whl", hash = "sha256:6f967dde489ca6a8c02d093ab245d2cbf50ccb5c36adf0188b17b0ca39d24b67", size = 511755, upload-time = "2026-10-11T01:02:29.685Z" }, + { url = "https://files.pythonhosted.org/packages/1a/6b/e0100e25502430a531c7cf1482a378d0b65bf728ab60c01ee270e56bc469/aiohttp-3.14.5-cp314-cp314-win_arm64.whl", hash = "sha256:1d2d981b53dd09a319e3570ef8cc3bbc3ef86f5a7abef0f6b2bff3867db3a9e7", size = 495151, upload-time = "2026-10-11T01:02:32.163Z" }, + { url = "https://files.pythonhosted.org/packages/9d/c2/ca2ead7b655688c53c03aeeb6e96e6851c9ff08d6be7b13802f53a6ae8fd/aiohttp-3.14.5-cp314-cp314t-macosx_10_15_universal2.whl", hash = "sha256:9ce66feae6ac65327379460380549bf1b8df8e17c4e25df2a2bcf168272e3bed", size = 855396, upload-time = "2026-10-11T01:02:34.443Z" }, + { url = "https://files.pythonhosted.org/packages/a7/70/22206fea409255a240c926ce11de48de354ae2bb90ca44f709c05497585d/aiohttp-3.14.5-cp314-cp314t-macosx_10_15_x86_64.whl", hash = "sha256:27c2322e03f66101acb09869ce1cf1efc04994ee95e1735b69827bf8c8b9d781", size = 567734, upload-time = "2026-10-11T01:02:36.644Z" }, + { url = "https://files.pythonhosted.org/packages/ce/e5/79a36c118308b56f8667d67e05d2fb6dc638ab45985704cdb199631bedaa/aiohttp-3.14.5-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:ff75a7537413a86e7cafe98e0e1d6e3dc4b15c6349896e7d5c6b881bfdb6d550", size = 567379, upload-time = "2026-10-11T01:02:38.757Z" }, + { url = "https://files.pythonhosted.org/packages/63/a3/2ebec7dece3b1f02c30d2e484647f6f7b13952b1bb40a4cb285b849e8432/aiohttp-3.14.5-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:9c061aa954daaf57d2a4b8374f9fca621ef0e1b603584431c220c22458c59b6d", size = 2050686, upload-time = "2026-10-11T01:02:41.169Z" }, + { url = "https://files.pythonhosted.org/packages/3a/d2/7e4d093db2f4450482652e7ef19a9e19919028f5135aa52bc4078c3beb80/aiohttp-3.14.5-cp314-cp314t-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:1612fa5857b37bf32e5c1eaeefb96e3b01e9c70679eec81f0934e8a600080863", size = 1915077, upload-time = "2026-10-11T01:02:43.563Z" }, + { url = "https://files.pythonhosted.org/packages/a6/88/bd40d09958442a0a1df67da81de496361d6e2afc04f9db2950d835da750b/aiohttp-3.14.5-cp314-cp314t-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:adbeee7d6fd4cf5fe0aece2fb3edc4243615d3180430ba8149d01a90670cac99", size = 2027204, upload-time = "2026-10-11T01:02:46.185Z" }, + { url = "https://files.pythonhosted.org/packages/63/eb/3a601c1f8d3103c1a60ea981f20924855da9f575d2007fc38f8898b792fb/aiohttp-3.14.5-cp314-cp314t-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:b2966998927d7bed9db12c0a4647b0c7b179755878fc9c357fe1ffd3e3b0c1a5", size = 2149520, upload-time = "2026-10-11T01:02:48.812Z" }, + { url = "https://files.pythonhosted.org/packages/22/d0/4e41bfe1b1ce1cb6f6d2e59fa7a88ef5cf92c402b2d07e9018778ba9edbc/aiohttp-3.14.5-cp314-cp314t-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:8e317e0fb6b16212c881d2205a7d87414c29acd69320b3aa6dce9d9c7b86fe4f", size = 2002039, upload-time = "2026-10-11T01:02:51.293Z" }, + { url = "https://files.pythonhosted.org/packages/6f/5e/72067019545c502b881b031153c437752ecef48d7d213bc0218ccebb4bfb/aiohttp-3.14.5-cp314-cp314t-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:50343c1757b4b6f6708eeaf24534b32f19dfb99fb1b762c00420867a62fc81e0", size = 1786164, upload-time = "2026-10-11T01:02:53.533Z" }, + { url = "https://files.pythonhosted.org/packages/d9/fe/7741efd6119bfb7a00827fe6f7b84b4409de58d888ae21adc5a9a6824992/aiohttp-3.14.5-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:083673c7a94c3ea035caaa5ca04288bdb44887abfe1f5ba23294e6a4b03efd2d", size = 1970689, upload-time = "2026-10-11T01:02:55.888Z" }, + { url = "https://files.pythonhosted.org/packages/43/e7/342a13bf67f34d269bf2f7e870ecd72b99c832cc6f0a271a9210c0ebfb84/aiohttp-3.14.5-cp314-cp314t-musllinux_1_2_armv7l.whl", hash = "sha256:2528cb4c6b92008c76ac9ac6298624069bb2db91ff4929905512d1d84485f658", size = 1951967, upload-time = "2026-10-11T01:02:58.467Z" }, + { url = "https://files.pythonhosted.org/packages/e7/d4/fdb3b27340617e5e64df18a70fa89097778652ea5c7c7e2f79def76999c3/aiohttp-3.14.5-cp314-cp314t-musllinux_1_2_ppc64le.whl", hash = "sha256:b1b8ece1e71132d2afba4dbc0c3d62c766e25165990b25db1196c04969eb3d84", size = 1968511, upload-time = "2026-10-11T01:03:00.883Z" }, + { url = "https://files.pythonhosted.org/packages/83/b2/e8f88298de78d1a951f36f9f966d38ec6ed1d4721303ba02064a545e8aa6/aiohttp-3.14.5-cp314-cp314t-musllinux_1_2_riscv64.whl", hash = "sha256:fce9523df31cea6284f3e2c479876750d7687cf671d7b25d32b19effc0e86441", size = 1778497, upload-time = "2026-10-11T01:03:03.206Z" }, + { url = "https://files.pythonhosted.org/packages/22/68/9ccdb93d664345c546be7f34480b921774d8c0d98f47e70d7e03b115d475/aiohttp-3.14.5-cp314-cp314t-musllinux_1_2_s390x.whl", hash = "sha256:09e0eb18c7e0c8777e2f9149de63799195b9b3ca1b5c81ba6f32f2c6b8628210", size = 1999676, upload-time = "2026-10-11T01:03:05.829Z" }, + { url = "https://files.pythonhosted.org/packages/57/4a/a33cfa6dcb00e94194ae4fe710432ca4ed111e016356b4ba4d2f4c3a124c/aiohttp-3.14.5-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:6774814fd5c338e72ee0da5cbb9432816df450e69c019f72b5d29bdec2a1792d", size = 1963437, upload-time = "2026-10-11T01:03:08.196Z" }, + { url = "https://files.pythonhosted.org/packages/f4/20/eacbecfea3b5c3dcbfc9b023e3a5460f43e5dda16d06a2877ebe7184c3f3/aiohttp-3.14.5-cp314-cp314t-win32.whl", hash = "sha256:33f706574e32c6e694f352a856e05caf18f7f2c871b3e87b41c55ea452b409ab", size = 503973, upload-time = "2026-10-11T01:03:10.481Z" }, + { url = "https://files.pythonhosted.org/packages/ff/78/18eec294f6c8c5dc845dcf6d730a0147d8d0f17e86138a7bdb85e43a30fa/aiohttp-3.14.5-cp314-cp314t-win_amd64.whl", hash = "sha256:5ba14a839fbe87cf7c12a6b5661c05f324a296eb8363141edb3944ba63d4c9d3", size = 531190, upload-time = "2026-10-11T01:03:12.716Z" }, + { url = "https://files.pythonhosted.org/packages/9d/39/e53f8169acc85271ebd12b5b32ad7f1541b35639ccbe0f49034c64785d10/aiohttp-3.14.5-cp314-cp314t-win_arm64.whl", hash = "sha256:1061b364556e8172e8d46b0b183adeeb73e8c42d30ebc745591e1bd89acad52e", size = 510360, upload-time = "2026-10-11T01:03:15.08Z" }, + { url = "https://files.pythonhosted.org/packages/f3/1c/06d89f58b2db3ee92dd377217659d587e06f973e57bf0a97a0d8a4586c0c/aiohttp-3.14.5-cp315-cp315-android_24_arm64_v8a.whl", hash = "sha256:788ecaa9c10533b786ce5ba70c4f2df78ad41819fd00a6c99d92b66f9a32e1da", size = 540674, upload-time = "2026-10-11T01:03:17.483Z" }, + { url = "https://files.pythonhosted.org/packages/18/39/5e822e038f496f0540ada91e27099d48f9e7f919b6c6deb4cf6db36cc706/aiohttp-3.14.5-cp315-cp315-android_24_x86_64.whl", hash = "sha256:5c76f1802bab718a68ac3cce447160605c734551f95c67ae90fa1132b215cb29", size = 554183, upload-time = "2026-10-11T01:03:19.71Z" }, + { url = "https://files.pythonhosted.org/packages/9b/ff/0cf2619d902b5b160762422a7e5e02091295766a7fe4fcf5b9a655e386c1/aiohttp-3.14.5-cp315-cp315-ios_13_0_arm64_iphoneos.whl", hash = "sha256:a6d02b4c38de03d9c7617813433e6a0fb6b522797974177d69d9dad431900833", size = 523160, upload-time = "2026-10-11T01:03:22.193Z" }, + { url = "https://files.pythonhosted.org/packages/86/99/3553abfc53a40849dbaacc3f54c730ec58410809ffa2d05885ae56108f2d/aiohttp-3.14.5-cp315-cp315-ios_13_0_arm64_iphonesimulator.whl", hash = "sha256:20726f9782d5c2744c1c66255842d1d163bb3edcf768b8de25216bf47f7b6ccf", size = 530311, upload-time = "2026-10-11T01:03:24.435Z" }, + { url = "https://files.pythonhosted.org/packages/fe/a4/5d25f73754bc1e8f983ba704e86d641aea290c967f195f2aeebdaed2bd84/aiohttp-3.14.5-cp315-cp315-ios_13_0_x86_64_iphonesimulator.whl", hash = "sha256:248d779ad720b49d4fb355720e60c9e5f444f95887bc16974fea48fc56c41789", size = 540274, upload-time = "2026-10-11T01:03:26.698Z" }, + { url = "https://files.pythonhosted.org/packages/29/a4/07eda5db2e3ee017d9590f36c12a94ec6f1f50516e8df78672373dfc7185/aiohttp-3.14.5-cp315-cp315-macosx_10_15_universal2.whl", hash = "sha256:0a8ea271867e360ac985ae607f4a23ad9a38414b9aca1d49ec98839ae660e49f", size = 819239, upload-time = "2026-10-11T01:03:29.481Z" }, + { url = "https://files.pythonhosted.org/packages/cb/aa/a8723dd987a696dd48d4cf2f0088e589ce77caebff0b96f2a78c20424380/aiohttp-3.14.5-cp315-cp315-macosx_10_15_x86_64.whl", hash = "sha256:823c910f046f23f4c713b8d99a2242dc65f591cb45ee86418fa11762a3c2963c", size = 549832, upload-time = "2026-10-11T01:03:32.02Z" }, + { url = "https://files.pythonhosted.org/packages/29/5c/969a1b72692055fd2a419590c41847ec9144fefb97b75ff1cde5b6372891/aiohttp-3.14.5-cp315-cp315-macosx_11_0_arm64.whl", hash = "sha256:9b42db919715e91eb76acf3bc492a9a7ccd8bd9adc6745c1412b689735269f14", size = 549234, upload-time = "2026-10-11T01:03:34.469Z" }, + { url = "https://files.pythonhosted.org/packages/38/05/8e3e07fd8a0d33d06955ff4e54a1cb92f4bce347ff55e441dc3e25a7b5e5/aiohttp-3.14.5-cp315-cp315-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:d3112585250b199296c26ca6e0131640b6a8d01bab8b232d2eb3763ed469de11", size = 1891314, upload-time = "2026-10-11T01:03:36.899Z" }, + { url = "https://files.pythonhosted.org/packages/b6/b3/05a79ce2e25f024e93de30c94f39dc6aa6e2bc1e9c531a5c4b18dc61b7a4/aiohttp-3.14.5-cp315-cp315-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:c147451b4a58e7050f7f7394e6c467867c84161560001f9ad4fb2d1446743946", size = 1884372, upload-time = "2026-10-11T01:03:39.334Z" }, + { url = "https://files.pythonhosted.org/packages/94/52/0fd8af0717db109eea258191b326b5cb5847fb88928bfa6c862fd78b9ad3/aiohttp-3.14.5-cp315-cp315-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:bf163cc701f3d4ac43ba7d97771bf5fd955220ef5500ef3ee847bc0ecfbf4ec1", size = 1930957, upload-time = "2026-10-11T01:03:42.172Z" }, + { url = "https://files.pythonhosted.org/packages/4e/b3/fa78733da88812bf9fb193913fb0ce1548f8b6912047633fdf88a758ff8c/aiohttp-3.14.5-cp315-cp315-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:f8d40ce41991e9d56fab4f5dc4a51fe59bc3b5c77c27f4b148963064d00232e8", size = 2038886, upload-time = "2026-10-11T01:03:44.646Z" }, + { url = "https://files.pythonhosted.org/packages/cf/f5/2fcc5e30053a938286f17d0edf3f0850b8061b984256fa7c26850b9c8809/aiohttp-3.14.5-cp315-cp315-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:276a4fc00b1d9ae492b802763a789c5b86328b989c5ea169f2faa447d6a11c7c", size = 1894470, upload-time = "2026-10-11T01:03:47.304Z" }, + { url = "https://files.pythonhosted.org/packages/62/2a/f87feb42abe8e6a7c03814dbcb711540849a1e90aa392055f3183c643610/aiohttp-3.14.5-cp315-cp315-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:50983e3be33d8c0942ab88cec3905b10602f64c469b20153c48c5d4e558dd016", size = 1716273, upload-time = "2026-10-11T01:03:50.121Z" }, + { url = "https://files.pythonhosted.org/packages/81/b2/adf1f960dd977722ed1347d33da512a1624807114f57a3b91f5cc828e081/aiohttp-3.14.5-cp315-cp315-musllinux_1_2_aarch64.whl", hash = "sha256:16c8abd5bca220a47efe667d26f8460124c81810787e79ee87b242677563d9dd", size = 1857513, upload-time = "2026-10-11T01:03:52.959Z" }, + { url = "https://files.pythonhosted.org/packages/d7/fd/ef8d910e641de4160026a513ace5888b7f92826bbc3fd90ced05d55a828e/aiohttp-3.14.5-cp315-cp315-musllinux_1_2_armv7l.whl", hash = "sha256:0790ec66fa4013e83c53b9025a45d454723da1a2fce28b3208c9b32d08af162f", size = 1887704, upload-time = "2026-10-11T01:03:55.641Z" }, + { url = "https://files.pythonhosted.org/packages/7e/db/6c9142f941cba8d35be8e1fae6ea2bd390e754fc14076b8147aee1a4592f/aiohttp-3.14.5-cp315-cp315-musllinux_1_2_ppc64le.whl", hash = "sha256:cb11a971a3aea10f9b8373be628f1df932964fc6c6b174516d318a48c3ac4412", size = 1895684, upload-time = "2026-10-11T01:03:58.18Z" }, + { url = "https://files.pythonhosted.org/packages/e6/7c/6a6bd9a72e576d376c668333b00c51c6147aba4fb863ed6c94996d497eca/aiohttp-3.14.5-cp315-cp315-musllinux_1_2_riscv64.whl", hash = "sha256:932ce7e694bbc29b2bf6f64f2343c27d148d4997c771d01bdade4639b6749ff4", size = 1706299, upload-time = "2026-10-11T01:04:00.8Z" }, + { url = "https://files.pythonhosted.org/packages/69/ec/d2cc494242f8c4d3d1cd70baf591742818a74386dc3b84af3195c5c4fced/aiohttp-3.14.5-cp315-cp315-musllinux_1_2_s390x.whl", hash = "sha256:a7d470cf7b206e6359fc77b1b860632fde400d5a2ed59cd0181b93a686bc81ee", size = 1916645, upload-time = "2026-10-11T01:04:03.892Z" }, + { url = "https://files.pythonhosted.org/packages/a3/6e/e852c53647e815db09a1b6b5ab634f54bd736412397e11940feef4d2c89a/aiohttp-3.14.5-cp315-cp315-musllinux_1_2_x86_64.whl", hash = "sha256:6e1d8637cf73eebc92eba2e11d4cfff98a3b562f2505bd75bba766d908926e8d", size = 1875408, upload-time = "2026-10-11T01:04:06.922Z" }, + { url = "https://files.pythonhosted.org/packages/fe/f6/72ab6ef20c332399be593bac543d2c24a6d241e39d3540ce9f95a63e4bd2/aiohttp-3.14.5-cp315-cp315-win32.whl", hash = "sha256:fbdc5ec49f9ca3cd24955cf3520b10a4d4c901ba2572094c84274e9e7eb30534", size = 485590, upload-time = "2026-10-11T01:04:09.626Z" }, + { url = "https://files.pythonhosted.org/packages/06/eb/e9de75b8c6d2170c42c08ff303abf857ea8a6d9d9b6e99b5aba40f15e962/aiohttp-3.14.5-cp315-cp315-win_amd64.whl", hash = "sha256:a9d3983bd6ab7aa1cfd573544ae98df9b6cb6912a5185a198263e024a636861d", size = 511740, upload-time = "2026-10-11T01:04:12.277Z" }, + { url = "https://files.pythonhosted.org/packages/fc/25/455f3c2785eb0d50748cffd0abd07500815f419a9495b14610b7622d8d2d/aiohttp-3.14.5-cp315-cp315-win_arm64.whl", hash = "sha256:e29347c142cf6e99e0dff5e2995ead1d50fa3b51bf37a7c726a7ccfe5419745a", size = 495171, upload-time = "2026-10-11T01:04:14.667Z" }, + { url = "https://files.pythonhosted.org/packages/e7/6c/497f0a98782eebfcf0f02a7fbdef5428148bd426027140cbad494cf842b5/aiohttp-3.14.5-cp315-cp315t-macosx_10_15_universal2.whl", hash = "sha256:9bf1d5dcc15204d9ec8b8ea4c18fd66e6b80e5de1f4ecbafb3a2f2740f8039d4", size = 855638, upload-time = "2026-10-11T01:04:17.154Z" }, + { url = "https://files.pythonhosted.org/packages/9a/c5/55c0cef2572af9b1ee81608f7c0a1bf74e6c9151a73b04915d933f192335/aiohttp-3.14.5-cp315-cp315t-macosx_10_15_x86_64.whl", hash = "sha256:14f04769cfefe4734016a856a83af36133cd17779cef9ae817f812b8ba9d6d51", size = 567455, upload-time = "2026-10-11T01:04:19.702Z" }, + { url = "https://files.pythonhosted.org/packages/4d/47/e1a0e39f4a2b881f6071225afaf94a6547001b5aefc1566734d73c685934/aiohttp-3.14.5-cp315-cp315t-macosx_11_0_arm64.whl", hash = "sha256:6e4251c0ba4624a68a2c11471a1ac54c3306876c21f0ae86de085cc9241c8905", size = 567836, upload-time = "2026-10-11T01:04:22.235Z" }, + { url = "https://files.pythonhosted.org/packages/c3/1d/817d85836f52b687160064a326e62e037dc42f1ad5b6b5188a70e5c134b5/aiohttp-3.14.5-cp315-cp315t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:e4f5cf4dc72a71c4cfa9751b4950be22f733626670230d46e7d606592aa22d59", size = 2051409, upload-time = "2026-10-11T01:04:24.821Z" }, + { url = "https://files.pythonhosted.org/packages/f7/25/e8ea6fc212a9aabce982917346ce8ecab0929c74b60232a056dd11c99da0/aiohttp-3.14.5-cp315-cp315t-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:dbf53ae2601b7fd5a93c3944deea3a78d40f495226d582c35ef7a433425ce2b2", size = 1936493, upload-time = "2026-10-11T01:04:27.456Z" }, + { url = "https://files.pythonhosted.org/packages/24/33/de0517f71f1a19feea4aff78a2ec4ec2d98634129ec30ead78fce2f8f81b/aiohttp-3.14.5-cp315-cp315t-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:657291433bf4dd3142f3abac495764cd47d0c7c92087751e6666c6447e65fcef", size = 2021405, upload-time = "2026-10-11T01:04:30.276Z" }, + { url = "https://files.pythonhosted.org/packages/c4/11/ddaf2e7930543e9f0cad3a1c54e1af0c1bd2fae3973d568c4263d3b010e9/aiohttp-3.14.5-cp315-cp315t-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:3e51a27980c3788e6e6b3325d694fdd4898087fa8a86b2763af77b39353da41e", size = 2142017, upload-time = "2026-10-11T01:04:33.022Z" }, + { url = "https://files.pythonhosted.org/packages/1d/7b/58784353c06de8adc20f426daad3d85dd86fd55331c713a3f4b638c94573/aiohttp-3.14.5-cp315-cp315t-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:82c7583cd3dfdc7dcc927835b4f6c7faae7ecc1ba3ca5879321621ae2e6f8e84", size = 2002482, upload-time = "2026-10-11T01:04:35.94Z" }, + { url = "https://files.pythonhosted.org/packages/b9/f0/417d9535caa9e165ffe6a53e2347a78107e7c87dcb0e10aca315c3af0344/aiohttp-3.14.5-cp315-cp315t-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:6fdcd6af7e2e51d1ba1b4bea16e97b074bcb7b5dd0246a9d8201341bb28085a0", size = 1791774, upload-time = "2026-10-11T01:04:38.733Z" }, + { url = "https://files.pythonhosted.org/packages/98/01/25e49c2e8a01b9f0e19ca0a8448ad50aa2bdf96c8cd41e92bd45af044784/aiohttp-3.14.5-cp315-cp315t-musllinux_1_2_aarch64.whl", hash = "sha256:c8859a013ae0de1074660992139a1a440df3e6b219b86cf0d3f11c2692bb4fe3", size = 1970358, upload-time = "2026-10-11T01:04:41.66Z" }, + { url = "https://files.pythonhosted.org/packages/2d/fc/c132fd3465b6c7e4ce0193154f602c3e6c46b680e4da7eb3bd0d8a40d1c7/aiohttp-3.14.5-cp315-cp315t-musllinux_1_2_armv7l.whl", hash = "sha256:8966ecac808dd5f473c9c4cefd10cd3ffda71c18a4d3493b7c7d2ae1803bf2cc", size = 1969192, upload-time = "2026-10-11T01:04:44.66Z" }, + { url = "https://files.pythonhosted.org/packages/95/4e/d58b45e7dba4eb607eca11fc0a4aa77ae0f39c11afa804635a61ce18cff4/aiohttp-3.14.5-cp315-cp315t-musllinux_1_2_ppc64le.whl", hash = "sha256:3093b72c215bda16ce961a6d073f6e71d46e022962a9d5d457c5d4d421c78b57", size = 1963618, upload-time = "2026-10-11T01:04:47.505Z" }, + { url = "https://files.pythonhosted.org/packages/a2/d9/f6ac50946efb3490428ef52b56e62c1c6b7f9c6ff3ec6083535526c83e60/aiohttp-3.14.5-cp315-cp315t-musllinux_1_2_riscv64.whl", hash = "sha256:149fb56caf7acb67073126f675d0958d9c4b3125fcd3f6d4877df98aa8a97ce9", size = 1784817, upload-time = "2026-10-11T01:04:50.287Z" }, + { url = "https://files.pythonhosted.org/packages/d0/2f/f255eb63da788cd8a452fe350869c03266ccad7d884925f6963c87808f24/aiohttp-3.14.5-cp315-cp315t-musllinux_1_2_s390x.whl", hash = "sha256:293d3ae7c6a0ed176a42e59a1b5fde825ead65c835360f734148e96729f928d2", size = 1995956, upload-time = "2026-10-11T01:04:53.213Z" }, + { url = "https://files.pythonhosted.org/packages/d9/9b/241aa3393eaafda0034470add1625f82a4c252901108723b283a9b0b32ca/aiohttp-3.14.5-cp315-cp315t-musllinux_1_2_x86_64.whl", hash = "sha256:3f2dcc00191fd563e9075181a14ec31d7dd63223ced7582cc70a15a499de0c79", size = 1967794, upload-time = "2026-10-11T01:04:55.958Z" }, + { url = "https://files.pythonhosted.org/packages/5f/7f/a68e689288c9e4bfcf8d0979f2b12b774bf01861985420df6150eba5448e/aiohttp-3.14.5-cp315-cp315t-win32.whl", hash = "sha256:7779cd97e61ebe583ec2f1c5616cdd038aa08a4453b1848c67842176d054948e", size = 503876, upload-time = "2026-10-11T01:04:58.978Z" }, + { url = "https://files.pythonhosted.org/packages/a4/78/49b0299da6d54de19fc6fdc6889d50233ac47d192a461624f4fc010fde83/aiohttp-3.14.5-cp315-cp315t-win_amd64.whl", hash = "sha256:0e6f16f5e49c4b8267988c05ab07760d7064cea57d077c3d068d04b0fbb992cb", size = 530957, upload-time = "2026-10-11T01:05:02.23Z" }, + { url = "https://files.pythonhosted.org/packages/21/d4/b0afc936aeb6d2f93157e3408b069ec5d7934429ae7d023de5e0953b1887/aiohttp-3.14.5-cp315-cp315t-win_arm64.whl", hash = "sha256:1aead151c3abbac6b32942e452020cb66d7efc099d253cc6c20f748e926c858b", size = 510408, upload-time = "2026-10-11T01:05:05.362Z" }, + { url = "https://files.pythonhosted.org/packages/68/30/173960c42b05a6c59f7558e4b12a4b0d9ba376cf6aa9bde7f9e08a30ca8d/aiohttp-3.14.5-py3-none-any.whl", hash = "sha256:efc21a454892828368b11c2c780de0ff8bc991f73f6b99c6b66e56205470929b", size = 279517, upload-time = "2026-10-11T01:05:08.523Z" }, +] + +[[package]] +name = "aiosignal" +version = "1.4.0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "frozenlist" }, + { name = "typing-extensions", marker = "python_full_version < '3.13'" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/61/62/06741b579156360248d1ec624842ad0edf697050bbaf7c3e46394e106ad1/aiosignal-1.4.0.tar.gz", hash = "sha256:f47eecd9468083c2029cc99945502cb7708b082c232f9aca65da147157b251c7", size = 25007, upload-time = "2025-07-03T22:54:43.528Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/fb/76/641ae371508676492379f16e2fa48f4e2c11741bd63c48be4b12a6b09cba/aiosignal-1.4.0-py3-none-any.whl", hash = "sha256:053243f8b92b990551949e63930a839ff0cf0b0ebbe0597b0f3fb19e1a0fe82e", size = 7490, upload-time = "2025-07-03T22:54:42.156Z" }, +] + [[package]] name = "annotated-types" version = "0.8.0" @@ -94,6 +295,15 @@ wheels = [ { url = "https://files.pythonhosted.org/packages/11/25/4235f4b375a67a37ac595bf478a5407a744eaf7b64113c1c3a5432b8d954/ast_serialize-0.13.1-cp39-abi3-win_arm64.whl", hash = "sha256:48f11d96c9ec71119612f8e79a8c55c12f2b136716d68347433c561d27a25f43", size = 1139035, upload-time = "2026-10-17T00:04:15.767Z" }, ] +[[package]] +name = "async-timeout" +version = "5.0.1" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/a5/ae/136395dfbfe00dfc94da3f3e136d0b13f394cba8f4841120e34226265780/async_timeout-5.0.1.tar.gz", hash = "sha256:d9321a7a3d5a6a5e187e824d2fa0793ce379a202935782d555d6e9d2735677d3", size = 9274, upload-time = "2024-11-06T16:41:39.6Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/fe/ba/e2081de779ca30d473f21f5b30e0e737c438205440784c7dfc81efc2b029/async_timeout-5.0.1-py3-none-any.whl", hash = "sha256:39e3809566ff85354557ec2398b55e096c8364bacac9405a7a1fa429e77fe76c", size = 6233, upload-time = "2024-11-06T16:41:37.9Z" }, +] + [[package]] name = "attrs" version = "26.1.0" @@ -621,6 +831,127 @@ wheels = [ { url = "https://files.pythonhosted.org/packages/8a/0e/97c33bf5009bdbac74fd2beace167cab3f978feb69cc36f1ef79360d6c4e/exceptiongroup-1.3.1-py3-none-any.whl", hash = "sha256:a7a39a3bd276781e98394987d3a5701d0c4edffb633bb7a5144577f82c773598", size = 16740, upload-time = "2025-11-21T23:01:53.443Z" }, ] +[[package]] +name = "frozenlist" +version = "1.8.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/2d/f5/c831fac6cc817d26fd54c7eaccd04ef7e0288806943f7cc5bbf69f3ac1f0/frozenlist-1.8.0.tar.gz", hash = "sha256:3ede829ed8d842f6cd48fc7081d7a41001a56f1f38603f9d49bf3020d59a31ad", size = 45875, upload-time = "2025-10-06T05:38:17.865Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/83/4a/557715d5047da48d54e659203b9335be7bfaafda2c3f627b7c47e0b3aaf3/frozenlist-1.8.0-cp310-cp310-macosx_10_9_universal2.whl", hash = "sha256:b37f6d31b3dcea7deb5e9696e529a6aa4a898adc33db82da12e4c60a7c4d2011", size = 86230, upload-time = "2025-10-06T05:35:23.699Z" }, + { url = "https://files.pythonhosted.org/packages/a2/fb/c85f9fed3ea8fe8740e5b46a59cc141c23b842eca617da8876cfce5f760e/frozenlist-1.8.0-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:ef2b7b394f208233e471abc541cc6991f907ffd47dc72584acee3147899d6565", size = 49621, upload-time = "2025-10-06T05:35:25.341Z" }, + { url = "https://files.pythonhosted.org/packages/63/70/26ca3f06aace16f2352796b08704338d74b6d1a24ca38f2771afbb7ed915/frozenlist-1.8.0-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:a88f062f072d1589b7b46e951698950e7da00442fc1cacbe17e19e025dc327ad", size = 49889, upload-time = "2025-10-06T05:35:26.797Z" }, + { url = "https://files.pythonhosted.org/packages/5d/ed/c7895fd2fde7f3ee70d248175f9b6cdf792fb741ab92dc59cd9ef3bd241b/frozenlist-1.8.0-cp310-cp310-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:f57fb59d9f385710aa7060e89410aeb5058b99e62f4d16b08b91986b9a2140c2", size = 219464, upload-time = "2025-10-06T05:35:28.254Z" }, + { url = "https://files.pythonhosted.org/packages/6b/83/4d587dccbfca74cb8b810472392ad62bfa100bf8108c7223eb4c4fa2f7b3/frozenlist-1.8.0-cp310-cp310-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:799345ab092bee59f01a915620b5d014698547afd011e691a208637312db9186", size = 221649, upload-time = "2025-10-06T05:35:29.454Z" }, + { url = "https://files.pythonhosted.org/packages/6a/c6/fd3b9cd046ec5fff9dab66831083bc2077006a874a2d3d9247dea93ddf7e/frozenlist-1.8.0-cp310-cp310-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:c23c3ff005322a6e16f71bf8692fcf4d5a304aaafe1e262c98c6d4adc7be863e", size = 219188, upload-time = "2025-10-06T05:35:30.951Z" }, + { url = "https://files.pythonhosted.org/packages/ce/80/6693f55eb2e085fc8afb28cf611448fb5b90e98e068fa1d1b8d8e66e5c7d/frozenlist-1.8.0-cp310-cp310-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:8a76ea0f0b9dfa06f254ee06053d93a600865b3274358ca48a352ce4f0798450", size = 231748, upload-time = "2025-10-06T05:35:32.101Z" }, + { url = "https://files.pythonhosted.org/packages/97/d6/e9459f7c5183854abd989ba384fe0cc1a0fb795a83c033f0571ec5933ca4/frozenlist-1.8.0-cp310-cp310-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:c7366fe1418a6133d5aa824ee53d406550110984de7637d65a178010f759c6ef", size = 236351, upload-time = "2025-10-06T05:35:33.834Z" }, + { url = "https://files.pythonhosted.org/packages/97/92/24e97474b65c0262e9ecd076e826bfd1d3074adcc165a256e42e7b8a7249/frozenlist-1.8.0-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:13d23a45c4cebade99340c4165bd90eeb4a56c6d8a9d8aa49568cac19a6d0dc4", size = 218767, upload-time = "2025-10-06T05:35:35.205Z" }, + { url = "https://files.pythonhosted.org/packages/ee/bf/dc394a097508f15abff383c5108cb8ad880d1f64a725ed3b90d5c2fbf0bb/frozenlist-1.8.0-cp310-cp310-musllinux_1_2_armv7l.whl", hash = "sha256:e4a3408834f65da56c83528fb52ce7911484f0d1eaf7b761fc66001db1646eff", size = 235887, upload-time = "2025-10-06T05:35:36.354Z" }, + { url = "https://files.pythonhosted.org/packages/40/90/25b201b9c015dbc999a5baf475a257010471a1fa8c200c843fd4abbee725/frozenlist-1.8.0-cp310-cp310-musllinux_1_2_ppc64le.whl", hash = "sha256:42145cd2748ca39f32801dad54aeea10039da6f86e303659db90db1c4b614c8c", size = 228785, upload-time = "2025-10-06T05:35:37.949Z" }, + { url = "https://files.pythonhosted.org/packages/84/f4/b5bc148df03082f05d2dd30c089e269acdbe251ac9a9cf4e727b2dbb8a3d/frozenlist-1.8.0-cp310-cp310-musllinux_1_2_s390x.whl", hash = "sha256:e2de870d16a7a53901e41b64ffdf26f2fbb8917b3e6ebf398098d72c5b20bd7f", size = 230312, upload-time = "2025-10-06T05:35:39.178Z" }, + { url = "https://files.pythonhosted.org/packages/db/4b/87e95b5d15097c302430e647136b7d7ab2398a702390cf4c8601975709e7/frozenlist-1.8.0-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:20e63c9493d33ee48536600d1a5c95eefc870cd71e7ab037763d1fbb89cc51e7", size = 217650, upload-time = "2025-10-06T05:35:40.377Z" }, + { url = "https://files.pythonhosted.org/packages/e5/70/78a0315d1fea97120591a83e0acd644da638c872f142fd72a6cebee825f3/frozenlist-1.8.0-cp310-cp310-win32.whl", hash = "sha256:adbeebaebae3526afc3c96fad434367cafbfd1b25d72369a9e5858453b1bb71a", size = 39659, upload-time = "2025-10-06T05:35:41.863Z" }, + { url = "https://files.pythonhosted.org/packages/66/aa/3f04523fb189a00e147e60c5b2205126118f216b0aa908035c45336e27e4/frozenlist-1.8.0-cp310-cp310-win_amd64.whl", hash = "sha256:667c3777ca571e5dbeb76f331562ff98b957431df140b54c85fd4d52eea8d8f6", size = 43837, upload-time = "2025-10-06T05:35:43.205Z" }, + { url = "https://files.pythonhosted.org/packages/39/75/1135feecdd7c336938bd55b4dc3b0dfc46d85b9be12ef2628574b28de776/frozenlist-1.8.0-cp310-cp310-win_arm64.whl", hash = "sha256:80f85f0a7cc86e7a54c46d99c9e1318ff01f4687c172ede30fd52d19d1da1c8e", size = 39989, upload-time = "2025-10-06T05:35:44.596Z" }, + { url = "https://files.pythonhosted.org/packages/bc/03/077f869d540370db12165c0aa51640a873fb661d8b315d1d4d67b284d7ac/frozenlist-1.8.0-cp311-cp311-macosx_10_9_universal2.whl", hash = "sha256:09474e9831bc2b2199fad6da3c14c7b0fbdd377cce9d3d77131be28906cb7d84", size = 86912, upload-time = "2025-10-06T05:35:45.98Z" }, + { url = "https://files.pythonhosted.org/packages/df/b5/7610b6bd13e4ae77b96ba85abea1c8cb249683217ef09ac9e0ae93f25a91/frozenlist-1.8.0-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:17c883ab0ab67200b5f964d2b9ed6b00971917d5d8a92df149dc2c9779208ee9", size = 50046, upload-time = "2025-10-06T05:35:47.009Z" }, + { url = "https://files.pythonhosted.org/packages/6e/ef/0e8f1fe32f8a53dd26bdd1f9347efe0778b0fddf62789ea683f4cc7d787d/frozenlist-1.8.0-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:fa47e444b8ba08fffd1c18e8cdb9a75db1b6a27f17507522834ad13ed5922b93", size = 50119, upload-time = "2025-10-06T05:35:48.38Z" }, + { url = "https://files.pythonhosted.org/packages/11/b1/71a477adc7c36e5fb628245dfbdea2166feae310757dea848d02bd0689fd/frozenlist-1.8.0-cp311-cp311-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:2552f44204b744fba866e573be4c1f9048d6a324dfe14475103fd51613eb1d1f", size = 231067, upload-time = "2025-10-06T05:35:49.97Z" }, + { url = "https://files.pythonhosted.org/packages/45/7e/afe40eca3a2dc19b9904c0f5d7edfe82b5304cb831391edec0ac04af94c2/frozenlist-1.8.0-cp311-cp311-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:957e7c38f250991e48a9a73e6423db1bb9dd14e722a10f6b8bb8e16a0f55f695", size = 233160, upload-time = "2025-10-06T05:35:51.729Z" }, + { url = "https://files.pythonhosted.org/packages/a6/aa/7416eac95603ce428679d273255ffc7c998d4132cfae200103f164b108aa/frozenlist-1.8.0-cp311-cp311-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:8585e3bb2cdea02fc88ffa245069c36555557ad3609e83be0ec71f54fd4abb52", size = 228544, upload-time = "2025-10-06T05:35:53.246Z" }, + { url = "https://files.pythonhosted.org/packages/8b/3d/2a2d1f683d55ac7e3875e4263d28410063e738384d3adc294f5ff3d7105e/frozenlist-1.8.0-cp311-cp311-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:edee74874ce20a373d62dc28b0b18b93f645633c2943fd90ee9d898550770581", size = 243797, upload-time = "2025-10-06T05:35:54.497Z" }, + { url = "https://files.pythonhosted.org/packages/78/1e/2d5565b589e580c296d3bb54da08d206e797d941a83a6fdea42af23be79c/frozenlist-1.8.0-cp311-cp311-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:c9a63152fe95756b85f31186bddf42e4c02c6321207fd6601a1c89ebac4fe567", size = 247923, upload-time = "2025-10-06T05:35:55.861Z" }, + { url = "https://files.pythonhosted.org/packages/aa/c3/65872fcf1d326a7f101ad4d86285c403c87be7d832b7470b77f6d2ed5ddc/frozenlist-1.8.0-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:b6db2185db9be0a04fecf2f241c70b63b1a242e2805be291855078f2b404dd6b", size = 230886, upload-time = "2025-10-06T05:35:57.399Z" }, + { url = "https://files.pythonhosted.org/packages/a0/76/ac9ced601d62f6956f03cc794f9e04c81719509f85255abf96e2510f4265/frozenlist-1.8.0-cp311-cp311-musllinux_1_2_armv7l.whl", hash = "sha256:f4be2e3d8bc8aabd566f8d5b8ba7ecc09249d74ba3c9ed52e54dc23a293f0b92", size = 245731, upload-time = "2025-10-06T05:35:58.563Z" }, + { url = "https://files.pythonhosted.org/packages/b9/49/ecccb5f2598daf0b4a1415497eba4c33c1e8ce07495eb07d2860c731b8d5/frozenlist-1.8.0-cp311-cp311-musllinux_1_2_ppc64le.whl", hash = "sha256:c8d1634419f39ea6f5c427ea2f90ca85126b54b50837f31497f3bf38266e853d", size = 241544, upload-time = "2025-10-06T05:35:59.719Z" }, + { url = "https://files.pythonhosted.org/packages/53/4b/ddf24113323c0bbcc54cb38c8b8916f1da7165e07b8e24a717b4a12cbf10/frozenlist-1.8.0-cp311-cp311-musllinux_1_2_s390x.whl", hash = "sha256:1a7fa382a4a223773ed64242dbe1c9c326ec09457e6b8428efb4118c685c3dfd", size = 241806, upload-time = "2025-10-06T05:36:00.959Z" }, + { url = "https://files.pythonhosted.org/packages/a7/fb/9b9a084d73c67175484ba2789a59f8eebebd0827d186a8102005ce41e1ba/frozenlist-1.8.0-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:11847b53d722050808926e785df837353bd4d75f1d494377e59b23594d834967", size = 229382, upload-time = "2025-10-06T05:36:02.22Z" }, + { url = "https://files.pythonhosted.org/packages/95/a3/c8fb25aac55bf5e12dae5c5aa6a98f85d436c1dc658f21c3ac73f9fa95e5/frozenlist-1.8.0-cp311-cp311-win32.whl", hash = "sha256:27c6e8077956cf73eadd514be8fb04d77fc946a7fe9f7fe167648b0b9085cc25", size = 39647, upload-time = "2025-10-06T05:36:03.409Z" }, + { url = "https://files.pythonhosted.org/packages/0a/f5/603d0d6a02cfd4c8f2a095a54672b3cf967ad688a60fb9faf04fc4887f65/frozenlist-1.8.0-cp311-cp311-win_amd64.whl", hash = "sha256:ac913f8403b36a2c8610bbfd25b8013488533e71e62b4b4adce9c86c8cea905b", size = 44064, upload-time = "2025-10-06T05:36:04.368Z" }, + { url = "https://files.pythonhosted.org/packages/5d/16/c2c9ab44e181f043a86f9a8f84d5124b62dbcb3a02c0977ec72b9ac1d3e0/frozenlist-1.8.0-cp311-cp311-win_arm64.whl", hash = "sha256:d4d3214a0f8394edfa3e303136d0575eece0745ff2b47bd2cb2e66dd92d4351a", size = 39937, upload-time = "2025-10-06T05:36:05.669Z" }, + { url = "https://files.pythonhosted.org/packages/69/29/948b9aa87e75820a38650af445d2ef2b6b8a6fab1a23b6bb9e4ef0be2d59/frozenlist-1.8.0-cp312-cp312-macosx_10_13_universal2.whl", hash = "sha256:78f7b9e5d6f2fdb88cdde9440dc147259b62b9d3b019924def9f6478be254ac1", size = 87782, upload-time = "2025-10-06T05:36:06.649Z" }, + { url = "https://files.pythonhosted.org/packages/64/80/4f6e318ee2a7c0750ed724fa33a4bdf1eacdc5a39a7a24e818a773cd91af/frozenlist-1.8.0-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:229bf37d2e4acdaf808fd3f06e854a4a7a3661e871b10dc1f8f1896a3b05f18b", size = 50594, upload-time = "2025-10-06T05:36:07.69Z" }, + { url = "https://files.pythonhosted.org/packages/2b/94/5c8a2b50a496b11dd519f4a24cb5496cf125681dd99e94c604ccdea9419a/frozenlist-1.8.0-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:f833670942247a14eafbb675458b4e61c82e002a148f49e68257b79296e865c4", size = 50448, upload-time = "2025-10-06T05:36:08.78Z" }, + { url = "https://files.pythonhosted.org/packages/6a/bd/d91c5e39f490a49df14320f4e8c80161cfcce09f1e2cde1edd16a551abb3/frozenlist-1.8.0-cp312-cp312-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:494a5952b1c597ba44e0e78113a7266e656b9794eec897b19ead706bd7074383", size = 242411, upload-time = "2025-10-06T05:36:09.801Z" }, + { url = "https://files.pythonhosted.org/packages/8f/83/f61505a05109ef3293dfb1ff594d13d64a2324ac3482be2cedc2be818256/frozenlist-1.8.0-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:96f423a119f4777a4a056b66ce11527366a8bb92f54e541ade21f2374433f6d4", size = 243014, upload-time = "2025-10-06T05:36:11.394Z" }, + { url = "https://files.pythonhosted.org/packages/d8/cb/cb6c7b0f7d4023ddda30cf56b8b17494eb3a79e3fda666bf735f63118b35/frozenlist-1.8.0-cp312-cp312-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:3462dd9475af2025c31cc61be6652dfa25cbfb56cbbf52f4ccfe029f38decaf8", size = 234909, upload-time = "2025-10-06T05:36:12.598Z" }, + { url = "https://files.pythonhosted.org/packages/31/c5/cd7a1f3b8b34af009fb17d4123c5a778b44ae2804e3ad6b86204255f9ec5/frozenlist-1.8.0-cp312-cp312-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:c4c800524c9cd9bac5166cd6f55285957fcfc907db323e193f2afcd4d9abd69b", size = 250049, upload-time = "2025-10-06T05:36:14.065Z" }, + { url = "https://files.pythonhosted.org/packages/c0/01/2f95d3b416c584a1e7f0e1d6d31998c4a795f7544069ee2e0962a4b60740/frozenlist-1.8.0-cp312-cp312-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:d6a5df73acd3399d893dafc71663ad22534b5aa4f94e8a2fabfe856c3c1b6a52", size = 256485, upload-time = "2025-10-06T05:36:15.39Z" }, + { url = "https://files.pythonhosted.org/packages/ce/03/024bf7720b3abaebcff6d0793d73c154237b85bdf67b7ed55e5e9596dc9a/frozenlist-1.8.0-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:405e8fe955c2280ce66428b3ca55e12b3c4e9c336fb2103a4937e891c69a4a29", size = 237619, upload-time = "2025-10-06T05:36:16.558Z" }, + { url = "https://files.pythonhosted.org/packages/69/fa/f8abdfe7d76b731f5d8bd217827cf6764d4f1d9763407e42717b4bed50a0/frozenlist-1.8.0-cp312-cp312-musllinux_1_2_armv7l.whl", hash = "sha256:908bd3f6439f2fef9e85031b59fd4f1297af54415fb60e4254a95f75b3cab3f3", size = 250320, upload-time = "2025-10-06T05:36:17.821Z" }, + { url = "https://files.pythonhosted.org/packages/f5/3c/b051329f718b463b22613e269ad72138cc256c540f78a6de89452803a47d/frozenlist-1.8.0-cp312-cp312-musllinux_1_2_ppc64le.whl", hash = "sha256:294e487f9ec720bd8ffcebc99d575f7eff3568a08a253d1ee1a0378754b74143", size = 246820, upload-time = "2025-10-06T05:36:19.046Z" }, + { url = "https://files.pythonhosted.org/packages/0f/ae/58282e8f98e444b3f4dd42448ff36fa38bef29e40d40f330b22e7108f565/frozenlist-1.8.0-cp312-cp312-musllinux_1_2_s390x.whl", hash = "sha256:74c51543498289c0c43656701be6b077f4b265868fa7f8a8859c197006efb608", size = 250518, upload-time = "2025-10-06T05:36:20.763Z" }, + { url = "https://files.pythonhosted.org/packages/8f/96/007e5944694d66123183845a106547a15944fbbb7154788cbf7272789536/frozenlist-1.8.0-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:776f352e8329135506a1d6bf16ac3f87bc25b28e765949282dcc627af36123aa", size = 239096, upload-time = "2025-10-06T05:36:22.129Z" }, + { url = "https://files.pythonhosted.org/packages/66/bb/852b9d6db2fa40be96f29c0d1205c306288f0684df8fd26ca1951d461a56/frozenlist-1.8.0-cp312-cp312-win32.whl", hash = "sha256:433403ae80709741ce34038da08511d4a77062aa924baf411ef73d1146e74faf", size = 39985, upload-time = "2025-10-06T05:36:23.661Z" }, + { url = "https://files.pythonhosted.org/packages/b8/af/38e51a553dd66eb064cdf193841f16f077585d4d28394c2fa6235cb41765/frozenlist-1.8.0-cp312-cp312-win_amd64.whl", hash = "sha256:34187385b08f866104f0c0617404c8eb08165ab1272e884abc89c112e9c00746", size = 44591, upload-time = "2025-10-06T05:36:24.958Z" }, + { url = "https://files.pythonhosted.org/packages/a7/06/1dc65480ab147339fecc70797e9c2f69d9cea9cf38934ce08df070fdb9cb/frozenlist-1.8.0-cp312-cp312-win_arm64.whl", hash = "sha256:fe3c58d2f5db5fbd18c2987cba06d51b0529f52bc3a6cdc33d3f4eab725104bd", size = 40102, upload-time = "2025-10-06T05:36:26.333Z" }, + { url = "https://files.pythonhosted.org/packages/2d/40/0832c31a37d60f60ed79e9dfb5a92e1e2af4f40a16a29abcc7992af9edff/frozenlist-1.8.0-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:8d92f1a84bb12d9e56f818b3a746f3efba93c1b63c8387a73dde655e1e42282a", size = 85717, upload-time = "2025-10-06T05:36:27.341Z" }, + { url = "https://files.pythonhosted.org/packages/30/ba/b0b3de23f40bc55a7057bd38434e25c34fa48e17f20ee273bbde5e0650f3/frozenlist-1.8.0-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:96153e77a591c8adc2ee805756c61f59fef4cf4073a9275ee86fe8cba41241f7", size = 49651, upload-time = "2025-10-06T05:36:28.855Z" }, + { url = "https://files.pythonhosted.org/packages/0c/ab/6e5080ee374f875296c4243c381bbdef97a9ac39c6e3ce1d5f7d42cb78d6/frozenlist-1.8.0-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:f21f00a91358803399890ab167098c131ec2ddd5f8f5fd5fe9c9f2c6fcd91e40", size = 49417, upload-time = "2025-10-06T05:36:29.877Z" }, + { url = "https://files.pythonhosted.org/packages/d5/4e/e4691508f9477ce67da2015d8c00acd751e6287739123113a9fca6f1604e/frozenlist-1.8.0-cp313-cp313-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:fb30f9626572a76dfe4293c7194a09fb1fe93ba94c7d4f720dfae3b646b45027", size = 234391, upload-time = "2025-10-06T05:36:31.301Z" }, + { url = "https://files.pythonhosted.org/packages/40/76/c202df58e3acdf12969a7895fd6f3bc016c642e6726aa63bd3025e0fc71c/frozenlist-1.8.0-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:eaa352d7047a31d87dafcacbabe89df0aa506abb5b1b85a2fb91bc3faa02d822", size = 233048, upload-time = "2025-10-06T05:36:32.531Z" }, + { url = "https://files.pythonhosted.org/packages/f9/c0/8746afb90f17b73ca5979c7a3958116e105ff796e718575175319b5bb4ce/frozenlist-1.8.0-cp313-cp313-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:03ae967b4e297f58f8c774c7eabcce57fe3c2434817d4385c50661845a058121", size = 226549, upload-time = "2025-10-06T05:36:33.706Z" }, + { url = "https://files.pythonhosted.org/packages/7e/eb/4c7eefc718ff72f9b6c4893291abaae5fbc0c82226a32dcd8ef4f7a5dbef/frozenlist-1.8.0-cp313-cp313-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:f6292f1de555ffcc675941d65fffffb0a5bcd992905015f85d0592201793e0e5", size = 239833, upload-time = "2025-10-06T05:36:34.947Z" }, + { url = "https://files.pythonhosted.org/packages/c2/4e/e5c02187cf704224f8b21bee886f3d713ca379535f16893233b9d672ea71/frozenlist-1.8.0-cp313-cp313-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:29548f9b5b5e3460ce7378144c3010363d8035cea44bc0bf02d57f5a685e084e", size = 245363, upload-time = "2025-10-06T05:36:36.534Z" }, + { url = "https://files.pythonhosted.org/packages/1f/96/cb85ec608464472e82ad37a17f844889c36100eed57bea094518bf270692/frozenlist-1.8.0-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:ec3cc8c5d4084591b4237c0a272cc4f50a5b03396a47d9caaf76f5d7b38a4f11", size = 229314, upload-time = "2025-10-06T05:36:38.582Z" }, + { url = "https://files.pythonhosted.org/packages/5d/6f/4ae69c550e4cee66b57887daeebe006fe985917c01d0fff9caab9883f6d0/frozenlist-1.8.0-cp313-cp313-musllinux_1_2_armv7l.whl", hash = "sha256:517279f58009d0b1f2e7c1b130b377a349405da3f7621ed6bfae50b10adf20c1", size = 243365, upload-time = "2025-10-06T05:36:40.152Z" }, + { url = "https://files.pythonhosted.org/packages/7a/58/afd56de246cf11780a40a2c28dc7cbabbf06337cc8ddb1c780a2d97e88d8/frozenlist-1.8.0-cp313-cp313-musllinux_1_2_ppc64le.whl", hash = "sha256:db1e72ede2d0d7ccb213f218df6a078a9c09a7de257c2fe8fcef16d5925230b1", size = 237763, upload-time = "2025-10-06T05:36:41.355Z" }, + { url = "https://files.pythonhosted.org/packages/cb/36/cdfaf6ed42e2644740d4a10452d8e97fa1c062e2a8006e4b09f1b5fd7d63/frozenlist-1.8.0-cp313-cp313-musllinux_1_2_s390x.whl", hash = "sha256:b4dec9482a65c54a5044486847b8a66bf10c9cb4926d42927ec4e8fd5db7fed8", size = 240110, upload-time = "2025-10-06T05:36:42.716Z" }, + { url = "https://files.pythonhosted.org/packages/03/a8/9ea226fbefad669f11b52e864c55f0bd57d3c8d7eb07e9f2e9a0b39502e1/frozenlist-1.8.0-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:21900c48ae04d13d416f0e1e0c4d81f7931f73a9dfa0b7a8746fb2fe7dd970ed", size = 233717, upload-time = "2025-10-06T05:36:44.251Z" }, + { url = "https://files.pythonhosted.org/packages/1e/0b/1b5531611e83ba7d13ccc9988967ea1b51186af64c42b7a7af465dcc9568/frozenlist-1.8.0-cp313-cp313-win32.whl", hash = "sha256:8b7b94a067d1c504ee0b16def57ad5738701e4ba10cec90529f13fa03c833496", size = 39628, upload-time = "2025-10-06T05:36:45.423Z" }, + { url = "https://files.pythonhosted.org/packages/d8/cf/174c91dbc9cc49bc7b7aab74d8b734e974d1faa8f191c74af9b7e80848e6/frozenlist-1.8.0-cp313-cp313-win_amd64.whl", hash = "sha256:878be833caa6a3821caf85eb39c5ba92d28e85df26d57afb06b35b2efd937231", size = 43882, upload-time = "2025-10-06T05:36:46.796Z" }, + { url = "https://files.pythonhosted.org/packages/c1/17/502cd212cbfa96eb1388614fe39a3fc9ab87dbbe042b66f97acb57474834/frozenlist-1.8.0-cp313-cp313-win_arm64.whl", hash = "sha256:44389d135b3ff43ba8cc89ff7f51f5a0bb6b63d829c8300f79a2fe4fe61bcc62", size = 39676, upload-time = "2025-10-06T05:36:47.8Z" }, + { url = "https://files.pythonhosted.org/packages/d2/5c/3bbfaa920dfab09e76946a5d2833a7cbdf7b9b4a91c714666ac4855b88b4/frozenlist-1.8.0-cp313-cp313t-macosx_10_13_universal2.whl", hash = "sha256:e25ac20a2ef37e91c1b39938b591457666a0fa835c7783c3a8f33ea42870db94", size = 89235, upload-time = "2025-10-06T05:36:48.78Z" }, + { url = "https://files.pythonhosted.org/packages/d2/d6/f03961ef72166cec1687e84e8925838442b615bd0b8854b54923ce5b7b8a/frozenlist-1.8.0-cp313-cp313t-macosx_10_13_x86_64.whl", hash = "sha256:07cdca25a91a4386d2e76ad992916a85038a9b97561bf7a3fd12d5d9ce31870c", size = 50742, upload-time = "2025-10-06T05:36:49.837Z" }, + { url = "https://files.pythonhosted.org/packages/1e/bb/a6d12b7ba4c3337667d0e421f7181c82dda448ce4e7ad7ecd249a16fa806/frozenlist-1.8.0-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:4e0c11f2cc6717e0a741f84a527c52616140741cd812a50422f83dc31749fb52", size = 51725, upload-time = "2025-10-06T05:36:50.851Z" }, + { url = "https://files.pythonhosted.org/packages/bc/71/d1fed0ffe2c2ccd70b43714c6cab0f4188f09f8a67a7914a6b46ee30f274/frozenlist-1.8.0-cp313-cp313t-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:b3210649ee28062ea6099cfda39e147fa1bc039583c8ee4481cb7811e2448c51", size = 284533, upload-time = "2025-10-06T05:36:51.898Z" }, + { url = "https://files.pythonhosted.org/packages/c9/1f/fb1685a7b009d89f9bf78a42d94461bc06581f6e718c39344754a5d9bada/frozenlist-1.8.0-cp313-cp313t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:581ef5194c48035a7de2aefc72ac6539823bb71508189e5de01d60c9dcd5fa65", size = 292506, upload-time = "2025-10-06T05:36:53.101Z" }, + { url = "https://files.pythonhosted.org/packages/e6/3b/b991fe1612703f7e0d05c0cf734c1b77aaf7c7d321df4572e8d36e7048c8/frozenlist-1.8.0-cp313-cp313t-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:3ef2d026f16a2b1866e1d86fc4e1291e1ed8a387b2c333809419a2f8b3a77b82", size = 274161, upload-time = "2025-10-06T05:36:54.309Z" }, + { url = "https://files.pythonhosted.org/packages/ca/ec/c5c618767bcdf66e88945ec0157d7f6c4a1322f1473392319b7a2501ded7/frozenlist-1.8.0-cp313-cp313t-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:5500ef82073f599ac84d888e3a8c1f77ac831183244bfd7f11eaa0289fb30714", size = 294676, upload-time = "2025-10-06T05:36:55.566Z" }, + { url = "https://files.pythonhosted.org/packages/7c/ce/3934758637d8f8a88d11f0585d6495ef54b2044ed6ec84492a91fa3b27aa/frozenlist-1.8.0-cp313-cp313t-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:50066c3997d0091c411a66e710f4e11752251e6d2d73d70d8d5d4c76442a199d", size = 300638, upload-time = "2025-10-06T05:36:56.758Z" }, + { url = "https://files.pythonhosted.org/packages/fc/4f/a7e4d0d467298f42de4b41cbc7ddaf19d3cfeabaf9ff97c20c6c7ee409f9/frozenlist-1.8.0-cp313-cp313t-musllinux_1_2_aarch64.whl", hash = "sha256:5c1c8e78426e59b3f8005e9b19f6ff46e5845895adbde20ece9218319eca6506", size = 283067, upload-time = "2025-10-06T05:36:57.965Z" }, + { url = "https://files.pythonhosted.org/packages/dc/48/c7b163063d55a83772b268e6d1affb960771b0e203b632cfe09522d67ea5/frozenlist-1.8.0-cp313-cp313t-musllinux_1_2_armv7l.whl", hash = "sha256:eefdba20de0d938cec6a89bd4d70f346a03108a19b9df4248d3cf0d88f1b0f51", size = 292101, upload-time = "2025-10-06T05:36:59.237Z" }, + { url = "https://files.pythonhosted.org/packages/9f/d0/2366d3c4ecdc2fd391e0afa6e11500bfba0ea772764d631bbf82f0136c9d/frozenlist-1.8.0-cp313-cp313t-musllinux_1_2_ppc64le.whl", hash = "sha256:cf253e0e1c3ceb4aaff6df637ce033ff6535fb8c70a764a8f46aafd3d6ab798e", size = 289901, upload-time = "2025-10-06T05:37:00.811Z" }, + { url = "https://files.pythonhosted.org/packages/b8/94/daff920e82c1b70e3618a2ac39fbc01ae3e2ff6124e80739ce5d71c9b920/frozenlist-1.8.0-cp313-cp313t-musllinux_1_2_s390x.whl", hash = "sha256:032efa2674356903cd0261c4317a561a6850f3ac864a63fc1583147fb05a79b0", size = 289395, upload-time = "2025-10-06T05:37:02.115Z" }, + { url = "https://files.pythonhosted.org/packages/e3/20/bba307ab4235a09fdcd3cc5508dbabd17c4634a1af4b96e0f69bfe551ebd/frozenlist-1.8.0-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:6da155091429aeba16851ecb10a9104a108bcd32f6c1642867eadaee401c1c41", size = 283659, upload-time = "2025-10-06T05:37:03.711Z" }, + { url = "https://files.pythonhosted.org/packages/fd/00/04ca1c3a7a124b6de4f8a9a17cc2fcad138b4608e7a3fc5877804b8715d7/frozenlist-1.8.0-cp313-cp313t-win32.whl", hash = "sha256:0f96534f8bfebc1a394209427d0f8a63d343c9779cda6fc25e8e121b5fd8555b", size = 43492, upload-time = "2025-10-06T05:37:04.915Z" }, + { url = "https://files.pythonhosted.org/packages/59/5e/c69f733a86a94ab10f68e496dc6b7e8bc078ebb415281d5698313e3af3a1/frozenlist-1.8.0-cp313-cp313t-win_amd64.whl", hash = "sha256:5d63a068f978fc69421fb0e6eb91a9603187527c86b7cd3f534a5b77a592b888", size = 48034, upload-time = "2025-10-06T05:37:06.343Z" }, + { url = "https://files.pythonhosted.org/packages/16/6c/be9d79775d8abe79b05fa6d23da99ad6e7763a1d080fbae7290b286093fd/frozenlist-1.8.0-cp313-cp313t-win_arm64.whl", hash = "sha256:bf0a7e10b077bf5fb9380ad3ae8ce20ef919a6ad93b4552896419ac7e1d8e042", size = 41749, upload-time = "2025-10-06T05:37:07.431Z" }, + { url = "https://files.pythonhosted.org/packages/f1/c8/85da824b7e7b9b6e7f7705b2ecaf9591ba6f79c1177f324c2735e41d36a2/frozenlist-1.8.0-cp314-cp314-macosx_10_13_universal2.whl", hash = "sha256:cee686f1f4cadeb2136007ddedd0aaf928ab95216e7691c63e50a8ec066336d0", size = 86127, upload-time = "2025-10-06T05:37:08.438Z" }, + { url = "https://files.pythonhosted.org/packages/8e/e8/a1185e236ec66c20afd72399522f142c3724c785789255202d27ae992818/frozenlist-1.8.0-cp314-cp314-macosx_10_13_x86_64.whl", hash = "sha256:119fb2a1bd47307e899c2fac7f28e85b9a543864df47aa7ec9d3c1b4545f096f", size = 49698, upload-time = "2025-10-06T05:37:09.48Z" }, + { url = "https://files.pythonhosted.org/packages/a1/93/72b1736d68f03fda5fdf0f2180fb6caaae3894f1b854d006ac61ecc727ee/frozenlist-1.8.0-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:4970ece02dbc8c3a92fcc5228e36a3e933a01a999f7094ff7c23fbd2beeaa67c", size = 49749, upload-time = "2025-10-06T05:37:10.569Z" }, + { url = "https://files.pythonhosted.org/packages/a7/b2/fabede9fafd976b991e9f1b9c8c873ed86f202889b864756f240ce6dd855/frozenlist-1.8.0-cp314-cp314-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:cba69cb73723c3f329622e34bdbf5ce1f80c21c290ff04256cff1cd3c2036ed2", size = 231298, upload-time = "2025-10-06T05:37:11.993Z" }, + { url = "https://files.pythonhosted.org/packages/3a/3b/d9b1e0b0eed36e70477ffb8360c49c85c8ca8ef9700a4e6711f39a6e8b45/frozenlist-1.8.0-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:778a11b15673f6f1df23d9586f83c4846c471a8af693a22e066508b77d201ec8", size = 232015, upload-time = "2025-10-06T05:37:13.194Z" }, + { url = "https://files.pythonhosted.org/packages/dc/94/be719d2766c1138148564a3960fc2c06eb688da592bdc25adcf856101be7/frozenlist-1.8.0-cp314-cp314-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:0325024fe97f94c41c08872db482cf8ac4800d80e79222c6b0b7b162d5b13686", size = 225038, upload-time = "2025-10-06T05:37:14.577Z" }, + { url = "https://files.pythonhosted.org/packages/e4/09/6712b6c5465f083f52f50cf74167b92d4ea2f50e46a9eea0523d658454ae/frozenlist-1.8.0-cp314-cp314-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:97260ff46b207a82a7567b581ab4190bd4dfa09f4db8a8b49d1a958f6aa4940e", size = 240130, upload-time = "2025-10-06T05:37:15.781Z" }, + { url = "https://files.pythonhosted.org/packages/f8/d4/cd065cdcf21550b54f3ce6a22e143ac9e4836ca42a0de1022da8498eac89/frozenlist-1.8.0-cp314-cp314-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:54b2077180eb7f83dd52c40b2750d0a9f175e06a42e3213ce047219de902717a", size = 242845, upload-time = "2025-10-06T05:37:17.037Z" }, + { url = "https://files.pythonhosted.org/packages/62/c3/f57a5c8c70cd1ead3d5d5f776f89d33110b1addae0ab010ad774d9a44fb9/frozenlist-1.8.0-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:2f05983daecab868a31e1da44462873306d3cbfd76d1f0b5b69c473d21dbb128", size = 229131, upload-time = "2025-10-06T05:37:18.221Z" }, + { url = "https://files.pythonhosted.org/packages/6c/52/232476fe9cb64f0742f3fde2b7d26c1dac18b6d62071c74d4ded55e0ef94/frozenlist-1.8.0-cp314-cp314-musllinux_1_2_armv7l.whl", hash = "sha256:33f48f51a446114bc5d251fb2954ab0164d5be02ad3382abcbfe07e2531d650f", size = 240542, upload-time = "2025-10-06T05:37:19.771Z" }, + { url = "https://files.pythonhosted.org/packages/5f/85/07bf3f5d0fb5414aee5f47d33c6f5c77bfe49aac680bfece33d4fdf6a246/frozenlist-1.8.0-cp314-cp314-musllinux_1_2_ppc64le.whl", hash = "sha256:154e55ec0655291b5dd1b8731c637ecdb50975a2ae70c606d100750a540082f7", size = 237308, upload-time = "2025-10-06T05:37:20.969Z" }, + { url = "https://files.pythonhosted.org/packages/11/99/ae3a33d5befd41ac0ca2cc7fd3aa707c9c324de2e89db0e0f45db9a64c26/frozenlist-1.8.0-cp314-cp314-musllinux_1_2_s390x.whl", hash = "sha256:4314debad13beb564b708b4a496020e5306c7333fa9a3ab90374169a20ffab30", size = 238210, upload-time = "2025-10-06T05:37:22.252Z" }, + { url = "https://files.pythonhosted.org/packages/b2/60/b1d2da22f4970e7a155f0adde9b1435712ece01b3cd45ba63702aea33938/frozenlist-1.8.0-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:073f8bf8becba60aa931eb3bc420b217bb7d5b8f4750e6f8b3be7f3da85d38b7", size = 231972, upload-time = "2025-10-06T05:37:23.5Z" }, + { url = "https://files.pythonhosted.org/packages/3f/ab/945b2f32de889993b9c9133216c068b7fcf257d8595a0ac420ac8677cab0/frozenlist-1.8.0-cp314-cp314-win32.whl", hash = "sha256:bac9c42ba2ac65ddc115d930c78d24ab8d4f465fd3fc473cdedfccadb9429806", size = 40536, upload-time = "2025-10-06T05:37:25.581Z" }, + { url = "https://files.pythonhosted.org/packages/59/ad/9caa9b9c836d9ad6f067157a531ac48b7d36499f5036d4141ce78c230b1b/frozenlist-1.8.0-cp314-cp314-win_amd64.whl", hash = "sha256:3e0761f4d1a44f1d1a47996511752cf3dcec5bbdd9cc2b4fe595caf97754b7a0", size = 44330, upload-time = "2025-10-06T05:37:26.928Z" }, + { url = "https://files.pythonhosted.org/packages/82/13/e6950121764f2676f43534c555249f57030150260aee9dcf7d64efda11dd/frozenlist-1.8.0-cp314-cp314-win_arm64.whl", hash = "sha256:d1eaff1d00c7751b7c6662e9c5ba6eb2c17a2306ba5e2a37f24ddf3cc953402b", size = 40627, upload-time = "2025-10-06T05:37:28.075Z" }, + { url = "https://files.pythonhosted.org/packages/c0/c7/43200656ecc4e02d3f8bc248df68256cd9572b3f0017f0a0c4e93440ae23/frozenlist-1.8.0-cp314-cp314t-macosx_10_13_universal2.whl", hash = "sha256:d3bb933317c52d7ea5004a1c442eef86f426886fba134ef8cf4226ea6ee1821d", size = 89238, upload-time = "2025-10-06T05:37:29.373Z" }, + { url = "https://files.pythonhosted.org/packages/d1/29/55c5f0689b9c0fb765055629f472c0de484dcaf0acee2f7707266ae3583c/frozenlist-1.8.0-cp314-cp314t-macosx_10_13_x86_64.whl", hash = "sha256:8009897cdef112072f93a0efdce29cd819e717fd2f649ee3016efd3cd885a7ed", size = 50738, upload-time = "2025-10-06T05:37:30.792Z" }, + { url = "https://files.pythonhosted.org/packages/ba/7d/b7282a445956506fa11da8c2db7d276adcbf2b17d8bb8407a47685263f90/frozenlist-1.8.0-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:2c5dcbbc55383e5883246d11fd179782a9d07a986c40f49abe89ddf865913930", size = 51739, upload-time = "2025-10-06T05:37:32.127Z" }, + { url = "https://files.pythonhosted.org/packages/62/1c/3d8622e60d0b767a5510d1d3cf21065b9db874696a51ea6d7a43180a259c/frozenlist-1.8.0-cp314-cp314t-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:39ecbc32f1390387d2aa4f5a995e465e9e2f79ba3adcac92d68e3e0afae6657c", size = 284186, upload-time = "2025-10-06T05:37:33.21Z" }, + { url = "https://files.pythonhosted.org/packages/2d/14/aa36d5f85a89679a85a1d44cd7a6657e0b1c75f61e7cad987b203d2daca8/frozenlist-1.8.0-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:92db2bf818d5cc8d9c1f1fc56b897662e24ea5adb36ad1f1d82875bd64e03c24", size = 292196, upload-time = "2025-10-06T05:37:36.107Z" }, + { url = "https://files.pythonhosted.org/packages/05/23/6bde59eb55abd407d34f77d39a5126fb7b4f109a3f611d3929f14b700c66/frozenlist-1.8.0-cp314-cp314t-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:2dc43a022e555de94c3b68a4ef0b11c4f747d12c024a520c7101709a2144fb37", size = 273830, upload-time = "2025-10-06T05:37:37.663Z" }, + { url = "https://files.pythonhosted.org/packages/d2/3f/22cff331bfad7a8afa616289000ba793347fcd7bc275f3b28ecea2a27909/frozenlist-1.8.0-cp314-cp314t-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:cb89a7f2de3602cfed448095bab3f178399646ab7c61454315089787df07733a", size = 294289, upload-time = "2025-10-06T05:37:39.261Z" }, + { url = "https://files.pythonhosted.org/packages/a4/89/5b057c799de4838b6c69aa82b79705f2027615e01be996d2486a69ca99c4/frozenlist-1.8.0-cp314-cp314t-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:33139dc858c580ea50e7e60a1b0ea003efa1fd42e6ec7fdbad78fff65fad2fd2", size = 300318, upload-time = "2025-10-06T05:37:43.213Z" }, + { url = "https://files.pythonhosted.org/packages/30/de/2c22ab3eb2a8af6d69dc799e48455813bab3690c760de58e1bf43b36da3e/frozenlist-1.8.0-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:168c0969a329b416119507ba30b9ea13688fafffac1b7822802537569a1cb0ef", size = 282814, upload-time = "2025-10-06T05:37:45.337Z" }, + { url = "https://files.pythonhosted.org/packages/59/f7/970141a6a8dbd7f556d94977858cfb36fa9b66e0892c6dd780d2219d8cd8/frozenlist-1.8.0-cp314-cp314t-musllinux_1_2_armv7l.whl", hash = "sha256:28bd570e8e189d7f7b001966435f9dac6718324b5be2990ac496cf1ea9ddb7fe", size = 291762, upload-time = "2025-10-06T05:37:46.657Z" }, + { url = "https://files.pythonhosted.org/packages/c1/15/ca1adae83a719f82df9116d66f5bb28bb95557b3951903d39135620ef157/frozenlist-1.8.0-cp314-cp314t-musllinux_1_2_ppc64le.whl", hash = "sha256:b2a095d45c5d46e5e79ba1e5b9cb787f541a8dee0433836cea4b96a2c439dcd8", size = 289470, upload-time = "2025-10-06T05:37:47.946Z" }, + { url = "https://files.pythonhosted.org/packages/ac/83/dca6dc53bf657d371fbc88ddeb21b79891e747189c5de990b9dfff2ccba1/frozenlist-1.8.0-cp314-cp314t-musllinux_1_2_s390x.whl", hash = "sha256:eab8145831a0d56ec9c4139b6c3e594c7a83c2c8be25d5bcf2d86136a532287a", size = 289042, upload-time = "2025-10-06T05:37:49.499Z" }, + { url = "https://files.pythonhosted.org/packages/96/52/abddd34ca99be142f354398700536c5bd315880ed0a213812bc491cff5e4/frozenlist-1.8.0-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:974b28cf63cc99dfb2188d8d222bc6843656188164848c4f679e63dae4b0708e", size = 283148, upload-time = "2025-10-06T05:37:50.745Z" }, + { url = "https://files.pythonhosted.org/packages/af/d3/76bd4ed4317e7119c2b7f57c3f6934aba26d277acc6309f873341640e21f/frozenlist-1.8.0-cp314-cp314t-win32.whl", hash = "sha256:342c97bf697ac5480c0a7ec73cd700ecfa5a8a40ac923bd035484616efecc2df", size = 44676, upload-time = "2025-10-06T05:37:52.222Z" }, + { url = "https://files.pythonhosted.org/packages/89/76/c615883b7b521ead2944bb3480398cbb07e12b7b4e4d073d3752eb721558/frozenlist-1.8.0-cp314-cp314t-win_amd64.whl", hash = "sha256:06be8f67f39c8b1dc671f5d83aaefd3358ae5cdcf8314552c57e7ed3e6475bdd", size = 49451, upload-time = "2025-10-06T05:37:53.425Z" }, + { url = "https://files.pythonhosted.org/packages/e0/a3/5982da14e113d07b325230f95060e2169f5311b1017ea8af2a29b374c289/frozenlist-1.8.0-cp314-cp314t-win_arm64.whl", hash = "sha256:102e6314ca4da683dca92e3b1355490fed5f313b768500084fbe6371fddfdb79", size = 42507, upload-time = "2025-10-06T05:37:54.513Z" }, + { url = "https://files.pythonhosted.org/packages/9a/9a/e35b4a917281c0b8419d4207f4334c8e8c5dbf4f3f5f9ada73958d937dcc/frozenlist-1.8.0-py3-none-any.whl", hash = "sha256:0c18a16eab41e82c295618a77502e17b195883241c563b00f0aa5106fc4eaa0d", size = 13409, upload-time = "2025-10-06T05:38:16.721Z" }, +] + [[package]] name = "ghp-import" version = "2.1.0" @@ -679,6 +1010,19 @@ wheels = [ { url = "https://files.pythonhosted.org/packages/2a/39/e50c7c3a983047577ee07d2a9e53faf5a69493943ec3f6a384bdc792deb2/httpx-0.28.1-py3-none-any.whl", hash = "sha256:d909fcccc110f8c7faf814ca82a9a4d816bc5a6dbfea25d6591d6985b8ba59ad", size = 73517, upload-time = "2024-12-06T15:37:21.509Z" }, ] +[[package]] +name = "httpx-aiohttp" +version = "0.2.0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "aiohttp" }, + { name = "httpx" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/4c/87/3b2df9732a497403e5f4bbf2ec9f25427d53cec797e83070c503649863ef/httpx_aiohttp-0.2.0.tar.gz", hash = "sha256:d4796b981f04734f1d1db9b4d9326ea16bc994f126460b93b69036262cd4a9d8", size = 195714, upload-time = "2026-07-25T07:34:12.17Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/e8/e2/74b6bad3a6d342aee12d8b8d825456c02d21d72319c924326d17444c5ff7/httpx_aiohttp-0.2.0-py3-none-any.whl", hash = "sha256:ccd6eb19ba18805476096e8ef0b369a6beda3955db145a538979eface2fce7ff", size = 9732, upload-time = "2026-07-25T07:34:10.939Z" }, +] + [[package]] name = "idna" version = "3.20" @@ -1125,6 +1469,187 @@ wheels = [ { url = "https://files.pythonhosted.org/packages/be/1b/fc924a97a237adda47f15c1b0cc271639e6b181ab3f95500fbf060c79a69/mkdocstrings_python-2.0.10-py3-none-any.whl", hash = "sha256:4a3aaeebb25ba5ae57a8f9e75432fe4571984889602f2b2f7d672faa760e9062", size = 105538, upload-time = "2026-10-19T15:58:06.287Z" }, ] +[[package]] +name = "multidict" +version = "7.1.0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "typing-extensions", marker = "python_full_version < '3.11'" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/f9/79/84ddb5ba16c4eb2c69c71db76ae3c579fe546e511f7170c7e27eedbab7c1/multidict-7.1.0.tar.gz", hash = "sha256:61a4e5d81b8d4e4ad61964b230129e7a2b914793d96289029078fc9009f074ec", size = 362341, upload-time = "2026-10-09T20:31:38.279Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/9c/27/77366104f779d883f1a13ef3e8e274cbc2adf75847afecdee0970ace37ed/multidict-7.1.0-cp310-cp310-macosx_10_9_universal2.whl", hash = "sha256:24ad4921135a1410d95b1f1504f4901e1c64cea680014ce2c3c7a825f4f259fc", size = 166031, upload-time = "2026-10-09T13:58:50.692Z" }, + { url = "https://files.pythonhosted.org/packages/02/c0/dd8df25b15560bd6dcb1d844150ed72af8fc2f2b52e29b4362b22c91383d/multidict-7.1.0-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:8b8429361241da973e594d15344a0989f44fd288ea58d33a6221fb7cc0daf27e", size = 95884, upload-time = "2026-10-09T13:58:52.034Z" }, + { url = "https://files.pythonhosted.org/packages/0b/31/e759ae1d3a44db8af1c6f37e1a0d290122b455ee4ebce4b989705b5a8787/multidict-7.1.0-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:5c6455f2c11daeee40665c67494cedb426f67dba7375710524071c0c56d739a6", size = 99026, upload-time = "2026-10-09T13:58:53.365Z" }, + { url = "https://files.pythonhosted.org/packages/cb/ee/898d2a18bd1ef8b2adc20c7d8ab8f027f2b9e5da9cb40675133778e26215/multidict-7.1.0-cp310-cp310-manylinux1_i686.manylinux_2_28_i686.manylinux_2_5_i686.whl", hash = "sha256:6120aab922bb3e15800b6655558cf8e0a5cc79518e954d457f064e5b3d5e9bf6", size = 436692, upload-time = "2026-10-09T13:58:54.57Z" }, + { url = "https://files.pythonhosted.org/packages/7d/c2/2a6994dff5c01685ab08db1a88bad2579fa1db3e74e568cba632118242f8/multidict-7.1.0-cp310-cp310-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:14b1ce8579a43dfc0e592d93fb1d63dea693e4977980ac4166f26d494cc7a358", size = 455754, upload-time = "2026-10-09T13:58:56.159Z" }, + { url = "https://files.pythonhosted.org/packages/48/27/353916a8c627067b54723792f172813025f87f9f70f9771c27214f748b01/multidict-7.1.0-cp310-cp310-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:71acdc6eded0f4b86b5e16c96314887cf2572a8eb5d8038b78583d0c0eb3aa1c", size = 427471, upload-time = "2026-10-09T13:58:57.569Z" }, + { url = "https://files.pythonhosted.org/packages/62/f4/08993b1ee8e208dbf6cdcb5b536f4dd261211cde2c864cdcc2b527eb974b/multidict-7.1.0-cp310-cp310-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:6b7cd1cb0b363cd43ebf499beca26d201dd8b89eee49fae60205c82ba13ee03a", size = 477087, upload-time = "2026-10-09T13:58:58.879Z" }, + { url = "https://files.pythonhosted.org/packages/ba/02/31f6890cc54c83de25df712fab9300ef7b13edef463aa7e0f68e5afe40dc/multidict-7.1.0-cp310-cp310-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:dd8a6b3e8f9edb07fe671b02d8c3241c8b641fecce7eb1e36432db3e55e243da", size = 488933, upload-time = "2026-10-09T13:59:00.632Z" }, + { url = "https://files.pythonhosted.org/packages/5a/9c/598d765e98aa02ff7204b6f11cf790e5840f5e8252d7b1d955ed0043bb94/multidict-7.1.0-cp310-cp310-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:9a8c826caeb7c08264e0a556df1267531c6ed90cc70506e7e5f4119e2d09f3d7", size = 464425, upload-time = "2026-10-09T13:59:01.955Z" }, + { url = "https://files.pythonhosted.org/packages/eb/07/b6b3508ba72bb82944f985cdd9c4d398c442c07270e5179ea03262b9bf03/multidict-7.1.0-cp310-cp310-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:c44ced5e5168cdf677f0ae39900863bf2bda7d14a5e13502014005cfe040b8b4", size = 420397, upload-time = "2026-10-09T13:59:03.61Z" }, + { url = "https://files.pythonhosted.org/packages/8c/81/596582dfcf8d3c2d41ec03f24849be9e53c8a44aebd40cf45a31720112f5/multidict-7.1.0-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:b57d4d7021bfd159db9f8f6f862a85a7a6027934643c512f028d6e5c60c4cbd2", size = 445983, upload-time = "2026-10-09T13:59:04.941Z" }, + { url = "https://files.pythonhosted.org/packages/f6/aa/600a68f29c2b027c2000e4ec6f51824790ff9a13a3828487716e31ac3277/multidict-7.1.0-cp310-cp310-musllinux_1_2_armv7l.whl", hash = "sha256:7fac4250b37d994e3fe42b46ba3c8bfa1614d1d7d8cf1cf23f303099082a9565", size = 421056, upload-time = "2026-10-09T13:59:06.469Z" }, + { url = "https://files.pythonhosted.org/packages/c1/82/006ef3fb5f2b798e9e538125667ba1b90ed8967bc862d7b9103297b2bcb7/multidict-7.1.0-cp310-cp310-musllinux_1_2_i686.whl", hash = "sha256:966ae0588ac9959a040220063733b33f321d04eaf4e60349b42cd855d232202f", size = 436830, upload-time = "2026-10-09T13:59:07.882Z" }, + { url = "https://files.pythonhosted.org/packages/3b/6e/ffa1117db64d4be681f908cb7f38877c70cd06bbbdf29c8685839dcff7d2/multidict-7.1.0-cp310-cp310-musllinux_1_2_ppc64le.whl", hash = "sha256:50acd7ee7096949b04482cd7720cb6b85eb9cd9dd5d7ffb6704bfda250261a22", size = 465434, upload-time = "2026-10-09T13:59:09.272Z" }, + { url = "https://files.pythonhosted.org/packages/44/8b/f3ab95a4fb591467c0d2a3c0876f38c17aa0b5c2cd60b4c53bc0c9867c7d/multidict-7.1.0-cp310-cp310-musllinux_1_2_riscv64.whl", hash = "sha256:ed6b7f402f3dabd1d72c798b96cf947005ddd796a5bea7b041bccbd517859a42", size = 417108, upload-time = "2026-10-09T13:59:10.595Z" }, + { url = "https://files.pythonhosted.org/packages/fc/2c/3e929884b0f3fd4ae96572d62952e18a76048115832835fb11075295590a/multidict-7.1.0-cp310-cp310-musllinux_1_2_s390x.whl", hash = "sha256:fadcc96cd6155f35e6d85845fa4fcd37b35885dc8fda77b9f851cdfa538194c1", size = 471643, upload-time = "2026-10-09T13:59:12.082Z" }, + { url = "https://files.pythonhosted.org/packages/32/7b/0c3451ada3a85c1232b04ed0209d5421b07ecad1f69d1b55939b3be0cef4/multidict-7.1.0-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:c6b67f08014bfc4aedc22cf6a21010c2530cd5fbeb655730406827fe196296be", size = 459115, upload-time = "2026-10-09T13:59:13.613Z" }, + { url = "https://files.pythonhosted.org/packages/ee/d9/aa3b846e69c3730bd999f4f95943301ac26d999d9e285e75b9759c340a45/multidict-7.1.0-cp310-cp310-win32.whl", hash = "sha256:0604ff025497a050a2b2dcc4ae0e5cb6477c525e57b89825152c707e88d74d28", size = 81811, upload-time = "2026-10-09T13:59:14.941Z" }, + { url = "https://files.pythonhosted.org/packages/f0/2d/f4907e688463dedc1e644777851c0aaf2b814f37278436f9d3f4d3225a0e/multidict-7.1.0-cp310-cp310-win_amd64.whl", hash = "sha256:36b14886aa3e0b8786ecdaa196374422c7b1c1dcc8764d02b2409f74d47914bc", size = 92126, upload-time = "2026-10-09T13:59:16.222Z" }, + { url = "https://files.pythonhosted.org/packages/16/b8/5f438830119ab1979245c07bf61038813d2f7509f38d1031d6b8e2114bcc/multidict-7.1.0-cp310-cp310-win_arm64.whl", hash = "sha256:a2e575129c048bc286d696ed8e49ca148591768b2d77debcc6569f6fb64d0668", size = 92561, upload-time = "2026-10-09T13:59:17.47Z" }, + { url = "https://files.pythonhosted.org/packages/29/72/c68c86c078a3b3cfa254bce218fbeaf1f6617d4ace811558154ae63d2c20/multidict-7.1.0-cp311-cp311-macosx_10_9_universal2.whl", hash = "sha256:41ff3202cc23c800507777df5a4805b402f262b31008c60fdc652aeb6db2f278", size = 165442, upload-time = "2026-10-09T13:59:19.146Z" }, + { url = "https://files.pythonhosted.org/packages/7c/af/988c71ec3a6fe143b2971ac8d57cd5aca7cc6da970bccd1e4c2254997a09/multidict-7.1.0-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:e50f7775b66c7802f4cb697e986c5acf30ec07301efee95b396c08114e890d67", size = 95611, upload-time = "2026-10-09T13:59:20.591Z" }, + { url = "https://files.pythonhosted.org/packages/30/5e/7d18eb5a75cf4bacb6b3ee689929dcb27d7ed8ca2d245e80e9b8056fcbf5/multidict-7.1.0-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:85cb3ced4fa84949cee12bfe78208b6ece7baf3cbd242b26dcaf773efff8d206", size = 98743, upload-time = "2026-10-09T13:59:21.841Z" }, + { url = "https://files.pythonhosted.org/packages/72/38/2aeff3de6ddf235094aad6f833e3df14d1b3175e328748508443cb2b5458/multidict-7.1.0-cp311-cp311-manylinux1_i686.manylinux_2_28_i686.manylinux_2_5_i686.whl", hash = "sha256:2128f3358335e0c83688ecb40c19d9d6606cd60784dfbf2e24e980ac2ba87b0d", size = 452832, upload-time = "2026-10-09T13:59:23.131Z" }, + { url = "https://files.pythonhosted.org/packages/eb/1f/94d8b7fc7d47bb43be1fc041bccc2784383d352258d4d0dd90ef55d1a2e5/multidict-7.1.0-cp311-cp311-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:e2e718fa9d1d900decbc240a533d5d0baf0947ef464c78a8cd4fa32b4e8f590c", size = 475378, upload-time = "2026-10-09T13:59:24.661Z" }, + { url = "https://files.pythonhosted.org/packages/93/86/78f431ef2735fae7a773261ea26cff11e37cbbb4520bf3caed56ece006f1/multidict-7.1.0-cp311-cp311-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:ecc68f5e47bc6f6f889bbed5bc657b22bb2237ad9ccab8229cb5a0d64f4cb536", size = 442847, upload-time = "2026-10-09T13:59:26.276Z" }, + { url = "https://files.pythonhosted.org/packages/45/d3/1c5af82fe42f677f7c4dcaf487449511d754b84fc29f11a6d190cfb01836/multidict-7.1.0-cp311-cp311-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:5f21fda91bd6c34455bd5c312e42aa1334da46cdafb4c533ecd01e0f7f19250b", size = 493652, upload-time = "2026-10-09T13:59:28.162Z" }, + { url = "https://files.pythonhosted.org/packages/c4/bc/414b4a83a12811329c046a7c1954d6f08a5eda63f8466939a6cb612da22b/multidict-7.1.0-cp311-cp311-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:7a90453a79423cd7145cc08fc92322dcd7aca4862258f533e03f473226d4b835", size = 506991, upload-time = "2026-10-09T13:59:29.701Z" }, + { url = "https://files.pythonhosted.org/packages/ec/ac/a91709d7153489a3b53661b62af371112b96fb083d10443e22d54665a1e1/multidict-7.1.0-cp311-cp311-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:c54ae1b89e582aa25f213cd8b5eac0bda1724e79299f486baeb3f562bbf82ca5", size = 480392, upload-time = "2026-10-09T13:59:31.179Z" }, + { url = "https://files.pythonhosted.org/packages/72/63/a4fc53b6da419876f363fc6860f9fbaa48eb8066f458e907eb2989e9510b/multidict-7.1.0-cp311-cp311-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:7ff8dd079e7b5f3438332499233a2a5acfca0741fd0eb3d4ddba0c2d9bc04d19", size = 431248, upload-time = "2026-10-09T13:59:32.899Z" }, + { url = "https://files.pythonhosted.org/packages/3d/78/08af4a624b3b9d2f48af730c173394135d14afbf4b3de5ae6c80e0900fd1/multidict-7.1.0-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:e4ef15d0a29fc2da67fe8ba2301ecabd6f8733696cc2bf0a0cf96a144a20328c", size = 463657, upload-time = "2026-10-09T13:59:34.721Z" }, + { url = "https://files.pythonhosted.org/packages/58/ef/06e5c75b88506972c880d228fe96702cf0fa058ea31f157f5fcd5efcf006/multidict-7.1.0-cp311-cp311-musllinux_1_2_armv7l.whl", hash = "sha256:5fa296f14068538fced53c6eec86520a2ef3d3d27a0fb134640d03e067986d5f", size = 436120, upload-time = "2026-10-09T13:59:36.135Z" }, + { url = "https://files.pythonhosted.org/packages/23/8d/a917004a1e8ceb325c4cf0583e418a40b7ff9519cbfe759bc6982cd3b4c1/multidict-7.1.0-cp311-cp311-musllinux_1_2_i686.whl", hash = "sha256:6ab323f0c5490abaf35a78563e1043c7a772eb86d93f359ecc0fd286d1cd3807", size = 453859, upload-time = "2026-10-09T13:59:37.878Z" }, + { url = "https://files.pythonhosted.org/packages/1f/0b/d1cc417355625152b611790aa1f0bc780983ed8c0752f44087fc7dbe66c9/multidict-7.1.0-cp311-cp311-musllinux_1_2_ppc64le.whl", hash = "sha256:88ec4d16e9f58071c9896ea01c4da97cce9d01418fe844ff06eebb00e0a1386a", size = 481768, upload-time = "2026-10-09T13:59:39.39Z" }, + { url = "https://files.pythonhosted.org/packages/94/0b/8e79adf65cf5430497d1020504b7d86ebe90e3289a95bb6b252a630d761f/multidict-7.1.0-cp311-cp311-musllinux_1_2_riscv64.whl", hash = "sha256:9161eb81b8062da824426d3700d4b0d287f0cb0b05923713adfe3bd25e7937ac", size = 426973, upload-time = "2026-10-09T13:59:40.932Z" }, + { url = "https://files.pythonhosted.org/packages/ae/4c/e84d6e05943600b16cd2745587e65a407f89b3a4a1f77081d456c5a07011/multidict-7.1.0-cp311-cp311-musllinux_1_2_s390x.whl", hash = "sha256:c564d0758748f38aec56a6b98c6801a427b3a63f39b7cac538b2b2d18ca32740", size = 489681, upload-time = "2026-10-09T13:59:42.663Z" }, + { url = "https://files.pythonhosted.org/packages/eb/98/01951236a01b3e15c037a4a796f329b5099374e46365d0bc65bb4a7b325d/multidict-7.1.0-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:c5e4a362a95b85301d262ef6bed06cc8e4a144ac7e2be874cb4c3c46ae89d754", size = 475655, upload-time = "2026-10-09T13:59:44.508Z" }, + { url = "https://files.pythonhosted.org/packages/d3/72/52be318cdb46732da8eb118c2e4212fe570724eaef817901f8b702af2016/multidict-7.1.0-cp311-cp311-win32.whl", hash = "sha256:5d19bb1ec12e385c09215d5d53a243c060c7e8a0aacdba16d933e22902ee380d", size = 81719, upload-time = "2026-10-09T13:59:46.158Z" }, + { url = "https://files.pythonhosted.org/packages/37/fd/1ed7b7d206ef7a6918ac3de515543ca4b49bc50131325ca1814c005daf3f/multidict-7.1.0-cp311-cp311-win_amd64.whl", hash = "sha256:396ba9917fe489ec3a5942ae3e29e91324c8b9956f371f7e124c971c71379e7a", size = 93586, upload-time = "2026-10-09T13:59:47.618Z" }, + { url = "https://files.pythonhosted.org/packages/d8/1e/837877d218bfd2b656ca899ec9dd83e6eb82d8e1ef16e896d5abf3cb60cd/multidict-7.1.0-cp311-cp311-win_arm64.whl", hash = "sha256:b5ed78742502b8d90ff2816688d407a097c8b5cc6af4343fc5ad7a98df53a7cd", size = 92446, upload-time = "2026-10-09T13:59:48.996Z" }, + { url = "https://files.pythonhosted.org/packages/03/e1/215e7df354e2907f3af9d910c8136653cfec94796012a776359bc802a326/multidict-7.1.0-cp312-cp312-macosx_10_13_universal2.whl", hash = "sha256:ccfb950359a80de0fcd2030ad60ac1b1a861462de3e2ef746697c9256659af21", size = 165426, upload-time = "2026-10-09T13:59:50.564Z" }, + { url = "https://files.pythonhosted.org/packages/a4/ec/461ba588b308ada2cd16907d6ea425ca4d417596b88c12814ad9a0bb7325/multidict-7.1.0-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:939d8cd2d8c35e3956f6bc858390b6ccb611e6152b4920d64ab5e98f3fcf39e4", size = 95943, upload-time = "2026-10-09T13:59:52.381Z" }, + { url = "https://files.pythonhosted.org/packages/c9/84/31444ef07ec13a33c42c2772d986129e137e69c4beb89ca64f2138988145/multidict-7.1.0-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:f8e95c95039eab6a2dad8c83c38ab87fc5431d28849e0c8a7e2a4e70ba38710d", size = 98294, upload-time = "2026-10-09T13:59:54.066Z" }, + { url = "https://files.pythonhosted.org/packages/dc/10/aca13806d73d88b5b01e35e828e23a346cb1abad710a49dff0507702efc9/multidict-7.1.0-cp312-cp312-manylinux1_i686.manylinux_2_28_i686.manylinux_2_5_i686.whl", hash = "sha256:05d12b4bac53abe0c65f3163af2b45894e2e1c0cc55493ac784d52a350047d88", size = 453301, upload-time = "2026-10-09T13:59:55.397Z" }, + { url = "https://files.pythonhosted.org/packages/96/8c/382d771bfb3a9282d98332d0e1f27fd1f8b4ae0e7175bd7e008ebf934900/multidict-7.1.0-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:0e79ed92b1dece6bb57e9b46effd74d7a5d3d00187c85466d880ed184239a698", size = 478570, upload-time = "2026-10-09T13:59:56.899Z" }, + { url = "https://files.pythonhosted.org/packages/52/9c/e81b0c92449da3a1950a575c520d957d7be618777d170717a71e00558d7f/multidict-7.1.0-cp312-cp312-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:fab380fcff8b3555eb2bd04304fa4330909a771a9a9b0dc07666cfc23148a711", size = 443699, upload-time = "2026-10-09T13:59:58.465Z" }, + { url = "https://files.pythonhosted.org/packages/63/72/f8f5fee6960d1b580a7b046c7c5abccf67aa26fa5647927a91c9c835c2f8/multidict-7.1.0-cp312-cp312-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:4b5c41e44da74383c924cc5d75ef0a268f301d69305b3c42bd17af685d55e412", size = 497332, upload-time = "2026-10-09T14:08:01.88Z" }, + { url = "https://files.pythonhosted.org/packages/e2/92/a25d7db3ca451b588e743e067ee80f2b475edf6467a56908454faf6a714c/multidict-7.1.0-cp312-cp312-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:3dbaa7f7c2f0ca8578895fc61fb8c8e50ebb405dad8982f92f4343285c7a3fda", size = 512457, upload-time = "2026-10-09T14:08:25.465Z" }, + { url = "https://files.pythonhosted.org/packages/7a/f3/374c0ab122bb98b1a62a8742b1e3f59563e4d609942005a4041861a0df67/multidict-7.1.0-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:fed6b7705d49dd07e5e0dd5f5c873fc44047e92d714299b13245b5fecac49d01", size = 483000, upload-time = "2026-10-09T14:08:27.132Z" }, + { url = "https://files.pythonhosted.org/packages/46/1f/01c8522859771dc3cee840d5852233fe84c91aa982a1cd8ad594306d25cc/multidict-7.1.0-cp312-cp312-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:53daa47dd176db64bb35170e3d5d0ae2388c060121201883696278f055a0e70c", size = 430746, upload-time = "2026-10-09T14:08:28.715Z" }, + { url = "https://files.pythonhosted.org/packages/ab/f3/af90affc8cca6b4ee59b2ec354a20839005e829d14d155451009810ef1ce/multidict-7.1.0-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:542429c796430de924d03b68a6173bb6d79d5c4967d4e9a18de3e501cad55593", size = 466859, upload-time = "2026-10-09T20:27:24.139Z" }, + { url = "https://files.pythonhosted.org/packages/f8/97/1b6762f37f6331449e164af9d5500f0abb0f23670e81ba543441e0a6be1d/multidict-7.1.0-cp312-cp312-musllinux_1_2_armv7l.whl", hash = "sha256:c44ca6d3cdf4cfcbcd4f928fdcbe87af5fd7319f6ad4169617b7fd6b4527c33c", size = 441952, upload-time = "2026-10-09T20:27:26.559Z" }, + { url = "https://files.pythonhosted.org/packages/bf/d2/4908177fbf22438799c04ba11a2853a99c69d028fccefe61f19e68caba0c/multidict-7.1.0-cp312-cp312-musllinux_1_2_i686.whl", hash = "sha256:eb0228c809b2e7eb47921876050af0bc4214b351bad8d8112f70b6ed4288763c", size = 452810, upload-time = "2026-10-09T20:27:28.347Z" }, + { url = "https://files.pythonhosted.org/packages/8d/05/5031f44f680ec54fc182c4d71c9ab7c07216983946aa64ce6fdd56a52692/multidict-7.1.0-cp312-cp312-musllinux_1_2_ppc64le.whl", hash = "sha256:6ad60de1f4c702448fc8f1449f05e810f6b7957c08a5b3950c8a792dfb13b50a", size = 483934, upload-time = "2026-10-09T20:27:30.14Z" }, + { url = "https://files.pythonhosted.org/packages/da/3b/9b21d107dbe96fa7e6966ff9e5e10b9ac0d2d1c2cf1633098e4c700f865e/multidict-7.1.0-cp312-cp312-musllinux_1_2_riscv64.whl", hash = "sha256:f79def86aee67b5ba01b2565f1610f262bf88ae53c379f93e5fa29c50fe793be", size = 427042, upload-time = "2026-10-09T20:27:32.433Z" }, + { url = "https://files.pythonhosted.org/packages/53/ce/5b01b1041580072866b30e39c6380bff269e72fb5ca41a7f2fb828ede943/multidict-7.1.0-cp312-cp312-musllinux_1_2_s390x.whl", hash = "sha256:248dabb89b5aa90b2f7e43e045f048f7e5392ec77b6446d80853ba7117d7bbdf", size = 492543, upload-time = "2026-10-09T20:27:34.459Z" }, + { url = "https://files.pythonhosted.org/packages/1e/6f/6508a23fcc7b1122e4f18409d7900ffeb3cd020cd080fe98aba3eabf9486/multidict-7.1.0-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:0747a83e7ae617793181a4763ee8b84863cec5c0bbbde70c4394e4c0276c36de", size = 475796, upload-time = "2026-10-09T20:27:36.289Z" }, + { url = "https://files.pythonhosted.org/packages/8f/b6/ebb6433f4aa55ac1fea4bf11e860e99611640d07cc92d21cb3f35608de22/multidict-7.1.0-cp312-cp312-win32.whl", hash = "sha256:1df055e51fe7491120cc84f3362bd43db186be78d0e4c476acad45e435af9ffb", size = 81250, upload-time = "2026-10-09T20:27:38.229Z" }, + { url = "https://files.pythonhosted.org/packages/61/0a/11240e5e7d2e986e288f4a6090f569ad00225b7c2c513d4096b36643f9ab/multidict-7.1.0-cp312-cp312-win_amd64.whl", hash = "sha256:10202ba98cfb3f7eb60da7ca87a2c458a69b7d0d6e4d4388cd6773ebbce89085", size = 93817, upload-time = "2026-10-09T20:27:39.739Z" }, + { url = "https://files.pythonhosted.org/packages/e9/9b/a04ffd76db7cca2a60d347e839315e1ada63017c6c343fa90a23a5a55433/multidict-7.1.0-cp312-cp312-win_arm64.whl", hash = "sha256:0aa1ba3ff7cdda05a1242490612976b2ae1c90fc6200903ef8f53815dcb35c5d", size = 92312, upload-time = "2026-10-09T20:27:41.285Z" }, + { url = "https://files.pythonhosted.org/packages/60/34/22ee5f60d704e8edfe6e0a37ca1e2d1efe276560dc8f6f8caee35ea7a4f5/multidict-7.1.0-cp313-cp313-android_24_x86_64.whl", hash = "sha256:51d7f33be9a4a1a2801430846d72841deea0894eae8381a07e7d90e0f71b3c4b", size = 101454, upload-time = "2026-10-09T20:27:43.102Z" }, + { url = "https://files.pythonhosted.org/packages/3b/6d/7652943397171fd624de163d25fc6d2807852931c40c24776cfee3f857cc/multidict-7.1.0-cp313-cp313-ios_13_0_arm64_iphoneos.whl", hash = "sha256:2a964dfeb2aba3663f0536c809aa1ff385f065e89fae57e883fb7edfb4067c2f", size = 95823, upload-time = "2026-10-09T20:27:44.912Z" }, + { url = "https://files.pythonhosted.org/packages/a2/57/717d1aa4e901f58a7e93b945ed741c860d950f456b75be47123fef507ac2/multidict-7.1.0-cp313-cp313-ios_13_0_arm64_iphonesimulator.whl", hash = "sha256:d02cd23b5af182a49d635ee72be38053767711987a9fd82625b16b93828a0d8c", size = 97841, upload-time = "2026-10-09T20:27:46.616Z" }, + { url = "https://files.pythonhosted.org/packages/a8/74/d2d22d306225f3c53ea5a682abb8a43bc30057d6c78b5c94a74035450bfd/multidict-7.1.0-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:0179698c3c913eb64f32397083747fad20ed0f0a2b7469a08cd1a8a95d14d90e", size = 164661, upload-time = "2026-10-09T20:27:48.495Z" }, + { url = "https://files.pythonhosted.org/packages/55/f4/1e63fea41ba86768e18dbc1743e6780f75ad32d7a45e418740c6fb64589e/multidict-7.1.0-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:ccf98ee859fe29f874ddd8e637f14ba59108a333492b521acb885a9095244a9c", size = 95489, upload-time = "2026-10-09T20:27:50.055Z" }, + { url = "https://files.pythonhosted.org/packages/8c/55/477c351b21b34fe948ffffa8b64cd0c246efd998fed3de922b217e632e59/multidict-7.1.0-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:5fa1484f74d011addf2e5f5a0378ec41521989839a05d6051d8067d8ce732423", size = 97931, upload-time = "2026-10-09T20:27:51.598Z" }, + { url = "https://files.pythonhosted.org/packages/cc/dd/288508d7deb9489dd7c8e0b172d62dc1da8f3cb24877293ead42e6cc2047/multidict-7.1.0-cp313-cp313-manylinux1_i686.manylinux_2_28_i686.manylinux_2_5_i686.whl", hash = "sha256:1fed3d721f75c25a9fcdd0e362af53f4b20acbcdc63081112f85419ba0ce3444", size = 453816, upload-time = "2026-10-09T20:27:53.217Z" }, + { url = "https://files.pythonhosted.org/packages/60/ed/172447dd09f06111f69d2cf22a018020b34a93a39ddf72cddfdb48323449/multidict-7.1.0-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:df03e392cae1e05462918abbae06d6100f1e53f67db971ff0ac6c07d9edf7321", size = 477779, upload-time = "2026-10-09T20:27:54.972Z" }, + { url = "https://files.pythonhosted.org/packages/e4/7d/e5b7755e84611ee846f0dc830cb1363ce10764b29247a01b857722fda653/multidict-7.1.0-cp313-cp313-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:379f477b98a1e9a77ddc3ccaa8c709d3fb4a288ff54b96e171e637b55b4adbae", size = 441299, upload-time = "2026-10-09T20:27:56.901Z" }, + { url = "https://files.pythonhosted.org/packages/1b/d6/e9c93da1644491610f09258349283421a279fdb3b383929b4d963698691c/multidict-7.1.0-cp313-cp313-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:40f586bc8a084a3671ddcae9e5fbd3228a596bfb63d9f0380f153f9a65b69f08", size = 496193, upload-time = "2026-10-09T20:27:58.788Z" }, + { url = "https://files.pythonhosted.org/packages/22/49/7fe19efed1b1c73e2f6ae65eba4e6528eeb26e10c970dc0bb0fc009a2aae/multidict-7.1.0-cp313-cp313-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:6e7f70d912a589e30290ed926f90ddbc3160998359cbad7c9ede1bcee481748c", size = 511469, upload-time = "2026-10-09T20:28:00.689Z" }, + { url = "https://files.pythonhosted.org/packages/4d/2e/7b708a72001323dc6b2930834d63e355870ea5b1ee8d1450e0fe1a24752b/multidict-7.1.0-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:5129cc1f5fec6888e2db0be936dab67242e32c738811c8769aeea93aab4257a8", size = 481377, upload-time = "2026-10-09T20:28:03.011Z" }, + { url = "https://files.pythonhosted.org/packages/8b/60/3d23e7d2ebc7e7e6b1b205de0d5c2ce0652a9b2edef65eea3528758b5699/multidict-7.1.0-cp313-cp313-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:1401caec21fd7f002e79ab6806bbfd1f54bb3de6d5e12bd91c6685dce16ad2be", size = 429992, upload-time = "2026-10-09T20:28:04.846Z" }, + { url = "https://files.pythonhosted.org/packages/f6/e6/8e3bef78ea1929a3f2c395aa292799d4effd6ce1b5cfce42c1986a33e2b5/multidict-7.1.0-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:c81062e947f4b5a624135a843f6ac4b3c7fe6508300c9fb27347f022ba0c513d", size = 465635, upload-time = "2026-10-09T20:28:06.527Z" }, + { url = "https://files.pythonhosted.org/packages/44/6a/55fe5dd90c0e9ce60f5c4fa8ace27eeb1190d9cbb151929b04412f0c673a/multidict-7.1.0-cp313-cp313-musllinux_1_2_armv7l.whl", hash = "sha256:c53be0dd676484a660acc56e4f1cd0dd74bc1255d12fa285e86a3fa9d5f22bf9", size = 441693, upload-time = "2026-10-09T20:28:08.443Z" }, + { url = "https://files.pythonhosted.org/packages/c2/a9/628913f71537dce7dbd6c4ee1ae5019976264427c55354ecc593b4b921b9/multidict-7.1.0-cp313-cp313-musllinux_1_2_i686.whl", hash = "sha256:41e0c3350d08994ee8640c39884e16514e282f70ba40f5b2299582509a327774", size = 453808, upload-time = "2026-10-09T20:28:10.871Z" }, + { url = "https://files.pythonhosted.org/packages/25/d0/3ae3af653b5776d045f460582006d0b4d7dd41b078b3ab2e874bf4d1e22f/multidict-7.1.0-cp313-cp313-musllinux_1_2_ppc64le.whl", hash = "sha256:abeec7a89d698aa1c9b4c36bd5e3c746faef0867076e6a2ca27fa5077c4ece26", size = 483160, upload-time = "2026-10-09T20:28:12.892Z" }, + { url = "https://files.pythonhosted.org/packages/56/3e/2c13e111b9f4c6216aee0ac57ac39c53db7f97e42bb8490e60a06eaca352/multidict-7.1.0-cp313-cp313-musllinux_1_2_riscv64.whl", hash = "sha256:23f6d325241b0db006ca2841309ed17622137e134930a740a8f1331ec4404791", size = 425896, upload-time = "2026-10-09T20:28:14.65Z" }, + { url = "https://files.pythonhosted.org/packages/45/13/15b4d614cf0d6838a7d89eb14f4820fdecfd1b7f529061d172a674912d41/multidict-7.1.0-cp313-cp313-musllinux_1_2_s390x.whl", hash = "sha256:034b0dc1b7fb8279599c5d8563f86abb4d2454735b06544ecab23c54572ad2bd", size = 491674, upload-time = "2026-10-09T20:28:16.508Z" }, + { url = "https://files.pythonhosted.org/packages/4f/97/3a6f8c75f12a607ff047e3db9a45dff6a558b1e31b89b2f0f27da0fedb6f/multidict-7.1.0-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:5c8074ad4d67067c87bd0663dfda654f786336078c8fd7d2f6c1aa41de8494cc", size = 473989, upload-time = "2026-10-09T20:28:18.284Z" }, + { url = "https://files.pythonhosted.org/packages/3f/20/5e7726631e50b6afd26324a234851a06104b8ee30f01bc209140788b76c6/multidict-7.1.0-cp313-cp313-win32.whl", hash = "sha256:7b25c335fc53acf29d4d21dbc19fe39d2824201cdda0448623152cc5917bd259", size = 80952, upload-time = "2026-10-09T20:28:20.044Z" }, + { url = "https://files.pythonhosted.org/packages/4f/19/b26bdbef5bf5071ea5a3ba37c963af187fddb8b0a925bd39c0c5dd0ad04a/multidict-7.1.0-cp313-cp313-win_amd64.whl", hash = "sha256:7de54b49e6da811b0321e412d14efdaa1ee0c0b6609296ea5b9022bc5b2bd843", size = 93554, upload-time = "2026-10-09T20:28:21.657Z" }, + { url = "https://files.pythonhosted.org/packages/35/d5/e9a8600d3868e3fdc4a4be1d15e594048508511c0398423df0ed18c11b5a/multidict-7.1.0-cp313-cp313-win_arm64.whl", hash = "sha256:aeba2c750102051aa51e087c2ccbc79f2724a41c94168f8731e36f54c453551a", size = 92039, upload-time = "2026-10-09T20:28:23.464Z" }, + { url = "https://files.pythonhosted.org/packages/2c/a7/c9f5c08348a6f903143b631546e22becf1b704a1304b17f7e1b9850308d2/multidict-7.1.0-cp314-cp314-android_24_x86_64.whl", hash = "sha256:128ea4142f81a79d430f3d0eb55206093e5eda03a12abbc7b03c34748ff6116b", size = 100435, upload-time = "2026-10-09T20:28:26.111Z" }, + { url = "https://files.pythonhosted.org/packages/82/60/92fe617008c74cc019483b1c59202c48738c6f637ad5b12b36f01e21db43/multidict-7.1.0-cp314-cp314-ios_13_0_arm64_iphoneos.whl", hash = "sha256:439a19f7fbbff232ce96682c57e27030b8ac3a4b8121484c94f04bf99d08bfff", size = 95267, upload-time = "2026-10-09T20:28:27.856Z" }, + { url = "https://files.pythonhosted.org/packages/17/78/82182f311d673f17de15bc7f7465c7ea5cbd2987ca3a6bf6546fa721e9d8/multidict-7.1.0-cp314-cp314-ios_13_0_arm64_iphonesimulator.whl", hash = "sha256:8090c35199d6b7bc6426bb8bdaf341e64f295cc2624a1fda7860c0837f1acc03", size = 97233, upload-time = "2026-10-09T20:28:29.817Z" }, + { url = "https://files.pythonhosted.org/packages/63/25/af4e482d053fd73b4b1d60de3ff5578c6cb1d319d39d3f2a454d65409835/multidict-7.1.0-cp314-cp314-macosx_10_15_universal2.whl", hash = "sha256:b7cc5333fcbfb27327d12612ed72322f221b61c2b69deb1155078c964f86e1a1", size = 163070, upload-time = "2026-10-09T20:28:31.495Z" }, + { url = "https://files.pythonhosted.org/packages/df/d5/eaed52e199451dac445305fb2631d3f4e7ac9536aeef01f23622a1d93f90/multidict-7.1.0-cp314-cp314-macosx_10_15_x86_64.whl", hash = "sha256:b0e0040b0d8dd89bd0af9ab18901981e344ffba68bb30b8eabb4eab6c303279b", size = 94582, upload-time = "2026-10-09T20:28:33.263Z" }, + { url = "https://files.pythonhosted.org/packages/6b/e3/ff58ecad5161baa98dec05716e2745449446f2424a9c727464bf452f7fd1/multidict-7.1.0-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:33376418ab2846b931a72b36cfa16810befc4f49485d0b3f4dc054a4d6d00038", size = 97406, upload-time = "2026-10-09T20:28:34.981Z" }, + { url = "https://files.pythonhosted.org/packages/ac/a2/ae4eadf02d4bc035baa7cadf5548ca4fa441517193f76ce1aeb5ed276ae3/multidict-7.1.0-cp314-cp314-manylinux1_i686.manylinux_2_28_i686.manylinux_2_5_i686.whl", hash = "sha256:1101aea5c3eb1d26e090b931c693488af0db9f3d52e68be8d4cdd807dad9841d", size = 449908, upload-time = "2026-10-09T20:28:36.659Z" }, + { url = "https://files.pythonhosted.org/packages/91/55/bd5101ef760d1af4c3f246330b29b48ee22bfdd5a83150b713dd93b431e2/multidict-7.1.0-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:f996b19ac89e0dae65821ce65f788619e4286f78c62d005ecd3b75b5d9c0892b", size = 471605, upload-time = "2026-10-09T20:28:38.561Z" }, + { url = "https://files.pythonhosted.org/packages/4d/8f/3dea8a28b0416ab71d47c8ce274bb3cacedde2d9838647ac67cdaa3d48e6/multidict-7.1.0-cp314-cp314-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:e0d91a4bcb59ac0d7af0d8e0da737332e1b7fe6831e53e47819b1b5349d431b2", size = 433523, upload-time = "2026-10-09T20:28:40.913Z" }, + { url = "https://files.pythonhosted.org/packages/24/97/805d2aa4f746cc43cf4b206f1b1bfe2566add95bbb145abd3d9cf61858bf/multidict-7.1.0-cp314-cp314-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:e96d67914ddbf5466e4476a1cd7ff30a332cbab85ed895207acc3e58c979b6a7", size = 488277, upload-time = "2026-10-09T20:28:42.851Z" }, + { url = "https://files.pythonhosted.org/packages/dd/7b/eac247b7e76f6010071c7c2401da5255eeffd1b2ac981925e533413d21ec/multidict-7.1.0-cp314-cp314-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:170ba61761f59ab92afcc86ce5534a3f3d0b07c38b339b950a83213f22dd86ec", size = 501888, upload-time = "2026-10-09T20:28:44.75Z" }, + { url = "https://files.pythonhosted.org/packages/87/58/de62e27b09dd15756265765945f68f1c0d1e23eaba09e2e109fbb4112425/multidict-7.1.0-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:33389fe084e5426d9fd85d7d9ca91a29cd0d88a83c7c96e411aca49a3f9967bc", size = 474883, upload-time = "2026-10-09T20:28:46.704Z" }, + { url = "https://files.pythonhosted.org/packages/21/fd/afb4e50ce3b44707b5ee39c6b5fa1573bdb50c4be660bb35b040362b5170/multidict-7.1.0-cp314-cp314-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:77024596b9046572c4e90b34c1ff212346756dc48933f90c53cf6e233660788d", size = 424327, upload-time = "2026-10-09T20:28:48.681Z" }, + { url = "https://files.pythonhosted.org/packages/23/70/96c9abf933c4edae53b8a1c8d3f038120a3a60d363f16c6d94eee9b04851/multidict-7.1.0-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:ff15531a376dc6f35984443fd1429e4b150c36ce27633e7cc52a9e5318546e20", size = 459255, upload-time = "2026-10-09T20:28:50.562Z" }, + { url = "https://files.pythonhosted.org/packages/24/37/dbc1dba26dc1c9e42aa07ee01908131a67fee0e79ebe5c1d0e7fc00aad55/multidict-7.1.0-cp314-cp314-musllinux_1_2_armv7l.whl", hash = "sha256:544f2642a456fa264614e975d921540ee8c3b368b04d5aa1ddbec33241b13e08", size = 432476, upload-time = "2026-10-09T20:28:52.361Z" }, + { url = "https://files.pythonhosted.org/packages/9c/0a/eac70cc1461668bad8253a2da727670a56293eaba112aeb4079af8cd37d9/multidict-7.1.0-cp314-cp314-musllinux_1_2_i686.whl", hash = "sha256:08834fb8b20e1a985c70e8380a10940234b4162de62694458727330376e58b33", size = 450030, upload-time = "2026-10-09T20:28:54.252Z" }, + { url = "https://files.pythonhosted.org/packages/23/2d/eb40652ea74f96df859c7c5d38f9997f420b9dc404300dda0c5745327a6f/multidict-7.1.0-cp314-cp314-musllinux_1_2_ppc64le.whl", hash = "sha256:b4908e17867930b7ac77f89a18dc67308c67c511f037d8580489be86fb585912", size = 476169, upload-time = "2026-10-09T20:28:56.819Z" }, + { url = "https://files.pythonhosted.org/packages/44/d0/7454ab8335bc4ec9f8abcc4c83a314bab060f22db6da8436b396e07ed21a/multidict-7.1.0-cp314-cp314-musllinux_1_2_riscv64.whl", hash = "sha256:9b24e1f93b9b586ec03bc7bea1bf021ec90bf2528c729195028a3ca1c266b3f9", size = 420459, upload-time = "2026-10-09T20:28:58.744Z" }, + { url = "https://files.pythonhosted.org/packages/60/7a/cedb46b287b720a2c4eda2448faf162612d0b718beb32581e35ccd9219b3/multidict-7.1.0-cp314-cp314-musllinux_1_2_s390x.whl", hash = "sha256:5c93473d0d7cd9bbb370973a9679a62f381c7050d7dff4ad6aaa92e8650f5a79", size = 483071, upload-time = "2026-10-09T20:29:01.114Z" }, + { url = "https://files.pythonhosted.org/packages/9a/11/e7ded22b008546dd30ae8c979aa5ac3282cad98876f7d5bbe93c1f2409a0/multidict-7.1.0-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:bf14cfcc30b097583d698a6e2b8b68c9bcffab277c485d481881958360c2938d", size = 467470, upload-time = "2026-10-09T20:29:03.388Z" }, + { url = "https://files.pythonhosted.org/packages/1d/f3/0136144cb0b1731fd93475cea75d974a55009358d3bf61dd55e2709a3dca/multidict-7.1.0-cp314-cp314-win32.whl", hash = "sha256:86bc779a0896e59e4be30a5be5cd6eeffd0b40b6f0e75e730218736b7bfc6f5c", size = 80205, upload-time = "2026-10-09T20:29:05.736Z" }, + { url = "https://files.pythonhosted.org/packages/74/d9/a62a690d780febc171026d3e3c5700fc8387aa3e5f77cd04ada33d23d3f4/multidict-7.1.0-cp314-cp314-win_amd64.whl", hash = "sha256:6c9fd50f636a8fa9cb6324cd3eac962fec2bc5bb432452a3b583583a1059acfc", size = 92923, upload-time = "2026-10-09T20:29:07.337Z" }, + { url = "https://files.pythonhosted.org/packages/84/08/eb7a1c34dc37c5f2c6aef52e6861e6f1cdfc6c685dcb72581eb218c00953/multidict-7.1.0-cp314-cp314-win_arm64.whl", hash = "sha256:e6906aa4bc62cde2c8aeb8a99a7b4401b241e274ae7b11df67d863d61ab3d5de", size = 92851, upload-time = "2026-10-09T20:29:09.15Z" }, + { url = "https://files.pythonhosted.org/packages/ff/3a/019abd746e8fbed9edd74b81259f20b278c011cef918868506d9b5bd6566/multidict-7.1.0-cp314-cp314t-macosx_10_15_universal2.whl", hash = "sha256:fabfdd4cf97db033196b51af46b8a681d4785c2a66347f2a5af1b4bbb1182629", size = 177429, upload-time = "2026-10-09T20:29:10.989Z" }, + { url = "https://files.pythonhosted.org/packages/f7/41/c8dda935231305d9b83c4a4cc5b5b9e323615328d4704f00ba2cf6d89916/multidict-7.1.0-cp314-cp314t-macosx_10_15_x86_64.whl", hash = "sha256:a177a0ee5cf19931dcaeb3f662bc562754cfa4f4ace2351d9da24a954ef7db94", size = 102003, upload-time = "2026-10-09T20:29:12.78Z" }, + { url = "https://files.pythonhosted.org/packages/af/23/3c3e79a222eaaa59a32648cec34709d848657be5339f96876075731e7f8e/multidict-7.1.0-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:0ae91de396d5c4ac97cb24dbada3d5c91a51454781e0a70476b008f4e879e4f0", size = 104861, upload-time = "2026-10-09T20:29:14.591Z" }, + { url = "https://files.pythonhosted.org/packages/cd/5b/04637e7cea5729466fb89048520fde167c5404df1beedcc86f18aeabed7c/multidict-7.1.0-cp314-cp314t-manylinux1_i686.manylinux_2_28_i686.manylinux_2_5_i686.whl", hash = "sha256:160bdb3520fdadcaa21e1b98aab2e011265070814ecab3804eb61674becbd400", size = 463221, upload-time = "2026-10-09T20:29:16.697Z" }, + { url = "https://files.pythonhosted.org/packages/2d/42/b121767de213a9774399c200cb877b19c2e1e5a0b0a6bc8407c7325fa37e/multidict-7.1.0-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:6c2144785e42527404bbd5cfd11981fee4abe59a22aded0e498eb711a831d3f3", size = 502241, upload-time = "2026-10-09T20:29:18.657Z" }, + { url = "https://files.pythonhosted.org/packages/47/0a/1cccd17ebf39776df7d8a6c99d066fc3ac1823d044cfe86a22ebbf42b841/multidict-7.1.0-cp314-cp314t-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:7d0b4fec6a8d02d7e95de5cfa913261820f1ce04bd4c0381924de0da523179b8", size = 457128, upload-time = "2026-10-09T20:29:20.589Z" }, + { url = "https://files.pythonhosted.org/packages/19/a9/0616d20dee16255f8737d9017288d9304dabf3695ac0071baca25d00c713/multidict-7.1.0-cp314-cp314t-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:943a9bce22180ad0f4d32d1b402a0949a4ecfe5a1257b47f54a1b51981d81b86", size = 511842, upload-time = "2026-10-09T20:29:22.569Z" }, + { url = "https://files.pythonhosted.org/packages/91/68/5a406b82ecfeee50c097c05fd519c836a61815d81c4a9a8c523d90fb4b35/multidict-7.1.0-cp314-cp314t-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:f76ceb623f7ff50df46ac57e1587c479d87a5766319c4f43d0c0a5158896afab", size = 519852, upload-time = "2026-10-09T20:29:24.527Z" }, + { url = "https://files.pythonhosted.org/packages/d5/da/d42234f9d4f0e33885c70149112bf62aa4436045090c15cec0810ada0b2f/multidict-7.1.0-cp314-cp314t-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:98beff85392ce435b28a0971ec21cade61ce8be8b632c9d855475a28ef92d31a", size = 500322, upload-time = "2026-10-09T20:29:26.569Z" }, + { url = "https://files.pythonhosted.org/packages/fb/c6/323e921a9812a6ea82978d4e1d9713e0b709023be037e6e4c14efe5472eb/multidict-7.1.0-cp314-cp314t-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:71196ebb8d523148e5975396a444de02367f204b53b14e26794c96b2be0ed742", size = 444070, upload-time = "2026-10-09T20:29:28.52Z" }, + { url = "https://files.pythonhosted.org/packages/93/87/109b7170de2168294f3e562f9d10caaaf946628d614b5a57246279acc1a6/multidict-7.1.0-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:35534b366410a36bb3d6f788691e37a76e4d1da48326b0ada3e5032580dd76af", size = 484862, upload-time = "2026-10-09T20:29:30.504Z" }, + { url = "https://files.pythonhosted.org/packages/51/cf/7f1f63c9cf13f47036c0c64c607e6eee87c94076e3c6876abb6990ee62ad/multidict-7.1.0-cp314-cp314t-musllinux_1_2_armv7l.whl", hash = "sha256:b4674b12701c3fcbdf7f88b9e4479701c93bec5da9eb576140d5fcc0092990af", size = 457314, upload-time = "2026-10-09T20:29:32.6Z" }, + { url = "https://files.pythonhosted.org/packages/93/ce/7de8b4ee6a847cc951915c279fc388127ec32a7c14aa7a01c4ad692be575/multidict-7.1.0-cp314-cp314t-musllinux_1_2_i686.whl", hash = "sha256:0ead852a5e906a43fcb6784eeac480f6a67919a51d480c1f80d32ddf9d615475", size = 462672, upload-time = "2026-10-09T20:29:34.776Z" }, + { url = "https://files.pythonhosted.org/packages/f6/6c/02dd089475983b1f5b8729319caa0b02fa3a60b527f27c86b2d53c24ca11/multidict-7.1.0-cp314-cp314t-musllinux_1_2_ppc64le.whl", hash = "sha256:afe36ca503c2ffe30fb6df82b20389fa3c4035b5d65888a61310921cf3ae91c5", size = 498109, upload-time = "2026-10-09T20:29:36.763Z" }, + { url = "https://files.pythonhosted.org/packages/47/d9/b9bdc59aa8e3eaf1f9e5d2460bbe0c428a01250d44417f8ccf965a8f6fa6/multidict-7.1.0-cp314-cp314t-musllinux_1_2_riscv64.whl", hash = "sha256:a5f0bebb10aae010d3c9ee3abaf83ab2069c718457aea09c15532355dd7e061f", size = 442260, upload-time = "2026-10-09T20:29:38.872Z" }, + { url = "https://files.pythonhosted.org/packages/fa/83/21b044885ab81bf5c03ec5c4c16aa449977e428c5c122e38969481cec1df/multidict-7.1.0-cp314-cp314t-musllinux_1_2_s390x.whl", hash = "sha256:b9d9b7d72975521434368fe8aed3f6b522060bf271adabaa5ca6c87c0c08e168", size = 498916, upload-time = "2026-10-09T20:29:41.091Z" }, + { url = "https://files.pythonhosted.org/packages/95/8b/31686730092e349ee2255fa630945ca344fc62e76f0b18d65b0f3dbb0ecf/multidict-7.1.0-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:274023bf952f849e0d05eba28a4c1f65f9796430d2b09ec16539386c0f76554c", size = 493525, upload-time = "2026-10-09T20:29:43.192Z" }, + { url = "https://files.pythonhosted.org/packages/c7/d0/c9fddcd7ac42b70a46ac9cf15e21eb527874164e14d418fcb50ce7190a4b/multidict-7.1.0-cp314-cp314t-win32.whl", hash = "sha256:7e0bfa161df365ba3c88899ee3b7c94755200967284bdedef8c1b8b43e2c0f2b", size = 86481, upload-time = "2026-10-09T20:29:45.188Z" }, + { url = "https://files.pythonhosted.org/packages/24/ab/ce727c06680e72b5d381caa8587f561cb6fea1bfab6ba20c877019768a6f/multidict-7.1.0-cp314-cp314t-win_amd64.whl", hash = "sha256:34a35be8fb82d37087e8176aba907b9459f03d0e293c80f574c6337a436f4eaa", size = 99676, upload-time = "2026-10-09T20:29:47.441Z" }, + { url = "https://files.pythonhosted.org/packages/fa/e7/d116d7ce514d04d9bf63774ed55e8033e2ce15ab5655a597bb947c53dfb8/multidict-7.1.0-cp314-cp314t-win_arm64.whl", hash = "sha256:d7dd46a8fcd7653c09ebe67eae9d4cb6636c7a905d9cbaf587dabcbd4eca6013", size = 98726, upload-time = "2026-10-09T20:29:49.365Z" }, + { url = "https://files.pythonhosted.org/packages/28/42/963e2e38ffd79487b24775841cfe2abb85aa1fa08ee152afc4a9b64e1cdd/multidict-7.1.0-cp315-cp315-android_24_x86_64.whl", hash = "sha256:852c921217f330b3e81a822647ebadeae7e42cf503ec1992d0bfbc90121c09fb", size = 100450, upload-time = "2026-10-09T20:29:51.486Z" }, + { url = "https://files.pythonhosted.org/packages/b3/6e/fbc4721aa0eaea2dff3274ff44e94f60a89841bbb4cdaecd9faa4eb64aa7/multidict-7.1.0-cp315-cp315-ios_13_0_arm64_iphoneos.whl", hash = "sha256:cbec738d2ad551c6f70955d7eec95e339380ee1564e2afe86bfee05fed52ceec", size = 95440, upload-time = "2026-10-09T20:29:53.929Z" }, + { url = "https://files.pythonhosted.org/packages/76/66/045aee749b599560d5348bb1bee5c9d61d8b12f31d16e0594778ef3472de/multidict-7.1.0-cp315-cp315-ios_13_0_arm64_iphonesimulator.whl", hash = "sha256:a5f721a2437390ab69c10c6df5c142478d399af8dfb02e6d823cf2358e8a4748", size = 97496, upload-time = "2026-10-09T20:29:55.808Z" }, + { url = "https://files.pythonhosted.org/packages/97/79/f2916b81324d629eba363f760fba26cafef5cb437489c24969ada979508d/multidict-7.1.0-cp315-cp315-macosx_10_15_universal2.whl", hash = "sha256:99cf27791129d37e191ff013bfc29bf6631c29edb21680c00978567b91fc5d6b", size = 163241, upload-time = "2026-10-09T20:29:57.813Z" }, + { url = "https://files.pythonhosted.org/packages/ce/f6/2aab2b2d7bf2d69204bde0cdabfefe4df3d1954f3f156bfc53714917e757/multidict-7.1.0-cp315-cp315-macosx_10_15_x86_64.whl", hash = "sha256:2ba6611fc93c4b169d0e0ea376ebf4b8a529933d1f5f2c2ec7d8f8b93ef58ec2", size = 94586, upload-time = "2026-10-09T20:30:00.201Z" }, + { url = "https://files.pythonhosted.org/packages/b6/83/cf690ab80a0db0f50b300a7141f45dbf1bbbb6b32457f74bb55f47d38f5c/multidict-7.1.0-cp315-cp315-macosx_11_0_arm64.whl", hash = "sha256:c45629c0049fbdef932dbe408ac2b271fdc8c7d9962ca31160f4a0fc3455fe4f", size = 97573, upload-time = "2026-10-09T20:30:02.675Z" }, + { url = "https://files.pythonhosted.org/packages/ce/2e/951c1412c9803e8f87c8673305be1e448761c940cd867ccfdd3e6a551dfd/multidict-7.1.0-cp315-cp315-manylinux1_i686.manylinux_2_28_i686.manylinux_2_5_i686.whl", hash = "sha256:cf606cfe3f67984b4064ac605d71e1eba12515fbabf5bd5a34a8952b8800dc66", size = 453476, upload-time = "2026-10-09T20:30:04.622Z" }, + { url = "https://files.pythonhosted.org/packages/a1/55/12f9f95fc65470bf481ad3d1c0e0fc20094720d0af1985119656f2b4be25/multidict-7.1.0-cp315-cp315-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:50fdfcb03be719d9573597b095b1175d2e9d0b30d065791dfd9fca727c499442", size = 473078, upload-time = "2026-10-09T20:30:06.986Z" }, + { url = "https://files.pythonhosted.org/packages/87/31/ebe216194a68934de7053d582cde62c839bef4dbc4ae67e9bbccf80a61d2/multidict-7.1.0-cp315-cp315-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:a8bba9d1f6db4ef2a6ebfc937a65d36e80e3aada00b382eaf56fea8f639322d5", size = 435633, upload-time = "2026-10-09T20:30:09.021Z" }, + { url = "https://files.pythonhosted.org/packages/46/e5/4aea764cd6a1d326d91f2bb92b1c8c39c3f5a8da624e7b20b88179dffb72/multidict-7.1.0-cp315-cp315-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:46d4af0afc6eb9867b3ae50605787c80b868e2f52eac3801246034925fe578b8", size = 488656, upload-time = "2026-10-09T20:30:11.119Z" }, + { url = "https://files.pythonhosted.org/packages/6e/f8/b1e5935233fa4b504b1a58b584fcdf03526635e4b5f268f716be9108a1a4/multidict-7.1.0-cp315-cp315-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:5cc58ebb731200ddb64d55f1b345630fb5f7a8138cdbd242af9dce964a7cb03d", size = 502311, upload-time = "2026-10-09T20:30:13.396Z" }, + { url = "https://files.pythonhosted.org/packages/9a/8e/cde07147b6fc56b9ae0fe01d9c0bebd730b2be2c3052d3a5a117e13f561e/multidict-7.1.0-cp315-cp315-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:4b87ad54e8d4adeb0a1f04889504d6ec7f04fb02609220810f51f1b6c66bc1cc", size = 477470, upload-time = "2026-10-09T20:30:15.894Z" }, + { url = "https://files.pythonhosted.org/packages/68/a1/11ac1880eacddcf698aa227ba9387cda60128e38034eda182cf4585109ee/multidict-7.1.0-cp315-cp315-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:44f7e5dd83a615636b80182bdf446ece57ed61d5d51854acc5d9840631136d4e", size = 430088, upload-time = "2026-10-09T20:30:18.972Z" }, + { url = "https://files.pythonhosted.org/packages/6a/5a/09926de0ec910704507a21c4f1ad76026aab9a5657ced868c57bbbe9324b/multidict-7.1.0-cp315-cp315-musllinux_1_2_aarch64.whl", hash = "sha256:9bc5e7f843d14a167cdc26fe2d22f6f3aa2feb57919cf3ff034262a57d8d95d0", size = 460632, upload-time = "2026-10-09T20:30:21.45Z" }, + { url = "https://files.pythonhosted.org/packages/ed/36/cc51eb3ffb09f475326bbf868c6af2805fbbe9175122ce6d7a65aa06d6c1/multidict-7.1.0-cp315-cp315-musllinux_1_2_armv7l.whl", hash = "sha256:0631eb5f49f67de10bbdc3f64141326dbc62e8d319900966648381ce0845d8ca", size = 434056, upload-time = "2026-10-09T20:30:23.679Z" }, + { url = "https://files.pythonhosted.org/packages/6d/f4/9e0e4dce595573eba1555495ac9ca6b5f7f6e14cf6c3a5cd87ce5bd33d6f/multidict-7.1.0-cp315-cp315-musllinux_1_2_i686.whl", hash = "sha256:d1b1b32f3c32f734dde8f36ac1df8e275e768a7b333241cd637cb2538628a4b4", size = 453014, upload-time = "2026-10-09T20:30:26.192Z" }, + { url = "https://files.pythonhosted.org/packages/96/14/993a7ac9f3592f5628a12f6bc2495f5cce5814b883170e06f487dede6969/multidict-7.1.0-cp315-cp315-musllinux_1_2_ppc64le.whl", hash = "sha256:159976f9c40f96e3fe0952b708846a43a76bacb114e9cc828816f5080bddd5ec", size = 476343, upload-time = "2026-10-09T20:30:28.532Z" }, + { url = "https://files.pythonhosted.org/packages/b0/da/c2147c1e225a676ee0c97f97bb935fb8a70821bc12df240491bf9f140801/multidict-7.1.0-cp315-cp315-musllinux_1_2_riscv64.whl", hash = "sha256:81a0e08c64dfdad27dab687b96f572b23bafa1999a39d1b6f70b3ddbb73e8bd0", size = 426813, upload-time = "2026-10-09T20:30:31.015Z" }, + { url = "https://files.pythonhosted.org/packages/5f/fa/8858b260a6662035670759e7b3a7da9decc227296491749073e76202de93/multidict-7.1.0-cp315-cp315-musllinux_1_2_s390x.whl", hash = "sha256:4e11e7299079718c78f8147e7206c22fe35bab4466d38992420795288a0b8096", size = 483882, upload-time = "2026-10-09T20:30:33.509Z" }, + { url = "https://files.pythonhosted.org/packages/c2/43/d42dc515d56d506f437e8a19c4f604719a306f8d2b60f70a14be34ac9231/multidict-7.1.0-cp315-cp315-musllinux_1_2_x86_64.whl", hash = "sha256:34d2ee98e15d5cfe782a431bc913fce3b58cf3fdb34fcb437aeb275cdf9007ab", size = 469953, upload-time = "2026-10-09T20:30:35.996Z" }, + { url = "https://files.pythonhosted.org/packages/5e/bd/1b6fb52f7e082b4d49b069d362169a2e6dbc43800f152f33c8f0e8933117/multidict-7.1.0-cp315-cp315-win32.whl", hash = "sha256:f376224572d1f5da1c871f969ab04765727f180e70d012d93e07bfc08442c64b", size = 80202, upload-time = "2026-10-09T20:30:38.121Z" }, + { url = "https://files.pythonhosted.org/packages/f2/26/5dec513dec950825529037703da89a597dc0b157e7b1b8d0304dd9e672cc/multidict-7.1.0-cp315-cp315-win_amd64.whl", hash = "sha256:67fcf28db77b385820881521db7435e9f1c607cfaf07db6eb78aa9d1146bde86", size = 92921, upload-time = "2026-10-09T20:30:40.507Z" }, + { url = "https://files.pythonhosted.org/packages/dd/eb/fd62025f8cd3dad6f936df8bd7ff2642e2fe3fe0166ef2fc75699ee57cac/multidict-7.1.0-cp315-cp315-win_arm64.whl", hash = "sha256:c7aafa4dd2f702ee2198005d6cba4309c1e25ed1c201d77beddefa47411bead8", size = 92848, upload-time = "2026-10-09T20:30:43.026Z" }, + { url = "https://files.pythonhosted.org/packages/42/f4/2dcd45731d2f57b87211a1dab1c29a72c6a4a527f370851c3e4cef5c4445/multidict-7.1.0-cp315-cp315t-macosx_10_15_universal2.whl", hash = "sha256:1348ddc076251cd542f4a99ccda4b7c1f8444e8ab489d3541a978ca5901c7c1f", size = 177634, upload-time = "2026-10-09T20:30:45.125Z" }, + { url = "https://files.pythonhosted.org/packages/6d/d6/d57b12a5bb19396a99ae66ec48ff69f764cc2c83e83bd9a003bd5ed5802a/multidict-7.1.0-cp315-cp315t-macosx_10_15_x86_64.whl", hash = "sha256:9267bf8261a779abb2a6eab5f107f5db85b2d1745f2494081c731aaf28738ce3", size = 101954, upload-time = "2026-10-09T20:30:47.416Z" }, + { url = "https://files.pythonhosted.org/packages/46/8b/374e3f6e4581b8f8425712214cad854ff9370019483aaa49e6207c160adf/multidict-7.1.0-cp315-cp315t-macosx_11_0_arm64.whl", hash = "sha256:8a844b8b1685f38a2e8b2f3213b286e2a7abfe67508381780a0d4599ac337c1c", size = 105056, upload-time = "2026-10-09T20:30:49.618Z" }, + { url = "https://files.pythonhosted.org/packages/9e/0a/6c89e2179a84eaa78eec658b9a05f10d3e22654708d7b2e3ebdf0faa0614/multidict-7.1.0-cp315-cp315t-manylinux1_i686.manylinux_2_28_i686.manylinux_2_5_i686.whl", hash = "sha256:18a447d46a3a2f1e61b365cbf5627db7030fdb707dad70c4f2760e5144166ecc", size = 467374, upload-time = "2026-10-09T20:30:51.933Z" }, + { url = "https://files.pythonhosted.org/packages/c5/62/431ed831b5e9b94c75ed0a410786d07176e879603601570eb25594039200/multidict-7.1.0-cp315-cp315t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:88811f890db240a1c82bf0bcd52973763707a552c8113ac3fcebca183afb2fa8", size = 504024, upload-time = "2026-10-09T20:30:54.701Z" }, + { url = "https://files.pythonhosted.org/packages/d4/dc/52e4204538a7824e407e531b742ff6f7a2ff614dd40382d29a62755699cb/multidict-7.1.0-cp315-cp315t-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:a60b720c329c0007feae692b7bf91cf17b3f9bd3727be96cc6f9a3336651041b", size = 460139, upload-time = "2026-10-09T20:30:57.193Z" }, + { url = "https://files.pythonhosted.org/packages/22/4c/0228d61a8fee69a7ac4d8d0426aa1810b9c36b679a8c51844de701230073/multidict-7.1.0-cp315-cp315t-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:b117ed1cd1a23df0902461c38093408b95971833dcee629112acda25b603c8d0", size = 513162, upload-time = "2026-10-09T20:30:59.662Z" }, + { url = "https://files.pythonhosted.org/packages/56/50/a0b28bf4f036897bbd44c8761fbb384c014c34f621687799d07345b62820/multidict-7.1.0-cp315-cp315t-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:bbcae7a54050b7ad7bc7bf425ba63dea7d2cd31a92246ba787a2ce69a9b98dbc", size = 520312, upload-time = "2026-10-09T20:31:02.515Z" }, + { url = "https://files.pythonhosted.org/packages/4f/1d/ba96f77c24174eff9f6521cc7c83958f27598b924a9f7b6aca5d11c73f35/multidict-7.1.0-cp315-cp315t-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:4cba2b0b9235fe10e12301d6b4cfba0f353fa668d635f6e988b03623c2cd42ba", size = 502953, upload-time = "2026-10-09T20:31:05.187Z" }, + { url = "https://files.pythonhosted.org/packages/59/f2/14c3ffb649cf45a629ec38ca757a493f0caf729e3f3580816dc7779e4caa/multidict-7.1.0-cp315-cp315t-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:535173fbcc3933d84f9929d49d7a59a0faec259ee07d07c34c7d2a980b4e3683", size = 451497, upload-time = "2026-10-09T20:31:07.597Z" }, + { url = "https://files.pythonhosted.org/packages/55/df/fa4f8f6ee2314bdd3e4bc830c25f1d8a737188198abeaf105c73454f0b95/multidict-7.1.0-cp315-cp315t-musllinux_1_2_aarch64.whl", hash = "sha256:ea027bdeca1d7e498237634ee4e3a852e2723eef39996dec0ff0f77dff8a2336", size = 486212, upload-time = "2026-10-09T20:31:10.178Z" }, + { url = "https://files.pythonhosted.org/packages/32/5e/3227762b04a8ff1a90359ee2c04af9ed095fe3892e101705fa4233b51514/multidict-7.1.0-cp315-cp315t-musllinux_1_2_armv7l.whl", hash = "sha256:507151e1e3dee95e9e8159e329aed4f75aa5205ecd6505a4f6be546890eafbe1", size = 459864, upload-time = "2026-10-09T20:31:13.044Z" }, + { url = "https://files.pythonhosted.org/packages/5e/04/58524c7e82176438a48704a687fb383cc943dd7075c67b5bea288043b504/multidict-7.1.0-cp315-cp315t-musllinux_1_2_i686.whl", hash = "sha256:9c10791e9f5ef132effc8fdce2009482c1cfb26618c5fc1b7952a47dd5eb632e", size = 465861, upload-time = "2026-10-09T20:31:15.503Z" }, + { url = "https://files.pythonhosted.org/packages/f8/d6/28e549b6ec0c829647de4c75cf32e4c7ea0d0e87b91dfb399292f630c365/multidict-7.1.0-cp315-cp315t-musllinux_1_2_ppc64le.whl", hash = "sha256:f16ac8af2804855d3cae5fc3c5ab609c9fd0fc8ecacd92579c05ed3c173396fd", size = 498865, upload-time = "2026-10-09T20:31:18.548Z" }, + { url = "https://files.pythonhosted.org/packages/eb/ac/3006640586b4d33442c53989b78fc290c8eae5fab5b62a31ac7a4c220e69/multidict-7.1.0-cp315-cp315t-musllinux_1_2_riscv64.whl", hash = "sha256:b78de22bae456a976f33df34d598dfd16edc9a03df8f4cc8b7c17bdba4c97b4a", size = 449885, upload-time = "2026-10-09T20:31:21.03Z" }, + { url = "https://files.pythonhosted.org/packages/80/7e/1ece407cee9f9aff9ace9e44379ed937bccb790936ae448feb79a82c362e/multidict-7.1.0-cp315-cp315t-musllinux_1_2_s390x.whl", hash = "sha256:db77888081431aaa69f3fd3480891746ddce6c2a571f6201869a24e2f06cf423", size = 500237, upload-time = "2026-10-09T20:31:23.611Z" }, + { url = "https://files.pythonhosted.org/packages/9a/4c/c052b700ffcf689454848ee81ba87bedfdc10caff592c0d2a327c43939a5/multidict-7.1.0-cp315-cp315t-musllinux_1_2_x86_64.whl", hash = "sha256:c39dfcaa0bf23443474c0cb58d8d8aea9529c1841d99654cb38e4dada7b1948a", size = 495143, upload-time = "2026-10-09T20:31:26.237Z" }, + { url = "https://files.pythonhosted.org/packages/0a/ef/9ddad94c32fb0bdfc5ad0942d06ae6699bd30d261b0ff59b94810a133238/multidict-7.1.0-cp315-cp315t-win32.whl", hash = "sha256:16b21164797bde6f417066d02775975cc2e15ab8abf80efa55fe85e0b4894020", size = 86526, upload-time = "2026-10-09T20:31:28.734Z" }, + { url = "https://files.pythonhosted.org/packages/b3/ce/2efa1f32a07adfe041d48c6d04c08b6f9db66b8512c765983172399b2855/multidict-7.1.0-cp315-cp315t-win_amd64.whl", hash = "sha256:55392202cb374dd1a1f89a8ce1586644870d9e936752059d053e576acc50bc89", size = 99671, upload-time = "2026-10-09T20:31:31.282Z" }, + { url = "https://files.pythonhosted.org/packages/a9/b3/a44c301fe13716c5f2c08afd89a481018988cde4b337b36e28a2b0fcf3a3/multidict-7.1.0-cp315-cp315t-win_arm64.whl", hash = "sha256:f979a077d1c0a9a36dd4fab0d3a36b8de7b593bf935e13df85a380395b2c11ad", size = 98893, upload-time = "2026-10-09T20:31:33.62Z" }, + { url = "https://files.pythonhosted.org/packages/d0/86/a3de309c5e28ee85b314d0e3ba0e0dea6fd361c313322a05e67be4656e1e/multidict-7.1.0-py3-none-any.whl", hash = "sha256:d9ef29cfd98e17085b4f91bba8fa1570bec6787d5c52ce653ed33a58785585d0", size = 28087, upload-time = "2026-10-09T20:31:35.945Z" }, +] + [[package]] name = "mypy" version = "2.4.0" @@ -1221,12 +1746,16 @@ dependencies = [ ] [package.optional-dependencies] +aiohttp = [ + { name = "httpx-aiohttp" }, +] pty = [ { name = "websockets" }, ] [package.dev-dependencies] dev = [ + { name = "httpx-aiohttp" }, { name = "mypy" }, { name = "pyright" }, { name = "pytest" }, @@ -1246,14 +1775,16 @@ docs = [ requires-dist = [ { name = "anyio", specifier = ">=4.4,<5" }, { name = "httpx", specifier = ">=0.27,<1" }, + { name = "httpx-aiohttp", marker = "extra == 'aiohttp'", specifier = ">=0.1.9,<0.3" }, { name = "pydantic", specifier = ">=2.12,<3" }, { name = "typing-extensions", specifier = ">=4.12" }, { name = "websockets", marker = "extra == 'pty'", specifier = ">=14,<17" }, ] -provides-extras = ["pty"] +provides-extras = ["aiohttp", "pty"] [package.metadata.requires-dev] dev = [ + { name = "httpx-aiohttp", specifier = ">=0.1.9" }, { name = "mypy", specifier = ">=1.18" }, { name = "pyright", specifier = ">=1.1.408" }, { name = "pytest", specifier = ">=8.4" }, @@ -1416,6 +1947,151 @@ wheels = [ { url = "https://files.pythonhosted.org/packages/40/9e/2b38731e0fc536806f16490e1a12d7f0dc2a1235aa8cc07bcc75416a7daa/pluggy-1.7.0-py3-none-any.whl", hash = "sha256:7dd7b0d8832ba3cb632c306926ded123429211b83641b35dc5c41ad2d34f9bec", size = 27082, upload-time = "2026-10-15T09:50:56.808Z" }, ] +[[package]] +name = "propcache" +version = "0.5.4" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/b3/9a/9fbf4e4ec0c2d7f1c32519fff782ef467859b8faa9fbc5331a96f6395d43/propcache-0.5.4.tar.gz", hash = "sha256:ff6b113f50bc066a698db5d944d2c6dc7507168dd3341e255a8892fd0715a558", size = 61545, upload-time = "2026-09-16T00:17:14.386Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/ec/dd/997704118aea215cc5f65c277f5323657b4ba44c1f9a32fb11c8064e4997/propcache-0.5.4-cp310-cp310-macosx_10_9_universal2.whl", hash = "sha256:b77c313314524ca9c38fbd70f73515d04597ac58c40c939bc0e71eeb4abff680", size = 87225, upload-time = "2026-09-16T00:13:43.864Z" }, + { url = "https://files.pythonhosted.org/packages/3e/6d/ceeca1762ed51230c08d557591404f844ecef5e294550136155572f7faae/propcache-0.5.4-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:8f911c395cef73c510bac566da9507bb6a43e7763d0c79138dc60ee53f11207e", size = 50809, upload-time = "2026-09-16T00:13:45.33Z" }, + { url = "https://files.pythonhosted.org/packages/ff/9a/6be90814d8762952594a9e380161802541bff690f3a2e011dcc28ec193ce/propcache-0.5.4-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:d83b12902eb8bce151259c86c03ba746600b2d994543de46e370cecf96c452f2", size = 52552, upload-time = "2026-09-16T00:13:46.48Z" }, + { url = "https://files.pythonhosted.org/packages/bf/d1/7fd3ffb5ca0e669a8fbf55d9fbb17c50ff5f44becfefcab27a9b9b67908f/propcache-0.5.4-cp310-cp310-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:c9281e922c072158c91974d4589f1dbe0fee6d467f284c28e463f9f5a4d933f4", size = 226804, upload-time = "2026-09-16T00:13:47.739Z" }, + { url = "https://files.pythonhosted.org/packages/74/87/a3e199c45b26587f073db655d19c30d2144b0f883827ba6ab77acf5c7d45/propcache-0.5.4-cp310-cp310-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:9f3551b8a35c1df3e7ea4d2d86edee15f0dde1bddd434a71744048683544d0ef", size = 234452, upload-time = "2026-09-16T00:13:48.98Z" }, + { url = "https://files.pythonhosted.org/packages/12/7c/08c15c7df256f94a6b4563f74165c3242fb554cdd1909b661d093c31b976/propcache-0.5.4-cp310-cp310-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:ec6a85f424afa8d23e0d9a094e5dbb6eda01da91c92b9183cd433768247ffc97", size = 240399, upload-time = "2026-09-16T00:13:50.416Z" }, + { url = "https://files.pythonhosted.org/packages/f0/51/5adee15e12a7e314cece4543fbf295b0fe1b504dc78b32dff4c8eb1e29b0/propcache-0.5.4-cp310-cp310-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:f574e460d1c8a08384a016fdb09ccf3543433263ed6b2f97104f979e64ea57c2", size = 224251, upload-time = "2026-09-16T00:13:51.874Z" }, + { url = "https://files.pythonhosted.org/packages/9d/53/54bd510bb5d473edf66914602885226187218b4e3a5017e9dd80bceea41f/propcache-0.5.4-cp310-cp310-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:d8e017eeb7482bed34cdb0d61cf2bcfc88d104bbab296a17cd16a6af8aabc70e", size = 202721, upload-time = "2026-09-16T00:13:53.524Z" }, + { url = "https://files.pythonhosted.org/packages/6f/b4/a468700d0526dfb2ca6af5d790125de5894acc7d8ecd99243ecedfa4c4cc/propcache-0.5.4-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:f273dcf7149a50527c4fd1f55cfe9eac0f60753f5af544b4c9352578e20c0874", size = 219148, upload-time = "2026-09-16T00:13:55.068Z" }, + { url = "https://files.pythonhosted.org/packages/6b/d4/bf563e19ac9a5cc47113431337fdf2ee3573859f3f3e0a58e59833e9b75d/propcache-0.5.4-cp310-cp310-musllinux_1_2_armv7l.whl", hash = "sha256:fc2461ecc45f17893f8207e73b46ea8ba93e33630e51cf4af3fbc21d47462b1a", size = 211011, upload-time = "2026-09-16T00:13:56.588Z" }, + { url = "https://files.pythonhosted.org/packages/4b/3d/0189b6537f4a8cd795e685a130a6f47aeda78a5b7b062574705cffc685ca/propcache-0.5.4-cp310-cp310-musllinux_1_2_ppc64le.whl", hash = "sha256:279655a16973f1ee2bd2fe79973137681642fd9ae0d89215bba263726eb0dc3a", size = 228148, upload-time = "2026-09-16T00:13:57.913Z" }, + { url = "https://files.pythonhosted.org/packages/ce/b7/59c16e245a549df202b4ebe2de91fa58a67dc4373df9840e372a64224dee/propcache-0.5.4-cp310-cp310-musllinux_1_2_riscv64.whl", hash = "sha256:e9f165403b81fea7e89c932d89046a1e3d9a3a60e8d7ef2f249dccdcb0982bf5", size = 201432, upload-time = "2026-09-16T00:13:59.453Z" }, + { url = "https://files.pythonhosted.org/packages/41/0b/7b19eb20bb0b1f9476d08f6e387ae094dc6870fc06d459ea1f35f28b25d3/propcache-0.5.4-cp310-cp310-musllinux_1_2_s390x.whl", hash = "sha256:1783582065a1f07f9d9ee1e992e13f15d7dc8fb1eb3a7476d43eb3f2e69d26bb", size = 228923, upload-time = "2026-09-16T00:14:00.731Z" }, + { url = "https://files.pythonhosted.org/packages/3a/f9/b1a0bd47218216b935d019912d6fec1676ae7c07f15fa82bfb54b8d58976/propcache-0.5.4-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:3d605bb239b796e82a81c6709548b2bd460ab73b4590cb0c83de8a2dd9694d0f", size = 218327, upload-time = "2026-09-16T00:14:02.091Z" }, + { url = "https://files.pythonhosted.org/packages/55/c0/51e5d1ad504e9529831606534c48e272db751072eee9ff07e4abe37e50bd/propcache-0.5.4-cp310-cp310-win32.whl", hash = "sha256:141fdbd73748db0cf7636035030aaac383d2efde8f34e7bc24594cc776d225b8", size = 43096, upload-time = "2026-09-16T00:14:03.427Z" }, + { url = "https://files.pythonhosted.org/packages/80/57/0a0b4b1122f4ed5bcd1c626d910003cdf5282c2a12f8a1cfa17970b3ded2/propcache-0.5.4-cp310-cp310-win_amd64.whl", hash = "sha256:146f48a9e4812611a7581003b1a39de56c34967046310c4171a68ef908c9a745", size = 46589, upload-time = "2026-09-16T00:14:04.581Z" }, + { url = "https://files.pythonhosted.org/packages/66/87/e71b24adc8ece61782ba3d6f3879e6a07fdb85bce21a9c529524184e3ec6/propcache-0.5.4-cp310-cp310-win_arm64.whl", hash = "sha256:6c7599df2b57ebeea8de011b5f2f7b85de95e76037d43d34b95e328430275487", size = 43982, upload-time = "2026-09-16T00:14:05.728Z" }, + { url = "https://files.pythonhosted.org/packages/1e/40/14b21e505b7921617466576423f188a5c9caddfdaa1cf4b2b8a83d8fe216/propcache-0.5.4-cp311-cp311-macosx_10_9_universal2.whl", hash = "sha256:897d1ddf6716e8f47200f7aad9a0efa6cc7586df66c6defa572f9eab379c078e", size = 86393, upload-time = "2026-09-16T00:14:06.9Z" }, + { url = "https://files.pythonhosted.org/packages/e7/4b/5a52e1a7b43563f7d408814194bb23cc8bf214eb6b86639b667a33a8d0d0/propcache-0.5.4-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:9cbfff4423eef4cc6cafc021469641a2b835f610b2647a6c5281903e21b8670d", size = 50431, upload-time = "2026-09-16T00:14:08.025Z" }, + { url = "https://files.pythonhosted.org/packages/05/cf/b5248180bf056cc76acc60c9c6e8c0ebbfdbd1c6cffd31fd14996927b7c8/propcache-0.5.4-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:3fc24f209c1b7f7f688b66b98293954f5504279760999b58920ee12dd8471c1d", size = 52116, upload-time = "2026-09-16T00:14:09.114Z" }, + { url = "https://files.pythonhosted.org/packages/86/a8/7c6cd6bfead1a11f2e411e688640e6d26574cb0bde7dcaa7423b0b65ed7a/propcache-0.5.4-cp311-cp311-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:62530ca89187827e4a4fe733f971abe81a7542eeea48ff61995f19b64d7199c8", size = 238729, upload-time = "2026-09-16T00:14:10.357Z" }, + { url = "https://files.pythonhosted.org/packages/5c/b4/442715b2e980df51be52d203549279e027728f24c80b00b5e525e31cd5ea/propcache-0.5.4-cp311-cp311-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:56fc3f7599528db40b1efa0889a620116e2704144495273d66066e8164e45838", size = 246121, upload-time = "2026-09-16T00:14:11.735Z" }, + { url = "https://files.pythonhosted.org/packages/bc/5d/df0684fc2b1732a01a7bec26d7897369022712422d25b09c37ce7dbc88a2/propcache-0.5.4-cp311-cp311-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:4f2d880ff60f45898f4acfa152aac8d04e3ee627d90ff4003491bf92239d5757", size = 251735, upload-time = "2026-09-16T00:14:13.053Z" }, + { url = "https://files.pythonhosted.org/packages/c7/06/519a5ebb48b6f94beb48396e55c905f12246a25c3a3608a7ec7bceabf50e/propcache-0.5.4-cp311-cp311-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:6e9368e87a3efc285e559131092c5db643eb8e56de4ee42064d5baec22ef2bb5", size = 235381, upload-time = "2026-09-16T00:14:14.398Z" }, + { url = "https://files.pythonhosted.org/packages/3c/07/1e0a9bb310830f2245edbd5cd3c6d24a783c053c4efd8e08e386e513c940/propcache-0.5.4-cp311-cp311-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:004e685b315646c410771836e72a44f143bbe624f29653a42687815069a303d5", size = 208973, upload-time = "2026-09-16T00:14:15.715Z" }, + { url = "https://files.pythonhosted.org/packages/62/5c/9324fab27d6088eecc47fe4332bf7aaf8c1ded93c36f558391e8a06d41a7/propcache-0.5.4-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:594eb4c6ec35e7179b058481f4e9f02521b56de16fa577c4b85c76fb1bf8a9f8", size = 233897, upload-time = "2026-09-16T00:14:17.25Z" }, + { url = "https://files.pythonhosted.org/packages/9c/a3/570d92fc952eae93b676f3a1568f4b89264102abd3c982ab6a9ebec58dcf/propcache-0.5.4-cp311-cp311-musllinux_1_2_armv7l.whl", hash = "sha256:2dba2f02d2d5c09ef8a0e6c1a42aeaa451f4be9898cb00b04fe98717da2eb23b", size = 223512, upload-time = "2026-09-16T00:14:18.87Z" }, + { url = "https://files.pythonhosted.org/packages/65/47/26810d889d89bba31db397e6a88f8984af775f5ed6bad0a29dce84324cff/propcache-0.5.4-cp311-cp311-musllinux_1_2_ppc64le.whl", hash = "sha256:c3ef2818d63bc86071e9d2989ae75a1bc32b8f7059cfd9f5abbbee70c32e2ed6", size = 239043, upload-time = "2026-09-16T00:14:20.366Z" }, + { url = "https://files.pythonhosted.org/packages/89/2d/f9c47691aa024c8299a3afacd78d22a01ab57eb627b481b6089708e71017/propcache-0.5.4-cp311-cp311-musllinux_1_2_riscv64.whl", hash = "sha256:dd2ac8f5b643454c2cc6b6118b13da16e88f4a6434fc3ba61aca384029f04f36", size = 208218, upload-time = "2026-09-16T00:14:21.801Z" }, + { url = "https://files.pythonhosted.org/packages/74/6b/d510c0c378cabbf9d0ac7b663af6d00f2e9074073d93b20c85f24aa5c071/propcache-0.5.4-cp311-cp311-musllinux_1_2_s390x.whl", hash = "sha256:4054acf80d40456a0537f2913b349718649d8d6458a14ab7f48d0ce28c30869d", size = 240301, upload-time = "2026-09-16T00:14:23.121Z" }, + { url = "https://files.pythonhosted.org/packages/3d/80/c80f6adaaa1e51f0db2dce8c9b3714d94ec45e358a21f9a1910b10b40a80/propcache-0.5.4-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:40e94adb1e7d39ff28a8bd8d8b8fbd1df6b9f40976dbe379134f1ce058e532dd", size = 230785, upload-time = "2026-09-16T00:14:24.458Z" }, + { url = "https://files.pythonhosted.org/packages/d9/e2/c32a7df3f39caa7f11b2eb37ea5b6960a6946f2bc7c4b8ff97bbdf6d6b6e/propcache-0.5.4-cp311-cp311-win32.whl", hash = "sha256:9f86f7259efe2c951f43e57d471c9b41daa5bfc7db9f67189059cf1ae6d77fd9", size = 42747, upload-time = "2026-09-16T00:14:25.715Z" }, + { url = "https://files.pythonhosted.org/packages/0a/8a/3db6a3543d8101263b4c52978b6276a04ead2caff2c5ab880d934f47bd89/propcache-0.5.4-cp311-cp311-win_amd64.whl", hash = "sha256:e904d4d01f36bd6e197590be1533c44e06058771e0746dd073a8ebb3ef880858", size = 46268, upload-time = "2026-09-16T00:14:26.996Z" }, + { url = "https://files.pythonhosted.org/packages/41/07/5222e2665bbf6e45847492ecbf3b9f3e4975a0ae300e5fd465df7d48ce55/propcache-0.5.4-cp311-cp311-win_arm64.whl", hash = "sha256:d42a9a856a4a6e2f6c10f1318c07e7daa498d6593abe745c71dae4521a26ca39", size = 43547, upload-time = "2026-09-16T00:14:28.143Z" }, + { url = "https://files.pythonhosted.org/packages/71/cd/348d58f142aebc4873345c6b31087629182ca6e0f2b3caeaa528cf882eba/propcache-0.5.4-cp312-cp312-macosx_10_13_universal2.whl", hash = "sha256:b28f41fa3b8c6900457f858ec5b03998f3a6d535fbc1bb2edec5961ea05ec429", size = 87285, upload-time = "2026-09-16T00:14:29.362Z" }, + { url = "https://files.pythonhosted.org/packages/df/f4/f3ffaee281b276da854ac1d7a6a506d26cbc62ea2e623756f1d0a4a1ba1a/propcache-0.5.4-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:dcbf346a318a5e30063f547630b02bb787ce2f45b6368d5da143660b6a3835d8", size = 50984, upload-time = "2026-09-16T00:14:30.473Z" }, + { url = "https://files.pythonhosted.org/packages/25/88/1d7df7201750b37765ef2b23bc1c526c028dadde80afa0f57a118fc01182/propcache-0.5.4-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:87a3caecf8095e48dc72f84bfa42e23a848cf410cc9cc13031fba4869b706a21", size = 52460, upload-time = "2026-09-16T00:14:31.692Z" }, + { url = "https://files.pythonhosted.org/packages/83/4f/48865bd02a16ee5236bc46166b2946f37b93e07b0eae355dac0be0b216ca/propcache-0.5.4-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:60a64cbccaa11b7760ce705a14ada17ba459e7ca9f23ba587eb013821032d7ef", size = 251768, upload-time = "2026-09-16T00:14:32.908Z" }, + { url = "https://files.pythonhosted.org/packages/b0/19/3742a5eed62317b03b4002ee865dc9fd720308bdd0da1f29a5786c630311/propcache-0.5.4-cp312-cp312-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:a74bfa37147cc08fb29df10bd9c16f40fa7f860cd3a6d2fff853323a94f6e17f", size = 257723, upload-time = "2026-09-16T00:14:34.267Z" }, + { url = "https://files.pythonhosted.org/packages/cb/d5/ee6350fb0be9122bb6c67082a876d34b90d980d100c106af4b81023e04f4/propcache-0.5.4-cp312-cp312-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:a4d7a54719b67338a305dca2ce6aafe366817df94ddfd4b5514374356f5ca546", size = 265597, upload-time = "2026-09-16T00:14:35.56Z" }, + { url = "https://files.pythonhosted.org/packages/85/9f/83a07b6ec0e043c050cfdd35fb0cf1b7897b91d554d6eea293740309afe7/propcache-0.5.4-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:2814ecd8e818f487bee4b0f921bc4d1c176cc5fc71ac0f072d0fa67eda4ac14b", size = 250424, upload-time = "2026-09-16T00:14:36.894Z" }, + { url = "https://files.pythonhosted.org/packages/33/2c/a763a8251f50fba042af0fb1f02bfec4b31381e40aff760db2be7b2e1f84/propcache-0.5.4-cp312-cp312-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:6af4693716bfb03f1752ef1b30faa593db2c01d5272e9b8564a1549452a979ab", size = 216748, upload-time = "2026-09-16T00:14:38.369Z" }, + { url = "https://files.pythonhosted.org/packages/6a/e2/4d11bea8fd6a777149c6c20645f873952eab5de3a2497aa11648ec9ab6ab/propcache-0.5.4-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:4fbc1a15dc8cd1689508758d626b372b1f09d28d9577667feaf9e6bfcd8efcbc", size = 246533, upload-time = "2026-09-16T00:14:39.82Z" }, + { url = "https://files.pythonhosted.org/packages/9f/36/6683597de4907e70c717e3588c541202c66086a72ff3db58be49de66e72c/propcache-0.5.4-cp312-cp312-musllinux_1_2_armv7l.whl", hash = "sha256:cdee8205a44d0be91bbac4c41b95d86641b72dfc7aef1279400e4fda3f26a937", size = 238173, upload-time = "2026-09-16T00:14:41.259Z" }, + { url = "https://files.pythonhosted.org/packages/85/84/cb08d79f1762daafeb2b030c470cd0c725c97b8ad67412457c6f35c53e9d/propcache-0.5.4-cp312-cp312-musllinux_1_2_ppc64le.whl", hash = "sha256:9a2a8a50a93dee0268a860a07fa3b4bd968f8ce4dbd794957da772f395368526", size = 251128, upload-time = "2026-09-16T00:14:42.652Z" }, + { url = "https://files.pythonhosted.org/packages/c2/0d/41b848036db6621370c1f2e5471a7da8149c730f8552a5257567721f4576/propcache-0.5.4-cp312-cp312-musllinux_1_2_riscv64.whl", hash = "sha256:7ffafcbfc7b549ab940047e505c831eabac5e67de53e1bc174adbc5285c55944", size = 214821, upload-time = "2026-09-16T00:14:44.112Z" }, + { url = "https://files.pythonhosted.org/packages/f1/b7/adfae4bf9c63bccf12e2d9690a175c6579047a6eec3b5a6a5f51428c15e2/propcache-0.5.4-cp312-cp312-musllinux_1_2_s390x.whl", hash = "sha256:d1f5a500bfcbb2c0ab85e98a0dcd70f5899d34efe365a0187700369a79603031", size = 254793, upload-time = "2026-09-16T00:14:45.429Z" }, + { url = "https://files.pythonhosted.org/packages/51/6f/eeca9647245d5f92e87d53e5f14335bb42fce1a7e6842c8045b364eded8b/propcache-0.5.4-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:8a235f73d6e020855dc29dff012d920c02ee0feab8d73a24185a7569f4be1161", size = 247134, upload-time = "2026-09-16T00:14:46.976Z" }, + { url = "https://files.pythonhosted.org/packages/5d/a9/424e38838793d37160b4379c702f61c74c598fc6cd17204adbe3c554f7a8/propcache-0.5.4-cp312-cp312-win32.whl", hash = "sha256:b3083bfe87f95c756e610bd8025f26cbd1cd4aaa03a422f2d65efb7a97cd53d8", size = 43073, upload-time = "2026-09-16T00:14:48.338Z" }, + { url = "https://files.pythonhosted.org/packages/58/7b/6e8ef26f6d510a7916064fec68d55fcbfbdf7eb01e377480d66a122152d8/propcache-0.5.4-cp312-cp312-win_amd64.whl", hash = "sha256:98914de2c4d7f0f9f4a8c6ea4bf05841f4175796941e3ef7d47eb718f22311fb", size = 46190, upload-time = "2026-09-16T00:14:49.99Z" }, + { url = "https://files.pythonhosted.org/packages/08/b9/72028c5b56ced97f456de6aefa79435ca64d7f77af78ea8cf3c76fc5195f/propcache-0.5.4-cp312-cp312-win_arm64.whl", hash = "sha256:8876b39961e33d912afe3c1bee18ee564fdad0206f873cc15d522756b7f50737", size = 43075, upload-time = "2026-09-16T00:14:51.155Z" }, + { url = "https://files.pythonhosted.org/packages/78/4c/3b1365d58a667689e067e13d055fcd92bdf8d9a2fca3d9201b47ed5b3631/propcache-0.5.4-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:36c0d9db44b523ef93d03341b1c42d69ff01d673c053d1b1c6c3a363bcaa39ba", size = 85290, upload-time = "2026-09-16T00:14:52.342Z" }, + { url = "https://files.pythonhosted.org/packages/8f/61/5f9c29c3aa67c30238c4eadf95149b1d983a48f69b86b0cff927a7d6df13/propcache-0.5.4-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:e1d52a05dc417279f7e5c7618c5dfbbc29923aaf9bc0a5c1802ddcebf54c61a0", size = 50027, upload-time = "2026-09-16T00:14:53.67Z" }, + { url = "https://files.pythonhosted.org/packages/25/7d/c1ab1ef09e9d4d835be5d58c0a32a1e1de8397abaa4e502a9d4141328cad/propcache-0.5.4-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:44149f46500a0a41b95b4d99c2e586a77319539730607b9892974a092788b111", size = 51425, upload-time = "2026-09-16T00:14:54.826Z" }, + { url = "https://files.pythonhosted.org/packages/73/36/0093091ebb270fcd1bc1f6e095f93b2e0ed7f1011c28837dc2dbe5f96b99/propcache-0.5.4-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:dbab5f5ff6897c81f355d079010cdae85b02e5a0b518b5251523b8ad8ae9ac3c", size = 233595, upload-time = "2026-09-16T00:14:56.09Z" }, + { url = "https://files.pythonhosted.org/packages/ae/8f/0de9d4c8e05ce0be71b436919a216bd7fc5cc6e2691c0602295efb22b9ed/propcache-0.5.4-cp313-cp313-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:c3e98c55bde2bcf7db3c70d1aed7ae9aa8aebbf19a250c66645cde44cdb8b867", size = 240318, upload-time = "2026-09-16T00:14:57.674Z" }, + { url = "https://files.pythonhosted.org/packages/7d/71/2b35e91455209b85ee98f7859583e0814fab57d3af0f2381aaee34c37304/propcache-0.5.4-cp313-cp313-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:db3ae52ccc150dbc84704e9d642743897f3e1c54742ff34cacb661e52e3818a9", size = 246649, upload-time = "2026-09-16T00:14:59.352Z" }, + { url = "https://files.pythonhosted.org/packages/ed/74/08e6c1faf26ee2732023a3828787ba535557122774f4a386b1f715cbd8e0/propcache-0.5.4-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:f85915e00dcb1cd9f2f890ead064ed40a27df06f0db65be427b29482ae357572", size = 234316, upload-time = "2026-09-16T00:15:00.696Z" }, + { url = "https://files.pythonhosted.org/packages/5c/9a/08385733c9321c9bb78039d3ff31045e4fca962d9665023c4eb70f998819/propcache-0.5.4-cp313-cp313-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:c2ba30a89035b57b73e00475de948521602f543d79ce01db10b04b36c4c76fc8", size = 204666, upload-time = "2026-09-16T00:15:02.019Z" }, + { url = "https://files.pythonhosted.org/packages/1d/f4/e87bc7629af9a14a752b218764a78742d73c2c563ac58315da6841f0cbe4/propcache-0.5.4-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:ae58f361bd5dae942717c65d3413b478c70aea9c462599e7b9adad3731db3894", size = 225900, upload-time = "2026-09-16T00:15:03.394Z" }, + { url = "https://files.pythonhosted.org/packages/d9/6d/11014938d3fe9bea2ea2dcf930f26ed565bfb2f5be3c756362ea48c92636/propcache-0.5.4-cp313-cp313-musllinux_1_2_armv7l.whl", hash = "sha256:96f7c5c15656040ddcbc51e56dc59b58aa25999d743c126abd425b9766ab43e9", size = 219988, upload-time = "2026-09-16T00:15:04.811Z" }, + { url = "https://files.pythonhosted.org/packages/dc/72/fbf17c589f92c0b3bbf6709a425661f8ef2ed0d46b38985a7d7b5a0f6b91/propcache-0.5.4-cp313-cp313-musllinux_1_2_ppc64le.whl", hash = "sha256:7cc528e760a8af06f2b13e9b9f362cd90c7c718ea61228a96dbd31ba16ed7f47", size = 233611, upload-time = "2026-09-16T00:15:06.498Z" }, + { url = "https://files.pythonhosted.org/packages/55/7e/dbd637572a279692e5518d117274a9331bf5faac59f191d30e82521a3ec7/propcache-0.5.4-cp313-cp313-musllinux_1_2_riscv64.whl", hash = "sha256:425f8cc86ab5018b4b8d4a23bc8e74d964bd3d757c3702e301aa79be76c53f6c", size = 204333, upload-time = "2026-09-16T00:15:07.961Z" }, + { url = "https://files.pythonhosted.org/packages/ba/5a/f99c92068f1e0f5c886899ce0e4a619db376ca98c5279d93f95bd86906af/propcache-0.5.4-cp313-cp313-musllinux_1_2_s390x.whl", hash = "sha256:a5793c7698a53f56f4a1889a4737c7eeb1b7ad0842fa6b1abca22913ff79c8c1", size = 235177, upload-time = "2026-09-16T00:15:09.334Z" }, + { url = "https://files.pythonhosted.org/packages/ee/28/95456fabd2daf6be89049a13fbf03341756014d2959c83d12957d4c49694/propcache-0.5.4-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:c02c0e570c5c7e077b0181a9f3cdb7d4c3617d1cda6b5c95bd5d34022923d82c", size = 228982, upload-time = "2026-09-16T00:15:10.729Z" }, + { url = "https://files.pythonhosted.org/packages/b1/bb/df90f62c9cf7c93ea235f6f9405143bba802914607317266dd81fc8d737e/propcache-0.5.4-cp313-cp313-win32.whl", hash = "sha256:3e413d7a4a9b4866b7a761d6060d434b64d23cd35122eda3b026a0bbe8196b25", size = 42611, upload-time = "2026-09-16T00:15:12.111Z" }, + { url = "https://files.pythonhosted.org/packages/01/bc/e0a7b84af04ec02d73a48aa71f091e1e4a2107e3074b7ce12195b66901f4/propcache-0.5.4-cp313-cp313-win_amd64.whl", hash = "sha256:0c889f6fa84957bc7e8b4eab71fd16a0455068d5045e3aa40c733071d2b2fd77", size = 45342, upload-time = "2026-09-16T00:15:13.519Z" }, + { url = "https://files.pythonhosted.org/packages/9a/70/50b031cafe72a5c1878b903ee87303f71313345566bf3d6ec202e5ddc9ec/propcache-0.5.4-cp313-cp313-win_arm64.whl", hash = "sha256:69fc35c0779522da366c563e5faf203ffc1f8ff0021d5b1337fa4efa5be73177", size = 42408, upload-time = "2026-09-16T00:15:14.788Z" }, + { url = "https://files.pythonhosted.org/packages/33/c9/07e227b930c8ae513b8ef1aae3793499be097bffcdf7aee4fb8b33db4cd1/propcache-0.5.4-cp314-cp314-macosx_10_15_universal2.whl", hash = "sha256:e6720ba44ad7e72174314d0e1fb0172494cff5c73a3a8a2159c3d2402ff15565", size = 85933, upload-time = "2026-09-16T00:15:16.073Z" }, + { url = "https://files.pythonhosted.org/packages/e4/e1/6710bb44510c4e4a8e0f004bbaf3cecfd048141309c77bae56d4e5a6ebc1/propcache-0.5.4-cp314-cp314-macosx_10_15_x86_64.whl", hash = "sha256:4cfe0a92ae30151869e67a4b5f5e105e4e03ad30b3f38e5211b5bf77d0881993", size = 50179, upload-time = "2026-09-16T00:15:17.377Z" }, + { url = "https://files.pythonhosted.org/packages/e2/22/b533b493d7025456f44518b33e53e000021a20fe7c27b88cf3d341df7186/propcache-0.5.4-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:1d759d05634f1b038fb625a66662a8c85e5a8fec912da381b5149ddac107482b", size = 51942, upload-time = "2026-09-16T00:15:18.589Z" }, + { url = "https://files.pythonhosted.org/packages/f1/74/70ac8430e28f21e442c7bcb964eb46c4363f6881ade4aa0e978bfd8d503a/propcache-0.5.4-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:251c63dd46a0659bb875cb254dc4c1e79ee91a847c737cd62373295afc2235dc", size = 232647, upload-time = "2026-09-16T00:15:19.905Z" }, + { url = "https://files.pythonhosted.org/packages/72/95/f222f13b6fe623310be0eb61a673bf26df439ce27e563ca8e422d0818777/propcache-0.5.4-cp314-cp314-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:7a8d5ff04eb1f85698a78d20c62a14676e7b960dcafde09a388d60ad377d355d", size = 241541, upload-time = "2026-09-16T00:15:21.3Z" }, + { url = "https://files.pythonhosted.org/packages/a2/3e/763e370340db16115c5e63ad46e21ef0770a7f06928b3d3b62d8f8edfca4/propcache-0.5.4-cp314-cp314-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:7b9100a93b372418d8688f3f2a3e5b45c64d70ca4d6176e121aca1e3bfc1e32f", size = 245332, upload-time = "2026-09-16T00:15:22.802Z" }, + { url = "https://files.pythonhosted.org/packages/96/d3/e97cd6f5de2176bd90ed4076c7a9b5e09d0f0b9687d00a576507988bb62c/propcache-0.5.4-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:cc07876cfb079b6f6f36d21ce75784ad6c2c6b563eeac0ed26c2fa2669b85df9", size = 232757, upload-time = "2026-09-16T00:15:24.374Z" }, + { url = "https://files.pythonhosted.org/packages/f9/4c/6766e5f60bcda26d244333aa71d0a702c1c9b21b251d543c7af5953d1eee/propcache-0.5.4-cp314-cp314-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:0951315a6b3142ee2167404d707743f0157c110091342b1aa0accac5cf0e4acf", size = 204389, upload-time = "2026-09-16T00:15:25.667Z" }, + { url = "https://files.pythonhosted.org/packages/b8/5e/ec4bb09a70b26ea99d76a8292c3383b960b296de2b347ac9986678f1761c/propcache-0.5.4-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:bee7d3aed13d56f54e681df38c3a23031bc9e3863f687d9d598825c9146acd7d", size = 228217, upload-time = "2026-09-16T00:15:27.11Z" }, + { url = "https://files.pythonhosted.org/packages/e1/7d/b53922ba7d9e5bf797324e63aa05906ec240871899f779628df068743e2d/propcache-0.5.4-cp314-cp314-musllinux_1_2_armv7l.whl", hash = "sha256:4e985382be6d15da8d0c2710a6fa7b9070fc9ecdeefb7f580e88373984ec8be3", size = 216947, upload-time = "2026-09-16T00:15:28.532Z" }, + { url = "https://files.pythonhosted.org/packages/ff/39/b62eee45e5ea4de094a258cbb3b01c1e856ca51ddfd95b43135c5effd1eb/propcache-0.5.4-cp314-cp314-musllinux_1_2_ppc64le.whl", hash = "sha256:9e9ab13760aa8b6d0881ae7cb04fd891d8d490cd2554ea8e79bb278399169bcc", size = 233457, upload-time = "2026-09-16T00:15:29.977Z" }, + { url = "https://files.pythonhosted.org/packages/cc/a9/feec61ed296d993db9dd097e0f6723e3f576a647722367547495e4c5b05c/propcache-0.5.4-cp314-cp314-musllinux_1_2_riscv64.whl", hash = "sha256:1b2f3bec4261a94019575481c726c29850f72e27907773c75b1de421e20e9f9d", size = 204131, upload-time = "2026-09-16T00:15:31.74Z" }, + { url = "https://files.pythonhosted.org/packages/92/4d/411ef380cddad28dc001f1c6d75ec72c76cd3817030f68ec1ccfba0ec6c1/propcache-0.5.4-cp314-cp314-musllinux_1_2_s390x.whl", hash = "sha256:720cf832eb2d0b0dfee129cb3335a26f6ce3cc45ee1187e8f0731758caa16792", size = 234820, upload-time = "2026-09-16T00:15:33.087Z" }, + { url = "https://files.pythonhosted.org/packages/15/37/c988229753629ef1cfd5198337a83e624780ea2b3787efe9e747c05aad2d/propcache-0.5.4-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:9fb0a5be8d9aa213150e8d8148a42aca4984b285bcad1e69587dc4298edd929b", size = 228350, upload-time = "2026-09-16T00:15:34.533Z" }, + { url = "https://files.pythonhosted.org/packages/12/49/5ef1c5cf98591da3c5b952b39e6a298084cc1ce353bc70f85e82397a5036/propcache-0.5.4-cp314-cp314-win32.whl", hash = "sha256:30cc1cebaf9aef49db06357a50398323ae04d70460c0491837d026ab7d6452ea", size = 43578, upload-time = "2026-09-16T00:15:35.957Z" }, + { url = "https://files.pythonhosted.org/packages/1e/9e/a0ac821a2229186af5e2e3c3635a78abb23cfddca57f38513ab5d70420f3/propcache-0.5.4-cp314-cp314-win_amd64.whl", hash = "sha256:0a095db8e15a6020db149ecbed6461939fe74f6acaa3ae8b702a1fe8c38cd983", size = 46304, upload-time = "2026-09-16T00:15:37.655Z" }, + { url = "https://files.pythonhosted.org/packages/a1/19/c8d0d36a9d16cba5dcee67d389c9333b988c8986a653a61c00a451817a46/propcache-0.5.4-cp314-cp314-win_arm64.whl", hash = "sha256:45488d1a5f9ab5bd90aaa1ca20f50fe1922b8ffad71a2009d2adf41355897aac", size = 43440, upload-time = "2026-09-16T00:15:39.091Z" }, + { url = "https://files.pythonhosted.org/packages/2c/e9/42f1da77cacfc184e6ec929557ef653b7961bbf6f1da460b9221273948b3/propcache-0.5.4-cp314-cp314t-macosx_10_15_universal2.whl", hash = "sha256:53eaa697c4d0422ff4cb714d00231b43352064d97b944033b30c1d57cc506ec0", size = 90672, upload-time = "2026-09-16T00:15:40.306Z" }, + { url = "https://files.pythonhosted.org/packages/cf/2f/4b79940908c6ab8c795097c102999d7bc1f7e0b8604dfd1c232f9d99d67a/propcache-0.5.4-cp314-cp314t-macosx_10_15_x86_64.whl", hash = "sha256:886b59c4d28ca97dd23b025fdfc50a0356be934efbbbca89ad26230067f86fe5", size = 52586, upload-time = "2026-09-16T00:15:41.575Z" }, + { url = "https://files.pythonhosted.org/packages/eb/07/02196ae6320c110235bb343f90dbd34be41f8b8964a3ee30db84ec12579e/propcache-0.5.4-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:3fa15757fea1dfcd5b7745cad9f4638929605531bd4018ab2adff7955f1a403d", size = 54335, upload-time = "2026-09-16T00:15:43.027Z" }, + { url = "https://files.pythonhosted.org/packages/6f/44/f48b9a131985659924df5fa5093f68fe72c7ee375329802989ba3126efc6/propcache-0.5.4-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:6f0093ac3e9daada202c2082439d414a625c57184727a46e112a3fb2a81cb788", size = 297567, upload-time = "2026-09-16T00:15:44.373Z" }, + { url = "https://files.pythonhosted.org/packages/04/a1/418d956d2735139f77fc35262179f1f52c23aa666de5a8ab3819c1ae7854/propcache-0.5.4-cp314-cp314t-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:3cd3a7edb6b95b9b33998135ebfa18d709da82290fb8f27c858970b5a12c8b56", size = 297477, upload-time = "2026-09-16T00:15:46.048Z" }, + { url = "https://files.pythonhosted.org/packages/69/fd/ff811fdb6d3d3e67fd9bbfb75881675d34a42d0ef29a45d33e3e233dde07/propcache-0.5.4-cp314-cp314t-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:c174bfd1c48a1b51a3078e95586dde718374bac79719ab3541ec9e74aec40574", size = 302669, upload-time = "2026-09-16T00:15:47.458Z" }, + { url = "https://files.pythonhosted.org/packages/fc/57/527910c455b5ec62f6871bef45d4f79fea16cb8c966ba0d4a07f0339ddc4/propcache-0.5.4-cp314-cp314t-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:a219f0ac59817a9114dd2aa57c13180f993e819ba658c7ddab4b66ed1ee0d370", size = 287908, upload-time = "2026-09-16T00:15:48.99Z" }, + { url = "https://files.pythonhosted.org/packages/1d/86/f69ab82707534a0cb2057bdca04f9200a71214c7551800f9d34d6ac39e4f/propcache-0.5.4-cp314-cp314t-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:17a7400cec0256f0a71ae71f9da398f9894c956ff6668a1c9d317b3367316320", size = 249804, upload-time = "2026-09-16T00:15:50.486Z" }, + { url = "https://files.pythonhosted.org/packages/27/19/60677af50d93be4256213de7cd487f056944c048b9c0b6f2e45b3a30f666/propcache-0.5.4-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:978f28401afbc76cdc3df9e1717b4229a06b626a1dcc75db4e1f2beb3884c3e9", size = 282344, upload-time = "2026-09-16T00:15:52.029Z" }, + { url = "https://files.pythonhosted.org/packages/7c/f7/a0057808a91fb3b6a5f3602b528f0cdcb3d53e0ff8315d73fabdfdf8fec4/propcache-0.5.4-cp314-cp314t-musllinux_1_2_armv7l.whl", hash = "sha256:4a1f4f5ffa55dce6307631f3cb2948e117e665966ea512e0d502b16c24f567e7", size = 270167, upload-time = "2026-09-16T00:15:53.466Z" }, + { url = "https://files.pythonhosted.org/packages/83/c8/f4a865490df0dc0c8531d4e59ac411cb6dc24bb255d2396a6f1c60a368f4/propcache-0.5.4-cp314-cp314t-musllinux_1_2_ppc64le.whl", hash = "sha256:213bb68d9ced5cf2bf717b1071bf2b09b4b04c426256f9fe6d054c60318424c4", size = 286551, upload-time = "2026-09-16T00:15:54.995Z" }, + { url = "https://files.pythonhosted.org/packages/b0/67/b4faebde9da4e8173d0e5a30e8cd31335914af7ef350b988f27fec588cfd/propcache-0.5.4-cp314-cp314t-musllinux_1_2_riscv64.whl", hash = "sha256:286867fb156488c251a3721766e380ac4495e4fd6b51aaa1403d89ce7f4359d9", size = 249595, upload-time = "2026-09-16T00:15:56.505Z" }, + { url = "https://files.pythonhosted.org/packages/f6/40/52e1dd5636e9f5a27f6b5a4b4e2f33c322fd72afe956c397d82523ec4a80/propcache-0.5.4-cp314-cp314t-musllinux_1_2_s390x.whl", hash = "sha256:445ee3bfb46e85838387fb3c536a73cc0b994dc192b004e40e170adc54aa2a7e", size = 286700, upload-time = "2026-09-16T00:15:57.985Z" }, + { url = "https://files.pythonhosted.org/packages/d5/0e/30b2b324b93ff31a0bab539c102aae59e84e444031b2742150a7646aa1bb/propcache-0.5.4-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:48cb48c5346a97de792254af77715aa2529c2a1ebc5f586aa0aae44a02f1fe57", size = 280500, upload-time = "2026-09-16T00:15:59.487Z" }, + { url = "https://files.pythonhosted.org/packages/64/36/721bb59f682ff060d0c8df64274fca8cd0521b1a54506c2eedaef795b7f5/propcache-0.5.4-cp314-cp314t-win32.whl", hash = "sha256:03b229037d25b801e7af53fd52b9fc49d9439b036fca1e087e02780631adfa97", size = 46121, upload-time = "2026-09-16T00:16:01.349Z" }, + { url = "https://files.pythonhosted.org/packages/c1/86/0b1b80fa1ac3a0aac44e2922a6964fbe9cd52af5eab8fa933bf9e90b030c/propcache-0.5.4-cp314-cp314t-win_amd64.whl", hash = "sha256:8a1fc236528c457cd739c88abe823da851b7ab645d72792f88658114cc340c12", size = 49154, upload-time = "2026-09-16T00:16:02.901Z" }, + { url = "https://files.pythonhosted.org/packages/69/4f/9fe6f05a47cb550c823155052116f710064b6be5c6e8ec4e9faae7e18115/propcache-0.5.4-cp314-cp314t-win_arm64.whl", hash = "sha256:135036c5cfc93864affb0f9af9a27e5d7a71cb7bd745e7b6dbfc2d56cc30e827", size = 46005, upload-time = "2026-09-16T00:16:04.266Z" }, + { url = "https://files.pythonhosted.org/packages/58/25/895a11d1e4c5c2acc6d816e2bece34e02d9dc92f2182ae276cd819e9e804/propcache-0.5.4-cp315-cp315-macosx_10_15_universal2.whl", hash = "sha256:45bf2e730ab8905d0527fe05a86500f406e64305c34cc81ebe64b4617cab9760", size = 85634, upload-time = "2026-09-16T00:16:05.599Z" }, + { url = "https://files.pythonhosted.org/packages/58/41/c0acd69271de7a1cf439e77d5d60c18575fd09bad56e798b95fa23458ea4/propcache-0.5.4-cp315-cp315-macosx_10_15_x86_64.whl", hash = "sha256:31eb43ba2edc704ab2ec27815315dd8a19def0fb16215be4cfe8d32fe78ffd51", size = 50084, upload-time = "2026-09-16T00:16:07.384Z" }, + { url = "https://files.pythonhosted.org/packages/a5/1a/ad561f99f90884089e6403b76c220610809429ba868a81a2e7ce115d32e0/propcache-0.5.4-cp315-cp315-macosx_11_0_arm64.whl", hash = "sha256:174507f82d3594622acb1dd2dafecf2d899d6d506335494e7107767bf05f3aae", size = 51692, upload-time = "2026-09-16T00:16:08.956Z" }, + { url = "https://files.pythonhosted.org/packages/e9/07/057bdd3a9609ffad59b06239cceee784b047f6c720247bfaa36d2103e138/propcache-0.5.4-cp315-cp315-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:50e337653721d20ead710da33bf44487fbe8a0db8782714b60306481e9f95b51", size = 232947, upload-time = "2026-09-16T00:16:10.466Z" }, + { url = "https://files.pythonhosted.org/packages/fa/dd/d36ad35986718530498a65e45e3713f9f0e6a580f192ef02d2ef7cae9b52/propcache-0.5.4-cp315-cp315-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:0d21d0d2c82bbfeb1677a9711f38df968f9837576102bb4add1bd449d28d88f1", size = 241250, upload-time = "2026-09-16T00:16:12.056Z" }, + { url = "https://files.pythonhosted.org/packages/fb/81/f1459415cdb6c10d46942779de39bb59a77b38e5a76bb1def9227962eb45/propcache-0.5.4-cp315-cp315-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:ccf4f7a79e26bb7efb06ecd50c177833b71df05cbc748701372325e6bcc17f6f", size = 245150, upload-time = "2026-09-16T00:16:13.596Z" }, + { url = "https://files.pythonhosted.org/packages/ce/4e/58b9b1460afc97a4c0b17ee89af701c4011d4d7f46470eba3aaff76a8069/propcache-0.5.4-cp315-cp315-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:23278f808cd81d5ada7184a76606b925fb3389c60e1077b2cd7da7b1fcf0553c", size = 232166, upload-time = "2026-09-16T00:16:15.126Z" }, + { url = "https://files.pythonhosted.org/packages/b9/c6/5a79e0eda3e7b6987d03d8c622ff6d52a42165a12e8418eb37694b9cc4b4/propcache-0.5.4-cp315-cp315-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:e738ab81179510ce79b2eac9a6ecf47feffd9e76d1c72e403005dddb6e36c06c", size = 206085, upload-time = "2026-09-16T00:16:16.713Z" }, + { url = "https://files.pythonhosted.org/packages/4e/72/940aed42c73f9da345ca2de0f6e835c726498159abca5f1ef14fb0a2af8a/propcache-0.5.4-cp315-cp315-musllinux_1_2_aarch64.whl", hash = "sha256:a419ee85e654927baabda3929c03c0cc1112bf472ff0dfd6142f4e3a81ca4162", size = 228460, upload-time = "2026-09-16T00:16:18.352Z" }, + { url = "https://files.pythonhosted.org/packages/85/71/3f54e1535c8f323d91ba566044d7c2b39ff6f6a2f1d0bd9071779d07b9b3/propcache-0.5.4-cp315-cp315-musllinux_1_2_armv7l.whl", hash = "sha256:b61805357d966680acf68b3b6d49772631ed9df44ebece10ff1460e117a7da8a", size = 218350, upload-time = "2026-09-16T00:16:20.064Z" }, + { url = "https://files.pythonhosted.org/packages/a8/f4/025890cc389ac3ec485ecec607d4a7ca47e15bfa2a465746ab98af602536/propcache-0.5.4-cp315-cp315-musllinux_1_2_ppc64le.whl", hash = "sha256:58134228927cee6c047d626c08e60a81be604a20578a12ce752cc5c9a84d4826", size = 233156, upload-time = "2026-09-16T00:16:21.624Z" }, + { url = "https://files.pythonhosted.org/packages/04/29/b39cae08c87c140d3d274f0a2c058cb5588e836175c3309e260b230ab07d/propcache-0.5.4-cp315-cp315-musllinux_1_2_riscv64.whl", hash = "sha256:350b272b2279f4135a64fc0c304a5d08e28a137c9573442c606152446638a831", size = 206206, upload-time = "2026-09-16T00:16:23.204Z" }, + { url = "https://files.pythonhosted.org/packages/18/61/e16462ef18a87247dc9ebbd5c606f46d5ce67e708bd9cc734dd0d9222564/propcache-0.5.4-cp315-cp315-musllinux_1_2_s390x.whl", hash = "sha256:45bebbe252550fec975ba3b62bc6f931643cfd3b5464ef47619cf3fef154e01c", size = 234469, upload-time = "2026-09-16T00:16:24.841Z" }, + { url = "https://files.pythonhosted.org/packages/9f/84/b6a1490922427204fc47df920ed002eec709621de6b79b11592bf45c623a/propcache-0.5.4-cp315-cp315-musllinux_1_2_x86_64.whl", hash = "sha256:ada748108a43d29b7c328ba7db3755327cd94f028bcc1a7ee3f0addcfacd9c38", size = 227311, upload-time = "2026-09-16T00:16:26.549Z" }, + { url = "https://files.pythonhosted.org/packages/ff/5c/5a59527582e9bcb694b2f08b9894134b65a0f5f79dbff174f054f5f74ed0/propcache-0.5.4-cp315-cp315-win32.whl", hash = "sha256:ee19113bce2f3acd46432050688b70f61acd6857d75abb9ec96341b7e9ced123", size = 43512, upload-time = "2026-09-16T00:16:28.313Z" }, + { url = "https://files.pythonhosted.org/packages/26/07/93cf699ed363681e754d7c3fad587fb09ef6b65618ee193332ad16a68d7b/propcache-0.5.4-cp315-cp315-win_amd64.whl", hash = "sha256:ceb3e879afac028f93d272c957814695dc5569e4904262dbee92f6c41bd5e4a3", size = 46264, upload-time = "2026-09-16T00:16:29.751Z" }, + { url = "https://files.pythonhosted.org/packages/65/10/fef04fbdcd44a4a163cb5ff5674599c6d6fdefd64a5a459438f9ad2ba042/propcache-0.5.4-cp315-cp315-win_arm64.whl", hash = "sha256:c83acbce9f2b5e3f5f5eda9e53d2001fed22fcdfef81274a9e02d8fd53b70a30", size = 43395, upload-time = "2026-09-16T00:16:31.5Z" }, + { url = "https://files.pythonhosted.org/packages/70/f6/7e2f4dab0b92ab46111bd48cee9ee1e5f519514c44e3779ede5358d7ada0/propcache-0.5.4-cp315-cp315t-macosx_10_15_universal2.whl", hash = "sha256:a5e8ef588c109725dc713ba69aadcac00a1ef90c2ce9c0a8c7075128f569f47f", size = 89825, upload-time = "2026-09-16T00:16:43.115Z" }, + { url = "https://files.pythonhosted.org/packages/9f/8b/dfeff925cb6ced97ede701d5c6a99998da963c6f2e06abbf879c9dac5b54/propcache-0.5.4-cp315-cp315t-macosx_10_15_x86_64.whl", hash = "sha256:4d86476a935c88963d9b8e1a9a0d38188790e9622169bfbafa173046846709d3", size = 52159, upload-time = "2026-09-16T00:16:44.754Z" }, + { url = "https://files.pythonhosted.org/packages/24/6c/924c810be5b7cf218ef47e707cf06d34adb4e3f3a31e3c24c55c6d945a88/propcache-0.5.4-cp315-cp315t-macosx_11_0_arm64.whl", hash = "sha256:f5470694918830da62fac9e69133b53d23b736d7070e587b27a4a2be37e08e68", size = 53956, upload-time = "2026-09-16T00:16:46.762Z" }, + { url = "https://files.pythonhosted.org/packages/3f/b6/9ed0a5c939b58b6bed740a05b5d0f919f0b318d03284b4b6d81a0fe8a29a/propcache-0.5.4-cp315-cp315t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:10ef33a68a61ce317e095fd2e202a592ea92392b90944a78c993f0d9a73ab06c", size = 295235, upload-time = "2026-09-16T00:16:48.577Z" }, + { url = "https://files.pythonhosted.org/packages/5a/eb/5ce886e902a2e781dddf110993d5329458a9b1a8626b876c65e5e25bf413/propcache-0.5.4-cp315-cp315t-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:5cacf3c9efd09df409dc33654dd077e1c245ba8fb747b0f0236ef41b7c49b589", size = 294463, upload-time = "2026-09-16T00:16:50.539Z" }, + { url = "https://files.pythonhosted.org/packages/f2/88/c98f49183ecd3e5b204a556f0ca47baa02c2206a500fe8c7ec1726297b0a/propcache-0.5.4-cp315-cp315t-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:770e8209d018175fc0063936fa9583b6d27e88c5ad31543f3383d66080efdd62", size = 300081, upload-time = "2026-09-16T00:16:52.423Z" }, + { url = "https://files.pythonhosted.org/packages/27/0d/c5090f9e6f67cbc30a2b744c7bb0f8006dcba5ec1b0d82f866ae1cc7c5c4/propcache-0.5.4-cp315-cp315t-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:03969626faf0783a592dfa17e28eac06018bd0b44dafae6943d53b92421a7f72", size = 285360, upload-time = "2026-09-16T00:16:54.141Z" }, + { url = "https://files.pythonhosted.org/packages/ac/9c/34a55396910583ed07926669ab309dde2213a2dec05a7e946bb90ad66908/propcache-0.5.4-cp315-cp315t-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:ef3b928d9c984322b5c44e6964d8dbc653da87d2d8ee1647fa6da43072e650a9", size = 248014, upload-time = "2026-09-16T00:16:56.062Z" }, + { url = "https://files.pythonhosted.org/packages/cd/b5/c0a142b656093ca397039dd3fe166cbb87c945712b534546514a24cd2611/propcache-0.5.4-cp315-cp315t-musllinux_1_2_aarch64.whl", hash = "sha256:7177c43eddf10a0893c4fec52ebb408fdcd7f7d63962caace9180d8f81b14ece", size = 280662, upload-time = "2026-09-16T00:16:58.044Z" }, + { url = "https://files.pythonhosted.org/packages/54/28/fab2809c2e337fe26becea9648e84d5cef46075c91b826acb13e4f9dd04e/propcache-0.5.4-cp315-cp315t-musllinux_1_2_armv7l.whl", hash = "sha256:420162a77f94eb1cf5ef7893f500016dabd548e73de956785a1dd899cc73006a", size = 266149, upload-time = "2026-09-16T00:16:59.702Z" }, + { url = "https://files.pythonhosted.org/packages/3a/11/7ddf336288b2678a5f054f8da2e2bd1a719f5d4b7de714d9c6bd588a2313/propcache-0.5.4-cp315-cp315t-musllinux_1_2_ppc64le.whl", hash = "sha256:3eb2e820e8e2101407da93f17c57cbb7d225461955fc60105daaba14cd421ee2", size = 283097, upload-time = "2026-09-16T00:17:01.459Z" }, + { url = "https://files.pythonhosted.org/packages/1a/ae/351b1a5225f5473c411d9a612a229ae147cf0cf65c72ad838b87219ea8e8/propcache-0.5.4-cp315-cp315t-musllinux_1_2_riscv64.whl", hash = "sha256:13e52b6e0bde97dee98ab66552dbff2931649c96f1ac432eac299fe689ec373b", size = 248160, upload-time = "2026-09-16T00:17:03.298Z" }, + { url = "https://files.pythonhosted.org/packages/3f/d0/7f79f061e30d135bb615c9782c94a74652033d00b49254edbbf35a9165a8/propcache-0.5.4-cp315-cp315t-musllinux_1_2_s390x.whl", hash = "sha256:12682126712ddc19b70ff819debbd279e58adf1f0c8f8f8138c18ade2044b284", size = 283036, upload-time = "2026-09-16T00:17:05.238Z" }, + { url = "https://files.pythonhosted.org/packages/53/3c/016f1cad8bf4c428d748cf399b2bac603026fbfd6966e6a5579b5c5b6956/propcache-0.5.4-cp315-cp315t-musllinux_1_2_x86_64.whl", hash = "sha256:3af0c8642b2da4815d86e631232ac8286e17644fad907c19508aa8e7cb4ba8ad", size = 279350, upload-time = "2026-09-16T00:17:06.881Z" }, + { url = "https://files.pythonhosted.org/packages/ea/60/d8f72cb24b412487ed4c397f539117d3b74c3c33dd32020e91fe00a958a8/propcache-0.5.4-cp315-cp315t-win32.whl", hash = "sha256:1df8d8561b21465c5dd56110a01caf897e026d065b4b84e98a488209094272ec", size = 45874, upload-time = "2026-09-16T00:17:08.567Z" }, + { url = "https://files.pythonhosted.org/packages/d4/ef/8bae0a316d406644450522f2f3d44a4e19632f5f3bb60d1d0e6c53842616/propcache-0.5.4-cp315-cp315t-win_amd64.whl", hash = "sha256:02c0a34f16889cf800f10f0247a564d8ce6eeab6ffcd7c87198f769067eb8432", size = 48574, upload-time = "2026-09-16T00:17:10.077Z" }, + { url = "https://files.pythonhosted.org/packages/57/be/bcc053f66a97355683884b448198e79580fae8e8fa4d96b9bb01614e9913/propcache-0.5.4-cp315-cp315t-win_arm64.whl", hash = "sha256:dc4242ca653c9b30ab51c5f8193323e7bc0928f897ee9103201e59a43abcb72e", size = 45625, upload-time = "2026-09-16T00:17:11.377Z" }, + { url = "https://files.pythonhosted.org/packages/f5/cd/785c64ed382f3f04201870267b02783f63b4678c2acfddc177a3ebcc2727/propcache-0.5.4-py3-none-any.whl", hash = "sha256:62c60aec739ed00124573cce1178138fd690c7676352d67a37328c1cf51d7468", size = 16338, upload-time = "2026-09-16T00:17:13.106Z" }, +] + [[package]] name = "pycparser" version = "3.11" @@ -2119,3 +2795,153 @@ wheels = [ { url = "https://files.pythonhosted.org/packages/2d/3f/73e511ecf2496ceac57dd4ed8388efe2bcf0769338a2dbf242c8366ae87e/websockets-16.1.1-pp311-pypy311_pp73-win_amd64.whl", hash = "sha256:56cd5fc4f10a9ea8aa0804bddb7b42506cf9e136046f3b4c27de8fec9e2ecba5", size = 180330, upload-time = "2026-07-17T22:51:02.603Z" }, { url = "https://files.pythonhosted.org/packages/be/4d/2d0d67834092e354d2b0498f014a41249a89556bc406cf86f3e1557bb463/websockets-16.1.1-py3-none-any.whl", hash = "sha256:6abbd3e82c731c8e531714466acd5d87b5e88ac3243465337ba71d68e23ae7e3", size = 173814, upload-time = "2026-07-17T22:51:04.184Z" }, ] + +[[package]] +name = "yarl" +version = "1.25.1" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "idna" }, + { name = "multidict" }, + { name = "propcache" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/75/16/e8be8e2fb175bbf41a0680381a319f1199fae256588241a2ac8677eafb49/yarl-1.25.1.tar.gz", hash = "sha256:03dd38de09bc213e9a8b29761eec33ee1d5318dac0e49d8af36e4d27830e23a7", size = 246245, upload-time = "2026-09-15T19:35:02.264Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/85/92/55fa9ee84cb8ec9930a910b5753936a926f918d8cc8965bdac571479c095/yarl-1.25.1-cp310-cp310-macosx_10_9_universal2.whl", hash = "sha256:142c06c4d6a35ee3ec5da08499805e879cb3ca7c1fbfbecb0140fe72403818d6", size = 144695, upload-time = "2026-09-15T19:29:53.114Z" }, + { url = "https://files.pythonhosted.org/packages/16/b4/9edc8e605b16b2eb5bd0c2ccc73e2b15aab583862460767fb43f91f11839/yarl-1.25.1-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:24ce942011a61953e7d313438038f4d32ff21387b775f58a957f7a07dd55ef95", size = 104332, upload-time = "2026-09-15T19:29:55.443Z" }, + { url = "https://files.pythonhosted.org/packages/ae/de/4204e6646e278b1cd4a9cf73ebe8b7cfcf16693f1249b324eb273d67602a/yarl-1.25.1-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:9e23c82b63cd7652fc24d33ed6cc17099d607aa3b4fc4ddc75e95062f3d82df4", size = 104449, upload-time = "2026-09-15T19:29:57.239Z" }, + { url = "https://files.pythonhosted.org/packages/1d/fc/21d74789198ad68a23a209ab0d73fe5a52d39ebbd9945041e72827acdd77/yarl-1.25.1-cp310-cp310-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:8ee202350cf57abf0e9502a41601841019c25d3db7ff52d980aaf31446254059", size = 116828, upload-time = "2026-09-15T19:29:59.031Z" }, + { url = "https://files.pythonhosted.org/packages/8f/31/90891ddb61848c067ebd1fb505ab5902a6e7d4707c2f3823f67ff37883d3/yarl-1.25.1-cp310-cp310-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:5df89f769cc8ff94c3d7e7603386fba309d25ce5240132d26c15baa8d0e96c4c", size = 107150, upload-time = "2026-09-15T19:30:00.868Z" }, + { url = "https://files.pythonhosted.org/packages/a1/15/f3d18743d3688b5f01aa83034b6c00665692ab20e1d0c89a29000d4979ea/yarl-1.25.1-cp310-cp310-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:83e9f4a25085bd4b7214701a0794ff1f50fc633ffb8bdfebf07abdd81c2db126", size = 124704, upload-time = "2026-09-15T19:30:03.128Z" }, + { url = "https://files.pythonhosted.org/packages/99/37/718789d8004775d6a2db86b2afc72b1d156e0590b88a1b8634ddd4bdb8ee/yarl-1.25.1-cp310-cp310-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:e636b64d24fd9c38053c5e389a1174c66361fa49dcfd220f4dd35b4abde7cb89", size = 129246, upload-time = "2026-09-15T19:30:05.014Z" }, + { url = "https://files.pythonhosted.org/packages/28/b9/7818ac6dec7fbcd16be2d19495807c01e2c38834e57d41c63356a75e786b/yarl-1.25.1-cp310-cp310-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:e5637ca8d0bd7fb72648a6c7934af4baaccb697657f7438c9d264fc2abb8b0b1", size = 118071, upload-time = "2026-09-15T19:30:06.977Z" }, + { url = "https://files.pythonhosted.org/packages/b2/e3/8d098cafb30a64df7283b5a5dd0d32d22a71b18a1b9ec071d0776ffe5c2a/yarl-1.25.1-cp310-cp310-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:683e362b8ba453080f7489c66f4ea794e751c35b72e7eab3575ef784c2fbc7fb", size = 116180, upload-time = "2026-09-15T19:30:08.836Z" }, + { url = "https://files.pythonhosted.org/packages/20/9c/fbe9432478d87e00eef80242e15179639df162cb3d5d8d978fc56dcb6c51/yarl-1.25.1-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:df23df54b5114a17c2d0ef192433e2e5a9f0c5178c32375e90b7cfc965f349d0", size = 116578, upload-time = "2026-09-15T19:30:10.782Z" }, + { url = "https://files.pythonhosted.org/packages/b1/8e/b3dfd03732236b86b0bcf06a72a37de412ff6f82e719a947c3c651d4dece/yarl-1.25.1-cp310-cp310-musllinux_1_2_armv7l.whl", hash = "sha256:f53dcd26694f148f738edc052b5a69234833e739f10f4c3287bdfd8ec0f7b326", size = 108886, upload-time = "2026-09-15T19:30:12.951Z" }, + { url = "https://files.pythonhosted.org/packages/83/e1/94dacb650d4963d5f844bc3df7ba70288cb7b68ed5a4d070da71acb19b14/yarl-1.25.1-cp310-cp310-musllinux_1_2_ppc64le.whl", hash = "sha256:b8075fe90bc08e40b8b8a1874fab42ee4c7b56af05c5886e9cc841397f916908", size = 124098, upload-time = "2026-09-15T19:30:14.963Z" }, + { url = "https://files.pythonhosted.org/packages/d6/3f/c93f76a218258c7bfc60dd27fd56e9102bdbc625517f4a6ee673295fe4e4/yarl-1.25.1-cp310-cp310-musllinux_1_2_riscv64.whl", hash = "sha256:a8c2b841478068440d8b733005d13a5ef535b9928cbc05f17182d410f32ba449", size = 115768, upload-time = "2026-09-15T19:30:16.736Z" }, + { url = "https://files.pythonhosted.org/packages/a8/79/4d93f13c3b05cda3c962805dec28cbc255c50239b3457808abc5633a00c2/yarl-1.25.1-cp310-cp310-musllinux_1_2_s390x.whl", hash = "sha256:ca32926d7d77bcc8838425c4c95e040a3ace1cb7dfdae599013458dcda2607ca", size = 122461, upload-time = "2026-09-15T19:30:18.901Z" }, + { url = "https://files.pythonhosted.org/packages/c5/8e/e2ba83b3a9bfc1d3b882ad35fa8abc04a7af4d9356f2e329a23d0c8d889d/yarl-1.25.1-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:192a866877a49993949ef1975864ad8728bea28ee810f6abe1a0729c2b500426", size = 118295, upload-time = "2026-09-15T19:30:21.07Z" }, + { url = "https://files.pythonhosted.org/packages/42/67/cb5ea1baa0c0ac60bda44ce59f601133154af2a2e67722d3517f8793855d/yarl-1.25.1-cp310-cp310-win_amd64.whl", hash = "sha256:3f4d48a6112712973e676bd792121fee470e432d749177162d9949d5c9460a1b", size = 102929, upload-time = "2026-09-15T19:30:23.122Z" }, + { url = "https://files.pythonhosted.org/packages/2f/85/9a1e98de10fc0e738d517efd2a9984c3e7db6cf35fa72b2b373988a9e9b7/yarl-1.25.1-cp310-cp310-win_arm64.whl", hash = "sha256:48796ea00a303961507dc6c8437c4b325a6fc3f95f7c36c71b91ea9a8150963c", size = 98854, upload-time = "2026-09-15T19:30:25.102Z" }, + { url = "https://files.pythonhosted.org/packages/83/b3/2cea721d495ca57f8f414aa4867ee263f486b274e07463158cf52f02ba7f/yarl-1.25.1-cp311-cp311-macosx_10_9_universal2.whl", hash = "sha256:9d693bf4bf534e9ba3ae2780cfd577f5135629f7b5ac653490859d0b77864865", size = 143794, upload-time = "2026-09-15T19:30:26.946Z" }, + { url = "https://files.pythonhosted.org/packages/55/e6/cd145cff8e5cf60b8b3c41fbecfa2a45028a8dec3fbc52bec03595ff3d3b/yarl-1.25.1-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:ab2054c5531af2a9ba7b69b8ec91e4f884420e83a8c5e579b013084cb57e5e5d", size = 103993, upload-time = "2026-09-15T19:30:28.661Z" }, + { url = "https://files.pythonhosted.org/packages/ce/7c/fbb40fe2d53747c40aa36a9e2bd2178a202f942bda0b670f3306d4aefbce/yarl-1.25.1-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:564fdc7085d2245ab84f88882fdb1d6ac0723124bff6ded35bfb1c00f812630d", size = 104010, upload-time = "2026-09-15T19:30:31.069Z" }, + { url = "https://files.pythonhosted.org/packages/f0/0b/5a516f70641092283f57cf3670bdb75e7327bcc0dcb5038697e4dfbfd569/yarl-1.25.1-cp311-cp311-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:acae6b45d1ace09b6ba3876da43b88366ef368f73b988c7f57e14231753d4420", size = 116444, upload-time = "2026-09-15T19:30:32.894Z" }, + { url = "https://files.pythonhosted.org/packages/b6/8a/d1a627f827b0a404ae0f5647cab0534959081cde13b0756a783469fb3b5e/yarl-1.25.1-cp311-cp311-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:1fb2a01ba8cd9c5d2c5dc1ec35e0fc951d04b4f037541d4ac090c993ce58b3d7", size = 107565, upload-time = "2026-09-15T19:30:35.188Z" }, + { url = "https://files.pythonhosted.org/packages/aa/cf/c8e0aaec886840a6c4480fe44eaec7cd4319f79a563b79321473be79c56f/yarl-1.25.1-cp311-cp311-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:e92b6bcc741b86d67606c40d3cb9c7cc8e6c737f81e31f4a94efc204456c92e3", size = 125006, upload-time = "2026-09-15T19:30:37.1Z" }, + { url = "https://files.pythonhosted.org/packages/50/26/0cce366d54a93cdc8342965dc7663385e4db161625cc1e8b18e786753d24/yarl-1.25.1-cp311-cp311-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:72c34ac7ad4314c19362d5ce27626dcc8429bd30bbf8c179f4234078851f9492", size = 128717, upload-time = "2026-09-15T19:30:38.904Z" }, + { url = "https://files.pythonhosted.org/packages/95/0c/a71501bbc1a674ff72c4d6c2b75f4d9a5af819f5244c3a7558080a8802c5/yarl-1.25.1-cp311-cp311-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:d5add7b4ca7afeea91d52e4d4e4db3b1fe9885b71f07054560d8c4296b7441a2", size = 117728, upload-time = "2026-09-15T19:30:40.809Z" }, + { url = "https://files.pythonhosted.org/packages/e7/6f/c3267ca01defeed9ed9c4ff9b17bd54915432c405945233265b707475d1c/yarl-1.25.1-cp311-cp311-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:def538065f9e4d4cf1ae164bd59aba00dfa84f03923e0de4c3788f252d6bcd17", size = 116224, upload-time = "2026-09-15T19:30:42.818Z" }, + { url = "https://files.pythonhosted.org/packages/8f/69/fad57ee52d648431718ee0f1f68966a99c1352c3924688ffbdcc9d3fe51a/yarl-1.25.1-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:0a191bfdb30a79b98e5d175d75285f9fcb78bf0e46ba5efda042e1c72071a0de", size = 116299, upload-time = "2026-09-15T19:30:44.966Z" }, + { url = "https://files.pythonhosted.org/packages/2a/d4/6a8c1e29f33338687ca278cba0a8fbf6525a322c2c02a9a500ccbe041152/yarl-1.25.1-cp311-cp311-musllinux_1_2_armv7l.whl", hash = "sha256:71f42c5b9a948c113bbdebfa544598321431d064ff959d32e99b1feb61d68345", size = 108625, upload-time = "2026-09-15T19:30:46.874Z" }, + { url = "https://files.pythonhosted.org/packages/e8/d2/3a35ae791c9cb6522c106923ff25c3230d999091e5e65511bca23bbd9914/yarl-1.25.1-cp311-cp311-musllinux_1_2_ppc64le.whl", hash = "sha256:72849d892954be4d09e569b8b831ac39ce58417fedc767d4308a0fe542018a40", size = 124515, upload-time = "2026-09-15T19:30:49.082Z" }, + { url = "https://files.pythonhosted.org/packages/be/fd/2b022109a6b4af0f7dc371cf7500af380b0d4f034010243e1b0ce218dc93/yarl-1.25.1-cp311-cp311-musllinux_1_2_riscv64.whl", hash = "sha256:efb01a106f971cb3752856bca2318bbdf7f01bd8823779c461586cbe5ffd5258", size = 115711, upload-time = "2026-09-15T19:30:51.208Z" }, + { url = "https://files.pythonhosted.org/packages/18/59/f7586271136c3ddb0126bbfe661844699369b76b555fe38c4efe86870b2e/yarl-1.25.1-cp311-cp311-musllinux_1_2_s390x.whl", hash = "sha256:a1daf47cd95a7c3a63456336bc5aaa8c86dd3a47d07ed3d0e76132ae4666a5a1", size = 122751, upload-time = "2026-09-15T19:30:53.535Z" }, + { url = "https://files.pythonhosted.org/packages/a0/0b/07f7a2d881f7e16c385b47fc1753382600847cad305dcc7fa0c25828acf8/yarl-1.25.1-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:9489e6abf47ba37f332075a91444c7cfedb03e6ce99fbb2f116bfe1ce810da3b", size = 117983, upload-time = "2026-09-15T19:30:55.277Z" }, + { url = "https://files.pythonhosted.org/packages/aa/9d/8cdceec66a9b940700cb45931741403f045b162afd79bcb93c41cadd0972/yarl-1.25.1-cp311-cp311-win_amd64.whl", hash = "sha256:d7306dee25b8a0e737363f347362b875094b4dc4e367311470656ae420fdbf8e", size = 102894, upload-time = "2026-09-15T19:30:57.606Z" }, + { url = "https://files.pythonhosted.org/packages/17/f1/7ec357db1d3ad2863542d71e8fe64a126bbec17b134cd7d30951196809a5/yarl-1.25.1-cp311-cp311-win_arm64.whl", hash = "sha256:abb1384477f5901d436b5d2e5465954de46ea6098f59163d243660b5c4461d35", size = 98609, upload-time = "2026-09-15T19:30:59.705Z" }, + { url = "https://files.pythonhosted.org/packages/75/b3/cd32ac66ae622b854c2df0ac52106dda220d361b65a64fde7d5b3684aa3f/yarl-1.25.1-cp312-cp312-macosx_10_13_universal2.whl", hash = "sha256:94d7aa6debf92a1dd14cb5280b083a764169a13cfb23a452111160274ed989f4", size = 144798, upload-time = "2026-09-15T19:31:01.821Z" }, + { url = "https://files.pythonhosted.org/packages/61/fb/a2c52a8007c2051ba74662afb112ecf3d00346af4c25e33df9d80fd14fb8/yarl-1.25.1-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:83d4a37e4b95da4d8bda930d6d35b75b4cdadbacbb4980cae290ea3100b5d51d", size = 104583, upload-time = "2026-09-15T19:31:04.05Z" }, + { url = "https://files.pythonhosted.org/packages/be/dd/ee38aec8e09fdf957e50d4085453fbe202f56c6c3b4cf07b81cdb4f09ee9/yarl-1.25.1-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:e029648f9c951db30e98a7d7ec90835db88ec4b32820efe2a9bdc2287e032eb6", size = 104325, upload-time = "2026-09-15T19:31:06.338Z" }, + { url = "https://files.pythonhosted.org/packages/1e/b3/058dbfb1857b484c9cf9cc135659f50b85ce66e03c99e44dc2f7b6161f55/yarl-1.25.1-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:4d781294bb815ecb5ea57ff6bbf8038e0a31a95fdf3e1788f66e0dc100d64b58", size = 115358, upload-time = "2026-09-15T19:31:08.593Z" }, + { url = "https://files.pythonhosted.org/packages/db/39/29693446cf0cf6b15a0e2f75a5d40f93c56819b05b0622196f45e95b5cc0/yarl-1.25.1-cp312-cp312-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:e12c538e00e7c1b286a07061046b90e8124e6a9793efae2c70db6a4aad07faad", size = 107658, upload-time = "2026-09-15T19:31:10.802Z" }, + { url = "https://files.pythonhosted.org/packages/86/b3/3c4dd7e1af43b931fba95e0a722737f2ea94a6d199c802585282831d7abd/yarl-1.25.1-cp312-cp312-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:7e4de3ac4adbad3d0bc7c6f4360a7dbff5de2f15e3b723be3198074e17fd9c40", size = 122660, upload-time = "2026-09-15T19:31:12.84Z" }, + { url = "https://files.pythonhosted.org/packages/bd/b5/1b60dbc3cfc9c5712b15148c206748f2bc93953ffdbe25ea75b63dfc89c9/yarl-1.25.1-cp312-cp312-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:419f392a1da624877975709e3864dfe833af6cc7671b39318086d456e288380c", size = 126506, upload-time = "2026-09-15T19:31:15.088Z" }, + { url = "https://files.pythonhosted.org/packages/bc/7b/ca212cbe170ac8b96e45317ecbcf9c3c3ecf0cdec98d5b088a9c4088929b/yarl-1.25.1-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:c6f117789d22dce188e5754e8bc65b7e6ebf8cb73963b9fa761f672a5883769d", size = 117050, upload-time = "2026-09-15T19:31:17.241Z" }, + { url = "https://files.pythonhosted.org/packages/cb/c3/72b4938cdbe619ad71ac156182faef4908846b84dc3ca4dbb4c4e6f84014/yarl-1.25.1-cp312-cp312-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:80e47012e730da131c9f059c80936783f9659aae22dc31c03c0595590d11ed54", size = 114174, upload-time = "2026-09-15T19:31:19.294Z" }, + { url = "https://files.pythonhosted.org/packages/e8/43/268717870f9ba0cc9701a95181587f6dc8c5f387aab4aeecc83158f38a79/yarl-1.25.1-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:e80f557716fd765439577131e526b8942ffc2c07bdbc5e39fa62f660ba1e963f", size = 114944, upload-time = "2026-09-15T19:31:21.414Z" }, + { url = "https://files.pythonhosted.org/packages/da/84/baa5bf504d51fe062c4bcaf62936da97fffb43285978d0b39984824231fd/yarl-1.25.1-cp312-cp312-musllinux_1_2_armv7l.whl", hash = "sha256:f61964f235a43738bfac50da46fc4254943a7eea3051aeb0b6fc7c992c29fadc", size = 108263, upload-time = "2026-09-15T19:31:23.388Z" }, + { url = "https://files.pythonhosted.org/packages/a4/28/779a2ed9e0152a601a27039bed9aead3f0b79797a67e2c44bfa444622dd8/yarl-1.25.1-cp312-cp312-musllinux_1_2_ppc64le.whl", hash = "sha256:e546fe1d4a93ebc2910f0d768baff19faa09843ab3f2036a67ed6e69fae4419d", size = 122184, upload-time = "2026-09-15T19:31:25.343Z" }, + { url = "https://files.pythonhosted.org/packages/f8/1f/118e9e5b8f07694d63fd3222e801d7782270003f1a222aa798df3f8d5933/yarl-1.25.1-cp312-cp312-musllinux_1_2_riscv64.whl", hash = "sha256:cce0727fd5ac04d372fa9bbfde9febc2bcf209aadfcf0468e45dec72719895d1", size = 114001, upload-time = "2026-09-15T19:31:27.465Z" }, + { url = "https://files.pythonhosted.org/packages/0f/ae/a4cf1cf372313734b17996d4007f9f73596e7a178b9485802e5494ecf484/yarl-1.25.1-cp312-cp312-musllinux_1_2_s390x.whl", hash = "sha256:af4ea5b37403ef4e30f3927eaed540db942bde01d8d3ff083527c0704d1c9c68", size = 120565, upload-time = "2026-09-15T19:31:29.47Z" }, + { url = "https://files.pythonhosted.org/packages/05/79/ad94f93ca731bc9e44d321833ab96b82a4f9f5f63cf773f81a4aeea5ecc1/yarl-1.25.1-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:68782fdb4027b8d1eee25ec35e9a6db05e863b899eb0310b3a33b6c3fef55707", size = 117060, upload-time = "2026-09-15T19:31:31.367Z" }, + { url = "https://files.pythonhosted.org/packages/bb/cc/51a7b4abf4ac593b8e7eb3794b28e5a35ae26eed8bc04787628d215af82f/yarl-1.25.1-cp312-cp312-win_amd64.whl", hash = "sha256:7d575b54cb3863ef9bc290ea4b009999d55dc237326131e4853cf33e888fee03", size = 102593, upload-time = "2026-09-15T19:31:33.329Z" }, + { url = "https://files.pythonhosted.org/packages/9d/21/0941a6b93a58b59a1ec75e5333bf06929b671309c43c0cd201c172d9c39f/yarl-1.25.1-cp312-cp312-win_arm64.whl", hash = "sha256:bc3ac7bf569f6b64dad04dd7808c7872dae8a97df657856eac05e9b7e3614a85", size = 97697, upload-time = "2026-09-15T19:31:35.855Z" }, + { url = "https://files.pythonhosted.org/packages/7b/ed/2f3129bbcc9a5c8ba12cc2b29d8060a3bab9c8043c456cfd4b5ca3188890/yarl-1.25.1-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:25868beca8b6765f8f7d0e11fe6dd7c66dd4b0793b9500286d20cc92352126a5", size = 143623, upload-time = "2026-09-15T19:31:37.966Z" }, + { url = "https://files.pythonhosted.org/packages/17/e1/f1bc3390fdca352826676b531d0712736f156919090206700421d46b2c37/yarl-1.25.1-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:10b2fd95332f0d716d5eee3c9fb2ce8eada19082de7fee83d32e37992fd75c26", size = 104011, upload-time = "2026-09-15T19:31:40.25Z" }, + { url = "https://files.pythonhosted.org/packages/a8/aa/50acc5c3e5da04172ae3c281c75405af4d2ca911e16120ab0563f4dffb66/yarl-1.25.1-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:0f12afda4eea8c8994a76d4df1875c765194f5fbe8a9d197929ea303caee29ec", size = 103677, upload-time = "2026-09-15T19:31:42.46Z" }, + { url = "https://files.pythonhosted.org/packages/30/d2/7d1e0ab9f8390e1fbcede5a6dbf70d23c96ad09b8c5567f3a514d1ddb0e2/yarl-1.25.1-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:14b79a30a93a3ce2e8832603fd0ab780ada281b0ba5110b519a634f2d7d7d1fc", size = 115392, upload-time = "2026-09-15T19:31:44.371Z" }, + { url = "https://files.pythonhosted.org/packages/71/e1/5ba1e3a2a22139213655e760919038e8ed7e2d4a99826d0bbddb3beb96e5/yarl-1.25.1-cp313-cp313-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:4bd6340d20ae2c7ca719b87b426e808e90743b676d05d4c26c4fb5ca71f41184", size = 107493, upload-time = "2026-09-15T19:31:46.273Z" }, + { url = "https://files.pythonhosted.org/packages/f5/53/780653d5e0f73831f467cf13548912e5eec97f21dc49fc8daf21da027df4/yarl-1.25.1-cp313-cp313-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:126a2533570c554719ca40a1288fdee1700b6bc82e7131aa69fa85252d92e651", size = 122537, upload-time = "2026-09-15T19:31:48.654Z" }, + { url = "https://files.pythonhosted.org/packages/03/92/d54fa70236c6036271c9c9c09fd978df5cbe3ef49ef6c46e9b833476d215/yarl-1.25.1-cp313-cp313-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:a3faadac7d812ddac258feb57b9846b60c1b437c4f4b9ad42595c6f6fe4390df", size = 126170, upload-time = "2026-09-15T19:31:50.872Z" }, + { url = "https://files.pythonhosted.org/packages/0e/b7/a82a49bf88340b837ef6972b508a1604ae377b9e6904b46b10cf5f1cf925/yarl-1.25.1-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:be80550d9bfe83d9b62398a37081a90434e6df2d978ec345c3d2820de6beddab", size = 117012, upload-time = "2026-09-15T19:31:53.189Z" }, + { url = "https://files.pythonhosted.org/packages/ef/78/5d684b411e3f3602464ee9b538db48205038f8605872985f61efb809ced0/yarl-1.25.1-cp313-cp313-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:e07595c7d6f4db270ceede356a1bd1c07a34f1c26f958d1ed0cd7b48e0d2bba3", size = 114950, upload-time = "2026-09-15T19:31:55.694Z" }, + { url = "https://files.pythonhosted.org/packages/2f/11/51d82b852c64f7fad0fc7a7ff3031517204887e874c722bbca839c0b23ac/yarl-1.25.1-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:eb96ed1ae6c7d072d60840c0434aef07a2df611812810807fbc54263a6053e9a", size = 115428, upload-time = "2026-09-15T19:31:57.966Z" }, + { url = "https://files.pythonhosted.org/packages/e4/49/9d1978049bf646b9ea918313926453c6901b71c92f097467777d47d36a88/yarl-1.25.1-cp313-cp313-musllinux_1_2_armv7l.whl", hash = "sha256:3feb99222553a8cbedfa52c2f59dd84c3f50d5b582c728d522caf8d72769a54b", size = 108428, upload-time = "2026-09-15T19:32:00.048Z" }, + { url = "https://files.pythonhosted.org/packages/43/35/7b8f1ebb45d7ec3dda7d1909bf44f458de41ef91e2937f107733582a5166/yarl-1.25.1-cp313-cp313-musllinux_1_2_ppc64le.whl", hash = "sha256:a2ed0ba415ccdf08f14bf544cb78346d0f76086707ffee24921a2c84dbf1305a", size = 121961, upload-time = "2026-09-15T19:32:02.436Z" }, + { url = "https://files.pythonhosted.org/packages/63/d6/d8b689ab7ca26edeb85f6ff28812aac7a25376eefc1780e303a7bfbaceff/yarl-1.25.1-cp313-cp313-musllinux_1_2_riscv64.whl", hash = "sha256:2b49375d22299b0a834c2bca72f39aaecc270d96fb24c30424899676f487b22a", size = 114961, upload-time = "2026-09-15T19:32:04.456Z" }, + { url = "https://files.pythonhosted.org/packages/cf/d5/1a1798ea4dc6b7ee3260010a27907ebc697c95dae99817d817ed446d24aa/yarl-1.25.1-cp313-cp313-musllinux_1_2_s390x.whl", hash = "sha256:ef74070ac553c59eb4f04258722066d6c6135b7baa03b2e9f2da65c096e96d98", size = 120036, upload-time = "2026-09-15T19:32:06.5Z" }, + { url = "https://files.pythonhosted.org/packages/91/8d/b1b35ed7903da6669b1d367cb2c09436acd4ff508029b4f39a0c0c2058fc/yarl-1.25.1-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:0a66db89ea473abeac4b70523cafd94db3772380e565f9d28af7a179b7af71fa", size = 117276, upload-time = "2026-09-15T19:32:09.401Z" }, + { url = "https://files.pythonhosted.org/packages/3a/8f/4db01cef62caff0d7a4593ed694fb8a41a27a11158cab80d290221f13e57/yarl-1.25.1-cp313-cp313-win_amd64.whl", hash = "sha256:1f51020b2eb8a003c84925638ec63c21a750a4bddd3a22ec8eac6a742dadf1b9", size = 101945, upload-time = "2026-09-15T19:32:11.545Z" }, + { url = "https://files.pythonhosted.org/packages/c0/5e/3ce00497c5c0babb74d4130c10c3828ccd215b4819d12020c42429f991ac/yarl-1.25.1-cp313-cp313-win_arm64.whl", hash = "sha256:b10dd0557ba422715b5206b3743192135a6022acca8baec51aa127d0a75db8fe", size = 97270, upload-time = "2026-09-15T19:32:14.127Z" }, + { url = "https://files.pythonhosted.org/packages/80/cf/54023edfab7aa773b860503db0c56e962ccab0922803ee97988c176ea090/yarl-1.25.1-cp314-cp314-macosx_10_15_universal2.whl", hash = "sha256:a9ca696eb02e5c02a8afd872ada510eba9b7fe6e68b9572c2e9a9b1941e31e2e", size = 143975, upload-time = "2026-09-15T19:32:16.416Z" }, + { url = "https://files.pythonhosted.org/packages/d7/a8/e6c1be0e6761d0f2d10bbf33a3e1e02b99dc83874d92945d7b461a72481e/yarl-1.25.1-cp314-cp314-macosx_10_15_x86_64.whl", hash = "sha256:a5877f2255aab518ebe528289037699201d5dc5f045f2396cb30aa02db22f57f", size = 104018, upload-time = "2026-09-15T19:32:18.364Z" }, + { url = "https://files.pythonhosted.org/packages/6e/bb/dda344765ffd3430afe1a1c66c866a57fae67786537d4f14607df6505ac1/yarl-1.25.1-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:7a5c3115595995779ee21f2567035793911c3802a43c74f3fbb0314929ec67ac", size = 104156, upload-time = "2026-09-15T19:32:20.459Z" }, + { url = "https://files.pythonhosted.org/packages/e5/5f/ed1538bcd06009fe990d6d283dd7667f639e62a81e35c6d8c6ef6c08fb3c/yarl-1.25.1-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:77e5099b99b37f3cf79c246998ca9f7313a78054cd1809ec46bc1afad47e1c4c", size = 116025, upload-time = "2026-09-15T19:32:22.766Z" }, + { url = "https://files.pythonhosted.org/packages/a2/af/2185daf56b99830d3356ecfada46faaa49945de6626e842b7728088d4980/yarl-1.25.1-cp314-cp314-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:6efaf45df6a849cef613a03a94c845647456662f85438c886bb67a9c027c8c2c", size = 106985, upload-time = "2026-09-15T19:32:24.749Z" }, + { url = "https://files.pythonhosted.org/packages/c1/65/bc1ae564fb4b04a30b6a8f250e787772581c57e4c3d5cf07ac3359de3103/yarl-1.25.1-cp314-cp314-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:d5f90e44653c4e0f78501ed9bb7d3fce835a8d62b7c6ed0cb16557534087e743", size = 123030, upload-time = "2026-09-15T19:32:27.084Z" }, + { url = "https://files.pythonhosted.org/packages/6a/3e/e2afcde10d74e53b3fa889960991efb3019beda2b1682a01de720a302056/yarl-1.25.1-cp314-cp314-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:632da579b2d879f6bad20f2cfa35ded1efe2f4f77f8abb26a6234a5b236acd2f", size = 126765, upload-time = "2026-09-15T19:32:29.332Z" }, + { url = "https://files.pythonhosted.org/packages/a2/be/415b00c0fe5a0615b062a456b26623d7ec91c2bee20faea1a14045aa0469/yarl-1.25.1-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:30eec96e8a91bd588ce897c9543f6d5d8d34b28fbcba28a4dedf20ebeae9fe57", size = 117199, upload-time = "2026-09-15T19:32:31.49Z" }, + { url = "https://files.pythonhosted.org/packages/97/27/3d8c63ddd3e8bcfd033748ab93876678ce59bacd66e4cb1ed851c9c5b37e/yarl-1.25.1-cp314-cp314-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:12b6bc4906e11f5e1a1cdcb12296e7afbd366c783cc8073403cd2fb74334e453", size = 115187, upload-time = "2026-09-15T19:32:34.137Z" }, + { url = "https://files.pythonhosted.org/packages/39/b7/7a81d0be1a502a26a0d4326c6f2ecb736c824f570ea1c6529f2b0b227b50/yarl-1.25.1-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:9d6ed3d17bccce4c05343e1ca8da13bc5c02c812a4e7282ddd05e8769322d3fc", size = 116085, upload-time = "2026-09-15T19:32:36.438Z" }, + { url = "https://files.pythonhosted.org/packages/f0/69/39fff459916aa0fab42215dc47b759586fd80f94aa56dfc4a7c15ba6e0dc/yarl-1.25.1-cp314-cp314-musllinux_1_2_armv7l.whl", hash = "sha256:f38a70074041d3b7e138e452799f5174198bae5bd5ab2000917badf403908c5f", size = 107996, upload-time = "2026-09-15T19:32:38.959Z" }, + { url = "https://files.pythonhosted.org/packages/c0/39/80b9a55a3335590451d9ecf3eb593a8c635351f4c905ef056d7e8a8fd9e7/yarl-1.25.1-cp314-cp314-musllinux_1_2_ppc64le.whl", hash = "sha256:4ca89e4e21854ed27ec753297dde84b16c9f8e53b14a4866fb44457d643c19f8", size = 122549, upload-time = "2026-09-15T19:32:41.151Z" }, + { url = "https://files.pythonhosted.org/packages/42/7d/a179c6757818bb59372a4adafd09f7f26a3b4a0f04c3ae404b544c0b0c82/yarl-1.25.1-cp314-cp314-musllinux_1_2_riscv64.whl", hash = "sha256:1ab7618921a93767387a4b83776f751588f5b5ae9bb5bc96620e2e2e00bca868", size = 115107, upload-time = "2026-09-15T19:32:43.072Z" }, + { url = "https://files.pythonhosted.org/packages/32/2b/a773ac867e4ab53a98ed98e5cefe3bae31e6f550252ca9d1de266f1a40c5/yarl-1.25.1-cp314-cp314-musllinux_1_2_s390x.whl", hash = "sha256:0ae12ff2b805fa02c4dab838005caef735e39986322698c48588d3beacb65c62", size = 120666, upload-time = "2026-09-15T19:32:45.061Z" }, + { url = "https://files.pythonhosted.org/packages/bc/41/52be6505e85b0f76b4f85b01b5de7e06a0512201abc2c95e14e099549174/yarl-1.25.1-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:90c30ed53546da833c700115c0064c22120d1b1560f474699fd31f22dd668233", size = 117505, upload-time = "2026-09-15T19:32:47.177Z" }, + { url = "https://files.pythonhosted.org/packages/f5/01/349c0386caedbbe488d519f252df54efac8a1459282d466c474bdd84a620/yarl-1.25.1-cp314-cp314-win_amd64.whl", hash = "sha256:acfa7e22aa6c6e7a5996a41d275bfa01efa7ea56ab890590280e9063e2cf5c1b", size = 103446, upload-time = "2026-09-15T19:32:49.615Z" }, + { url = "https://files.pythonhosted.org/packages/5c/f0/8ec63180f77912f0dc4e5a42760cb8c08d20da1d5ace3578a01b84d1f3d8/yarl-1.25.1-cp314-cp314-win_arm64.whl", hash = "sha256:8e7d98cdbb6d71e726f7d525952867096053d1f290dd4e3c50d7d313a136f414", size = 99159, upload-time = "2026-09-15T19:32:51.686Z" }, + { url = "https://files.pythonhosted.org/packages/47/7d/92d2220d6886b70ab1ed8579533ac2af2dfac716d5d929001daff7986df9/yarl-1.25.1-cp314-cp314t-macosx_10_15_universal2.whl", hash = "sha256:d21f0fa80a02d05299207eeaafef345d812ace96d5306e4ef265e1d419a615fa", size = 150071, upload-time = "2026-09-15T19:32:53.911Z" }, + { url = "https://files.pythonhosted.org/packages/64/fc/b245e448124bcda9340df38e3553fa222b50260fca027a84095e9bd8642d/yarl-1.25.1-cp314-cp314t-macosx_10_15_x86_64.whl", hash = "sha256:17c9877a89fb6e2bca6f9087eb24cd7fb434653946ef5075e470d23d49b52287", size = 106780, upload-time = "2026-09-15T19:32:56.443Z" }, + { url = "https://files.pythonhosted.org/packages/51/e2/9a6ce2e334ebf218a30335ae76fb1696459430d42f733b8cb0d7d65b84d3/yarl-1.25.1-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:29273edf1530e397bd07cb784db1fbe0d2590b77569f2e24679a9c0a2d763b94", size = 107361, upload-time = "2026-09-15T19:32:58.827Z" }, + { url = "https://files.pythonhosted.org/packages/ed/70/66e8c76b569b450d16e190f15071c916c3df70b0e33927e415ac497cf0c2/yarl-1.25.1-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:b7abffdf37af1cec6a2ad69b827aa84320db5894791bc8ed932dc93fb274b7e9", size = 114396, upload-time = "2026-09-15T19:33:02.24Z" }, + { url = "https://files.pythonhosted.org/packages/73/23/0d82838a05c57fdc05bc8b66e8c92dcc0df15e27463a5f163142d521c682/yarl-1.25.1-cp314-cp314t-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:2239a02249d9326655419e0168a28ca9008938eaab31dc29fc875c217927a6c0", size = 104882, upload-time = "2026-09-15T19:33:04.494Z" }, + { url = "https://files.pythonhosted.org/packages/86/d4/ea08615c4edaa6049a13a2f1128944d068d1893abda7d708d4d7ea01599a/yarl-1.25.1-cp314-cp314t-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:664ec6a520b74a1df2810666eb67695fcb77fa663e6ea0a25aaf2e529cb24dfa", size = 119485, upload-time = "2026-09-15T19:33:06.583Z" }, + { url = "https://files.pythonhosted.org/packages/1a/82/0898bdce9b1ae403b308b9c733d0d24af4a3464270c2c081f457b16c3e0d/yarl-1.25.1-cp314-cp314t-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:4f1c91f5a5980a937ff8e238e98e6897e1ad74a4b1e2c0d68c73b5ffbb3f5c0b", size = 122490, upload-time = "2026-09-15T19:33:08.653Z" }, + { url = "https://files.pythonhosted.org/packages/d1/38/97d79b81c342b78246cfedb74809e68841f3198d21653e10d3232bd9c622/yarl-1.25.1-cp314-cp314t-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:7c88edaec8c349ad4c5ad4c486a3defcc4b80ceb2f074436ffa0a87caf5e76a6", size = 115336, upload-time = "2026-09-15T19:33:11.056Z" }, + { url = "https://files.pythonhosted.org/packages/8e/9d/2577896554cd310dc470adb6da0b7dd0b435cb63e2565204a7ac240e504c/yarl-1.25.1-cp314-cp314t-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:35dcbea443fafb3eece757ad4e514560ddeb6c34cfae1582c620d7b293d7feee", size = 111825, upload-time = "2026-09-15T19:33:13.204Z" }, + { url = "https://files.pythonhosted.org/packages/29/6b/7ac49d8ba84a5c4bd73415a4c949d22c749cb3762579b3d50e48019a78aa/yarl-1.25.1-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:882569ff613758cac762a457a5d72d6e211b28d4bcfea89d1d71ea942b02eac0", size = 114655, upload-time = "2026-09-15T19:33:15.553Z" }, + { url = "https://files.pythonhosted.org/packages/e5/18/e5942a16723f5b72f9b1297fd5a85a54f6300cd15c0dcb5005b90cd89156/yarl-1.25.1-cp314-cp314t-musllinux_1_2_armv7l.whl", hash = "sha256:d0f1489233a254bb3643d2f05de7d59019254d81daeca6b9162fe9edef57e0c7", size = 106395, upload-time = "2026-09-15T19:33:17.599Z" }, + { url = "https://files.pythonhosted.org/packages/7b/2d/549fa46240781513ebc47ae7eb418df428a163a2a3d644cc9cbb3ecb7846/yarl-1.25.1-cp314-cp314t-musllinux_1_2_ppc64le.whl", hash = "sha256:f41753a76f4f63927d03a0d8ba8f5ce0f2083bec29a8cfaccc55371b1564b96b", size = 119277, upload-time = "2026-09-15T19:33:19.973Z" }, + { url = "https://files.pythonhosted.org/packages/76/16/4763f78dcdc0b3b9fb3842b04afe72b9320857c6a69300c62a0eab03d119/yarl-1.25.1-cp314-cp314t-musllinux_1_2_riscv64.whl", hash = "sha256:8fb0eb4955adf0579001581f2f71a126e8781ba61bcd120f127b0401163c6c2d", size = 112504, upload-time = "2026-09-15T19:33:22.464Z" }, + { url = "https://files.pythonhosted.org/packages/ae/b4/974e3edfe0d188393ce1cb9de400111c63fe61f4eb3b772a500d84c970d1/yarl-1.25.1-cp314-cp314t-musllinux_1_2_s390x.whl", hash = "sha256:a1e32763e641a1566507d90a8d3b19bfc3cc04a9d4e5ae3e32189874ed4b58a3", size = 116243, upload-time = "2026-09-15T19:33:24.788Z" }, + { url = "https://files.pythonhosted.org/packages/b0/aa/157b940428da80c104ca09666a740e51c94963df65d5b112e06b52e4d7a8/yarl-1.25.1-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:65b5b2066651b7432d389e9799d979c703bcc6ef44266bb8153ef54e91e4aab3", size = 115822, upload-time = "2026-09-15T19:33:26.886Z" }, + { url = "https://files.pythonhosted.org/packages/7e/af/19fbdce41412e1b96825544cc52cd7029d3724655d0988237972f078bd29/yarl-1.25.1-cp314-cp314t-win_amd64.whl", hash = "sha256:734f6e5400352ac4254456003d462866c684703570929cff7a7bde015d0cb371", size = 107386, upload-time = "2026-09-15T19:33:29.009Z" }, + { url = "https://files.pythonhosted.org/packages/2a/99/f6431c8968e89be608d74b28ae2d024521b2953f27dd44e0dece5e04f67a/yarl-1.25.1-cp314-cp314t-win_arm64.whl", hash = "sha256:287e99ff5aa4dc1c7630bfc683ded6f106d756c99dec432a2d7f197a784f51c6", size = 102094, upload-time = "2026-09-15T19:33:31.151Z" }, + { url = "https://files.pythonhosted.org/packages/c7/3b/4f51eab40c2eabea6c3d5b121dff4b8988dc35087732ffede12d2be8b8dd/yarl-1.25.1-cp315-cp315-macosx_10_15_universal2.whl", hash = "sha256:9b1bdaae98bc016825dd3c9d8ee1832f829b3341f9cc6ebd1a1b0a7fef7367cc", size = 143875, upload-time = "2026-09-15T19:33:33.52Z" }, + { url = "https://files.pythonhosted.org/packages/41/05/bbd58fc063f5f299a883f810760b265ca26c8167c91cb9a494d0fe2387e1/yarl-1.25.1-cp315-cp315-macosx_10_15_x86_64.whl", hash = "sha256:e7011b8fb8c4054bf0c12e5edc6cd83778b0028e99ce59b18586ed036f92cfdc", size = 104028, upload-time = "2026-09-15T19:33:36.22Z" }, + { url = "https://files.pythonhosted.org/packages/12/ee/2fba0aecb52e7020e189f684148783aa0b9cfa3b3bfb0b400646eef70ad4/yarl-1.25.1-cp315-cp315-macosx_11_0_arm64.whl", hash = "sha256:f074e8d4aa0a5798920ddb6de3d08b228c614ff3724c3e8bd7577f4bafea867b", size = 104041, upload-time = "2026-09-15T19:33:38.86Z" }, + { url = "https://files.pythonhosted.org/packages/38/35/884beab53ed88c7247d1671972b5ef116f7351fe0c7e6de8c3558372cb16/yarl-1.25.1-cp315-cp315-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:7d42e7e3ca399555578b4d617e3a6ecf13371b3743a115995fa010c7bf341459", size = 116018, upload-time = "2026-09-15T19:33:44.265Z" }, + { url = "https://files.pythonhosted.org/packages/e2/cc/1a91b685afb55cc18608443ace95280e96e263a97565811732b6788d3269/yarl-1.25.1-cp315-cp315-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:aa4ed3dd308548f9e707d9caaf005d2d7f8c1e7868f858dfeb47fe76e16b391d", size = 107033, upload-time = "2026-09-15T19:33:46.45Z" }, + { url = "https://files.pythonhosted.org/packages/c5/c1/58b379fcb1d68d907b7fcf75200c44321896509b2a6a74abbb4b19d864d2/yarl-1.25.1-cp315-cp315-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:42a66563d8cc056ee32e6191e05097a7b2b3bc302e0bc3133daf8710eb18bd26", size = 123257, upload-time = "2026-09-15T19:33:48.631Z" }, + { url = "https://files.pythonhosted.org/packages/d7/2d/1fe96cf5c2aeab10095e48f38585cf5a8451fb7253234822398e52aa5336/yarl-1.25.1-cp315-cp315-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:98d370568f393215d605304cdb77b3d5539bd192c75b623c7304c42c8d6d8273", size = 126745, upload-time = "2026-09-15T19:33:50.999Z" }, + { url = "https://files.pythonhosted.org/packages/ad/60/8674394ce43f4dadae573a1d6f451716438e9eab7d7fe8d643c673a32d85/yarl-1.25.1-cp315-cp315-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:23bf5b403c879a54964e0feac7285688e04bb220074878d737d331522da0a5bf", size = 117255, upload-time = "2026-09-15T19:33:53.456Z" }, + { url = "https://files.pythonhosted.org/packages/2f/72/0faa30e02605d56127d42bb987dcc97da3863b7bf70b9bfbf5f739c05e30/yarl-1.25.1-cp315-cp315-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:d45673badd08456d0340e9364eddafe1c53a9d2896424294de4d7dd71ad3ee57", size = 115166, upload-time = "2026-09-15T19:33:55.669Z" }, + { url = "https://files.pythonhosted.org/packages/8c/90/9a46eac564c437e128285c5c1d7bb385d268394e9209d84f6bf4a14471ef/yarl-1.25.1-cp315-cp315-musllinux_1_2_aarch64.whl", hash = "sha256:0136d640dfa9b0523853e411430a99f8a91eca85774c6420285a33b755bc6de3", size = 116082, upload-time = "2026-09-15T19:33:57.78Z" }, + { url = "https://files.pythonhosted.org/packages/ad/38/4b1a686a3758878f93d2f1ea943f5a165f3555769cd16e761cfd0efdca17/yarl-1.25.1-cp315-cp315-musllinux_1_2_armv7l.whl", hash = "sha256:59ba3a6e1aa8cfe5adf4bd270fd965db21955401b7ca6f1696010c55ed4daec2", size = 108048, upload-time = "2026-09-15T19:34:00.25Z" }, + { url = "https://files.pythonhosted.org/packages/da/14/f348eb967f31a58348612a2b93bd8a2ab664548e2b5e879cac7f592f7201/yarl-1.25.1-cp315-cp315-musllinux_1_2_ppc64le.whl", hash = "sha256:87796fedc3ba97ec14fab55acb48584276e6c1e4c1e89c422bda62c838e754a9", size = 122775, upload-time = "2026-09-15T19:34:02.455Z" }, + { url = "https://files.pythonhosted.org/packages/ab/e9/4f7b79700f88cb9e8bb66f8b54f9bce1844c013a2c39fdc47112e9334c95/yarl-1.25.1-cp315-cp315-musllinux_1_2_riscv64.whl", hash = "sha256:bd0912757081f89b107d6c00b2ff8a194401b0b87eadcf4481de2b865a8fd44f", size = 115096, upload-time = "2026-09-15T19:34:05.283Z" }, + { url = "https://files.pythonhosted.org/packages/cf/37/f9cb020331997d3eb887bd28d5410ecfd3d80bf163c23d7cec490d78dade/yarl-1.25.1-cp315-cp315-musllinux_1_2_s390x.whl", hash = "sha256:b51c159a9794633f5e0db7ecec7b2b6e3734eca1f5d17dc989ff3552a43ff78b", size = 120655, upload-time = "2026-09-15T19:34:07.382Z" }, + { url = "https://files.pythonhosted.org/packages/12/83/52fceb22891a41f168db7ec22fd1d81e06b6a0b8d9f70921bd3e785defd0/yarl-1.25.1-cp315-cp315-musllinux_1_2_x86_64.whl", hash = "sha256:319e070a01db9920fb63761843f96a104c8e2b9427266731810dc1e22595b17c", size = 117488, upload-time = "2026-09-15T19:34:09.988Z" }, + { url = "https://files.pythonhosted.org/packages/f5/5c/ce6c4ff1247fcbe4b33d462c23a097106d909b173fde7042bc52290466e2/yarl-1.25.1-cp315-cp315-win_amd64.whl", hash = "sha256:a2059a2d891bd156bc5184e7ab7a56e78a84dfcfdeac8c501b552533ad1c36ee", size = 103434, upload-time = "2026-09-15T19:34:12.56Z" }, + { url = "https://files.pythonhosted.org/packages/3c/a1/766a906b0704fb26d52b19dc22bed48a8ba0544203b70dcf44da350e8194/yarl-1.25.1-cp315-cp315-win_arm64.whl", hash = "sha256:a78b50b4f7918a3de71105d5c0b93bbc57bb8339a4d03a9dfd449f9068e76f3d", size = 99155, upload-time = "2026-09-15T19:34:15.132Z" }, + { url = "https://files.pythonhosted.org/packages/bd/d3/a1d09b32cb6ab14f66b44939f5b4255b8b9e747aef3974af1d5d80ccc2fd/yarl-1.25.1-cp315-cp315t-macosx_10_15_universal2.whl", hash = "sha256:b5402a340723fa7da00b5cff987ddab61276be6d11251ea71ae02bcac54890d8", size = 149284, upload-time = "2026-09-15T19:34:17.452Z" }, + { url = "https://files.pythonhosted.org/packages/7f/3b/fe554d879692650bca70bfbc0df124e82e4d2bb7456f698c7756f1279a96/yarl-1.25.1-cp315-cp315t-macosx_10_15_x86_64.whl", hash = "sha256:eda19ea5ee88742f47a2340816e6f2d40b53bed3ab5b69794769f36af9f35bb4", size = 106399, upload-time = "2026-09-15T19:34:21.474Z" }, + { url = "https://files.pythonhosted.org/packages/e1/4b/e7af56177ac8d40094c82d7728224c0b8472157d50d362e5fb3b014b2bc8/yarl-1.25.1-cp315-cp315t-macosx_11_0_arm64.whl", hash = "sha256:75baa6cf9b6d1c52f3e111a130e202fd8cf0a5b3a066c3f73d615e885092e4ec", size = 106968, upload-time = "2026-09-15T19:34:23.619Z" }, + { url = "https://files.pythonhosted.org/packages/da/4f/2df41fd738d46f23ef829ae8b4468d94bb6070038fc6dfab6165ed44fea8/yarl-1.25.1-cp315-cp315t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:dbcef5a9119ef653653132cccaf999b30a0af6f33bb0a4ba80bec30056868487", size = 114717, upload-time = "2026-09-15T19:34:25.879Z" }, + { url = "https://files.pythonhosted.org/packages/69/ea/002b66df53bbd1aed1c23358ff99c9bdc744fe3f4d2740e1b2fdd7192885/yarl-1.25.1-cp315-cp315t-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:7efc9f082dfed77c316edffa9deb52888e1bc6789171887cc1f68e06d65465c8", size = 105198, upload-time = "2026-09-15T19:34:28.204Z" }, + { url = "https://files.pythonhosted.org/packages/b1/7c/95c8bc0c8f97d71e59c94525ad60d76f5c57d3f2820f08137ca8b9f0542a/yarl-1.25.1-cp315-cp315t-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:fe01645169a2112aa1d4ebc3e4c5f029c5c8f97adfc32e5d37c993b39a994d75", size = 120271, upload-time = "2026-09-15T19:34:30.5Z" }, + { url = "https://files.pythonhosted.org/packages/5d/7a/6fe9da56ec77927baa669fd86c39c567ce6205bab53d581082c6744c8ae7/yarl-1.25.1-cp315-cp315t-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:d1c557dfd5e3db046053a0bdc72261ade790ebe8e2c7a41b36b0ca1f14cb95f3", size = 123572, upload-time = "2026-09-15T19:34:32.73Z" }, + { url = "https://files.pythonhosted.org/packages/8b/83/35f222d17fa70a14c7c74fdf112ccf5515e0c2a87082b1f9b99f7693bf57/yarl-1.25.1-cp315-cp315t-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:8ce4d6ccafb33d39bd78444612d14938ead674c25702ded2ee9c54a47735d225", size = 115228, upload-time = "2026-09-15T19:34:35.344Z" }, + { url = "https://files.pythonhosted.org/packages/da/6f/fbaaf619423578a7d898d0f226ae47bc1906c293865c416d83c17b828b0e/yarl-1.25.1-cp315-cp315t-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:80a063f8297fc796296f00f100be520f209b23dc98f93ce8eba6ee7122598209", size = 111618, upload-time = "2026-09-15T19:34:37.656Z" }, + { url = "https://files.pythonhosted.org/packages/ba/78/7383278f1b3cf8e0496bd95b3281a7b09b89217b6b428db24c6b99b3deca/yarl-1.25.1-cp315-cp315t-musllinux_1_2_aarch64.whl", hash = "sha256:7cb414a73e21a7ab58254926073f2930cb22f5b4314ea4260a687e2b3fd4dce3", size = 114839, upload-time = "2026-09-15T19:34:40.099Z" }, + { url = "https://files.pythonhosted.org/packages/62/49/5506e5b6d29aab91bd845cc9016d88c3d3f81b81bc242b8100bdd5737825/yarl-1.25.1-cp315-cp315t-musllinux_1_2_armv7l.whl", hash = "sha256:85a18376073f8a39aa07be34f9fc77e2869aa72c55c441efdd2cf79a0407504d", size = 106212, upload-time = "2026-09-15T19:34:42.768Z" }, + { url = "https://files.pythonhosted.org/packages/46/8a/19877c193b7c5929f4b07118c18bbe390f3fadd0f59dd98c0cd12b31fa5c/yarl-1.25.1-cp315-cp315t-musllinux_1_2_ppc64le.whl", hash = "sha256:77716e245c90f058466a05e6a465bb8600f767a8f4b18b4d40f3aff958e5f73c", size = 119985, upload-time = "2026-09-15T19:34:44.976Z" }, + { url = "https://files.pythonhosted.org/packages/4e/6c/0a46fbbf9ecbcbd0cc20d2193394254b9e19817f22c814aab60f99847400/yarl-1.25.1-cp315-cp315t-musllinux_1_2_riscv64.whl", hash = "sha256:1e80dcf1446e1b080b1932b0d103c464a04112f5bc31f0f983ad418172063cde", size = 112081, upload-time = "2026-09-15T19:34:47.45Z" }, + { url = "https://files.pythonhosted.org/packages/ef/30/93f5d471230c74ccd06255d0842739f86551f937f9e63a5e947853c6244a/yarl-1.25.1-cp315-cp315t-musllinux_1_2_s390x.whl", hash = "sha256:bdc8d8b8c22e9e43ac68316b5e6cf083dec537f4ec213cb4aa967b583bc3fa64", size = 116995, upload-time = "2026-09-15T19:34:49.972Z" }, + { url = "https://files.pythonhosted.org/packages/2b/80/c386593035ee3f9c6c6af0847b5578f2830c674794a9d7701b744a3ebd42/yarl-1.25.1-cp315-cp315t-musllinux_1_2_x86_64.whl", hash = "sha256:dfbf531053a0935f2e871bcd4753f90313688772ff8c017f5ea402e315a78c1f", size = 115570, upload-time = "2026-09-15T19:34:52.628Z" }, + { url = "https://files.pythonhosted.org/packages/38/02/eef443559563ef8f2e10469387b8b1e97cb5efee95b288a56da60801f7ee/yarl-1.25.1-cp315-cp315t-win_amd64.whl", hash = "sha256:b13b88747769537f3d32e89e3a735da10c0a9e35d7322928c701b5f93d3afffd", size = 106811, upload-time = "2026-09-15T19:34:54.935Z" }, + { url = "https://files.pythonhosted.org/packages/88/91/41e284ca2cf5211e05dae031d126a3668aea88fa759df56e7e35c6ad25ba/yarl-1.25.1-cp315-cp315t-win_arm64.whl", hash = "sha256:783dd1467083f4d3f7722ad6a313f24c173e7571372738fcb7a6e6d1ba48df25", size = 101804, upload-time = "2026-09-15T19:34:57.231Z" }, + { url = "https://files.pythonhosted.org/packages/54/22/318c7980066769c6bcd9221ed2248294f5698811da099013098c670565ed/yarl-1.25.1-py3-none-any.whl", hash = "sha256:681c758b0490f9e96b78e5fa8e8dc6e648e9185bb6eaebe73183c33ea0c445f3", size = 63617, upload-time = "2026-09-15T19:34:59.616Z" }, +]