patchright 1.48.0__py3-none-win32.whl

patchright/_impl/_transport.py

@@ -0,0 +1,150 @@
+import asyncio
+import io
+import json
+import os
+import subprocess
+import sys
+from abc import ABC, abstractmethod
+from typing import Callable, Dict, Optional, Union
+from patchright._impl._driver import compute_driver_executable, get_driver_env
+from patchright._impl._helper import ParsedMessagePayload
+
+
+def _get_stderr_fileno() -> Optional[int]:
+    try:
+        if sys.stderr is None or not hasattr(sys.stderr, "closed"):
+            return None
+        if sys.stderr.closed:
+            return None
+        return sys.stderr.fileno()
+    except (NotImplementedError, AttributeError, io.UnsupportedOperation):
+        if not hasattr(sys, "__stderr__") or not sys.__stderr__:
+            return None
+        return sys.__stderr__.fileno()
+
+
+class Transport(ABC):
+
+    def __init__(self, loop: asyncio.AbstractEventLoop) -> None:
+        self._loop = loop
+        self.on_message: Callable[[ParsedMessagePayload], None] = lambda _: None
+        self.on_error_future: asyncio.Future = loop.create_future()
+
+    @abstractmethod
+    def request_stop(self) -> None:
+        pass
+
+    def dispose(self) -> None:
+        pass
+
+    @abstractmethod
+    async def wait_until_stopped(self) -> None:
+        pass
+
+    @abstractmethod
+    async def connect(self) -> None:
+        pass
+
+    @abstractmethod
+    async def run(self) -> None:
+        pass
+
+    @abstractmethod
+    def send(self, message: Dict) -> None:
+        pass
+
+    def serialize_message(self, message: Dict) -> bytes:
+        msg = json.dumps(message)
+        if "DEBUGP" in os.environ:
+            print("\x1b[32mSEND>\x1b[0m", json.dumps(message, indent=2))
+        return msg.encode()
+
+    def deserialize_message(self, data: Union[str, bytes]) -> ParsedMessagePayload:
+        obj = json.loads(data)
+        if "DEBUGP" in os.environ:
+            print("\x1b[33mRECV>\x1b[0m", json.dumps(obj, indent=2))
+        return obj
+
+
+class PipeTransport(Transport):
+
+    def __init__(self, loop: asyncio.AbstractEventLoop) -> None:
+        super().__init__(loop)
+        self._stopped = False
+
+    def request_stop(self) -> None:
+        assert self._output
+        self._stopped = True
+        self._output.close()
+
+    async def wait_until_stopped(self) -> None:
+        await self._stopped_future
+
+    async def connect(self) -> None:
+        self._stopped_future: asyncio.Future = asyncio.Future()
+        try:
+            env = get_driver_env()
+            if getattr(sys, "frozen", False) or globals().get("__compiled__"):
+                env.setdefault("PLAYWRIGHT_BROWSERS_PATH", "0")
+            startupinfo = None
+            if sys.platform == "win32":
+                startupinfo = subprocess.STARTUPINFO()
+                startupinfo.dwFlags |= subprocess.STARTF_USESHOWWINDOW
+                startupinfo.wShowWindow = subprocess.SW_HIDE
+            executable_path, entrypoint_path = compute_driver_executable()
+            self._proc = await asyncio.create_subprocess_exec(
+                executable_path,
+                entrypoint_path,
+                "run-driver",
+                stdin=asyncio.subprocess.PIPE,
+                stdout=asyncio.subprocess.PIPE,
+                stderr=_get_stderr_fileno(),
+                limit=32768,
+                env=env,
+                startupinfo=startupinfo,
+            )
+        except Exception as exc:
+            self.on_error_future.set_exception(exc)
+            raise exc
+        self._output = self._proc.stdin
+
+    async def run(self) -> None:
+        assert self._proc.stdout
+        assert self._proc.stdin
+        while not self._stopped:
+            try:
+                buffer = await self._proc.stdout.readexactly(4)
+                if self._stopped:
+                    break
+                length = int.from_bytes(buffer, byteorder="little", signed=False)
+                buffer = bytes(0)
+                while length:
+                    to_read = min(length, 32768)
+                    data = await self._proc.stdout.readexactly(to_read)
+                    if self._stopped:
+                        break
+                    length -= to_read
+                    if len(buffer):
+                        buffer = buffer + data
+                    else:
+                        buffer = data
+                if self._stopped:
+                    break
+                obj = self.deserialize_message(buffer)
+                self.on_message(obj)
+            except asyncio.IncompleteReadError:
+                if not self._stopped:
+                    self.on_error_future.set_exception(
+                        Exception("Connection closed while reading from the driver")
+                    )
+                break
+            await asyncio.sleep(0)
+        await self._proc.wait()
+        self._stopped_future.set_result(None)
+
+    def send(self, message: Dict) -> None:
+        assert self._output
+        data = self.serialize_message(message)
+        self._output.write(
+            len(data).to_bytes(4, byteorder="little", signed=False) + data
+        )

patchright/_impl/_video.py

@@ -0,0 +1,57 @@
+import pathlib
+from typing import TYPE_CHECKING, Union
+from patchright._impl._artifact import Artifact
+from patchright._impl._helper import Error
+
+if TYPE_CHECKING:
+    from patchright._impl._page import Page
+
+
+class Video:
+
+    def __init__(self, page: "Page") -> None:
+        self._loop = page._loop
+        self._dispatcher_fiber = page._dispatcher_fiber
+        self._page = page
+        self._artifact_future = page._loop.create_future()
+        if page.is_closed():
+            self._page_closed()
+        else:
+            page.on("close", lambda page: self._page_closed())
+
+    def __repr__(self) -> str:
+        return f"<Video page={self._page}>"
+
+    def _page_closed(self) -> None:
+        if not self._artifact_future.done():
+            self._artifact_future.set_exception(Error("Page closed"))
+
+    def _artifact_ready(self, artifact: Artifact) -> None:
+        if not self._artifact_future.done():
+            self._artifact_future.set_result(artifact)
+
+    async def path(self) -> pathlib.Path:
+        if self._page._connection.is_remote:
+            raise Error(
+                "Path is not available when using browserType.connect(). Use save_as() to save a local copy."
+            )
+        artifact = await self._artifact_future
+        if not artifact:
+            raise Error("Page did not produce any video frames")
+        return artifact.absolute_path
+
+    async def save_as(self, path: Union[str, pathlib.Path]) -> None:
+        if self._page._connection._is_sync and (not self._page._is_closed):
+            raise Error(
+                "Page is not yet closed. Close the page prior to calling save_as"
+            )
+        artifact = await self._artifact_future
+        if not artifact:
+            raise Error("Page did not produce any video frames")
+        await artifact.save_as(path)
+
+    async def delete(self) -> None:
+        artifact = await self._artifact_future
+        if not artifact:
+            raise Error("Page did not produce any video frames")
+        await artifact.delete()

patchright/_impl/_waiter.py

@@ -0,0 +1,142 @@
+import asyncio
+import math
+import uuid
+from asyncio.tasks import Task
+from typing import Any, Callable, List, Tuple, Union
+from pyee import EventEmitter
+from patchright._impl._connection import ChannelOwner
+from patchright._impl._errors import Error, TimeoutError
+
+
+class Waiter:
+
+    def __init__(self, channel_owner: ChannelOwner, event: str) -> None:
+        self._result: asyncio.Future = asyncio.Future()
+        self._wait_id = uuid.uuid4().hex
+        self._loop = channel_owner._loop
+        self._pending_tasks: List[Task] = []
+        self._channel = channel_owner._channel
+        self._registered_listeners: List[Tuple[EventEmitter, str, Callable]] = []
+        self._logs: List[str] = []
+        self._wait_for_event_info_before(self._wait_id, event)
+
+    def _wait_for_event_info_before(self, wait_id: str, event: str) -> None:
+        self._channel.send_no_reply(
+            "waitForEventInfo",
+            {"info": {"waitId": wait_id, "phase": "before", "event": event}},
+        )
+
+    def _wait_for_event_info_after(self, wait_id: str, error: Exception = None) -> None:
+        self._channel._connection.wrap_api_call_sync(
+            lambda: self._channel.send_no_reply(
+                "waitForEventInfo",
+                {
+                    "info": {
+                        "waitId": wait_id,
+                        "phase": "after",
+                        **({"error": str(error)} if error else {}),
+                    }
+                },
+            ),
+            True,
+        )
+
+    def reject_on_event(
+        self,
+        emitter: EventEmitter,
+        event: str,
+        error: Union[Error, Callable[..., Error]],
+        predicate: Callable = None,
+    ) -> None:
+
+        def listener(event_data: Any = None) -> None:
+            if not predicate or predicate(event_data):
+                self._reject(error() if callable(error) else error)
+
+        emitter.on(event, listener)
+        self._registered_listeners.append((emitter, event, listener))
+
+    def reject_on_timeout(self, timeout: float, message: str) -> None:
+        if timeout == 0:
+            return
+
+        async def reject() -> None:
+            await asyncio.sleep(timeout / 1000)
+            self._reject(TimeoutError(message))
+
+        self._pending_tasks.append(self._loop.create_task(reject()))
+
+    def _cleanup(self) -> None:
+        for task in self._pending_tasks:
+            if not task.done():
+                task.cancel()
+        for listener in self._registered_listeners:
+            listener[0].remove_listener(listener[1], listener[2])
+
+    def _fulfill(self, result: Any) -> None:
+        self._cleanup()
+        if not self._result.done():
+            self._result.set_result(result)
+        self._wait_for_event_info_after(self._wait_id)
+
+    def _reject(self, exception: Exception) -> None:
+        self._cleanup()
+        if exception:
+            base_class = TimeoutError if isinstance(exception, TimeoutError) else Error
+            exception = base_class(str(exception) + format_log_recording(self._logs))
+        if not self._result.done():
+            self._result.set_exception(exception)
+        self._wait_for_event_info_after(self._wait_id, exception)
+
+    def wait_for_event(
+        self, emitter: EventEmitter, event: str, predicate: Callable = None
+    ) -> None:
+
+        def listener(event_data: Any = None) -> None:
+            if not predicate or predicate(event_data):
+                self._fulfill(event_data)
+
+        emitter.on(event, listener)
+        self._registered_listeners.append((emitter, event, listener))
+
+    def result(self) -> asyncio.Future:
+        return self._result
+
+    def log(self, message: str) -> None:
+        self._logs.append(message)
+        try:
+            self._channel._connection.wrap_api_call_sync(
+                lambda: self._channel.send_no_reply(
+                    "waitForEventInfo",
+                    {
+                        "info": {
+                            "waitId": self._wait_id,
+                            "phase": "log",
+                            "message": message,
+                        }
+                    },
+                ),
+                True,
+            )
+        except Exception:
+            pass
+
+
+def throw_on_timeout(timeout: float, exception: Exception) -> asyncio.Task:
+
+    async def throw() -> None:
+        await asyncio.sleep(timeout / 1000)
+        raise exception
+
+    return asyncio.create_task(throw())
+
+
+def format_log_recording(log: List[str]) -> str:
+    if not log:
+        return ""
+    header = " logs "
+    header_length = 60
+    left_length = math.floor((header_length - len(header)) / 2)
+    right_length = header_length - len(header) - left_length
+    new_line = "\n"
+    return f"{new_line}{'=' * left_length}{header}{'=' * right_length}{new_line}{new_line.join(log)}{new_line}{'=' * header_length}"

patchright/_impl/_web_error.py

@@ -0,0 +1,22 @@
+from asyncio import AbstractEventLoop
+from typing import Optional
+from patchright._impl._helper import Error
+from patchright._impl._page import Page
+
+
+class WebError:
+
+    def __init__(
+        self, loop: AbstractEventLoop, page: Optional[Page], error: Error
+    ) -> None:
+        self._loop = loop
+        self._page = page
+        self._error = error
+
+    @property
+    def page(self) -> Optional[Page]:
+        return self._page
+
+    @property
+    def error(self) -> Error:
+        return self._error

patchright/_impl/_writable_stream.py

@@ -0,0 +1,27 @@
+import base64
+import os
+from pathlib import Path
+from typing import Dict, Union
+from patchright._impl._connection import ChannelOwner
+
+_WINDOWS = os.name == "nt"
+COPY_BUFSIZE = 1024 * 1024 if _WINDOWS else 64 * 1024
+
+
+class WritableStream(ChannelOwner):
+
+    def __init__(
+        self, parent: ChannelOwner, type: str, guid: str, initializer: Dict
+    ) -> None:
+        super().__init__(parent, type, guid, initializer)
+
+    async def copy(self, path: Union[str, Path]) -> None:
+        with open(path, "rb") as f:
+            while True:
+                data = f.read(COPY_BUFSIZE)
+                if not data:
+                    break
+                await self._channel.send(
+                    "write", {"binary": base64.b64encode(data).decode()}
+                )
+        await self._channel.send("close")

patchright/_repo_version.py

@@ -0,0 +1,12 @@
+TYPE_CHECKING = False
+if TYPE_CHECKING:
+    from typing import Tuple, Union
+    VERSION_TUPLE = Tuple[Union[int, str], ...]
+else:
+    VERSION_TUPLE = object
+version: str
+__version__: str
+__version_tuple__: VERSION_TUPLE
+version_tuple: VERSION_TUPLE
+__version__ = version = '1.48.0'
+__version_tuple__ = version_tuple = (1, 48, 0)

patchright/async_api/__init__.py

@@ -0,0 +1,177 @@
+"""
+Python package `playwright` is a Python library to automate Chromium,
+Firefox and WebKit with a single API. Playwright is built to enable cross-browser
+web automation that is ever-green, capable, reliable and fast.
+"""
+
+from typing import Any, Optional, Union, overload
+import patchright._impl._api_structures
+import patchright._impl._errors
+import patchright.async_api._generated
+from patchright._impl._assertions import (
+    APIResponseAssertions as APIResponseAssertionsImpl,
+)
+from patchright._impl._assertions import LocatorAssertions as LocatorAssertionsImpl
+from patchright._impl._assertions import PageAssertions as PageAssertionsImpl
+from patchright.async_api._context_manager import PlaywrightContextManager
+from patchright.async_api._generated import (
+    Accessibility,
+    APIRequest,
+    APIRequestContext,
+    APIResponse,
+    APIResponseAssertions,
+    Browser,
+    BrowserContext,
+    BrowserType,
+    CDPSession,
+    ConsoleMessage,
+    Dialog,
+    Download,
+    ElementHandle,
+    FileChooser,
+    Frame,
+    FrameLocator,
+    JSHandle,
+    Keyboard,
+    Locator,
+    LocatorAssertions,
+    Mouse,
+    Page,
+    PageAssertions,
+    Playwright,
+    Request,
+    Response,
+    Route,
+    Selectors,
+    Touchscreen,
+    Video,
+    WebSocket,
+    WebSocketRoute,
+    Worker,
+)
+
+ChromiumBrowserContext = BrowserContext
+Cookie = patchright._impl._api_structures.Cookie
+FilePayload = patchright._impl._api_structures.FilePayload
+FloatRect = patchright._impl._api_structures.FloatRect
+Geolocation = patchright._impl._api_structures.Geolocation
+HttpCredentials = patchright._impl._api_structures.HttpCredentials
+PdfMargins = patchright._impl._api_structures.PdfMargins
+Position = patchright._impl._api_structures.Position
+ProxySettings = patchright._impl._api_structures.ProxySettings
+ResourceTiming = patchright._impl._api_structures.ResourceTiming
+SourceLocation = patchright._impl._api_structures.SourceLocation
+StorageState = patchright._impl._api_structures.StorageState
+ViewportSize = patchright._impl._api_structures.ViewportSize
+Error = patchright._impl._errors.Error
+TimeoutError = patchright._impl._errors.TimeoutError
+
+
+def async_playwright() -> PlaywrightContextManager:
+    return PlaywrightContextManager()
+
+
+class Expect:
+    _unset: Any = object()
+
+    def __init__(self) -> None:
+        self._timeout: Optional[float] = None
+
+    def set_options(self, timeout: Optional[float] = _unset) -> None:
+        """
+        This method sets global `expect()` options.
+
+        Args:
+            timeout (float): Timeout value in milliseconds. Default to 5000 milliseconds.
+
+        Returns:
+            None
+        """
+        if timeout is not self._unset:
+            self._timeout = timeout
+
+    @overload
+    def __call__(
+        self, actual: Page, message: Optional[str] = None
+    ) -> PageAssertions: ...
+
+    @overload
+    def __call__(
+        self, actual: Locator, message: Optional[str] = None
+    ) -> LocatorAssertions: ...
+
+    @overload
+    def __call__(
+        self, actual: APIResponse, message: Optional[str] = None
+    ) -> APIResponseAssertions: ...
+
+    def __call__(
+        self, actual: Union[Page, Locator, APIResponse], message: Optional[str] = None
+    ) -> Union[PageAssertions, LocatorAssertions, APIResponseAssertions]:
+        if isinstance(actual, Page):
+            return PageAssertions(
+                PageAssertionsImpl(actual._impl_obj, self._timeout, message=message)
+            )
+        elif isinstance(actual, Locator):
+            return LocatorAssertions(
+                LocatorAssertionsImpl(actual._impl_obj, self._timeout, message=message)
+            )
+        elif isinstance(actual, APIResponse):
+            return APIResponseAssertions(
+                APIResponseAssertionsImpl(
+                    actual._impl_obj, self._timeout, message=message
+                )
+            )
+        raise ValueError(f"Unsupported type: {type(actual)}")
+
+
+expect = Expect()
+__all__ = [
+    "expect",
+    "async_playwright",
+    "Accessibility",
+    "APIRequest",
+    "APIRequestContext",
+    "APIResponse",
+    "Browser",
+    "BrowserContext",
+    "BrowserType",
+    "CDPSession",
+    "ChromiumBrowserContext",
+    "ConsoleMessage",
+    "Cookie",
+    "Dialog",
+    "Download",
+    "ElementHandle",
+    "Error",
+    "FileChooser",
+    "FilePayload",
+    "FloatRect",
+    "Frame",
+    "FrameLocator",
+    "Geolocation",
+    "HttpCredentials",
+    "JSHandle",
+    "Keyboard",
+    "Locator",
+    "Mouse",
+    "Page",
+    "PdfMargins",
+    "Position",
+    "Playwright",
+    "ProxySettings",
+    "Request",
+    "ResourceTiming",
+    "Response",
+    "Route",
+    "Selectors",
+    "SourceLocation",
+    "StorageState",
+    "TimeoutError",
+    "Touchscreen",
+    "Video",
+    "ViewportSize",
+    "WebSocket",
+    "WebSocketRoute",
+    "Worker",
+]

patchright/async_api/_context_manager.py

@@ -0,0 +1,39 @@
+import asyncio
+from typing import Any
+from patchright._impl._connection import Connection
+from patchright._impl._object_factory import create_remote_object
+from patchright._impl._transport import PipeTransport
+from patchright.async_api._generated import Playwright as AsyncPlaywright
+
+
+class PlaywrightContextManager:
+
+    def __init__(self) -> None:
+        self._connection: Connection
+        self._exit_was_called = False
+
+    async def __aenter__(self) -> AsyncPlaywright:
+        loop = asyncio.get_running_loop()
+        self._connection = Connection(
+            None, create_remote_object, PipeTransport(loop), loop
+        )
+        loop.create_task(self._connection.run())
+        playwright_future = self._connection.playwright_future
+        done, _ = await asyncio.wait(
+            {self._connection._transport.on_error_future, playwright_future},
+            return_when=asyncio.FIRST_COMPLETED,
+        )
+        if not playwright_future.done():
+            playwright_future.cancel()
+        playwright = AsyncPlaywright(next(iter(done)).result())
+        playwright.stop = self.__aexit__
+        return playwright
+
+    async def start(self) -> AsyncPlaywright:
+        return await self.__aenter__()
+
+    async def __aexit__(self, *args: Any) -> None:
+        if self._exit_was_called:
+            return
+        self._exit_was_called = True
+        await self._connection.stop_async()