pure-patchright 1.52.5__py3-none-any.whl

patchright/_impl/_browser_type.py

@@ -0,0 +1,276 @@
+import asyncio
+import pathlib
+import sys
+from pathlib import Path
+from typing import TYPE_CHECKING, Dict, List, Optional, Pattern, Sequence, Union, cast
+from patchright._impl._api_structures import (
+    ClientCertificate,
+    Geolocation,
+    HttpCredentials,
+    ProxySettings,
+    ViewportSize,
+)
+from patchright._impl._browser import Browser, prepare_browser_context_params
+from patchright._impl._browser_context import BrowserContext
+from patchright._impl._connection import (
+    ChannelOwner,
+    Connection,
+    from_channel,
+    from_nullable_channel,
+)
+from patchright._impl._errors import Error
+from patchright._impl._helper import (
+    ColorScheme,
+    Contrast,
+    Env,
+    ForcedColors,
+    HarContentPolicy,
+    HarMode,
+    ReducedMotion,
+    ServiceWorkersPolicy,
+    locals_to_params,
+)
+from patchright._impl._json_pipe import JsonPipeTransport
+from patchright._impl._network import serialize_headers
+from patchright._impl._waiter import throw_on_timeout
+
+if TYPE_CHECKING:
+    from patchright._impl._playwright import Playwright
+
+
+class BrowserType(ChannelOwner):
+
+    def __init__(
+        self, parent: ChannelOwner, type: str, guid: str, initializer: Dict
+    ) -> None:
+        super().__init__(parent, type, guid, initializer)
+        self._playwright: "Playwright"
+
+    def __repr__(self) -> str:
+        return f"<BrowserType name={self.name} executable_path={self.executable_path}>"
+
+    @property
+    def name(self) -> str:
+        return self._initializer["name"]
+
+    @property
+    def executable_path(self) -> str:
+        return self._initializer["executablePath"]
+
+    async def launch(
+        self,
+        executablePath: Union[str, Path] = None,
+        channel: str = None,
+        args: Sequence[str] = None,
+        ignoreDefaultArgs: Union[bool, Sequence[str]] = None,
+        handleSIGINT: bool = None,
+        handleSIGTERM: bool = None,
+        handleSIGHUP: bool = None,
+        timeout: float = None,
+        env: Env = None,
+        headless: bool = None,
+        devtools: bool = None,
+        proxy: ProxySettings = None,
+        downloadsPath: Union[str, Path] = None,
+        slowMo: float = None,
+        tracesDir: Union[pathlib.Path, str] = None,
+        chromiumSandbox: bool = None,
+        firefoxUserPrefs: Dict[str, Union[str, float, bool]] = None,
+    ) -> Browser:
+        params = locals_to_params(locals())
+        normalize_launch_params(params)
+        browser = cast(
+            Browser, from_channel(await self._channel.send("launch", params))
+        )
+        self._did_launch_browser(browser)
+        return browser
+
+    async def launch_persistent_context(
+        self,
+        userDataDir: Union[str, Path],
+        channel: str = None,
+        executablePath: Union[str, Path] = None,
+        args: Sequence[str] = None,
+        ignoreDefaultArgs: Union[bool, Sequence[str]] = None,
+        handleSIGINT: bool = None,
+        handleSIGTERM: bool = None,
+        handleSIGHUP: bool = None,
+        timeout: float = None,
+        env: Env = None,
+        headless: bool = None,
+        devtools: bool = None,
+        proxy: ProxySettings = None,
+        downloadsPath: Union[str, Path] = None,
+        slowMo: float = None,
+        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,
+        tracesDir: Union[pathlib.Path, str] = None,
+        chromiumSandbox: bool = None,
+        firefoxUserPrefs: Dict[str, Union[str, float, bool]] = None,
+        recordHarPath: Union[Path, str] = None,
+        recordHarOmitContent: bool = None,
+        recordVideoDir: Union[Path, str] = None,
+        recordVideoSize: ViewportSize = 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,
+    ) -> BrowserContext:
+        userDataDir = self._user_data_dir(userDataDir)
+        params = locals_to_params(locals())
+        await prepare_browser_context_params(params)
+        normalize_launch_params(params)
+        context = cast(
+            BrowserContext,
+            from_channel(await self._channel.send("launchPersistentContext", params)),
+        )
+        self._did_create_context(context, params, params)
+        return context
+
+    def _user_data_dir(self, userDataDir: Optional[Union[str, Path]]) -> str:
+        if not userDataDir:
+            return ""
+        if not Path(userDataDir).is_absolute():
+            if sys.platform == "win32" and sys.version_info[:2] < (3, 10):
+                return pathlib.Path.cwd() / userDataDir
+            return str(Path(userDataDir).resolve())
+        return str(Path(userDataDir))
+
+    async def connect_over_cdp(
+        self,
+        endpointURL: str,
+        timeout: float = None,
+        slowMo: float = None,
+        headers: Dict[str, str] = None,
+    ) -> Browser:
+        params = locals_to_params(locals())
+        if params.get("headers"):
+            params["headers"] = serialize_headers(params["headers"])
+        response = await self._channel.send_return_as_dict("connectOverCDP", params)
+        browser = cast(Browser, from_channel(response["browser"]))
+        self._did_launch_browser(browser)
+        default_context = cast(
+            Optional[BrowserContext],
+            from_nullable_channel(response.get("defaultContext")),
+        )
+        if default_context:
+            self._did_create_context(default_context, {}, {})
+        return browser
+
+    async def connect(
+        self,
+        wsEndpoint: str,
+        timeout: float = None,
+        slowMo: float = None,
+        headers: Dict[str, str] = None,
+        exposeNetwork: str = None,
+    ) -> Browser:
+        if timeout is None:
+            timeout = 30000
+        if slowMo is None:
+            slowMo = 0
+        headers = {**(headers if headers else {}), "x-playwright-browser": self.name}
+        local_utils = self._connection.local_utils
+        pipe_channel = (
+            await local_utils._channel.send_return_as_dict(
+                "connect",
+                {
+                    "wsEndpoint": wsEndpoint,
+                    "headers": headers,
+                    "slowMo": slowMo,
+                    "timeout": timeout,
+                    "exposeNetwork": exposeNetwork,
+                },
+            )
+        )["pipe"]
+        transport = JsonPipeTransport(self._connection._loop, pipe_channel)
+        connection = Connection(
+            self._connection._dispatcher_fiber,
+            self._connection._object_factory,
+            transport,
+            self._connection._loop,
+            local_utils=self._connection.local_utils,
+        )
+        connection.mark_as_remote()
+        browser = None
+
+        def handle_transport_close(reason: Optional[str]) -> None:
+            if browser:
+                for context in browser.contexts:
+                    for page in context.pages:
+                        page._on_close()
+                    context._on_close()
+                browser._on_close()
+            connection.cleanup(reason)
+
+        transport.once("close", handle_transport_close)
+        connection._is_sync = self._connection._is_sync
+        connection._loop.create_task(connection.run())
+        playwright_future = connection.playwright_future
+        timeout_future = throw_on_timeout(timeout, Error("Connection timed out"))
+        done, pending = await asyncio.wait(
+            {transport.on_error_future, playwright_future, timeout_future},
+            return_when=asyncio.FIRST_COMPLETED,
+        )
+        if not playwright_future.done():
+            playwright_future.cancel()
+        if not timeout_future.done():
+            timeout_future.cancel()
+        playwright: "Playwright" = next(iter(done)).result()
+        playwright._set_selectors(self._playwright.selectors)
+        self._connection._child_ws_connections.append(connection)
+        pre_launched_browser = playwright._initializer.get("preLaunchedBrowser")
+        assert pre_launched_browser
+        browser = cast(Browser, from_channel(pre_launched_browser))
+        self._did_launch_browser(browser)
+        browser._should_close_connection_on_close = True
+        return browser
+
+    def _did_create_context(
+        self, context: BrowserContext, context_options: Dict, browser_options: Dict
+    ) -> None:
+        context._set_options(context_options, browser_options)
+
+    def _did_launch_browser(self, browser: Browser) -> None:
+        browser._browser_type = self
+
+
+def normalize_launch_params(params: Dict) -> None:
+    if "env" in params:
+        params["env"] = [
+            {"name": name, "value": str(value)}
+            for [name, value] in params["env"].items()
+        ]
+    if "ignoreDefaultArgs" in params:
+        if params["ignoreDefaultArgs"] is True:
+            params["ignoreAllDefaultArgs"] = True
+            del params["ignoreDefaultArgs"]
+    if "executablePath" in params:
+        params["executablePath"] = str(Path(params["executablePath"]))
+    if "downloadsPath" in params:
+        params["downloadsPath"] = str(Path(params["downloadsPath"]))
+    if "tracesDir" in params:
+        params["tracesDir"] = str(Path(params["tracesDir"]))

patchright/_impl/_cdp_session.py

@@ -0,0 +1,21 @@
+from typing import Any, Dict
+from patchright._impl._connection import ChannelOwner
+from patchright._impl._helper import locals_to_params
+
+
+class CDPSession(ChannelOwner):
+
+    def __init__(
+        self, parent: ChannelOwner, type: str, guid: str, initializer: Dict
+    ) -> None:
+        super().__init__(parent, type, guid, initializer)
+        self._channel.on("event", lambda params: self._on_event(params))
+
+    def _on_event(self, params: Any) -> None:
+        self.emit(params["method"], params.get("params"))
+
+    async def send(self, method: str, params: Dict = None) -> Dict:
+        return await self._channel.send("send", locals_to_params(locals()))
+
+    async def detach(self) -> None:
+        await self._channel.send("detach")

patchright/_impl/_clock.py

@@ -0,0 +1,57 @@
+import datetime
+from typing import TYPE_CHECKING, Dict, Union
+
+if TYPE_CHECKING:
+    from patchright._impl._browser_context import BrowserContext
+
+
+class Clock:
+
+    def __init__(self, browser_context: "BrowserContext") -> None:
+        self._browser_context = browser_context
+        self._loop = browser_context._loop
+        self._dispatcher_fiber = browser_context._dispatcher_fiber
+
+    async def install(self, time: Union[float, str, datetime.datetime] = None) -> None:
+        await self._browser_context.install_inject_route()
+        await self._browser_context._channel.send(
+            "clockInstall", parse_time(time) if time is not None else {}
+        )
+
+    async def fast_forward(self, ticks: Union[int, str]) -> None:
+        await self._browser_context._channel.send(
+            "clockFastForward", parse_ticks(ticks)
+        )
+
+    async def pause_at(self, time: Union[float, str, datetime.datetime]) -> None:
+        await self._browser_context._channel.send("clockPauseAt", parse_time(time))
+
+    async def resume(self) -> None:
+        await self._browser_context._channel.send("clockResume")
+
+    async def run_for(self, ticks: Union[int, str]) -> None:
+        await self._browser_context._channel.send("clockRunFor", parse_ticks(ticks))
+
+    async def set_fixed_time(self, time: Union[float, str, datetime.datetime]) -> None:
+        await self._browser_context._channel.send("clockSetFixedTime", parse_time(time))
+
+    async def set_system_time(self, time: Union[float, str, datetime.datetime]) -> None:
+        await self._browser_context._channel.send(
+            "clockSetSystemTime", parse_time(time)
+        )
+
+
+def parse_time(
+    time: Union[float, str, datetime.datetime],
+) -> Dict[str, Union[int, str]]:
+    if isinstance(time, (float, int)):
+        return {"timeNumber": int(time * 1000)}
+    if isinstance(time, str):
+        return {"timeString": time}
+    return {"timeNumber": int(time.timestamp() * 1000)}
+
+
+def parse_ticks(ticks: Union[int, str]) -> Dict[str, Union[int, str]]:
+    if isinstance(ticks, int):
+        return {"ticksNumber": ticks}
+    return {"ticksString": ticks}