pymobiledevice3 5.3.2__py3-none-any.whl → 6.0.1__py3-none-any.whl

pymobiledevice3/_version.py

@@ -28,7 +28,7 @@ version_tuple: VERSION_TUPLE
 commit_id: COMMIT_ID
 __commit_id__: COMMIT_ID
 
-__version__ = version = '5.3.2'
-__version_tuple__ = version_tuple = (5, 3, 2)
+__version__ = version = '6.0.1'
+__version_tuple__ = version_tuple = (6, 0, 1)
 
 __commit_id__ = commit_id = None

pymobiledevice3/cli/webinspector.py

@@ -2,14 +2,16 @@ import asyncio
 import logging
 import re
 from abc import ABC, abstractmethod
-from collections.abc import Iterable
+from asyncio import CancelledError
+from collections.abc import AsyncIterator, Iterable
 from contextlib import asynccontextmanager
 from functools import update_wrapper
-from typing import Optional
+from typing import Optional, Union
 
 import click
 import inquirer3
 import IPython
+import nest_asyncio
 import uvicorn
 from inquirer3.themes import GreenPassion
 from prompt_toolkit import HTML, PromptSession
@@ -161,13 +163,22 @@ def reload_pages(inspector: WebinspectorService):
     inspector.flush_input(2)
 
 
-def create_webinspector_and_launch_app(lockdown: LockdownClient, timeout: float, app: str):
+async def create_webinspector_and_launch_app(lockdown: LockdownClient, timeout: float, app: str):
     inspector = WebinspectorService(lockdown=lockdown)
-    inspector.connect(timeout)
-    application = inspector.open_app(app)
+    await inspector.connect(timeout)
+    application = await inspector.open_app(app)
     return inspector, application
 
 
+async def opened_tabs_task(service_provider: LockdownClient, timeout):
+    inspector = WebinspectorService(lockdown=service_provider)
+    await inspector.connect(timeout)
+    application_pages = await inspector.get_open_application_pages(timeout=timeout)
+    for application_page in application_pages:
+        print(application_page)
+    await inspector.close()
+
+
 @webinspector.command(cls=Command)
 @click.option("-t", "--timeout", default=3, show_default=True, type=float)
 @catch_errors
@@ -181,12 +192,21 @@ def opened_tabs(service_provider: LockdownClient, timeout):
 
        iOS < 18: Settings -> Safari -> Advanced -> Web Inspector
     """
-    inspector = WebinspectorService(lockdown=service_provider)
-    inspector.connect(timeout)
-    application_pages = inspector.get_open_application_pages(timeout=timeout)
-    for application_page in application_pages:
-        print(application_page)
-    inspector.close()
+    asyncio.run(opened_tabs_task(service_provider, timeout), debug=True)
+
+
+@catch_errors
+async def launch_task(service_provider: LockdownClient, url, timeout):
+    inspector, safari = await create_webinspector_and_launch_app(service_provider, timeout, SAFARI)
+    session = await inspector.automation_session(safari)
+    driver = WebDriver(session)
+    print("Starting session")
+    await driver.start_session()
+    print("Getting URL")
+    await driver.get(url)
+    OSUTILS.wait_return()
+    await session.stop_session()
+    await inspector.close()
 
 
 @webinspector.command(cls=Command)
@@ -207,16 +227,7 @@ def launch(service_provider: LockdownClient, url, timeout):
         Settings -> Safari -> Advanced -> Remote Automation
 
     """
-    inspector, safari = create_webinspector_and_launch_app(service_provider, timeout, SAFARI)
-    session = inspector.automation_session(safari)
-    driver = WebDriver(session)
-    print("Starting session")
-    driver.start_session()
-    print("Getting URL")
-    driver.get(url)
-    OSUTILS.wait_return()
-    session.stop_session()
-    inspector.close()
+    asyncio.run(launch_task(service_provider, url, timeout), debug=True)
 
 
 SHELL_USAGE = """
@@ -240,9 +251,28 @@ driver.add_cookie(
 """
 
 
+@catch_errors
+async def shell_task(service_provider: LockdownClient, timeout):
+    inspector, safari = await create_webinspector_and_launch_app(service_provider, timeout, SAFARI)
+    session = await inspector.automation_session(safari)
+    driver = WebDriver(session)
+    try:
+        nest_asyncio.apply()
+        IPython.embed(
+            header=highlight(SHELL_USAGE, lexers.PythonLexer(), formatters.Terminal256Formatter(style="native")),
+            user_ns={
+                "driver": driver,
+                "Cookie": Cookie,
+                "By": By,
+            },
+        )
+    finally:
+        await session.stop_session()
+        await inspector.close()
+
+
 @webinspector.command(cls=Command)
 @click.option("-t", "--timeout", default=3, show_default=True, type=float)
-@catch_errors
 def shell(service_provider: LockdownClient, timeout):
     """
     Create an IPython shell for interacting with a WebView.
@@ -256,21 +286,7 @@ def shell(service_provider: LockdownClient, timeout):
         Settings -> Safari -> Advanced -> Web Inspector
         Settings -> Safari -> Advanced -> Remote Automation
     """
-    inspector, safari = create_webinspector_and_launch_app(service_provider, timeout, SAFARI)
-    session = inspector.automation_session(safari)
-    driver = WebDriver(session)
-    try:
-        IPython.embed(
-            header=highlight(SHELL_USAGE, lexers.PythonLexer(), formatters.Terminal256Formatter(style="native")),
-            user_ns={
-                "driver": driver,
-                "Cookie": Cookie,
-                "By": By,
-            },
-        )
-    finally:
-        session.stop_session()
-        inspector.close()
+    asyncio.run(shell_task(service_provider, timeout), debug=True)
 
 
 @webinspector.command(cls=Command)
@@ -333,42 +349,56 @@ def cdp(service_provider: LockdownClient, host, port):
     )
 
 
-def get_js_completions(jsshell: "JsShell", obj: str, prefix: str) -> list[Completion]:
+async def get_js_completions(jsshell: "JsShell", obj: str, prefix: str) -> AsyncIterator[Completion]:
     if obj in JS_RESERVED_WORDS:
-        return []
+        return
 
-    completions = []
     try:
-        for key in asyncio.get_running_loop().run_until_complete(
-            jsshell.evaluate_expression(SCRIPT.format(object=obj), return_by_value=True)
-        ):
+        for key in await jsshell.evaluate_expression(SCRIPT.format(object=obj), return_by_value=True):
             if not key.startswith(prefix):
                 continue
-            completions.append(Completion(key.removeprefix(prefix), display=key))
-    except Exception:
+            yield Completion(key.removeprefix(prefix), display=key)
+    except (Exception, CancelledError):
         # ignore every possible exception
         pass
-    return completions
 
 
 class JsShellCompleter(Completer):
     def __init__(self, jsshell: "JsShell"):
         self.jsshell = jsshell
 
-    def get_completions(self, document: Document, complete_event: CompleteEvent) -> Iterable[Completion]:
+    def get_completions_async(
+        self,
+        document: Document,
+        complete_event: CompleteEvent,
+    ) -> Union[AsyncIterator[Completion], Iterable[Completion]]:
+        # Build the JS expression we want to inspect
         text = f"globalThis.{document.text_before_cursor}"
-        text = re.findall("[a-zA-Z_][a-zA-Z_0-9.]+", text)
-        if len(text) == 0:
-            return []
-        text = text[-1]
+
+        # Extract identifiers / dotted paths
+        matches = re.findall(r"[a-zA-Z_][a-zA-Z_0-9.]+", text)
+        if not matches:
+            # async *generator*: just end, don't return a list
+            return iter(())
+
+        text = matches[-1]
         if "." in text:
             js_obj, prefix = text.rsplit(".", 1)
         else:
             js_obj = text
             prefix = ""
 
+        # This should return an iterable of Completion (or something we can wrap)
         return get_js_completions(self.jsshell, js_obj, prefix)
 
+    # Optional: keep sync completions empty so PTK knows we prefer async
+    def get_completions(
+        self,
+        document: Document,
+        complete_event: CompleteEvent,
+    ) -> Iterable[Completion]:
+        return []
+
 
 class JsShell(ABC):
     def __init__(self) -> None:
@@ -436,7 +466,7 @@ class AutomationJsShell(JsShell):
         inspector, application = create_webinspector_and_launch_app(lockdown, timeout, SAFARI)
         automation_session = inspector.automation_session(application)
         driver = WebDriver(automation_session)
-        driver.start_session()
+        await driver.start_session()
         try:
             yield cls(driver)
         finally:
@@ -444,10 +474,10 @@ class AutomationJsShell(JsShell):
             inspector.close()
 
     async def evaluate_expression(self, exp: str, return_by_value: bool = False):
-        return self.driver.execute_script(f"return {exp}")
+        return await self.driver.execute_script(f"return {exp}")
 
     async def navigate(self, url: str):
-        self.driver.get(url)
+        await self.driver.get(url)
 
 
 class InspectorJsShell(JsShell):
@@ -459,10 +489,10 @@ class InspectorJsShell(JsShell):
     @asynccontextmanager
     async def create(cls, lockdown: LockdownClient, timeout: float, open_safari: bool) -> "InspectorJsShell":
         inspector = WebinspectorService(lockdown=lockdown)
-        inspector.connect(timeout)
+        await inspector.connect(timeout)
         if open_safari:
-            _ = inspector.open_app(SAFARI)
-        application_page = cls.query_page(inspector, bundle_identifier=SAFARI if open_safari else None)
+            _ = await inspector.open_app(SAFARI)
+        application_page = await cls.query_page(inspector, bundle_identifier=SAFARI if open_safari else None)
         if application_page is None:
             raise click.exceptions.Exit()
 
@@ -473,7 +503,7 @@ class InspectorJsShell(JsShell):
         try:
             yield cls(inspector_session)
         finally:
-            inspector.close()
+            await inspector.close()
 
     async def evaluate_expression(self, exp: str, return_by_value: bool = False):
         return await self.inspector_session.runtime_evaluate(exp, return_by_value=return_by_value)
@@ -482,10 +512,10 @@ class InspectorJsShell(JsShell):
         await self.inspector_session.navigate_to_url(url)
 
     @staticmethod
-    def query_page(
+    async def query_page(
         inspector: WebinspectorService, bundle_identifier: Optional[str] = None
     ) -> Optional[ApplicationPage]:
-        available_pages = inspector.get_open_application_pages(timeout=1)
+        available_pages = await inspector.get_open_application_pages(timeout=1)
         if bundle_identifier is not None:
             available_pages = [
                 application_page

pymobiledevice3/services/web_protocol/alert.py

@@ -5,22 +5,22 @@ class Alert:
         """
         self.session = session
 
-    def accept(self):
+    async def accept(self):
         """Accepts the alert available."""
-        self.session.accept_current_javascript_dialog()
+        await self.session.accept_current_javascript_dialog()
 
-    def dismiss(self):
+    async def dismiss(self):
         """Dismisses the alert available."""
-        self.session.dismiss_current_javascript_dialog()
+        await self.session.dismiss_current_javascript_dialog()
 
-    def send_keys(self, text: str):
+    async def send_keys(self, text: str):
         """
         Send Keys to the Alert.
         :param text: Text to send to prompts.
         """
-        self.session.set_user_input_for_current_javascript_prompt(text)
+        await self.session.set_user_input_for_current_javascript_prompt(text)
 
     @property
-    def text(self) -> str:
+    async def text(self) -> str:
         """Gets the text of the Alert."""
-        return self.session.message_of_current_javascript_dialog()
+        return await self.session.message_of_current_javascript_dialog()

pymobiledevice3/services/web_protocol/automation_session.py

@@ -167,62 +167,62 @@ class AutomationSession:
     def id_(self):
         return self.protocol.id_
 
-    def start_session(self):
-        handle = self.protocol.createBrowsingContext()["handle"]
-        self.switch_to_top_level_browsing_context(handle)
+    async def start_session(self):
+        handle = (await self.protocol.createBrowsingContext())["handle"]
+        await self.switch_to_top_level_browsing_context(handle)
 
-    def stop_session(self):
+    async def stop_session(self):
         self.top_level_handle = ""
         self.current_handle = ""
         self.current_parent_handle = ""
-        for handle in self.get_window_handles():
-            self.protocol.closeBrowsingContext(handle=handle)
+        for handle in await self.get_window_handles():
+            await self.protocol.closeBrowsingContext(handle=handle)
 
-    def create_window(self, type_):
+    async def create_window(self, type_):
         type_ = type_.capitalize()
         params = {"presentationHint": type_} if type_ else {}
-        return self.protocol.createBrowsingContext(**params)["handle"]
+        return (await self.protocol.createBrowsingContext(**params))["handle"]
 
-    def close_window(self):
+    async def close_window(self):
         if not self.top_level_handle:
             return
         handle = self.top_level_handle
-        self.protocol.closeBrowsingContext(handle=handle)
+        await self.protocol.closeBrowsingContext(handle=handle)
 
-    def maximize_window(self):
-        self.protocol.maximizeWindowOfBrowsingContext(handle=self.top_level_handle)
+    async def maximize_window(self):
+        await self.protocol.maximizeWindowOfBrowsingContext(handle=self.top_level_handle)
 
-    def hide_window(self):
-        self.protocol.hideWindowOfBrowsingContext(handle=self.top_level_handle)
+    async def hide_window(self):
+        await self.protocol.hideWindowOfBrowsingContext(handle=self.top_level_handle)
 
-    def get_browsing_context(self):
-        return self.protocol.getBrowsingContext(handle=self.top_level_handle)["context"]
+    async def get_browsing_context(self):
+        return (await self.protocol.getBrowsingContext(handle=self.top_level_handle))["context"]
 
-    def get_window_handles(self):
-        contexts = self.protocol.getBrowsingContexts()
+    async def get_window_handles(self):
+        contexts = await self.protocol.getBrowsingContexts()
         return [c["handle"] for c in contexts["contexts"]]
 
-    def set_window_frame(self, x=None, y=None, width=None, height=None):
+    async def set_window_frame(self, x=None, y=None, width=None, height=None):
         params = {}
         if x is not None and y is not None:
             params["origin"] = {"x": x, "y": y}
         if width is not None and height is not None:
             params["size"] = {"width": width, "height": height}
-        self.protocol.setWindowFrameOfBrowsingContext(handle=self.top_level_handle, **params)
+        await self.protocol.setWindowFrameOfBrowsingContext(handle=self.top_level_handle, **params)
 
-    def add_single_cookie(self, cookie):
-        self.protocol.addSingleCookie(browsingContextHandle=self.top_level_handle, cookie=cookie)
+    async def add_single_cookie(self, cookie):
+        await self.protocol.addSingleCookie(browsingContextHandle=self.top_level_handle, cookie=cookie)
 
-    def delete_all_cookies(self):
-        self.protocol.deleteAllCookies(browsingContextHandle=self.top_level_handle)
+    async def delete_all_cookies(self):
+        await self.protocol.deleteAllCookies(browsingContextHandle=self.top_level_handle)
 
-    def delete_single_cookie(self, name):
-        self.protocol.deleteSingleCookie(browsingContextHandle=self.top_level_handle, cookieName=name)
+    async def delete_single_cookie(self, name):
+        await self.protocol.deleteSingleCookie(browsingContextHandle=self.top_level_handle, cookieName=name)
 
-    def get_all_cookies(self):
-        return self.protocol.getAllCookies(browsingContextHandle=self.top_level_handle)["cookies"]
+    async def get_all_cookies(self):
+        return (await self.protocol.getAllCookies(browsingContextHandle=self.top_level_handle))["cookies"]
 
-    def execute_script(self, script, args, async_=False):
+    async def execute_script(self, script, args, async_=False):
         parameters = {
             "browsingContextHandle": self.top_level_handle,
             "function": "function(){\n" + script + "\n}",
@@ -234,13 +234,13 @@ class AutomationSession:
             parameters["expectsImplicitCallbackArgument"] = True
         if self.script_timeout != -1:
             parameters["callbackTimeout"] = self.script_timeout
-        result = self.protocol.evaluateJavaScriptFunction(**parameters, wait_for_response=not async_)
+        result = await self.protocol.evaluateJavaScriptFunction(**parameters, wait_for_response=not async_)
         if async_:
             return result
         else:
             return json.loads(result["result"])
 
-    def evaluate_js_function(self, function, *args, implicit_callback=False, include_frame=True):
+    async def evaluate_js_function(self, function, *args, implicit_callback=False, include_frame=True):
         params = {
             "browsingContextHandle": self.top_level_handle,
             "function": function,
@@ -250,11 +250,11 @@ class AutomationSession:
             params["frameHandle"] = self.current_handle
         if implicit_callback:
             params["expectsImplicitCallbackArgument"] = True
-        result = self.protocol.evaluateJavaScriptFunction(**params)
+        result = await self.protocol.evaluateJavaScriptFunction(**params)
         return json.loads(result["result"])
 
-    def find_elements(self, by, value, single: bool = True, root=None):
-        self.wait_for_navigation_to_complete()
+    async def find_elements(self, by, value, single: bool = True, root=None):
+        await self.wait_for_navigation_to_complete()
         by = by.value if isinstance(by, By) else by
         if by == By.ID.value:
             by = By.CSS_SELECTOR.value
@@ -278,10 +278,10 @@ class AutomationSession:
             parameters["frameHandle"] = self.current_handle
         if self.implicit_wait_timeout:
             parameters["callbackTimeout"] = self.implicit_wait_timeout + 1000
-        result = json.loads(self.protocol.evaluateJavaScriptFunction(**parameters)["result"])
+        result = json.loads((await self.protocol.evaluateJavaScriptFunction(**parameters))["result"])
         return result
 
-    def screenshot_as_base64(self, scroll=False, node_id="", clip=True):
+    async def screenshot_as_base64(self, scroll=False, node_id="", clip=True):
         params = {"handle": self.top_level_handle, "clipToViewport": clip}
         if self.current_handle:
             params["frameHandle"] = self.current_handle
@@ -289,42 +289,46 @@ class AutomationSession:
             params["scrollIntoViewIfNeeded"] = True
         if node_id:
             params["nodeHandle"] = node_id
-        return self.protocol.takeScreenshot(**params)["data"]
+        return (await self.protocol.takeScreenshot(**params))["data"]
 
-    def switch_to_top_level_browsing_context(self, top_level_handle):
+    async def switch_to_top_level_browsing_context(self, top_level_handle):
         self.top_level_handle = top_level_handle
         self.current_handle = ""
         self.current_parent_handle = ""
 
-    def switch_to_browsing_context(self, handle):
+    async def switch_to_browsing_context(self, handle):
         self.current_handle = handle
         if not self.current_handle:
             self.current_parent_handle = ""
             return
 
-        resp = self.protocol.resolveParentFrameHandle(
+        resp = await self.protocol.resolveParentFrameHandle(
             browsingContextHandle=self.top_level_handle, frameHandle=self.current_handle
         )
         self.current_parent_handle = resp["result"]
 
-    def switch_to_browsing_context_frame(self, context, frame):
-        self.protocol.switchToBrowsingContext(browsingContextHandle=context, frameHandle=frame)
+    async def switch_to_browsing_context_frame(self, context, frame):
+        await self.protocol.switchToBrowsingContext(browsingContextHandle=context, frameHandle=frame)
 
-    def navigate_broswing_context(self, url):
-        self.protocol.navigateBrowsingContext(
+    async def navigate_broswing_context(self, url):
+        await self.protocol.navigateBrowsingContext(
             handle=self.top_level_handle, pageLoadTimeout=self.page_load_timeout, url=url
         )
 
-    def go_back_in_browsing_context(self):
-        self.protocol.goBackInBrowsingContext(handle=self.top_level_handle, pageLoadTimeout=self.page_load_timeout)
+    async def go_back_in_browsing_context(self):
+        await self.protocol.goBackInBrowsingContext(
+            handle=self.top_level_handle, pageLoadTimeout=self.page_load_timeout
+        )
 
-    def go_forward_in_browsing_context(self):
-        self.protocol.goForwardInBrowsingContext(handle=self.top_level_handle, pageLoadTimeout=self.page_load_timeout)
+    async def go_forward_in_browsing_context(self):
+        await self.protocol.goForwardInBrowsingContext(
+            handle=self.top_level_handle, pageLoadTimeout=self.page_load_timeout
+        )
 
-    def reload_browsing_context(self):
-        self.protocol.reloadBrowsingContext(handle=self.top_level_handle, pageLoadTimeout=self.page_load_timeout)
+    async def reload_browsing_context(self):
+        await self.protocol.reloadBrowsingContext(handle=self.top_level_handle, pageLoadTimeout=self.page_load_timeout)
 
-    def switch_to_frame(self, frame_ordinal=None, frame_handle=None):
+    async def switch_to_frame(self, frame_ordinal=None, frame_handle=None):
         params = {"browsingContextHandle": self.top_level_handle}
         if self.current_handle:
             params["frameHandle"] = self.current_handle
@@ -332,23 +336,23 @@ class AutomationSession:
             params["ordinal"] = frame_ordinal
         elif frame_handle is not None:
             params["nodeHandle"] = frame_handle.node_id
-        resp = self.protocol.resolveChildFrameHandle(**params)["result"]
-        self.switch_to_browsing_context_frame(self.top_level_handle, resp)
-        self.switch_to_browsing_context(resp)
+        resp = (await self.protocol.resolveChildFrameHandle(**params))["result"]
+        await self.switch_to_browsing_context_frame(self.top_level_handle, resp)
+        await self.switch_to_browsing_context(resp)
 
-    def switch_to_window(self, handle):
-        self.switch_to_browsing_context_frame(handle, "")
-        self.switch_to_top_level_browsing_context(handle)
+    async def switch_to_window(self, handle):
+        await self.switch_to_browsing_context_frame(handle, "")
+        await self.switch_to_top_level_browsing_context(handle)
 
-    def perform_keyboard_interactions(self, interactions):
+    async def perform_keyboard_interactions(self, interactions):
         for interaction in interactions:
             type_ = interaction["type"]
             interaction["type"] = type_.value if isinstance(type_, KeyboardInteractionType) else type_
-        self.protocol.performKeyboardInteractions(handle=self.top_level_handle, interactions=interactions)
+        await self.protocol.performKeyboardInteractions(handle=self.top_level_handle, interactions=interactions)
 
-    def perform_mouse_interaction(self, x, y, button: MouseButton, interaction: MouseInteraction, modifiers=None):
+    async def perform_mouse_interaction(self, x, y, button: MouseButton, interaction: MouseInteraction, modifiers=None):
         modifiers = [] if modifiers is None else modifiers
-        self.protocol.performMouseInteraction(
+        await self.protocol.performMouseInteraction(
             handle=self.top_level_handle,
             position={"x": x, "y": y},
             button=button.value,
@@ -356,7 +360,7 @@ class AutomationSession:
             modifiers=modifiers,
         )
 
-    def perform_interaction_sequence(self, sources, steps):
+    async def perform_interaction_sequence(self, sources, steps):
         params = {
             "handle": self.top_level_handle,
             "inputSources": sources,
@@ -364,30 +368,32 @@ class AutomationSession:
         }
         if self.current_handle:
             params["frameHandle"] = self.current_handle
-        self.protocol.performInteractionSequence(**params)
+        await self.protocol.performInteractionSequence(**params)
 
-    def wait_for_navigation_to_complete(self):
+    async def wait_for_navigation_to_complete(self):
         params = {"browsingContextHandle": self.top_level_handle, "pageLoadTimeout": self.page_load_timeout}
         if self.current_handle:
             params["frameHandle"] = self.current_handle
-        self.protocol.waitForNavigationToComplete(**params)
+        await self.protocol.waitForNavigationToComplete(**params)
 
-    def accept_current_javascript_dialog(self):
-        self.protocol.acceptCurrentJavaScriptDialog(browsingContextHandle=self.top_level_handle)
+    async def accept_current_javascript_dialog(self):
+        await self.protocol.acceptCurrentJavaScriptDialog(browsingContextHandle=self.top_level_handle)
 
-    def dismiss_current_javascript_dialog(self):
-        self.protocol.dismissCurrentJavaScriptDialog(browsingContextHandle=self.top_level_handle)
+    async def dismiss_current_javascript_dialog(self):
+        await self.protocol.dismissCurrentJavaScriptDialog(browsingContextHandle=self.top_level_handle)
 
-    def set_user_input_for_current_javascript_prompt(self, user_input):
-        self.protocol.setUserInputForCurrentJavaScriptPrompt(
+    async def set_user_input_for_current_javascript_prompt(self, user_input):
+        await self.protocol.setUserInputForCurrentJavaScriptPrompt(
             browsingContextHandle=self.top_level_handle, userInput=user_input
         )
 
-    def message_of_current_javascript_dialog(self):
-        return self.protocol.messageOfCurrentJavaScriptDialog(browsingContextHandle=self.top_level_handle)["message"]
+    async def message_of_current_javascript_dialog(self):
+        return (await self.protocol.messageOfCurrentJavaScriptDialog(browsingContextHandle=self.top_level_handle))[
+            "message"
+        ]
 
-    def compute_element_layout(self, node_id, scroll_if_needed, coordinate_system):
-        return self.protocol.computeElementLayout(
+    async def compute_element_layout(self, node_id, scroll_if_needed, coordinate_system):
+        return await self.protocol.computeElementLayout(
             browsingContextHandle=self.top_level_handle,
             nodeHandle=node_id,
             scrollIntoViewIfNeeded=scroll_if_needed,
@@ -395,8 +401,8 @@ class AutomationSession:
             frameHandle="" if self.current_handle is None else self.current_handle,
         )
 
-    def select_option_element(self, node_id):
-        self.protocol.selectOptionElement(
+    async def select_option_element(self, node_id):
+        await self.protocol.selectOptionElement(
             browsingContextHandle=self.top_level_handle,
             nodeHandle=node_id,
             frameHandle="" if self.current_handle is None else self.current_handle,