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

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_)
+        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):
+    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,59 +134,59 @@ 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")
+        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() }"
         )
-        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) -> None:
         """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}"); '
             "}"
         )
 
-    def is_editable(self) -> bool:
+    async def is_editable(self) -> bool:
         """Returns whether the element is editable."""
-        return self._evaluate_js_function(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(
+            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/selenium_api.py

@@ -6,68 +6,68 @@ from pymobiledevice3.services.web_protocol.automation_session import By
 
 class SeleniumApi(ABC):
     @abstractmethod
-    def find_element(self, by=By.ID, value=None):
+    async def find_element(self, by=By.ID, value=None):
         pass
 
     @abstractmethod
-    def find_elements(self, by=By.ID, value=None):
+    async def find_elements(self, by=By.ID, value=None):
         pass
 
     @property
     @abstractmethod
-    def screenshot_as_base64(self):
+    async def screenshot_as_base64(self) -> str:
         pass
 
-    def find_element_by_class_name(self, name):
-        return self.find_element(By.CLASS_NAME, name)
+    async def find_element_by_class_name(self, name):
+        return await self.find_element(By.CLASS_NAME, name)
 
-    def find_element_by_css_selector(self, css_selector):
-        return self.find_element(By.CSS_SELECTOR, css_selector)
+    async def find_element_by_css_selector(self, css_selector):
+        return await self.find_element(By.CSS_SELECTOR, css_selector)
 
-    def find_element_by_id(self, id_):
-        return self.find_element(value=id_)
+    async def find_element_by_id(self, id_):
+        return await self.find_element(value=id_)
 
-    def find_element_by_link_text(self, link_text):
-        return self.find_element(By.LINK_TEXT, link_text)
+    async def find_element_by_link_text(self, link_text):
+        return await self.find_element(By.LINK_TEXT, link_text)
 
-    def find_element_by_name(self, name):
-        return self.find_element(By.NAME, name)
+    async def find_element_by_name(self, name):
+        return await self.find_element(By.NAME, name)
 
-    def find_element_by_partial_link_text(self, link_text):
-        return self.find_element(By.PARTIAL_LINK_TEXT, link_text)
+    async def find_element_by_partial_link_text(self, link_text):
+        return await self.find_element(By.PARTIAL_LINK_TEXT, link_text)
 
-    def find_element_by_tag_name(self, name):
-        return self.find_element(By.TAG_NAME, name)
+    async def find_element_by_tag_name(self, name):
+        return await self.find_element(By.TAG_NAME, name)
 
-    def find_element_by_xpath(self, xpath):
-        return self.find_element(By.XPATH, xpath)
+    async def find_element_by_xpath(self, xpath):
+        return await self.find_element(By.XPATH, xpath)
 
-    def find_elements_by_class_name(self, name):
-        return self.find_elements(By.CLASS_NAME, name)
+    async def find_elements_by_class_name(self, name):
+        return await self.find_elements(By.CLASS_NAME, name)
 
-    def find_elements_by_css_selector(self, css_selector):
-        return self.find_elements(By.CSS_SELECTOR, css_selector)
+    async def find_elements_by_css_selector(self, css_selector):
+        return await self.find_elements(By.CSS_SELECTOR, css_selector)
 
-    def find_elements_by_id(self, id_):
-        return self.find_elements(value=id_)
+    async def find_elements_by_id(self, id_):
+        return await self.find_elements(value=id_)
 
-    def find_elements_by_link_text(self, link_text):
-        return self.find_elements(By.LINK_TEXT, link_text)
+    async def find_elements_by_link_text(self, link_text):
+        return await self.find_elements(By.LINK_TEXT, link_text)
 
-    def find_elements_by_name(self, name):
-        return self.find_elements(By.NAME, name)
+    async def find_elements_by_name(self, name):
+        return await self.find_elements(By.NAME, name)
 
-    def find_elements_by_partial_link_text(self, link_text):
-        return self.find_elements(By.PARTIAL_LINK_TEXT, link_text)
+    async def find_elements_by_partial_link_text(self, link_text):
+        return await self.find_elements(By.PARTIAL_LINK_TEXT, link_text)
 
-    def find_elements_by_tag_name(self, name):
-        return self.find_elements(By.TAG_NAME, name)
+    async def find_elements_by_tag_name(self, name):
+        return await self.find_elements(By.TAG_NAME, name)
 
-    def find_elements_by_xpath(self, xpath):
-        return self.find_elements(By.XPATH, xpath)
+    async def find_elements_by_xpath(self, xpath):
+        return await self.find_elements(By.XPATH, xpath)
 
-    def screenshot(self, filename):
-        png = self.screenshot_as_png()
+    async def screenshot(self, filename):
+        png = await self.screenshot_as_png()
         try:
             with open(filename, "wb") as f:
                 f.write(png)
@@ -75,17 +75,17 @@ class SeleniumApi(ABC):
             return False
         return True
 
-    def screenshot_as_png(self):
-        return b64decode(self.screenshot_as_base64.encode("ascii"))
+    async def screenshot_as_png(self) -> bytes:
+        return b64decode((await self.screenshot_as_base64).encode("ascii"))
 
-    def get_screenshot_as_base64(self):
-        return self.screenshot_as_base64
+    async def get_screenshot_as_base64(self) -> str:
+        return await self.screenshot_as_base64
 
-    def get_screenshot_as_file(self, filename):
-        return self.screenshot(filename)
+    async def get_screenshot_as_file(self, filename):
+        return await self.screenshot(filename)
 
-    def get_screenshot_as_png(self):
-        return self.screenshot_as_png()
+    async def get_screenshot_as_png(self):
+        return await self.screenshot_as_png()
 
-    def save_screenshot(self, filename) -> bool:
-        return self.screenshot(filename)
+    async def save_screenshot(self, filename) -> bool:
+        return await self.screenshot(filename)

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)

pymobiledevice3/services/web_protocol/switch_to.py

@@ -11,10 +11,12 @@ class SwitchTo:
         self.session = session
 
     @property
-    def active_element(self) -> WebElement:
+    async def active_element(self) -> WebElement:
         """Returns the element with focus, or BODY if nothing has focus."""
-        self.session.wait_for_navigation_to_complete()
-        elem = self.session.evaluate_js_function("function() { return document.activeElement; }", include_frame=False)
+        await self.session.wait_for_navigation_to_complete()
+        elem = await self.session.evaluate_js_function(
+            "function() { return document.activeElement; }", include_frame=False
+        )
         return WebElement(self.session, elem)
 
     @property
@@ -22,11 +24,11 @@ class SwitchTo:
         """Switches focus to an alert on the page."""
         return Alert(self.session)
 
-    def default_content(self):
+    async def default_content(self):
         """Switch focus to the default frame."""
-        self.session.switch_to_browsing_context("")
+        await self.session.switch_to_browsing_context("")
 
-    def frame(self, frame_reference):
+    async def frame(self, frame_reference):
         """
         Switches focus to the specified frame, by index, name, or web element.
         :param frame_reference: The name of the window to switch to, an integer representing the index,
@@ -35,32 +37,34 @@ class SwitchTo:
         if isinstance(frame_reference, (int, WebElement)):
             frame = frame_reference
         elif isinstance(frame_reference, str):
-            elem = self.session.find_elements(By.ID, frame_reference)
+            elem = await self.session.find_elements(By.ID, frame_reference)
             if elem is None:
-                elem = self.session.find_elements(By.NAME, frame_reference)
+                elem = await self.session.find_elements(By.NAME, frame_reference)
             frame = WebElement(self.session, elem)
         else:
             raise TypeError()
 
-        self.session.wait_for_navigation_to_complete()
+        await self.session.wait_for_navigation_to_complete()
         if isinstance(frame, int):
-            self.session.switch_to_frame(frame_ordinal=frame)
+            await self.session.switch_to_frame(frame_ordinal=frame)
         else:
-            self.session.switch_to_frame(frame_handle=frame)
+            await self.session.switch_to_frame(frame_handle=frame)
 
-    def new_window(self, type_=""):
+    async def new_window(self, type_=""):
         """Switches to a new top-level browsing context."""
-        self.session.switch_to_window(self.session.create_window(type_))
+        await self.session.switch_to_window(self.session.create_window(type_))
 
-    def parent_frame(self):
+    async def parent_frame(self):
         """
         Switches focus to the parent context. If the current context is the top
         level browsing context, the context remains unchanged.
         """
-        self.session.wait_for_navigation_to_complete()
-        self.session.switch_to_browsing_context_frame(self.session.top_level_handle, self.session.current_parent_handle)
-        self.session.switch_to_browsing_context(self.session.current_parent_handle)
+        await self.session.wait_for_navigation_to_complete()
+        await self.session.switch_to_browsing_context_frame(
+            self.session.top_level_handle, self.session.current_parent_handle
+        )
+        await self.session.switch_to_browsing_context(self.session.current_parent_handle)
 
-    def window(self, window_name):
+    async def window(self, window_name):
         """Switches focus to the specified window."""
-        self.session.switch_to_window(window_name)
+        await self.session.switch_to_window(window_name)