opencode-python-sdk 0.2.2__py3-none-any.whl → 0.2.3__py3-none-any.whl

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

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 @@ __all__ = ["AgentResource", "AsyncAgentResource"]
 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 @@ class AgentResource(SyncAPIResource):
         )
 
 
+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 @@ class AsyncAgentResource(AsyncAPIResource):
                 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)

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 @@ __all__ = ["CommandResource", "AsyncCommandResource"]
 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 @@ class CommandResource(SyncAPIResource):
         )
 
 
+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 @@ class AsyncCommandResource(AsyncAPIResource):
                 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)

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 @@ __all__ = ["ConfigResource", "AsyncConfigResource"]
 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 @@ class ConfigResource(SyncAPIResource):
 
         ``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 @@ class AsyncConfigResource(AsyncAPIResource):
 
         ``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)