chore: roll to 1.53.1

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 -->136.0.7103.25<!-- GEN:stop --> | ✅ | ✅ | ✅ |
-| WebKit <!-- GEN:webkit-version -->18.4<!-- GEN:stop --> | ✅ | ✅ | ✅ |
-| Firefox <!-- GEN:firefox-version -->137.0<!-- GEN:stop --> | ✅ | ✅ | ✅ |
+| Chromium <!-- GEN:chromium-version -->138.0.7204.15<!-- GEN:stop --> | ✅ | ✅ | ✅ |
+| WebKit <!-- GEN:webkit-version -->18.5<!-- GEN:stop --> | ✅ | ✅ | ✅ |
+| Firefox <!-- GEN:firefox-version -->139.0<!-- GEN:stop --> | ✅ | ✅ | ✅ |
 
 ## Documentation
 

playwright/_impl/_browser.py

@@ -12,10 +12,19 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-import json
 from pathlib import Path
 from types import SimpleNamespace
-from typing import TYPE_CHECKING, Dict, List, Optional, Pattern, Sequence, Union, cast
+from typing import (
+    TYPE_CHECKING,
+    Dict,
+    List,
+    Optional,
+    Pattern,
+    Sequence,
+    Set,
+    Union,
+    cast,
+)
 
 from playwright._impl._api_structures import (
     ClientCertificate,
@@ -38,12 +47,9 @@
     HarMode,
     ReducedMotion,
     ServiceWorkersPolicy,
-    async_readfile,
     locals_to_params,
     make_dirs_for_file,
-    prepare_record_har_options,
 )
-from playwright._impl._network import serialize_headers, to_client_certificates_protocol
 from playwright._impl._page import Page
 
 if TYPE_CHECKING:  # pragma: no cover
@@ -64,20 +70,52 @@ def __init__(
         self._should_close_connection_on_close = False
         self._cr_tracing_path: Optional[str] = None
 
-        self._contexts: List[BrowserContext] = []
+        self._contexts: Set[BrowserContext] = set()
+        self._traces_dir: Optional[str] = None
+        self._channel.on(
+            "context",
+            lambda params: self._did_create_context(
+                cast(BrowserContext, from_channel(params["context"]))
+            ),
+        )
         self._channel.on("close", lambda _: self._on_close())
         self._close_reason: Optional[str] = None
 
     def __repr__(self) -> str:
         return f"<Browser type={self._browser_type} version={self.version}>"
 
+    def _connect_to_browser_type(
+        self,
+        browserType: "BrowserType",
+        tracesDir: Optional[str] = None,
+    ) -> None:
+        # Note: when using connect(), `browserType` is different from `this.parent`.
+        # This is why browser type is not wired up in the constructor, and instead this separate method is called later on.
+        self._browser_type = browserType
+        self._traces_dir = tracesDir
+        for context in self._contexts:
+            self._setup_browser_context(context)
+
+    def _did_create_context(self, context: BrowserContext) -> None:
+        context._browser = self
+        self._contexts.add(context)
+        # Note: when connecting to a browser, initial contexts arrive before `_browserType` is set,
+        # and will be configured later in `ConnectToBrowserType`.
+        if self._browser_type:
+            self._setup_browser_context(context)
+
+    def _setup_browser_context(self, context: BrowserContext) -> None:
+        context._tracing._traces_dir = self._traces_dir
+        print("Appending context to selectors")
+        self._browser_type._playwright.selectors._contextsForSelectors.add(context)
+
     def _on_close(self) -> None:
         self._is_connected = False
         self.emit(Browser.Events.Disconnected, self)
 
     @property
     def contexts(self) -> List[BrowserContext]:
-        return self._contexts.copy()
+        return list(self._contexts)
 
     @property
     def browser_type(self) -> "BrowserType":
@@ -126,11 +164,17 @@ async def new_context(
         clientCertificates: List[ClientCertificate] = None,
     ) -> BrowserContext:
         params = locals_to_params(locals())
-        await prepare_browser_context_params(params)
+        await self._browser_type._prepare_browser_context_params(params)
 
         channel = await self._channel.send("newContext", params)
         context = cast(BrowserContext, from_channel(channel))
-        self._browser_type._did_create_context(context, params, {})
+        await context._initialize_har_from_options(
+            record_har_content=recordHarContent,
+            record_har_mode=recordHarMode,
+            record_har_omit_content=recordHarOmitContent,
+            record_har_path=recordHarPath,
+            record_har_url_filter=recordHarUrlFilter,
+        )
         return context
 
     async def new_page(
@@ -226,43 +270,3 @@ async def stop_tracing(self) -> bytes:
                 f.write(buffer)
             self._cr_tracing_path = None
         return buffer
-
-
-async def prepare_browser_context_params(params: Dict) -> None:
-    if params.get("noViewport"):
-        del params["noViewport"]
-        params["noDefaultViewport"] = True
-    if "defaultBrowserType" in params:
-        del params["defaultBrowserType"]
-    if "extraHTTPHeaders" in params:
-        params["extraHTTPHeaders"] = serialize_headers(params["extraHTTPHeaders"])
-    if "recordHarPath" in params:
-        params["recordHar"] = prepare_record_har_options(params)
-        del params["recordHarPath"]
-    if "recordVideoDir" in params:
-        params["recordVideo"] = {"dir": Path(params["recordVideoDir"]).absolute()}
-        if "recordVideoSize" in params:
-            params["recordVideo"]["size"] = params["recordVideoSize"]
-            del params["recordVideoSize"]
-        del params["recordVideoDir"]
-    if "storageState" in params:
-        storageState = params["storageState"]
-        if not isinstance(storageState, dict):
-            params["storageState"] = json.loads(
-                (await async_readfile(storageState)).decode()
-            )
-    if params.get("colorScheme", None) == "null":
-        params["colorScheme"] = "no-override"
-    if params.get("reducedMotion", None) == "null":
-        params["reducedMotion"] = "no-override"
-    if params.get("forcedColors", None) == "null":
-        params["forcedColors"] = "no-override"
-    if params.get("contrast", None) == "null":
-        params["contrast"] = "no-override"
-    if "acceptDownloads" in params:
-        params["acceptDownloads"] = "accept" if params["acceptDownloads"] else "deny"
-
-    if "clientCertificates" in params:
-        params["clientCertificates"] = await to_client_certificates_protocol(
-            params["clientCertificates"]
-        )

playwright/_impl/_browser_context.py

@@ -66,7 +66,6 @@
     async_writefile,
     locals_to_params,
     parse_error,
-    prepare_record_har_options,
     to_impl,
 )
 from playwright._impl._network import (
@@ -106,18 +105,18 @@ def __init__(
         self, parent: ChannelOwner, type: str, guid: str, initializer: Dict
     ) -> None:
         super().__init__(parent, type, guid, initializer)
+        # Browser is null for browser contexts created outside of normal browser, e.g. android or electron.
         # circular import workaround:
         self._browser: Optional["Browser"] = None
         if parent.__class__.__name__ == "Browser":
             self._browser = cast("Browser", parent)
-            self._browser._contexts.append(self)
         self._pages: List[Page] = []
         self._routes: List[RouteHandler] = []
         self._web_socket_routes: List[WebSocketRouteHandler] = []
         self._bindings: Dict[str, Any] = {}
         self._timeout_settings = TimeoutSettings(None)
         self._owner_page: Optional[Page] = None
-        self._options: Dict[str, Any] = {}
+        self._options: Dict[str, Any] = initializer.get("options", {})
         self._background_pages: Set[Page] = set()
         self._service_workers: Set[Worker] = set()
         self._tracing = cast(Tracing, from_channel(initializer["tracing"]))
@@ -220,7 +219,7 @@ def __init__(
                 BrowserContext.Events.RequestFailed: "requestFailed",
             }
         )
-        self._close_was_called = False
+        self._closing_or_closed = False
 
     def __repr__(self) -> str:
         return f"<BrowserContext browser={self.browser}>"
@@ -237,7 +236,7 @@ async def _on_route(self, route: Route) -> None:
         route_handlers = self._routes.copy()
         for route_handler in route_handlers:
             # If the page or the context was closed we stall all requests right away.
-            if (page and page._close_was_called) or self._close_was_called:
+            if (page and page._close_was_called) or self._closing_or_closed:
                 return
             if not route_handler.matches(route.request.url):
                 continue
@@ -288,19 +287,12 @@ def set_default_navigation_timeout(self, timeout: float) -> None:
 
     def _set_default_navigation_timeout_impl(self, timeout: Optional[float]) -> None:
         self._timeout_settings.set_default_navigation_timeout(timeout)
-        self._channel.send_no_reply(
-            "setDefaultNavigationTimeoutNoReply",
-            {} if timeout is None else {"timeout": timeout},
-        )
 
     def set_default_timeout(self, timeout: float) -> None:
         return self._set_default_timeout_impl(timeout)
 
     def _set_default_timeout_impl(self, timeout: Optional[float]) -> None:
         self._timeout_settings.set_default_timeout(timeout)
-        self._channel.send_no_reply(
-            "setDefaultTimeoutNoReply", {} if timeout is None else {"timeout": timeout}
-        )
 
     @property
     def pages(self) -> List[Page]:
@@ -310,14 +302,33 @@ def pages(self) -> List[Page]:
     def browser(self) -> Optional["Browser"]:
         return self._browser
 
-    def _set_options(self, context_options: Dict, browser_options: Dict) -> None:
-        self._options = context_options
-        if self._options.get("recordHar"):
-            self._har_recorders[""] = {
-                "path": self._options["recordHar"]["path"],
-                "content": self._options["recordHar"].get("content"),
-            }
-        self._tracing._traces_dir = browser_options.get("tracesDir")
+    async def _initialize_har_from_options(
+        self,
+        record_har_path: Optional[Union[Path, str]],
+        record_har_content: Optional[HarContentPolicy],
+        record_har_omit_content: Optional[bool],
+        record_har_url_filter: Optional[Union[Pattern[str], str]],
+        record_har_mode: Optional[HarMode],
+    ) -> None:
+        if not record_har_path:
+            return
+        record_har_path = str(record_har_path)
+        if len(record_har_path) == 0:
+            return
+        # Forcibly provide type to satisfy mypy
+        default_policy: HarContentPolicy = (
+            "attach" if record_har_path.endswith(".zip") else "embed"
+        )
+        content_policy: HarContentPolicy = record_har_content or (
+            "omit" if record_har_omit_content is True else default_policy
+        )
+        await self._record_into_har(
+            har=record_har_path,
+            page=None,
+            url=record_har_url_filter,
+            update_content=content_policy,
+            update_mode=(record_har_mode or "full"),
+        )
 
     async def new_page(self) -> Page:
         if self._owner_page:
@@ -476,22 +487,25 @@ async def _record_into_har(
         update_content: HarContentPolicy = None,
         update_mode: HarMode = None,
     ) -> None:
+        update_content = update_content or "attach"
         params: Dict[str, Any] = {
-            "options": prepare_record_har_options(
-                {
-                    "recordHarPath": har,
-                    "recordHarContent": update_content or "attach",
-                    "recordHarMode": update_mode or "minimal",
-                    "recordHarUrlFilter": url,
-                }
-            )
+            "options": {
+                "zip": str(har).endswith(".zip"),
+                "content": update_content,
+                "urlGlob": url if isinstance(url, str) else None,
+                "urlRegexSource": url.pattern if isinstance(url, Pattern) else None,
+                "urlRegexFlags": (
+                    escape_regex_flags(url) if isinstance(url, Pattern) else None
+                ),
+                "mode": update_mode or "minimal",
+            }
         }
         if page:
             params["page"] = page._channel
         har_id = await self._channel.send("harStart", params)
         self._har_recorders[har_id] = {
             "path": str(har),
-            "content": update_content or "attach",
+            "content": update_content,
         }
 
     async def route_from_har(
@@ -555,22 +569,30 @@ def expect_event(
         return EventContextManagerImpl(waiter.result())
 
     def _on_close(self) -> None:
+        self._closing_or_closed = True
         if self._browser:
-            self._browser._contexts.remove(self)
+            try:
+                self._browser._contexts.remove(self)
+            except KeyError:
+                pass
+            try:
+                self._browser._browser_type._playwright.selectors._contextsForSelectors.remove(
+                    self
+                )
+            except KeyError:
+                pass
 
         self._dispose_har_routers()
         self._tracing._reset_stack_counter()
         self.emit(BrowserContext.Events.Close, self)
 
     async def close(self, reason: str = None) -> None:
-        if self._close_was_called:
+        if self._closing_or_closed:
             return
         self._close_reason = reason
-        self._close_was_called = True
+        self._closing_or_closed = True
 
-        await self._channel._connection.wrap_api_call(
-            lambda: self.request.dispose(reason=reason), True
-        )
+        await self.request.dispose(reason=reason)
 
         async def _inner_close() -> None:
             for har_id, params in self._har_recorders.items():