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

raccoonai/resources/lam.py

@@ -2,12 +2,12 @@
 
 from __future__ import annotations
 
-from typing import Any, Iterable, Optional, cast
+from typing import List, Iterable, Optional
 from typing_extensions import Literal, overload
 
 import httpx
 
-from ..types import lam_run_params, lam_integration_run_params
+from ..types import lam_run_params, lam_tasks_params
 from .._types import NOT_GIVEN, Body, Query, Headers, NotGiven
 from .._utils import (
     required_args,
@@ -25,7 +25,7 @@ from .._response import (
 from .._streaming import Stream, AsyncStream
 from .._base_client import make_request_options
 from ..types.lam_run_response import LamRunResponse
-from ..types.lam_integration_run_response import LamIntegrationRunResponse
+from ..types.lam_tasks_response import LamTasksResponse
 
 __all__ = ["LamResource", "AsyncLamResource"]
 
@@ -50,179 +50,6 @@ class LamResource(SyncAPIResource):
         """
         return LamResourceWithStreamingResponse(self)
 
-    @overload
-    def integration_run(
-        self,
-        app_name: str,
-        *,
-        raccoon_passcode: str,
-        advanced: Optional[lam_integration_run_params.Advanced] | NotGiven = NOT_GIVEN,
-        integration_id: Optional[str] | NotGiven = NOT_GIVEN,
-        properties: Optional[object] | NotGiven = NOT_GIVEN,
-        stream: Optional[Literal[False]] | 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,
-    ) -> LamIntegrationRunResponse:
-        """
-        Lam Integrations Endpoint
-
-        Args:
-          raccoon_passcode: The raccoon passcode associated with the end user on behalf of which the call is
-              being made.
-
-          advanced: Advanced configuration options for the session, such as ad-blocking and CAPTCHA
-              solving.
-
-          integration_id: The unique identifier for the integration being called.
-
-          properties: Additional properties or data related to the particular integration.
-
-          stream: Whether the response should be streamed back or not.
-
-          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
-        """
-        ...
-
-    @overload
-    def integration_run(
-        self,
-        app_name: str,
-        *,
-        raccoon_passcode: str,
-        stream: Literal[True],
-        advanced: Optional[lam_integration_run_params.Advanced] | NotGiven = NOT_GIVEN,
-        integration_id: Optional[str] | NotGiven = NOT_GIVEN,
-        properties: Optional[object] | 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,
-    ) -> Stream[LamIntegrationRunResponse]:
-        """
-        Lam Integrations Endpoint
-
-        Args:
-          raccoon_passcode: The raccoon passcode associated with the end user on behalf of which the call is
-              being made.
-
-          stream: Whether the response should be streamed back or not.
-
-          advanced: Advanced configuration options for the session, such as ad-blocking and CAPTCHA
-              solving.
-
-          integration_id: The unique identifier for the integration being called.
-
-          properties: Additional properties or data related to the particular integration.
-
-          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
-        """
-        ...
-
-    @overload
-    def integration_run(
-        self,
-        app_name: str,
-        *,
-        raccoon_passcode: str,
-        stream: bool,
-        advanced: Optional[lam_integration_run_params.Advanced] | NotGiven = NOT_GIVEN,
-        integration_id: Optional[str] | NotGiven = NOT_GIVEN,
-        properties: Optional[object] | 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,
-    ) -> LamIntegrationRunResponse | Stream[LamIntegrationRunResponse]:
-        """
-        Lam Integrations Endpoint
-
-        Args:
-          raccoon_passcode: The raccoon passcode associated with the end user on behalf of which the call is
-              being made.
-
-          stream: Whether the response should be streamed back or not.
-
-          advanced: Advanced configuration options for the session, such as ad-blocking and CAPTCHA
-              solving.
-
-          integration_id: The unique identifier for the integration being called.
-
-          properties: Additional properties or data related to the particular integration.
-
-          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
-        """
-        ...
-
-    @required_args(["raccoon_passcode"], ["raccoon_passcode", "stream"])
-    def integration_run(
-        self,
-        app_name: str,
-        *,
-        raccoon_passcode: str,
-        advanced: Optional[lam_integration_run_params.Advanced] | NotGiven = NOT_GIVEN,
-        integration_id: Optional[str] | NotGiven = NOT_GIVEN,
-        properties: Optional[object] | NotGiven = NOT_GIVEN,
-        stream: Optional[Literal[False]] | Literal[True] | 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,
-    ) -> LamIntegrationRunResponse | Stream[LamIntegrationRunResponse]:
-        if not app_name:
-            raise ValueError(f"Expected a non-empty value for `app_name` but received {app_name!r}")
-        return cast(
-            LamIntegrationRunResponse,
-            self._post(
-                f"/lam/{app_name}/run",
-                body=maybe_transform(
-                    {
-                        "raccoon_passcode": raccoon_passcode,
-                        "advanced": advanced,
-                        "integration_id": integration_id,
-                        "properties": properties,
-                        "stream": stream,
-                    },
-                    lam_integration_run_params.LamIntegrationRunParams,
-                ),
-                options=make_request_options(
-                    extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
-                ),
-                cast_to=cast(
-                    Any, LamIntegrationRunResponse
-                ),  # Union types cannot be passed in as arguments in the type system
-                stream=stream or False,
-                stream_cls=Stream[LamIntegrationRunResponse],
-            ),
-        )
-
     @overload
     def run(
         self,
@@ -438,145 +265,47 @@ class LamResource(SyncAPIResource):
             stream_cls=Stream[LamRunResponse],
         )
 
-
-class AsyncLamResource(AsyncAPIResource):
-    @cached_property
-    def with_raw_response(self) -> AsyncLamResourceWithRawResponse:
-        """
-        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 AsyncLamResourceWithRawResponse(self)
-
-    @cached_property
-    def with_streaming_response(self) -> AsyncLamResourceWithStreamingResponse:
-        """
-        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 AsyncLamResourceWithStreamingResponse(self)
-
-    @overload
-    async def integration_run(
-        self,
-        app_name: str,
-        *,
-        raccoon_passcode: str,
-        advanced: Optional[lam_integration_run_params.Advanced] | NotGiven = NOT_GIVEN,
-        integration_id: Optional[str] | NotGiven = NOT_GIVEN,
-        properties: Optional[object] | NotGiven = NOT_GIVEN,
-        stream: Optional[Literal[False]] | 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,
-    ) -> LamIntegrationRunResponse:
-        """
-        Lam Integrations Endpoint
-
-        Args:
-          raccoon_passcode: The raccoon passcode associated with the end user on behalf of which the call is
-              being made.
-
-          advanced: Advanced configuration options for the session, such as ad-blocking and CAPTCHA
-              solving.
-
-          integration_id: The unique identifier for the integration being called.
-
-          properties: Additional properties or data related to the particular integration.
-
-          stream: Whether the response should be streamed back or not.
-
-          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
-        """
-        ...
-
-    @overload
-    async def integration_run(
+    def tasks(
         self,
-        app_name: str,
         *,
-        raccoon_passcode: str,
-        stream: Literal[True],
-        advanced: Optional[lam_integration_run_params.Advanced] | NotGiven = NOT_GIVEN,
-        integration_id: Optional[str] | NotGiven = NOT_GIVEN,
-        properties: Optional[object] | NotGiven = NOT_GIVEN,
+        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,
-    ) -> AsyncStream[LamIntegrationRunResponse]:
+    ) -> LamTasksResponse:
         """
-        Lam Integrations Endpoint
+        Get Tasks Endpoint
 
         Args:
-          raccoon_passcode: The raccoon passcode associated with the end user on behalf of which the call is
-              being made.
+          end_time: Filter tasks created before this Unix timestamp (in milliseconds).
 
-          stream: Whether the response should be streamed back or not.
+          execution_type: Filter tasks by execution type (e.g., 'run', 'extract').
 
-          advanced: Advanced configuration options for the session, such as ad-blocking and CAPTCHA
-              solving.
+          limit: Number of tasks per page (maximum 100).
 
-          integration_id: The unique identifier for the integration being called.
+          page: Page number for pagination.
 
-          properties: Additional properties or data related to the particular integration.
+          raccoon_passcode: Filter tasks by Raccoon passcode.
 
-          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
-        """
-        ...
-
-    @overload
-    async def integration_run(
-        self,
-        app_name: str,
-        *,
-        raccoon_passcode: str,
-        stream: bool,
-        advanced: Optional[lam_integration_run_params.Advanced] | NotGiven = NOT_GIVEN,
-        integration_id: Optional[str] | NotGiven = NOT_GIVEN,
-        properties: Optional[object] | 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,
-    ) -> LamIntegrationRunResponse | AsyncStream[LamIntegrationRunResponse]:
-        """
-        Lam Integrations Endpoint
-
-        Args:
-          raccoon_passcode: The raccoon passcode associated with the end user on behalf of which the call is
-              being made.
-
-          stream: Whether the response should be streamed back or not.
+          sort_by: Field to sort tasks by (e.g., 'timestamp', 'executionTime').
 
-          advanced: Advanced configuration options for the session, such as ad-blocking and CAPTCHA
-              solving.
+          sort_order: Sort order ('ascend' or 'descend').
 
-          integration_id: The unique identifier for the integration being called.
+          start_time: Filter tasks created after this Unix timestamp (in milliseconds).
 
-          properties: Additional properties or data related to the particular integration.
+          task_id: Filter tasks by a specific task ID.
 
           extra_headers: Send extra headers
 
@@ -586,52 +315,52 @@ class AsyncLamResource(AsyncAPIResource):
 
           timeout: Override the client-level default timeout for this request, in seconds
         """
-        ...
-
-    @required_args(["raccoon_passcode"], ["raccoon_passcode", "stream"])
-    async def integration_run(
-        self,
-        app_name: str,
-        *,
-        raccoon_passcode: str,
-        advanced: Optional[lam_integration_run_params.Advanced] | NotGiven = NOT_GIVEN,
-        integration_id: Optional[str] | NotGiven = NOT_GIVEN,
-        properties: Optional[object] | NotGiven = NOT_GIVEN,
-        stream: Optional[Literal[False]] | Literal[True] | 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,
-    ) -> LamIntegrationRunResponse | AsyncStream[LamIntegrationRunResponse]:
-        if not app_name:
-            raise ValueError(f"Expected a non-empty value for `app_name` but received {app_name!r}")
-        return cast(
-            LamIntegrationRunResponse,
-            await self._post(
-                f"/lam/{app_name}/run",
-                body=await async_maybe_transform(
+        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,
-                        "advanced": advanced,
-                        "integration_id": integration_id,
-                        "properties": properties,
-                        "stream": stream,
+                        "sort_by": sort_by,
+                        "sort_order": sort_order,
+                        "start_time": start_time,
+                        "task_id": task_id,
                     },
-                    lam_integration_run_params.LamIntegrationRunParams,
-                ),
-                options=make_request_options(
-                    extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
+                    lam_tasks_params.LamTasksParams,
                 ),
-                cast_to=cast(
-                    Any, LamIntegrationRunResponse
-                ),  # Union types cannot be passed in as arguments in the type system
-                stream=stream or False,
-                stream_cls=AsyncStream[LamIntegrationRunResponse],
             ),
+            cast_to=LamTasksResponse,
         )
 
+
+class AsyncLamResource(AsyncAPIResource):
+    @cached_property
+    def with_raw_response(self) -> AsyncLamResourceWithRawResponse:
+        """
+        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 AsyncLamResourceWithRawResponse(self)
+
+    @cached_property
+    def with_streaming_response(self) -> AsyncLamResourceWithStreamingResponse:
+        """
+        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 AsyncLamResourceWithStreamingResponse(self)
+
     @overload
     async def run(
         self,
@@ -847,50 +576,125 @@ 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:
         self._lam = lam
 
-        self.integration_run = to_raw_response_wrapper(
-            lam.integration_run,
-        )
         self.run = to_raw_response_wrapper(
             lam.run,
         )
+        self.tasks = to_raw_response_wrapper(
+            lam.tasks,
+        )
 
 
 class AsyncLamResourceWithRawResponse:
     def __init__(self, lam: AsyncLamResource) -> None:
         self._lam = lam
 
-        self.integration_run = async_to_raw_response_wrapper(
-            lam.integration_run,
-        )
         self.run = async_to_raw_response_wrapper(
             lam.run,
         )
+        self.tasks = async_to_raw_response_wrapper(
+            lam.tasks,
+        )
 
 
 class LamResourceWithStreamingResponse:
     def __init__(self, lam: LamResource) -> None:
         self._lam = lam
 
-        self.integration_run = to_streamed_response_wrapper(
-            lam.integration_run,
-        )
         self.run = to_streamed_response_wrapper(
             lam.run,
         )
+        self.tasks = to_streamed_response_wrapper(
+            lam.tasks,
+        )
 
 
 class AsyncLamResourceWithStreamingResponse:
     def __init__(self, lam: AsyncLamResource) -> None:
         self._lam = lam
 
-        self.integration_run = async_to_streamed_response_wrapper(
-            lam.integration_run,
-        )
         self.run = async_to_streamed_response_wrapper(
             lam.run,
         )
+        self.tasks = async_to_streamed_response_wrapper(
+            lam.tasks,
+        )

raccoonai/resources/tail/__init__.py

@@ -0,0 +1,47 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from .apps import (
+    AppsResource,
+    AsyncAppsResource,
+    AppsResourceWithRawResponse,
+    AsyncAppsResourceWithRawResponse,
+    AppsResourceWithStreamingResponse,
+    AsyncAppsResourceWithStreamingResponse,
+)
+from .auth import (
+    AuthResource,
+    AsyncAuthResource,
+    AuthResourceWithRawResponse,
+    AsyncAuthResourceWithRawResponse,
+    AuthResourceWithStreamingResponse,
+    AsyncAuthResourceWithStreamingResponse,
+)
+from .tail import (
+    TailResource,
+    AsyncTailResource,
+    TailResourceWithRawResponse,
+    AsyncTailResourceWithRawResponse,
+    TailResourceWithStreamingResponse,
+    AsyncTailResourceWithStreamingResponse,
+)
+
+__all__ = [
+    "AppsResource",
+    "AsyncAppsResource",
+    "AppsResourceWithRawResponse",
+    "AsyncAppsResourceWithRawResponse",
+    "AppsResourceWithStreamingResponse",
+    "AsyncAppsResourceWithStreamingResponse",
+    "AuthResource",
+    "AsyncAuthResource",
+    "AuthResourceWithRawResponse",
+    "AsyncAuthResourceWithRawResponse",
+    "AuthResourceWithStreamingResponse",
+    "AsyncAuthResourceWithStreamingResponse",
+    "TailResource",
+    "AsyncTailResource",
+    "TailResourceWithRawResponse",
+    "AsyncTailResourceWithRawResponse",
+    "TailResourceWithStreamingResponse",
+    "AsyncTailResourceWithStreamingResponse",
+]