anchorbrowser 0.1.0__py3-none-any.whl

anchorbrowser/resources/browser.py

@@ -0,0 +1,152 @@
+from __future__ import annotations
+
+from contextlib import _GeneratorContextManager, _AsyncGeneratorContextManager
+
+from playwright.sync_api import Browser
+from playwright.async_api import Browser as AsyncBrowser
+
+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 ..lib.browser import (
+    get_playwright_chromium_from_cdp_url,
+    get_async_playwright_chromium_from_cdp_url,
+)
+
+__all__ = ["BrowserResource", "AsyncBrowserResource"]
+
+
+class BrowserResource(SyncAPIResource):
+    @cached_property
+    def with_raw_response(self) -> BrowserResourceWithRawResponse:
+        """
+        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 BrowserResourceWithRawResponse(self)
+
+    @cached_property
+    def with_streaming_response(self) -> BrowserResourceWithStreamingResponse:
+        """
+        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 BrowserResourceWithStreamingResponse(self)
+
+    def connect(self, session_id: str) -> _GeneratorContextManager[Browser]:
+        """Connect to a browser session.
+
+        Args:
+            session_id (str): The ID of the session to connect to.
+
+        Returns:
+            BrowserContext: a context manager that can be used to interact with the browser(playwright)
+        """
+        return get_playwright_chromium_from_cdp_url(str(self._client.base_url), session_id, self._client.api_key)
+
+    def create(self) -> _GeneratorContextManager[Browser]:
+        session = self._client.sessions.create()
+        if not session.data or not session.data.id:
+            raise ValueError("Failed to create session")
+        return get_playwright_chromium_from_cdp_url(str(self._client.base_url), session.data.id, self._client.api_key)
+
+
+class AsyncBrowserResource(AsyncAPIResource):
+    @cached_property
+    def with_raw_response(self) -> AsyncBrowserResourceWithRawResponse:
+        """
+        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 AsyncBrowserResourceWithRawResponse(self)
+
+    @cached_property
+    def with_streaming_response(self) -> AsyncBrowserResourceWithStreamingResponse:
+        """
+        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 AsyncBrowserResourceWithStreamingResponse(self)
+
+    async def connect(self, session_id: str) -> _AsyncGeneratorContextManager[AsyncBrowser]:
+        """Connect to a browser session.
+
+        Args:
+            session_id (str): The ID of the session to connect to.
+
+        Returns:
+            BrowserContext: a context manager that can be used to interact with the browser(playwright)
+        """
+        return get_async_playwright_chromium_from_cdp_url(str(self._client.base_url), session_id, self._client.api_key)
+
+    async def create(self) -> _AsyncGeneratorContextManager[AsyncBrowser]:
+        """Create a new browser session.
+
+        Returns:
+            BrowserContext: a context manager that can be used to interact with the browser(playwright)
+        """
+        session = await self._client.sessions.create()
+        if not session.data or not session.data.id:
+            raise ValueError("Failed to create session")
+        return get_async_playwright_chromium_from_cdp_url(
+            str(self._client.base_url), session.data.id, self._client.api_key
+        )
+
+
+class BrowserResourceWithRawResponse:
+    def __init__(self, browser: BrowserResource) -> None:
+        self._browser = browser
+
+        self.connect = to_raw_response_wrapper(
+            browser.connect,
+        )
+        self.create = to_raw_response_wrapper(
+            browser.create,
+        )
+
+
+class AsyncBrowserResourceWithRawResponse:
+    def __init__(self, browser: AsyncBrowserResource) -> None:
+        self._browser = browser
+
+        self.connect = async_to_raw_response_wrapper(
+            browser.connect,
+        )
+        self.create = async_to_raw_response_wrapper(
+            browser.create,
+        )
+
+
+class BrowserResourceWithStreamingResponse:
+    def __init__(self, browser: BrowserResource) -> None:
+        self._browser = browser
+
+        self.connect = to_streamed_response_wrapper(
+            browser.connect,
+        )
+        self.create = to_streamed_response_wrapper(
+            browser.create,
+        )
+
+
+class AsyncBrowserResourceWithStreamingResponse:
+    def __init__(self, browser: AsyncBrowserResource) -> None:
+        self._browser = browser
+
+        self.connect = async_to_streamed_response_wrapper(
+            browser.connect,
+        )
+        self.create = async_to_streamed_response_wrapper(
+            browser.create,
+        )

anchorbrowser/resources/extensions.py

@@ -0,0 +1,412 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from __future__ import annotations
+
+from typing import Mapping, cast
+
+import httpx
+
+from ..types import extension_upload_params
+from .._types import NOT_GIVEN, Body, Query, Headers, NotGiven, FileTypes
+from .._utils import extract_files, maybe_transform, deepcopy_minimal, async_maybe_transform
+from .._compat import cached_property
+from .._resource import SyncAPIResource, AsyncAPIResource
+from .._response import (
+    to_raw_response_wrapper,
+    to_streamed_response_wrapper,
+    async_to_raw_response_wrapper,
+    async_to_streamed_response_wrapper,
+)
+from .._base_client import make_request_options
+from ..types.extension_list_response import ExtensionListResponse
+from ..types.extension_delete_response import ExtensionDeleteResponse
+from ..types.extension_upload_response import ExtensionUploadResponse
+from ..types.extension_retrieve_response import ExtensionRetrieveResponse
+
+__all__ = ["ExtensionsResource", "AsyncExtensionsResource"]
+
+
+class ExtensionsResource(SyncAPIResource):
+    @cached_property
+    def with_raw_response(self) -> ExtensionsResourceWithRawResponse:
+        """
+        This property can be used as a prefix for any HTTP method call to return
+        the raw response object instead of the parsed content.
+
+        For more information, see https://www.github.com/anchorbrowser/AnchorBrowser-SDK-Python#accessing-raw-response-data-eg-headers
+        """
+        return ExtensionsResourceWithRawResponse(self)
+
+    @cached_property
+    def with_streaming_response(self) -> ExtensionsResourceWithStreamingResponse:
+        """
+        An alternative to `.with_raw_response` that doesn't eagerly read the response body.
+
+        For more information, see https://www.github.com/anchorbrowser/AnchorBrowser-SDK-Python#with_streaming_response
+        """
+        return ExtensionsResourceWithStreamingResponse(self)
+
+    def retrieve(
+        self,
+        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,
+    ) -> ExtensionRetrieveResponse:
+        """
+        Get details of a specific extension by its ID
+
+        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 id:
+            raise ValueError(f"Expected a non-empty value for `id` but received {id!r}")
+        return self._get(
+            f"/v1/extensions/{id}",
+            options=make_request_options(
+                extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
+            ),
+            cast_to=ExtensionRetrieveResponse,
+        )
+
+    def list(
+        self,
+        *,
+        # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs.
+        # The extra values given here take precedence over values defined on the client or passed to this method.
+        extra_headers: Headers | None = None,
+        extra_query: Query | None = None,
+        extra_body: Body | None = None,
+        timeout: float | httpx.Timeout | None | NotGiven = NOT_GIVEN,
+    ) -> ExtensionListResponse:
+        """Get all extensions for the authenticated user"""
+        return self._get(
+            "/v1/extensions",
+            options=make_request_options(
+                extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
+            ),
+            cast_to=ExtensionListResponse,
+        )
+
+    def delete(
+        self,
+        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,
+    ) -> ExtensionDeleteResponse:
+        """
+        Delete an extension and remove it from storage
+
+        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 id:
+            raise ValueError(f"Expected a non-empty value for `id` but received {id!r}")
+        return self._delete(
+            f"/v1/extensions/{id}",
+            options=make_request_options(
+                extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
+            ),
+            cast_to=ExtensionDeleteResponse,
+        )
+
+    def upload(
+        self,
+        *,
+        file: FileTypes,
+        name: 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,
+    ) -> ExtensionUploadResponse:
+        """Upload a new browser extension as a ZIP file.
+
+        The extension will be validated
+        and stored for use in browser sessions.
+
+        Args:
+          file: ZIP file containing the browser extension
+
+          name: User-friendly name for the extension (1-255 characters)
+
+          extra_headers: Send extra headers
+
+          extra_query: Add additional query parameters to the request
+
+          extra_body: Add additional JSON properties to the request
+
+          timeout: Override the client-level default timeout for this request, in seconds
+        """
+        body = deepcopy_minimal(
+            {
+                "file": file,
+                "name": name,
+            }
+        )
+        files = extract_files(cast(Mapping[str, object], body), paths=[["file"]])
+        # It should be noted that the actual Content-Type header that will be
+        # sent to the server will contain a `boundary` parameter, e.g.
+        # multipart/form-data; boundary=---abc--
+        extra_headers = {"Content-Type": "multipart/form-data", **(extra_headers or {})}
+        return self._post(
+            "/v1/extensions",
+            body=maybe_transform(body, extension_upload_params.ExtensionUploadParams),
+            files=files,
+            options=make_request_options(
+                extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
+            ),
+            cast_to=ExtensionUploadResponse,
+        )
+
+
+class AsyncExtensionsResource(AsyncAPIResource):
+    @cached_property
+    def with_raw_response(self) -> AsyncExtensionsResourceWithRawResponse:
+        """
+        This property can be used as a prefix for any HTTP method call to return
+        the raw response object instead of the parsed content.
+
+        For more information, see https://www.github.com/anchorbrowser/AnchorBrowser-SDK-Python#accessing-raw-response-data-eg-headers
+        """
+        return AsyncExtensionsResourceWithRawResponse(self)
+
+    @cached_property
+    def with_streaming_response(self) -> AsyncExtensionsResourceWithStreamingResponse:
+        """
+        An alternative to `.with_raw_response` that doesn't eagerly read the response body.
+
+        For more information, see https://www.github.com/anchorbrowser/AnchorBrowser-SDK-Python#with_streaming_response
+        """
+        return AsyncExtensionsResourceWithStreamingResponse(self)
+
+    async def retrieve(
+        self,
+        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,
+    ) -> ExtensionRetrieveResponse:
+        """
+        Get details of a specific extension by its ID
+
+        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 id:
+            raise ValueError(f"Expected a non-empty value for `id` but received {id!r}")
+        return await self._get(
+            f"/v1/extensions/{id}",
+            options=make_request_options(
+                extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
+            ),
+            cast_to=ExtensionRetrieveResponse,
+        )
+
+    async def list(
+        self,
+        *,
+        # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs.
+        # The extra values given here take precedence over values defined on the client or passed to this method.
+        extra_headers: Headers | None = None,
+        extra_query: Query | None = None,
+        extra_body: Body | None = None,
+        timeout: float | httpx.Timeout | None | NotGiven = NOT_GIVEN,
+    ) -> ExtensionListResponse:
+        """Get all extensions for the authenticated user"""
+        return await self._get(
+            "/v1/extensions",
+            options=make_request_options(
+                extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
+            ),
+            cast_to=ExtensionListResponse,
+        )
+
+    async def delete(
+        self,
+        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,
+    ) -> ExtensionDeleteResponse:
+        """
+        Delete an extension and remove it from storage
+
+        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 id:
+            raise ValueError(f"Expected a non-empty value for `id` but received {id!r}")
+        return await self._delete(
+            f"/v1/extensions/{id}",
+            options=make_request_options(
+                extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
+            ),
+            cast_to=ExtensionDeleteResponse,
+        )
+
+    async def upload(
+        self,
+        *,
+        file: FileTypes,
+        name: 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,
+    ) -> ExtensionUploadResponse:
+        """Upload a new browser extension as a ZIP file.
+
+        The extension will be validated
+        and stored for use in browser sessions.
+
+        Args:
+          file: ZIP file containing the browser extension
+
+          name: User-friendly name for the extension (1-255 characters)
+
+          extra_headers: Send extra headers
+
+          extra_query: Add additional query parameters to the request
+
+          extra_body: Add additional JSON properties to the request
+
+          timeout: Override the client-level default timeout for this request, in seconds
+        """
+        body = deepcopy_minimal(
+            {
+                "file": file,
+                "name": name,
+            }
+        )
+        files = extract_files(cast(Mapping[str, object], body), paths=[["file"]])
+        # It should be noted that the actual Content-Type header that will be
+        # sent to the server will contain a `boundary` parameter, e.g.
+        # multipart/form-data; boundary=---abc--
+        extra_headers = {"Content-Type": "multipart/form-data", **(extra_headers or {})}
+        return await self._post(
+            "/v1/extensions",
+            body=await async_maybe_transform(body, extension_upload_params.ExtensionUploadParams),
+            files=files,
+            options=make_request_options(
+                extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
+            ),
+            cast_to=ExtensionUploadResponse,
+        )
+
+
+class ExtensionsResourceWithRawResponse:
+    def __init__(self, extensions: ExtensionsResource) -> None:
+        self._extensions = extensions
+
+        self.retrieve = to_raw_response_wrapper(
+            extensions.retrieve,
+        )
+        self.list = to_raw_response_wrapper(
+            extensions.list,
+        )
+        self.delete = to_raw_response_wrapper(
+            extensions.delete,
+        )
+        self.upload = to_raw_response_wrapper(
+            extensions.upload,
+        )
+
+
+class AsyncExtensionsResourceWithRawResponse:
+    def __init__(self, extensions: AsyncExtensionsResource) -> None:
+        self._extensions = extensions
+
+        self.retrieve = async_to_raw_response_wrapper(
+            extensions.retrieve,
+        )
+        self.list = async_to_raw_response_wrapper(
+            extensions.list,
+        )
+        self.delete = async_to_raw_response_wrapper(
+            extensions.delete,
+        )
+        self.upload = async_to_raw_response_wrapper(
+            extensions.upload,
+        )
+
+
+class ExtensionsResourceWithStreamingResponse:
+    def __init__(self, extensions: ExtensionsResource) -> None:
+        self._extensions = extensions
+
+        self.retrieve = to_streamed_response_wrapper(
+            extensions.retrieve,
+        )
+        self.list = to_streamed_response_wrapper(
+            extensions.list,
+        )
+        self.delete = to_streamed_response_wrapper(
+            extensions.delete,
+        )
+        self.upload = to_streamed_response_wrapper(
+            extensions.upload,
+        )
+
+
+class AsyncExtensionsResourceWithStreamingResponse:
+    def __init__(self, extensions: AsyncExtensionsResource) -> None:
+        self._extensions = extensions
+
+        self.retrieve = async_to_streamed_response_wrapper(
+            extensions.retrieve,
+        )
+        self.list = async_to_streamed_response_wrapper(
+            extensions.list,
+        )
+        self.delete = async_to_streamed_response_wrapper(
+            extensions.delete,
+        )
+        self.upload = async_to_streamed_response_wrapper(
+            extensions.upload,
+        )