airmate-navdata-sync 0.2.0__tar.gz

airmate_navdata_sync-0.2.0/.gitignore

@@ -0,0 +1,21 @@
+# Holds the Airmate customer id and the Dynon serial.
+config.toml
+
+# Navdata (multi-GB, licensed per subscription) and the staging tree.
+downloads/
+downloads_prepared/
+*.dup
+*.DUP
+*.dcf
+*.key
+*.mbtiles
+
+__pycache__/
+*.py[cod]
+.venv/
+venv/
+
+# Build artefacts from `python -m build`.
+dist/
+build/
+*.egg-info/

airmate_navdata_sync-0.2.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Rémy Hubscher
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

airmate_navdata_sync-0.2.0/PKG-INFO

@@ -0,0 +1,188 @@
+Metadata-Version: 2.5
+Name: airmate-navdata-sync
+Version: 0.2.0
+Summary: Download an Airmate AIRAC cycle and lay it out for a Dynon SkyView USB stick
+Project-URL: Homepage, https://github.com/Natim/skydemon-airmate-navdata-sync
+Project-URL: Source, https://github.com/Natim/skydemon-airmate-navdata-sync
+Project-URL: Issues, https://github.com/Natim/skydemon-airmate-navdata-sync/issues
+Author-email: Rémy Hubscher <remy@yampa.ai>
+License-Expression: MIT
+License-File: LICENSE
+Keywords: airac,airmate,aviation,dynon,navdata,skyview,vfr
+Classifier: Development Status :: 4 - Beta
+Classifier: Environment :: Console
+Classifier: Intended Audience :: End Users/Desktop
+Classifier: Operating System :: POSIX :: Linux
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: Scientific/Engineering :: GIS
+Classifier: Topic :: Utilities
+Requires-Python: >=3.11
+Requires-Dist: aiofile>=3.9
+Requires-Dist: httpx[http2]>=0.28
+Requires-Dist: rich>=13.9
+Requires-Dist: tqdm>=4.67
+Provides-Extra: mbtiles
+Requires-Dist: pillow>=10.0; extra == 'mbtiles'
+Description-Content-Type: text/markdown
+
+# skydemon-airmate-navdata-sync
+
+Keeps the navigation data of a Dynon SkyView up to date: it downloads an
+[Airmate](https://www.airmate.aero) AIRAC cycle, lays the files out exactly the
+way the Dynon expects them, and copies the result onto every configured USB
+stick without rewriting the gigabytes that did not change.
+
+Everything specific to a subscription or a machine — the Airmate customer id,
+the Dynon serial, the AIRAC cycle, the local paths — lives in `config.toml`,
+which is git-ignored. The code contains no ids.
+
+## Requirements
+
+- Python 3.11 or newer (the config reader uses the standard-library `tomllib`)
+- An active Airmate subscription bound to your Dynon serial
+
+## Setup
+
+Either install the release, which puts a `navdata-update` command on your PATH:
+
+```bash
+pip install airmate-navdata-sync
+navdata-update --init-config      # writes ~/.config/navdata-sync/config.toml
+```
+
+or work from a checkout, which keeps everything in one folder. `pip install -e .`
+installs the dependencies from `pyproject.toml` and links the package in place,
+so edits take effect without reinstalling:
+
+```bash
+git clone https://github.com/Natim/skydemon-airmate-navdata-sync
+cd skydemon-airmate-navdata-sync
+python3 -m venv .venv && . .venv/bin/activate
+pip install -e .
+cp config.example.toml config.toml
+```
+
+Then edit the config file. The two values you have to fill in are in the
+`[airmate]` section:
+
+- `id` — the customer id in your personal download URLs
+  (`https://www.airmate.aero/download/navdata/<id>/...`), visible on the Airmate
+  download page once logged in.
+- `serial` — the serial of the Dynon the subscription is bound to. It is the
+  number embedded in the filenames Airmate offers you, as in
+  `airmate_av_data_eu_2608_<serial>.dup` and `CHARTS-<serial>.key`.
+
+If you would rather not keep those on disk, leave the placeholders in place and
+export them instead; the environment always wins over the file:
+
+```bash
+export AIRMATE_ID=... AIRMATE_SERIAL=...
+```
+
+Every other setting is documented inline in
+[`config.example.toml`](config.example.toml).
+
+Without `--config`, the first of these that exists is used: `./config.toml`,
+then `~/.config/navdata-sync/config.toml` (honouring `XDG_CONFIG_HOME`), then
+`config.toml` at the root of a checkout.
+
+## Usage
+
+```bash
+navdata-update                 # download the configured cycle, then stage it
+navdata-update --list          # show which files the config resolves to
+navdata-update --cycle 2609    # try the next cycle without editing the config
+navdata-update --skip-download # rebuild the staging folder from the cache
+navdata-update --sync          # ...and copy it onto every configured USB stick
+```
+
+From a checkout without installing, `./navdata-update.py` and
+`python -m navdata_sync` take the same arguments.
+
+Without `--sync` the run stops after staging and prints the configured USB
+mounts, so you can inspect the result first.
+
+Downloads are resumable and run four at a time behind one global progress bar;
+interrupting the script and running it again picks up where it left off. Files
+that are already complete are skipped, with one deliberate exception: the
+`CHARTS-*.key` file is always re-fetched, because its contents change every
+cycle while its size stays identical.
+
+## Keeping the configuration current
+
+Two things drift and need a manual edit:
+
+- **`data.cycle`** — the AIRAC cycle, as `<two-digit year><two-digit cycle>`
+  (`2608` is the 8th cycle of 2026). It changes every 28 days.
+- **`data.raster`** — raster VFR charts are named after their *edition* date
+  (`VFR-FRANCE-OACI-16APR26.dcf`), which is unrelated to the AIRAC cycle. Copy
+  the new filenames from the Airmate download page when an edition is published.
+
+`--list` is the quick way to check what the current configuration points at
+before starting a multi-gigabyte download.
+
+## What ends up on the stick
+
+```
+AIRMATE_AV_DATA_EU_<cycle>_<serial>.DUP    navdata (uppercased, the Dynon is picky)
+AIRMATE_OBSTACLE_DATA_EU_<cycle>_<serial>.DUP
+CHARTS-<serial>.key                        unlocks the chart and raster layers
+ChartData/Plates/...                       approach plates, from the region zips
+Raster/VFR-*.dcf                           raster VFR charts
+```
+
+The copy checksums each file (blake2b) and writes only those whose bytes
+actually changed, in 4 MiB sequential chunks via `aiofile`. The staging folder
+is rebuilt from scratch every run, so timestamps are always new and a
+size+mtime comparison would recopy everything. Full sequential writes of
+changed files are easier on a FAT-32 stick than rsync's random block deltas,
+and opening the destination in place avoids a temp copy on a nearly-full
+volume. Several sticks (left and right SkyView) are updated in parallel, each
+with its own sequential writer.
+
+## Repository layout
+
+```
+pyproject.toml             packaging metadata, distributed as airmate-navdata-sync
+navdata-update.py          entry point for a checkout, mirrors the installed command
+config.example.toml        documented template for the git-ignored config.toml
+navdata_sync/
+  config.py                finds and validates config.toml, applies env overrides
+  catalog.py               turns the config into the list of URLs to fetch
+  download.py              resumable parallel downloader
+  prepare.py               staging into the Dynon layout
+  usb.py                   checksum-and-copy onto one or more USB sticks
+  cli.py                   argument parsing and the run sequence
+tools/
+  mbtiles_to_dcf.py        converts an MBTiles file into an Airmate-style .dcf
+```
+
+`tools/mbtiles_to_dcf.py` is a standalone experiment, not part of the update
+flow, so it ships in the source distribution and the checkout rather than in the
+wheel. It builds a `.dcf` raster layer from any MBTiles source; note that a layer
+is only displayed if a matching entry exists in `CHARTS-<serial>.key`, which the
+script cannot create. It needs Pillow, from the `mbtiles` extra
+(`pip install -e '.[mbtiles]'` in a checkout); run
+`tools/mbtiles_to_dcf.py --help` for the options.
+
+## Releasing
+
+```bash
+pip install build twine
+python -m build            # writes dist/*.whl and dist/*.tar.gz
+twine check dist/*
+twine upload dist/*
+```
+
+The version lives in `navdata_sync/__init__.py` and is read from there by the
+build backend, so bump it in that one place.
+
+## A note on the data
+
+The navdata is licensed per subscription and tied to your Dynon serial. Keep
+`config.toml`, the downloads and the staging folder out of version control —
+`.gitignore` already covers them. And, obviously: this is a personal convenience
+script, so verify on the unit that the cycle you expect is the cycle it loaded.

airmate_navdata_sync-0.2.0/README.md

@@ -0,0 +1,158 @@
+# skydemon-airmate-navdata-sync
+
+Keeps the navigation data of a Dynon SkyView up to date: it downloads an
+[Airmate](https://www.airmate.aero) AIRAC cycle, lays the files out exactly the
+way the Dynon expects them, and copies the result onto every configured USB
+stick without rewriting the gigabytes that did not change.
+
+Everything specific to a subscription or a machine — the Airmate customer id,
+the Dynon serial, the AIRAC cycle, the local paths — lives in `config.toml`,
+which is git-ignored. The code contains no ids.
+
+## Requirements
+
+- Python 3.11 or newer (the config reader uses the standard-library `tomllib`)
+- An active Airmate subscription bound to your Dynon serial
+
+## Setup
+
+Either install the release, which puts a `navdata-update` command on your PATH:
+
+```bash
+pip install airmate-navdata-sync
+navdata-update --init-config      # writes ~/.config/navdata-sync/config.toml
+```
+
+or work from a checkout, which keeps everything in one folder. `pip install -e .`
+installs the dependencies from `pyproject.toml` and links the package in place,
+so edits take effect without reinstalling:
+
+```bash
+git clone https://github.com/Natim/skydemon-airmate-navdata-sync
+cd skydemon-airmate-navdata-sync
+python3 -m venv .venv && . .venv/bin/activate
+pip install -e .
+cp config.example.toml config.toml
+```
+
+Then edit the config file. The two values you have to fill in are in the
+`[airmate]` section:
+
+- `id` — the customer id in your personal download URLs
+  (`https://www.airmate.aero/download/navdata/<id>/...`), visible on the Airmate
+  download page once logged in.
+- `serial` — the serial of the Dynon the subscription is bound to. It is the
+  number embedded in the filenames Airmate offers you, as in
+  `airmate_av_data_eu_2608_<serial>.dup` and `CHARTS-<serial>.key`.
+
+If you would rather not keep those on disk, leave the placeholders in place and
+export them instead; the environment always wins over the file:
+
+```bash
+export AIRMATE_ID=... AIRMATE_SERIAL=...
+```
+
+Every other setting is documented inline in
+[`config.example.toml`](config.example.toml).
+
+Without `--config`, the first of these that exists is used: `./config.toml`,
+then `~/.config/navdata-sync/config.toml` (honouring `XDG_CONFIG_HOME`), then
+`config.toml` at the root of a checkout.
+
+## Usage
+
+```bash
+navdata-update                 # download the configured cycle, then stage it
+navdata-update --list          # show which files the config resolves to
+navdata-update --cycle 2609    # try the next cycle without editing the config
+navdata-update --skip-download # rebuild the staging folder from the cache
+navdata-update --sync          # ...and copy it onto every configured USB stick
+```
+
+From a checkout without installing, `./navdata-update.py` and
+`python -m navdata_sync` take the same arguments.
+
+Without `--sync` the run stops after staging and prints the configured USB
+mounts, so you can inspect the result first.
+
+Downloads are resumable and run four at a time behind one global progress bar;
+interrupting the script and running it again picks up where it left off. Files
+that are already complete are skipped, with one deliberate exception: the
+`CHARTS-*.key` file is always re-fetched, because its contents change every
+cycle while its size stays identical.
+
+## Keeping the configuration current
+
+Two things drift and need a manual edit:
+
+- **`data.cycle`** — the AIRAC cycle, as `<two-digit year><two-digit cycle>`
+  (`2608` is the 8th cycle of 2026). It changes every 28 days.
+- **`data.raster`** — raster VFR charts are named after their *edition* date
+  (`VFR-FRANCE-OACI-16APR26.dcf`), which is unrelated to the AIRAC cycle. Copy
+  the new filenames from the Airmate download page when an edition is published.
+
+`--list` is the quick way to check what the current configuration points at
+before starting a multi-gigabyte download.
+
+## What ends up on the stick
+
+```
+AIRMATE_AV_DATA_EU_<cycle>_<serial>.DUP    navdata (uppercased, the Dynon is picky)
+AIRMATE_OBSTACLE_DATA_EU_<cycle>_<serial>.DUP
+CHARTS-<serial>.key                        unlocks the chart and raster layers
+ChartData/Plates/...                       approach plates, from the region zips
+Raster/VFR-*.dcf                           raster VFR charts
+```
+
+The copy checksums each file (blake2b) and writes only those whose bytes
+actually changed, in 4 MiB sequential chunks via `aiofile`. The staging folder
+is rebuilt from scratch every run, so timestamps are always new and a
+size+mtime comparison would recopy everything. Full sequential writes of
+changed files are easier on a FAT-32 stick than rsync's random block deltas,
+and opening the destination in place avoids a temp copy on a nearly-full
+volume. Several sticks (left and right SkyView) are updated in parallel, each
+with its own sequential writer.
+
+## Repository layout
+
+```
+pyproject.toml             packaging metadata, distributed as airmate-navdata-sync
+navdata-update.py          entry point for a checkout, mirrors the installed command
+config.example.toml        documented template for the git-ignored config.toml
+navdata_sync/
+  config.py                finds and validates config.toml, applies env overrides
+  catalog.py               turns the config into the list of URLs to fetch
+  download.py              resumable parallel downloader
+  prepare.py               staging into the Dynon layout
+  usb.py                   checksum-and-copy onto one or more USB sticks
+  cli.py                   argument parsing and the run sequence
+tools/
+  mbtiles_to_dcf.py        converts an MBTiles file into an Airmate-style .dcf
+```
+
+`tools/mbtiles_to_dcf.py` is a standalone experiment, not part of the update
+flow, so it ships in the source distribution and the checkout rather than in the
+wheel. It builds a `.dcf` raster layer from any MBTiles source; note that a layer
+is only displayed if a matching entry exists in `CHARTS-<serial>.key`, which the
+script cannot create. It needs Pillow, from the `mbtiles` extra
+(`pip install -e '.[mbtiles]'` in a checkout); run
+`tools/mbtiles_to_dcf.py --help` for the options.
+
+## Releasing
+
+```bash
+pip install build twine
+python -m build            # writes dist/*.whl and dist/*.tar.gz
+twine check dist/*
+twine upload dist/*
+```
+
+The version lives in `navdata_sync/__init__.py` and is read from there by the
+build backend, so bump it in that one place.
+
+## A note on the data
+
+The navdata is licensed per subscription and tied to your Dynon serial. Keep
+`config.toml`, the downloads and the staging folder out of version control —
+`.gitignore` already covers them. And, obviously: this is a personal convenience
+script, so verify on the unit that the cycle you expect is the cycle it loaded.

airmate_navdata_sync-0.2.0/config.example.toml

@@ -0,0 +1,66 @@
+# Copy this file to config.toml and fill in your own values.
+#
+#   cp config.example.toml config.toml
+#
+# config.toml is git-ignored because it holds the two values that identify your
+# Airmate subscription: the customer id and the Dynon serial it is bound to.
+
+[airmate]
+# The customer id that appears in your personal download URLs:
+#   https://www.airmate.aero/download/navdata/<id>/...
+# It is shown on the Airmate download page once you are logged in.
+# May also be supplied through the AIRMATE_ID environment variable.
+id = "YOUR_AIRMATE_ID"
+
+# Serial number of the Dynon unit the subscription is bound to. It is the
+# number embedded in the data filenames:
+#   airmate_av_data_eu_<cycle>_<serial>.dup   CHARTS-<serial>.key
+# May also be supplied through the AIRMATE_SERIAL environment variable.
+serial = "000000"
+
+# Only change this if Airmate moves its download endpoint.
+base_url = "https://www.airmate.aero/download/navdata"
+
+[data]
+# AIRAC cycle to download, as <two-digit year><two-digit cycle number>.
+# 2608 is the 8th cycle of 2026. Bump this every 28 days.
+cycle = "2608"
+
+# Approach plate bundles, published as <region>-Plates-<cycle>.zip.
+# "FR" alone is enough if you only fly in France; "Europe" is a large download.
+plates = ["FR", "Europe"]
+
+# Raster VFR charts, published under <base_url>/Raster/.
+# The trailing date is the chart *edition*, not the AIRAC cycle, so these names
+# have to be updated by hand whenever a new edition is published. Remove the
+# ones you do not need: each entry is a few hundred MB on the USB stick.
+raster = [
+    "VFR-FRANCE-OACI-16APR26.dcf",
+    "VFR-EUROPE-HIRES-14MAY26.dcf",
+    "VFR-DENMARK-NAVIAIR-14MAY26.dcf",
+    "VFR-IRELAND-01JAN24.dcf",
+    "VFR-UK-01JAN24.dcf",
+    "VFR-ITALY-16APR26.dcf",
+    "VFR-SWITZERLAND-19MAR26.dcf",
+]
+
+[paths]
+# Relative paths below are resolved next to this config file, which keeps a git
+# checkout self-contained. If this config lives in ~/.config, make them absolute
+# instead: the AIRAC cycle is several gigabytes and does not belong there.
+
+# Download cache. Partially downloaded files are resumed from here, so keeping
+# it between runs saves bandwidth.
+download_dir = "downloads"
+
+# Staging area laid out exactly like the root of the Dynon USB stick. Rebuilt
+# from scratch on every run.
+prepared_dir = "downloads_prepared"
+
+# Mount points of the Dynon USB sticks, used by --sync. One entry per unit
+# (left and right SkyView). A single string still works. Leave the list empty
+# to only build the staging directory.
+usb_targets = [
+    "/run/media/YOUR_USER/LH D1000",
+    "/run/media/YOUR_USER/RH D1000",
+]

airmate_navdata_sync-0.2.0/navdata-update.py

@@ -0,0 +1,19 @@
+#!/usr/bin/env python3
+"""Entry point kept at the repo root; the logic lives in navdata_sync/."""
+import sys
+from pathlib import Path
+
+sys.path.insert(0, str(Path(__file__).resolve().parent))
+
+try:
+    from navdata_sync.cli import main
+except ModuleNotFoundError as exc:
+    # The shebang is deliberately generic, so this is what an unactivated
+    # virtualenv looks like rather than a broken checkout.
+    raise SystemExit(
+        f"❌ dépendance manquante: {exc.name}\n"
+        "   activez votre virtualenv, ou: pip install -e ."
+    ) from exc
+
+if __name__ == "__main__":
+    raise SystemExit(main())

airmate_navdata_sync-0.2.0/navdata_sync/__init__.py

@@ -0,0 +1,3 @@
+"""Airmate navdata updater for a Dynon SkyView."""
+
+__version__ = "0.2.0"

airmate_navdata_sync-0.2.0/navdata_sync/__main__.py

@@ -0,0 +1,3 @@
+from .cli import main
+
+raise SystemExit(main())

airmate_navdata_sync-0.2.0/navdata_sync/catalog.py

@@ -0,0 +1,71 @@
+"""Turns a Config into the list of files to fetch from Airmate.
+
+Airmate publishes three kinds of URL:
+
+  <base>/<customer id>/...   subscription-bound data, one file per serial
+  <base>/Plates/...          approach plate bundles, one zip per region
+  <base>/Raster/...          raster VFR charts, shared by everyone
+"""
+from __future__ import annotations
+
+from dataclasses import dataclass
+from enum import Enum
+
+from .config import Config
+
+
+class Kind(Enum):
+    """What a file becomes on the USB stick, which decides how it is staged."""
+
+    DATA = "data"      # .dup, navdata and obstacles, uppercased at the root
+    KEY = "key"        # CHARTS-<serial>.key, unlocks the raster layers
+    PLATES = "plates"  # zip expanded at the root, creates ChartData/
+    RASTER = "raster"  # .dcf copied under Raster/
+
+
+@dataclass(frozen=True)
+class RemoteFile:
+    url: str
+    name: str
+    kind: Kind
+
+    @property
+    def always_refresh(self) -> bool:
+        """Whether a byte-identical local copy still has to be re-downloaded.
+
+        The key file changes content every AIRAC cycle (chart filenames and auth
+        codes rotate) while keeping the exact same byte size, so a size-only
+        "already complete" check would keep a stale key on disk. The Dynon then
+        silently hides every layer whose filename or code no longer matches.
+        """
+        return self.kind is Kind.KEY
+
+
+def build(config: Config) -> list[RemoteFile]:
+    account = f"{config.base_url}/{config.airmate_id}"
+    files = [
+        RemoteFile(
+            f"{account}/airmate_av_data_eu_{config.cycle}_{config.serial}.dup",
+            f"airmate_av_data_eu_{config.cycle}_{config.serial}.dup",
+            Kind.DATA,
+        ),
+        RemoteFile(
+            f"{account}/airmate_obstacle_data_eu_{config.cycle}_{config.serial}.dup",
+            f"airmate_obstacle_data_eu_{config.cycle}_{config.serial}.dup",
+            Kind.DATA,
+        ),
+        RemoteFile(
+            f"{account}/CHARTS-{config.serial}.key",
+            f"CHARTS-{config.serial}.key",
+            Kind.KEY,
+        ),
+    ]
+
+    for region in config.plates:
+        name = f"{region}-Plates-{config.cycle}.zip"
+        files.append(RemoteFile(f"{config.base_url}/Plates/{name}", name, Kind.PLATES))
+
+    for name in config.raster:
+        files.append(RemoteFile(f"{config.base_url}/Raster/{name}", name, Kind.RASTER))
+
+    return files

airmate_navdata_sync-0.2.0/navdata_sync/cli.py

@@ -0,0 +1,109 @@
+"""Command line entry point: download, stage, optionally sync."""
+from __future__ import annotations
+
+import argparse
+import asyncio
+import dataclasses
+from pathlib import Path
+
+from . import catalog, download, prepare
+from . import __version__
+from .config import ConfigError, init_config, search_path
+from .config import load as load_config
+
+
+def build_parser() -> argparse.ArgumentParser:
+    parser = argparse.ArgumentParser(
+        prog="navdata-update",
+        description="Download an Airmate AIRAC cycle and lay it out for a "
+        "Dynon SkyView USB stick.",
+    )
+    parser.add_argument("--version", action="version", version=f"%(prog)s {__version__}")
+    searched = " or ".join(str(candidate) for candidate in search_path())
+    parser.add_argument(
+        "-c",
+        "--config",
+        type=Path,
+        metavar="PATH",
+        help=f"configuration file (default: the first of {searched})",
+    )
+    parser.add_argument(
+        "--init-config",
+        action="store_true",
+        help="write a starter configuration to --config, or to the per-user "
+        "location, then exit",
+    )
+    parser.add_argument(
+        "--cycle",
+        metavar="YYCC",
+        help="override data.cycle for this run, e.g. 2609",
+    )
+    parser.add_argument(
+        "--list",
+        action="store_true",
+        help="list the files the configuration resolves to and exit",
+    )
+    parser.add_argument(
+        "--skip-download",
+        action="store_true",
+        help="rebuild the staging folder from the download cache only",
+    )
+    parser.add_argument(
+        "--sync",
+        action="store_true",
+        help="copy the staging folder onto every configured USB stick",
+    )
+    return parser
+
+
+def main(argv: list[str] | None = None) -> int:
+    args = build_parser().parse_args(argv)
+
+    if args.init_config:
+        try:
+            target = init_config(args.config)
+        except ConfigError as exc:
+            print(f"❌ {exc}")
+            return 2
+        print(
+            f"✅ Configuration créée: {target}\n"
+            "   Renseignez airmate.id et airmate.serial avant le premier run."
+        )
+        return 0
+
+    try:
+        config = load_config(args.config)
+    except ConfigError as exc:
+        print(f"❌ {exc}")
+        return 2
+
+    if args.cycle:
+        config = dataclasses.replace(config, cycle=args.cycle)
+
+    # Checked before anything is downloaded or staged, since --sync is the whole
+    # point of the run when it is passed.
+    if args.sync and not config.usb_targets:
+        print("❌ --sync demande paths.usb_target ou paths.usb_targets dans la configuration")
+        return 2
+
+    files = catalog.build(config)
+
+    if args.list:
+        for file in files:
+            print(f"{file.kind.value:>7}  {file.name}")
+        print(f"\ncycle {config.cycle} · {len(files)} fichiers · {config.download_dir}")
+        return 0
+
+    if not args.skip_download:
+        asyncio.run(download.run(files, config.download_dir))
+
+    missing = prepare.build(files, config.download_dir, config.prepared_dir)
+
+    if args.sync:
+        if missing:
+            print("❌ Synchronisation annulée: des fichiers manquent")
+            return 1
+        return prepare.sync(config.prepared_dir, config.usb_targets)
+
+    print(prepare.describe_sync(config.prepared_dir, config.usb_targets))
+    return 1 if missing else 0