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

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

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

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