Download google_play/script/image_download.py from Jl-wei/PhoneWatchUI: direct link, hf CLI and curl.
- Browser
- Download file 6.77 kB
-
https://huggingface.co/datasets/Jl-wei/PhoneWatchUI/resolve/main/google_play/script/image_download.py
- Command line
-
hf download hf://datasets/Jl-wei/PhoneWatchUI/google_play/script/image_download.py
-
curl -L -o image_download.py https://huggingface.co/datasets/Jl-wei/PhoneWatchUI/resolve/main/google_play/script/image_download.py
6.77 kB
| #!/usr/bin/env python3 | |
| """Download original Google Play gallery positions without assigning devices. | |
| Repeated URLs and bytes receive separate files. Run device_filter.py on the | |
| resulting images.jsonl to add the public device labels after downloading. | |
| """ | |
| import argparse | |
| import hashlib | |
| import io | |
| import json | |
| from pathlib import Path | |
| import time | |
| from urllib.parse import urlsplit, urlunsplit | |
| from PIL import Image | |
| import requests | |
| from app_collect import clean_app, read_jsonl, write_line | |
| EXTENSIONS = {"PNG":"png", "JPEG":"jpg", "WEBP":"webp", "GIF":"gif", "MPO":"mpo"} | |
| MAX_BYTES = 40 * 1024 * 1024 | |
| def native_url(url): | |
| parts = urlsplit(url) | |
| if parts.scheme != "https" or parts.hostname not in {"play-lh.googleusercontent.com", "lh3.googleusercontent.com"}: | |
| raise ValueError("Unsupported screenshot CDN URL") | |
| return urlunsplit((parts.scheme, parts.netloc, parts.path.split("=", 1)[0] + "=s0", "", "")) | |
| def inspect_bytes(data): | |
| if len(data) > MAX_BYTES: | |
| raise ValueError("Image byte limit") | |
| with Image.open(io.BytesIO(data)) as image: | |
| width, height = image.size | |
| fmt = image.format | |
| frames = getattr(image, "n_frames", 1) | |
| if fmt not in EXTENSIONS or not 1 <= frames <= 16 or min(width, height) <= 0 or width * height > 40_000_000: | |
| raise ValueError("Image format, dimensions, or frame limit") | |
| image.verify() | |
| pixels = 0 | |
| with Image.open(io.BytesIO(data)) as image: | |
| for frame in range(frames): | |
| image.seek(frame) | |
| pixels += image.width * image.height | |
| if image.width * image.height > 40_000_000 or pixels > 80_000_000: | |
| raise ValueError("Image pixel limit") | |
| image.load() | |
| return {"width":width, "height":height, "format":fmt, "sha256":hashlib.sha256(data).hexdigest(), "size_bytes":len(data)} | |
| def fetch_bytes(session, url): | |
| data = bytearray() | |
| with session.get(url, timeout=(15, 60), stream=True) as response: | |
| response.raise_for_status() | |
| for chunk in response.iter_content(128 * 1024): | |
| data.extend(chunk) | |
| if len(data) > MAX_BYTES: | |
| raise ValueError("Image byte limit") | |
| return bytes(data) | |
| def app_folder(app_id): | |
| # Always add a suffix for fresh downloads; avoids case-fold collisions. | |
| return app_id + "__" + hashlib.sha256(app_id.encode()).hexdigest()[:10] | |
| def screenshot_positions(metadata): | |
| """Accept the frozen scraper schema and the bundled live parser schema.""" | |
| for ordinal, value in enumerate(metadata.get("screenshots", [])): | |
| if isinstance(value, str): | |
| yield ordinal, value | |
| elif isinstance(value, dict): | |
| for position in value.get("source_gallery_indices", [value.get("index", ordinal)]): | |
| yield position, value["url"] | |
| def image_row(app_id, position, *, width=None, height=None, image_path=None, | |
| source_url=None, sha256=None): | |
| """Build one unclassified gallery-position record for device_filter.py.""" | |
| return { | |
| "image_id": f"google_play:{app_id}:screenshots:{position}", | |
| "app_id": app_id, "store": "google_play", "gallery": "screenshots", | |
| "position": position, "image_path": image_path, | |
| "width": width, "height": height, | |
| "aspect_ratio": width / height if width and height else None, | |
| "source_url": source_url, "sha256": sha256, | |
| } | |
| def main(): | |
| parser = argparse.ArgumentParser(description=__doc__) | |
| parser.add_argument("--apps", type=Path, required=True) | |
| parser.add_argument("--output", type=Path, required=True, help="A fresh dataset directory.") | |
| parser.add_argument("--interval", type=float, default=0.2) | |
| parser.add_argument("--attempts", type=int, default=3) | |
| parser.add_argument("--limit", type=int, help="Download only this many positions; retain remaining positions without files.") | |
| args = parser.parse_args() | |
| if args.attempts < 1 or (args.limit is not None and args.limit < 0): | |
| parser.error("Invalid attempts or limit") | |
| if (args.output / "images.jsonl").exists() or (args.output / "images").exists(): | |
| parser.error("Choose a fresh output directory to preserve existing data.") | |
| args.output.mkdir(parents=True, exist_ok=True) | |
| app_output = args.output / "apps.jsonl" | |
| if args.apps.resolve() != app_output.resolve(): | |
| if app_output.exists(): | |
| parser.error("apps.jsonl already exists and differs from --apps") | |
| (args.output / "images").mkdir() | |
| session = requests.Session() | |
| attempted = 0 | |
| with (args.output / "images.jsonl").open("x", encoding="utf-8") as output: | |
| for app in read_jsonl(args.apps): | |
| app_id = app["app_id"] | |
| for position, source_url in screenshot_positions(app.get("metadata", app)): | |
| record = image_row(app_id, position, source_url=source_url) | |
| if args.limit is None or attempted < args.limit: | |
| attempted += 1 | |
| for attempt in range(args.attempts): | |
| try: | |
| url = native_url(source_url) | |
| data = fetch_bytes(session, url) | |
| info = inspect_bytes(data) | |
| relative = f"images/{app_folder(app_id)}/{position:04d}.{EXTENSIONS[info['format']]}" | |
| path = args.output / relative | |
| path.parent.mkdir(parents=True, exist_ok=True) | |
| with path.open("xb") as image_file: | |
| image_file.write(data) | |
| record = image_row(app_id, position, | |
| width=info["width"], height=info["height"], source_url=source_url, | |
| image_path=relative, sha256=info["sha256"]) | |
| break | |
| except (requests.RequestException, OSError, ValueError, SyntaxError): | |
| if attempt + 1 < args.attempts: | |
| time.sleep(2 ** attempt) | |
| time.sleep(max(0, args.interval)) | |
| write_line(output, record) | |
| output.flush() | |
| # Sanitize only after reading the selected records: --apps is allowed to | |
| # name output/apps.jsonl itself. Keep all apps in limited image runs. | |
| temporary_apps = args.output / "apps.jsonl.public.tmp" | |
| with temporary_apps.open("x", encoding="utf-8") as output: | |
| for app in read_jsonl(args.apps): | |
| write_line(output, clean_app(app)) | |
| temporary_apps.replace(app_output) | |
| print(json.dumps({"attempted_positions":attempted, "manifest":str(args.output / "images.jsonl")})) | |
| if __name__ == "__main__": | |
| main() | |