pymobiledevice3 6.2.0__py3-none-any.whl → 7.0.0__py3-none-any.whl

pymobiledevice3/cli/webinspector.py

@@ -1,30 +1,34 @@
 import asyncio
+import inspect
 import logging
 import re
 from abc import ABC, abstractmethod
 from asyncio import CancelledError
 from collections.abc import AsyncIterator, Iterable
-from contextlib import asynccontextmanager
+from contextlib import AbstractAsyncContextManager, asynccontextmanager
 from functools import update_wrapper
-from typing import Optional, Union
+from string import Template
+from typing import Annotated, Any, Optional
 
-import click
 import inquirer3
 import IPython
 import nest_asyncio
+import typer
 import uvicorn
 from inquirer3.themes import GreenPassion
 from prompt_toolkit import HTML, PromptSession
 from prompt_toolkit.auto_suggest import AutoSuggestFromHistory
-from prompt_toolkit.completion.base import CompleteEvent, Completer, Completion, Document
+from prompt_toolkit.completion.base import CompleteEvent, Completer, Completion
+from prompt_toolkit.document import Document
 from prompt_toolkit.history import FileHistory
 from prompt_toolkit.lexers import PygmentsLexer
 from prompt_toolkit.patch_stdout import patch_stdout
 from prompt_toolkit.styles import style_from_pygments_cls
 from pygments import formatters, highlight, lexers
 from pygments.styles import get_style_by_name
+from typer_injector import InjectingTyper
 
-from pymobiledevice3.cli.cli_common import Command
+from pymobiledevice3.cli.cli_common import ServiceProviderDep
 from pymobiledevice3.common import get_home_folder
 from pymobiledevice3.exceptions import (
     InspectorEvaluateError,
@@ -33,35 +37,34 @@ from pymobiledevice3.exceptions import (
     WebInspectorNotEnabledError,
     WirError,
 )
-from pymobiledevice3.lockdown import LockdownClient, create_using_usbmux
+from pymobiledevice3.lockdown import create_using_usbmux
 from pymobiledevice3.lockdown_service_provider import LockdownServiceProvider
 from pymobiledevice3.osu.os_utils import get_os_utils
 from pymobiledevice3.services.web_protocol.cdp_server import app
 from pymobiledevice3.services.web_protocol.driver import By, Cookie, WebDriver
 from pymobiledevice3.services.web_protocol.inspector_session import InspectorSession
-from pymobiledevice3.services.webinspector import SAFARI, ApplicationPage, WebinspectorService
-
-SCRIPT = """
-function inspectedPage_evalResult_getCompletions(primitiveType) {{
-    var resultSet={{}};
-    var object = primitiveType;
-    for(var o=object;o;o=o.__proto__) {{
-
-        try{{
-            var names=Object.getOwnPropertyNames(o);
-            for(var i=0;i<names.length;++i)
-                resultSet[names[i]]=true;
-        }} catch(e){{}}
-    }}
+from pymobiledevice3.services.webinspector import SAFARI, Application, ApplicationPage, WebinspectorService
+
+SCRIPT = Template("""
+function inspectedPage_evalResult_getCompletions(primitiveType) {
+    let resultSet = {};
+    let object = primitiveType;
+    for (let o = object; o; o = o.__proto__) {
+        try {
+            let names = Object.getOwnPropertyNames(o);
+            for (let i = 0; i < names.length; ++i)
+                resultSet[names[i]] = true;
+        } catch(e) {}
+    }
     return resultSet;
-}}
+}
 
-try {{
-    inspectedPage_evalResult_getCompletions({object})
-}} catch (e) {{}}
-"""
+try {
+    inspectedPage_evalResult_getCompletions(${object})
+} catch (e) {}
+""")
 
-JS_RESERVED_WORDS = [
+JS_RESERVED_WORDS = frozenset({
     "abstract",
     "arguments",
     "await",
@@ -126,51 +129,67 @@ JS_RESERVED_WORDS = [
     "while",
     "with",
     "yield",
-]
+})
 
 OSUTILS = get_os_utils()
 logger = logging.getLogger(__name__)
 
 
-@click.group()
-def cli() -> None:
-    pass
+cli = InjectingTyper(
+    name="webinspector",
+    help=(
+        "Control Safari/WebViews (tabs, automation, JS shells, CDP). "
+        "Requires Web Inspector and Remote Automation enabled on the device."
+    ),
+    no_args_is_help=True,
+)
 
 
-@cli.group()
-def webinspector() -> None:
-    """Access webinspector services"""
-    pass
+def catch_errors(func):
+    errors = {
+        LaunchingApplicationError: "Unable to launch application (try to unlock device)",
+        WebInspectorNotEnabledError: "Web inspector is not enabled",
+        RemoteAutomationNotEnabledError: "Remote automation is not enabled",
+    }
 
+    def handle_error(e):
+        logger.error(next(msg for exc, msg in errors.items() if isinstance(e, exc)))
 
-def catch_errors(func):
-    def catch_function(*args, **kwargs):
-        try:
-            return func(*args, **kwargs)
-        except LaunchingApplicationError:
-            logger.error("Unable to launch application (try to unlock device)")
-        except WebInspectorNotEnabledError:
-            logger.error("Web inspector is not enable")
-        except RemoteAutomationNotEnabledError:
-            logger.error("Remote automation is not enable")
+    if inspect.iscoroutinefunction(func):
+
+        async def catch_function(*args, **kwargs):
+            try:
+                return await func(*args, **kwargs)
+            except tuple(errors) as e:
+                handle_error(e)
+
+    else:
+
+        def catch_function(*args, **kwargs):
+            try:
+                return func(*args, **kwargs)
+            except tuple(errors) as e:
+                handle_error(e)
 
     return update_wrapper(catch_function, func)
 
 
-def reload_pages(inspector: WebinspectorService):
-    inspector.get_open_pages()
+async def reload_pages(inspector: WebinspectorService) -> None:
+    await inspector.get_open_pages()
     # Best effort.
-    inspector.flush_input(2)
+    await inspector.flush_input(2)
 
 
-async def create_webinspector_and_launch_app(lockdown: LockdownClient, timeout: float, app: str):
+async def create_webinspector_and_launch_app(
+    lockdown: LockdownServiceProvider, timeout: float, app: str
+) -> tuple[WebinspectorService, Application]:
     inspector = WebinspectorService(lockdown=lockdown)
     await inspector.connect(timeout)
     application = await inspector.open_app(app)
     return inspector, application
 
 
-async def opened_tabs_task(service_provider: LockdownClient, timeout):
+async def opened_tabs_task(service_provider: LockdownServiceProvider, timeout: float) -> None:
     inspector = WebinspectorService(lockdown=service_provider)
     await inspector.connect(timeout)
     application_pages = await inspector.get_open_application_pages(timeout=timeout)
@@ -179,10 +198,15 @@ async def opened_tabs_task(service_provider: LockdownClient, timeout):
     await inspector.close()
 
 
-@webinspector.command(cls=Command)
-@click.option("-t", "--timeout", default=3, show_default=True, type=float)
+@cli.command()
 @catch_errors
-def opened_tabs(service_provider: LockdownClient, timeout):
+def opened_tabs(
+    service_provider: ServiceProviderDep,
+    timeout: Annotated[
+        float,
+        typer.Option("--timeout", "-t", help="Seconds to wait for WebInspector to respond."),
+    ] = 3.0,
+) -> None:
     """
     Show all currently opened tabs.
 
@@ -196,7 +220,7 @@ def opened_tabs(service_provider: LockdownClient, timeout):
 
 
 @catch_errors
-async def launch_task(service_provider: LockdownClient, url, timeout):
+async def launch_task(service_provider: LockdownServiceProvider, url, timeout) -> None:
     inspector, safari = await create_webinspector_and_launch_app(service_provider, timeout, SAFARI)
     session = await inspector.automation_session(safari)
     driver = WebDriver(session)
@@ -209,11 +233,16 @@ async def launch_task(service_provider: LockdownClient, url, timeout):
     await inspector.close()
 
 
-@webinspector.command(cls=Command)
-@click.argument("url")
-@click.option("-t", "--timeout", default=3, show_default=True, type=float)
+@cli.command()
 @catch_errors
-def launch(service_provider: LockdownClient, url, timeout):
+def launch(
+    service_provider: ServiceProviderDep,
+    url: str,
+    timeout: Annotated[
+        float,
+        typer.Option("--timeout", "-t", help="Seconds to wait for WebInspector to respond."),
+    ] = 3.0,
+) -> None:
     """
     Launch a specific URL in Safari.
 
@@ -252,7 +281,7 @@ driver.add_cookie(
 
 
 @catch_errors
-async def shell_task(service_provider: LockdownClient, timeout):
+async def shell_task(service_provider: LockdownServiceProvider, timeout: float) -> None:
     inspector, safari = await create_webinspector_and_launch_app(service_provider, timeout, SAFARI)
     session = await inspector.automation_session(safari)
     driver = WebDriver(session)
@@ -271,9 +300,15 @@ async def shell_task(service_provider: LockdownClient, timeout):
         await inspector.close()
 
 
-@webinspector.command(cls=Command)
-@click.option("-t", "--timeout", default=3, show_default=True, type=float)
-def shell(service_provider: LockdownClient, timeout):
+@cli.command()
+@catch_errors
+def shell(
+    service_provider: ServiceProviderDep,
+    timeout: Annotated[
+        float,
+        typer.Option("--timeout", "-t", help="Seconds to wait for WebInspector to respond."),
+    ] = 3.0,
+) -> None:
     """
     Create an IPython shell for interacting with a WebView.
 
@@ -289,14 +324,23 @@ def shell(service_provider: LockdownClient, timeout):
     asyncio.run(shell_task(service_provider, timeout), debug=True)
 
 
-@webinspector.command(cls=Command)
-@click.option("-t", "--timeout", default=3, show_default=True, type=float)
-@click.option("--automation", is_flag=True, help="Use remote automation")
-@click.option("--no-open-safari", is_flag=True, help="Avoid opening the Safari app")
-@click.argument("url", required=False, default="")
+@cli.command()
 @catch_errors
 def js_shell(
-    service_provider: LockdownServiceProvider, timeout: float, automation: bool, no_open_safari: bool, url: str
+    service_provider: ServiceProviderDep,
+    url: str = "",
+    timeout: Annotated[
+        float,
+        typer.Option("--timeout", "-t", help="Seconds to wait for WebInspector to respond."),
+    ] = 3.0,
+    automation: Annotated[
+        bool,
+        typer.Option(help="Use remote automation (requires Remote Automation toggle)."),
+    ] = False,
+    open_safari: Annotated[
+        bool,
+        typer.Option(help="Use an existing WebView; skip auto-opening Safari."),
+    ] = False,
 ) -> None:
     """
     Create a javascript shell. This interpreter runs on your local machine,
@@ -313,7 +357,7 @@ def js_shell(
     """
 
     js_shell_class = AutomationJsShell if automation else InspectorJsShell
-    asyncio.run(run_js_shell(js_shell_class, service_provider, timeout, url, not no_open_safari))
+    asyncio.run(run_js_shell(js_shell_class, service_provider, timeout, url, open_safari))
 
 
 udid = ""
@@ -325,10 +369,8 @@ def create_app():
     return app
 
 
-@webinspector.command(cls=Command)
-@click.option("--host", default="127.0.0.1")
-@click.option("--port", type=click.INT, default=9222)
-def cdp(service_provider: LockdownClient, host, port):
+@cli.command()
+def cdp(service_provider: ServiceProviderDep, host: str = "127.0.0.1", port: int = 9222) -> None:
     """
     Start a CDP server for debugging WebViews.
 
@@ -339,7 +381,7 @@ def cdp(service_provider: LockdownClient, host, port):
     global udid
     udid = service_provider.udid
     uvicorn.run(
-        "pymobiledevice3.cli.webinspector:create_app",
+        f"{__name__}:{create_app.__name__}",
         host=host,
         port=port,
         factory=True,
@@ -354,7 +396,7 @@ async def get_js_completions(jsshell: "JsShell", obj: str, prefix: str) -> Async
         return
 
     try:
-        for key in await jsshell.evaluate_expression(SCRIPT.format(object=obj), return_by_value=True):
+        for key in await jsshell.evaluate_expression(SCRIPT.substitute(object=obj), return_by_value=True):
             if not key.startswith(prefix):
                 continue
             yield Completion(key.removeprefix(prefix), display=key)
@@ -364,14 +406,14 @@ async def get_js_completions(jsshell: "JsShell", obj: str, prefix: str) -> Async
 
 
 class JsShellCompleter(Completer):
-    def __init__(self, jsshell: "JsShell"):
-        self.jsshell = jsshell
+    def __init__(self, jsshell: "JsShell") -> None:
+        self.jsshell: JsShell = jsshell
 
-    def get_completions_async(
+    async def get_completions_async(
         self,
         document: Document,
         complete_event: CompleteEvent,
-    ) -> Union[AsyncIterator[Completion], Iterable[Completion]]:
+    ) -> AsyncIterator[Completion]:
         # Build the JS expression we want to inspect
         text = f"globalThis.{document.text_before_cursor}"
 
@@ -379,7 +421,7 @@ class JsShellCompleter(Completer):
         matches = re.findall(r"[a-zA-Z_][a-zA-Z_0-9.]+", text)
         if not matches:
             # async *generator*: just end, don't return a list
-            return iter(())
+            return
 
         text = matches[-1]
         if "." in text:
@@ -389,7 +431,8 @@ class JsShellCompleter(Completer):
             prefix = ""
 
         # This should return an iterable of Completion (or something we can wrap)
-        return get_js_completions(self.jsshell, js_obj, prefix)
+        async for completion in get_js_completions(self.jsshell, js_obj, prefix):
+            yield completion
 
     # Optional: keep sync completions empty so PTK knows we prefer async
     def get_completions(
@@ -403,7 +446,7 @@ class JsShellCompleter(Completer):
 class JsShell(ABC):
     def __init__(self) -> None:
         super().__init__()
-        self.prompt_session = PromptSession(
+        self.prompt_session: PromptSession = PromptSession(
             lexer=PygmentsLexer(lexers.JavascriptLexer),
             auto_suggest=AutoSuggestFromHistory(),
             style=style_from_pygments_cls(get_style_by_name("stata-dark")),
@@ -413,18 +456,17 @@ class JsShell(ABC):
 
     @classmethod
     @abstractmethod
-    def create(cls, lockdown: LockdownServiceProvider, timeout: float, open_safari: bool) -> None:
-        pass
+    def create(
+        cls, lockdown: LockdownServiceProvider, timeout: float, open_safari: bool
+    ) -> "AbstractAsyncContextManager[JsShell]": ...
 
     @abstractmethod
-    async def evaluate_expression(self, exp, return_by_value: bool = False):
-        pass
+    async def evaluate_expression(self, exp, return_by_value: bool = False) -> Any: ...
 
     @abstractmethod
-    async def navigate(self, url: str):
-        pass
+    async def navigate(self, url: str) -> None: ...
 
-    async def js_iter(self):
+    async def js_iter(self) -> None:
         with patch_stdout(True):
             exp = await self.prompt_session.prompt_async(HTML('<style fg="cyan"><b>&gt;</b></style> '))
 
@@ -437,7 +479,7 @@ class JsShell(ABC):
         )
         print(colorful_result, end="")
 
-    async def start(self, url: str = ""):
+    async def start(self, url: str = "") -> None:
         if url:
             await self.navigate(url)
         while True:
@@ -456,45 +498,49 @@ class JsShell(ABC):
 
 
 class AutomationJsShell(JsShell):
-    def __init__(self, driver: WebDriver):
+    def __init__(self, driver: WebDriver) -> None:
         super().__init__()
-        self.driver = driver
+        self.driver: WebDriver = driver
 
     @classmethod
     @asynccontextmanager
-    async def create(cls, lockdown: LockdownClient, timeout: float, open_safari: bool) -> "AutomationJsShell":
-        inspector, application = create_webinspector_and_launch_app(lockdown, timeout, SAFARI)
-        automation_session = inspector.automation_session(application)
+    async def create(
+        cls, lockdown: LockdownServiceProvider, timeout: float, open_safari: bool
+    ) -> "AsyncIterator[AutomationJsShell]":
+        inspector, application = await create_webinspector_and_launch_app(lockdown, timeout, SAFARI)
+        automation_session = await inspector.automation_session(application)
         driver = WebDriver(automation_session)
         await driver.start_session()
         try:
             yield cls(driver)
         finally:
-            automation_session.stop_session()
-            inspector.close()
+            await automation_session.stop_session()
+            await inspector.close()
 
-    async def evaluate_expression(self, exp: str, return_by_value: bool = False):
+    async def evaluate_expression(self, exp: str, return_by_value: bool = False) -> Any:
         return await self.driver.execute_script(f"return {exp}")
 
-    async def navigate(self, url: str):
+    async def navigate(self, url: str) -> None:
         await self.driver.get(url)
 
 
 class InspectorJsShell(JsShell):
-    def __init__(self, inspector_session: InspectorSession):
+    def __init__(self, inspector_session: InspectorSession) -> None:
         super().__init__()
-        self.inspector_session = inspector_session
+        self.inspector_session: InspectorSession = inspector_session
 
     @classmethod
     @asynccontextmanager
-    async def create(cls, lockdown: LockdownClient, timeout: float, open_safari: bool) -> "InspectorJsShell":
+    async def create(
+        cls, lockdown: LockdownServiceProvider, timeout: float, open_safari: bool
+    ) -> "AsyncIterator[InspectorJsShell]":
         inspector = WebinspectorService(lockdown=lockdown)
         await inspector.connect(timeout)
         if open_safari:
             _ = await inspector.open_app(SAFARI)
         application_page = await cls.query_page(inspector, bundle_identifier=SAFARI if open_safari else None)
         if application_page is None:
-            raise click.exceptions.Exit()
+            raise typer.Exit()
 
         inspector_session = await inspector.inspector_session(application_page.application, application_page.page)
         await inspector_session.console_enable()
@@ -505,7 +551,7 @@ class InspectorJsShell(JsShell):
         finally:
             await inspector.close()
 
-    async def evaluate_expression(self, exp: str, return_by_value: bool = False):
+    async def evaluate_expression(self, exp: str, return_by_value: bool = False) -> Any:
         return await self.inspector_session.runtime_evaluate(exp, return_by_value=return_by_value)
 
     async def navigate(self, url: str):

pymobiledevice3/remote/remote_service_discovery.py

@@ -166,17 +166,18 @@ class RemoteServiceDiscoveryService(LockdownServiceProvider):
 
 async def get_remoted_devices(timeout: float = DEFAULT_BONJOUR_TIMEOUT) -> list[RSDDevice]:
     result = []
-    for hostname in await browse_remoted(timeout):
-        with RemoteServiceDiscoveryService((hostname, RSD_PORT)) as rsd:
-            properties = rsd.peer_info["Properties"]
-            result.append(
-                RSDDevice(
-                    hostname=hostname,
-                    udid=properties["UniqueDeviceID"],
-                    product_type=properties["ProductType"],
-                    os_version=properties["OSVersion"],
+    for instance in await browse_remoted(timeout):
+        for address in instance.addresses:
+            with RemoteServiceDiscoveryService((address.full_ip, RSD_PORT)) as rsd:
+                properties = rsd.peer_info["Properties"]
+                result.append(
+                    RSDDevice(
+                        hostname=address.full_ip,
+                        udid=properties["UniqueDeviceID"],
+                        product_type=properties["ProductType"],
+                        os_version=properties["OSVersion"],
+                    )
                 )
-            )
     return result
 
 

pymobiledevice3/restore/device.py

@@ -1,6 +1,6 @@
 from contextlib import suppress
 from functools import cached_property
-from typing import Optional
+from typing import Optional, overload
 
 from pymobiledevice3.exceptions import MissingValueError
 from pymobiledevice3.irecv import IRecv
@@ -8,9 +8,15 @@ from pymobiledevice3.lockdown import LockdownClient
 
 
 class Device:
-    def __init__(self, lockdown: LockdownClient = None, irecv: IRecv = None):
-        self.lockdown = lockdown
-        self.irecv = irecv
+    @overload
+    def __init__(self, lockdown: LockdownClient, irecv: None = None) -> None: ...
+
+    @overload
+    def __init__(self, lockdown: None = None, *, irecv: IRecv) -> None: ...
+
+    def __init__(self, lockdown: Optional[LockdownClient] = None, irecv: Optional[IRecv] = None) -> None:
+        self._lockdown: Optional[LockdownClient] = lockdown
+        self._irecv: Optional[IRecv] = irecv
 
     def __repr__(self) -> str:
         return (
@@ -20,6 +26,24 @@ class Device:
             f"image4-support: {self.is_image4_supported}>"
         )
 
+    @cached_property
+    def is_lockdown(self) -> bool:
+        return self._lockdown is not None
+
+    @cached_property
+    def is_irecv(self) -> bool:
+        return self._irecv is not None
+
+    @cached_property
+    def lockdown(self) -> LockdownClient:
+        assert self._lockdown is not None
+        return self._lockdown
+
+    @cached_property
+    def irecv(self) -> IRecv:
+        assert self._irecv is not None
+        return self._irecv
+
     @cached_property
     def ecid(self):
         if self.lockdown:

pymobiledevice3/service_connection.py

@@ -192,7 +192,7 @@ class ServiceConnection:
         except ssl.SSLEOFError as e:
             raise ConnectionTerminatedError from e
 
-    def send_recv_plist(self, data: dict, endianity: str = ">", fmt: Enum = plistlib.FMT_XML) -> Any:
+    def send_recv_plist(self, data: Union[dict, list], endianity: str = ">", fmt: Enum = plistlib.FMT_XML) -> Any:
         """
         Send a plist to the socket and receive a plist response.
 

pymobiledevice3/services/mobilebackup2.py

@@ -5,6 +5,7 @@ import uuid
 from contextlib import contextmanager, suppress
 from datetime import datetime
 from pathlib import Path
+from typing import Union
 
 from pymobiledevice3.exceptions import (
     AfcException,
@@ -60,7 +61,9 @@ class Mobilebackup2Service(LockdownService):
         except LockdownError:
             return False
 
-    def backup(self, full: bool = True, backup_directory: str = ".", progress_callback=lambda x: None) -> None:
+    def backup(
+        self, full: bool = True, backup_directory: Union[str, Path] = ".", progress_callback=lambda x: None
+    ) -> None:
         """
         Backup a device.
         :param full: Whether to do a full backup. If full is True, any previous backup attempts will be discarded.

pymobiledevice3/services/screenshot.py

@@ -1,12 +1,12 @@
 from pymobiledevice3.exceptions import PyMobileDevice3Exception
-from pymobiledevice3.lockdown import LockdownClient
+from pymobiledevice3.lockdown_service_provider import LockdownServiceProvider
 from pymobiledevice3.services.lockdown_service import LockdownService
 
 
 class ScreenshotService(LockdownService):
     SERVICE_NAME = "com.apple.mobile.screenshotr"
 
-    def __init__(self, lockdown: LockdownClient):
+    def __init__(self, lockdown: LockdownServiceProvider) -> None:
         super().__init__(lockdown, self.SERVICE_NAME, is_developer_service=True)
 
         dl_message_version_exchange = self.service.recv_plist()

pymobiledevice3/services/web_protocol/automation_session.py

@@ -1,9 +1,11 @@
+import importlib.resources
 import json
 from dataclasses import dataclass
 from enum import Enum
-from pathlib import Path
 
-RESOURCES = Path(__file__).parent.parent.parent / "resources" / "webinspector"
+import pymobiledevice3.resources
+
+RESOURCES = importlib.resources.files(pymobiledevice3.resources) / "webinspector"
 FIND_NODES = (RESOURCES / "find_nodes.js").read_text()
 
 

pymobiledevice3/services/web_protocol/cdp_screencast.py

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

pymobiledevice3/services/web_protocol/element.py

@@ -103,7 +103,7 @@ class WebElement(SeleniumApi):
     @property
     async def rect(self) -> Rect:
         """The size and location of the element."""
-        return await self._compute_layout(scroll_if_needed=False)[0]
+        return (await self._compute_layout(scroll_if_needed=False))[0]
 
     @property
     async def screenshot_as_base64(self) -> str:
@@ -144,7 +144,7 @@ class WebElement(SeleniumApi):
 
     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);"
@@ -164,7 +164,7 @@ class WebElement(SeleniumApi):
             'function(element) { return element.innerText.replace(/^[^\\S\\xa0]+|[^\\S\\xa0]+$/g, "") }'
         )
 
-    async def touch(self):
+    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(