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

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:
         """Gets the x,y position of the current window."""
         rect = 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()

pymobiledevice3/services/web_protocol/element.py

@@ -31,89 +31,91 @@ class WebElement(SeleniumApi):
         self.id_ = id_
         self.node_id = id_[f"session-node-{self.session.id_}"]
 
-    def clear(self):
+    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):
+    async def click(self):
         """Clicks the element."""
-        rect, center, is_obscured = self._compute_layout(use_viewport=True)
+        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()
+            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):
+    async 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_)
         return None if elem is None else WebElement(self.session, elem)
 
-    def find_elements(self, by=By.ID, value=None):
+    async 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_)
+        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:
+    async 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)
+        return await self.session.execute_script(f"return ({GET_ATTRIBUTE}).apply(null, arguments);", self.id_, name)
 
-    def get_dom_attribute(self, name: str) -> str:
+    async def get_dom_attribute(self, name: str) -> str:
         """Gets the given attribute of the element."""
-        return self._evaluate_js_function(ELEMENT_ATTRIBUTE, name)
+        return await self._evaluate_js_function(ELEMENT_ATTRIBUTE, name)
 
-    def get_property(self, name: str) -> str:
+    async 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}; }}")
+        return await self._evaluate_js_function(f"function(element) {{ return element.{name}; }}")
 
-    def is_displayed(self) -> bool:
+    async 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_)
+        return await self.session.execute_script(f"return ({IS_DISPLAYED}).apply(null, arguments);", self.id_)
 
-    def is_enabled(self) -> bool:
+    async def is_enabled(self) -> bool:
         """Returns whether the element is enabled."""
-        return self._evaluate_js_function(IS_ENABLED)
+        return await self._evaluate_js_function(IS_ENABLED)
 
-    def is_selected(self) -> bool:
+    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(self.get_dom_attribute("selected"))
+        return bool(await self.get_dom_attribute("selected"))
 
     @property
-    def location(self) -> Point:
+    async def location(self) -> Point:
         """The location of the element in the renderable canvas."""
-        rect = self.rect
+        rect = await self.rect
         return Point(x=rect.x, y=rect.y)
 
     @property
-    def location_once_scrolled_into_view(self) -> Point:
+    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 = self.session.execute_script(
+        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"]))
 
     @property
-    def rect(self) -> Rect:
+    async def rect(self) -> Rect:
         """The size and location of the element."""
-        return self._compute_layout(scroll_if_needed=False)[0]
+        return await self._compute_layout(scroll_if_needed=False)[0]
 
     @property
-    def screenshot_as_base64(self) -> str:
+    async 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)
+        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:
@@ -132,15 +134,15 @@ class WebElement(SeleniumApi):
                 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)
+        await self.session.perform_keyboard_interactions(interactions)
 
     @property
-    def size(self) -> Size:
+    async def size(self) -> Size:
         """The size of the element."""
-        rect = self.rect
+        rect = await self.rect
         return Size(height=rect.height, width=rect.width)
 
-    def submit(self):
+    async def submit(self):
         """Submits a form."""
         form = self.find_element(By.XPATH, "./ancestor-or-self::form")
         submit_code = (
@@ -148,31 +150,31 @@ class WebElement(SeleniumApi):
             "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:
+    async def tag_name(self) -> str:
         """This element's ``tagName`` property."""
-        return self._evaluate_js_function("function(element) { return element.tagName.toLowerCase() }")
+        return await self._evaluate_js_function("function(element) { return element.tagName.toLowerCase() }")
 
     @property
-    def text(self) -> str:
+    async def text(self) -> str:
         """The text of the element."""
-        return self._evaluate_js_function(
+        return await self._evaluate_js_function(
             'function(element) { return element.innerText.replace(/^[^\\S\\xa0]+|[^\\S\\xa0]+$/g, "") }'
         )
 
-    def touch(self):
+    async def touch(self):
         """Simulate touch interaction on the element."""
-        _rect, center, _is_obscured = self._compute_layout(use_viewport=True)
-        self.session.perform_interaction_sequence(
+        _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:
+    async def value_of_css_property(self, property_name) -> str:
         """The value of a CSS property."""
-        return self._evaluate_js_function(
+        return await self._evaluate_js_function(
             "function(element) {"
             f' return document.defaultView.getComputedStyle(element).getPropertyValue("{property_name}"); '
             "}"
@@ -182,9 +184,9 @@ class WebElement(SeleniumApi):
         """Returns whether the element is editable."""
         return 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(
+            result = await self.session.compute_element_layout(
                 self.node_id, scroll_if_needed, "LayoutViewport" if use_viewport else "Page"
             )
         except WirError:
@@ -196,11 +198,11 @@ class WebElement(SeleniumApi):
         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_

pymobiledevice3/services/web_protocol/session_protocol.py

@@ -37,6 +37,7 @@ class SessionProtocol:
             return response["result"]
         elif "error" in response:
             raise WirError(response["error"]["message"])
+        raise WirError(f"Unknown response: {response}")
 
     async def send_receive(self, method, wait_for_response=True, **kwargs):
         wir_id = await self.send_command(method, **kwargs)
@@ -50,8 +51,8 @@ class SessionProtocol:
             await asyncio.sleep(0)
         return self.inspector.wir_message_results.pop(id_)
 
-    def sync_send_receive(self, method, wait_for_response=True, **kwargs):
-        return self.inspector.await_(self.send_receive(method, wait_for_response, **kwargs))
+    async def sync_send_receive(self, method, wait_for_response=True, **kwargs):
+        return await self.send_receive(method, wait_for_response, **kwargs)
 
     def __getattr__(self, item):
         return partial(self.sync_send_receive, method=item)