pymobiledevice3 5.0.4__py3-none-any.whl → 7.0.6__py3-none-any.whl

pymobiledevice3/services/web_protocol/automation_session.py

@@ -1,9 +1,11 @@
+import importlib.resources
 import json
 from dataclasses import dataclass
 from enum import Enum
-from pathlib import Path
 
-RESOURCES = Path(__file__).parent.parent.parent / "resources" / "webinspector"
+import pymobiledevice3.resources
+
+RESOURCES = importlib.resources.files(pymobiledevice3.resources) / "webinspector"
 FIND_NODES = (RESOURCES / "find_nodes.js").read_text()
 
 
@@ -167,62 +169,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 +236,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 +252,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 +280,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 +291,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 +338,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 +362,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 +370,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 +403,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,

pymobiledevice3/services/web_protocol/cdp_screencast.py

@@ -3,6 +3,7 @@ import contextlib
 from base64 import b64decode, b64encode
 from datetime import datetime
 from io import BytesIO
+from typing import Optional
 
 from PIL import Image
 
@@ -28,7 +29,7 @@ class ScreenCast:
         self.device_height = 0
         self.page_scale_factor = 0
         self._run = True
-        self.recording_task = None  # type: asyncio.Task | None
+        self.recording_task: Optional[asyncio.Task] = None
 
     @property
     def scale(self) -> float:

pymobiledevice3/services/web_protocol/driver.py

@@ -1,4 +1,5 @@
 from dataclasses import asdict, dataclass
+from typing import Optional
 
 from pymobiledevice3.services.web_protocol.automation_session import RESOURCES, Point, Rect, Size
 from pymobiledevice3.services.web_protocol.element import WebElement
@@ -34,106 +35,106 @@ class WebDriver(SeleniumApi):
         self.session = session
         self.switch_to = SwitchTo(session)
 
-    def add_cookie(self, cookie: Cookie):
+    async def add_cookie(self, cookie: Cookie):
         """Adds a cookie to your current session."""
         if isinstance(cookie, Cookie):
             cookie = asdict(cookie)
-        self.session.add_single_cookie(cookie)
+        await self.session.add_single_cookie(cookie)
 
-    def back(self):
+    async def back(self):
         """Goes one step backward in the browser history."""
-        self.session.wait_for_navigation_to_complete()
-        self.session.go_back_in_browsing_context()
-        self.session.switch_to_browsing_context("")
+        await self.session.wait_for_navigation_to_complete()
+        await self.session.go_back_in_browsing_context()
+        await self.session.switch_to_browsing_context("")
 
-    def close(self):
+    async def close(self):
         """Closes the current window."""
-        self.session.close_window()
+        await self.session.close_window()
 
     @property
-    def current_url(self):
+    async def current_url(self):
         """Gets the URL of the current page."""
-        self.session.wait_for_navigation_to_complete()
-        return self.session.get_browsing_context()["url"]
+        await self.session.wait_for_navigation_to_complete()
+        return (await self.session.get_browsing_context())["url"]
 
     @property
-    def current_window_handle(self):
+    async def current_window_handle(self):
         """Returns the handle of the current window."""
-        return self.session.get_browsing_context()["handle"]
+        return (await self.session.get_browsing_context())["handle"]
 
-    def delete_all_cookies(self):
+    async def delete_all_cookies(self):
         """Delete all cookies in the scope of the session."""
-        self.session.delete_all_cookies()
+        await self.session.delete_all_cookies()
 
-    def delete_cookie(self, name: str):
+    async def delete_cookie(self, name: str):
         """Deletes a single cookie with the given name."""
-        self.session.delete_single_cookie(name)
+        await self.session.delete_single_cookie(name)
 
-    def execute_async_script(self, script: str, *args):
+    async def execute_async_script(self, script: str, *args):
         """
         Asynchronously Executes JavaScript in the current window/frame.
         :param script: The JavaScript to execute.
         :param args: Any applicable arguments for your JavaScript.
         """
-        return self.session.execute_script(script, args, async_=True)
+        return await self.session.execute_script(script, args, async_=True)
 
-    def execute_script(self, script: str, *args):
+    async def execute_script(self, script: str, *args):
         """
         Synchronously Executes JavaScript in the current window/frame.
         :param script: The JavaScript to execute.
         :param args: Any applicable arguments for your JavaScript.
         """
-        return self.session.execute_script(script, args)
+        return await self.session.execute_script(script, args)
 
-    def find_element(self, by=By.ID, value=None) -> WebElement:
+    async def find_element(self, by=By.ID, value=None) -> Optional[WebElement]:
         """Find an element given a By strategy and locator."""
-        elem = self.session.find_elements(by, value)
+        elem = await self.session.find_elements(by, value)
         return None if elem is None else WebElement(self.session, elem)
 
-    def find_elements(self, by=By.ID, value=None) -> list[WebElement]:
+    async def find_elements(self, by=By.ID, value=None) -> list[WebElement]:
         """Find elements given a By strategy and locator."""
-        elements = self.session.find_elements(by, value, single=False)
+        elements = await self.session.find_elements(by, value, single=False)
         return [WebElement(self.session, elem) for elem in elements]
 
-    def forward(self):
+    async def forward(self):
         """Goes one step forward in the browser history."""
-        self.session.wait_for_navigation_to_complete()
-        self.session.go_forward_in_browsing_context()
-        self.session.switch_to_browsing_context("")
+        await self.session.wait_for_navigation_to_complete()
+        await self.session.go_forward_in_browsing_context()
+        await self.session.switch_to_browsing_context("")
 
-    def fullscreen_window(self):
+    async def fullscreen_window(self):
         """Invokes the window manager-specific 'full screen' operation."""
-        self.session.evaluate_js_function(ENTER_FULLSCREEN, implicit_callback=True)
+        await self.session.evaluate_js_function(ENTER_FULLSCREEN, implicit_callback=True)
 
-    def get(self, url: str):
+    async def get(self, url: str):
         """Loads a web page in the current browser session."""
-        self.session.wait_for_navigation_to_complete()
-        self.session.navigate_broswing_context(url)
-        self.session.switch_to_browsing_context("")
+        await self.session.wait_for_navigation_to_complete()
+        await self.session.navigate_broswing_context(url)
+        await self.session.switch_to_browsing_context("")
 
-    def get_cookie(self, name: str) -> Cookie:
+    async def get_cookie(self, name: str) -> Cookie:
         """Get a single cookie by name. Returns the cookie if found, None if not."""
-        for cookie in self.get_cookies():
+        for cookie in await self.get_cookies():
             if cookie.name == name:
                 return cookie
 
-    def get_cookies(self) -> list[Cookie]:
+    async def get_cookies(self) -> list[Cookie]:
         """Returns cookies visible in the current session."""
-        return list(map(Cookie.from_automation, self.session.get_all_cookies()))
+        return list(map(Cookie.from_automation, await self.session.get_all_cookies()))
 
     @property
-    def screenshot_as_base64(self) -> str:
+    async def screenshot_as_base64(self) -> str:
         """Gets the screenshot of the current window as a base64 encoded string."""
-        return self.session.screenshot_as_base64()
+        return await self.session.screenshot_as_base64()
 
-    def get_window_position(self) -> Point:
+    async def get_window_position(self) -> Point:
         """Gets the x,y position of the current window."""
-        rect = self.get_window_rect()
+        rect = await self.get_window_rect()
         return Point(x=rect.x, y=rect.y)
 
-    def get_window_rect(self) -> Rect:
+    async def get_window_rect(self) -> Rect:
         """Gets the x, y coordinates of the window as well as height and width of the current window."""
-        context = self.session.get_browsing_context()
+        context = await self.session.get_browsing_context()
         return Rect(
             context["windowOrigin"]["x"],
             context["windowOrigin"]["y"],
@@ -141,57 +142,57 @@ class WebDriver(SeleniumApi):
             context["windowSize"]["height"],
         )
 
-    def get_window_size(self) -> Size:
+    async def get_window_size(self) -> Size:
         """Gets the width and height of the current window."""
-        rect = self.get_window_rect()
+        rect = await self.get_window_rect()
         return Size(height=rect.height, width=rect.width)
 
     def implicitly_wait(self, time_to_wait):
         """Sets a sticky timeout to implicitly wait for an element to be found, or a command to complete."""
         self.session.implicit_wait_timeout = time_to_wait * 1000
 
-    def maximize_window(self):
+    async def maximize_window(self):
         """Maximizes the current window."""
-        self.session.maximize_window()
+        await self.session.maximize_window()
 
-    def minimize_window(self):
+    async def minimize_window(self):
         """Invokes the window manager-specific 'minimize' operation."""
-        self.session.hide_window()
+        await self.session.hide_window()
 
     @property
-    def page_source(self) -> str:
+    async def page_source(self) -> str:
         """Gets the source of the current page."""
-        return self.session.evaluate_js_function("function() { return document.documentElement.outerHTML; }")
+        return await self.session.evaluate_js_function("function() { return document.documentElement.outerHTML; }")
 
-    def refresh(self):
+    async def refresh(self):
         """Refreshes the current page."""
-        self.session.wait_for_navigation_to_complete()
-        self.session.reload_browsing_context()
-        self.session.switch_to_browsing_context("")
+        await self.session.wait_for_navigation_to_complete()
+        await self.session.reload_browsing_context()
+        await self.session.switch_to_browsing_context("")
 
-    def set_window_position(self, x, y):
+    async def set_window_position(self, x, y):
         """Sets the x,y position of the current window."""
-        self.set_window_rect(x=int(x, 0), y=int(y, 0))
+        await self.set_window_rect(x=int(x, 0), y=int(y, 0))
 
-    def set_window_rect(self, x=None, y=None, width=None, height=None):
+    async def set_window_rect(self, x=None, y=None, width=None, height=None):
         """Sets the x, y coordinates of the window as well as height and width of the current window."""
-        self.session.set_window_frame(x, y, width, height)
+        await self.session.set_window_frame(x, y, width, height)
 
-    def set_window_size(self, width, height):
+    async def set_window_size(self, width, height):
         """Sets the width and height of the current window."""
-        self.set_window_rect(width=int(width, 0), height=int(height, 0))
+        await self.set_window_rect(width=int(width, 0), height=int(height, 0))
 
-    def start_session(self):
+    async def start_session(self):
         """Creates a new session."""
-        self.session.start_session()
+        await self.session.start_session()
 
     @property
-    def title(self) -> str:
+    async def title(self) -> str:
         """Returns the title of the current page."""
-        self.session.wait_for_navigation_to_complete()
-        return self.session.evaluate_js_function("function() { return document.title; }")
+        await self.session.wait_for_navigation_to_complete()
+        return await self.session.evaluate_js_function("function() { return document.title; }")
 
     @property
-    def window_handles(self) -> list[str]:
+    async def window_handles(self) -> list[str]:
         """Returns the handles of all windows within the current session."""
-        return self.session.get_window_handles()
+        return await self.session.get_window_handles()