chore: roll to Playwright ToT (#481)

Author: pavelfeldman

README.md

@@ -6,9 +6,9 @@ Playwright is a Python library to automate [Chromium](https://www.chromium.org/H
 
 |          | Linux | macOS | Windows |
 |   :---   | :---: | :---: | :---:   |
-| Chromium <!-- GEN:chromium-version -->90.0.4392.0<!-- GEN:stop --> | ✅ | ✅ | ✅ |
+| Chromium <!-- GEN:chromium-version -->90.0.4396.0<!-- GEN:stop --> | ✅ | ✅ | ✅ |
 | WebKit <!-- GEN:webkit-version -->14.1<!-- GEN:stop --> | ✅ | ✅ | ✅ |
-| Firefox <!-- GEN:firefox-version -->85.0b5<!-- GEN:stop --> | ✅ | ✅ | ✅ |
+| Firefox <!-- GEN:firefox-version -->85.0b10<!-- GEN:stop --> | ✅ | ✅ | ✅ |
 
 Headless execution is supported for all browsers on all platforms.
 

playwright/_impl/_browser_context.py

@@ -235,6 +235,9 @@ async def close(self) -> None:
             if not is_safe_close_error(e):
                 raise e
 
+    async def _pause(self) -> None:
+        await self._channel.send("pause")
+
     async def storage_state(self, path: Union[str, Path] = None) -> StorageState:
         result = await self._channel.send_return_as_dict("storageState")
         if path:

playwright/_impl/_element_handle.py

@@ -243,15 +243,13 @@ async def eval_on_selector(
         selector: str,
         expression: str,
         arg: Serializable = None,
-        force_expr: bool = None,
     ) -> Any:
         return parse_result(
             await self._channel.send(
                 "evalOnSelector",
                 dict(
                     selector=selector,
                     expression=expression,
-                    isFunction=not (force_expr),
                     arg=serialize_argument(arg),
                 ),
             )
@@ -262,15 +260,13 @@ async def eval_on_selector_all(
         selector: str,
         expression: str,
         arg: Serializable = None,
-        force_expr: bool = None,
     ) -> Any:
         return parse_result(
             await self._channel.send(
                 "evalOnSelectorAll",
                 dict(
                     selector=selector,
                     expression=expression,
-                    isFunction=not (force_expr),
                     arg=serialize_argument(arg),
                 ),
             )

playwright/_impl/_frame.py

@@ -36,7 +36,6 @@
     MouseButton,
     URLMatch,
     URLMatcher,
-    is_function_body,
     locals_to_params,
     monotonic_time,
 )
@@ -195,33 +194,25 @@ async def wait_for_load_state(
     async def frame_element(self) -> ElementHandle:
         return from_channel(await self._channel.send("frameElement"))
 
-    async def evaluate(
-        self, expression: str, arg: Serializable = None, force_expr: bool = None
-    ) -> Any:
-        if not is_function_body(expression):
-            force_expr = True
+    async def evaluate(self, expression: str, arg: Serializable = None) -> Any:
         return parse_result(
             await self._channel.send(
                 "evaluateExpression",
                 dict(
                     expression=expression,
-                    isFunction=not (force_expr),
                     arg=serialize_argument(arg),
                 ),
             )
         )
 
     async def evaluate_handle(
-        self, expression: str, arg: Serializable = None, force_expr: bool = None
+        self, expression: str, arg: Serializable = None
     ) -> JSHandle:
-        if not is_function_body(expression):
-            force_expr = True
         return from_channel(
             await self._channel.send(
                 "evaluateExpressionHandle",
                 dict(
                     expression=expression,
-                    isFunction=not (force_expr),
                     arg=serialize_argument(arg),
                 ),
             )
@@ -281,15 +272,13 @@ async def eval_on_selector(
         selector: str,
         expression: str,
         arg: Serializable = None,
-        force_expr: bool = None,
     ) -> Any:
         return parse_result(
             await self._channel.send(
                 "evalOnSelector",
                 dict(
                     selector=selector,
                     expression=expression,
-                    isFunction=not (force_expr),
                     arg=serialize_argument(arg),
                 ),
             )
@@ -300,15 +289,13 @@ async def eval_on_selector_all(
         selector: str,
         expression: str,
         arg: Serializable = None,
-        force_expr: bool = None,
     ) -> Any:
         return parse_result(
             await self._channel.send(
                 "evalOnSelectorAll",
                 dict(
                     selector=selector,
                     expression=expression,
-                    isFunction=not (force_expr),
                     arg=serialize_argument(arg),
                 ),
             )
@@ -516,14 +503,10 @@ async def wait_for_function(
         self,
         expression: str,
         arg: Serializable = None,
-        force_expr: bool = None,
         timeout: float = None,
         polling: Union[float, Literal["raf"]] = None,
     ) -> JSHandle:
-        if not is_function_body(expression):
-            force_expr = True
         params = locals_to_params(locals())
-        params["isFunction"] = not (force_expr)
         params["arg"] = serialize_argument(arg)
         return from_channel(await self._channel.send("waitForFunction", params))
 

playwright/_impl/_helper.py

@@ -175,15 +175,6 @@ def patch_error_message(message: Optional[str]) -> Optional[str]:
     return message
 
 
-def is_function_body(expression: str) -> bool:
-    expression = expression.strip()
-    return (
-        expression.startswith("function")
-        or expression.startswith("async ")
-        or "=>" in expression
-    )
-
-
 def locals_to_params(args: Dict) -> Dict:
     copy = {}
     for key in args:

playwright/_impl/_js_handle.py

@@ -18,7 +18,6 @@
 
 from playwright._impl._api_types import Error
 from playwright._impl._connection import ChannelOwner, from_channel
-from playwright._impl._helper import is_function_body
 
 if TYPE_CHECKING:  # pragma: no cover
     from playwright._impl._element_handle import ElementHandle
@@ -43,33 +42,25 @@ def __str__(self) -> str:
     def _on_preview_updated(self, preview: str) -> None:
         self._preview = preview
 
-    async def evaluate(
-        self, expression: str, arg: Serializable = None, force_expr: bool = None
-    ) -> Any:
-        if not is_function_body(expression):
-            force_expr = True
+    async def evaluate(self, expression: str, arg: Serializable = None) -> Any:
         return parse_result(
             await self._channel.send(
                 "evaluateExpression",
                 dict(
                     expression=expression,
-                    isFunction=not (force_expr),
                     arg=serialize_argument(arg),
                 ),
             )
         )
 
     async def evaluate_handle(
-        self, expression: str, arg: Serializable = None, force_expr: bool = None
+        self, expression: str, arg: Serializable = None
     ) -> "JSHandle":
-        if not is_function_body(expression):
-            force_expr = True
         return from_channel(
             await self._channel.send(
                 "evaluateExpressionHandle",
                 dict(
                     expression=expression,
-                    isFunction=not (force_expr),
                     arg=serialize_argument(arg),
                 ),
             )

playwright/_impl/_page.py

@@ -52,7 +52,6 @@
     URLMatcher,
     URLMatchRequest,
     URLMatchResponse,
-    is_function_body,
     is_safe_close_error,
     locals_to_params,
     parse_error,
@@ -139,12 +138,7 @@ def __init__(
             ),
         )
         self._channel.on("crash", lambda _: self._on_crash())
-        self._channel.on(
-            "dialog",
-            lambda params: self.emit(
-                Page.Events.Dialog, from_channel(params["dialog"])
-            ),
-        )
+        self._channel.on("dialog", lambda params: self._on_dialog(params))
         self._channel.on(
             "domcontentloaded", lambda _: self.emit(Page.Events.DOMContentLoaded)
         )
@@ -290,6 +284,13 @@ def _on_close(self) -> None:
     def _on_crash(self) -> None:
         self.emit(Page.Events.Crash)
 
+    def _on_dialog(self, params: Any) -> None:
+        dialog = from_channel(params["dialog"])
+        if self.listeners(Page.Events.Dialog):
+            self.emit(Page.Events.Dialog, dialog)
+        else:
+            asyncio.create_task(dialog.dismiss())
+
     def _add_event_handler(self, event: str, k: Any, v: Any) -> None:
         if event == Page.Events.FileChooser and len(self.listeners(event)) == 0:
             self._channel.send_no_reply(
@@ -375,39 +376,29 @@ async def dispatch_event(
     ) -> None:
         return await self._main_frame.dispatch_event(**locals_to_params(locals()))
 
-    async def evaluate(
-        self, expression: str, arg: Serializable = None, force_expr: bool = None
-    ) -> Any:
-        return await self._main_frame.evaluate(expression, arg, force_expr=force_expr)
+    async def evaluate(self, expression: str, arg: Serializable = None) -> Any:
+        return await self._main_frame.evaluate(expression, arg)
 
     async def evaluate_handle(
-        self, expression: str, arg: Serializable = None, force_expr: bool = None
+        self, expression: str, arg: Serializable = None
     ) -> JSHandle:
-        return await self._main_frame.evaluate_handle(
-            expression, arg, force_expr=force_expr
-        )
+        return await self._main_frame.evaluate_handle(expression, arg)
 
     async def eval_on_selector(
         self,
         selector: str,
         expression: str,
         arg: Serializable = None,
-        force_expr: bool = None,
     ) -> Any:
-        return await self._main_frame.eval_on_selector(
-            selector, expression, arg, force_expr=force_expr
-        )
+        return await self._main_frame.eval_on_selector(selector, expression, arg)
 
     async def eval_on_selector_all(
         self,
         selector: str,
         expression: str,
         arg: Serializable = None,
-        force_expr: bool = None,
     ) -> Any:
-        return await self._main_frame.eval_on_selector_all(
-            selector, expression, arg, force_expr=force_expr
-        )
+        return await self._main_frame.eval_on_selector_all(selector, expression, arg)
 
     async def add_script_tag(
         self,
@@ -729,18 +720,18 @@ async def wait_for_function(
         self,
         expression: str,
         arg: Serializable = None,
-        force_expr: bool = None,
         timeout: float = None,
         polling: Union[float, Literal["raf"]] = None,
     ) -> JSHandle:
-        if not is_function_body(expression):
-            force_expr = True
         return await self._main_frame.wait_for_function(**locals_to_params(locals()))
 
     @property
     def workers(self) -> List["Worker"]:
         return self._workers.copy()
 
+    async def pause(self) -> None:
+        await self._browser_context._pause()
+
     async def pdf(
         self,
         scale: float = None,
@@ -903,31 +894,25 @@ def _on_close(self) -> None:
     def url(self) -> str:
         return self._initializer["url"]
 
-    async def evaluate(
-        self, expression: str, arg: Serializable = None, force_expr: bool = None
-    ) -> Any:
-        if not is_function_body(expression):
-            force_expr = True
+    async def evaluate(self, expression: str, arg: Serializable = None) -> Any:
         return parse_result(
             await self._channel.send(
                 "evaluateExpression",
                 dict(
                     expression=expression,
-                    isFunction=not (force_expr),
                     arg=serialize_argument(arg),
                 ),
             )
         )
 
     async def evaluate_handle(
-        self, expression: str, arg: Serializable = None, force_expr: bool = None
+        self, expression: str, arg: Serializable = None
     ) -> JSHandle:
         return from_channel(
             await self._channel.send(
                 "evaluateExpressionHandle",
                 dict(
                     expression=expression,
-                    isFunction=not (force_expr),
                     arg=serialize_argument(arg),
                 ),
             )