Bumped to 1.53.0-beta-1749221468000 due to selector bug

Author: agg23

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 -->137.0.7151.27<!-- 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/_api_structures.py

@@ -34,10 +34,6 @@ class Cookie(TypedDict, total=False):
     sameSite: Literal["Lax", "None", "Strict"]
 
 
-class PartitionedCookie(Cookie):
-    partitionKey: Optional[str]
-
-
 # TODO: We are waiting for PEP705 so SetCookieParam can be readonly and matches Cookie.
 class SetCookieParam(TypedDict, total=False):
     name: str
@@ -49,7 +45,6 @@ class SetCookieParam(TypedDict, total=False):
     httpOnly: Optional[bool]
     secure: Optional[bool]
     sameSite: Optional[Literal["Lax", "None", "Strict"]]
-    partitionKey: Optional[str]
 
 
 class FloatRect(TypedDict):
@@ -106,11 +101,6 @@ class StorageState(TypedDict, total=False):
     origins: List[OriginState]
 
 
-class PartitionedStorageState(TypedDict, total=False):
-    cookies: List[PartitionedCookie]
-    origins: List[OriginState]
-
-
 class ClientCertificate(TypedDict, total=False):
     origin: str
     certPath: Optional[Union[str, Path]]

playwright/_impl/_assertions.py

@@ -51,6 +51,7 @@ async def _expect_impl(
         expect_options: FrameExpectOptions,
         expected: Any,
         message: str,
+        # title: str,
     ) -> None:
         __tracebackhide__ = True
         expect_options["isNot"] = self._is_not
@@ -60,6 +61,7 @@ async def _expect_impl(
             message = message.replace("expected to", "expected not to")
         if "useInnerText" in expect_options and expect_options["useInnerText"] is None:
             del expect_options["useInnerText"]
+        # result = await self._actual_locator._expect(expression, expect_options, title)
         result = await self._actual_locator._expect(expression, expect_options)
         if result["matches"] == self._is_not:
             actual = result.get("received")
@@ -123,7 +125,10 @@ async def to_have_url(
         base_url = self._actual_page.context._options.get("baseURL")
         if isinstance(urlOrRegExp, str) and base_url:
             urlOrRegExp = urljoin(base_url, urlOrRegExp)
+            print("Changed", urlOrRegExp)
+        print("Expecting URL", urlOrRegExp)
         expected_text = to_expected_text_values([urlOrRegExp], ignoreCase=ignoreCase)
+        print("Expected text", expected_text)
         await self._expect_impl(
             "to.have.url",
             FrameExpectOptions(expectedText=expected_text, timeout=timeout),

playwright/_impl/_browser.py

@@ -65,12 +65,43 @@ def __init__(
         self._cr_tracing_path: Optional[str] = None
 
         self._contexts: List[BrowserContext] = []
+        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.append(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
+        self._browser_type._playwright.selectors._contextsForSelectors.append(context)
+
     def _on_close(self) -> None:
         self._is_connected = False
         self.emit(Browser.Events.Disconnected, self)
@@ -130,7 +161,15 @@ async def new_context(
 
         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(
+            {
+                "recordHarPath": recordHarPath,
+                "recordHarContent": recordHarContent,
+                "recordHarOmitContent": recordHarOmitContent,
+                "recordHarUrlFilter": recordHarUrlFilter,
+                "recordHarMode": recordHarMode,
+            }
+        )
         return context
 
     async def new_page(
@@ -181,6 +220,7 @@ async def inner() -> Page:
             context._owner_page = page
             return page
 
+        # TODO: Args
         return await self._connection.wrap_api_call(inner)
 
     async def close(self, reason: str = None) -> None:

playwright/_impl/_browser_context.py

@@ -32,10 +32,10 @@
 )
 
 from playwright._impl._api_structures import (
+    Cookie,
     Geolocation,
-    PartitionedCookie,
-    PartitionedStorageState,
     SetCookieParam,
+    StorageState,
 )
 from playwright._impl._artifact import Artifact
 from playwright._impl._cdp_session import CDPSession
@@ -66,7 +66,6 @@
     async_writefile,
     locals_to_params,
     parse_error,
-    prepare_record_har_options,
     to_impl,
 )
 from playwright._impl._network import (
@@ -106,6 +105,7 @@ 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":
@@ -220,7 +220,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 +237,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
@@ -312,14 +312,29 @@ def _set_options(self, context_options: Dict, browser_options: Dict) -> None:
             }
         self._tracing._traces_dir = browser_options.get("tracesDir")
 
+    async def _initialize_har_from_options(self, options: Dict) -> None:
+        record_har_path = str(options["recordHarPath"])
+        if not record_har_path or len(record_har_path) == 0:
+            return
+        default_policy = "attach" if record_har_path.endswith(".zip") else "embed"
+        content_policy = options.get(
+            "recordHarContent",
+            "omit" if options["recordHarOmitContent"] is True else default_policy,
+        )
+        await self._record_into_har(
+            har=record_har_path,
+            page=None,
+            url=options["recordHarUrlFilter"],
+            update_content=content_policy,
+            update_mode=options.get("recordHarMode", "full"),
+        )
+
     async def new_page(self) -> Page:
         if self._owner_page:
             raise Error("Please use browser.new_context()")
         return from_channel(await self._channel.send("newPage"))
 
-    async def cookies(
-        self, urls: Union[str, Sequence[str]] = None
-    ) -> List[PartitionedCookie]:
+    async def cookies(self, urls: Union[str, Sequence[str]] = None) -> List[Cookie]:
         if urls is None:
             urls = []
         if isinstance(urls, str):
@@ -471,22 +486,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(
@@ -550,22 +568,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 ValueError:
+                pass
+            try:
+                self._browser._browser_type._playwright.selectors._contextsForSelectors.remove(
+                    self
+                )
+            except ValueError:
+                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():
@@ -596,7 +622,7 @@ async def _inner_close() -> None:
 
     async def storage_state(
         self, path: Union[str, Path] = None, indexedDB: bool = None
-    ) -> PartitionedStorageState:
+    ) -> StorageState:
         result = await self._channel.send_return_as_dict(
             "storageState", {"indexedDB": indexedDB}
         )