chore: roll 1.58

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 -->143.0.7499.4<!-- GEN:stop --> | ✅ | ✅ | ✅ |
+| Chromium <!-- GEN:chromium-version -->144.0.7559.20<!-- GEN:stop --> | ✅ | ✅ | ✅ |
 | WebKit <!-- GEN:webkit-version -->26.0<!-- GEN:stop --> | ✅ | ✅ | ✅ |
-| Firefox <!-- GEN:firefox-version -->144.0.2<!-- GEN:stop --> | ✅ | ✅ | ✅ |
+| Firefox <!-- GEN:firefox-version -->146.0.1<!-- GEN:stop --> | ✅ | ✅ | ✅ |
 
 ## Documentation
 

playwright/_impl/_browser_type.py

@@ -200,6 +200,7 @@ async def connect_over_cdp(
         timeout: float = None,
         slowMo: float = None,
         headers: Dict[str, str] = None,
+        isLocal: bool = None,
     ) -> Browser:
         params = locals_to_params(locals())
         if params.get("headers"):

playwright/_impl/_console_message.py

@@ -57,6 +57,7 @@ def type(self) -> Union[
         Literal["startGroup"],
         Literal["startGroupCollapsed"],
         Literal["table"],
+        Literal["time"],
         Literal["timeEnd"],
         Literal["trace"],
         Literal["warning"],

playwright/_impl/_object_factory.py

@@ -34,6 +34,7 @@
     WebSocketRoute,
 )
 from playwright._impl._page import BindingCall, Page, Worker
+from playwright._impl._page_agent import PageAgent
 from playwright._impl._playwright import Playwright
 from playwright._impl._stream import Stream
 from playwright._impl._tracing import Tracing
@@ -79,6 +80,8 @@ def create_remote_object(
         return local_utils
     if type == "Page":
         return Page(parent, type, guid, initializer)
+    if type == "PageAgent":
+        return PageAgent(parent, type, guid, initializer)
     if type == "Playwright":
         return Playwright(parent, type, guid, initializer)
     if type == "Request":

playwright/_impl/_page.py

@@ -106,6 +106,7 @@
     from playwright._impl._fetch import APIRequestContext
     from playwright._impl._locator import FrameLocator, Locator
     from playwright._impl._network import WebSocket
+    from playwright._impl._page_agent import PageAgent
 
 
 class LocatorHandler:
@@ -1117,6 +1118,45 @@ def workers(self) -> List["Worker"]:
     def request(self) -> "APIRequestContext":
         return self.context.request
 
+    async def agent(
+        self,
+        provider: Dict[str, Any] = None,
+        cache: Dict[str, str] = None,
+        maxTokens: int = None,
+        maxTurns: int = None,
+        secrets: Dict[str, str] = None,
+        systemPrompt: str = None,
+    ) -> "PageAgent":
+        from playwright._impl._page_agent import PageAgent
+
+        params: Dict[str, Any] = {}
+        if provider is not None:
+            if "api" in provider:
+                params["api"] = provider["api"]
+            if "apiEndpoint" in provider:
+                params["apiEndpoint"] = provider["apiEndpoint"]
+            if "apiKey" in provider:
+                params["apiKey"] = provider["apiKey"]
+            if "model" in provider:
+                params["model"] = provider["model"]
+        if cache is not None:
+            if "cacheFile" in cache:
+                params["cacheFile"] = cache["cacheFile"]
+            if "cacheOutFile" in cache:
+                params["cacheOutFile"] = cache["cacheOutFile"]
+        if maxTokens is not None:
+            params["maxTokens"] = maxTokens
+        if maxTurns is not None:
+            params["maxTurns"] = maxTurns
+        if secrets is not None:
+            params["secrets"] = [
+                {"name": name, "value": value} for name, value in secrets.items()
+            ]
+        if systemPrompt is not None:
+            params["systemPrompt"] = systemPrompt
+        result = await self._channel.send_return_as_dict("agent", None, params)
+        return from_channel(result["agent"])
+
     async def pause(self) -> None:
         default_navigation_timeout = (
             self._browser_context._timeout_settings.default_navigation_timeout()

playwright/_impl/_page_agent.py

@@ -0,0 +1,72 @@
+# 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 types import SimpleNamespace
+from typing import TYPE_CHECKING, Any, Dict, List, Optional
+
+from playwright._impl._connection import ChannelOwner, from_channel
+from playwright._impl._helper import locals_to_params
+
+
+class PageAgent(ChannelOwner):
+    Events = SimpleNamespace(
+        Turn="turn",
+    )
+
+    def __init__(
+        self, parent: ChannelOwner, type: str, guid: str, initializer: Dict
+    ) -> None:
+        super().__init__(parent, type, guid, initializer)
+        self._channel.on(
+            "turn", lambda params: self.emit(PageAgent.Events.Turn, params)
+        )
+
+    async def expect(
+        self,
+        expectation: str,
+        cacheKey: str = None,
+        maxTokens: int = None,
+        maxTurns: int = None,
+        timeout: float = None,
+    ) -> None:
+        await self._channel.send("expect", None, locals_to_params(locals()))
+
+    async def perform(
+        self,
+        task: str,
+        cacheKey: str = None,
+        maxTokens: int = None,
+        maxTurns: int = None,
+        timeout: float = None,
+    ) -> Dict[str, Any]:
+        return await self._channel.send_return_as_dict(
+            "perform", None, locals_to_params(locals())
+        )
+
+    async def extract(
+        self,
+        query: str,
+        schema: Dict[str, Any],
+        cacheKey: str = None,
+        maxTokens: int = None,
+        maxTurns: int = None,
+        timeout: float = None,
+    ) -> Dict[str, Any]:
+        # TODO: implement pydantic
+        return await self._channel.send_return_as_dict(
+            "extract", None, locals_to_params(locals())
+        )
+
+    async def dispose(self) -> None:
+        await self._channel.send("dispose", None)