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

raccoonai/resources/{fleet.py → fleet/sessions.py}

@@ -7,59 +7,60 @@ from typing_extensions import Literal
 
 import httpx
 
-from ..types import fleet_create_params, fleet_sessions_params
-from .._types import NOT_GIVEN, Body, Query, Headers, NotGiven
-from .._utils import (
+from ..._types import NOT_GIVEN, Body, Query, Headers, NotGiven
+from ..._utils import (
     maybe_transform,
     async_maybe_transform,
 )
-from .._compat import cached_property
-from .._resource import SyncAPIResource, AsyncAPIResource
-from .._response import (
+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.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
+from ...types.fleet import session_all_params, session_create_params
+from ..._base_client import make_request_options
+from ...types.fleet.session_all_response import SessionAllResponse
+from ...types.fleet.session_logs_response import SessionLogsResponse
+from ...types.fleet.session_media_response import SessionMediaResponse
+from ...types.fleet.session_create_response import SessionCreateResponse
+from ...types.fleet.session_status_response import SessionStatusResponse
+from ...types.fleet.session_terminate_response import SessionTerminateResponse
 
-__all__ = ["FleetResource", "AsyncFleetResource"]
+__all__ = ["SessionsResource", "AsyncSessionsResource"]
 
 
-class FleetResource(SyncAPIResource):
+class SessionsResource(SyncAPIResource):
     @cached_property
-    def with_raw_response(self) -> FleetResourceWithRawResponse:
+    def with_raw_response(self) -> SessionsResourceWithRawResponse:
         """
         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 FleetResourceWithRawResponse(self)
+        return SessionsResourceWithRawResponse(self)
 
     @cached_property
-    def with_streaming_response(self) -> FleetResourceWithStreamingResponse:
+    def with_streaming_response(self) -> SessionsResourceWithStreamingResponse:
         """
         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 FleetResourceWithStreamingResponse(self)
+        return SessionsResourceWithStreamingResponse(self)
 
     def create(
         self,
         *,
-        advanced: Optional[fleet_create_params.Advanced] | NotGiven = NOT_GIVEN,
+        advanced: Optional[session_create_params.Advanced] | NotGiven = NOT_GIVEN,
         browser_type: Optional[Literal["chromium", "firefox", "webkit"]] | NotGiven = NOT_GIVEN,
         headless: Optional[bool] | NotGiven = NOT_GIVEN,
         raccoon_passcode: Optional[str] | NotGiven = NOT_GIVEN,
         session_timeout: Optional[int] | NotGiven = NOT_GIVEN,
-        settings: Optional[fleet_create_params.Settings] | NotGiven = NOT_GIVEN,
+        settings: Optional[session_create_params.Settings] | NotGiven = NOT_GIVEN,
         url: 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.
@@ -67,7 +68,7 @@ class FleetResource(SyncAPIResource):
         extra_query: Query | None = None,
         extra_body: Body | None = None,
         timeout: float | httpx.Timeout | None | NotGiven = NOT_GIVEN,
-    ) -> FleetCreateResponse:
+    ) -> SessionCreateResponse:
         """
         Fleet Websocket Session Create Endpoint
 
@@ -110,48 +111,15 @@ class FleetResource(SyncAPIResource):
                     "settings": settings,
                     "url": url,
                 },
-                fleet_create_params.FleetCreateParams,
+                session_create_params.SessionCreateParams,
             ),
             options=make_request_options(
                 extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
             ),
-            cast_to=FleetCreateResponse,
+            cast_to=SessionCreateResponse,
         )
 
-    def logs(
-        self,
-        session_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,
-    ) -> FleetLogsResponse:
-        """
-        Fleet Session Logs 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
-        """
-        if not session_id:
-            raise ValueError(f"Expected a non-empty value for `session_id` but received {session_id!r}")
-        return self._get(
-            f"/sessions/{session_id}/logs",
-            options=make_request_options(
-                extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
-            ),
-            cast_to=FleetLogsResponse,
-        )
-
-    def sessions(
+    def all(
         self,
         *,
         end_time: Optional[int] | NotGiven = NOT_GIVEN,
@@ -171,7 +139,7 @@ class FleetResource(SyncAPIResource):
         extra_query: Query | None = None,
         extra_body: Body | None = None,
         timeout: float | httpx.Timeout | None | NotGiven = NOT_GIVEN,
-    ) -> FleetSessionsResponse:
+    ) -> SessionAllResponse:
         """
         Get Sessions Endpoint
 
@@ -224,10 +192,78 @@ class FleetResource(SyncAPIResource):
                         "start_time": start_time,
                         "task_id": task_id,
                     },
-                    fleet_sessions_params.FleetSessionsParams,
+                    session_all_params.SessionAllParams,
                 ),
             ),
-            cast_to=FleetSessionsResponse,
+            cast_to=SessionAllResponse,
+        )
+
+    def logs(
+        self,
+        session_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,
+    ) -> SessionLogsResponse:
+        """
+        Fleet Session Logs 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
+        """
+        if not session_id:
+            raise ValueError(f"Expected a non-empty value for `session_id` but received {session_id!r}")
+        return self._get(
+            f"/sessions/{session_id}/logs",
+            options=make_request_options(
+                extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
+            ),
+            cast_to=SessionLogsResponse,
+        )
+
+    def media(
+        self,
+        session_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,
+    ) -> SessionMediaResponse:
+        """
+        Get Session Media Endpoint
+
+        Args:
+          session_id: The ID of the session
+
+          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 session_id:
+            raise ValueError(f"Expected a non-empty value for `session_id` but received {session_id!r}")
+        return self._get(
+            f"/sessions/{session_id}/media",
+            options=make_request_options(
+                extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
+            ),
+            cast_to=SessionMediaResponse,
         )
 
     def status(
@@ -240,7 +276,7 @@ class FleetResource(SyncAPIResource):
         extra_query: Query | None = None,
         extra_body: Body | None = None,
         timeout: float | httpx.Timeout | None | NotGiven = NOT_GIVEN,
-    ) -> FleetStatusResponse:
+    ) -> SessionStatusResponse:
         """
         Fleet Session Status Endpoint
 
@@ -260,7 +296,7 @@ class FleetResource(SyncAPIResource):
             options=make_request_options(
                 extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
             ),
-            cast_to=FleetStatusResponse,
+            cast_to=SessionStatusResponse,
         )
 
     def terminate(
@@ -273,7 +309,7 @@ class FleetResource(SyncAPIResource):
         extra_query: Query | None = None,
         extra_body: Body | None = None,
         timeout: float | httpx.Timeout | None | NotGiven = NOT_GIVEN,
-    ) -> FleetTerminateResponse:
+    ) -> SessionTerminateResponse:
         """
         Fleet Session Terminate Endpoint
 
@@ -293,39 +329,39 @@ class FleetResource(SyncAPIResource):
             options=make_request_options(
                 extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
             ),
-            cast_to=FleetTerminateResponse,
+            cast_to=SessionTerminateResponse,
         )
 
 
-class AsyncFleetResource(AsyncAPIResource):
+class AsyncSessionsResource(AsyncAPIResource):
     @cached_property
-    def with_raw_response(self) -> AsyncFleetResourceWithRawResponse:
+    def with_raw_response(self) -> AsyncSessionsResourceWithRawResponse:
         """
         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 AsyncFleetResourceWithRawResponse(self)
+        return AsyncSessionsResourceWithRawResponse(self)
 
     @cached_property
-    def with_streaming_response(self) -> AsyncFleetResourceWithStreamingResponse:
+    def with_streaming_response(self) -> AsyncSessionsResourceWithStreamingResponse:
         """
         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 AsyncFleetResourceWithStreamingResponse(self)
+        return AsyncSessionsResourceWithStreamingResponse(self)
 
     async def create(
         self,
         *,
-        advanced: Optional[fleet_create_params.Advanced] | NotGiven = NOT_GIVEN,
+        advanced: Optional[session_create_params.Advanced] | NotGiven = NOT_GIVEN,
         browser_type: Optional[Literal["chromium", "firefox", "webkit"]] | NotGiven = NOT_GIVEN,
         headless: Optional[bool] | NotGiven = NOT_GIVEN,
         raccoon_passcode: Optional[str] | NotGiven = NOT_GIVEN,
         session_timeout: Optional[int] | NotGiven = NOT_GIVEN,
-        settings: Optional[fleet_create_params.Settings] | NotGiven = NOT_GIVEN,
+        settings: Optional[session_create_params.Settings] | NotGiven = NOT_GIVEN,
         url: 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.
@@ -333,7 +369,7 @@ class AsyncFleetResource(AsyncAPIResource):
         extra_query: Query | None = None,
         extra_body: Body | None = None,
         timeout: float | httpx.Timeout | None | NotGiven = NOT_GIVEN,
-    ) -> FleetCreateResponse:
+    ) -> SessionCreateResponse:
         """
         Fleet Websocket Session Create Endpoint
 
@@ -376,48 +412,15 @@ class AsyncFleetResource(AsyncAPIResource):
                     "settings": settings,
                     "url": url,
                 },
-                fleet_create_params.FleetCreateParams,
-            ),
-            options=make_request_options(
-                extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
+                session_create_params.SessionCreateParams,
             ),
-            cast_to=FleetCreateResponse,
-        )
-
-    async def logs(
-        self,
-        session_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,
-    ) -> FleetLogsResponse:
-        """
-        Fleet Session Logs 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
-        """
-        if not session_id:
-            raise ValueError(f"Expected a non-empty value for `session_id` but received {session_id!r}")
-        return await self._get(
-            f"/sessions/{session_id}/logs",
             options=make_request_options(
                 extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
             ),
-            cast_to=FleetLogsResponse,
+            cast_to=SessionCreateResponse,
         )
 
-    async def sessions(
+    async def all(
         self,
         *,
         end_time: Optional[int] | NotGiven = NOT_GIVEN,
@@ -437,7 +440,7 @@ class AsyncFleetResource(AsyncAPIResource):
         extra_query: Query | None = None,
         extra_body: Body | None = None,
         timeout: float | httpx.Timeout | None | NotGiven = NOT_GIVEN,
-    ) -> FleetSessionsResponse:
+    ) -> SessionAllResponse:
         """
         Get Sessions Endpoint
 
@@ -490,10 +493,78 @@ class AsyncFleetResource(AsyncAPIResource):
                         "start_time": start_time,
                         "task_id": task_id,
                     },
-                    fleet_sessions_params.FleetSessionsParams,
+                    session_all_params.SessionAllParams,
                 ),
             ),
-            cast_to=FleetSessionsResponse,
+            cast_to=SessionAllResponse,
+        )
+
+    async def logs(
+        self,
+        session_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,
+    ) -> SessionLogsResponse:
+        """
+        Fleet Session Logs 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
+        """
+        if not session_id:
+            raise ValueError(f"Expected a non-empty value for `session_id` but received {session_id!r}")
+        return await self._get(
+            f"/sessions/{session_id}/logs",
+            options=make_request_options(
+                extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
+            ),
+            cast_to=SessionLogsResponse,
+        )
+
+    async def media(
+        self,
+        session_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,
+    ) -> SessionMediaResponse:
+        """
+        Get Session Media Endpoint
+
+        Args:
+          session_id: The ID of the session
+
+          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 session_id:
+            raise ValueError(f"Expected a non-empty value for `session_id` but received {session_id!r}")
+        return await self._get(
+            f"/sessions/{session_id}/media",
+            options=make_request_options(
+                extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
+            ),
+            cast_to=SessionMediaResponse,
         )
 
     async def status(
@@ -506,7 +577,7 @@ class AsyncFleetResource(AsyncAPIResource):
         extra_query: Query | None = None,
         extra_body: Body | None = None,
         timeout: float | httpx.Timeout | None | NotGiven = NOT_GIVEN,
-    ) -> FleetStatusResponse:
+    ) -> SessionStatusResponse:
         """
         Fleet Session Status Endpoint
 
@@ -526,7 +597,7 @@ class AsyncFleetResource(AsyncAPIResource):
             options=make_request_options(
                 extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
             ),
-            cast_to=FleetStatusResponse,
+            cast_to=SessionStatusResponse,
         )
 
     async def terminate(
@@ -539,7 +610,7 @@ class AsyncFleetResource(AsyncAPIResource):
         extra_query: Query | None = None,
         extra_body: Body | None = None,
         timeout: float | httpx.Timeout | None | NotGiven = NOT_GIVEN,
-    ) -> FleetTerminateResponse:
+    ) -> SessionTerminateResponse:
         """
         Fleet Session Terminate Endpoint
 
@@ -559,89 +630,101 @@ class AsyncFleetResource(AsyncAPIResource):
             options=make_request_options(
                 extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
             ),
-            cast_to=FleetTerminateResponse,
+            cast_to=SessionTerminateResponse,
         )
 
 
-class FleetResourceWithRawResponse:
-    def __init__(self, fleet: FleetResource) -> None:
-        self._fleet = fleet
+class SessionsResourceWithRawResponse:
+    def __init__(self, sessions: SessionsResource) -> None:
+        self._sessions = sessions
 
         self.create = to_raw_response_wrapper(
-            fleet.create,
+            sessions.create,
+        )
+        self.all = to_raw_response_wrapper(
+            sessions.all,
         )
         self.logs = to_raw_response_wrapper(
-            fleet.logs,
+            sessions.logs,
         )
-        self.sessions = to_raw_response_wrapper(
-            fleet.sessions,
+        self.media = to_raw_response_wrapper(
+            sessions.media,
         )
         self.status = to_raw_response_wrapper(
-            fleet.status,
+            sessions.status,
         )
         self.terminate = to_raw_response_wrapper(
-            fleet.terminate,
+            sessions.terminate,
         )
 
 
-class AsyncFleetResourceWithRawResponse:
-    def __init__(self, fleet: AsyncFleetResource) -> None:
-        self._fleet = fleet
+class AsyncSessionsResourceWithRawResponse:
+    def __init__(self, sessions: AsyncSessionsResource) -> None:
+        self._sessions = sessions
 
         self.create = async_to_raw_response_wrapper(
-            fleet.create,
+            sessions.create,
+        )
+        self.all = async_to_raw_response_wrapper(
+            sessions.all,
         )
         self.logs = async_to_raw_response_wrapper(
-            fleet.logs,
+            sessions.logs,
         )
-        self.sessions = async_to_raw_response_wrapper(
-            fleet.sessions,
+        self.media = async_to_raw_response_wrapper(
+            sessions.media,
         )
         self.status = async_to_raw_response_wrapper(
-            fleet.status,
+            sessions.status,
         )
         self.terminate = async_to_raw_response_wrapper(
-            fleet.terminate,
+            sessions.terminate,
         )
 
 
-class FleetResourceWithStreamingResponse:
-    def __init__(self, fleet: FleetResource) -> None:
-        self._fleet = fleet
+class SessionsResourceWithStreamingResponse:
+    def __init__(self, sessions: SessionsResource) -> None:
+        self._sessions = sessions
 
         self.create = to_streamed_response_wrapper(
-            fleet.create,
+            sessions.create,
+        )
+        self.all = to_streamed_response_wrapper(
+            sessions.all,
         )
         self.logs = to_streamed_response_wrapper(
-            fleet.logs,
+            sessions.logs,
         )
-        self.sessions = to_streamed_response_wrapper(
-            fleet.sessions,
+        self.media = to_streamed_response_wrapper(
+            sessions.media,
         )
         self.status = to_streamed_response_wrapper(
-            fleet.status,
+            sessions.status,
         )
         self.terminate = to_streamed_response_wrapper(
-            fleet.terminate,
+            sessions.terminate,
         )
 
 
-class AsyncFleetResourceWithStreamingResponse:
-    def __init__(self, fleet: AsyncFleetResource) -> None:
-        self._fleet = fleet
+class AsyncSessionsResourceWithStreamingResponse:
+    def __init__(self, sessions: AsyncSessionsResource) -> None:
+        self._sessions = sessions
 
         self.create = async_to_streamed_response_wrapper(
-            fleet.create,
+            sessions.create,
+        )
+        self.all = async_to_streamed_response_wrapper(
+            sessions.all,
         )
         self.logs = async_to_streamed_response_wrapper(
-            fleet.logs,
+            sessions.logs,
         )
-        self.sessions = async_to_streamed_response_wrapper(
-            fleet.sessions,
+        self.media = async_to_streamed_response_wrapper(
+            sessions.media,
         )
         self.status = async_to_streamed_response_wrapper(
-            fleet.status,
+            sessions.status,
         )
         self.terminate = async_to_streamed_response_wrapper(
-            fleet.terminate,
+            sessions.terminate,
         )

raccoonai/resources/lam/__init__.py

@@ -0,0 +1,33 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from .lam import (
+    LamResource,
+    AsyncLamResource,
+    LamResourceWithRawResponse,
+    AsyncLamResourceWithRawResponse,
+    LamResourceWithStreamingResponse,
+    AsyncLamResourceWithStreamingResponse,
+)
+from .tasks import (
+    TasksResource,
+    AsyncTasksResource,
+    TasksResourceWithRawResponse,
+    AsyncTasksResourceWithRawResponse,
+    TasksResourceWithStreamingResponse,
+    AsyncTasksResourceWithStreamingResponse,
+)
+
+__all__ = [
+    "TasksResource",
+    "AsyncTasksResource",
+    "TasksResourceWithRawResponse",
+    "AsyncTasksResourceWithRawResponse",
+    "TasksResourceWithStreamingResponse",
+    "AsyncTasksResourceWithStreamingResponse",
+    "LamResource",
+    "AsyncLamResource",
+    "LamResourceWithRawResponse",
+    "AsyncLamResourceWithRawResponse",
+    "LamResourceWithStreamingResponse",
+    "AsyncLamResourceWithStreamingResponse",
+]