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

pymobiledevice3/services/web_protocol/driver.py

@@ -1,28 +1,29 @@
 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
 from pymobiledevice3.services.web_protocol.selenium_api import By, SeleniumApi
 from pymobiledevice3.services.web_protocol.switch_to import SwitchTo
 
-ENTER_FULLSCREEN = (RESOURCES / 'enter_fullscreen.js').read_text()
+ENTER_FULLSCREEN = (RESOURCES / "enter_fullscreen.js").read_text()
 
 
 @dataclass
 class Cookie:
     name: str
     value: str
-    domain: str = ''
-    path: str = '/'
+    domain: str = ""
+    path: str = "/"
     expires: int = 0
     httpOnly: bool = False
     secure: bool = False
     session: bool = True
-    sameSite: str = 'None'
+    sameSite: str = "None"
 
     @classmethod
     def from_automation(cls, d):
-        d.pop('size')
+        d.pop("size")
         return cls(**d)
 
 
@@ -34,162 +35,164 @@ class WebDriver(SeleniumApi):
         self.session = session
         self.switch_to = SwitchTo(session)
 
-    def add_cookie(self, cookie: Cookie):
-        """ Adds a cookie to your current session. """
+    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):
-        """ 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('')
+    async def back(self):
+        """Goes one step backward in the browser history."""
+        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):
-        """ Closes the current window. """
-        self.session.close_window()
+    async def close(self):
+        """Closes the current window."""
+        await self.session.close_window()
 
     @property
-    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']
+    async def current_url(self):
+        """Gets the URL of the current page."""
+        await self.session.wait_for_navigation_to_complete()
+        return (await self.session.get_browsing_context())["url"]
 
     @property
-    def current_window_handle(self):
-        """ Returns the handle of the current window. """
-        return self.session.get_browsing_context()['handle']
+    async def current_window_handle(self):
+        """Returns the handle of the current window."""
+        return (await self.session.get_browsing_context())["handle"]
 
-    def delete_all_cookies(self):
-        """ Delete all cookies in the scope of the session. """
-        self.session.delete_all_cookies()
+    async def delete_all_cookies(self):
+        """Delete all cookies in the scope of the session."""
+        await self.session.delete_all_cookies()
 
-    def delete_cookie(self, name: str):
-        """ Deletes a single cookie with the given name. """
-        self.session.delete_single_cookie(name)
+    async def delete_cookie(self, name: str):
+        """Deletes a single cookie with the given 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:
-        """ Find an element given a By strategy and locator. """
-        elem = self.session.find_elements(by, value)
+    async def find_element(self, by=By.ID, value=None) -> Optional[WebElement]:
+        """Find an element given a By strategy and locator."""
+        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]:
-        """ Find elements given a By strategy and locator. """
-        elements = self.session.find_elements(by, value, single=False)
-        return list(map(lambda elem: WebElement(self.session, elem), elements))
-
-    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('')
-
-    def fullscreen_window(self):
-        """ Invokes the window manager-specific 'full screen' operation. """
-        self.session.evaluate_js_function(ENTER_FULLSCREEN, implicit_callback=True)
-
-    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('')
-
-    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():
+    async def find_elements(self, by=By.ID, value=None) -> list[WebElement]:
+        """Find elements given a By strategy and locator."""
+        elements = await self.session.find_elements(by, value, single=False)
+        return [WebElement(self.session, elem) for elem in elements]
+
+    async def forward(self):
+        """Goes one step forward in the browser history."""
+        await self.session.wait_for_navigation_to_complete()
+        await self.session.go_forward_in_browsing_context()
+        await self.session.switch_to_browsing_context("")
+
+    async def fullscreen_window(self):
+        """Invokes the window manager-specific 'full screen' operation."""
+        await self.session.evaluate_js_function(ENTER_FULLSCREEN, implicit_callback=True)
+
+    async def get(self, url: str):
+        """Loads a web page in the current browser session."""
+        await self.session.wait_for_navigation_to_complete()
+        await self.session.navigate_broswing_context(url)
+        await self.session.switch_to_browsing_context("")
+
+    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 await self.get_cookies():
             if cookie.name == name:
                 return cookie
 
-    def get_cookies(self) -> list[Cookie]:
-        """ Returns cookies visible in the current session. """
-        return list(map(Cookie.from_automation, self.session.get_all_cookies()))
+    async def get_cookies(self) -> list[Cookie]:
+        """Returns cookies visible in the current session."""
+        return list(map(Cookie.from_automation, await self.session.get_all_cookies()))
 
     @property
-    def screenshot_as_base64(self) -> str:
-        """ Gets the screenshot of the current window as a base64 encoded string. """
-        return self.session.screenshot_as_base64()
+    async def screenshot_as_base64(self) -> str:
+        """Gets the screenshot of the current window as a base64 encoded string."""
+        return await self.session.screenshot_as_base64()
 
-    def get_window_position(self) -> Point:
-        """ Gets the x,y position of the current window. """
-        rect = self.get_window_rect()
+    async def get_window_position(self) -> Point:
+        """Gets the x,y position of the current window."""
+        rect = await self.get_window_rect()
         return Point(x=rect.x, y=rect.y)
 
-    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()
+    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 = await self.session.get_browsing_context()
         return Rect(
-            context['windowOrigin']['x'], context['windowOrigin']['y'],
-            context['windowSize']['width'], context['windowSize']['height']
+            context["windowOrigin"]["x"],
+            context["windowOrigin"]["y"],
+            context["windowSize"]["width"],
+            context["windowSize"]["height"],
         )
 
-    def get_window_size(self) -> Size:
-        """ Gets the width and height of the current window. """
-        rect = self.get_window_rect()
+    async def get_window_size(self) -> Size:
+        """Gets the width and height of the current window."""
+        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. """
+        """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):
-        """ Maximizes the current window. """
-        self.session.maximize_window()
+    async def maximize_window(self):
+        """Maximizes the current window."""
+        await self.session.maximize_window()
 
-    def minimize_window(self):
-        """ Invokes the window manager-specific 'minimize' operation. """
-        self.session.hide_window()
+    async def minimize_window(self):
+        """Invokes the window manager-specific 'minimize' operation."""
+        await self.session.hide_window()
 
     @property
-    def page_source(self) -> str:
-        """ Gets the source of the current page. """
-        return self.session.evaluate_js_function('function() { return document.documentElement.outerHTML; }')
+    async def page_source(self) -> str:
+        """Gets the source of the current page."""
+        return await self.session.evaluate_js_function("function() { return document.documentElement.outerHTML; }")
 
-    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('')
+    async def refresh(self):
+        """Refreshes the current page."""
+        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):
-        """ Sets the x,y position of the current window. """
-        self.set_window_rect(x=int(x, 0), y=int(y, 0))
+    async def set_window_position(self, x, y):
+        """Sets the x,y position of the current window."""
+        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):
-        """ 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)
+    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."""
+        await self.session.set_window_frame(x, y, width, height)
 
-    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))
+    async def set_window_size(self, width, height):
+        """Sets the width and height of the current window."""
+        await self.set_window_rect(width=int(width, 0), height=int(height, 0))
 
-    def start_session(self):
-        """ Creates a new session. """
-        self.session.start_session()
+    async def start_session(self):
+        """Creates a new session."""
+        await self.session.start_session()
 
     @property
-    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; }')
+    async def title(self) -> str:
+        """Returns the title of the current page."""
+        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]:
-        """ Returns the handles of all windows within the current session. """
-        return self.session.get_window_handles()
+    async def window_handles(self) -> list[str]:
+        """Returns the handles of all windows within the current session."""
+        return await self.session.get_window_handles()

pymobiledevice3/services/web_protocol/element.py

@@ -1,15 +1,24 @@
 from pymobiledevice3.exceptions import WirError
-from pymobiledevice3.services.web_protocol.automation_session import MODIFIER_TO_KEY, RESOURCES, VIRTUAL_KEYS, \
-    KeyboardInteractionType, MouseButton, MouseInteraction, Point, Rect, Size
+from pymobiledevice3.services.web_protocol.automation_session import (
+    MODIFIER_TO_KEY,
+    RESOURCES,
+    VIRTUAL_KEYS,
+    KeyboardInteractionType,
+    MouseButton,
+    MouseInteraction,
+    Point,
+    Rect,
+    Size,
+)
 from pymobiledevice3.services.web_protocol.selenium_api import By, SeleniumApi
 
-IS_EDITABLE = (RESOURCES / 'is_editable.js').read_text()
-ELEMENT_CLEAR = (RESOURCES / 'element_clear.js').read_text()
-GET_ATTRIBUTE = (RESOURCES / 'get_attribute.js').read_text()
-ELEMENT_ATTRIBUTE = (RESOURCES / 'element_attribute.js').read_text()
-IS_DISPLAYED = (RESOURCES / 'is_displayed.js').read_text()
-IS_ENABLED = (RESOURCES / 'is_enabled.js').read_text()
-FOCUS = (RESOURCES / 'focus.js').read_text()
+IS_EDITABLE = (RESOURCES / "is_editable.js").read_text()
+ELEMENT_CLEAR = (RESOURCES / "element_clear.js").read_text()
+GET_ATTRIBUTE = (RESOURCES / "get_attribute.js").read_text()
+ELEMENT_ATTRIBUTE = (RESOURCES / "element_attribute.js").read_text()
+IS_DISPLAYED = (RESOURCES / "is_displayed.js").read_text()
+IS_ENABLED = (RESOURCES / "is_enabled.js").read_text()
+FOCUS = (RESOURCES / "focus.js").read_text()
 
 
 class WebElement(SeleniumApi):
@@ -20,176 +29,180 @@ class WebElement(SeleniumApi):
         """
         self.session = session
         self.id_ = id_
-        self.node_id = id_[f'session-node-{self.session.id_}']
+        self.node_id = id_[f"session-node-{self.session.id_}"]
 
-    def clear(self):
-        """ Clears the text if it's a text entry element. """
+    async def clear(self):
+        """Clears the text if it's a text entry element."""
         if not self.is_editable():
             return
-        rect, center, is_obscured = self._compute_layout()
+        rect, center, _is_obscured = await self._compute_layout()
         if rect is None or center is None:
             return
-        self._evaluate_js_function(ELEMENT_CLEAR)
+        await self._evaluate_js_function(ELEMENT_CLEAR)
 
-    def click(self):
-        """ Clicks the element. """
-        rect, center, is_obscured = self._compute_layout(use_viewport=True)
+    async def click(self):
+        """Clicks the element."""
+        rect, center, is_obscured = await self._compute_layout(use_viewport=True)
         if rect is None or is_obscured or center is None:
             return
-        if self.tag_name == 'option':
-            self._select_option_element()
+        if self.tag_name == "option":
+            await self._select_option_element()
         else:
-            self.session.perform_mouse_interaction(center.x, center.y, MouseButton.LEFT, MouseInteraction.SINGLE_CLICK)
+            await self.session.perform_mouse_interaction(
+                center.x, center.y, MouseButton.LEFT, MouseInteraction.SINGLE_CLICK
+            )
 
-    def find_element(self, by=By.ID, value=None):
-        """ Find an element given a By strategy and locator. """
-        elem = self.session.find_elements(by, value, root=self.id_)
+    async def find_element(self, by=By.ID, value=None):
+        """Find an element given a By strategy and locator."""
+        elem = await self.session.find_elements(by, value, root=self.id_)
         return None if elem is None else WebElement(self.session, elem)
 
-    def find_elements(self, by=By.ID, value=None):
-        """ Find elements given a By strategy and locator. """
-        elements = self.session.find_elements(by, value, single=False, root=self.id_)
-        return list(map(lambda elem: WebElement(self.session, elem), elements))
+    async def find_elements(self, by=By.ID, value=None):
+        """Find elements given a By strategy and locator."""
+        elements = await self.session.find_elements(by, value, single=False, root=self.id_)
+        return [WebElement(self.session, elem) for elem in elements]
 
-    def get_attribute(self, name: str) -> str:
-        """ Gets the given attribute or property of the element. """
-        return self.session.execute_script(f'return ({GET_ATTRIBUTE}).apply(null, arguments);', self.id_, name)
+    async def get_attribute(self, name: str) -> str:
+        """Gets the given attribute or property of the element."""
+        return await self.session.execute_script(f"return ({GET_ATTRIBUTE}).apply(null, arguments);", self.id_, name)
 
-    def get_dom_attribute(self, name: str) -> str:
-        """ Gets the given attribute of the element. """
-        return self._evaluate_js_function(ELEMENT_ATTRIBUTE, name)
+    async def get_dom_attribute(self, name: str) -> str:
+        """Gets the given attribute of the element."""
+        return await self._evaluate_js_function(ELEMENT_ATTRIBUTE, name)
 
-    def get_property(self, name: str) -> str:
-        """ Gets the given property of the element. """
-        return self._evaluate_js_function(f'function(element) {{ return element.{name}; }}')
+    async def get_property(self, name: str) -> str:
+        """Gets the given property of the element."""
+        return await self._evaluate_js_function(f"function(element) {{ return element.{name}; }}")
 
-    def is_displayed(self) -> bool:
-        """ Whether the element is visible to a user. """
-        return self.session.execute_script(f'return ({IS_DISPLAYED}).apply(null, arguments);', self.id_)
+    async def is_displayed(self) -> bool:
+        """Whether the element is visible to a user."""
+        return await self.session.execute_script(f"return ({IS_DISPLAYED}).apply(null, arguments);", self.id_)
 
-    def is_enabled(self) -> bool:
-        """ Returns whether the element is enabled. """
-        return self._evaluate_js_function(IS_ENABLED)
+    async def is_enabled(self) -> bool:
+        """Returns whether the element is enabled."""
+        return await self._evaluate_js_function(IS_ENABLED)
 
-    def is_selected(self) -> bool:
-        """ Returns whether the element is selected. Can be used to check if a checkbox or radio button is selected. """
-        return bool(self.get_dom_attribute('selected'))
+    async def is_selected(self) -> bool:
+        """Returns whether the element is selected. Can be used to check if a checkbox or radio button is selected."""
+        return bool(await self.get_dom_attribute("selected"))
 
     @property
-    def location(self) -> Point:
-        """ The location of the element in the renderable canvas. """
-        rect = self.rect
+    async def location(self) -> Point:
+        """The location of the element in the renderable canvas."""
+        rect = await self.rect
         return Point(x=rect.x, y=rect.y)
 
     @property
-    def location_once_scrolled_into_view(self) -> Point:
-        """ Returns the top lefthand corner location on the screen, or ``None`` if the element is not visible. """
-        rect = self.session.execute_script(
-            'arguments[0].scrollIntoView(true); return arguments[0].getBoundingClientRect(); ', self.id_
+    async def location_once_scrolled_into_view(self) -> Point:
+        """Returns the top lefthand corner location on the screen, or ``None`` if the element is not visible."""
+        rect = await self.session.execute_script(
+            "arguments[0].scrollIntoView(true); return arguments[0].getBoundingClientRect(); ", self.id_
         )
-        return Point(x=round(rect['x']), y=round(rect['y']))
+        return Point(x=round(rect["x"]), y=round(rect["y"]))
 
     @property
-    def rect(self) -> Rect:
-        """ The size and location of the element. """
-        return self._compute_layout(scroll_if_needed=False)[0]
+    async def rect(self) -> Rect:
+        """The size and location of the element."""
+        return (await self._compute_layout(scroll_if_needed=False))[0]
 
     @property
-    def screenshot_as_base64(self) -> str:
-        """ Gets the screenshot of the current element as a base64 encoded string. """
-        return self.session.screenshot_as_base64(scroll=True, node_id=self.node_id)
+    async def screenshot_as_base64(self) -> str:
+        """Gets the screenshot of the current element as a base64 encoded string."""
+        return await self.session.screenshot_as_base64(scroll=True, node_id=self.node_id)
 
-    def send_keys(self, value):
+    async def send_keys(self, value):
         """
         Simulates typing into the element.
         :param value: A string for typing, or setting form fields.
         """
-        self._evaluate_js_function(FOCUS)
+        await self._evaluate_js_function(FOCUS)
         interactions = []
         sticky_modifier = set()
         for key in value:
             if key in VIRTUAL_KEYS:
                 virtual_key, modifier = VIRTUAL_KEYS[key]
-                interaction = {'type': KeyboardInteractionType.INSERT_BY_KEY, 'key': virtual_key}
+                interaction = {"type": KeyboardInteractionType.INSERT_BY_KEY, "key": virtual_key}
                 if modifier is not None:
                     sticky_modifier ^= {modifier}
-                    interaction['type'] = (KeyboardInteractionType.KEY_PRESS if modifier in sticky_modifier
-                                           else KeyboardInteractionType.KEY_RELEASE)
+                    interaction["type"] = (
+                        KeyboardInteractionType.KEY_PRESS
+                        if modifier in sticky_modifier
+                        else KeyboardInteractionType.KEY_RELEASE
+                    )
                 interactions.append(interaction)
             else:
-                interactions.append({'type': KeyboardInteractionType.INSERT_BY_KEY, 'text': key})
+                interactions.append({"type": KeyboardInteractionType.INSERT_BY_KEY, "text": key})
         for modifier in sticky_modifier:
-            interactions.append({'type': KeyboardInteractionType.KEY_RELEASE, 'key': MODIFIER_TO_KEY[modifier]})
-        self.session.perform_keyboard_interactions(interactions)
+            interactions.append({"type": KeyboardInteractionType.KEY_RELEASE, "key": MODIFIER_TO_KEY[modifier]})
+        await self.session.perform_keyboard_interactions(interactions)
 
     @property
-    def size(self) -> Size:
-        """ The size of the element. """
-        rect = self.rect
+    async def size(self) -> Size:
+        """The size of the element."""
+        rect = await self.rect
         return Size(height=rect.height, width=rect.width)
 
-    def submit(self):
-        """ Submits a form. """
-        form = self.find_element(By.XPATH, "./ancestor-or-self::form")
+    async def submit(self):
+        """Submits a form."""
+        form = await self.find_element(By.XPATH, "./ancestor-or-self::form")
         submit_code = (
-            'var e = arguments[0].ownerDocument.createEvent(\'Event\');'
-            'e.initEvent(\'submit\', true, true);'
-            'if (arguments[0].dispatchEvent(e)) { arguments[0].submit() }'
+            "var e = arguments[0].ownerDocument.createEvent('Event');"
+            "e.initEvent('submit', true, true);"
+            "if (arguments[0].dispatchEvent(e)) { arguments[0].submit() }"
         )
-        self.session.execute_script(submit_code, form.id_)
+        await self.session.execute_script(submit_code, form.id_)
 
     @property
-    def tag_name(self) -> str:
-        """ This element's ``tagName`` property. """
-        return self._evaluate_js_function('function(element) { return element.tagName.toLowerCase() }')
+    async def tag_name(self) -> str:
+        """This element's ``tagName`` property."""
+        return await self._evaluate_js_function("function(element) { return element.tagName.toLowerCase() }")
 
     @property
-    def text(self) -> str:
-        """ The text of the element. """
-        return self._evaluate_js_function(
+    async def text(self) -> str:
+        """The text of the element."""
+        return await self._evaluate_js_function(
             'function(element) { return element.innerText.replace(/^[^\\S\\xa0]+|[^\\S\\xa0]+$/g, "") }'
         )
 
-    def touch(self):
-        """ Simulate touch interaction on the element. """
-        rect, center, is_obscured = self._compute_layout(use_viewport=True)
-        self.session.perform_interaction_sequence(
-            [{'sourceId': self.session.id_, 'sourceType': 'Touch'}],
-            [{'states': [
-                {'sourceId': self.session.id_, 'location': {'x': center.x, 'y': center.y}}
-            ]}]
+    async def touch(self) -> None:
+        """Simulate touch interaction on the element."""
+        _rect, center, _is_obscured = await self._compute_layout(use_viewport=True)
+        await self.session.perform_interaction_sequence(
+            [{"sourceId": self.session.id_, "sourceType": "Touch"}],
+            [{"states": [{"sourceId": self.session.id_, "location": {"x": center.x, "y": center.y}}]}],
         )
 
-    def value_of_css_property(self, property_name) -> str:
-        """ The value of a CSS property. """
-        return self._evaluate_js_function(
-            'function(element) {'
+    async def value_of_css_property(self, property_name) -> str:
+        """The value of a CSS property."""
+        return await self._evaluate_js_function(
+            "function(element) {"
             f' return document.defaultView.getComputedStyle(element).getPropertyValue("{property_name}"); '
-            '}'
+            "}"
         )
 
-    def is_editable(self) -> bool:
-        """ Returns whether the element is editable. """
-        return self._evaluate_js_function(IS_EDITABLE)
+    async def is_editable(self) -> bool:
+        """Returns whether the element is editable."""
+        return await self._evaluate_js_function(IS_EDITABLE)
 
-    def _compute_layout(self, scroll_if_needed=True, use_viewport=False):
+    async def _compute_layout(self, scroll_if_needed=True, use_viewport=False):
         try:
-            result = self.session.compute_element_layout(self.node_id, scroll_if_needed,
-                                                         'LayoutViewport' if use_viewport else 'Page')
+            result = await self.session.compute_element_layout(
+                self.node_id, scroll_if_needed, "LayoutViewport" if use_viewport else "Page"
+            )
         except WirError:
             return
 
-        origin = result['rect']['origin']
-        size = result['rect']['size']
-        rect = Rect(x=round(origin['x']), y=round(origin['y']), width=size['width'], height=size['height'])
-        center = Point(x=result['inViewCenterPoint']['x'], y=result['inViewCenterPoint']['y'])
-        return rect, center, result['isObscured']
+        origin = result["rect"]["origin"]
+        size = result["rect"]["size"]
+        rect = Rect(x=round(origin["x"]), y=round(origin["y"]), width=size["width"], height=size["height"])
+        center = Point(x=result["inViewCenterPoint"]["x"], y=result["inViewCenterPoint"]["y"])
+        return rect, center, result["isObscured"]
 
-    def _select_option_element(self):
-        self.session.select_option_element(self.node_id)
+    async def _select_option_element(self):
+        await self.session.select_option_element(self.node_id)
 
-    def _evaluate_js_function(self, function, *args):
-        return self.session.evaluate_js_function(function, self.id_, *args)
+    async def _evaluate_js_function(self, function, *args):
+        return await self.session.evaluate_js_function(function, self.id_, *args)
 
     def __eq__(self, other):
         return self.id_ == other.id_