anchorbrowser 0.1.0a3__py3-none-any.whl → 0.2.0__py3-none-any.whl

anchorbrowser/_utils/_transform.py

@@ -16,18 +16,20 @@ from ._utils import (
     lru_cache,
     is_mapping,
     is_iterable,
+    is_sequence,
 )
 from .._files import is_base64_file_input
+from ._compat import get_origin, is_typeddict
 from ._typing import (
     is_list_type,
     is_union_type,
     extract_type_arg,
     is_iterable_type,
     is_required_type,
+    is_sequence_type,
     is_annotated_type,
     strip_annotated_type,
 )
-from .._compat import get_origin, model_dump, is_typeddict
 
 _T = TypeVar("_T")
 
@@ -167,6 +169,8 @@ def _transform_recursive(
 
             Defaults to the same value as the `annotation` argument.
     """
+    from .._compat import model_dump
+
     if inner_type is None:
         inner_type = annotation
 
@@ -184,6 +188,8 @@ def _transform_recursive(
         (is_list_type(stripped_type) and is_list(data))
         # Iterable[T]
         or (is_iterable_type(stripped_type) and is_iterable(data) and not isinstance(data, str))
+        # Sequence[T]
+        or (is_sequence_type(stripped_type) and is_sequence(data) and not isinstance(data, str))
     ):
         # dicts are technically iterable, but it is an iterable on the keys of the dict and is not usually
         # intended as an iterable, so we don't transform it.
@@ -262,7 +268,7 @@ def _transform_typeddict(
     annotations = get_type_hints(expected_type, include_extras=True)
     for key, value in data.items():
         if not is_given(value):
-            # we don't need to include `NotGiven` values here as they'll
+            # we don't need to include omitted values here as they'll
             # be stripped out before the request is sent anyway
             continue
 
@@ -329,6 +335,8 @@ async def _async_transform_recursive(
 
             Defaults to the same value as the `annotation` argument.
     """
+    from .._compat import model_dump
+
     if inner_type is None:
         inner_type = annotation
 
@@ -346,6 +354,8 @@ async def _async_transform_recursive(
         (is_list_type(stripped_type) and is_list(data))
         # Iterable[T]
         or (is_iterable_type(stripped_type) and is_iterable(data) and not isinstance(data, str))
+        # Sequence[T]
+        or (is_sequence_type(stripped_type) and is_sequence(data) and not isinstance(data, str))
     ):
         # dicts are technically iterable, but it is an iterable on the keys of the dict and is not usually
         # intended as an iterable, so we don't transform it.
@@ -424,7 +434,7 @@ async def _async_transform_typeddict(
     annotations = get_type_hints(expected_type, include_extras=True)
     for key, value in data.items():
         if not is_given(value):
-            # we don't need to include `NotGiven` values here as they'll
+            # we don't need to include omitted values here as they'll
             # be stripped out before the request is sent anyway
             continue
 

anchorbrowser/_utils/_typing.py

@@ -15,7 +15,7 @@ from typing_extensions import (
 
 from ._utils import lru_cache
 from .._types import InheritsGeneric
-from .._compat import is_union as _is_union
+from ._compat import is_union as _is_union
 
 
 def is_annotated_type(typ: type) -> bool:
@@ -26,6 +26,11 @@ def is_list_type(typ: type) -> bool:
     return (get_origin(typ) or typ) == list
 
 
+def is_sequence_type(typ: type) -> bool:
+    origin = get_origin(typ) or typ
+    return origin == typing_extensions.Sequence or origin == typing.Sequence or origin == _c_abc.Sequence
+
+
 def is_iterable_type(typ: type) -> bool:
     """If the given type is `typing.Iterable[T]`"""
     origin = get_origin(typ) or typ

anchorbrowser/_utils/_utils.py

@@ -21,8 +21,7 @@ from typing_extensions import TypeGuard
 
 import sniffio
 
-from .._types import NotGiven, FileTypes, NotGivenOr, HeadersLike
-from .._compat import parse_date as parse_date, parse_datetime as parse_datetime
+from .._types import Omit, NotGiven, FileTypes, HeadersLike
 
 _T = TypeVar("_T")
 _TupleT = TypeVar("_TupleT", bound=Tuple[object, ...])
@@ -64,7 +63,7 @@ def _extract_items(
     try:
         key = path[index]
     except IndexError:
-        if isinstance(obj, NotGiven):
+        if not is_given(obj):
             # no value was provided - we can safely ignore
             return []
 
@@ -127,8 +126,8 @@ def _extract_items(
     return []
 
 
-def is_given(obj: NotGivenOr[_T]) -> TypeGuard[_T]:
-    return not isinstance(obj, NotGiven)
+def is_given(obj: _T | NotGiven | Omit) -> TypeGuard[_T]:
+    return not isinstance(obj, NotGiven) and not isinstance(obj, Omit)
 
 
 # Type safe methods for narrowing types with TypeVars.

anchorbrowser/_version.py

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

anchorbrowser/lib/browser.py

@@ -53,7 +53,7 @@ def get_cdp_url(api_base_url: str, session_id: str, api_key: str) -> str:
 
 
 def get_agent_ws_url(api_base_url: str, session_id: str) -> str:
-    return f"{api_base_url.replace('https://', 'wss://').replace('api.', 'connect.')}/ws?sessionId={session_id}"
+    return f"{api_base_url.replace('https://', 'wss://')}/ws?sessionId={session_id}"
 
 
 def get_ai_service_worker(browser_context: "BrowserContext") -> Optional["Worker"]:

anchorbrowser/resources/__init__.py

@@ -1,5 +1,13 @@
 # File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
 
+from .task import (
+    TaskResource,
+    AsyncTaskResource,
+    TaskResourceWithRawResponse,
+    AsyncTaskResourceWithRawResponse,
+    TaskResourceWithStreamingResponse,
+    AsyncTaskResourceWithStreamingResponse,
+)
 from .tools import (
     ToolsResource,
     AsyncToolsResource,
@@ -8,6 +16,14 @@ from .tools import (
     ToolsResourceWithStreamingResponse,
     AsyncToolsResourceWithStreamingResponse,
 )
+from .events import (
+    EventsResource,
+    AsyncEventsResource,
+    EventsResourceWithRawResponse,
+    AsyncEventsResourceWithRawResponse,
+    EventsResourceWithStreamingResponse,
+    AsyncEventsResourceWithStreamingResponse,
+)
 from .profiles import (
     ProfilesResource,
     AsyncProfilesResource,
@@ -32,6 +48,14 @@ from .extensions import (
     ExtensionsResourceWithStreamingResponse,
     AsyncExtensionsResourceWithStreamingResponse,
 )
+from .batch_sessions import (
+    BatchSessionsResource,
+    AsyncBatchSessionsResource,
+    BatchSessionsResourceWithRawResponse,
+    AsyncBatchSessionsResourceWithRawResponse,
+    BatchSessionsResourceWithStreamingResponse,
+    AsyncBatchSessionsResourceWithStreamingResponse,
+)
 
 __all__ = [
     "ProfilesResource",
@@ -58,4 +82,22 @@ __all__ = [
     "AsyncExtensionsResourceWithRawResponse",
     "ExtensionsResourceWithStreamingResponse",
     "AsyncExtensionsResourceWithStreamingResponse",
+    "EventsResource",
+    "AsyncEventsResource",
+    "EventsResourceWithRawResponse",
+    "AsyncEventsResourceWithRawResponse",
+    "EventsResourceWithStreamingResponse",
+    "AsyncEventsResourceWithStreamingResponse",
+    "BatchSessionsResource",
+    "AsyncBatchSessionsResource",
+    "BatchSessionsResourceWithRawResponse",
+    "AsyncBatchSessionsResourceWithRawResponse",
+    "BatchSessionsResourceWithStreamingResponse",
+    "AsyncBatchSessionsResourceWithStreamingResponse",
+    "TaskResource",
+    "AsyncTaskResource",
+    "TaskResourceWithRawResponse",
+    "AsyncTaskResourceWithRawResponse",
+    "TaskResourceWithStreamingResponse",
+    "AsyncTaskResourceWithStreamingResponse",
 ]

anchorbrowser/resources/batch_sessions.py

@@ -0,0 +1,288 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from __future__ import annotations
+
+from typing import Dict
+
+import httpx
+
+from ..types import batch_session_create_params
+from .._types import Body, Omit, Query, Headers, NotGiven, omit, not_given
+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 .._base_client import make_request_options
+from ..types.batch_session_create_response import BatchSessionCreateResponse
+from ..types.batch_session_retrieve_response import BatchSessionRetrieveResponse
+
+__all__ = ["BatchSessionsResource", "AsyncBatchSessionsResource"]
+
+
+class BatchSessionsResource(SyncAPIResource):
+    @cached_property
+    def with_raw_response(self) -> BatchSessionsResourceWithRawResponse:
+        """
+        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/anchorbrowser/AnchorBrowser-SDK-Python#accessing-raw-response-data-eg-headers
+        """
+        return BatchSessionsResourceWithRawResponse(self)
+
+    @cached_property
+    def with_streaming_response(self) -> BatchSessionsResourceWithStreamingResponse:
+        """
+        An alternative to `.with_raw_response` that doesn't eagerly read the response body.
+
+        For more information, see https://www.github.com/anchorbrowser/AnchorBrowser-SDK-Python#with_streaming_response
+        """
+        return BatchSessionsResourceWithStreamingResponse(self)
+
+    def create(
+        self,
+        *,
+        count: int,
+        configuration: batch_session_create_params.Configuration | Omit = omit,
+        metadata: Dict[str, object] | Omit = omit,
+        # 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,
+    ) -> BatchSessionCreateResponse:
+        """Creates multiple browser sessions in a single batch operation.
+
+        This endpoint
+        allows you to create up to 5,000 browser sessions simultaneously with the same
+        configuration.
+
+        The batch will be processed asynchronously, and you can monitor progress using
+        the batch status endpoint.
+
+        Args:
+          count: Number of sessions to create in the batch (1-1000)
+
+          configuration: Configuration that applies to all sessions in the batch
+
+          metadata: Optional batch-level metadata for identification and organization
+
+          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._post(
+            "/v1/batch-sessions",
+            body=maybe_transform(
+                {
+                    "count": count,
+                    "configuration": configuration,
+                    "metadata": metadata,
+                },
+                batch_session_create_params.BatchSessionCreateParams,
+            ),
+            options=make_request_options(
+                extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
+            ),
+            cast_to=BatchSessionCreateResponse,
+        )
+
+    def retrieve(
+        self,
+        batch_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,
+    ) -> BatchSessionRetrieveResponse:
+        """
+        Retrieves detailed status information for a specific batch, including progress,
+        individual session details, and any errors that occurred.
+
+        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 batch_id:
+            raise ValueError(f"Expected a non-empty value for `batch_id` but received {batch_id!r}")
+        return self._get(
+            f"/v1/batch-sessions/{batch_id}",
+            options=make_request_options(
+                extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
+            ),
+            cast_to=BatchSessionRetrieveResponse,
+        )
+
+
+class AsyncBatchSessionsResource(AsyncAPIResource):
+    @cached_property
+    def with_raw_response(self) -> AsyncBatchSessionsResourceWithRawResponse:
+        """
+        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/anchorbrowser/AnchorBrowser-SDK-Python#accessing-raw-response-data-eg-headers
+        """
+        return AsyncBatchSessionsResourceWithRawResponse(self)
+
+    @cached_property
+    def with_streaming_response(self) -> AsyncBatchSessionsResourceWithStreamingResponse:
+        """
+        An alternative to `.with_raw_response` that doesn't eagerly read the response body.
+
+        For more information, see https://www.github.com/anchorbrowser/AnchorBrowser-SDK-Python#with_streaming_response
+        """
+        return AsyncBatchSessionsResourceWithStreamingResponse(self)
+
+    async def create(
+        self,
+        *,
+        count: int,
+        configuration: batch_session_create_params.Configuration | Omit = omit,
+        metadata: Dict[str, object] | Omit = omit,
+        # 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,
+    ) -> BatchSessionCreateResponse:
+        """Creates multiple browser sessions in a single batch operation.
+
+        This endpoint
+        allows you to create up to 5,000 browser sessions simultaneously with the same
+        configuration.
+
+        The batch will be processed asynchronously, and you can monitor progress using
+        the batch status endpoint.
+
+        Args:
+          count: Number of sessions to create in the batch (1-1000)
+
+          configuration: Configuration that applies to all sessions in the batch
+
+          metadata: Optional batch-level metadata for identification and organization
+
+          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._post(
+            "/v1/batch-sessions",
+            body=await async_maybe_transform(
+                {
+                    "count": count,
+                    "configuration": configuration,
+                    "metadata": metadata,
+                },
+                batch_session_create_params.BatchSessionCreateParams,
+            ),
+            options=make_request_options(
+                extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
+            ),
+            cast_to=BatchSessionCreateResponse,
+        )
+
+    async def retrieve(
+        self,
+        batch_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,
+    ) -> BatchSessionRetrieveResponse:
+        """
+        Retrieves detailed status information for a specific batch, including progress,
+        individual session details, and any errors that occurred.
+
+        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 batch_id:
+            raise ValueError(f"Expected a non-empty value for `batch_id` but received {batch_id!r}")
+        return await self._get(
+            f"/v1/batch-sessions/{batch_id}",
+            options=make_request_options(
+                extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
+            ),
+            cast_to=BatchSessionRetrieveResponse,
+        )
+
+
+class BatchSessionsResourceWithRawResponse:
+    def __init__(self, batch_sessions: BatchSessionsResource) -> None:
+        self._batch_sessions = batch_sessions
+
+        self.create = to_raw_response_wrapper(
+            batch_sessions.create,
+        )
+        self.retrieve = to_raw_response_wrapper(
+            batch_sessions.retrieve,
+        )
+
+
+class AsyncBatchSessionsResourceWithRawResponse:
+    def __init__(self, batch_sessions: AsyncBatchSessionsResource) -> None:
+        self._batch_sessions = batch_sessions
+
+        self.create = async_to_raw_response_wrapper(
+            batch_sessions.create,
+        )
+        self.retrieve = async_to_raw_response_wrapper(
+            batch_sessions.retrieve,
+        )
+
+
+class BatchSessionsResourceWithStreamingResponse:
+    def __init__(self, batch_sessions: BatchSessionsResource) -> None:
+        self._batch_sessions = batch_sessions
+
+        self.create = to_streamed_response_wrapper(
+            batch_sessions.create,
+        )
+        self.retrieve = to_streamed_response_wrapper(
+            batch_sessions.retrieve,
+        )
+
+
+class AsyncBatchSessionsResourceWithStreamingResponse:
+    def __init__(self, batch_sessions: AsyncBatchSessionsResource) -> None:
+        self._batch_sessions = batch_sessions
+
+        self.create = async_to_streamed_response_wrapper(
+            batch_sessions.create,
+        )
+        self.retrieve = async_to_streamed_response_wrapper(
+            batch_sessions.retrieve,
+        )