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

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

opencode/resources/debug.py

@@ -11,6 +11,12 @@ 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 +31,16 @@ __all__ = ["DebugResource", "AsyncDebugResource"]
 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 @@ class DebugLocationResource(SyncAPIResource):
 
         ``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 @@ class DebugResource(SyncAPIResource):
         """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 @@ class AsyncDebugLocationResource(AsyncAPIResource):
 
         ``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)

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