mobster-cli 0.4.3__py3-none-any.whl

mobile_agent/app_choice.py

@@ -0,0 +1,131 @@
+"""Which app a task means: the app it names or opens, the channel a message goes through, or the verb's own app.
+
+Shared by the terminal UI (its app chip) and `mobster run --demo`, so neither needs the UI library to decide.
+"""
+
+import re
+
+# When a task names no app, its opening verb can ("Text Alex…" is Messages), and so can a few
+# settings words anywhere ("…Display & Text Size" is Settings). Verbs count only at the start:
+# "Text Size" in the middle of a Settings task must not pick Messages.
+APP_VERBS = [
+    (r"(text|message|imessage)\s", "messages"), (r"e-?mail\s", "mail"), (r"(call|dial)\s", "phone"),
+    (r"facetime\s", "face-time"), (r"remind me\b", "reminders"), (r"(set|start) (an? )?(alarm|timer)\b", "clock"),
+    (r"(take|write|make) a note\b", "notes"), (r"(play|queue)\s", "music"),
+    (r"(search|google|look up)\s", "safari"),
+]
+APP_WORDS = [
+    (r"\b(dark mode|light mode|wi-?fi|bluetooth|airplane mode|brightness|accessibility|text size|"
+     r"display|wallpaper|ringtone|notifications|screen time|focus mode|general|about this|ios version|"
+     r"software update|storage|battery|cellular|hotspot|privacy|passwords?|sounds?)\b", "settings"),
+    (r"\b(weather|forecast)\b", "weather"), (r"(https?://|www\.)", "safari"),
+]
+# Words for what a feed or an inbox holds: a task about them is about that content, so its settings words ("the
+# formats, sounds and topics" of 20 Reels; real iPhone, 13 Oct) don't make it a Settings task.
+CONTENT_NOUNS = r"\b(reels?|tiktoks?|shorts|videos?|posts?|feeds?|stories|dms|direct messages|saved)\b"
+
+
+# App names that are also everyday words ("heading home", "the news", "Find my boarding pass"). They count only
+# when the task clearly means the app: written capitalised mid-sentence ("…in my Photos"), after
+# in/open/launch/from/using ("open music"), or before "app" ("the home app"); and an opening verb ("Text Sam…")
+# wins over them.
+COMMON_WORD_APPS = {"home", "news", "photos", "music", "clock", "files", "phone", "mail", "messages", "find my"}
+# ...or when what follows is what the app finds: "Find my iPhone", "Find my AirPods", "Find my son's phone".
+_FINDS = {"find my": r"\bfind my\s+(?:[\w-]+['’]s\s+)?(?:iphone|ipad|ipod|airpods|apple watch|watch|mac|macbook|"
+                     r"keys|airtags?|phone(?!\s+numbers?\b)|devices?)(?![\w-])"}
+_NAMED_AS_APP = r"(?:\b(?:in|open|launch|from|using|into)\s+(?:the\s+|my\s+)?){name}(?![\w-])|(?<![\w-]){name}\s+app\b"
+# Verbs whose object is a person or a message: the rest of the task is what to say, so an app named in it
+# ("Message Sam about the camera settings") is not where it runs, unless it names the channel ("…on WhatsApp").
+MESSAGE_VERB_APPS = {"messages", "mail", "phone", "face-time", "reminders", "notes"}
+_CHANNEL = r"\b(?:on|via|through|over)\s+(?:the\s+|my\s+)?{name}(?![\w-])"
+# ...or unless the verb's object is another app: "Call an Uber", "Call me a Lyft", "Message my Airbnb host", "Text
+# the DoorDash driver". The ride, the host and the driver are reached through that app. The verbs' own apps and
+# the common words stay what is said or sent ("Email the notes to Sam", "Text my photos to Mom").
+_OBJECT = r"^\s*(?:me\s+)?(?:(?:an?|the|my|our|your)\s+)?{name}(?![\w-])"
+
+
+def _names(name, lowered):
+    return re.search(rf"(?<![\w-]){re.escape(name)}(?![\w-])", lowered) is not None
+
+
+def _named_as_app(app, lowered, pattern=_NAMED_AS_APP):
+    name = app["name"].casefold()
+    return len(name) >= 3 and re.search(pattern.format(name=re.escape(name)), lowered) is not None
+
+
+def _clearly_the_app(app, goal, lowered):
+    if _named_as_app(app, lowered):
+        return True
+    written = re.search(rf"(?<![\w-]){re.escape(app['name'])}(?![\w-])", goal)
+    return written is not None and written.start() > 0
+
+
+def infer_app(goal, apps):
+    goal = goal.strip()
+    lowered = goal.casefold()
+    by_length = sorted(apps, key=lambda a: -len(a["name"]))
+    named = next((app for app in by_length if _named_as_app(app, lowered)), None)
+    if named is not None:
+        return named
+    opening = re.sub(r"^(please|can you|could you)\s+", "", lowered)
+
+    def hinted(patterns):
+        for pattern, app_id in patterns:
+            match = re.search(pattern, opening)
+            if match:
+                app = next((a for a in apps if a["id"] == app_id), None)
+                if app is not None:
+                    return app, match
+        return None, None
+
+    verb, said = hinted([(rf"^{pattern}", app_id) for pattern, app_id in APP_VERBS])
+    if verb is not None and verb["id"] in MESSAGE_VERB_APPS:
+        rest = opening[said.end():]
+        channel = next((app for app in by_length if _named_as_app(app, lowered, _CHANNEL)), None)
+        target = channel or next((app for app in by_length if app["id"] not in MESSAGE_VERB_APPS
+                                  and app["name"].casefold() not in COMMON_WORD_APPS
+                                  and _named_as_app(app, rest, _OBJECT)), None)
+        return target or verb
+    common = []
+    for app in by_length:
+        name = app["name"].casefold()
+        if len(name) >= 3 and _names(name, lowered):
+            if name not in COMMON_WORD_APPS or name in _FINDS and re.search(_FINDS[name], lowered):
+                return app
+            common.append(app)
+    if verb is not None:
+        return verb
+    named = next((app for app in common if _clearly_the_app(app, goal, lowered)), None)
+    if named is not None:
+        return named
+    words = [(pattern, app_id) for pattern, app_id in APP_WORDS
+             if not (app_id == "settings" and re.search(CONTENT_NOUNS, opening))]
+    return hinted(words)[0]
+
+
+def find_app(name, apps):
+    wanted = (name or "").strip().casefold()
+    if not wanted:
+        return None
+    for app in apps:
+        if wanted in {app["id"].casefold(), app["name"].casefold(), app["name"].casefold().replace(" ", ""),
+                      (app.get("bundleId") or "").casefold()}:
+            return app
+    return None
+
+
+def mention_rank(app, query):
+    name = app["name"].casefold()
+    if name.startswith(query) or name.replace(" ", "").startswith(query) or app["id"].casefold().startswith(query):
+        return 0
+    if any(word.startswith(query) for word in re.split(r"[\s-]+", name)):
+        return 1
+    if query in name:
+        return 2
+    if query in (app.get("bundleId") or "").casefold():
+        return 3
+    return None
+
+
+# An @word in the prompt: "@messages", "@com.burbn.instagram", "@nasa". A trailing dot ends the sentence.
+MENTION = re.compile(r"(?:^|\s)@([\w-]+(?:\.[\w-]+)*)")

mobile_agent/app_icons.py

@@ -0,0 +1,183 @@
+"""Icons for the phone's own apps, from Apple's public App Store lookup."""
+
+import hashlib
+import json
+import os
+import threading
+import time
+import urllib.error
+import urllib.request
+from pathlib import Path
+from urllib.parse import quote, urlsplit
+
+from .state import validate_bundle_id
+
+LOOKUP_URL = "https://itunes.apple.com/lookup?bundleId="
+LOOKUP_LIMIT = 512_000
+IMAGE_LIMIT = 1_000_000
+TIMEOUT = 8
+MISS_SECONDS = 7 * 86_400
+# Apple rate-limits the lookup service (roughly 20 requests a minute): after a refusal, wait.
+BACKOFF_SECONDS = 60.0
+# Hosts the lookup and its artwork are served from; a redirect anywhere else is refused.
+APPLE_HOSTS = ("itunes.apple.com",)
+ARTWORK_SUFFIX = ".mzstatic.com"
+PNG, JPEG = b"\x89PNG\r\n\x1a\n", b"\xff\xd8\xff"
+
+
+class IconUnavailable(RuntimeError):
+    """The icon could not be fetched right now (offline, rate limited); try again later."""
+
+
+def _apple_url(url, artwork=False):
+    parts = urlsplit(url)
+    host = (parts.hostname or "").lower()
+    return parts.scheme == "https" and not parts.username and not parts.password and (
+        host.endswith(ARTWORK_SUFFIX) if artwork else host in APPLE_HOSTS or host.endswith(ARTWORK_SUFFIX))
+
+
+class _AppleRedirects(urllib.request.HTTPRedirectHandler):
+    def redirect_request(self, request, response, code, message, headers, url):
+        if not _apple_url(url):
+            raise urllib.error.HTTPError(url, code, "Redirect away from Apple refused", headers, response)
+        return super().redirect_request(request, response, code, message, headers, url)
+
+
+def image_type(data):
+    """The MIME type of a PNG or JPEG, else None."""
+    return "image/png" if data.startswith(PNG) else "image/jpeg" if data.startswith(JPEG) else None
+
+
+class AppIcons:
+    """A folder of icons keyed by bundle ID, filled from the App Store lookup on demand."""
+
+    def __init__(self, directory, opener=None, clock=time.time, allowed=None, concurrency=2):
+        self.directory = Path(directory)
+        self.open = opener
+        self.clock, self.allowed = clock, allowed
+        self.lock = threading.Lock()
+        self.flights = {}
+        self.gate = threading.BoundedSemaphore(concurrency)
+        self.backoff_until = 0.0
+
+    def _key(self, bundle):
+        return hashlib.sha256(bundle.encode()).hexdigest()[:32]
+
+    def _cached(self, bundle):
+        key = self._key(bundle)
+        for suffix, mime in ((".png", "image/png"), (".jpg", "image/jpeg")):
+            try:
+                data = (self.directory / (key + suffix)).read_bytes()
+            except OSError:
+                continue
+            if image_type(data) == mime and len(data) <= IMAGE_LIMIT:
+                return data, mime
+        return None
+
+    def _misses(self):
+        try:
+            value = json.loads((self.directory / "misses.json").read_text())
+            return value if isinstance(value, dict) else {}
+        except (OSError, ValueError):
+            return {}
+
+    def _missed(self, bundle):
+        stamp = self._misses().get(self._key(bundle))
+        return isinstance(stamp, (int, float)) and self.clock() - stamp < MISS_SECONDS
+
+    def _write(self, name, data):
+        self.directory.mkdir(parents=True, exist_ok=True)
+        try:
+            os.chmod(self.directory, 0o700)
+        except OSError:
+            pass
+        temporary = self.directory / f".{name}.{threading.get_ident()}.tmp"
+        temporary.write_bytes(data)
+        os.replace(temporary, self.directory / name)
+
+    def _remember_miss(self, bundle):
+        with self.lock:
+            now = self.clock()
+            misses = {key: stamp for key, stamp in self._misses().items()
+                      if isinstance(stamp, (int, float)) and now - stamp < MISS_SECONDS}
+            misses[self._key(bundle)] = now
+            self._write("misses.json", json.dumps(misses).encode())
+
+    def get(self, bundle):
+        """(bytes, mime) of the app's icon, or None when there is none."""
+        bundle = validate_bundle_id(bundle)
+        cached = self._cached(bundle)
+        if cached or self._missed(bundle):
+            return cached
+        if self.allowed is not None and bundle not in self.allowed():
+            return None
+        # One lookup per bundle at a time: the picker and the Apps page ask together.
+        with self.lock:
+            flight = self.flights.get(bundle)
+            leader = flight is None
+            if leader:
+                flight = self.flights[bundle] = threading.Event()
+        if not leader:
+            flight.wait(TIMEOUT * 2 + 1)
+            cached = self._cached(bundle)
+            if cached or self._missed(bundle):
+                return cached
+            raise IconUnavailable("The icon is not available right now")
+        try:
+            with self.gate:
+                return self._fetch(bundle)
+        finally:
+            with self.lock:
+                self.flights.pop(bundle, None)
+            flight.set()
+
+    def _read(self, url, limit):
+        if self.clock() < self.backoff_until:
+            raise IconUnavailable("The App Store asked Mobster to slow down")
+        request = urllib.request.Request(url, headers={"User-Agent": "Mobster", "Accept": "*/*"})
+        try:
+            # CLI runs and cached icons need no HTTPS client or certificate-store initialization.
+            with self.lock:
+                if self.open is None:
+                    self.open = urllib.request.build_opener(_AppleRedirects).open
+                opener = self.open
+            with opener(request, timeout=TIMEOUT) as response:
+                data = response.read(limit + 1)
+                content_type = (response.headers.get("Content-Type") or "").split(";")[0].strip().lower()
+        except urllib.error.HTTPError as error:
+            if error.code in (403, 429, 503):
+                self.backoff_until = self.clock() + BACKOFF_SECONDS
+            if error.code == 404:
+                return None, None
+            raise IconUnavailable(f"The App Store answered {error.code}") from None
+        except (urllib.error.URLError, TimeoutError, OSError) as error:
+            raise IconUnavailable(f"The App Store could not be reached ({type(error).__name__})") from None
+        if len(data) > limit:
+            return None, None
+        return data, content_type
+
+    def _fetch(self, bundle):
+        cached = self._cached(bundle)  # another request may have finished it meanwhile
+        if cached:
+            return cached
+        body, _ = self._read(LOOKUP_URL + quote(bundle, safe=""), LOOKUP_LIMIT)
+        artwork = None
+        try:
+            results = json.loads(body)["results"] if body else []
+            match = next((item for item in results if isinstance(item, dict)
+                          and str(item.get("bundleId", "")).lower() == bundle.lower()), None)
+            if match:
+                artwork = next((url for url in (match.get("artworkUrl100"), match.get("artworkUrl512"))
+                                if isinstance(url, str) and _apple_url(url, artwork=True)), None)
+        except (ValueError, KeyError, TypeError):
+            artwork = None
+        if not artwork:
+            self._remember_miss(bundle)
+            return None
+        data, content_type = self._read(artwork, IMAGE_LIMIT)
+        mime = image_type(data or b"")
+        if not mime or content_type not in {"image/png", "image/jpeg", "image/jpg", ""}:
+            self._remember_miss(bundle)
+            return None
+        self._write(self._key(bundle) + (".png" if mime == "image/png" else ".jpg"), data)
+        return data, mime

mobile_agent/app_killer.py

@@ -0,0 +1,69 @@
+"""Close an app on the device without WebDriverAgent, for an app WDA itself can't close.
+
+An app whose accessibility server stopped answering snapshots also blocks WDA's own ``/wda/apps/terminate``: in
+the 11 Oct iOSWorld batch (ab1, scorezone-003) the stuck-app relaunch fired and WDA's terminate timed out, and the
+run ended in an error. ``xcrun simctl terminate`` closed the same kind of stuck app in about 2 s. ``WDA.killer``
+(drivers.py) is one of these, set where the device is known; ``WDA.relaunch_app`` uses it only when WDA's terminate
+fails.
+
+- ``simulator(udid)``: ``xcrun simctl terminate``.
+- ``device(udid)``: CoreDevice (``xcrun devicectl``). It finds the app's process by the app's install path, then
+  terminates that one process with SIGKILL. A process of any other app is never touched.
+
+Each returns a ``killer(bundle_id, timeout) -> bool``: True when the app was closed.
+"""
+
+import subprocess
+
+
+def simulator(udid, runner=subprocess.run):
+    """A killer for the simulator ``udid``."""
+    def kill(bundle_id, timeout=15):
+        try:
+            done = runner(["xcrun", "simctl", "terminate", udid, bundle_id], capture_output=True, timeout=timeout)
+        except (OSError, subprocess.SubprocessError):
+            return False
+        return done.returncode == 0
+    return kill
+
+
+def _app_url(document, bundle_id):
+    for app in ((document or {}).get("result") or {}).get("apps") or ():
+        if app.get("bundleIdentifier") == bundle_id and app.get("url"):
+            return app["url"].rstrip("/") + "/"
+    return None
+
+
+def _pids(document, app_url):
+    """Processes whose executable lies inside the app's install folder."""
+    out = []
+    for process in ((document or {}).get("result") or {}).get("runningProcesses") or ():
+        executable, pid = process.get("executable") or "", process.get("processIdentifier")
+        if app_url and executable.startswith(app_url) and isinstance(pid, int) and pid > 0:
+            out.append(pid)
+    return out
+
+
+def device(udid, run_json=None):
+    """A killer for the USB or network device ``udid``, through CoreDevice."""
+    def kill(bundle_id, timeout=15):
+        from .harness_api import hooks
+        run = run_json or hooks().devicectl_json
+        try:
+            # --include-all-apps: without it CoreDevice lists only apps installed for development, never an App Store
+            # app (TikTok on a phone, 11 Oct: no app found, so a stuck TikTok was never closed).
+            apps = run(["device", "info", "apps", "--device", udid, "--bundle-id", bundle_id, "--include-all-apps"],
+                       timeout)
+            app_url = _app_url(apps, bundle_id)
+            if app_url is None:
+                return False
+            processes = run(["device", "info", "processes", "--device", udid], timeout)
+            pids = _pids(processes, app_url)
+            if not pids:
+                return False
+            for pid in pids:
+                run(["device", "process", "terminate", "--device", udid, "--pid", str(pid), "--kill"], timeout)
+            return True
+        except Exception:
+            return False
+    return kill