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

opencode/resources/experimental.py

@@ -14,6 +14,12 @@ from .._base_client import RequestOptions
 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 @@ __all__ = ["ExperimentalResource", "AsyncExperimentalResource"]
 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 @@ class ExperimentalPersistentPtyResource(PersistentPtyAttachMixin):
 
         ``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 @@ class ExperimentalPersistentPtyResource(PersistentPtyAttachMixin):
 
         ``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 @@ class ExperimentalPersistentPtyResource(PersistentPtyAttachMixin):
         )
 
 
+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 @@ class ExperimentalResource(SyncAPIResource):
         """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 @@ class AsyncExperimentalPersistentPtyResource(AsyncPersistentPtyAttachMixin):
 
         ``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 @@ class AsyncExperimentalPersistentPtyResource(AsyncPersistentPtyAttachMixin):
 
         ``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 @@ class AsyncExperimentalPersistentPtyResource(AsyncPersistentPtyAttachMixin):
         )
 
 
+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)

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)