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

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,
+        )

raccoonai/resources/fleet.py

@@ -2,12 +2,12 @@
 
 from __future__ import annotations
 
-from typing import Optional
+from typing import List, Optional
 from typing_extensions import Literal
 
 import httpx
 
-from ..types import fleet_create_params
+from ..types import fleet_create_params, fleet_sessions_params
 from .._types import NOT_GIVEN, Body, Query, Headers, NotGiven
 from .._utils import (
     maybe_transform,
@@ -25,6 +25,7 @@ from .._base_client import make_request_options
 from ..types.fleet_logs_response import FleetLogsResponse
 from ..types.fleet_create_response import FleetCreateResponse
 from ..types.fleet_status_response import FleetStatusResponse
+from ..types.fleet_sessions_response import FleetSessionsResponse
 from ..types.fleet_terminate_response import FleetTerminateResponse
 
 __all__ = ["FleetResource", "AsyncFleetResource"]
@@ -150,6 +151,85 @@ class FleetResource(SyncAPIResource):
             cast_to=FleetLogsResponse,
         )
 
+    def sessions(
+        self,
+        *,
+        end_time: Optional[int] | NotGiven = NOT_GIVEN,
+        execution_type: Optional[List[Literal["run", "extract", "fleet"]]] | NotGiven = NOT_GIVEN,
+        limit: Optional[int] | NotGiven = NOT_GIVEN,
+        page: Optional[int] | NotGiven = NOT_GIVEN,
+        raccoon_passcode: Optional[str] | NotGiven = NOT_GIVEN,
+        session_id: Optional[str] | NotGiven = NOT_GIVEN,
+        sort_by: Optional[Literal["timestamp", "executionTime", "taskId", "status", "executionType"]]
+        | NotGiven = NOT_GIVEN,
+        sort_order: Optional[Literal["ascend", "descend"]] | NotGiven = NOT_GIVEN,
+        start_time: Optional[int] | NotGiven = NOT_GIVEN,
+        task_id: Optional[str] | NotGiven = NOT_GIVEN,
+        # 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,
+    ) -> FleetSessionsResponse:
+        """
+        Get Sessions Endpoint
+
+        Args:
+          end_time: Filter sessions created before this Unix timestamp (in milliseconds).
+
+          execution_type: Filter sessions by execution type (e.g., 'run', 'extract').
+
+          limit: Number of sessions per page (maximum 100).
+
+          page: Page number for pagination.
+
+          raccoon_passcode: Filter sessions by Raccoon passcode.
+
+          session_id: Filter sessions by a specific session ID.
+
+          sort_by: Field to sort sessions by (e.g., 'timestamp', 'executionTime').
+
+          sort_order: Sort order ('ascend' or 'descend').
+
+          start_time: Filter sessions created after this Unix timestamp (in milliseconds).
+
+          task_id: Filter sessions by a specific task ID.
+
+          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
+        """
+        return self._get(
+            "/sessions",
+            options=make_request_options(
+                extra_headers=extra_headers,
+                extra_query=extra_query,
+                extra_body=extra_body,
+                timeout=timeout,
+                query=maybe_transform(
+                    {
+                        "end_time": end_time,
+                        "execution_type": execution_type,
+                        "limit": limit,
+                        "page": page,
+                        "raccoon_passcode": raccoon_passcode,
+                        "session_id": session_id,
+                        "sort_by": sort_by,
+                        "sort_order": sort_order,
+                        "start_time": start_time,
+                        "task_id": task_id,
+                    },
+                    fleet_sessions_params.FleetSessionsParams,
+                ),
+            ),
+            cast_to=FleetSessionsResponse,
+        )
+
     def status(
         self,
         session_id: str,
@@ -337,6 +417,85 @@ class AsyncFleetResource(AsyncAPIResource):
             cast_to=FleetLogsResponse,
         )
 
+    async def sessions(
+        self,
+        *,
+        end_time: Optional[int] | NotGiven = NOT_GIVEN,
+        execution_type: Optional[List[Literal["run", "extract", "fleet"]]] | NotGiven = NOT_GIVEN,
+        limit: Optional[int] | NotGiven = NOT_GIVEN,
+        page: Optional[int] | NotGiven = NOT_GIVEN,
+        raccoon_passcode: Optional[str] | NotGiven = NOT_GIVEN,
+        session_id: Optional[str] | NotGiven = NOT_GIVEN,
+        sort_by: Optional[Literal["timestamp", "executionTime", "taskId", "status", "executionType"]]
+        | NotGiven = NOT_GIVEN,
+        sort_order: Optional[Literal["ascend", "descend"]] | NotGiven = NOT_GIVEN,
+        start_time: Optional[int] | NotGiven = NOT_GIVEN,
+        task_id: Optional[str] | NotGiven = NOT_GIVEN,
+        # 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,
+    ) -> FleetSessionsResponse:
+        """
+        Get Sessions Endpoint
+
+        Args:
+          end_time: Filter sessions created before this Unix timestamp (in milliseconds).
+
+          execution_type: Filter sessions by execution type (e.g., 'run', 'extract').
+
+          limit: Number of sessions per page (maximum 100).
+
+          page: Page number for pagination.
+
+          raccoon_passcode: Filter sessions by Raccoon passcode.
+
+          session_id: Filter sessions by a specific session ID.
+
+          sort_by: Field to sort sessions by (e.g., 'timestamp', 'executionTime').
+
+          sort_order: Sort order ('ascend' or 'descend').
+
+          start_time: Filter sessions created after this Unix timestamp (in milliseconds).
+
+          task_id: Filter sessions by a specific task ID.
+
+          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
+        """
+        return await self._get(
+            "/sessions",
+            options=make_request_options(
+                extra_headers=extra_headers,
+                extra_query=extra_query,
+                extra_body=extra_body,
+                timeout=timeout,
+                query=await async_maybe_transform(
+                    {
+                        "end_time": end_time,
+                        "execution_type": execution_type,
+                        "limit": limit,
+                        "page": page,
+                        "raccoon_passcode": raccoon_passcode,
+                        "session_id": session_id,
+                        "sort_by": sort_by,
+                        "sort_order": sort_order,
+                        "start_time": start_time,
+                        "task_id": task_id,
+                    },
+                    fleet_sessions_params.FleetSessionsParams,
+                ),
+            ),
+            cast_to=FleetSessionsResponse,
+        )
+
     async def status(
         self,
         session_id: str,
@@ -414,6 +573,9 @@ class FleetResourceWithRawResponse:
         self.logs = to_raw_response_wrapper(
             fleet.logs,
         )
+        self.sessions = to_raw_response_wrapper(
+            fleet.sessions,
+        )
         self.status = to_raw_response_wrapper(
             fleet.status,
         )
@@ -432,6 +594,9 @@ class AsyncFleetResourceWithRawResponse:
         self.logs = async_to_raw_response_wrapper(
             fleet.logs,
         )
+        self.sessions = async_to_raw_response_wrapper(
+            fleet.sessions,
+        )
         self.status = async_to_raw_response_wrapper(
             fleet.status,
         )
@@ -450,6 +615,9 @@ class FleetResourceWithStreamingResponse:
         self.logs = to_streamed_response_wrapper(
             fleet.logs,
         )
+        self.sessions = to_streamed_response_wrapper(
+            fleet.sessions,
+        )
         self.status = to_streamed_response_wrapper(
             fleet.status,
         )
@@ -468,6 +636,9 @@ class AsyncFleetResourceWithStreamingResponse:
         self.logs = async_to_streamed_response_wrapper(
             fleet.logs,
         )
+        self.sessions = async_to_streamed_response_wrapper(
+            fleet.sessions,
+        )
         self.status = async_to_streamed_response_wrapper(
             fleet.status,
         )