feat(roll): roll Playwright 1.15.0-next-1631091227000 (#887)

Author: mxschmitt

README.md

@@ -4,7 +4,7 @@ Playwright is a Python library to automate [Chromium](https://www.chromium.org/H
 
 |          | Linux | macOS | Windows |
 |   :---   | :---: | :---: | :---:   |
-| Chromium <!-- GEN:chromium-version -->94.0.4595.0<!-- GEN:stop --> | ✅ | ✅ | ✅ |
+| Chromium <!-- GEN:chromium-version -->95.0.4636.0<!-- GEN:stop --> | ✅ | ✅ | ✅ |
 | WebKit <!-- GEN:webkit-version -->15.0<!-- GEN:stop --> | ✅ | ✅ | ✅ |
 | Firefox <!-- GEN:firefox-version -->91.0<!-- GEN:stop --> | ✅ | ✅ | ✅ |
 

playwright/_impl/_api_structures.py

@@ -109,7 +109,6 @@ class RequestSizes(TypedDict):
     requestHeadersSize: int
     responseBodySize: int
     responseHeadersSize: int
-    responseTransferSize: int
 
 
 class ViewportSize(TypedDict):

playwright/_impl/_browser.py

@@ -30,6 +30,7 @@
 from playwright._impl._connection import ChannelOwner, from_channel
 from playwright._impl._helper import (
     ColorScheme,
+    ForcedColors,
     ReducedMotion,
     async_readfile,
     is_safe_close_error,
@@ -97,6 +98,7 @@ async def new_context(
         hasTouch: bool = None,
         colorScheme: ColorScheme = None,
         reducedMotion: ReducedMotion = None,
+        forcedColors: ForcedColors = None,
         acceptDownloads: bool = None,
         defaultBrowserType: str = None,
         proxy: ProxySettings = None,
@@ -138,6 +140,7 @@ async def new_page(
         isMobile: bool = None,
         hasTouch: bool = None,
         colorScheme: ColorScheme = None,
+        forcedColors: ForcedColors = None,
         reducedMotion: ReducedMotion = None,
         acceptDownloads: bool = None,
         defaultBrowserType: str = None,

playwright/_impl/_browser_context.py

@@ -19,12 +19,7 @@
 from types import SimpleNamespace
 from typing import TYPE_CHECKING, Any, Callable, Dict, List, Optional, Set, Union, cast
 
-from playwright._impl._api_structures import (
-    Cookie,
-    Geolocation,
-    RequestSizes,
-    StorageState,
-)
+from playwright._impl._api_structures import Cookie, Geolocation, StorageState
 from playwright._impl._api_types import Error
 from playwright._impl._artifact import Artifact
 from playwright._impl._cdp_session import CDPSession
@@ -134,9 +129,9 @@ def __init__(
             "requestFinished",
             lambda params: self._on_request_finished(
                 from_channel(params["request"]),
+                from_nullable_channel(params["response"]),
                 params["responseEndTiming"],
                 from_nullable_channel(params.get("page")),
-                params["requestSizes"],
             ),
         )
         self._closed_future: asyncio.Future = asyncio.Future()
@@ -366,16 +361,17 @@ def _on_request_failed(
     def _on_request_finished(
         self,
         request: Request,
+        response: Optional[Response],
         response_end_timing: float,
         page: Optional[Page],
-        request_sizes: RequestSizes,
     ) -> None:
         if request._timing:
             request._timing["responseEnd"] = response_end_timing
-        request._sizes = request_sizes
         self.emit(BrowserContext.Events.RequestFinished, request)
         if page:
             page.emit(Page.Events.RequestFinished, request)
+        if response:
+            response._finished_future.set_result(True)
 
     def _on_request(self, request: Request, page: Optional[Page]) -> None:
         self.emit(BrowserContext.Events.Request, request)

playwright/_impl/_browser_type.py

@@ -35,6 +35,7 @@
 from playwright._impl._helper import (
     ColorScheme,
     Env,
+    ForcedColors,
     ReducedMotion,
     locals_to_params,
     not_installed_error,
@@ -128,6 +129,7 @@ async def launch_persistent_context(
         hasTouch: bool = None,
         colorScheme: ColorScheme = None,
         reducedMotion: ReducedMotion = None,
+        forcedColors: ForcedColors = None,
         acceptDownloads: bool = None,
         tracesDir: Union[pathlib.Path, str] = None,
         chromiumSandbox: bool = None,

playwright/_impl/_element_handle.py

@@ -220,7 +220,6 @@ async def set_checked(
         timeout: float = None,
         force: bool = None,
         noWaitAfter: bool = None,
-        strict: bool = None,
         trial: bool = None,
     ) -> None:
         if checked:

playwright/_impl/_helper.py

@@ -55,6 +55,7 @@
 ]
 
 ColorScheme = Literal["dark", "light", "no-preference"]
+ForcedColors = Literal["active", "none"]
 ReducedMotion = Literal["no-preference", "reduce"]
 DocumentLoadState = Literal["domcontentloaded", "load", "networkidle"]
 KeyboardModifier = Literal["Alt", "Control", "Meta", "Shift"]

playwright/_impl/_locator.py

@@ -445,7 +445,6 @@ async def set_checked(
         position: Position = None,
         timeout: float = None,
         force: bool = None,
-        strict: bool = None,
         noWaitAfter: bool = None,
         trial: bool = None,
     ) -> None:

playwright/_impl/_network.py

@@ -12,6 +12,7 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
+import asyncio
 import base64
 import json
 import mimetypes
@@ -63,14 +64,8 @@ def __init__(
             "responseStart": -1,
             "responseEnd": -1,
         }
-        self._sizes: RequestSizes = {
-            "requestBodySize": 0,
-            "requestHeadersSize": 0,
-            "responseBodySize": 0,
-            "responseHeadersSize": 0,
-            "responseTransferSize": 0,
-        }
-        self._headers: Dict[str, str] = parse_headers(self._initializer["headers"])
+        self._headers: List[Header] = self._initializer["headers"]
+        self._all_headers_future: Optional[asyncio.Future[List[Header]]] = None
 
     def __repr__(self) -> str:
         return f"<Request url={self.url!r} method={self.method!r}>"
@@ -87,9 +82,11 @@ def resource_type(self) -> str:
     def method(self) -> str:
         return self._initializer["method"]
 
-    @property
-    def sizes(self) -> RequestSizes:
-        return self._sizes
+    async def sizes(self) -> RequestSizes:
+        response = await self.response()
+        if not response:
+            raise Error("Unable to fetch sizes for failed request")
+        return await response._channel.send("sizes")
 
     @property
     def post_data(self) -> Optional[str]:
@@ -120,7 +117,7 @@ def post_data_buffer(self) -> Optional[bytes]:
 
     @property
     def headers(self) -> Dict[str, str]:
-        return self._headers
+        return headers_array_to_object(self._headers, True)
 
     async def response(self) -> Optional["Response"]:
         return from_nullable_channel(await self._channel.send("response"))
@@ -148,6 +145,27 @@ def failure(self) -> Optional[str]:
     def timing(self) -> ResourceTiming:
         return self._timing
 
+    async def all_headers(self) -> Dict[str, str]:
+        return headers_array_to_object(await self._get_headers_if_needed(), True)
+
+    async def headers_array(self) -> List[List[str]]:
+        return list(
+            map(
+                lambda header: [header["name"], header["value"]],
+                await self._get_headers_if_needed(),
+            )
+        )
+
+    async def _get_headers_if_needed(self) -> List[Header]:
+        if not self._all_headers_future:
+            self._all_headers_future = asyncio.Future()
+            response = await self.response()
+            if not response:
+                return self._headers
+            headers = await response._channel.send("rawRequestHeaders")
+            self._all_headers_future.set_result(headers)
+        return await self._all_headers_future
+
 
 class Route(ChannelOwner):
     def __init__(
@@ -238,7 +256,11 @@ def __init__(
         self._request._timing["connectEnd"] = timing["connectEnd"]
         self._request._timing["requestStart"] = timing["requestStart"]
         self._request._timing["responseStart"] = timing["responseStart"]
-        self._request._headers = parse_headers(self._initializer["requestHeaders"])
+        self._headers = headers_array_to_object(
+            cast(List[Header], self._initializer["headers"]), True
+        )
+        self._raw_headers_future: Optional[asyncio.Future[List[Header]]] = None
+        self._finished_future: asyncio.Future[bool] = asyncio.Future()
 
     def __repr__(self) -> str:
         return f"<Response url={self.url!r} request={self.request}>"
@@ -263,16 +285,34 @@ def status_text(self) -> str:
 
     @property
     def headers(self) -> Dict[str, str]:
-        return parse_headers(self._initializer["headers"])
+        return self._headers.copy()
+
+    async def all_headers(self) -> Dict[str, str]:
+        return headers_array_to_object(await self._get_headers_if_needed(), True)
+
+    async def headers_array(self) -> List[List[str]]:
+        return list(
+            map(
+                lambda header: [header["name"], header["value"]],
+                await self._get_headers_if_needed(),
+            )
+        )
+
+    async def _get_headers_if_needed(self) -> List[Header]:
+        if not self._raw_headers_future:
+            self._raw_headers_future = asyncio.Future()
+            headers = cast(List[Header], await self._channel.send("rawResponseHeaders"))
+            self._raw_headers_future.set_result(headers)
+        return await self._raw_headers_future
 
     async def server_addr(self) -> Optional[RemoteAddr]:
         return await self._channel.send("serverAddr")
 
     async def security_details(self) -> Optional[SecurityDetails]:
         return await self._channel.send("securityDetails")
 
-    async def finished(self) -> Optional[str]:
-        return await self._channel.send("finished")
+    async def finished(self) -> None:
+        await self._finished_future
 
     async def body(self) -> bytes:
         binary = await self._channel.send("body")
@@ -384,5 +424,8 @@ def serialize_headers(headers: Dict[str, str]) -> List[Header]:
     return [{"name": name, "value": value} for name, value in headers.items()]
 
 
-def parse_headers(headers: List[Header]) -> Dict[str, str]:
-    return {header["name"].lower(): header["value"] for header in headers}
+def headers_array_to_object(headers: List[Header], lower_case: bool) -> Dict[str, str]:
+    return {
+        (header["name"].lower() if lower_case else header["name"]): header["value"]
+        for header in headers
+    }

playwright/_impl/_page.py

@@ -45,6 +45,7 @@
 from playwright._impl._helper import (
     ColorScheme,
     DocumentLoadState,
+    ForcedColors,
     KeyboardModifier,
     MouseButton,
     ReducedMotion,
@@ -513,6 +514,7 @@ async def emulate_media(
         media: Literal["print", "screen"] = None,
         colorScheme: ColorScheme = None,
         reducedMotion: ReducedMotion = None,
+        forcedColors: ForcedColors = None,
     ) -> None:
         await self._channel.send("emulateMedia", locals_to_params(locals()))