raccoonai 0.1.0a7__py3-none-any.whl → 0.1.0a8__py3-none-any.whl

raccoonai/_client.py

@@ -24,7 +24,7 @@ from ._utils import (
     get_async_library,
 )
 from ._version import __version__
-from .resources import lam, fleet
+from .resources import lam, fleet, extensions
 from ._streaming import Stream as Stream, AsyncStream as AsyncStream
 from ._exceptions import APIStatusError, RaccoonAIError
 from ._base_client import (
@@ -32,6 +32,7 @@ from ._base_client import (
     SyncAPIClient,
     AsyncAPIClient,
 )
+from .resources.tail import tail
 
 __all__ = [
     "ENVIRONMENTS",
@@ -54,7 +55,9 @@ ENVIRONMENTS: Dict[str, str] = {
 
 class RaccoonAI(SyncAPIClient):
     lam: lam.LamResource
+    tail: tail.TailResource
     fleet: fleet.FleetResource
+    extensions: extensions.ExtensionsResource
     with_raw_response: RaccoonAIWithRawResponse
     with_streaming_response: RaccoonAIWithStreamedResponse
 
@@ -137,7 +140,9 @@ class RaccoonAI(SyncAPIClient):
         )
 
         self.lam = lam.LamResource(self)
+        self.tail = tail.TailResource(self)
         self.fleet = fleet.FleetResource(self)
+        self.extensions = extensions.ExtensionsResource(self)
         self.with_raw_response = RaccoonAIWithRawResponse(self)
         self.with_streaming_response = RaccoonAIWithStreamedResponse(self)
 
@@ -250,7 +255,9 @@ class RaccoonAI(SyncAPIClient):
 
 class AsyncRaccoonAI(AsyncAPIClient):
     lam: lam.AsyncLamResource
+    tail: tail.AsyncTailResource
     fleet: fleet.AsyncFleetResource
+    extensions: extensions.AsyncExtensionsResource
     with_raw_response: AsyncRaccoonAIWithRawResponse
     with_streaming_response: AsyncRaccoonAIWithStreamedResponse
 
@@ -333,7 +340,9 @@ class AsyncRaccoonAI(AsyncAPIClient):
         )
 
         self.lam = lam.AsyncLamResource(self)
+        self.tail = tail.AsyncTailResource(self)
         self.fleet = fleet.AsyncFleetResource(self)
+        self.extensions = extensions.AsyncExtensionsResource(self)
         self.with_raw_response = AsyncRaccoonAIWithRawResponse(self)
         self.with_streaming_response = AsyncRaccoonAIWithStreamedResponse(self)
 
@@ -447,25 +456,33 @@ class AsyncRaccoonAI(AsyncAPIClient):
 class RaccoonAIWithRawResponse:
     def __init__(self, client: RaccoonAI) -> None:
         self.lam = lam.LamResourceWithRawResponse(client.lam)
+        self.tail = tail.TailResourceWithRawResponse(client.tail)
         self.fleet = fleet.FleetResourceWithRawResponse(client.fleet)
+        self.extensions = extensions.ExtensionsResourceWithRawResponse(client.extensions)
 
 
 class AsyncRaccoonAIWithRawResponse:
     def __init__(self, client: AsyncRaccoonAI) -> None:
         self.lam = lam.AsyncLamResourceWithRawResponse(client.lam)
+        self.tail = tail.AsyncTailResourceWithRawResponse(client.tail)
         self.fleet = fleet.AsyncFleetResourceWithRawResponse(client.fleet)
+        self.extensions = extensions.AsyncExtensionsResourceWithRawResponse(client.extensions)
 
 
 class RaccoonAIWithStreamedResponse:
     def __init__(self, client: RaccoonAI) -> None:
         self.lam = lam.LamResourceWithStreamingResponse(client.lam)
+        self.tail = tail.TailResourceWithStreamingResponse(client.tail)
         self.fleet = fleet.FleetResourceWithStreamingResponse(client.fleet)
+        self.extensions = extensions.ExtensionsResourceWithStreamingResponse(client.extensions)
 
 
 class AsyncRaccoonAIWithStreamedResponse:
     def __init__(self, client: AsyncRaccoonAI) -> None:
         self.lam = lam.AsyncLamResourceWithStreamingResponse(client.lam)
+        self.tail = tail.AsyncTailResourceWithStreamingResponse(client.tail)
         self.fleet = fleet.AsyncFleetResourceWithStreamingResponse(client.fleet)
+        self.extensions = extensions.AsyncExtensionsResourceWithStreamingResponse(client.extensions)
 
 
 Client = RaccoonAI

raccoonai/_files.py

@@ -34,7 +34,7 @@ def assert_is_file_content(obj: object, *, key: str | None = None) -> None:
     if not is_file_content(obj):
         prefix = f"Expected entry at `{key}`" if key is not None else f"Expected file input `{obj!r}`"
         raise RuntimeError(
-            f"{prefix} to be bytes, an io.IOBase instance, PathLike or a tuple but received {type(obj)} instead."
+            f"{prefix} to be bytes, an io.IOBase instance, PathLike or a tuple but received {type(obj)} instead. See https://github.com/raccoonaihq/raccoonai-python/tree/main#file-uploads"
         ) from None
 
 

raccoonai/_version.py

@@ -1,4 +1,4 @@
 # File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
 
 __title__ = "raccoonai"
-__version__ = "0.1.0-alpha.7"  # x-release-please-version
+__version__ = "0.1.0-alpha.8"  # x-release-please-version

raccoonai/resources/__init__.py

@@ -8,6 +8,14 @@ from .lam import (
     LamResourceWithStreamingResponse,
     AsyncLamResourceWithStreamingResponse,
 )
+from .tail import (
+    TailResource,
+    AsyncTailResource,
+    TailResourceWithRawResponse,
+    AsyncTailResourceWithRawResponse,
+    TailResourceWithStreamingResponse,
+    AsyncTailResourceWithStreamingResponse,
+)
 from .fleet import (
     FleetResource,
     AsyncFleetResource,
@@ -16,6 +24,14 @@ from .fleet import (
     FleetResourceWithStreamingResponse,
     AsyncFleetResourceWithStreamingResponse,
 )
+from .extensions import (
+    ExtensionsResource,
+    AsyncExtensionsResource,
+    ExtensionsResourceWithRawResponse,
+    AsyncExtensionsResourceWithRawResponse,
+    ExtensionsResourceWithStreamingResponse,
+    AsyncExtensionsResourceWithStreamingResponse,
+)
 
 __all__ = [
     "LamResource",
@@ -24,10 +40,22 @@ __all__ = [
     "AsyncLamResourceWithRawResponse",
     "LamResourceWithStreamingResponse",
     "AsyncLamResourceWithStreamingResponse",
+    "TailResource",
+    "AsyncTailResource",
+    "TailResourceWithRawResponse",
+    "AsyncTailResourceWithRawResponse",
+    "TailResourceWithStreamingResponse",
+    "AsyncTailResourceWithStreamingResponse",
     "FleetResource",
     "AsyncFleetResource",
     "FleetResourceWithRawResponse",
     "AsyncFleetResourceWithRawResponse",
     "FleetResourceWithStreamingResponse",
     "AsyncFleetResourceWithStreamingResponse",
+    "ExtensionsResource",
+    "AsyncExtensionsResource",
+    "ExtensionsResourceWithRawResponse",
+    "AsyncExtensionsResourceWithRawResponse",
+    "ExtensionsResourceWithStreamingResponse",
+    "AsyncExtensionsResourceWithStreamingResponse",
 ]

raccoonai/resources/extensions.py

@@ -0,0 +1,400 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from __future__ import annotations
+
+from typing import Mapping, cast
+
+import httpx
+
+from ..types import extension_upload_params
+from .._types import NOT_GIVEN, Body, Query, Headers, NotGiven, FileTypes
+from .._utils import (
+    extract_files,
+    maybe_transform,
+    deepcopy_minimal,
+    async_maybe_transform,
+)
+from .._compat import cached_property
+from .._resource import SyncAPIResource, AsyncAPIResource
+from .._response import (
+    to_raw_response_wrapper,
+    to_streamed_response_wrapper,
+    async_to_raw_response_wrapper,
+    async_to_streamed_response_wrapper,
+)
+from .._base_client import make_request_options
+from ..types.extension_all_response import ExtensionAllResponse
+from ..types.extension_get_response import ExtensionGetResponse
+from ..types.extension_upload_response import ExtensionUploadResponse
+
+__all__ = ["ExtensionsResource", "AsyncExtensionsResource"]
+
+
+class ExtensionsResource(SyncAPIResource):
+    @cached_property
+    def with_raw_response(self) -> ExtensionsResourceWithRawResponse:
+        """
+        This property can be used as a prefix for any HTTP method call to return
+        the raw response object instead of the parsed content.
+
+        For more information, see https://www.github.com/raccoonaihq/raccoonai-python#accessing-raw-response-data-eg-headers
+        """
+        return ExtensionsResourceWithRawResponse(self)
+
+    @cached_property
+    def with_streaming_response(self) -> ExtensionsResourceWithStreamingResponse:
+        """
+        An alternative to `.with_raw_response` that doesn't eagerly read the response body.
+
+        For more information, see https://www.github.com/raccoonaihq/raccoonai-python#with_streaming_response
+        """
+        return ExtensionsResourceWithStreamingResponse(self)
+
+    def delete(
+        self,
+        extension_id: str,
+        *,
+        # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs.
+        # The extra values given here take precedence over values defined on the client or passed to this method.
+        extra_headers: Headers | None = None,
+        extra_query: Query | None = None,
+        extra_body: Body | None = None,
+        timeout: float | httpx.Timeout | None | NotGiven = NOT_GIVEN,
+    ) -> object:
+        """
+        Delete Extension Endpoint
+
+        Args:
+          extension_id: The ID of the extension to delete
+
+          extra_headers: Send extra headers
+
+          extra_query: Add additional query parameters to the request
+
+          extra_body: Add additional JSON properties to the request
+
+          timeout: Override the client-level default timeout for this request, in seconds
+        """
+        if not extension_id:
+            raise ValueError(f"Expected a non-empty value for `extension_id` but received {extension_id!r}")
+        return self._delete(
+            f"/extensions/{extension_id}",
+            options=make_request_options(
+                extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
+            ),
+            cast_to=object,
+        )
+
+    def all(
+        self,
+        *,
+        # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs.
+        # The extra values given here take precedence over values defined on the client or passed to this method.
+        extra_headers: Headers | None = None,
+        extra_query: Query | None = None,
+        extra_body: Body | None = None,
+        timeout: float | httpx.Timeout | None | NotGiven = NOT_GIVEN,
+    ) -> ExtensionAllResponse:
+        """List Extensions Endpoint"""
+        return self._get(
+            "/extensions",
+            options=make_request_options(
+                extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
+            ),
+            cast_to=ExtensionAllResponse,
+        )
+
+    def get(
+        self,
+        extension_id: str,
+        *,
+        # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs.
+        # The extra values given here take precedence over values defined on the client or passed to this method.
+        extra_headers: Headers | None = None,
+        extra_query: Query | None = None,
+        extra_body: Body | None = None,
+        timeout: float | httpx.Timeout | None | NotGiven = NOT_GIVEN,
+    ) -> ExtensionGetResponse:
+        """
+        Get Extension Endpoint
+
+        Args:
+          extension_id: The ID of the extension
+
+          extra_headers: Send extra headers
+
+          extra_query: Add additional query parameters to the request
+
+          extra_body: Add additional JSON properties to the request
+
+          timeout: Override the client-level default timeout for this request, in seconds
+        """
+        if not extension_id:
+            raise ValueError(f"Expected a non-empty value for `extension_id` but received {extension_id!r}")
+        return self._get(
+            f"/extensions/{extension_id}",
+            options=make_request_options(
+                extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
+            ),
+            cast_to=ExtensionGetResponse,
+        )
+
+    def upload(
+        self,
+        *,
+        file: FileTypes,
+        # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs.
+        # The extra values given here take precedence over values defined on the client or passed to this method.
+        extra_headers: Headers | None = None,
+        extra_query: Query | None = None,
+        extra_body: Body | None = None,
+        timeout: float | httpx.Timeout | None | NotGiven = NOT_GIVEN,
+    ) -> ExtensionUploadResponse:
+        """
+        Upload Extension Endpoint
+
+        Args:
+          extra_headers: Send extra headers
+
+          extra_query: Add additional query parameters to the request
+
+          extra_body: Add additional JSON properties to the request
+
+          timeout: Override the client-level default timeout for this request, in seconds
+        """
+        body = deepcopy_minimal({"file": file})
+        files = extract_files(cast(Mapping[str, object], body), paths=[["file"]])
+        # It should be noted that the actual Content-Type header that will be
+        # sent to the server will contain a `boundary` parameter, e.g.
+        # multipart/form-data; boundary=---abc--
+        extra_headers = {"Content-Type": "multipart/form-data", **(extra_headers or {})}
+        return self._post(
+            "/extensions",
+            body=maybe_transform(body, extension_upload_params.ExtensionUploadParams),
+            files=files,
+            options=make_request_options(
+                extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
+            ),
+            cast_to=ExtensionUploadResponse,
+        )
+
+
+class AsyncExtensionsResource(AsyncAPIResource):
+    @cached_property
+    def with_raw_response(self) -> AsyncExtensionsResourceWithRawResponse:
+        """
+        This property can be used as a prefix for any HTTP method call to return
+        the raw response object instead of the parsed content.
+
+        For more information, see https://www.github.com/raccoonaihq/raccoonai-python#accessing-raw-response-data-eg-headers
+        """
+        return AsyncExtensionsResourceWithRawResponse(self)
+
+    @cached_property
+    def with_streaming_response(self) -> AsyncExtensionsResourceWithStreamingResponse:
+        """
+        An alternative to `.with_raw_response` that doesn't eagerly read the response body.
+
+        For more information, see https://www.github.com/raccoonaihq/raccoonai-python#with_streaming_response
+        """
+        return AsyncExtensionsResourceWithStreamingResponse(self)
+
+    async def delete(
+        self,
+        extension_id: str,
+        *,
+        # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs.
+        # The extra values given here take precedence over values defined on the client or passed to this method.
+        extra_headers: Headers | None = None,
+        extra_query: Query | None = None,
+        extra_body: Body | None = None,
+        timeout: float | httpx.Timeout | None | NotGiven = NOT_GIVEN,
+    ) -> object:
+        """
+        Delete Extension Endpoint
+
+        Args:
+          extension_id: The ID of the extension to delete
+
+          extra_headers: Send extra headers
+
+          extra_query: Add additional query parameters to the request
+
+          extra_body: Add additional JSON properties to the request
+
+          timeout: Override the client-level default timeout for this request, in seconds
+        """
+        if not extension_id:
+            raise ValueError(f"Expected a non-empty value for `extension_id` but received {extension_id!r}")
+        return await self._delete(
+            f"/extensions/{extension_id}",
+            options=make_request_options(
+                extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
+            ),
+            cast_to=object,
+        )
+
+    async def all(
+        self,
+        *,
+        # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs.
+        # The extra values given here take precedence over values defined on the client or passed to this method.
+        extra_headers: Headers | None = None,
+        extra_query: Query | None = None,
+        extra_body: Body | None = None,
+        timeout: float | httpx.Timeout | None | NotGiven = NOT_GIVEN,
+    ) -> ExtensionAllResponse:
+        """List Extensions Endpoint"""
+        return await self._get(
+            "/extensions",
+            options=make_request_options(
+                extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
+            ),
+            cast_to=ExtensionAllResponse,
+        )
+
+    async def get(
+        self,
+        extension_id: str,
+        *,
+        # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs.
+        # The extra values given here take precedence over values defined on the client or passed to this method.
+        extra_headers: Headers | None = None,
+        extra_query: Query | None = None,
+        extra_body: Body | None = None,
+        timeout: float | httpx.Timeout | None | NotGiven = NOT_GIVEN,
+    ) -> ExtensionGetResponse:
+        """
+        Get Extension Endpoint
+
+        Args:
+          extension_id: The ID of the extension
+
+          extra_headers: Send extra headers
+
+          extra_query: Add additional query parameters to the request
+
+          extra_body: Add additional JSON properties to the request
+
+          timeout: Override the client-level default timeout for this request, in seconds
+        """
+        if not extension_id:
+            raise ValueError(f"Expected a non-empty value for `extension_id` but received {extension_id!r}")
+        return await self._get(
+            f"/extensions/{extension_id}",
+            options=make_request_options(
+                extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
+            ),
+            cast_to=ExtensionGetResponse,
+        )
+
+    async def upload(
+        self,
+        *,
+        file: FileTypes,
+        # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs.
+        # The extra values given here take precedence over values defined on the client or passed to this method.
+        extra_headers: Headers | None = None,
+        extra_query: Query | None = None,
+        extra_body: Body | None = None,
+        timeout: float | httpx.Timeout | None | NotGiven = NOT_GIVEN,
+    ) -> ExtensionUploadResponse:
+        """
+        Upload Extension Endpoint
+
+        Args:
+          extra_headers: Send extra headers
+
+          extra_query: Add additional query parameters to the request
+
+          extra_body: Add additional JSON properties to the request
+
+          timeout: Override the client-level default timeout for this request, in seconds
+        """
+        body = deepcopy_minimal({"file": file})
+        files = extract_files(cast(Mapping[str, object], body), paths=[["file"]])
+        # It should be noted that the actual Content-Type header that will be
+        # sent to the server will contain a `boundary` parameter, e.g.
+        # multipart/form-data; boundary=---abc--
+        extra_headers = {"Content-Type": "multipart/form-data", **(extra_headers or {})}
+        return await self._post(
+            "/extensions",
+            body=await async_maybe_transform(body, extension_upload_params.ExtensionUploadParams),
+            files=files,
+            options=make_request_options(
+                extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
+            ),
+            cast_to=ExtensionUploadResponse,
+        )
+
+
+class ExtensionsResourceWithRawResponse:
+    def __init__(self, extensions: ExtensionsResource) -> None:
+        self._extensions = extensions
+
+        self.delete = to_raw_response_wrapper(
+            extensions.delete,
+        )
+        self.all = to_raw_response_wrapper(
+            extensions.all,
+        )
+        self.get = to_raw_response_wrapper(
+            extensions.get,
+        )
+        self.upload = to_raw_response_wrapper(
+            extensions.upload,
+        )
+
+
+class AsyncExtensionsResourceWithRawResponse:
+    def __init__(self, extensions: AsyncExtensionsResource) -> None:
+        self._extensions = extensions
+
+        self.delete = async_to_raw_response_wrapper(
+            extensions.delete,
+        )
+        self.all = async_to_raw_response_wrapper(
+            extensions.all,
+        )
+        self.get = async_to_raw_response_wrapper(
+            extensions.get,
+        )
+        self.upload = async_to_raw_response_wrapper(
+            extensions.upload,
+        )
+
+
+class ExtensionsResourceWithStreamingResponse:
+    def __init__(self, extensions: ExtensionsResource) -> None:
+        self._extensions = extensions
+
+        self.delete = to_streamed_response_wrapper(
+            extensions.delete,
+        )
+        self.all = to_streamed_response_wrapper(
+            extensions.all,
+        )
+        self.get = to_streamed_response_wrapper(
+            extensions.get,
+        )
+        self.upload = to_streamed_response_wrapper(
+            extensions.upload,
+        )
+
+
+class AsyncExtensionsResourceWithStreamingResponse:
+    def __init__(self, extensions: AsyncExtensionsResource) -> None:
+        self._extensions = extensions
+
+        self.delete = async_to_streamed_response_wrapper(
+            extensions.delete,
+        )
+        self.all = async_to_streamed_response_wrapper(
+            extensions.all,
+        )
+        self.get = async_to_streamed_response_wrapper(
+            extensions.get,
+        )
+        self.upload = async_to_streamed_response_wrapper(
+            extensions.upload,
+        )