airmate-navdata-sync 0.2.0__py3-none-any.whl

airmate_navdata_sync-0.2.0.dist-info/METADATA

@@ -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.dist-info/RECORD

@@ -0,0 +1,14 @@
+navdata_sync/__init__.py,sha256=hK23J6VmGu6ROH2_2ZtP6NmrHhYOn4Oviobpzs_yc1k,77
+navdata_sync/__main__.py,sha256=SCuGk-L-bb1zLj15YeA4J9PvoYe60R0p2hiL5YDrvuo,51
+navdata_sync/catalog.py,sha256=_Lbay5KooI8DTM2f0Yo2hbI4C-5Say130GxsjQ7lU-w,2471
+navdata_sync/cli.py,sha256=2gv1jOf-DRjesh8RDWF2YQcfuw4zAJrSNcFL0FScYM4,3492
+navdata_sync/config.py,sha256=64BeMisTUfXyGlLJigBV1mUCXCTzXrbBge6SIHVzGTA,7571
+navdata_sync/download.py,sha256=Op8qM9fqRIvs7IGV4EP3xDqz320Bio9yuRpsB-4Zd9Q,4554
+navdata_sync/prepare.py,sha256=mkSYjnq9zJ2E4-8DbeYIJJCd15YnByfu1UtLgRHIbXE,1817
+navdata_sync/usb.py,sha256=fp-mzA6Gqh5GfvW3MuUj3qim5s475HF5v_4tfk4lcMY,10592
+navdata_sync/config.example.toml,sha256=SA9zbOZKwybyePGH014dSfcsAipDtLuSTNuBFvEc-i8,2677
+airmate_navdata_sync-0.2.0.dist-info/METADATA,sha256=T6oMKnTVlvWv7-d_CWUBybCnXrjzSIS2diClX473BWs,7944
+airmate_navdata_sync-0.2.0.dist-info/WHEEL,sha256=THafob7ofN-NsuMN7Mg4qZyHaQI7KkD-QlcQatYhXPo,87
+airmate_navdata_sync-0.2.0.dist-info/entry_points.txt,sha256=LN6qy6Jt94INAct2TYi-B_QAkKdxZVvje0MhwetKE7E,57
+airmate_navdata_sync-0.2.0.dist-info/licenses/LICENSE,sha256=_bMIXIy67bjWeWdYt-iEMNjXF__qRwXIFhdn2s_Irzc,1071
+airmate_navdata_sync-0.2.0.dist-info/RECORD,,

airmate_navdata_sync-0.2.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.32.3
+Root-Is-Purelib: true
+Tag: py3-none-any

airmate_navdata_sync-0.2.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+navdata-update = navdata_sync.cli:main

airmate_navdata_sync-0.2.0.dist-info/licenses/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.

navdata_sync/__init__.py

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

navdata_sync/__main__.py

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

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

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

navdata_sync/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",
+]

navdata_sync/config.py

@@ -0,0 +1,210 @@
+"""Loading and validation of config.toml.
+
+Everything that identifies a particular subscription or machine lives in the
+config file, never in the code: the Airmate customer id, the Dynon serial, the
+AIRAC cycle and the local paths. See config.example.toml for the reference.
+"""
+from __future__ import annotations
+
+import os
+import shutil
+import tomllib
+from dataclasses import dataclass
+from pathlib import Path
+
+APP_NAME = "navdata-sync"
+PACKAGE_DIR = Path(__file__).resolve().parent
+CHECKOUT_ROOT = PACKAGE_DIR.parent  # the repository root, in a git checkout
+
+ID_ENV = "AIRMATE_ID"
+SERIAL_ENV = "AIRMATE_SERIAL"
+
+# Values shipped in config.example.toml. Refusing them keeps a half-filled copy
+# of the example from producing a run of 404s.
+PLACEHOLDERS = frozenset({
+    "YOUR_AIRMATE_ID",
+    "000000",
+    "/run/media/YOUR_USER/LH D1000",
+    "/run/media/YOUR_USER/RH D1000",
+})
+
+
+class ConfigError(Exception):
+    """Raised when the config file is missing, unreadable or incomplete."""
+
+
+def user_config() -> Path:
+    """The per-user configuration, following the XDG base directory spec."""
+    base = os.environ.get("XDG_CONFIG_HOME") or Path.home() / ".config"
+    return Path(base) / APP_NAME / "config.toml"
+
+
+def search_path() -> list[Path]:
+    """Where an invocation without --config looks, in order.
+
+    The current directory comes first so a checkout keeps working as a
+    self-contained folder, then the per-user location for an installed copy,
+    then the checkout root so cron jobs and shell aliases need no --config.
+    """
+    candidates = [Path.cwd() / "config.toml", user_config()]
+
+    # Only a checkout has a sibling pyproject.toml; for an installed package
+    # CHECKOUT_ROOT is site-packages, which would be nonsense to suggest.
+    if (CHECKOUT_ROOT / "pyproject.toml").is_file():
+        candidates.append(CHECKOUT_ROOT / "config.toml")
+
+    return list(dict.fromkeys(candidates))
+
+
+def example_config() -> Path | None:
+    """The bundled template: beside the package, or inside it once installed."""
+    for candidate in (
+        CHECKOUT_ROOT / "config.example.toml",
+        PACKAGE_DIR / "config.example.toml",
+    ):
+        if candidate.is_file():
+            return candidate
+    return None
+
+
+def init_config(target: Path | None = None) -> Path:
+    """Copy the bundled template to target, without ever clobbering a config."""
+    target = (target or user_config()).expanduser()
+    if target.exists():
+        raise ConfigError(f"{target} already exists, leaving it alone")
+
+    example = example_config()
+    if example is None:
+        raise ConfigError("this installation is missing its config.example.toml")
+
+    target.parent.mkdir(parents=True, exist_ok=True)
+    shutil.copyfile(example, target)
+    return target
+
+
+@dataclass(frozen=True)
+class Config:
+    airmate_id: str
+    serial: str
+    base_url: str
+    cycle: str
+    plates: tuple[str, ...]
+    raster: tuple[str, ...]
+    download_dir: Path
+    prepared_dir: Path
+    usb_targets: tuple[Path, ...]
+
+
+def load(path: Path | None = None) -> Config:
+    """Read a config file, apply environment overrides and validate it.
+
+    Without an explicit path, the first file in search_path() wins.
+    """
+    if path is None:
+        searched = search_path()
+        path = next((candidate for candidate in searched if candidate.is_file()), None)
+        if path is None:
+            locations = "".join(f"      {candidate}\n" for candidate in searched)
+            raise ConfigError(
+                "no configuration file found, looked in:\n" + locations
+                + "    create one with: navdata-update --init-config"
+            )
+
+    path = path.expanduser()
+    if not path.is_file():
+        raise ConfigError(f"no config file at {path}")
+
+    try:
+        with path.open("rb") as fh:
+            raw = tomllib.load(fh)
+    except tomllib.TOMLDecodeError as exc:
+        raise ConfigError(f"{path} is not valid TOML: {exc}") from exc
+
+    airmate = _section(raw, path, "airmate")
+    data = _section(raw, path, "data")
+    paths = _section(raw, path, "paths")
+
+    # The environment wins so the two identifying values can be kept in a
+    # password manager or a shell profile instead of on disk.
+    airmate_id = os.environ.get(ID_ENV) or _string(airmate, path, "airmate", "id")
+    serial = os.environ.get(SERIAL_ENV) or _string(airmate, path, "airmate", "serial")
+
+    for name, value, env in (("id", airmate_id, ID_ENV), ("serial", serial, SERIAL_ENV)):
+        if value in PLACEHOLDERS:
+            raise ConfigError(
+                f"airmate.{name} is still the example placeholder {value!r}; "
+                f"set it in {path} or export {env}"
+            )
+
+    # Relative paths follow the config file, so the script behaves the same from
+    # any working directory (cron, a shell alias, the repo itself).
+    anchor = path.parent
+
+    return Config(
+        airmate_id=airmate_id,
+        serial=serial,
+        base_url=_string(airmate, path, "airmate", "base_url").rstrip("/"),
+        cycle=_string(data, path, "data", "cycle"),
+        plates=_string_list(data, path, "data", "plates"),
+        raster=_string_list(data, path, "data", "raster"),
+        download_dir=_path(paths, path, "paths", "download_dir", anchor),
+        prepared_dir=_path(paths, path, "paths", "prepared_dir", anchor),
+        usb_targets=_usb_targets(paths, path),
+    )
+
+
+def _section(raw: dict, path: Path, name: str) -> dict:
+    section = raw.get(name)
+    if not isinstance(section, dict):
+        raise ConfigError(f"{path} has no [{name}] section")
+    return section
+
+
+def _string(section: dict, path: Path, name: str, key: str) -> str:
+    value = section.get(key)
+    if not isinstance(value, str) or not value:
+        raise ConfigError(f"{path} is missing a non-empty {name}.{key}")
+    return value
+
+
+def _string_list(section: dict, path: Path, name: str, key: str) -> tuple[str, ...]:
+    value = section.get(key, [])
+    if not isinstance(value, list) or not all(isinstance(v, str) for v in value):
+        raise ConfigError(f"{name}.{key} in {path} must be a list of strings")
+    return tuple(value)
+
+
+def _path(section: dict, path: Path, name: str, key: str, anchor: Path) -> Path:
+    value = Path(_string(section, path, name, key)).expanduser()
+    return value if value.is_absolute() else anchor / value
+
+
+def _usb_targets(paths: dict, config_path: Path) -> tuple[Path, ...]:
+    """Accept paths.usb_target (string or list) and/or paths.usb_targets (list)."""
+    collected: list[str] = []
+    for key in ("usb_target", "usb_targets"):
+        if key not in paths:
+            continue
+        value = paths[key]
+        if value in (None, "", []):
+            continue
+        if isinstance(value, str):
+            collected.append(value)
+        elif isinstance(value, list) and all(isinstance(item, str) for item in value):
+            collected.extend(value)
+        else:
+            raise ConfigError(
+                f"paths.{key} in {config_path} must be a string or a list of strings"
+            )
+
+    resolved: list[Path] = []
+    seen: set[Path] = set()
+    for raw in collected:
+        if not raw or raw in PLACEHOLDERS:
+            continue
+        target = Path(raw).expanduser()
+        if target in seen:
+            continue
+        seen.add(target)
+        resolved.append(target)
+    return tuple(resolved)

navdata_sync/download.py

@@ -0,0 +1,130 @@
+"""Resumable, parallel downloads behind a single global progress bar."""
+from __future__ import annotations
+
+import asyncio
+from dataclasses import dataclass
+from pathlib import Path
+
+import httpx
+from tqdm import tqdm
+
+from .catalog import RemoteFile
+
+CHUNK_SIZE = 1024 * 1024
+MAX_CONNECTIONS = 4
+
+
+def human_size(n: float) -> str:
+    for unit in ("B", "KB", "MB", "GB", "TB"):
+        if n < 1024 or unit == "TB":
+            return f"{n:.1f} {unit}"
+        n /= 1024
+    raise AssertionError("unreachable")
+
+
+@dataclass
+class _Job:
+    """A file to fetch, with what is already on disk resolved up front."""
+
+    file: RemoteFile
+    dest: Path
+    remote_size: int  # 0 when the server does not advertise a content-length
+    local_size: int
+
+    @property
+    def complete(self) -> bool:
+        return bool(self.remote_size) and self.local_size >= self.remote_size
+
+
+async def run(files: list[RemoteFile], download_dir: Path) -> None:
+    download_dir.mkdir(parents=True, exist_ok=True)
+    limits = httpx.Limits(max_connections=MAX_CONNECTIONS)
+
+    async with httpx.AsyncClient(http2=True, timeout=None, limits=limits) as client:
+        jobs = await _plan(client, files, download_dir)
+
+        progress = tqdm(
+            total=sum(job.remote_size for job in jobs),
+            initial=sum(job.local_size for job in jobs),
+            unit="B",
+            unit_scale=True,
+            desc="Téléchargement global",
+        )
+        await asyncio.gather(*(_fetch(client, job, progress) for job in jobs))
+        progress.close()
+
+
+async def _plan(
+    client: httpx.AsyncClient, files: list[RemoteFile], download_dir: Path
+) -> list[_Job]:
+    sizes = await asyncio.gather(*(_remote_size(client, f.url) for f in files))
+
+    jobs = []
+    for file, remote_size in zip(files, sizes):
+        dest = download_dir / file.name
+        if file.always_refresh:
+            dest.unlink(missing_ok=True)
+        local_size = dest.stat().st_size if dest.exists() else 0
+        jobs.append(_Job(file, dest, remote_size, local_size))
+    return jobs
+
+
+async def _remote_size(client: httpx.AsyncClient, url: str) -> int:
+    try:
+        response = await client.head(url)
+        return int(response.headers.get("content-length", 0))
+    except (httpx.HTTPError, ValueError):
+        return 0
+
+
+async def _fetch(client: httpx.AsyncClient, job: _Job, progress: tqdm) -> None:
+    if job.complete:
+        tqdm.write(f"⏭️  {job.dest.name} déjà complet ({human_size(job.local_size)})")
+        return
+
+    job.dest.parent.mkdir(parents=True, exist_ok=True)
+    headers = {}
+
+    if job.local_size:
+        headers["Range"] = f"bytes={job.local_size}-"
+        remaining = human_size(job.remote_size - job.local_size) if job.remote_size else "?"
+        tqdm.write(
+            f"↩️  Reprise {job.dest.name} "
+            f"({human_size(job.local_size)}/{human_size(job.remote_size)}, "
+            f"reste {remaining})"
+        )
+    else:
+        tqdm.write(f"⬇️  Téléchargement {job.dest.name} ({human_size(job.remote_size)})")
+
+    try:
+        resumed = await _stream(client, job, headers, progress)
+
+        # A 416 means the server disagrees with our idea of the file length, so
+        # the partial file is unusable: drop it, un-count its bytes and restart.
+        if not resumed:
+            tqdm.write(f"⚠️  {job.dest.name} mismatch → re-téléchargement complet")
+            job.dest.unlink(missing_ok=True)
+            progress.update(-job.local_size)
+            job.local_size = 0
+            await _stream(client, job, {}, progress)
+
+        tqdm.write(f"✅ {job.dest.name} terminé ({human_size(job.dest.stat().st_size)})")
+
+    except httpx.HTTPError as exc:
+        tqdm.write(f"❌ Erreur téléchargement {job.dest.name}: {exc}")
+
+
+async def _stream(
+    client: httpx.AsyncClient, job: _Job, headers: dict[str, str], progress: tqdm
+) -> bool:
+    """Append (or write) the response body to disk. False on a 416 rejection."""
+    async with client.stream("GET", job.file.url, headers=headers) as response:
+        if response.status_code == httpx.codes.REQUESTED_RANGE_NOT_SATISFIABLE:
+            return False
+        response.raise_for_status()
+
+        with open(job.dest, "ab" if headers.get("Range") else "wb") as fh:
+            async for chunk in response.aiter_bytes(CHUNK_SIZE):
+                fh.write(chunk)
+                progress.update(len(chunk))
+    return True

navdata_sync/prepare.py

@@ -0,0 +1,55 @@
+"""Staging of the downloaded files into the layout the Dynon expects.
+
+The root of the USB stick looks like this:
+
+    AIRMATE_AV_DATA_EU_<cycle>_<serial>.DUP
+    AIRMATE_OBSTACLE_DATA_EU_<cycle>_<serial>.DUP
+    CHARTS-<serial>.key
+    ChartData/Plates/...
+    Raster/VFR-*.dcf
+"""
+from __future__ import annotations
+
+import shutil
+import zipfile
+from pathlib import Path
+
+from .catalog import Kind, RemoteFile
+from .usb import describe_sync, sync
+
+__all__ = ["build", "describe_sync", "sync"]
+
+
+def build(files: list[RemoteFile], download_dir: Path, prepared_dir: Path) -> list[str]:
+    """Lay the downloads out under prepared_dir. Returns the names left out."""
+    print("📦 Construction du dossier final...")
+
+    if prepared_dir.exists():
+        shutil.rmtree(prepared_dir)
+    prepared_dir.mkdir(parents=True)
+
+    missing = []
+    for file in sorted(files, key=lambda f: f.name):
+        source = download_dir / file.name
+        if not source.is_file():
+            missing.append(file.name)
+            continue
+
+        match file.kind:
+            case Kind.DATA:
+                shutil.copyfile(source, prepared_dir / file.name.upper())
+            case Kind.KEY:
+                shutil.copyfile(source, prepared_dir / file.name)
+            case Kind.PLATES:
+                print(f"📂 Extraction {file.name}")
+                with zipfile.ZipFile(source) as archive:
+                    archive.extractall(prepared_dir)
+            case Kind.RASTER:
+                raster_dir = prepared_dir / "Raster"
+                raster_dir.mkdir(exist_ok=True)
+                shutil.copyfile(source, raster_dir / file.name)
+
+    for name in missing:
+        print(f"⚠️  {name} absent du dossier de téléchargement, ignoré")
+
+    return missing

navdata_sync/usb.py

@@ -0,0 +1,314 @@
+"""Copy the staging folder onto one or more Dynon USB sticks.
+
+rsync's default size+mtime check would recopy everything because the staging
+folder is rebuilt from scratch on every run (fresh mtimes). The delta algorithm
+(--no-whole-file) is also a poor fit for flash: it turns a changed file into
+scattered block rewrites.
+
+Instead we:
+
+  * decide by content (blake2b), so only files whose bytes actually changed
+    are written
+  * write changed files in full, sequentially, in large chunks — flash likes
+    that much more than random in-place deltas, and opening the dest with
+    "wb" is still in-place (no temp copy), which matters on a nearly-full
+    FAT-32 stick
+  * drop dest files that are no longer in the staging tree
+  * run one sequential writer per stick, in parallel, so LH and RH update
+    at the same time without randomizing I/O on either device
+
+aiofile (caio thread backend) is used because vfat/USB does not reliably
+support kernel AIO / O_DIRECT; the thread pool still lets the two sticks
+overlap.
+"""
+from __future__ import annotations
+
+import asyncio
+import hashlib
+import os
+from collections.abc import Callable
+from contextlib import AsyncExitStack
+from dataclasses import dataclass
+from pathlib import Path
+
+from aiofile import async_open
+from caio.thread_aio_asyncio import AsyncioContext
+from rich.progress import (
+    BarColumn,
+    DownloadColumn,
+    Progress,
+    TaskID,
+    TextColumn,
+    TimeRemainingColumn,
+    TransferSpeedColumn,
+)
+
+# 4 MiB sequential transfers: large enough to keep a USB controller busy,
+# small enough to report progress and overlap two destinations.
+CHUNK_SIZE = 4 * 1024 * 1024
+HASH_NAME = "blake2b"
+
+
+@dataclass(frozen=True)
+class _FileInfo:
+    rel: Path
+    size: int
+    digest: bytes
+
+
+@dataclass
+class SyncReport:
+    target: Path
+    copied: int = 0
+    skipped: int = 0
+    deleted: int = 0
+    error: str | None = None
+
+
+def relative_files(root: Path) -> list[Path]:
+    """Files under root, as paths relative to it, in a stable order."""
+    if not root.is_dir():
+        return []
+    return sorted(
+        path.relative_to(root)
+        for path in root.rglob("*")
+        if path.is_file() and not path.is_symlink()
+    )
+
+
+def prune_extras(target: Path, wanted: set[Path]) -> list[Path]:
+    """Delete dest files (and then empty dirs) that are not in the staging tree."""
+    extras = [rel for rel in relative_files(target) if rel not in wanted]
+    for rel in extras:
+        (target / rel).unlink(missing_ok=True)
+    for directory in sorted(
+        (path for path in target.rglob("*") if path.is_dir()),
+        key=lambda path: len(path.parts),
+        reverse=True,
+    ):
+        try:
+            directory.rmdir()
+        except OSError:
+            pass
+    return extras
+
+
+def describe_sync(prepared_dir: Path, usb_targets: tuple[Path, ...]) -> str:
+    if not usb_targets:
+        return (
+            f"✅ Dossier prêt: {prepared_dir}\n"
+            "   Renseignez paths.usb_targets dans config.toml pour la synchronisation."
+        )
+    lines = [f"✅ Dossier prêt: {prepared_dir}", "   Cibles USB:"]
+    for target in usb_targets:
+        status = "montée" if target.is_dir() else "absente"
+        lines.append(f"   • {target} ({status})")
+    lines.append(
+        "   Relancez avec --sync pour copier "
+        "(fichiers identiques ignorés, sticks en parallèle)."
+    )
+    return "\n".join(lines)
+
+
+def sync(prepared_dir: Path, usb_targets: tuple[Path, ...]) -> int:
+    """Copy the staging folder onto every configured stick. Returns an exit code."""
+    return asyncio.run(_sync(prepared_dir, usb_targets))
+
+
+async def _sync(prepared_dir: Path, usb_targets: tuple[Path, ...]) -> int:
+    if not usb_targets:
+        print("❌ aucune cible USB dans la configuration")
+        return 1
+
+    mounted = [target for target in usb_targets if target.is_dir()]
+    missing = [target for target in usb_targets if not target.is_dir()]
+    for target in missing:
+        print(f"❌ {target} introuvable: la clé USB est-elle montée ?")
+    if not mounted:
+        return 1
+
+    source_files = relative_files(prepared_dir)
+    if not source_files:
+        print(f"❌ {prepared_dir} est vide, rien à copier")
+        return 1
+
+    async with AsyncioContext(max_requests=32) as ctx:
+        manifest = await _index_source(prepared_dir, source_files, ctx)
+        source_total = sum(info.size for info in manifest)
+        with _usb_progress() as progress:
+            task_ids = [
+                progress.add_task(
+                    description=target.name or str(target),
+                    total=max(source_total, 1),
+                    label=target.name or str(target),
+                    phase="Vérif.",
+                    current="",
+                )
+                for target in mounted
+            ]
+            reports = await asyncio.gather(*(
+                _sync_target(
+                    prepared_dir, manifest, target, ctx, progress, task_id
+                )
+                for target, task_id in zip(mounted, task_ids)
+            ))
+        print("💾 Vidage des caches disque...")
+        os.sync()
+
+    failed = False
+    for report in reports:
+        if report.error:
+            print(
+                f"❌ {report.target}: {report.error} "
+                f"({report.copied} copiés, {report.skipped} inchangés, "
+                f"{report.deleted} supprimés)"
+            )
+            failed = True
+        else:
+            print(
+                f"✅ {report.target}: "
+                f"{report.copied} copiés, {report.skipped} inchangés, "
+                f"{report.deleted} supprimés"
+            )
+    if missing:
+        failed = True
+    return 1 if failed else 0
+
+
+def _usb_progress() -> Progress:
+    """One live bar per USB stick (or a single bar for the source checksum)."""
+    return Progress(
+        TextColumn("[bold cyan]{task.fields[label]:<12}"),
+        TextColumn("{task.fields[phase]:<8}"),
+        BarColumn(bar_width=None),
+        DownloadColumn(),
+        TransferSpeedColumn(),
+        TimeRemainingColumn(),
+        TextColumn("{task.fields[current]}", style="dim", markup=False),
+        expand=True,
+        refresh_per_second=8,
+    )
+
+
+def _advance(progress: Progress, task_id: TaskID, n: int) -> None:
+    progress.update(task_id, advance=n)
+
+
+def _finish(
+    progress: Progress, task_id: TaskID, phase: str, current: str = ""
+) -> None:
+    total = 1.0
+    for task in progress.tasks:
+        if task.id == task_id:
+            total = task.total or 1
+            break
+    progress.update(task_id, phase=phase, current=current, completed=total)
+
+
+async def _index_source(
+    prepared_dir: Path, files: list[Path], ctx: AsyncioContext
+) -> list[_FileInfo]:
+    total = sum((prepared_dir / rel).stat().st_size for rel in files)
+    with _usb_progress() as progress:
+        task_id = progress.add_task(
+            "Source",
+            total=max(total, 1),
+            label="Source",
+            phase="Hash",
+            current="",
+        )
+        manifest: list[_FileInfo] = []
+        for rel in files:
+            path = prepared_dir / rel
+            size = path.stat().st_size
+            progress.update(task_id, current=str(rel), phase="Hash")
+            digest = await _digest(path, ctx, lambda n: _advance(progress, task_id, n))
+            manifest.append(_FileInfo(rel, size, digest))
+        _finish(progress, task_id, "OK")
+    return manifest
+
+
+async def _sync_target(
+    prepared_dir: Path,
+    manifest: list[_FileInfo],
+    target: Path,
+    ctx: AsyncioContext,
+    progress: Progress,
+    task_id: TaskID,
+) -> SyncReport:
+    report = SyncReport(target)
+    label = target.name or str(target)
+    wanted = {info.rel for info in manifest}
+
+    try:
+        extras = prune_extras(target, wanted)
+        report.deleted = len(extras)
+        for rel in extras:
+            progress.log(f"🗑️  [{label}] {rel}")
+
+        to_copy: list[_FileInfo] = []
+        for info in manifest:
+            dest = target / info.rel
+            progress.update(task_id, phase="Vérif.", current=str(info.rel))
+            if dest.is_file() and dest.stat().st_size == info.size:
+                digest = await _digest(
+                    dest, ctx, lambda n: _advance(progress, task_id, n)
+                )
+                if digest == info.digest:
+                    report.skipped += 1
+                    continue
+            else:
+                progress.update(task_id, advance=info.size)
+            to_copy.append(info)
+
+        if not to_copy:
+            _finish(progress, task_id, "OK")
+            return report
+
+        copy_total = sum(info.size for info in to_copy)
+        progress.reset(task_id, total=max(copy_total, 1))
+        progress.update(task_id, phase="Copie", current="")
+        for info in to_copy:
+            progress.update(task_id, phase="Copie", current=str(info.rel))
+            await _copy_file(
+                prepared_dir / info.rel,
+                target / info.rel,
+                ctx,
+                lambda n: _advance(progress, task_id, n),
+            )
+            report.copied += 1
+        _finish(progress, task_id, "OK")
+    except OSError as exc:
+        report.error = str(exc)
+        _finish(progress, task_id, "Erreur", str(exc))
+    return report
+
+
+async def _digest(
+    path: Path,
+    ctx: AsyncioContext,
+    on_bytes: Callable[[int], None] | None = None,
+) -> bytes:
+    digest = hashlib.new(HASH_NAME)
+    async with async_open(path, "rb", context=ctx) as fh:
+        async for chunk in fh.iter_chunked(CHUNK_SIZE):
+            digest.update(chunk)
+            if on_bytes is not None:
+                on_bytes(len(chunk))
+    return digest.digest()
+
+
+async def _copy_file(
+    source: Path,
+    dest: Path,
+    ctx: AsyncioContext,
+    on_bytes: Callable[[int], None],
+) -> None:
+    dest.parent.mkdir(parents=True, exist_ok=True)
+    async with AsyncExitStack() as stack:
+        src = await stack.enter_async_context(async_open(source, "rb", context=ctx))
+        out = await stack.enter_async_context(async_open(dest, "wb", context=ctx))
+        async for chunk in src.iter_chunked(CHUNK_SIZE):
+            await out.write(chunk)
+            on_bytes(len(chunk))
+        await out.flush(sync_metadata=True)