chore(roll): roll Playwright to 1.42.0-alpha-2024-02-19 (#2313)

Author: mxschmitt

README.md

@@ -4,9 +4,9 @@ Playwright is a Python library to automate [Chromium](https://www.chromium.org/H
 
 |          | Linux | macOS | Windows |
 |   :---   | :---: | :---: | :---:   |
-| Chromium <!-- GEN:chromium-version -->121.0.6167.57<!-- GEN:stop --> | ✅ | ✅ | ✅ |
+| Chromium <!-- GEN:chromium-version -->122.0.6261.39<!-- GEN:stop --> | ✅ | ✅ | ✅ |
 | WebKit <!-- GEN:webkit-version -->17.4<!-- GEN:stop --> | ✅ | ✅ | ✅ |
-| Firefox <!-- GEN:firefox-version -->121.0<!-- GEN:stop --> | ✅ | ✅ | ✅ |
+| Firefox <!-- GEN:firefox-version -->122.0<!-- GEN:stop --> | ✅ | ✅ | ✅ |
 
 ## Documentation
 

playwright/_impl/_connection.py

@@ -33,12 +33,12 @@
     cast,
 )
 
-from greenlet import greenlet
 from pyee import EventEmitter
 from pyee.asyncio import AsyncIOEventEmitter
 
 import playwright
 from playwright._impl._errors import TargetClosedError
+from playwright._impl._greenlets import EventGreenlet
 from playwright._impl._helper import Error, ParsedMessagePayload, parse_error
 from playwright._impl._transport import Transport
 
@@ -417,7 +417,7 @@ def dispatch(self, msg: ParsedMessagePayload) -> None:
                     # Each event handler is a potentilly blocking context, create a fiber for each
                     # and switch to them in order, until they block inside and pass control to each
                     # other and then eventually back to dispatcher as listener functions return.
-                    g = greenlet(listener)
+                    g = EventGreenlet(listener)
                     if should_replace_guids_with_channels:
                         g.switch(self._replace_guids_with_channels(params))
                     else:

playwright/_impl/_frame.py

@@ -53,6 +53,7 @@
 from playwright._impl._js_handle import (
     JSHandle,
     Serializable,
+    add_source_url_to_script,
     parse_result,
     serialize_argument,
 )
@@ -450,10 +451,8 @@ async def add_script_tag(
     ) -> ElementHandle:
         params = locals_to_params(locals())
         if path:
-            params["content"] = (
-                (await async_readfile(path)).decode()
-                + "\n//# sourceURL="
-                + str(Path(path))
+            params["content"] = add_source_url_to_script(
+                (await async_readfile(path)).decode(), path
             )
             del params["path"]
         return from_channel(await self._channel.send("addScriptTag", params))

playwright/_impl/_greenlets.py

@@ -0,0 +1,49 @@
+# Copyright (c) Microsoft Corporation.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+import os
+from typing import Tuple
+
+import greenlet
+
+
+def _greenlet_trace_callback(
+    event: str, args: Tuple[greenlet.greenlet, greenlet.greenlet]
+) -> None:
+    if event in ("switch", "throw"):
+        origin, target = args
+        print(f"Transfer from {origin} to {target} with {event}")
+
+
+if os.environ.get("INTERNAL_PW_GREENLET_DEBUG"):
+    greenlet.settrace(_greenlet_trace_callback)
+
+
+class MainGreenlet(greenlet.greenlet):
+    def __str__(self) -> str:
+        return "<MainGreenlet>"
+
+
+class RouteGreenlet(greenlet.greenlet):
+    def __str__(self) -> str:
+        return "<RouteGreenlet>"
+
+
+class LocatorHandlerGreenlet(greenlet.greenlet):
+    def __str__(self) -> str:
+        return "<LocatorHandlerGreenlet>"
+
+
+class EventGreenlet(greenlet.greenlet):
+    def __str__(self) -> str:
+        return "<EventGreenlet>"

playwright/_impl/_har_router.py

@@ -75,6 +75,13 @@ async def _handle(self, route: "Route") -> None:
             return
 
         if action == "fulfill":
+            # If the response status is -1, the request was canceled or stalled, so we just stall it here.
+            # See https://github.com/microsoft/playwright/issues/29311.
+            # TODO: it'd be better to abort such requests, but then we likely need to respect the timing,
+            # because the request might have been stalled for a long time until the very end of the
+            # test when HAR was recorded but we'd abort it immediately.
+            if response.get("status") == -1:
+                return
             body = response["body"]
             assert body is not None
             await route.fulfill(

playwright/_impl/_helper.py

@@ -36,11 +36,10 @@
 )
 from urllib.parse import urljoin
 
-from greenlet import greenlet
-
 from playwright._impl._api_structures import NameValue
 from playwright._impl._errors import Error, TargetClosedError, TimeoutError
 from playwright._impl._glob import glob_to_regex
+from playwright._impl._greenlets import RouteGreenlet
 from playwright._impl._str_utils import escape_regex_flags
 
 if TYPE_CHECKING:  # pragma: no cover
@@ -302,7 +301,7 @@ async def _handle_internal(self, route: "Route") -> bool:
         if self._is_sync:
             # As with event handlers, each route handler is a potentially blocking context
             # so it needs a fiber.
-            g = greenlet(lambda: self.handler(route, route.request))  # type: ignore
+            g = RouteGreenlet(lambda: self.handler(route, route.request))  # type: ignore
             g.switch()
         else:
             coro_or_future = self.handler(route, route.request)  # type: ignore

playwright/_impl/_js_handle.py

@@ -15,7 +15,8 @@
 import collections.abc
 import math
 from datetime import datetime
-from typing import TYPE_CHECKING, Any, Dict, List, Optional
+from pathlib import Path
+from typing import TYPE_CHECKING, Any, Dict, List, Optional, Union
 from urllib.parse import ParseResult, urlparse, urlunparse
 
 from playwright._impl._connection import Channel, ChannelOwner, from_channel
@@ -226,3 +227,7 @@ def parse_value(value: Any, refs: Optional[Dict[int, Any]] = None) -> Any:
 
 def parse_result(result: Any) -> Any:
     return parse_value(result)
+
+
+def add_source_url_to_script(source: str, path: Union[str, Path]) -> str:
+    return source + "\n//# sourceURL=" + str(path).replace("\n", "")

playwright/_impl/_page.py

@@ -55,6 +55,7 @@
 from playwright._impl._event_context_manager import EventContextManagerImpl
 from playwright._impl._file_chooser import FileChooser
 from playwright._impl._frame import Frame
+from playwright._impl._greenlets import LocatorHandlerGreenlet
 from playwright._impl._har_router import HarRouter
 from playwright._impl._helper import (
     ColorScheme,
@@ -82,6 +83,7 @@
 from playwright._impl._js_handle import (
     JSHandle,
     Serializable,
+    add_source_url_to_script,
     parse_result,
     serialize_argument,
 )
@@ -150,6 +152,7 @@ def __init__(
         self._close_reason: Optional[str] = None
         self._close_was_called = False
         self._har_routers: List[HarRouter] = []
+        self._locator_handlers: Dict[str, Callable] = {}
 
         self._channel.on(
             "bindingCall",
@@ -175,6 +178,12 @@ def __init__(
             "frameDetached",
             lambda params: self._on_frame_detached(from_channel(params["frame"])),
         )
+        self._channel.on(
+            "locatorHandlerTriggered",
+            lambda params: asyncio.create_task(
+                self._on_locator_handler_triggered(params["uid"])
+            ),
+        )
         self._channel.on(
             "route",
             lambda params: asyncio.create_task(
@@ -194,17 +203,21 @@ def __init__(
         self._closed_or_crashed_future: asyncio.Future = asyncio.Future()
         self.on(
             Page.Events.Close,
-            lambda _: self._closed_or_crashed_future.set_result(
-                self._close_error_with_reason()
-            )
-            if not self._closed_or_crashed_future.done()
-            else None,
+            lambda _: (
+                self._closed_or_crashed_future.set_result(
+                    self._close_error_with_reason()
+                )
+                if not self._closed_or_crashed_future.done()
+                else None
+            ),
         )
         self.on(
             Page.Events.Crash,
-            lambda _: self._closed_or_crashed_future.set_result(TargetClosedError())
-            if not self._closed_or_crashed_future.done()
-            else None,
+            lambda _: (
+                self._closed_or_crashed_future.set_result(TargetClosedError())
+                if not self._closed_or_crashed_future.done()
+                else None
+            ),
         )
 
         self._set_event_to_subscription_mapping(
@@ -567,7 +580,9 @@ async def add_init_script(
         self, script: str = None, path: Union[str, Path] = None
     ) -> None:
         if path:
-            script = (await async_readfile(path)).decode()
+            script = add_source_url_to_script(
+                (await async_readfile(path)).decode(), path
+            )
         if not isinstance(script, str):
             raise Error("Either path or script parameter must be specified")
         await self._channel.send("addInitScript", dict(source=script))
@@ -1029,6 +1044,8 @@ async def pdf(
         preferCSSPageSize: bool = None,
         margin: PdfMargins = None,
         path: Union[str, Path] = None,
+        outline: bool = None,
+        tagged: bool = None,
     ) -> bytes:
         params = locals_to_params(locals())
         if "path" in params:
@@ -1238,6 +1255,48 @@ async def set_checked(
                 trial=trial,
             )
 
+    async def add_locator_handler(self, locator: "Locator", handler: Callable) -> None:
+        if locator._frame != self._main_frame:
+            raise Error("Locator must belong to the main frame of this page")
+        uid = await self._channel.send(
+            "registerLocatorHandler",
+            {
+                "selector": locator._selector,
+            },
+        )
+        self._locator_handlers[uid] = handler
+
+    async def _on_locator_handler_triggered(self, uid: str) -> None:
+        try:
+            if self._dispatcher_fiber:
+                handler_finished_future = self._loop.create_future()
+
+                def _handler() -> None:
+                    try:
+                        self._locator_handlers[uid]()
+                        handler_finished_future.set_result(None)
+                    except Exception as e:
+                        handler_finished_future.set_exception(e)
+
+                g = LocatorHandlerGreenlet(_handler)
+                g.switch()
+                await handler_finished_future
+            else:
+                coro_or_future = self._locator_handlers[uid]()
+                if coro_or_future:
+                    await coro_or_future
+
+        finally:
+            try:
+                await self._connection.wrap_api_call(
+                    lambda: self._channel.send(
+                        "resolveLocatorHandlerNoReply", {"uid": uid}
+                    ),
+                    is_internal=True,
+                )
+            except Error:
+                pass
+
 
 class Worker(ChannelOwner):
     Events = SimpleNamespace(Close="close")