PhoneWatchUI / apple_store /script /app_collect.py
Jl-wei's picture
Update image download and verification instructions and research-use notice
0d25dbe verified
Raw History Blame Contribute Delete
44.4 kB
"""Collect PhoneWatchUI Apple app metadata from a supplied App-ID list.
Includes the Apple Watch and iPhone page parsers. No network requests are made
when this file is imported; run the CLI to collect public metadata, not IPA files.
"""
from __future__ import annotations
import argparse
from datetime import datetime, timezone
import gzip
import hashlib
from html.parser import HTMLParser
import json
import math
from pathlib import Path
import re
import time
from typing import Any
from urllib.parse import urlsplit
from urllib.request import Request, urlopen
def write_json(path, value):
path = Path(path)
path.parent.mkdir(parents=True, exist_ok=True)
temporary = path.with_name(path.name + '.tmp')
temporary.write_text(json.dumps(value, ensure_ascii=False, indent=2) + '\n')
temporary.replace(path)
def jsonl(path):
with Path(path).open() as stream:
for line in stream:
if line.strip():
yield json.loads(line)
def dump_line(stream, value):
stream.write(json.dumps(value, ensure_ascii=False, separators=(',', ':')) + '\n')
# Apple Watch product parser.
class _Document(HTMLParser):
def __init__(self) -> None:
super().__init__(convert_charrefs=True)
self.scripts: list[tuple[dict[str, str | None], str]] = []
self.links: list[str] = []
self.canonical: str | None = None
self.language: str | None = None
self._script: dict[str, str | None] | None = None
self._parts: list[str] = []
def handle_starttag(self, tag: str, attrs: list[tuple[str, str | None]]) -> None:
values = dict(attrs)
if tag == "script":
self._script, self._parts = values, []
elif tag == "html":
self.language = values.get("lang")
elif tag == "link" and "canonical" in (values.get("rel") or "").split():
self.canonical = values.get("href")
elif tag == "a" and values.get("href"):
self.links.append(values["href"])
def handle_data(self, data: str) -> None:
if self._script is not None:
self._parts.append(data)
def handle_endtag(self, tag: str) -> None:
if tag == "script" and self._script is not None:
self.scripts.append((self._script, "".join(self._parts)))
self._script, self._parts = None, []
def _dict(value: Any) -> dict:
return value if isinstance(value, dict) else {}
def _list(value: Any) -> list:
return value if isinstance(value, list) else []
def _text(value: Any) -> str | None:
return value.strip() if isinstance(value, str) and value.strip() else None
def _id(value: Any) -> str | None:
if isinstance(value, bool):
return None
text = str(value) if isinstance(value, (str, int)) else ""
return text if text.isdigit() else None
def _app_url(value: Any) -> tuple[str, str] | None:
if not isinstance(value, str):
return None
try:
parts = urlsplit(value)
if parts.scheme != "https" or parts.hostname != "apps.apple.com" or parts.username:
return None
match = re.fullmatch(r"/([a-z]{2})/app/(?:[^/]+/)?id(\d+)/?", parts.path)
if match:
return match.group(2), value
except ValueError:
pass
return None
def _walk(value: Any):
"""Walk public content without collecting metrics, tokens, or review bodies."""
pending = [value]
while pending:
current = pending.pop()
if isinstance(current, dict):
yield current
pending.extend(
child for key, child in reversed(list(current.items()))
if key not in {"userTokenHash", "actionMetrics", "impressionMetrics",
"pageMetrics", "pageRenderMetrics", "allProductReviews",
"editorsChoiceProductReviews"}
)
elif isinstance(current, list):
pending.extend(reversed(current))
def _product_nodes(root: Any) -> list[dict]:
"""Support array, data-array, numeric dictionary, and direct wrappers."""
nodes = []
pending = [root]
while pending:
node = pending.pop()
if isinstance(node, list):
pending.extend(reversed(node))
elif isinstance(node, dict):
inner = _dict(node.get("data"))
if (isinstance(inner.get("shelfMapping"), dict)
or isinstance(inner.get("appPlatforms"), list)):
nodes.append(node)
# Do not confuse embedded related products with the main product.
continue
for key, child in reversed(list(node.items())):
if key == "data" or key.isdigit():
pending.append(child)
return nodes
def _identity(node: dict) -> set[str]:
data = _dict(node.get("data"))
values = {
_id(_dict(node.get("intent")).get("id")),
_id(_dict(data.get("lockup")).get("adamId")),
}
canonical = _app_url(data.get("canonicalURL"))
if canonical:
values.add(canonical[0])
return values - {None}
def _artwork(shot: Any, rank: int) -> dict | None:
shot = _dict(shot)
template = _text(shot.get("template"))
width, height = shot.get("width"), shot.get("height")
if (not template or isinstance(width, bool) or isinstance(height, bool)
or not isinstance(width, int) or not isinstance(height, int)
or width <= 0 or height <= 0):
return None
crop = shot.get("crop") or "bb"
if not isinstance(crop, str) or not re.fullmatch(r"[A-Za-z0-9-]+", crop):
return None
url = template
for key, value in {"w": width, "h": height, "c": crop, "f": "png"}.items():
url = url.replace("{" + key + "}", str(value))
if "{" in url or "}" in url:
return None
try:
parts = urlsplit(url)
host = parts.hostname or ""
if (parts.scheme != "https" or parts.username
or not (host == "mzstatic.com" or host.endswith(".mzstatic.com"))):
return None
except ValueError:
return None
return {"rank": rank, "url": url, "width": width, "height": height,
"platform": "watch", "source_template": template}
def _http_url(value: Any) -> str | None:
value = _text(value)
if value:
try:
parts = urlsplit(value)
if parts.scheme in {"http", "https"} and parts.hostname and not parts.username:
return value
except ValueError:
pass
return None
def _number(value: Any, *, integer: bool = False) -> int | float | None:
if isinstance(value, bool) or not isinstance(value, (str, int, float)):
return None
if isinstance(value, str) and not re.fullmatch(r"\d+(?:\.\d+)?", value):
return None # Do not estimate exact counts from labels such as "87K".
try:
number = float(value)
if not math.isfinite(number) or number < 0 or (integer and not number.is_integer()):
return None
return int(number) if number.is_integer() else number
except (ValueError, OverflowError):
return None
def _date(value: Any) -> str | None:
"""Normalize explicit dates; never resolve relative dates or invent a timezone."""
value = _text(value)
if not value:
return None
try:
if re.fullmatch(r"\d{4}-\d{2}-\d{2}", value):
return datetime.strptime(value, "%Y-%m-%d").date().isoformat()
parsed = datetime.fromisoformat(value.replace("Z", "+00:00"))
except ValueError:
try:
parsed = datetime.strptime(value.split(" (")[0], "%a %b %d %Y %H:%M:%S GMT%z")
except ValueError:
return None
return parsed.isoformat() if parsed.tzinfo is not None else None
def _extra_metadata(data: dict, products: list[dict], requested_id: str) -> dict:
"""Select scalar public fields from the identified product, not related apps."""
fields = {
key: None for key in (
"developer_name", "developer_id", "developer_url", "seller_name",
"app_version", "app_version_updated_at", "app_version_updated_at_raw",
"app_version_release_notes", "app_release_date", "price", "currency",
"is_free", "has_in_app_purchases", "age_rating", "content_rating_code",
"rating_average", "rating_count", "supported_languages", "website_url",
"support_url", "privacy_policy_url", "copyright",
)
}
sources: dict[str, str] = {}
def put(key: str, value: Any, source: str) -> None:
if fields[key] is None and value is not None:
fields[key] = value
sources[key] = source
shelves = _dict(data.get("shelfMapping"))
developer = _dict(data.get("developerAction"))
put("developer_name", _text(developer.get("title")), "data.developerAction.title")
put("developer_url", _http_url(developer.get("pageUrl")), "data.developerAction.pageUrl")
destination = _dict(developer.get("destination"))
if destination.get("$kind") == "DeveloperPageIntent":
put("developer_id", _id(destination.get("id")), "data.developerAction.destination.id")
version_items = _list(_dict(shelves.get("mostRecentVersion")).get("items"))
for index, item in enumerate(version_items):
item = _dict(item)
version = _text(item.get("primarySubtitle"))
if not version:
continue
version = re.sub(r"^Version\s+", "", version)
base = f"data.shelfMapping.mostRecentVersion.items[{index}]"
put("app_version", version, base + ".primarySubtitle")
raw_date = _text(item.get("secondarySubtitle"))
put("app_version_updated_at_raw", raw_date, base + ".secondarySubtitle")
put("app_version_updated_at", _date(raw_date), base + ".secondarySubtitle")
put("app_version_release_notes", _text(item.get("text")), base + ".text")
break # Do not mix a different version's date or notes with the current one.
offer = _dict(data.get("titleOfferDisplayProperties"))
for source, target in [("isFree", "is_free"), ("hasInAppPurchases", "has_in_app_purchases")]:
value = offer.get(source)
if isinstance(value, bool):
put(target, value, "data.titleOfferDisplayProperties." + source)
put("content_rating_code", _number(offer.get("contentRating"), integer=True),
"data.titleOfferDisplayProperties.contentRating")
for index, item in enumerate(_list(_dict(shelves.get("productRatings")).get("items"))):
item = _dict(item)
if _id(item.get("productId")) not in {None, requested_id}:
continue
base = f"data.shelfMapping.productRatings.items[{index}]"
average = _number(item.get("ratingAverage"))
if average is not None and average <= 5:
put("rating_average", average, base + ".ratingAverage")
put("rating_count", _number(item.get("totalNumberOfRatings"), integer=True),
base + ".totalNumberOfRatings")
for index, item in enumerate(_list(_dict(shelves.get("information")).get("items"))):
item = _dict(item)
title = (_text(item.get("title")) or "").lower()
texts = [_text(_dict(entry).get("text")) for entry in _list(item.get("items"))]
texts = [text for text in texts if text]
base = f"data.shelfMapping.information.items[{index}]"
if title in {"seller", "copyright"} and texts:
put("seller_name" if title == "seller" else "copyright", texts[0], base + ".items[0].text")
elif title == "age rating":
put("age_rating", _text(item.get("summary")) or (texts[0] if texts else None), base)
elif title == "languages" and texts:
languages = list(dict.fromkeys(language.strip() for text in texts
for language in text.split(",") if language.strip()))
put("supported_languages", languages or None, base + ".items[*].text")
for index, item in enumerate(_list(_dict(shelves.get("description")).get("items"))):
for link_index, link in enumerate(_list(_dict(item).get("developerLinks"))):
link = _dict(link)
label = (_text(link.get("text")) or "").lower()
target = {"website": "website_url", "support": "support_url",
"privacy policy": "privacy_policy_url"}.get(label)
if target:
put(target, _http_url(_dict(link.get("clickAction")).get("url")),
f"data.shelfMapping.description.items[{index}].developerLinks[{link_index}].clickAction.url")
for index, item in enumerate(_list(_dict(shelves.get("privacyHeader")).get("items"))):
links = _dict(_dict(_dict(item).get("bodyText")).get("linkedSubstrings"))
for label, action in links.items():
if "privacy" in label.lower():
put("privacy_policy_url", _http_url(_dict(action).get("url")),
f"data.shelfMapping.privacyHeader.items[{index}].bodyText.linkedSubstrings.{label}.url")
for product in products:
product_url = _app_url(product.get("url"))
if product_url and product_url[0] != requested_id:
continue
author = _dict(product.get("author"))
put("developer_name", _text(author.get("name")), "jsonld.SoftwareApplication.author.name")
put("developer_url", _http_url(author.get("url")), "jsonld.SoftwareApplication.author.url")
structured_offer = _dict(product.get("offers"))
put("price", _number(structured_offer.get("price")), "jsonld.SoftwareApplication.offers.price")
currency = _text(structured_offer.get("priceCurrency"))
if currency and re.fullmatch(r"[A-Z]{3}", currency):
put("currency", currency, "jsonld.SoftwareApplication.offers.priceCurrency")
rating = _dict(product.get("aggregateRating"))
average = _number(rating.get("ratingValue"))
if average is not None and average <= 5:
put("rating_average", average, "jsonld.SoftwareApplication.aggregateRating.ratingValue")
for count_key in ("ratingCount", "reviewCount"):
put("rating_count", _number(rating.get(count_key), integer=True),
"jsonld.SoftwareApplication.aggregateRating." + count_key)
put("app_release_date", _date(product.get("datePublished")), "jsonld.SoftwareApplication.datePublished")
put("app_version", _text(product.get("softwareVersion")), "jsonld.SoftwareApplication.softwareVersion")
if fields["developer_id"] is None and fields["developer_url"]:
parts = urlsplit(fields["developer_url"])
match = re.fullmatch(r"/[a-z]{2}/developer/(?:[^/]+/)?id(\d+)/?", parts.path)
if parts.hostname == "apps.apple.com" and match:
put("developer_id", match.group(1), sources["developer_url"])
fields["field_sources"] = sources
return fields
def parse_product(html: str, requested_id: str) -> dict:
"""Return public metadata, watch evidence, and original-size screenshot URLs.
``watch_supported`` is True for explicit positive evidence, False only for a
complete identified product with explicit non-watch platform compatibility,
and None otherwise. ``metadata.parse_status`` reports parsing separately.
Screenshot ranks are zero-based across all accepted watch shelves. The
requested ID remains the output ID; an identity mismatch yields no artwork.
"""
requested_id = str(requested_id)
result = {"app_id": requested_id, "name": None, "description": None,
"genres": [], "watch_supported": None, "evidence": [],
"screenshots": [], "related_apps": [], "metadata": {}}
meta = result["metadata"]
evidence = result["evidence"]
warnings: list[str] = []
document = _Document()
try:
document.feed(html)
document.close()
except (ValueError, AssertionError):
warnings.append("html_parse_error")
meta["html_language"] = document.language
meta["canonical_url"] = document.canonical
nodes: list[dict] = []
ld_products: list[dict] = []
serialized_count, malformed_count = 0, 0
for attrs, content in document.scripts:
is_server = attrs.get("id") == "serialized-server-data"
is_ld = (attrs.get("type") or "").lower() == "application/ld+json"
if not is_server and not is_ld:
continue
if is_server:
serialized_count += 1
try:
payload = json.loads(content)
except (ValueError, RecursionError):
if is_server:
malformed_count += 1
warnings.append("invalid_server_json" if is_server else "invalid_ld_json")
continue
if is_server:
nodes.extend(_product_nodes(payload))
else:
ld_products.extend(x for x in _walk(payload)
if x.get("@type") == "SoftwareApplication")
canonical = _app_url(document.canonical)
canonical_id = canonical[0] if canonical else None
candidates = [node for node in nodes if _identity(node) == {requested_id}]
if not candidates:
candidates = [node for node in nodes if not _identity(node)]
identity_mismatch = bool(
(canonical_id is not None and canonical_id != requested_id)
or (nodes and not candidates)
)
selected = candidates[0] if candidates and not identity_mismatch else {}
data = _dict(selected.get("data"))
intent = _dict(selected.get("intent"))
lockup = _dict(data.get("lockup"))
identity_evidence = _identity(selected)
if canonical_id:
identity_evidence.add(canonical_id)
identified = bool(selected) and identity_evidence == {requested_id}
incomplete = data.get("isIncomplete") is True
meta["parse_status"] = (
"app_id_mismatch" if identity_mismatch
else "identity_unknown" if selected and not identified else "ok" if selected
else "malformed_json" if malformed_count
else "unknown_structure" if serialized_count else "missing_script"
)
meta["identity_verified"] = identified
meta["is_incomplete"] = incomplete if selected else None
meta["storefront"] = _text(intent.get("storefront"))
meta["language"] = _text(intent.get("language"))
meta["requested_platform"] = _text(intent.get("platform"))
meta["bundle_id"] = _text(lockup.get("bundleId"))
meta["subtitle"] = _text(lockup.get("subtitle"))
if _app_url(data.get("canonicalURL")):
meta["canonical_url"] = data["canonicalURL"]
if not meta["storefront"] and _app_url(meta["canonical_url"]):
meta["storefront"] = urlsplit(meta["canonical_url"]).path.split("/")[1]
meta["language"] = meta["language"] or document.language
result["name"] = _text(data.get("title")) or _text(lockup.get("title"))
shelves = _dict(data.get("shelfMapping"))
description = _dict(shelves.get("description"))
paragraphs = [_text(_dict(item.get("paragraph")).get("text"))
for item in _list(description.get("items")) if isinstance(item, dict)]
result["description"] = "\n\n".join(p for p in paragraphs if p) or None
def genre(value: Any) -> None:
value = _text(value)
if value and value not in result["genres"]:
result["genres"].append(value)
compatibility: list[dict] = []
for item in _list(_dict(shelves.get("information")).get("items")):
item = _dict(item)
title = (_text(item.get("title")) or "").lower()
if title == "category":
for entry in _list(item.get("items")):
genre(_dict(entry).get("text"))
if title == "compatibility":
for entry in _list(item.get("items")):
entry = _dict(entry)
heading, text = _text(entry.get("heading")), _text(entry.get("text"))
if heading or text:
compatibility.append({"platform": heading, "requirement": text})
for item in _list(_dict(shelves.get("informationRibbon")).get("items")):
item = _dict(item)
if item.get("key") == "category":
genre(item.get("caption"))
meta["compatibility"] = compatibility
# JSON-LD is useful metadata, but its phone-oriented OS summary cannot prove
# the absence of a watch app. A watchOS requirement is positive evidence.
ld_watch = False
for product in ld_products:
product_url = _app_url(product.get("url"))
if identity_mismatch or (product_url and product_url[0] != requested_id):
continue
result["name"] = result["name"] or _text(product.get("name"))
result["description"] = result["description"] or _text(product.get("description"))
if not result["genres"]:
category = product.get("applicationCategory")
for value in category if isinstance(category, list) else [category]:
genre(value)
if re.search(r"\bwatchOS\b", _text(product.get("operatingSystem")) or "", re.I):
ld_watch = True
# Keep rich metadata under the same identity guard as downloadable artwork.
# No raw page, metrics, reviewer identities, or version-history payloads escape.
if identified:
meta.update(_extra_metadata(data, ld_products, requested_id))
raw_platforms = data.get("appPlatforms")
platforms = [p.lower() for p in raw_platforms if isinstance(p, str)] if isinstance(raw_platforms, list) else []
meta["platforms"] = platforms
explicit_watch = any(p in {"watch", "watchos", "applewatch"} for p in platforms)
compatibility_watch = any(
"watch" in ((row["platform"] or "") + " " + (row["requirement"] or "")).lower()
for row in compatibility
)
if explicit_watch:
evidence.append("appPlatforms:watch")
if compatibility_watch:
evidence.append("compatibility:watch")
if ld_watch:
evidence.append("structured_operating_system:watchOS")
watch_shelves: list[str] = []
# Public content can be decoded without identifying its app. Never turn
# such content into downloadable corpus records or positive Watch labels.
for key, shelf in shelves.items() if identified else []:
if not isinstance(shelf, dict):
continue
platform = _text(_dict(_dict(shelf.get("contentsMetadata")).get("platform")).get("appPlatform"))
platform = platform.lower() if platform else None
key_watch = key.startswith("product_media_watch")
if not key_watch and platform != "watch":
continue
conflicting_key = key.startswith("product_media_") and not key_watch
if (key_watch and platform not in {None, "watch"}) or (platform == "watch" and conflicting_key):
warnings.append("conflicting_platform_shelf:" + key)
continue
watch_shelves.append(key)
evidence.append("watch_media_shelf:" + key)
for shelf_item_index, item in enumerate(_list(shelf.get("items"))):
item = _dict(item)
if not item.get("screenshot"):
continue # Videos and other promotional media are not screenshots.
shot = _artwork(item["screenshot"], len(result["screenshots"]))
if not shot:
warnings.append("invalid_watch_artwork:" + key)
continue
shot.update(shelf_key=key, shelf_item_index=shelf_item_index)
result["screenshots"].append(shot)
meta["watch_shelves"] = watch_shelves
if identified and (explicit_watch or compatibility_watch or ld_watch or watch_shelves):
result["watch_supported"] = True
if platforms and not explicit_watch:
warnings.append("watch_evidence_conflicts_with_appPlatforms")
elif identified and not incomplete:
if platforms:
result["watch_supported"] = False
evidence.append("complete_appPlatforms_without_watch")
elif compatibility and any(row["platform"] for row in compatibility):
result["watch_supported"] = False
evidence.append("complete_compatibility_without_watch")
if identity_mismatch:
evidence.append("product_identity_mismatch")
elif selected and not identified:
evidence.append("product_identity_unverified")
related: dict[str, str] = {}
def add_related(url: Any) -> None:
parsed = _app_url(url)
if parsed and parsed[0] != requested_id:
related.setdefault(*parsed)
for url in document.links:
add_related(url)
for obj in _walk(shelves):
for field in ("pageUrl", "url"):
add_related(obj.get(field))
if obj.get("$kind") == "ProductPageIntent":
app_id = _id(obj.get("id"))
country = _text(obj.get("storefront")) or meta["storefront"] or "us"
if app_id and re.fullmatch(r"[a-z]{2}", country):
add_related(f"https://apps.apple.com/{country}/app/id{app_id}?platform=watch")
result["related_apps"] = [{"app_id": app_id, "url": url} for app_id, url in related.items()]
meta["warnings"] = list(dict.fromkeys(warnings))
return result
# iPhone product parser; gallery membership stays separate from Watch.
_PHONE = {"phone", "iphone"}
_OTHER_PLATFORMS = {"pad", "ipad", "watch", "watchos", "applewatch", "mac", "macos",
"tv", "appletv", "vision", "visionos", "reality", "ipod"}
_OTHER_COMPATIBILITY = {"ipad", "ipod touch", "mac", "apple watch", "apple tv",
"apple vision", "apple vision pro"}
_MAX_NODES = 10000
_MAX_DEPTH = 32
_MAX_SHELVES = 512
_MAX_ITEMS = 1000
class _LimitReached(ValueError):
pass
def _nodes(payload, *, jsonld=False):
"""Visit known wrappers only, with a budget and no related-product descent."""
pending, found, visited = [(payload, 0)], [], 0
while pending:
node, depth = pending.pop()
visited += 1
if visited > _MAX_NODES or depth > _MAX_DEPTH:
raise _LimitReached
if isinstance(node, list):
children = node
elif isinstance(node, dict):
if jsonld:
if node.get("@type") == "SoftwareApplication":
found.append(node)
continue
children = [node["@graph"]] if "@graph" in node else []
else:
data = _dict(node.get("data"))
if isinstance(data.get("shelfMapping"), dict) or isinstance(data.get("appPlatforms"), list):
found.append(node)
continue
children = [value for key, value in node.items() if key == "data" or key.isdigit()]
else:
continue
if len(children) + len(pending) + visited > _MAX_NODES:
raise _LimitReached
pending.extend((child, depth + 1) for child in reversed(children))
return found
def _compatibility(shelves):
rows = []
for item in _list(_dict(shelves.get("information")).get("items"))[:_MAX_ITEMS]:
item = _dict(item)
if (_text(item.get("title")) or "").lower() != "compatibility":
continue
for entry in _list(item.get("items"))[:_MAX_ITEMS]:
entry = _dict(entry)
heading, text = _text(entry.get("heading")), _text(entry.get("text"))
# Current public pages encode the same headings as styled Markdown.
raw = _text(_dict(_dict(entry.get("linkableText")).get("styledText")).get("rawText"))
if raw and not (heading or text):
match = re.fullmatch(r"\*\*([^*]+)\*\*\s*(.*)", raw, flags=re.S)
heading, text = (match.group(1), match.group(2)) if match else (None, raw)
if heading or text:
rows.append({"platform": heading, "requirement": text})
return rows
def _phone_artwork(value, rank):
shot = _artwork(value, rank)
if shot is None:
return None
try:
parts = urlsplit(shot["url"])
if (parts.username is not None or parts.password is not None or parts.port is not None
or parts.fragment or not parts.path.lower().endswith(".png")):
return None
except ValueError:
return None
return {**shot, "platform": "phone"}
def parse_phone_product(html: str, requested_id: str) -> dict:
"""Return identified US-English product data and native-size phone artwork.
``phone_supported`` is True for positive phone evidence, False only when a
complete page explicitly lists other platforms, and None for uncertainty.
Locale contradictions or missing locale evidence never authorize downloads.
``metadata.media_parse_complete`` additionally rejects incomplete/malformed
phone media; callers use it before marking a no-images or complete result.
"""
requested_id = str(requested_id)
result = {"app_id": requested_id, "name": None, "description": None, "genres": [],
"phone_supported": None, "evidence": [], "screenshots": [], "related_apps": [],
"page_locale_verified": False, "metadata": {}}
meta, warnings = result["metadata"], []
document = _Document()
try:
document.feed(html)
document.close()
except (ValueError, AssertionError):
warnings.append("html_parse_error")
nodes, products = [], []
serialized, malformed, limited = 0, 0, False
for attrs, content in document.scripts:
server = attrs.get("id") == "serialized-server-data"
jsonld = (attrs.get("type") or "").lower() == "application/ld+json"
if not server and not jsonld:
continue
serialized += int(server)
try:
payload = json.loads(content)
(nodes if server else products).extend(_nodes(payload, jsonld=not server))
except _LimitReached:
limited = True
warnings.append("parser_limit_reached")
except (ValueError, RecursionError):
malformed += int(server)
warnings.append("invalid_server_json" if server else "invalid_ld_json")
canonical = _app_url(document.canonical)
canonical_id = canonical[0] if canonical else None
candidates = [node for node in nodes if _identity(node) == {requested_id}]
if not candidates:
candidates = [node for node in nodes if not _identity(node)]
mismatch = bool((canonical_id is not None and canonical_id != requested_id) or (nodes and not candidates))
selected = candidates[0] if candidates and not mismatch and not limited else {}
data, intent = _dict(selected.get("data")), _dict(selected.get("intent"))
identity = _identity(selected) | ({canonical_id} if canonical_id else set())
identified = bool(selected) and identity == {requested_id}
shelves, lockup = _dict(data.get("shelfMapping")), _dict(data.get("lockup"))
status = ("parser_limit_reached" if limited else "app_id_mismatch" if mismatch
else "identity_unknown" if selected and not identified else "ok" if selected
else "malformed_json" if malformed else "unknown_structure" if serialized else "missing_script")
canonical_url = data.get("canonicalURL") if _app_url(data.get("canonicalURL")) else document.canonical
canonical_product = _app_url(canonical_url)
storefront = _text(intent.get("storefront"))
if not storefront and canonical_product:
storefront = urlsplit(canonical_product[1]).path.split("/")[1]
language = _text(intent.get("language")) or document.language
meta.update(html_language=document.language, canonical_url=canonical_url, parse_status=status,
identity_verified=identified, is_incomplete=data.get("isIncomplete") is True if selected else None,
storefront=storefront, language=language, requested_platform=_text(intent.get("platform")),
bundle_id=_text(lockup.get("bundleId")), subtitle=_text(lockup.get("subtitle")),
compatibility=_compatibility(shelves), phone_shelves=[], media_parse_complete=False,
platforms=[p.strip().lower() for p in _list(data.get("appPlatforms")) if isinstance(p, str)],
warnings=warnings)
common_shelves = ("description", "information", "informationRibbon", "mostRecentVersion",
"productRatings", "privacyHeader")
if (len(shelves) > _MAX_SHELVES
or any(len(_list(_dict(shelves.get(key)).get("items"))) > _MAX_ITEMS for key in common_shelves)
or any(len(_list(_dict(item).get("items"))) > _MAX_ITEMS
for item in _list(_dict(shelves.get("information")).get("items")))
or any(len(_list(_dict(item).get("developerLinks"))) > _MAX_ITEMS
for item in _list(_dict(shelves.get("description")).get("items")))):
meta["parse_status"] = "parser_limit_reached"
warnings.append("parser_limit_reached")
return result
result["name"] = _text(data.get("title")) or _text(lockup.get("title"))
result["description"] = "\n\n".join(text for item in _list(_dict(shelves.get("description")).get("items"))
if (text := _text(_dict(_dict(item).get("paragraph")).get("text")))) or None
for item in _list(_dict(shelves.get("information")).get("items")):
if (_text(_dict(item).get("title")) or "").lower() == "category":
for entry in _list(_dict(item).get("items")):
text = _text(_dict(entry).get("text"))
if text and text not in result["genres"]:
result["genres"].append(text)
for item in _list(_dict(shelves.get("informationRibbon")).get("items")):
if _dict(item).get("key") == "category":
text = _text(item.get("caption"))
if text and text not in result["genres"]:
result["genres"].append(text)
matching_products = [product for product in products
if not _app_url(product.get("url")) or _app_url(product.get("url"))[0] == requested_id]
if identified:
meta.update(_extra_metadata(data, matching_products, requested_id))
for product in matching_products:
result["name"] = result["name"] or _text(product.get("name"))
result["description"] = result["description"] or _text(product.get("description"))
if not result["genres"]:
categories = product.get("applicationCategory")
result["genres"] = [value for category in (categories if isinstance(categories, list) else [categories])
if (value := _text(category))]
if not identified:
if mismatch:
result["evidence"].append("product_identity_mismatch")
elif selected:
result["evidence"].append("product_identity_unverified")
return result
languages = [value for value in (document.language, _text(intent.get("language"))) if value]
storefronts = [value for value in (storefront,) if value]
for url in (document.canonical, data.get("canonicalURL")):
if _app_url(url):
storefronts.append(urlsplit(url).path.split("/")[1])
if any(value.lower() != "us" for value in storefronts):
meta["parse_status"] = "non_us_storefront"
return result
if any(not re.fullmatch(r"en(?:-[a-z0-9]+)*", value, re.I) for value in languages):
meta["parse_status"] = "non_english_locale"
return result
if not storefronts or not languages:
meta["parse_status"] = "locale_unknown"
return result
result["page_locale_verified"] = True
for key, shelf in shelves.items():
device = re.match(r"^product_media_([^_]+)(?:_|$)", key)
key_phone = bool(device and device.group(1) in _PHONE)
if not isinstance(shelf, dict):
if key_phone:
warnings.append("invalid_phone_shelf:" + key)
continue
platform = _text(_dict(_dict(shelf.get("contentsMetadata")).get("platform")).get("appPlatform"))
platform = platform.lower() if platform else None
if not key_phone and platform not in _PHONE:
continue
if ((key_phone and platform is not None and platform not in _PHONE)
or (platform in _PHONE and device and not key_phone)):
warnings.append("conflicting_platform_shelf:" + key)
continue
meta["phone_shelves"].append(key)
result["evidence"].append("phone_media_shelf:" + key)
items = shelf.get("items")
if not isinstance(items, list) or len(items) > _MAX_ITEMS:
warnings.append("invalid_phone_shelf:" + key)
continue
for shelf_item_index, item in enumerate(items):
if not isinstance(item, dict):
warnings.append("invalid_phone_artwork:" + key)
continue
if "screenshot" not in item:
continue
shot = _phone_artwork(item["screenshot"], len(result["screenshots"]))
if shot is None:
warnings.append("invalid_phone_artwork:" + key)
else:
shot.update(shelf_key=key, shelf_item_index=shelf_item_index)
result["screenshots"].append(shot)
platforms = meta["platforms"]
raw_platforms = _list(data.get("appPlatforms"))
known_nonphone_platforms = bool(platforms and len(platforms) == len(raw_platforms)
and all(p in _OTHER_PLATFORMS for p in platforms))
compatibility = meta["compatibility"]
phone_platform = any(platform in _PHONE for platform in platforms)
phone_compatibility = any(re.search(r"\biphone\b", row["platform"] or "", re.I) for row in compatibility)
if phone_platform:
result["evidence"].append("appPlatforms:phone")
if phone_compatibility:
result["evidence"].append("iphone_compatibility_without_phone_platform" if known_nonphone_platforms
else "compatibility:phone")
media_errors = any(w.startswith(("invalid_phone_", "conflicting_platform_shelf:", "parser_limit_reached",
"invalid_server_json", "invalid_ld_json", "html_parse_error"))
for w in warnings)
meta["media_parse_complete"] = meta["is_incomplete"] is False and not media_errors
if known_nonphone_platforms and not meta["phone_shelves"] and meta["media_parse_complete"]:
# Watch-only listings can require a paired iPhone without offering an
# iPhone app. The explicit platform list takes precedence over that
# compatibility requirement, but never over real phone media.
result["phone_supported"] = False
result["evidence"].append("complete_appPlatforms_without_phone")
elif known_nonphone_platforms and not result["screenshots"] and not meta["media_parse_complete"]:
# Missing media on an incomplete page, or broken/conflicting phone
# shelves, cannot establish either positive or negative availability.
pass
elif phone_platform or meta["phone_shelves"] or (phone_compatibility and not raw_platforms):
result["phone_supported"] = True
if not meta["phone_shelves"]:
warnings.append("missing_phone_media_shelf")
meta["media_parse_complete"] = False
if platforms and not phone_platform:
warnings.append("phone_evidence_conflicts_with_appPlatforms")
meta["media_parse_complete"] = False
elif meta["media_parse_complete"]:
if not raw_platforms and compatibility and all(
(row["platform"] or "").replace("\u00a0", " ").lower() in _OTHER_COMPATIBILITY for row in compatibility):
result["phone_supported"] = False
result["evidence"].append("complete_compatibility_without_phone")
related = {}
for link in document.links:
app = _app_url(link)
if app and app[0] != requested_id:
related.setdefault(*app)
result["related_apps"] = [{"app_id": app_id, "url": url} for app_id, url in related.items()]
meta["warnings"] = list(dict.fromkeys(warnings))
return result
# App metadata collection command.
def read_ids(path):
seen = set()
for line in Path(path).read_text().splitlines():
line = line.strip()
if not line or line.startswith('#'):
continue
if line.startswith('{'):
line = str(json.loads(line)['app_id'])
match = re.fullmatch(r'\d+', line) or re.search(r'/id(\d+)', line)
if not match:
raise ValueError(f'Expected numeric App ID or App Store URL: {line}')
app_id = match.group(1) if match.lastindex else match.group(0)
# Deduplicate app requests only; screenshot positions are never merged.
if app_id not in seen:
seen.add(app_id)
yield app_id
def main():
parser = argparse.ArgumentParser(description=__doc__)
parser.add_argument('--app-ids', required=True, type=Path, help='Text IDs/URLs, one per line; apps.jsonl is also accepted')
parser.add_argument('--output', required=True, type=Path, help='Candidate metadata JSONL; use a new path for a new acquisition')
parser.add_argument('--cache', type=Path, help='Raw HTML response cache; defaults beside output')
parser.add_argument('--delay', type=float, default=0.3)
parser.add_argument('--timeout', type=float, default=45)
parser.add_argument('--limit', type=int)
args = parser.parse_args()
cache = args.cache or args.output.parent / 'cache'
cache.mkdir(parents=True, exist_ok=True)
args.output.parent.mkdir(parents=True, exist_ok=True)
with args.output.open('x') as output:
for index, app_id in enumerate(read_ids(args.app_ids)):
if args.limit is not None and index >= args.limit:
break
url = f'https://apps.apple.com/us/app/id{app_id}?l=en-US&platform=watch'
fetched_at = datetime.now(timezone.utc).isoformat()
try:
request = Request(url, headers={'User-Agent': 'Mozilla/5.0 PhoneWatchUI/1.0', 'Accept-Language': 'en-US,en;q=0.9'})
with urlopen(request, timeout=args.timeout) as response:
body = response.read()
metadata = {'requested_url': url, 'final_url': response.url, 'http_status': response.status,
'content_type': response.headers.get('Content-Type'), 'fetched_at': fetched_at}
key = hashlib.sha256(url.encode()).hexdigest()
(cache / f'{key}.gz').write_bytes(gzip.compress(body))
write_json(cache / f'{key}.json', metadata)
html = body.decode('utf-8')
watch = parse_product(html, app_id)
phone = parse_phone_product(html, app_id)
for manifest in (watch, phone):
manifest['response'] = metadata
manifest['collected_at'] = fetched_at
manifest['requested_storefront'] = 'us'
manifest['requested_locale'] = 'en-US'
row = {'app_id': app_id, 'store': 'apple_store', 'title': watch.get('name'), 'description': watch.get('description'),
'source_url': url, 'watch_selection': {'selected': watch.get('watch_supported') is True,
'evidence': watch.get('evidence', []), 'method': 'explicit_product_page_platform_evidence'},
'metadata': {'watch_manifest': watch, 'phone_manifest': phone}, 'metadata_download_status': 'downloaded'}
except Exception as error:
row = {'app_id': app_id, 'store': 'apple_store', 'title': None, 'description': None, 'source_url': url,
'watch_selection': {'selected': None, 'evidence': [], 'method': 'explicit_product_page_platform_evidence'},
'metadata': {}, 'metadata_download_status': 'failed', 'error': type(error).__name__}
dump_line(output, row)
output.flush()
print(json.dumps({'app_id': app_id, 'status': row['metadata_download_status']}), flush=True)
time.sleep(max(args.delay, 0))
if __name__ == '__main__':
main()