iphone2android 0.1.0__py3-none-any.whl

iphone2android/cli.py

@@ -0,0 +1,214 @@
+"""iphone2android command line."""
+from __future__ import annotations
+
+import argparse
+import json
+import sys
+from pathlib import Path
+
+from . import __version__, backup, convert, layout, media
+from .android import debloat, play
+from .android.adb import Adb
+
+
+def _open(args) -> backup.Backup:
+    udid = args.udid or _only_backup(args)
+    return backup.open_backup(udid, backup.password_from_env_or_prompt(), Path(args.work), _root(args))
+
+
+def _root(args) -> Path:
+    return Path(args.backup_root) if args.backup_root else backup.DEFAULT_ROOT
+
+
+def _only_backup(args) -> str:
+    found = backup.backups(_root(args))
+    if len(found) != 1:
+        sys.exit(f"found {len(found)} backups; pass --udid (see `iphone2android backups`)")
+    return found[0]["udid"]
+
+
+def cmd_backups(args) -> int:
+    for b in backup.backups(_root(args)):
+        print(f"{b['udid']}  {b['name']} ({b['model']}, iOS {b['ios']})  {b['apps']} apps  {b['date']}")
+    return 0
+
+
+def cmd_apps(args) -> int:
+    for a in sorted(backup.installed_apps(args.udid or _only_backup(args), _root(args))):
+        print(a)
+    return 0
+
+
+def cmd_extract(args) -> int:
+    b = _open(args)
+    out = Path(args.work)
+    for label, dest, path in backup.extract_known(b, out):
+        print(f"{'ok' if path else '--'}  {label:20s} {('-> ' + dest) if path else 'not in this backup'}")
+    if args.inventory:
+        (out / "inventory.json").write_text(json.dumps(b.inventory(), indent=1))
+        print(f"inventory written to {out / 'inventory.json'}")
+    return 0
+
+
+def cmd_convert(args) -> int:
+    for name, n, err in convert.convert_all(Path(args.work), Path(args.out)):
+        print(f"{name:10s} {n if n is not None else 'FAILED ' + err}")
+    return 0
+
+
+def cmd_layout(args) -> int:
+    ios = layout.read_iconstate(Path(args.iconstate))
+    if not args.mapping:
+        print(json.dumps(ios, indent=1, ensure_ascii=False))
+        return 0
+    android, missing = layout.to_android(ios, layout.load_json(Path(args.mapping)))
+    print(json.dumps(android, indent=1, ensure_ascii=False))
+    if missing:
+        print(f"no Android mapping for {len(missing)} apps: " + ", ".join(missing), file=sys.stderr)
+    return 0
+
+
+def cmd_media(args) -> int:
+    b = _open(args)
+    adb = Adb(args.serial)
+    for name in args.sets:
+        domain, prefix, dest = media.SETS[name]
+        print(f"{name} -> {dest}")
+        r = media.push_set(b, adb, domain, prefix, dest)
+        print(f"  done: {r['copied']}/{r['files']} files, {len(r['failed'])} failed")
+    return 0
+
+
+def cmd_verify(args) -> int:
+    mapping = layout.load_json(Path(args.mapping))
+    bad = 0
+    for bundle, m in sorted(mapping.items()):
+        pkg = m.get("package")
+        if not pkg:
+            continue
+        ok = play.listed(pkg)
+        bad += ok is not True
+        print(f"{'ok  ' if ok else 'MISSING' if ok is False else 'ERROR'}  {pkg:45s} {bundle}")
+    return 1 if bad else 0
+
+
+def cmd_install(args) -> int:
+    adb = Adb(args.serial)
+    packages = layout.packages_in(layout.load_json(Path(args.mapping))) if args.mapping else args.packages
+    failed = 0
+    for i, pkg in enumerate(packages, 1):
+        r = play.install(adb, pkg)
+        failed += r in ("no-button", "timeout")
+        print(f"[{i}/{len(packages)}] {pkg}: {r}", flush=True)
+    return 1 if failed else 0
+
+
+def cmd_debloat(args) -> int:
+    adb = Adb(args.serial)
+    packages = [p.strip() for p in Path(args.list).read_text().splitlines() if p.strip() and not p.startswith("#")]
+    keep = set(layout.packages_in(layout.load_json(Path(args.keep_mapping)))) if args.keep_mapping else set()
+    for pkg, r in debloat.remove(adb, packages, keep, dry_run=args.dry_run).items():
+        print(f"{r:14s} {pkg}")
+    return 0
+
+
+def _builder(args):
+    from .android.build import Builder
+    from .android.launcher import Launcher
+
+    return Builder(Launcher(Adb(args.serial)), Path(args.state) if args.state else None)
+
+
+def cmd_build(args) -> int:
+    lay = layout.load_json(Path(args.layout))
+    b = _builder(args)
+    b.l.set_autofill(False)
+    b.build(lay)
+    ok = b.order_all(lay)
+    if args.autofill:
+        b.l.set_autofill(True)
+    return 0 if ok else 1
+
+
+def cmd_order(args) -> int:
+    return 0 if _builder(args).order_all(layout.load_json(Path(args.layout))) else 1
+
+
+def cmd_autofill(args) -> int:
+    from .android.launcher import Launcher
+
+    print(Launcher(Adb(args.serial)).set_autofill(args.state == "on"))
+    return 0
+
+
+def main(argv: list[str] | None = None) -> int:
+    p = argparse.ArgumentParser(prog="iphone2android", description="Move from an iPhone to an Android phone.")
+    p.add_argument("--version", action="version", version=f"iphone2android {__version__}")
+    p.add_argument("--backup-root", help="folder that holds the backups (default: the Finder location on macOS)")
+    p.add_argument("--udid", help="which backup (default: the only one)")
+    p.add_argument("--work", default="extracted", help="where decrypted files go (default: ./extracted)")
+    p.add_argument("--serial", help="adb serial of the phone, when more than one is connected")
+    sub = p.add_subparsers(dest="cmd", required=True)
+
+    sub.add_parser("backups", help="list the backups on this computer").set_defaults(fn=cmd_backups)
+    sub.add_parser("apps", help="bundle ids of the apps in a backup (no password needed)").set_defaults(fn=cmd_apps)
+
+    s = sub.add_parser("extract", help="decrypt the backup and copy out the useful databases")
+    s.add_argument("--inventory", action="store_true", help="also write files and bytes per domain")
+    s.set_defaults(fn=cmd_extract)
+
+    s = sub.add_parser("convert", help="turn the extracted databases into Android and Google formats")
+    s.add_argument("--out", default="android-import")
+    s.set_defaults(fn=cmd_convert)
+
+    s = sub.add_parser("layout", help="read IconState.plist; with --mapping, write an Android layout")
+    s.add_argument("iconstate")
+    s.add_argument("--mapping")
+    s.set_defaults(fn=cmd_layout)
+
+    s = sub.add_parser("media", help="copy media from the backup to the phone over adb")
+    s.add_argument("sets", nargs="+", choices=sorted(media.SETS))
+    s.set_defaults(fn=cmd_media)
+
+    s = sub.add_parser("verify", help="check every package in a mapping file exists on the Play Store")
+    s.add_argument("mapping")
+    s.set_defaults(fn=cmd_verify)
+
+    s = sub.add_parser("install", help="install free apps through the Play Store app")
+    s.add_argument("packages", nargs="*")
+    s.add_argument("--mapping", help="install every package in a mapping file")
+    s.set_defaults(fn=cmd_install)
+
+    s = sub.add_parser("debloat", help="remove preinstalled apps listed in a file (reversible)")
+    s.add_argument("list")
+    s.add_argument("--keep-mapping", help="never remove a package that appears in this mapping file")
+    s.add_argument("--dry-run", action="store_true")
+    s.set_defaults(fn=cmd_debloat)
+
+    for name, fn, text in (("build", cmd_build, "build the home screen from a layout file"),
+                           ("order", cmd_order, "put each page of the home screen in the layout's order")):
+        s = sub.add_parser(name, help=text)
+        s.add_argument("layout")
+        s.add_argument("--state", help="progress file, so an interrupted build continues")
+        if name == "build":
+            s.add_argument("--autofill", action="store_true", help="turn Icon autofill on at the end to pack the grid")
+        s.set_defaults(fn=fn)
+
+    s = sub.add_parser("autofill", help="turn the launcher's Icon autofill on or off")
+    s.add_argument("state", choices=["on", "off"])
+    s.set_defaults(fn=cmd_autofill)
+
+    args = p.parse_args(argv)
+    from .android.adb import DeviceUnavailable
+
+    try:
+        return args.fn(args)
+    except DeviceUnavailable as e:
+        print(f"the phone did not answer adb: {e}", file=sys.stderr)
+        return 3
+    except KeyboardInterrupt:
+        return 130
+
+
+if __name__ == "__main__":
+    sys.exit(main())

iphone2android/convert.py

@@ -0,0 +1,208 @@
+"""Turn the extracted iPhone databases into files Android and Google can import.
+
+    sms.db                  -> sms_backup.xml     (SMS Backup & Restore)
+    CallHistory.storedata   -> calls_backup.xml   (SMS Backup & Restore)
+    AddressBook.sqlitedb    -> contacts.vcf       (Google Contacts)
+    Calendar.sqlitedb       -> calendar.ics       (Google Calendar)
+    Safari_Bookmarks.db     -> safari_bookmarks.html (any browser's bookmark import)
+
+Apple stores dates as seconds since 2001-01-01. Newer sms.db files use nanoseconds.
+"""
+from __future__ import annotations
+
+import datetime
+import html
+import shutil
+import sqlite3
+import subprocess
+from pathlib import Path
+
+APPLE_EPOCH = 978307200  # 2001-01-01 in unix seconds
+
+
+def _open(path: Path) -> sqlite3.Connection:
+    c = sqlite3.connect(f"file:{path}?mode=ro", uri=True)
+    c.text_factory = lambda b: b.decode("utf-8", "replace") if isinstance(b, bytes) else b
+    return c
+
+
+def apple_ms(value) -> int:
+    if not value:
+        return 0
+    v = int(value)
+    if v > 10**12:  # nanoseconds on newer iOS
+        v //= 1_000_000_000
+    return (v + APPLE_EPOCH) * 1000
+
+
+def fix_page_count(src: Path, dst: Path) -> bool:
+    """Copy a database whose header claims more pages than the file holds, with the count corrected.
+
+    This is the usual damage in an iPhone backup: Apple snapshots sms.db in the middle of a write, the
+    file is shorter than its header says, and SQLite calls it malformed. The pages that are there are
+    readable once the header agrees with the file. Returns True when the copy opens cleanly.
+    """
+    data = bytearray(src.read_bytes())
+    if len(data) < 100 or not data.startswith(b"SQLite format 3\x00"):
+        return False
+    page_size = int.from_bytes(data[16:18], "big")
+    page_size = 65536 if page_size == 1 else page_size
+    if not page_size or len(data) % page_size:
+        return False
+    data[28:32] = (len(data) // page_size).to_bytes(4, "big")
+    data[92:96] = data[24:28]  # mark the corrected count as valid for the current change counter
+    dst.write_bytes(bytes(data))
+    try:
+        con = sqlite3.connect(dst)
+        ok = con.execute("PRAGMA integrity_check").fetchone()[0] == "ok"
+        con.close()
+        return ok
+    except sqlite3.DatabaseError:
+        return False
+
+
+def recover_sms(src: Path, dst: Path) -> bool:
+    """Rebuild a truncated sms.db with sqlite3's .recover.
+
+    Apple sometimes snapshots sms.db in the middle of a write, so the backup holds fewer pages than
+    the file's header declares and SQLite refuses to open it. .recover reads what is there.
+    """
+    if not shutil.which("sqlite3"):
+        return False
+    dump = subprocess.run(["sqlite3", str(src), ".recover"], capture_output=True, text=True)
+    if dump.returncode != 0 or not dump.stdout:
+        return False
+    if dst.exists():
+        dst.unlink()
+    load = subprocess.run(["sqlite3", str(dst)], input=dump.stdout, capture_output=True, text=True)
+    return load.returncode == 0 and dst.exists()
+
+
+def sms(src_dir: Path, out_dir: Path) -> int:
+    src = src_dir / "sms_recovered.db"
+    if not src.exists():
+        src = src_dir / "sms.db"
+        try:
+            _open(src).execute("PRAGMA integrity_check").fetchone()
+        except sqlite3.DatabaseError:
+            fixed = src_dir / "sms_recovered.db"
+            if not (fix_page_count(src, fixed) or recover_sms(src, fixed)):
+                raise RuntimeError("sms.db is damaged and could not be repaired (a sqlite3 with the .recover command may manage it)")
+            src = fixed
+    rows = _open(src).execute(
+        """SELECT m.text, m.date, m.is_from_me, h.id FROM message m
+           LEFT JOIN handle h ON m.handle_id = h.ROWID
+           WHERE m.text IS NOT NULL AND m.text != ''"""
+    ).fetchall()
+    rows = [r for r in rows if r[3]]
+    with open(out_dir / "sms_backup.xml", "w", encoding="utf-8") as f:
+        f.write(f"<?xml version='1.0' encoding='UTF-8' standalone='yes' ?>\n<smses count=\"{len(rows)}\">\n")
+        for text, date, from_me, addr in rows:
+            f.write(
+                f'  <sms protocol="0" address="{html.escape(str(addr), True)}" date="{apple_ms(date)}" '
+                f'type="{2 if from_me else 1}" subject="null" body="{html.escape(str(text), True)}" '
+                'toa="null" sc_toa="null" service_center="null" read="1" status="-1" locked="0" />\n'
+            )
+        f.write("</smses>\n")
+    return len(rows)
+
+
+def calls(src_dir: Path, out_dir: Path) -> int:
+    rows = _open(src_dir / "CallHistory.storedata").execute(
+        "SELECT ZADDRESS, ZDATE, ZDURATION, ZORIGINATED, ZANSWERED FROM ZCALLRECORD WHERE ZADDRESS IS NOT NULL"
+    ).fetchall()
+    with open(out_dir / "calls_backup.xml", "w", encoding="utf-8") as f:
+        f.write(f"<?xml version='1.0' encoding='UTF-8' standalone='yes' ?>\n<calls count=\"{len(rows)}\">\n")
+        for addr, date, dur, outgoing, answered in rows:
+            kind = 2 if outgoing else (1 if answered else 3)  # 1 incoming, 2 outgoing, 3 missed
+            f.write(
+                f'  <call number="{html.escape(str(addr), True)}" duration="{int(dur or 0)}" '
+                f'date="{int(((date or 0) + APPLE_EPOCH) * 1000)}" type="{kind}" presentation="1" />\n'
+            )
+        f.write("</calls>\n")
+    return len(rows)
+
+
+def contacts(src_dir: Path, out_dir: Path) -> int:
+    c = _open(src_dir / "AddressBook.sqlitedb")
+    n = 0
+    with open(out_dir / "contacts.vcf", "w", encoding="utf-8") as f:
+        for pid, first, last, org in c.execute("SELECT ROWID, First, Last, Organization FROM ABPerson").fetchall():
+            first, last, org = first or "", last or "", org or ""
+            # property 3 is a phone number and 4 an email address
+            values = [v[0] for v in c.execute(
+                "SELECT value FROM ABMultiValue WHERE record_id=? AND property IN (3, 4)", (pid,)
+            ).fetchall() if v[0]]
+            if not (first or last or org or values):
+                continue
+            f.write("BEGIN:VCARD\nVERSION:3.0\n")
+            f.write(f"N:{last};{first};;;\nFN:{(first + ' ' + last).strip() or org}\n")
+            if org:
+                f.write(f"ORG:{org}\n")
+            for v in values:
+                f.write(f"EMAIL;TYPE=INTERNET:{v}\n" if "@" in str(v) else f"TEL;TYPE=CELL:{v}\n")
+            f.write("END:VCARD\n")
+            n += 1
+    return n
+
+
+def _ics_time(value) -> str | None:
+    try:
+        return datetime.datetime.fromtimestamp(float(value) + APPLE_EPOCH, datetime.timezone.utc).strftime("%Y%m%dT%H%M%SZ")
+    except (TypeError, ValueError, OverflowError, OSError):
+        return None
+
+
+def _ics_text(s) -> str:
+    return str(s).replace("\\", "\\\\").replace(";", r"\;").replace(",", r"\,").replace("\n", r"\n")
+
+
+def calendar(src_dir: Path, out_dir: Path) -> int:
+    c = _open(src_dir / "Calendar.sqlitedb")
+    cols = {r[1] for r in c.execute("PRAGMA table_info(CalendarItem)")}
+    sel = ["ROWID", "summary", "start_date", "end_date"] + (["description"] if "description" in cols else [])
+    n = 0
+    with open(out_dir / "calendar.ics", "w", encoding="utf-8") as f:
+        f.write("BEGIN:VCALENDAR\nVERSION:2.0\nPRODID:-//iphone2android//EN\nCALSCALE:GREGORIAN\n")
+        for r in c.execute(f"SELECT {', '.join(sel)} FROM CalendarItem WHERE summary IS NOT NULL").fetchall():
+            d = dict(zip(sel, r))
+            start, end = _ics_time(d.get("start_date")), _ics_time(d.get("end_date"))
+            if not start:
+                continue
+            f.write(f"BEGIN:VEVENT\nUID:ios-{d['ROWID']}@iphone2android\nDTSTAMP:{start}\nDTSTART:{start}\n")
+            if end:
+                f.write(f"DTEND:{end}\n")
+            f.write(f"SUMMARY:{_ics_text(d.get('summary') or '')}\n")
+            if d.get("description"):
+                f.write(f"DESCRIPTION:{_ics_text(d['description'])}\n")
+            f.write("END:VEVENT\n")
+            n += 1
+        f.write("END:VCALENDAR\n")
+    return n
+
+
+def bookmarks(src_dir: Path, out_dir: Path) -> int:
+    rows = _open(src_dir / "Safari_Bookmarks.db").execute(
+        "SELECT title, url FROM bookmarks WHERE url IS NOT NULL AND url != ''"
+    ).fetchall()
+    with open(out_dir / "safari_bookmarks.html", "w", encoding="utf-8") as f:
+        f.write('<!DOCTYPE NETSCAPE-Bookmark-file-1>\n<META HTTP-EQUIV="Content-Type" CONTENT="text/html; charset=UTF-8">\n'
+                "<TITLE>Bookmarks</TITLE>\n<H1>Bookmarks</H1>\n<DL><p>\n")
+        for title, url in rows:
+            f.write(f'    <DT><A HREF="{html.escape(str(url), True)}">{html.escape(str(title or url))}</A>\n')
+        f.write("</DL><p>\n")
+    return len(rows)
+
+
+ALL = (sms, calls, contacts, calendar, bookmarks)
+
+
+def convert_all(src_dir: Path, out_dir: Path) -> list[tuple[str, int | None, str]]:
+    out_dir.mkdir(parents=True, exist_ok=True)
+    results = []
+    for fn in ALL:
+        try:
+            results.append((fn.__name__, fn(src_dir, out_dir), ""))
+        except Exception as e:  # noqa: BLE001 - one missing database must not stop the others
+            results.append((fn.__name__, None, f"{type(e).__name__}: {e}"))
+    return results

iphone2android/layout.py

@@ -0,0 +1,73 @@
+"""The iPhone home screen, read from SpringBoard/IconState.plist, and turned into an Android layout.
+
+An iPhone layout lists bundle ids (com.spotify.client). The Android launcher is driven through its
+app drawer search, so the Android layout lists the name to search for. A mapping file joins the two:
+
+    {"com.spotify.client": {"package": "com.spotify.music", "label": "Spotify"}}
+
+`label` is what to type in the drawer search and how the icon is named on the home screen. Apps
+with no Android equivalent are left out of the target layout and listed separately.
+"""
+from __future__ import annotations
+
+import json
+import plistlib
+from pathlib import Path
+
+
+def _bundle(item) -> str | None:
+    if isinstance(item, str):
+        return item
+    if isinstance(item, dict) and "displayName" not in item:
+        return item.get("bundleIdentifier") or item.get("displayIdentifier")
+    return None
+
+
+def _entry(item):
+    """A loose app (its bundle id) or a folder {"folder": name, "apps": [...]}; None for widgets."""
+    if isinstance(item, dict) and "displayName" in item:
+        apps = [b for page in item.get("iconLists", []) for x in page if (b := _bundle(x))]
+        return {"folder": item["displayName"], "apps": apps}
+    return _bundle(item)
+
+
+def read_iconstate(path: Path) -> dict:
+    with open(path, "rb") as f:
+        d = plistlib.load(f)
+    return {
+        "dock": [e for x in d.get("buttonBar", []) if (e := _entry(x))],
+        "pages": [[e for x in page if (e := _entry(x))] for page in d.get("iconLists", [])],
+    }
+
+
+def to_android(ios_layout: dict, mapping: dict) -> tuple[dict, list[str]]:
+    """Map an iPhone layout to an Android one. Returns (layout, bundle ids with no mapping)."""
+    missing: list[str] = []
+
+    def label(bundle: str) -> str | None:
+        m = mapping.get(bundle)
+        if not m or not m.get("label"):
+            missing.append(bundle)
+            return None
+        return m["label"]
+
+    def entry(e):
+        if isinstance(e, dict):
+            apps = [a for b in e["apps"] if (a := label(b))]
+            return {"folder": e["folder"], "apps": apps} if apps else None
+        return label(e)
+
+    out = {
+        "dock": [x for e in ios_layout.get("dock", []) if (x := entry(e)) and isinstance(x, str)],
+        "pages": [[x for e in page if (x := entry(e))] for page in ios_layout.get("pages", [])],
+    }
+    out["pages"] = [p for p in out["pages"] if p]
+    return out, sorted(set(missing))
+
+
+def packages_in(mapping: dict) -> list[str]:
+    return sorted({m["package"] for m in mapping.values() if m.get("package")})
+
+
+def load_json(path: Path) -> dict:
+    return json.loads(Path(path).read_text(encoding="utf-8"))

iphone2android/media.py

@@ -0,0 +1,67 @@
+"""Copy photos and other media out of the backup and onto the phone, in batches.
+
+Each batch is decrypted to a temp folder, pushed with adb and deleted, so the computer never needs
+room for the whole camera roll.
+
+The camera roll is often already in Google Photos. These are not, and are easy to lose:
+iMessage attachments, photo edits (Mutations) and media kept inside apps.
+"""
+from __future__ import annotations
+
+import os
+import shutil
+import tempfile
+from pathlib import Path
+
+from .android.adb import Adb
+from .backup import Backup
+
+MEDIA_EXT = {".jpg", ".jpeg", ".heic", ".heif", ".png", ".mov", ".mp4", ".dng", ".cr2", ".gif",
+             ".m4v", ".webp", ".m4a", ".wav", ".aac", ".caf", ".pdf"}
+
+# name -> (domain, path prefix, destination on the phone)
+SETS = {
+    "camera-roll": ("CameraRollDomain", "Media/DCIM/", "/sdcard/DCIM/iPhone"),
+    "message-attachments": ("MediaDomain", "Library/SMS/Attachments/", "/sdcard/Pictures/iPhone_Messages"),
+    "photo-edits": ("CameraRollDomain", "Media/PhotoData/Mutations/", "/sdcard/Pictures/iPhone_PhotoEdits"),
+}
+
+
+def app_set(domain: str, dest: str) -> tuple[str, str, str]:
+    """Media kept inside one app, for example AppDomainGroup-group.net.whatsapp.WhatsApp.shared."""
+    return (domain, "", dest)
+
+
+def media_rows(b: Backup, domain: str, prefix: str) -> list[dict]:
+    rows = b.rows("flags=1 AND domain=? AND relativePath LIKE ?", (domain, prefix + "%"))
+    return [r for r in rows if os.path.splitext(r["relativePath"] or "")[1].lower() in MEDIA_EXT]
+
+
+def push_set(b: Backup, adb: Adb, domain: str, prefix: str, dest: str, batch: int = 60, log=print) -> dict:
+    rows = media_rows(b, domain, prefix)
+    adb.run("shell", "mkdir", "-p", dest)
+    done = pushed_bytes = 0
+    failed: list[str] = []
+    for i in range(0, len(rows), batch):
+        stage = Path(tempfile.mkdtemp(prefix="iphone2android-"))
+        try:
+            used: set[str] = set()
+            for r in rows[i:i + batch]:
+                name = os.path.basename(r["relativePath"])
+                if name in used:  # the same name from two folders
+                    base, ext = os.path.splitext(name)
+                    name = f"{base}_{r['fileID'][:6]}{ext}"
+                used.add(name)
+                try:
+                    p = b.copy_entry(r, stage, name)
+                    done += 1
+                    pushed_bytes += p.stat().st_size
+                except Exception as e:  # noqa: BLE001
+                    failed.append(f"{r['relativePath']}\t{type(e).__name__}")
+            p = adb.run("push", f"{stage}/.", dest + "/", timeout=3600)
+            if p.returncode != 0:
+                failed.append(f"batch {i // batch}\t{p.stderr.strip()[:80]}")
+        finally:
+            shutil.rmtree(stage, ignore_errors=True)
+        log(f"  {done}/{len(rows)} files, {pushed_bytes / 1e9:.2f} GB, {len(failed)} failed")
+    return {"files": len(rows), "copied": done, "bytes": pushed_bytes, "failed": failed}