pure-patchright 1.62.3__py3-none-any.whl

patchright/_impl/_async_base.py

@@ -0,0 +1,88 @@
+import asyncio
+from contextlib import AbstractAsyncContextManager
+from types import TracebackType
+from typing import Any, Callable, Generic, Optional, Type, TypeVar, Union
+from patchright._impl._impl_to_api_mapping import ImplToApiMapping, ImplWrapper
+
+mapping = ImplToApiMapping()
+T = TypeVar("T")
+Self = TypeVar("Self", bound="AsyncContextManager")
+
+
+class AsyncEventInfo(Generic[T]):
+    def __init__(self, future: "asyncio.Future[T]") -> None:
+        self._future = future
+
+    @property
+    async def value(self) -> T:
+        return mapping.from_maybe_impl(await self._future)
+
+    def _cancel(self) -> None:
+        self._future.cancel()
+
+    def is_done(self) -> bool:
+        return self._future.done()
+
+
+class AsyncEventContextManager(Generic[T], AbstractAsyncContextManager):
+    def __init__(self, future: "asyncio.Future[T]") -> None:
+        self._event = AsyncEventInfo[T](future)
+
+    async def __aenter__(self) -> AsyncEventInfo[T]:
+        return self._event
+
+    async def __aexit__(
+        self,
+        exc_type: Optional[Type[BaseException]],
+        exc_val: Optional[BaseException],
+        exc_tb: Optional[TracebackType],
+    ) -> None:
+        if exc_val:
+            self._event._cancel()
+        else:
+            await self._event.value
+
+
+class AsyncBase(ImplWrapper):
+    def __init__(self, impl_obj: Any) -> None:
+        super().__init__(impl_obj)
+        self._loop = impl_obj._loop
+
+    def __str__(self) -> str:
+        return self._impl_obj.__str__()
+
+    def _wrap_handler(
+        self, handler: Union[Callable[..., Any], Any]
+    ) -> Callable[..., None]:
+        if callable(handler):
+            return mapping.wrap_handler(handler)
+        return handler
+
+    def on(self, event: Any, f: Any) -> None:
+        """Registers the function ``f`` to the event name ``event``."""
+        self._impl_obj.on(event, self._wrap_handler(f))
+
+    def once(self, event: Any, f: Any) -> None:
+        """The same as ``self.on``, except that the listener is automatically
+        removed after being called.
+        """
+        self._impl_obj.once(event, self._wrap_handler(f))
+
+    def remove_listener(self, event: Any, f: Any) -> None:
+        """Removes the function ``f`` from ``event``."""
+        self._impl_obj.remove_listener(event, self._wrap_handler(f))
+
+
+class AsyncContextManager(AsyncBase):
+    async def __aenter__(self: Self) -> Self:
+        return self
+
+    async def __aexit__(
+        self,
+        exc_type: Optional[Type[BaseException]],
+        exc_val: Optional[BaseException],
+        traceback: Optional[TracebackType],
+    ) -> None:
+        await self.close()
+
+    async def close(self) -> None: ...

patchright/_impl/_browser.py

@@ -0,0 +1,267 @@
+from pathlib import Path
+from types import SimpleNamespace
+from typing import (
+    TYPE_CHECKING,
+    Dict,
+    List,
+    Optional,
+    Pattern,
+    Sequence,
+    Set,
+    Union,
+    cast,
+)
+from patchright._impl._api_structures import (
+    BrowserBindResult,
+    ClientCertificate,
+    Geolocation,
+    HttpCredentials,
+    ProxySettings,
+    StorageState,
+    ViewportSize,
+)
+from patchright._impl._artifact import Artifact
+from patchright._impl._browser_context import BrowserContext
+from patchright._impl._cdp_session import CDPSession
+from patchright._impl._connection import ChannelOwner, from_channel
+from patchright._impl._errors import is_target_closed_error
+from patchright._impl._helper import (
+    ColorScheme,
+    Contrast,
+    ForcedColors,
+    HarContentPolicy,
+    HarMode,
+    ReducedMotion,
+    ServiceWorkersPolicy,
+    locals_to_params,
+    make_dirs_for_file,
+)
+from patchright._impl._page import Page
+
+if TYPE_CHECKING:
+    from patchright._impl._browser_type import BrowserType
+
+
+class Browser(ChannelOwner):
+    Events = SimpleNamespace(Context="context", Disconnected="disconnected")
+
+    def __init__(
+        self, parent: "BrowserType", type: str, guid: str, initializer: Dict
+    ) -> None:
+        super().__init__(parent, type, guid, initializer)
+        self._browser_type: Optional["BrowserType"] = None
+        self._is_connected = True
+        self._should_close_connection_on_close = False
+        self._cr_tracing_path: Optional[str] = None
+        self._contexts: Set[BrowserContext] = set()
+        self._traces_dir: Optional[str] = None
+        self._channel.on(
+            "context",
+            lambda params: self._did_create_context(
+                cast(BrowserContext, from_channel(params["context"]))
+            ),
+        )
+        self._channel.on("close", lambda _: self._on_close())
+        self._close_reason: Optional[str] = None
+
+    def __repr__(self) -> str:
+        return f"<Browser type={self._browser_type} version={self.version}>"
+
+    def _connect_to_browser_type(
+        self, browser_type: "BrowserType", traces_dir: Optional[str] = None
+    ) -> None:
+        self._browser_type = browser_type
+        self._traces_dir = traces_dir
+        for context in self._contexts:
+            self._setup_browser_context(context)
+
+    def _did_create_context(self, context: BrowserContext) -> None:
+        context._browser = self
+        self._contexts.add(context)
+        if self._browser_type:
+            self._setup_browser_context(context)
+        self.emit(Browser.Events.Context, context)
+
+    def _setup_browser_context(self, context: BrowserContext) -> None:
+        context._tracing._traces_dir = self._traces_dir
+        assert self._browser_type is not None
+        self._browser_type._playwright.selectors._contexts_for_selectors.add(context)
+
+    def _on_close(self) -> None:
+        self._is_connected = False
+        self.emit(Browser.Events.Disconnected, self)
+
+    @property
+    def contexts(self) -> List[BrowserContext]:
+        return list(self._contexts)
+
+    @property
+    def browser_type(self) -> "BrowserType":
+        assert self._browser_type is not None
+        return self._browser_type
+
+    def is_connected(self) -> bool:
+        return self._is_connected
+
+    async def new_context(
+        self,
+        viewport: ViewportSize = None,
+        screen: ViewportSize = None,
+        noViewport: bool = None,
+        ignoreHTTPSErrors: bool = None,
+        javaScriptEnabled: bool = None,
+        bypassCSP: bool = None,
+        userAgent: str = None,
+        locale: str = None,
+        timezoneId: str = None,
+        geolocation: Geolocation = None,
+        permissions: Sequence[str] = None,
+        extraHTTPHeaders: Dict[str, str] = None,
+        offline: bool = None,
+        httpCredentials: HttpCredentials = None,
+        deviceScaleFactor: float = None,
+        isMobile: bool = None,
+        hasTouch: bool = None,
+        colorScheme: ColorScheme = None,
+        reducedMotion: ReducedMotion = None,
+        forcedColors: ForcedColors = None,
+        contrast: Contrast = None,
+        acceptDownloads: bool = None,
+        defaultBrowserType: str = None,
+        proxy: ProxySettings = None,
+        recordHarPath: Union[Path, str] = None,
+        recordHarOmitContent: bool = None,
+        recordVideoDir: Union[Path, str] = None,
+        recordVideoSize: ViewportSize = None,
+        storageState: Union[StorageState, str, Path] = None,
+        baseURL: str = None,
+        strictSelectors: bool = None,
+        serviceWorkers: ServiceWorkersPolicy = None,
+        recordHarUrlFilter: Union[Pattern[str], str] = None,
+        recordHarMode: HarMode = None,
+        recordHarContent: HarContentPolicy = None,
+        clientCertificates: List[ClientCertificate] = None,
+        *,
+        focusControl: Optional[bool] = None,
+    ) -> BrowserContext:
+        params = locals_to_params(locals())
+        assert self._browser_type is not None
+        await self._browser_type._prepare_browser_context_params(params)
+        channel = await self._channel.send("newContext", None, params)
+        context = cast(BrowserContext, from_channel(channel))
+        await context._initialize_har_from_options(
+            record_har_content=recordHarContent,
+            record_har_mode=recordHarMode,
+            record_har_omit_content=recordHarOmitContent,
+            record_har_path=recordHarPath,
+            record_har_url_filter=recordHarUrlFilter,
+        )
+        return context
+
+    async def new_page(
+        self,
+        viewport: ViewportSize = None,
+        screen: ViewportSize = None,
+        noViewport: bool = None,
+        ignoreHTTPSErrors: bool = None,
+        javaScriptEnabled: bool = None,
+        bypassCSP: bool = None,
+        userAgent: str = None,
+        locale: str = None,
+        timezoneId: str = None,
+        geolocation: Geolocation = None,
+        permissions: Sequence[str] = None,
+        extraHTTPHeaders: Dict[str, str] = None,
+        offline: bool = None,
+        httpCredentials: HttpCredentials = None,
+        deviceScaleFactor: float = None,
+        isMobile: bool = None,
+        hasTouch: bool = None,
+        colorScheme: ColorScheme = None,
+        forcedColors: ForcedColors = None,
+        contrast: Contrast = None,
+        reducedMotion: ReducedMotion = None,
+        acceptDownloads: bool = None,
+        defaultBrowserType: str = None,
+        proxy: ProxySettings = None,
+        recordHarPath: Union[Path, str] = None,
+        recordHarOmitContent: bool = None,
+        recordVideoDir: Union[Path, str] = None,
+        recordVideoSize: ViewportSize = None,
+        storageState: Union[StorageState, str, Path] = None,
+        baseURL: str = None,
+        strictSelectors: bool = None,
+        serviceWorkers: ServiceWorkersPolicy = None,
+        recordHarUrlFilter: Union[Pattern[str], str] = None,
+        recordHarMode: HarMode = None,
+        recordHarContent: HarContentPolicy = None,
+        clientCertificates: List[ClientCertificate] = None,
+        *,
+        focusControl: Optional[bool] = None,
+    ) -> Page:
+        params = locals_to_params(locals())
+
+        async def inner() -> Page:
+            context = await self.new_context(**params)
+            page = await context.new_page()
+            page._owned_context = context
+            context._owner_page = page
+            return page
+
+        return await self._connection.wrap_api_call(inner, title="Create page")
+
+    async def close(self, reason: str = None) -> None:
+        self._close_reason = reason
+        try:
+            if self._should_close_connection_on_close:
+                await self._connection.stop_async()
+            else:
+                await self._channel.send("close", None, {"reason": reason})
+        except Exception as e:
+            if not is_target_closed_error(e):
+                raise e
+
+    @property
+    def version(self) -> str:
+        return self._initializer["version"]
+
+    async def new_browser_cdp_session(self) -> CDPSession:
+        return from_channel(await self._channel.send("newBrowserCDPSession", None))
+
+    async def bind(
+        self, title: str, workspaceDir: str = None, host: str = None, port: int = None
+    ) -> BrowserBindResult:
+        return await self._channel.send_return_as_dict(
+            "startServer", None, locals_to_params(locals())
+        )
+
+    async def unbind(self) -> None:
+        await self._channel.send("stopServer", None)
+
+    async def start_tracing(
+        self,
+        page: Page = None,
+        path: Union[str, Path] = None,
+        screenshots: bool = None,
+        categories: Sequence[str] = None,
+    ) -> None:
+        params = locals_to_params(locals())
+        if page:
+            params["page"] = page._channel
+        if path:
+            self._cr_tracing_path = str(path)
+            params["path"] = str(path)
+        await self._channel.send("startTracing", None, params)
+
+    async def stop_tracing(self) -> bytes:
+        artifact = cast(
+            Artifact, from_channel(await self._channel.send("stopTracing", None))
+        )
+        buffer = await artifact.read_info_buffer()
+        await artifact.delete()
+        if self._cr_tracing_path:
+            make_dirs_for_file(self._cr_tracing_path)
+            with open(self._cr_tracing_path, "wb") as f:
+                f.write(buffer)
+            self._cr_tracing_path = None
+        return buffer