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

raccoonai/resources/{lam.py → lam/lam.py}

@@ -2,35 +2,46 @@
 
 from __future__ import annotations
 
-from typing import List, Iterable, Optional
+from typing import Iterable, Optional
 from typing_extensions import Literal, overload
 
 import httpx
 
-from ..types import lam_run_params, lam_tasks_params
-from .._types import NOT_GIVEN, Body, Query, Headers, NotGiven
-from .._utils import (
+from .tasks import (
+    TasksResource,
+    AsyncTasksResource,
+    TasksResourceWithRawResponse,
+    AsyncTasksResourceWithRawResponse,
+    TasksResourceWithStreamingResponse,
+    AsyncTasksResourceWithStreamingResponse,
+)
+from ...types import lam_run_params
+from ..._types import NOT_GIVEN, Body, Query, Headers, NotGiven
+from ..._utils import (
     required_args,
     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 .._streaming import Stream, AsyncStream
-from .._base_client import make_request_options
-from ..types.lam_run_response import LamRunResponse
-from ..types.lam_tasks_response import LamTasksResponse
+from ..._streaming import Stream, AsyncStream
+from ..._base_client import make_request_options
+from ...types.lam_run_response import LamRunResponse
 
 __all__ = ["LamResource", "AsyncLamResource"]
 
 
 class LamResource(SyncAPIResource):
+    @cached_property
+    def tasks(self) -> TasksResource:
+        return TasksResource(self._client)
+
     @cached_property
     def with_raw_response(self) -> LamResourceWithRawResponse:
         """
@@ -265,83 +276,12 @@ class LamResource(SyncAPIResource):
             stream_cls=Stream[LamRunResponse],
         )
 
-    def tasks(
-        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,
-        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,
-    ) -> LamTasksResponse:
-        """
-        Get Tasks Endpoint
-
-        Args:
-          end_time: Filter tasks created before this Unix timestamp (in milliseconds).
-
-          execution_type: Filter tasks by execution type (e.g., 'run', 'extract').
-
-          limit: Number of tasks per page (maximum 100).
-
-          page: Page number for pagination.
-
-          raccoon_passcode: Filter tasks by Raccoon passcode.
-
-          sort_by: Field to sort tasks by (e.g., 'timestamp', 'executionTime').
-
-          sort_order: Sort order ('ascend' or 'descend').
-
-          start_time: Filter tasks created after this Unix timestamp (in milliseconds).
-
-          task_id: Filter tasks 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(
-            "/lam/tasks",
-            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,
-                        "sort_by": sort_by,
-                        "sort_order": sort_order,
-                        "start_time": start_time,
-                        "task_id": task_id,
-                    },
-                    lam_tasks_params.LamTasksParams,
-                ),
-            ),
-            cast_to=LamTasksResponse,
-        )
-
 
 class AsyncLamResource(AsyncAPIResource):
+    @cached_property
+    def tasks(self) -> AsyncTasksResource:
+        return AsyncTasksResource(self._client)
+
     @cached_property
     def with_raw_response(self) -> AsyncLamResourceWithRawResponse:
         """
@@ -576,81 +516,6 @@ class AsyncLamResource(AsyncAPIResource):
             stream_cls=AsyncStream[LamRunResponse],
         )
 
-    async def tasks(
-        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,
-        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,
-    ) -> LamTasksResponse:
-        """
-        Get Tasks Endpoint
-
-        Args:
-          end_time: Filter tasks created before this Unix timestamp (in milliseconds).
-
-          execution_type: Filter tasks by execution type (e.g., 'run', 'extract').
-
-          limit: Number of tasks per page (maximum 100).
-
-          page: Page number for pagination.
-
-          raccoon_passcode: Filter tasks by Raccoon passcode.
-
-          sort_by: Field to sort tasks by (e.g., 'timestamp', 'executionTime').
-
-          sort_order: Sort order ('ascend' or 'descend').
-
-          start_time: Filter tasks created after this Unix timestamp (in milliseconds).
-
-          task_id: Filter tasks 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(
-            "/lam/tasks",
-            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,
-                        "sort_by": sort_by,
-                        "sort_order": sort_order,
-                        "start_time": start_time,
-                        "task_id": task_id,
-                    },
-                    lam_tasks_params.LamTasksParams,
-                ),
-            ),
-            cast_to=LamTasksResponse,
-        )
-
 
 class LamResourceWithRawResponse:
     def __init__(self, lam: LamResource) -> None:
@@ -659,9 +524,10 @@ class LamResourceWithRawResponse:
         self.run = to_raw_response_wrapper(
             lam.run,
         )
-        self.tasks = to_raw_response_wrapper(
-            lam.tasks,
-        )
+
+    @cached_property
+    def tasks(self) -> TasksResourceWithRawResponse:
+        return TasksResourceWithRawResponse(self._lam.tasks)
 
 
 class AsyncLamResourceWithRawResponse:
@@ -671,9 +537,10 @@ class AsyncLamResourceWithRawResponse:
         self.run = async_to_raw_response_wrapper(
             lam.run,
         )
-        self.tasks = async_to_raw_response_wrapper(
-            lam.tasks,
-        )
+
+    @cached_property
+    def tasks(self) -> AsyncTasksResourceWithRawResponse:
+        return AsyncTasksResourceWithRawResponse(self._lam.tasks)
 
 
 class LamResourceWithStreamingResponse:
@@ -683,9 +550,10 @@ class LamResourceWithStreamingResponse:
         self.run = to_streamed_response_wrapper(
             lam.run,
         )
-        self.tasks = to_streamed_response_wrapper(
-            lam.tasks,
-        )
+
+    @cached_property
+    def tasks(self) -> TasksResourceWithStreamingResponse:
+        return TasksResourceWithStreamingResponse(self._lam.tasks)
 
 
 class AsyncLamResourceWithStreamingResponse:
@@ -695,6 +563,7 @@ class AsyncLamResourceWithStreamingResponse:
         self.run = async_to_streamed_response_wrapper(
             lam.run,
         )
-        self.tasks = async_to_streamed_response_wrapper(
-            lam.tasks,
-        )
+
+    @cached_property
+    def tasks(self) -> AsyncTasksResourceWithStreamingResponse:
+        return AsyncTasksResourceWithStreamingResponse(self._lam.tasks)

raccoonai/resources/lam/tasks.py

@@ -0,0 +1,338 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from __future__ import annotations
+
+from typing import List, Optional
+from typing_extensions import Literal
+
+import httpx
+
+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 (
+    to_raw_response_wrapper,
+    to_streamed_response_wrapper,
+    async_to_raw_response_wrapper,
+    async_to_streamed_response_wrapper,
+)
+from ...types.lam import task_all_params
+from ..._base_client import make_request_options
+from ...types.lam.task_all_response import TaskAllResponse
+from ...types.lam.task_media_response import TaskMediaResponse
+
+__all__ = ["TasksResource", "AsyncTasksResource"]
+
+
+class TasksResource(SyncAPIResource):
+    @cached_property
+    def with_raw_response(self) -> TasksResourceWithRawResponse:
+        """
+        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 TasksResourceWithRawResponse(self)
+
+    @cached_property
+    def with_streaming_response(self) -> TasksResourceWithStreamingResponse:
+        """
+        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 TasksResourceWithStreamingResponse(self)
+
+    def all(
+        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,
+        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,
+    ) -> TaskAllResponse:
+        """
+        Get Tasks Endpoint
+
+        Args:
+          end_time: Filter tasks created before this Unix timestamp (in milliseconds).
+
+          execution_type: Filter tasks by execution type (e.g., 'run', 'extract').
+
+          limit: Number of tasks per page (maximum 100).
+
+          page: Page number for pagination.
+
+          raccoon_passcode: Filter tasks by Raccoon passcode.
+
+          sort_by: Field to sort tasks by (e.g., 'timestamp', 'executionTime').
+
+          sort_order: Sort order ('ascend' or 'descend').
+
+          start_time: Filter tasks created after this Unix timestamp (in milliseconds).
+
+          task_id: Filter tasks 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(
+            "/lam/tasks",
+            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,
+                        "sort_by": sort_by,
+                        "sort_order": sort_order,
+                        "start_time": start_time,
+                        "task_id": task_id,
+                    },
+                    task_all_params.TaskAllParams,
+                ),
+            ),
+            cast_to=TaskAllResponse,
+        )
+
+    def media(
+        self,
+        task_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,
+    ) -> TaskMediaResponse:
+        """
+        Get Task Media Endpoint
+
+        Args:
+          task_id: The ID of the task
+
+          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 task_id:
+            raise ValueError(f"Expected a non-empty value for `task_id` but received {task_id!r}")
+        return self._get(
+            f"/lam/tasks/{task_id}/media",
+            options=make_request_options(
+                extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
+            ),
+            cast_to=TaskMediaResponse,
+        )
+
+
+class AsyncTasksResource(AsyncAPIResource):
+    @cached_property
+    def with_raw_response(self) -> AsyncTasksResourceWithRawResponse:
+        """
+        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 AsyncTasksResourceWithRawResponse(self)
+
+    @cached_property
+    def with_streaming_response(self) -> AsyncTasksResourceWithStreamingResponse:
+        """
+        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 AsyncTasksResourceWithStreamingResponse(self)
+
+    async def all(
+        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,
+        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,
+    ) -> TaskAllResponse:
+        """
+        Get Tasks Endpoint
+
+        Args:
+          end_time: Filter tasks created before this Unix timestamp (in milliseconds).
+
+          execution_type: Filter tasks by execution type (e.g., 'run', 'extract').
+
+          limit: Number of tasks per page (maximum 100).
+
+          page: Page number for pagination.
+
+          raccoon_passcode: Filter tasks by Raccoon passcode.
+
+          sort_by: Field to sort tasks by (e.g., 'timestamp', 'executionTime').
+
+          sort_order: Sort order ('ascend' or 'descend').
+
+          start_time: Filter tasks created after this Unix timestamp (in milliseconds).
+
+          task_id: Filter tasks 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(
+            "/lam/tasks",
+            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,
+                        "sort_by": sort_by,
+                        "sort_order": sort_order,
+                        "start_time": start_time,
+                        "task_id": task_id,
+                    },
+                    task_all_params.TaskAllParams,
+                ),
+            ),
+            cast_to=TaskAllResponse,
+        )
+
+    async def media(
+        self,
+        task_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,
+    ) -> TaskMediaResponse:
+        """
+        Get Task Media Endpoint
+
+        Args:
+          task_id: The ID of the task
+
+          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 task_id:
+            raise ValueError(f"Expected a non-empty value for `task_id` but received {task_id!r}")
+        return await self._get(
+            f"/lam/tasks/{task_id}/media",
+            options=make_request_options(
+                extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
+            ),
+            cast_to=TaskMediaResponse,
+        )
+
+
+class TasksResourceWithRawResponse:
+    def __init__(self, tasks: TasksResource) -> None:
+        self._tasks = tasks
+
+        self.all = to_raw_response_wrapper(
+            tasks.all,
+        )
+        self.media = to_raw_response_wrapper(
+            tasks.media,
+        )
+
+
+class AsyncTasksResourceWithRawResponse:
+    def __init__(self, tasks: AsyncTasksResource) -> None:
+        self._tasks = tasks
+
+        self.all = async_to_raw_response_wrapper(
+            tasks.all,
+        )
+        self.media = async_to_raw_response_wrapper(
+            tasks.media,
+        )
+
+
+class TasksResourceWithStreamingResponse:
+    def __init__(self, tasks: TasksResource) -> None:
+        self._tasks = tasks
+
+        self.all = to_streamed_response_wrapper(
+            tasks.all,
+        )
+        self.media = to_streamed_response_wrapper(
+            tasks.media,
+        )
+
+
+class AsyncTasksResourceWithStreamingResponse:
+    def __init__(self, tasks: AsyncTasksResource) -> None:
+        self._tasks = tasks
+
+        self.all = async_to_streamed_response_wrapper(
+            tasks.all,
+        )
+        self.media = async_to_streamed_response_wrapper(
+            tasks.media,
+        )

raccoonai/resources/tail/__init__.py

@@ -8,14 +8,6 @@ from .apps import (
     AppsResourceWithStreamingResponse,
     AsyncAppsResourceWithStreamingResponse,
 )
-from .auth import (
-    AuthResource,
-    AsyncAuthResource,
-    AuthResourceWithRawResponse,
-    AsyncAuthResourceWithRawResponse,
-    AuthResourceWithStreamingResponse,
-    AsyncAuthResourceWithStreamingResponse,
-)
 from .tail import (
     TailResource,
     AsyncTailResource,
@@ -24,20 +16,28 @@ from .tail import (
     TailResourceWithStreamingResponse,
     AsyncTailResourceWithStreamingResponse,
 )
+from .users import (
+    UsersResource,
+    AsyncUsersResource,
+    UsersResourceWithRawResponse,
+    AsyncUsersResourceWithRawResponse,
+    UsersResourceWithStreamingResponse,
+    AsyncUsersResourceWithStreamingResponse,
+)
 
 __all__ = [
+    "UsersResource",
+    "AsyncUsersResource",
+    "UsersResourceWithRawResponse",
+    "AsyncUsersResourceWithRawResponse",
+    "UsersResourceWithStreamingResponse",
+    "AsyncUsersResourceWithStreamingResponse",
     "AppsResource",
     "AsyncAppsResource",
     "AppsResourceWithRawResponse",
     "AsyncAppsResourceWithRawResponse",
     "AppsResourceWithStreamingResponse",
     "AsyncAppsResourceWithStreamingResponse",
-    "AuthResource",
-    "AsyncAuthResource",
-    "AuthResourceWithRawResponse",
-    "AsyncAuthResourceWithRawResponse",
-    "AuthResourceWithStreamingResponse",
-    "AsyncAuthResourceWithStreamingResponse",
     "TailResource",
     "AsyncTailResource",
     "TailResourceWithRawResponse",