chore: roll to 1.59.1

Author: Skn0tt

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 -->145.0.7632.6<!-- GEN:stop --> | ✅ | ✅ | ✅ |
-| WebKit <!-- GEN:webkit-version -->26.0<!-- GEN:stop --> | ✅ | ✅ | ✅ |
-| Firefox <!-- GEN:firefox-version -->146.0.1<!-- GEN:stop --> | ✅ | ✅ | ✅ |
+| Chromium <!-- GEN:chromium-version -->147.0.7727.15<!-- GEN:stop --> | ✅ | ✅ | ✅ |
+| WebKit <!-- GEN:webkit-version -->26.4<!-- GEN:stop --> | ✅ | ✅ | ✅ |
+| Firefox <!-- GEN:firefox-version -->148.0.2<!-- GEN:stop --> | ✅ | ✅ | ✅ |
 
 ## Documentation
 

playwright/_impl/_api_structures.py

@@ -214,7 +214,7 @@ class FrameExpectOptions(TypedDict, total=False):
     timeout: Optional[float]
 
 
-class FrameExpectResult(TypedDict):
+class FrameExpectResult(TypedDict, total=False):
     matches: bool
     received: Any
     log: List[str]
@@ -307,7 +307,26 @@ class FrameExpectResult(TypedDict):
 ]
 
 
-class TracingGroupLocation(TypedDict):
+class TracingGroupLocation(TypedDict, total=False):
     file: str
     line: Optional[int]
     column: Optional[int]
+
+
+class BindResult(TypedDict):
+    endpoint: str
+
+
+class PausedDetailsLocation(TypedDict, total=False):
+    file: str
+    line: Optional[int]
+    column: Optional[int]
+
+
+class PausedDetails(TypedDict):
+    location: PausedDetailsLocation
+    title: str
+
+
+class OnFrame(TypedDict):
+    data: bytes

playwright/_impl/_browser.py

@@ -27,6 +27,7 @@
 )
 
 from playwright._impl._api_structures import (
+    BindResult,
     ClientCertificate,
     Geolocation,
     HttpCredentials,
@@ -240,6 +241,19 @@ async def close(self, reason: str = None) -> None:
             if not is_target_closed_error(e):
                 raise e
 
+    async def bind(
+        self,
+        title: str,
+        workspaceDir: str = None,
+        host: str = None,
+        port: int = None,
+    ) -> BindResult:
+        params = locals_to_params(locals())
+        return await self._channel.send("startServer", None, params)
+
+    async def unbind(self) -> None:
+        await self._channel.send("stopServer", None)
+
     @property
     def version(self) -> str:
         return self._initializer["version"]

playwright/_impl/_browser_context.py

@@ -46,7 +46,9 @@
     from_nullable_channel,
 )
 from playwright._impl._console_message import ConsoleMessage
+from playwright._impl._debugger import Debugger
 from playwright._impl._dialog import Dialog
+from playwright._impl._disposable import Disposable, DisposableStub
 from playwright._impl._errors import Error, TargetClosedError
 from playwright._impl._event_context_manager import EventContextManagerImpl
 from playwright._impl._fetch import APIRequestContext
@@ -122,6 +124,7 @@ def __init__(
         self._base_url: Optional[str] = self._options.get("baseURL")
         self._videos_dir: Optional[str] = self._options.get("recordVideo")
         self._tracing = cast(Tracing, from_channel(initializer["tracing"]))
+        self._debugger: Debugger = from_channel(initializer["debugger"])
         self._har_recorders: Dict[str, HarRecordingMetadata] = {}
         self._request: APIRequestContext = from_channel(initializer["requestContext"])
         self._request._timeout_settings = self._timeout_settings
@@ -392,16 +395,18 @@ async def set_offline(self, offline: bool) -> None:
 
     async def add_init_script(
         self, script: str = None, path: Union[str, Path] = None
-    ) -> None:
+    ) -> Disposable:
         if path:
             script = (await async_readfile(path)).decode()
         if not isinstance(script, str):
             raise Error("Either path or script parameter must be specified")
-        await self._channel.send("addInitScript", None, dict(source=script))
+        return from_channel(
+            await self._channel.send("addInitScript", None, dict(source=script))
+        )
 
     async def expose_binding(
         self, name: str, callback: Callable, handle: bool = None
-    ) -> None:
+    ) -> Disposable:
         for page in self._pages:
             if name in page._bindings:
                 raise Error(
@@ -410,16 +415,18 @@ async def expose_binding(
         if name in self._bindings:
             raise Error(f'Function "{name}" has been already registered')
         self._bindings[name] = callback
-        await self._channel.send(
-            "exposeBinding", None, dict(name=name, needsHandle=handle or False)
+        return from_channel(
+            await self._channel.send(
+                "exposeBinding", None, dict(name=name, needsHandle=handle or False)
+            )
         )
 
-    async def expose_function(self, name: str, callback: Callable) -> None:
-        await self.expose_binding(name, lambda source, *args: callback(*args))
+    async def expose_function(self, name: str, callback: Callable) -> Disposable:
+        return await self.expose_binding(name, lambda source, *args: callback(*args))
 
     async def route(
         self, url: URLMatch, handler: RouteHandlerCallback, times: int = None
-    ) -> None:
+    ) -> DisposableStub:
         self._routes.insert(
             0,
             RouteHandler(
@@ -431,6 +438,7 @@ async def route(
             ),
         )
         await self._update_interception_patterns()
+        return DisposableStub(lambda: self.unroute(url, handler))
 
     async def unroute(
         self, url: URLMatch, handler: Optional[RouteHandlerCallback] = None
@@ -564,6 +572,9 @@ def expect_event(
         waiter.wait_for_event(self, event, predicate)
         return EventContextManagerImpl(waiter.result())
 
+    def is_closed(self) -> bool:
+        return self._closing_or_closed
+
     def _on_close(self) -> None:
         self._closing_or_closed = True
         if self._browser:
@@ -627,6 +638,16 @@ async def storage_state(
             await async_writefile(path, json.dumps(result))
         return result
 
+    async def set_storage_state(
+        self, storageState: Union[StorageState, str, Path]
+    ) -> None:
+        state: StorageState
+        if isinstance(storageState, (str, Path)):
+            state = json.loads(await async_readfile(storageState))
+        elif storageState:
+            state = storageState
+        await self._channel.send("setStorageState", None, {"storageState": state})
+
     def _effective_close_reason(self) -> Optional[str]:
         if self._close_reason:
             return self._close_reason
@@ -753,6 +774,10 @@ async def new_cdp_session(self, page: Union[Page, Frame]) -> CDPSession:
     def tracing(self) -> Tracing:
         return self._tracing
 
+    @property
+    def debugger(self) -> Debugger:
+        return self._debugger
+
     @property
     def request(self) -> "APIRequestContext":
         return self._request

playwright/_impl/_browser_type.py

@@ -88,6 +88,7 @@ async def launch(
         tracesDir: Union[pathlib.Path, str] = None,
         chromiumSandbox: bool = None,
         firefoxUserPrefs: Dict[str, Union[str, float, bool]] = None,
+        artifactsDir: Union[Path, str] = None,
     ) -> Browser:
         params = locals_to_params(locals())
         normalize_launch_params(params)
@@ -156,6 +157,7 @@ async def launch_persistent_context(
         recordHarMode: HarMode = None,
         recordHarContent: HarContentPolicy = None,
         clientCertificates: List[ClientCertificate] = None,
+        artifactsDir: Union[Path, str] = None,
     ) -> BrowserContext:
         userDataDir = self._user_data_dir(userDataDir)
         params = locals_to_params(locals())
@@ -213,7 +215,7 @@ async def connect_over_cdp(
 
     async def connect(
         self,
-        wsEndpoint: str,
+        endpoint: str,
         timeout: float = None,
         slowMo: float = None,
         headers: Dict[str, str] = None,
@@ -229,7 +231,7 @@ async def connect(
                 "connect",
                 None,
                 {
-                    "wsEndpoint": wsEndpoint,
+                    "endpoint": endpoint,
                     "headers": headers,
                     "slowMo": slowMo,
                     "timeout": timeout if timeout is not None else 0,

playwright/_impl/_cdp_session.py

@@ -24,6 +24,7 @@ def __init__(
     ) -> None:
         super().__init__(parent, type, guid, initializer)
         self._channel.on("event", lambda params: self._on_event(params))
+        self._channel.on("close", lambda _: self.emit("close"))
 
     def _on_event(self, params: Any) -> None:
         self.emit(params["method"], params.get("params"))

playwright/_impl/_console_message.py

@@ -76,6 +76,10 @@ def args(self) -> List[JSHandle]:
     def location(self) -> SourceLocation:
         return self._event["location"]
 
+    @property
+    def timestamp(self) -> float:
+        return self._event["timestamp"]
+
     @property
     def page(self) -> Optional["Page"]:
         return self._page

playwright/_impl/_debugger.py

@@ -0,0 +1,52 @@
+# 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.
+
+from typing import Dict, Optional
+
+from playwright._impl._api_structures import PausedDetails, PausedDetailsLocation
+from playwright._impl._connection import ChannelOwner
+
+
+class Debugger(ChannelOwner):
+    Events = {"PausedStateChanged": "pausedStateChanged"}
+
+    def __init__(
+        self, parent: ChannelOwner, type: str, guid: str, initializer: Dict
+    ) -> None:
+        super().__init__(parent, type, guid, initializer)
+        self._paused_details: Optional[PausedDetails] = None
+        self._channel.on(
+            "pausedStateChanged",
+            lambda params: self._on_paused_state_changed(params.get("pausedDetails")),
+        )
+
+    def _on_paused_state_changed(self, paused_details: Optional[PausedDetails]) -> None:
+        self._paused_details = paused_details
+        self.emit(Debugger.Events["PausedStateChanged"])
+
+    async def request_pause(self) -> None:
+        await self._channel.send("requestPause", None)
+
+    async def resume(self) -> None:
+        await self._channel.send("resume", None)
+
+    async def next(self) -> None:
+        await self._channel.send("next", None)
+
+    async def run_to(self, location: PausedDetailsLocation) -> None:
+        await self._channel.send("runTo", None, {"location": location})
+
+    @property
+    def paused_details(self) -> Optional[PausedDetails]:
+        return self._paused_details

playwright/_impl/_dialog.py

@@ -15,6 +15,7 @@
 from typing import TYPE_CHECKING, Dict, Optional
 
 from playwright._impl._connection import ChannelOwner, from_nullable_channel
+from playwright._impl._errors import is_target_closed_error
 from playwright._impl._helper import locals_to_params
 
 if TYPE_CHECKING:  # pragma: no cover
@@ -51,7 +52,12 @@ async def accept(self, promptText: str = None) -> None:
         await self._channel.send("accept", None, locals_to_params(locals()))
 
     async def dismiss(self) -> None:
-        await self._channel.send(
-            "dismiss",
-            None,
-        )
+        try:
+            await self._channel.send(
+                "dismiss",
+                None,
+            )
+        except Exception as e:
+            if is_target_closed_error(e):
+                return
+            raise

playwright/_impl/_disposable.py

@@ -0,0 +1,49 @@
+# 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.
+
+from typing import Awaitable, Callable, Dict
+
+from playwright._impl._connection import ChannelOwner
+from playwright._impl._errors import is_target_closed_error
+
+
+class Disposable(ChannelOwner):
+    def __init__(
+        self, parent: ChannelOwner, type: str, guid: str, initializer: Dict
+    ) -> None:
+        super().__init__(parent, type, guid, initializer)
+
+    async def dispose(self) -> None:
+        try:
+            await self._channel.send(
+                "dispose",
+                None,
+            )
+        except Exception as e:
+            if not is_target_closed_error(e):
+                raise e
+
+    def __repr__(self) -> str:
+        return "<Disposable>"
+
+
+class DisposableStub:
+    def __init__(self, dispose_fn: Callable[[], Awaitable[None]]) -> None:
+        self._dispose_fn = dispose_fn
+
+    async def dispose(self) -> None:
+        await self._dispose_fn()
+
+    def __repr__(self) -> str:
+        return "<Disposable>"