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

pymobiledevice3/services/web_protocol/inspector_session.py

@@ -8,15 +8,15 @@ from pymobiledevice3.exceptions import InspectorEvaluateError
 from pymobiledevice3.services.web_protocol.session_protocol import SessionProtocol
 
 logger = logging.getLogger(__name__)
-console_logger = logging.getLogger('webinspector.console')
-heap_logger = logging.getLogger('webinspector.heap')
+console_logger = logging.getLogger("webinspector.console")
+heap_logger = logging.getLogger("webinspector.heap")
 
 webinspector_logger_handlers = {
-    'log': console_logger.info,
-    'info': console_logger.info,
-    'error': console_logger.error,
-    'debug': console_logger.debug,
-    'warning': console_logger.warning,
+    "log": console_logger.info,
+    "info": console_logger.info,
+    "error": console_logger.error,
+    "debug": console_logger.debug,
+    "warning": console_logger.warning,
 }
 
 
@@ -24,8 +24,8 @@ class JSObjectPreview(UserDict):
     def __init__(self, properties: list[dict]):
         super().__init__()
         for p in properties:
-            name = p['name']
-            value = p['value']
+            name = p["name"]
+            value = p["value"]
             self.data[name] = value
 
 
@@ -33,26 +33,25 @@ class JSObjectProperties(UserDict):
     def __init__(self, properties: list[dict]):
         super().__init__()
         for p in properties:
-            name = p['name']
-            if name == '__proto__':
-                self.class_name = p['value']['className']
+            name = p["name"]
+            if name == "__proto__":
+                self.class_name = p["value"]["className"]
                 continue
             # test if a getter/setter first
-            value = p.get('get', p.get('set', p.get('value')))
+            value = p.get("get", p.get("set", p.get("value")))
             if value is None:
                 continue
-            preview = value.get('preview')
+            preview = value.get("preview")
             if preview is not None:
-                value = JSObjectPreview(preview['properties'])
-            elif value.get('className') == 'Function':
-                value = value['description']
+                value = JSObjectPreview(preview["properties"])
+            elif value.get("className") == "Function":
+                value = value["description"]
             else:
-                value = value.get('value')
+                value = value.get("value")
             self.data[name] = value
 
 
 class InspectorSession:
-
     def __init__(self, protocol: SessionProtocol, target_id: Optional[str] = None):
         """
         :param pymobiledevice3.services.web_protocol.session_protocol.SessionProtocol protocol: Session protocol.
@@ -64,14 +63,14 @@ class InspectorSession:
         self._dispatch_message_responses = {}
 
         self.response_methods = {
-            'Target.targetCreated': self._target_created,
-            'Target.targetDestroyed': self._target_destroyed,
-            'Target.dispatchMessageFromTarget': self._target_dispatch_message_from_target,
-            'Target.didCommitProvisionalTarget': self._target_did_commit_provisional_target,
-            'Console.messageAdded': self._console_message_added,
-            'Console.messagesCleared': lambda _: _,
-            'Console.messageRepeatCountUpdated': self._console_message_repeated_count_updated,
-            'Heap.garbageCollected': self._heap_garbage_collected,
+            "Target.targetCreated": self._target_created,
+            "Target.targetDestroyed": self._target_destroyed,
+            "Target.dispatchMessageFromTarget": self._target_dispatch_message_from_target,
+            "Target.didCommitProvisionalTarget": self._target_did_commit_provisional_target,
+            "Console.messageAdded": self._console_message_added,
+            "Console.messagesCleared": lambda _: _,
+            "Console.messageRepeatCountUpdated": self._console_message_repeated_count_updated,
+            "Heap.garbageCollected": self._heap_garbage_collected,
         }
 
         self._receive_task = asyncio.create_task(self._receive_loop())
@@ -88,64 +87,65 @@ class InspectorSession:
             while not protocol.inspector.wir_events:
                 await asyncio.sleep(0)
             created = protocol.inspector.wir_events.pop(0)
-            while 'targetInfo' not in created['params']:
+            while "targetInfo" not in created["params"]:
                 created = protocol.inspector.wir_events.pop(0)
-            target_id = created['params']['targetInfo']['targetId']
-            logger.info(f'Created: {target_id}')
+            target_id = created["params"]["targetInfo"]["targetId"]
+            logger.info(f"Created: {target_id}")
         target = cls(protocol, target_id)
         return target
 
     def set_target_id(self, target_id):
         self.target_id = target_id
-        logger.info(f'Changed to: {target_id}')
+        logger.info(f"Changed to: {target_id}")
 
     async def heap_gc(self):
-        return await self.send_command('Heap.gc')
+        return await self.send_command("Heap.gc")
 
     async def heap_snapshot(self):
-        snapshot = await self.send_command('Heap.snapshot')
+        snapshot = await self.send_command("Heap.snapshot")
         if self.target_id is not None:
-            snapshot = json.loads(snapshot['params']['message'])
-        snapshot = json.loads(snapshot)['result']['snapshotData']
+            snapshot = json.loads(snapshot["params"]["message"])
+        snapshot = json.loads(snapshot)["result"]["snapshotData"]
         return snapshot
 
     async def heap_enable(self):
-        return await self.send_command('Heap.enable')
+        return await self.send_command("Heap.enable")
 
     async def console_enable(self):
-        return await self.send_command('Console.enable')
+        return await self.send_command("Console.enable")
 
     async def runtime_enable(self):
-        return await self.send_command('Runtime.enable')
+        return await self.send_command("Runtime.enable")
 
     async def send_command(self, method: str, **kwargs):
         if self.target_id is None:
             return await self.protocol.send_receive(method, **kwargs)
         else:
-            return await self.send_and_receive({'method': method, 'params': kwargs})
+            return await self.send_and_receive({"method": method, "params": kwargs})
 
     async def runtime_evaluate(self, exp: str, return_by_value: bool = False):
         # if the expression is dict, it's needed to be in ()
         exp = exp.strip()
-        if exp:
-            if exp[0] == '{' and exp[-1] == '}':
-                exp = f'({exp})'
-
-        response = await self.send_and_receive({'method': 'Runtime.evaluate',
-                                                'params': {
-                                                    'expression': exp,
-                                                    'objectGroup': 'console',
-                                                    'includeCommandLineAPI': True,
-                                                    'doNotPauseOnExceptionsAndMuteConsole': False,
-                                                    'silent': False,
-                                                    'returnByValue': return_by_value,
-                                                    'generatePreview': True,
-                                                    'userGesture': True,
-                                                    'awaitPromise': False,
-                                                    'replMode': True,
-                                                    'allowUnsafeEvalBlockedByCSP': False,
-                                                    'uniqueContextId': '0.1'}
-                                                })
+        if exp and exp[0] == "{" and exp[-1] == "}":
+            exp = f"({exp})"
+
+        response = await self.send_and_receive({
+            "method": "Runtime.evaluate",
+            "params": {
+                "expression": exp,
+                "objectGroup": "console",
+                "includeCommandLineAPI": True,
+                "doNotPauseOnExceptionsAndMuteConsole": False,
+                "silent": False,
+                "returnByValue": return_by_value,
+                "generatePreview": True,
+                "userGesture": True,
+                "awaitPromise": False,
+                "replMode": True,
+                "allowUnsafeEvalBlockedByCSP": False,
+                "uniqueContextId": "0.1",
+            },
+        })
 
         return await self._parse_runtime_evaluate(response)
 
@@ -154,18 +154,19 @@ class InspectorSession:
 
     async def send_and_receive(self, message: dict) -> dict:
         if self.target_id is None:
-            message_id = await self.protocol.send_command(message['method'], **message.get('params', {}))
+            message_id = await self.protocol.send_command(message["method"], **message.get("params", {}))
             return await self.protocol.wait_for_message(message_id)
         else:
             message_id = await self.send_message_to_target(message)
             return await self.receive_response_by_id(message_id)
 
     async def send_message_to_target(self, message: dict) -> int:
-        message['id'] = self.message_id
+        message["id"] = self.message_id
         self.message_id += 1
-        await self.protocol.send_command('Target.sendMessageToTarget', targetId=self.target_id,
-                                         message=json.dumps(message))
-        return message['id']
+        await self.protocol.send_command(
+            "Target.sendMessageToTarget", targetId=self.target_id, message=json.dumps(message)
+        )
+        return message["id"]
 
     async def _receive_loop(self):
         while True:
@@ -173,11 +174,11 @@ class InspectorSession:
                 await asyncio.sleep(0)
 
             response = self.protocol.inspector.wir_events.pop(0)
-            response_method = response['method']
+            response_method = response["method"]
             if response_method in self.response_methods:
                 self.response_methods[response_method](response)
             else:
-                logger.error(f'Unknown response: {response}')
+                logger.error(f"Unknown response: {response}")
 
     async def receive_response_by_id(self, message_id: int) -> dict:
         while True:
@@ -187,64 +188,67 @@ class InspectorSession:
 
     async def get_properties(self, object_id: str) -> JSObjectProperties:
         message = await self.send_command(
-            'Runtime.getProperties', objectId=object_id, ownProperties=True, generatePreview=True)
+            "Runtime.getProperties", objectId=object_id, ownProperties=True, generatePreview=True
+        )
         if self.target_id is not None:
-            message = json.loads(message['params']['message'])['result']
-        return JSObjectProperties(message['properties'])
+            message = json.loads(message["params"]["message"])["result"]
+        return JSObjectProperties(message["properties"])
 
     async def _parse_runtime_evaluate(self, response: dict):
-        if self.target_id is None:
-            message = response
-        else:
-            message = json.loads(response['params']['message'])
-        result = message['result']['result']
-        if result.get('subtype', '') == 'error':
-            properties = await self.get_properties(result['objectId'])
-            raise InspectorEvaluateError(properties.class_name, properties['message'], properties.get('line'),
-                                         properties.get('column'), properties.get('stack', '').split('\n'))
-        elif result['type'] == 'bigint':
-            return result['description']
-        elif result['type'] == 'undefined':
+        message = response if self.target_id is None else json.loads(response["params"]["message"])
+        result = message["result"]["result"]
+        if result.get("subtype", "") == "error":
+            properties = await self.get_properties(result["objectId"])
+            raise InspectorEvaluateError(
+                properties.class_name,
+                properties["message"],
+                properties.get("line"),
+                properties.get("column"),
+                properties.get("stack", "").split("\n"),
+            )
+        elif result["type"] == "bigint":
+            return result["description"]
+        elif result["type"] == "undefined":
             pass
-        elif result['type'] == 'object':
-            value = result.get('value')
+        elif result["type"] == "object":
+            value = result.get("value")
             if value is not None:
                 return value
 
             # TODO: JSObjectProperties()
-            preview = result['preview']
-            preview_buf = '{\n'
-            for p in result['preview']['properties']:
-                value = p.get('value', 'NOT_SUPPORTED_FOR_PREVIEW')
-                preview_buf += f'\t{p["name"]}: {value}, // {p["type"]}\n'
-            if preview.get('overflow'):
-                preview_buf += '\t// ...\n'
-            preview_buf += '}'
-            return f'[object {result["className"]}]\n{preview_buf}'
-        elif result['type'] == 'function':
-            return result['description']
+            preview = result["preview"]
+            preview_buf = "{\n"
+            for p in result["preview"]["properties"]:
+                value = p.get("value", "NOT_SUPPORTED_FOR_PREVIEW")
+                preview_buf += f"\t{p['name']}: {value}, // {p['type']}\n"
+            if preview.get("overflow"):
+                preview_buf += "\t// ...\n"
+            preview_buf += "}"
+            return f"[object {result['className']}]\n{preview_buf}"
+        elif result["type"] == "function":
+            return result["description"]
         else:
-            return result['value']
+            return result["value"]
 
     # response methods
     def _target_dispatch_message_from_target(self, response: dict):
-        target_message = json.loads(response['params']['message'])
-        receive_message_id = target_message.get('id')
+        target_message = json.loads(response["params"]["message"])
+        receive_message_id = target_message.get("id")
         if receive_message_id is None:
             self._missing_id_in_message(target_message)
             return
         self._dispatch_message_responses[receive_message_id] = response
 
     def _missing_id_in_message(self, message: dict):
-        handler = self.response_methods.get(message['method'])
+        handler = self.response_methods.get(message["method"])
         if handler is not None:
             handler(message)
         else:
-            logger.critical(f'unhandled message: {message}')
+            logger.critical(f"unhandled message: {message}")
 
     def _console_message_added(self, message: dict):
-        log_level = message['params']['message']['level']
-        text = message['params']['message']['text']
+        log_level = message["params"]["message"]["level"]
+        text = message["params"]["message"]["text"]
         self._last_console_message = message
         webinspector_logger_handlers[log_level](text)
 
@@ -252,7 +256,7 @@ class InspectorSession:
         self._console_message_added(self._last_console_message)
 
     def _heap_garbage_collected(self, message: dict):
-        heap_logger.debug(message['params'])
+        heap_logger.debug(message["params"])
 
     def _target_created(self, response: dict):
         pass
@@ -261,4 +265,4 @@ class InspectorSession:
         pass
 
     def _target_did_commit_provisional_target(self, response: dict):
-        self.set_target_id(response['params']['newTargetId'])
+        self.set_target_id(response["params"]["newTargetId"])

pymobiledevice3/services/web_protocol/selenium_api.py

@@ -6,86 +6,86 @@ 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:
+            with open(filename, "wb") as f:
                 f.write(png)
-        except IOError:
+        except OSError:
             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

@@ -5,7 +5,7 @@ from pymobiledevice3.exceptions import WirError
 
 
 class SessionProtocol:
-    def __init__(self, inspector, id_, app, page, method_prefix='Automation'):
+    def __init__(self, inspector, id_, app, page, method_prefix="Automation"):
         """
         :param pymobiledevice3.services.webinspector.WebinspectorService inspector:
         """
@@ -19,19 +19,25 @@ class SessionProtocol:
     async def send_command(self, method, **kwargs):
         wir_id = self._wir_messages_id
         self._wir_messages_id += 1
-        await self.inspector.send_socket_data(self.id_, self.app.id_, self.page.id_, {
-            'method': f'{self.method_prefix}.{method}' if self.method_prefix else method,
-            'params': kwargs,
-            'id': wir_id,
-        })
+        await self.inspector.send_socket_data(
+            self.id_,
+            self.app.id_,
+            self.page.id_,
+            {
+                "method": f"{self.method_prefix}.{method}" if self.method_prefix else method,
+                "params": kwargs,
+                "id": wir_id,
+            },
+        )
         return wir_id
 
     async def get_response(self, wir_id):
         response = await self.wait_for_message(wir_id)
-        if 'result' in response:
-            return response['result']
-        elif 'error' in response:
-            raise WirError(response['error']['message'])
+        if "result" in response:
+            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)
@@ -45,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,57 +11,60 @@ class SwitchTo:
         self.session = session
 
     @property
-    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)
+    async def active_element(self) -> WebElement:
+        """Returns the element with focus, or BODY if nothing has focus."""
+        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
     def alert(self) -> Alert:
-        """ Switches focus to an alert on the page. """
+        """Switches focus to an alert on the page."""
         return Alert(self.session)
 
-    def default_content(self):
-        """ Switch focus to the default frame. """
-        self.session.switch_to_browsing_context('')
+    async def default_content(self):
+        """Switch focus to the default frame."""
+        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,
                                 or a web element that is an (i)frame to switch to.
         """
-        if isinstance(frame_reference, int) or isinstance(frame_reference, WebElement):
+        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 ValueError()
+            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_=''):
-        """ Switches to a new top-level browsing context. """
-        self.session.switch_to_window(self.session.create_window(type_))
+    async def new_window(self, type_=""):
+        """Switches to a new top-level browsing context."""
+        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):
-        """ Switches focus to the specified window. """
-        self.session.switch_to_window(window_name)
+    async def window(self, window_name):
+        """Switches focus to the specified window."""
+        await self.session.switch_to_window(window_name)