chore(roll): roll Playwright to 1.45.0-alpha-2024-06-14

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 -->125.0.6422.26<!-- GEN:stop --> | ✅ | ✅ | ✅ |
+| Chromium <!-- GEN:chromium-version -->127.0.6533.5<!-- GEN:stop --> | ✅ | ✅ | ✅ |
 | WebKit <!-- GEN:webkit-version -->17.4<!-- GEN:stop --> | ✅ | ✅ | ✅ |
-| Firefox <!-- GEN:firefox-version -->125.0.1<!-- GEN:stop --> | ✅ | ✅ | ✅ |
+| Firefox <!-- GEN:firefox-version -->127.0<!-- GEN:stop --> | ✅ | ✅ | ✅ |
 
 ## Documentation
 

playwright/_impl/_api_structures.py

@@ -63,6 +63,7 @@ class HttpCredentials(TypedDict, total=False):
     username: str
     password: str
     origin: Optional[str]
+    send: Optional[Literal["always", "unauthorized"]]
 
 
 class LocalStorageEntry(TypedDict):

playwright/_impl/_browser_context.py

@@ -39,6 +39,7 @@
 )
 from playwright._impl._artifact import Artifact
 from playwright._impl._cdp_session import CDPSession
+from playwright._impl._clock import Clock
 from playwright._impl._connection import (
     ChannelOwner,
     from_channel,
@@ -114,6 +115,7 @@ def __init__(
         self._tracing = cast(Tracing, from_channel(initializer["tracing"]))
         self._har_recorders: Dict[str, HarRecordingMetadata] = {}
         self._request: APIRequestContext = from_channel(initializer["requestContext"])
+        self._clock = Clock(self)
         self._channel.on(
             "bindingCall",
             lambda params: self._on_binding(from_channel(params["binding"])),
@@ -519,6 +521,10 @@ async def close(self, reason: str = None) -> None:
         self._close_reason = reason
         self._close_was_called = True
 
+        await self._channel._connection.wrap_api_call(
+            lambda: self.request.dispose(reason=reason), True
+        )
+
         async def _inner_close() -> None:
             for har_id, params in self._har_recorders.items():
                 har = cast(
@@ -679,3 +685,7 @@ def tracing(self) -> Tracing:
     @property
     def request(self) -> "APIRequestContext":
         return self._request
+
+    @property
+    def clock(self) -> Clock:
+        return self._clock

playwright/_impl/_clock.py

@@ -0,0 +1,83 @@
+# 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 datetime
+from typing import TYPE_CHECKING, Dict, Union
+
+if TYPE_CHECKING:
+    from playwright._impl._browser_context import BrowserContext
+
+
+class Clock:
+    def __init__(self, browser_context: "BrowserContext") -> None:
+        self._browser_context = browser_context
+        self._loop = browser_context._loop
+
+    async def install(self, time: Union[int, str, datetime.datetime] = None) -> None:
+        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[int, 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[int, str, datetime.datetime],
+    ) -> None:
+        await self._browser_context._channel.send("clockSetFixedTime", parse_time(time))
+
+    async def set_system_time(
+        self,
+        time: Union[int, str, datetime.datetime],
+    ) -> None:
+        await self._browser_context._channel.send(
+            "clockSetSystemTime", parse_time(time)
+        )
+
+
+def parse_time(time: Union[int, str, datetime.datetime]) -> Dict[str, Union[int, str]]:
+    if isinstance(time, int):
+        return {"timeNumber": time}
+    if isinstance(time, str):
+        return {"timeString": time}
+    return {"timeNumber": int(time.timestamp())}
+
+
+def parse_ticks(ticks: Union[int, str]) -> Dict[str, Union[int, str]]:
+    if isinstance(ticks, int):
+        return {"ticksNumber": ticks}
+    return {"ticksString": ticks}

playwright/_impl/_fetch.py

@@ -34,6 +34,7 @@
 from playwright._impl._helper import (
     Error,
     NameValue,
+    TargetClosedError,
     async_readfile,
     async_writefile,
     is_file_payload,
@@ -93,9 +94,16 @@ def __init__(
     ) -> None:
         super().__init__(parent, type, guid, initializer)
         self._tracing: Tracing = from_channel(initializer["tracing"])
+        self._close_reason: Optional[str] = None
 
-    async def dispose(self) -> None:
-        await self._channel.send("dispose")
+    async def dispose(self, reason: str = None) -> None:
+        self._close_reason = reason
+        try:
+            await self._channel.send("dispose", {"reason": reason})
+        except Error as e:
+            if is_target_closed_error(e):
+                return
+            raise e
         self._tracing._reset_stack_counter()
 
     async def delete(
@@ -313,6 +321,8 @@ async def _inner_fetch(
         ignoreHTTPSErrors: bool = None,
         maxRedirects: int = None,
     ) -> "APIResponse":
+        if self._close_reason:
+            raise TargetClosedError(self._close_reason)
         assert (
             (1 if data else 0) + (1 if form else 0) + (1 if multipart else 0)
         ) <= 1, "Only one of 'data', 'form' or 'multipart' can be specified"

playwright/_impl/_helper.py

@@ -37,7 +37,13 @@
 from urllib.parse import urljoin
 
 from playwright._impl._api_structures import NameValue
-from playwright._impl._errors import Error, TargetClosedError, TimeoutError
+from playwright._impl._errors import (
+    Error,
+    TargetClosedError,
+    TimeoutError,
+    is_target_closed_error,
+    rewrite_error,
+)
 from playwright._impl._glob import glob_to_regex
 from playwright._impl._greenlets import RouteGreenlet
 from playwright._impl._str_utils import escape_regex_flags
@@ -287,6 +293,13 @@ async def handle(self, route: "Route") -> bool:
             # If the handler was stopped (without waiting for completion), we ignore all exceptions.
             if self._ignore_exception:
                 return False
+            if is_target_closed_error(e):
+                # We are failing in the handler because the target close closed.
+                # Give user a hint!
+                raise rewrite_error(
+                    e,
+                    f"\"{str(e)}\" while running route callback.\nConsider awaiting `await page.unroute_all(behavior='ignoreErrors')`\nbefore the end of the test to ignore remaining routes in flight.",
+                )
             raise e
         finally:
             handler_invocation.complete.set_result(None)

playwright/_impl/_page.py

@@ -43,6 +43,7 @@
     ViewportSize,
 )
 from playwright._impl._artifact import Artifact
+from playwright._impl._clock import Clock
 from playwright._impl._connection import (
     ChannelOwner,
     from_channel,
@@ -336,6 +337,10 @@ def _on_video(self, params: Any) -> None:
     def context(self) -> "BrowserContext":
         return self._browser_context
 
+    @property
+    def clock(self) -> Clock:
+        return self._browser_context.clock
+
     async def opener(self) -> Optional["Page"]:
         if self._opener and self._opener.is_closed():
             return None

playwright/_impl/_set_input_files_helpers.py

@@ -15,7 +15,17 @@
 import collections.abc
 import os
 from pathlib import Path
-from typing import TYPE_CHECKING, Dict, List, Optional, Sequence, TypedDict, Union, cast
+from typing import (
+    TYPE_CHECKING,
+    Dict,
+    List,
+    Optional,
+    Sequence,
+    Tuple,
+    TypedDict,
+    Union,
+    cast,
+)
 
 from playwright._impl._connection import Channel, from_channel
 from playwright._impl._helper import Error
@@ -31,10 +41,20 @@
 
 class InputFilesList(TypedDict, total=False):
     streams: Optional[List[Channel]]
+    directoryStream: Optional[Channel]
+    localDirectory: Optional[str]
     localPaths: Optional[List[str]]
     payloads: Optional[List[Dict[str, Union[str, bytes]]]]
 
 
+def _list_files(directory: str) -> List[str]:
+    files = []
+    for root, _, filenames in os.walk(directory):
+        for filename in filenames:
+            files.append(os.path.join(root, filename))
+    return files
+
+
 async def convert_input_files(
     files: Union[
         str, Path, FilePayload, Sequence[Union[str, Path]], Sequence[FilePayload]
@@ -50,31 +70,51 @@ async def convert_input_files(
     if any([isinstance(item, (str, Path)) for item in items]):
         if not all([isinstance(item, (str, Path)) for item in items]):
             raise Error("File paths cannot be mixed with buffers")
+
+        (local_paths, local_directory) = resolve_paths_and_directory_for_input_files(
+            cast(Sequence[Union[str, Path]], items)
+        )
+
         if context._channel._connection.is_remote:
+            files_to_stream = cast(
+                List[str],
+                (_list_files(local_directory) if local_directory else local_paths),
+            )
             streams = []
-            for item in items:
-                assert isinstance(item, (str, Path))
-                last_modified_ms = int(os.path.getmtime(item) * 1000)
-                stream: WritableStream = from_channel(
-                    await context._connection.wrap_api_call(
-                        lambda: context._channel.send(
-                            "createTempFile",
-                            {
-                                "name": os.path.basename(cast(str, item)),
-                                "lastModifiedMs": last_modified_ms,
-                            },
-                        )
-                    )
+            result = await context._connection.wrap_api_call(
+                lambda: context._channel.send_return_as_dict(
+                    "createTempFiles",
+                    {
+                        "rootDirName": (
+                            os.path.basename(local_directory)
+                            if local_directory
+                            else None
+                        ),
+                        "items": list(
+                            map(
+                                lambda file: dict(
+                                    name=(
+                                        os.path.relpath(file, local_directory)
+                                        if local_directory
+                                        else os.path.basename(file)
+                                    ),
+                                    lastModifiedMs=int(os.path.getmtime(file) * 1000),
+                                ),
+                                files_to_stream,
+                            )
+                        ),
+                    },
                 )
-                await stream.copy(item)
+            )
+            for i, file in enumerate(result["writableStreams"]):
+                stream: WritableStream = from_channel(file)
+                await stream.copy(files_to_stream[i])
                 streams.append(stream._channel)
-            return InputFilesList(streams=streams)
-        return InputFilesList(
-            localPaths=[
-                str(Path(cast(Union[str, Path], item)).absolute().resolve())
-                for item in items
-            ]
-        )
+            return InputFilesList(
+                streams=None if local_directory else streams,
+                directoryStream=result.get("rootDir"),
+            )
+        return InputFilesList(localPaths=local_paths, localDirectory=local_directory)
 
     file_payload_exceeds_size_limit = (
         sum([len(f.get("buffer", "")) for f in items if not isinstance(f, (str, Path))])
@@ -95,3 +135,21 @@ async def convert_input_files(
             for item in cast(List[FilePayload], items)
         ]
     )
+
+
+def resolve_paths_and_directory_for_input_files(
+    items: Sequence[Union[str, Path]]
+) -> Tuple[Optional[List[str]], Optional[str]]:
+    local_paths: Optional[List[str]] = None
+    local_directory: Optional[str] = None
+    for item in items:
+        if os.path.isdir(item):
+            if local_directory:
+                raise Error("Multiple directories are not supported")
+            local_directory = str(Path(item).resolve())
+        else:
+            local_paths = local_paths or []
+            local_paths.append(str(Path(item).resolve()))
+    if local_paths and local_directory:
+        raise Error("File paths must be all files or a single directory")
+    return (local_paths, local_directory)