easysnowdata 0.3.1__tar.gz → 0.3.2__tar.gz

{easysnowdata-0.3.1 → easysnowdata-0.3.2}/CHANGELOG.md

@@ -6,6 +6,24 @@ The format is based on [Keep a Changelog](http://keepachangelog.com/en/1.0.0/)
 and this project adheres to [Semantic Versioning](http://semver.org/spec/v2.0.0.html).
 
 <!-- insertion marker -->
+## [v0.3.1](https://github.com/egagli/easysnowdata/releases/tag/v0.3.1) - 2026-09-22
+
+<small>[Compare with v0.2.0](https://github.com/egagli/easysnowdata/compare/v0.2.0...v0.3.1)</small>
+
+### Fixed
+
+- fix(planetscope): make a real order work end to end; gallery renders a real scene ([bd25c45](https://github.com/egagli/easysnowdata/commit/bd25c45c4212db5b1a5e212dec2fe295a9f1f5d6) by egagli).
+- fix(archive): open a scheme-less store path as a local store ([d71b0ee](https://github.com/egagli/easysnowdata/commit/d71b0ee753cef56ec9fdc0dc248b85fda202b5b5) by Eric Gagliano).
+- fix(sar): never fuse Sentinel-1 geometries — one raster per relative orbit ([c9fbe53](https://github.com/egagli/easysnowdata/commit/c9fbe53433a9ed8a36edadca1f72cafe67b387d8) by egagli).
+- fix(hls): a failed band read raises instead of filling the Dataset with nodata ([101d97f](https://github.com/egagli/easysnowdata/commit/101d97f5aa482ed74c4185486dbc8a3710c4fb26) by egagli).
+- fix(auth): log in at URS with the netrc for GDAL reads whenever a password exists ([1b7a1a1](https://github.com/egagli/easysnowdata/commit/1b7a1a13a66f3e71288967e41dcc61723dac5922) by egagli).
+- fix(sar): drop the nominal Sentinel-1 heading and the constant 39° incidence angle ([736499e](https://github.com/egagli/easysnowdata/commit/736499e0fcfdef3c1f4bfdc9ea33c5417198806a) by egagli).
+- fix(snow): Terra-only MODIS mosaics from Planetary Computer; real NSIDC-0768 file names ([8bbbdbd](https://github.com/egagli/easysnowdata/commit/8bbbdbdbe6d6c11411c867b07f5d578a672233ec) by egagli).
+- fix(sar): incidence angle from each track's geometry, with the right sign; OPERA reads work ([d12dc9f](https://github.com/egagli/easysnowdata/commit/d12dc9f37684c9dfb73287c08e0c2472f11254f3) by egagli).
+- fix(health): probe Planet through the SDK, send a User-Agent on first-byte probes ([e5aeb82](https://github.com/egagli/easysnowdata/commit/e5aeb82fc28802f3539aaea69c93e3d185b32553) by egagli).
+- fix(stations): finish the transfer — format the clients, relabel the probes, refresh the archive ([fb1bf3e](https://github.com/egagli/easysnowdata/commit/fb1bf3e191e27ee7453e23830a99bd6c85731016) by egagli).
+- fix(deprecation): the shims promised removal in the release they shipped in ([24e93b5](https://github.com/egagli/easysnowdata/commit/24e93b549e928cb6cfabd103b8ae40f9d1581b07) by egagli).
+
 ## [v0.2.0](https://github.com/egagli/easysnowdata/releases/tag/v0.2.0) - 2026-09-17
 
 <small>[Compare with v0.0.26](https://github.com/egagli/easysnowdata/compare/v0.0.26...v0.2.0)</small>

{easysnowdata-0.3.1 → easysnowdata-0.3.2}/CITATION.cff

@@ -38,5 +38,5 @@ keywords:
   - snow classification
   - easysnowdata
 license: MIT
-version: v0.3.1
-date-released: '2026-09-22'
+version: v0.3.2
+date-released: '2026-09-23'

{easysnowdata-0.3.1 → easysnowdata-0.3.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: easysnowdata
-Version: 0.3.1
+Version: 0.3.2
 Summary: A Python package to easily retrieve data relevant to snow science
 Project-URL: Homepage, https://github.com/egagli/easysnowdata
 Project-URL: Documentation, https://egagli.github.io/easysnowdata

{easysnowdata-0.3.1 → easysnowdata-0.3.2}/REVAMP_PLAN.md

@@ -912,10 +912,12 @@ that artefact (its `docs/STORAGE.md` and DESIGN.md §6.5). `easysnowdata`
 reads the inventory over HTTPS at call time; `archive.load()` reads the
 store by default, fetching only the chunks a request touches (one water year
 of every station 0.7 MB, one station's whole record 0.5 MB, against the
-27 MB bundle), and falls back to the `pooch`-cached bundle with a warning
-when the store cannot be read, so a Pages outage degrades rather than fails.
-The bundle stays published until this version is on PyPI and conda-forge,
-because older pins read nothing else.
+27 MB bundle), and falls back with a warning to the bundle attached to that
+repo's latest snapshot release when the store cannot be read, so a Pages
+outage degrades to a possibly-stale snapshot rather than failing (Releases
+are served from outside Pages). The daily-committed bundle on `main` was
+retired once 0.3.2 carried this fallback; 0.2.x and 0.3.1 read that file and
+must upgrade.
 
 **What `global_snow_networks` still owes this migration** is tracked in that
 repo as [`docs/EASYSNOWDATA_MIGRATION.md`](https://github.com/egagli/global_snow_networks/blob/main/docs/EASYSNOWDATA_MIGRATION.md):

{easysnowdata-0.3.1 → easysnowdata-0.3.2}/easysnowdata/_version.py

@@ -18,7 +18,7 @@ version_tuple: tuple[int | str, ...]
 commit_id: str | None
 __commit_id__: str | None
 
-__version__ = version = '0.3.1'
-__version_tuple__ = version_tuple = (0, 3, 1)
+__version__ = version = '0.3.2'
+__version_tuple__ = version_tuple = (0, 3, 2)
 
 __commit_id__ = commit_id = None

{easysnowdata-0.3.1 → easysnowdata-0.3.2}/easysnowdata/stations/archive.py

@@ -16,10 +16,12 @@ artefacts that this module reads (§9 step 3):
     range requests, so a query fetches the chunks it touches — well under a
     megabyte for either of those — instead of the whole bundle. The default
     route.
-``data/all_station_csvs.tar.xz``
-    One ``date,wteq_cm,snwd_cm`` CSV per daily-or-better station, bundled.
-    About 28 MB, whole-file only; the route that predates the store, kept
-    so older pins keep working and as the fallback when Pages is down.
+``all_station_csvs.tar.xz`` on that repo's latest GitHub Release
+    One ``date,wteq_cm,snwd_cm`` CSV per daily-or-better station, bundled:
+    the periodic, DOI'd snapshot (a few times a year), about 28 MB and
+    whole-file only. The fallback when Pages is down, since Releases are
+    served from elsewhere — and the route to use when a result should be
+    pinned to a citable snapshot rather than to today's archive.
 
 ::
 
@@ -64,10 +66,12 @@ __all__ = [
     "MANIFEST_URL",
     "PAGES_BASE",
     "PRODUCT",
+    "RELEASES_API",
     "REPO",
     "ZARR_URLS",
     "csv_url",
     "inventory",
+    "latest_snapshot",
     "load",
     "manifest",
     "network_of",
@@ -77,7 +81,15 @@ _logger = logging.getLogger(__name__)
 
 REPO = "https://github.com/egagli/global_snow_networks"
 INVENTORY_URL = f"{REPO}/raw/main/all_snow_stations.geojson"
-ARCHIVE_URL = f"{REPO}/raw/main/data/all_station_csvs.tar.xz"
+#: The bundled CSVs of the latest snapshot release. Fixed-name asset, so this
+#: URL always resolves to the newest release; :func:`latest_snapshot` asks the
+#: API for the tag and date behind it. Until 2026-09 the bundle was a file
+#: committed daily on ``main``; that stopped once the Pages store took over
+#: the daily role (that repo's docs/STORAGE.md §3).
+ARCHIVE_URL = f"{REPO}/releases/latest/download/all_station_csvs.tar.xz"
+RELEASES_API = (
+    "https://api.github.com/repos/egagli/global_snow_networks/releases/latest"
+)
 CSV_BASE = (
     "https://raw.githubusercontent.com/egagli/global_snow_networks/main/data/stations/"
 )
@@ -100,9 +112,10 @@ _BY_STATION_LIMIT = 64
 #: output contract keeps the two-letter names the CSV columns abbreviate.
 _STORE_COLUMNS = {"swe": "wteq_cm", "snow_depth": "snwd_cm"}
 
-#: How long a downloaded bundle is trusted before it is fetched again. The
-#: archive is rebuilt daily, so a day; the inventory, read over HTTP each
-#: time, would otherwise list stations the stale bundle does not hold.
+#: How long a downloaded bundle is trusted before it is fetched again, when
+#: the release it came from could not be identified (the API was unreachable)
+#: and the cache file therefore cannot be named after its tag. A tag-named
+#: file is immutable and never re-fetched.
 ARCHIVE_MAX_AGE = 24 * 3600
 
 #: Archive CSV column -> (standardized type, units).
@@ -269,6 +282,31 @@ def _fetch_json(url: str) -> dict[str, Any]:
     return response.json()
 
 
+def latest_snapshot() -> dict[str, Any]:
+    """The newest snapshot release of ``global_snow_networks``.
+
+    ``{"tag", "published_at", "html_url", "tarball_url"}`` from the GitHub
+    releases API — the tag is what a Zenodo version DOI corresponds to, so
+    this is what to cite when a result came from the bundle. ``tarball_url``
+    is the bundled-CSV asset; ``None`` when the release carries none.
+    """
+    release = _fetch_json(RELEASES_API)
+    assets = release.get("assets") or []
+    tarball = None
+    for asset in assets:
+        name = str(asset.get("name", ""))
+        if name.startswith("all_station_csvs") and name.endswith(".tar.xz"):
+            tarball = asset.get("browser_download_url")
+            if name == "all_station_csvs.tar.xz":
+                break
+    return {
+        "tag": str(release.get("tag_name") or ""),
+        "published_at": str(release.get("published_at") or "")[:10],
+        "html_url": str(release.get("html_url") or ""),
+        "tarball_url": tarball,
+    }
+
+
 # ── reading the data ─────────────────────────────────────────────────────────
 
 
@@ -278,20 +316,53 @@ def _parse_csv(text: str, code: str) -> pd.DataFrame:
     return frame.set_index("date").sort_index()
 
 
-def _from_tarball(codes: set[str] | None) -> dict[str, pd.DataFrame]:
-    """Every wanted station's CSV, out of the one bundled archive.
+def _snapshot_tarball() -> tuple[str, dict[str, Any]]:
+    """URL of the latest snapshot's bundle, and what is known about the release.
+
+    When the releases API cannot be reached the fixed-name download URL is
+    used blind — it still resolves to the newest release — and the returned
+    metadata is empty.
+    """
+    try:
+        info = latest_snapshot()
+    except Exception as exc:  # noqa: BLE001 — the download URL works without it
+        _logger.warning(
+            "Could not read the latest snapshot release (%s); downloading the "
+            "bundle without knowing its tag.",
+            exc,
+        )
+        return ARCHIVE_URL, {}
+    return info.get("tarball_url") or ARCHIVE_URL, info
+
+
+def _from_tarball(
+    codes: set[str] | None,
+) -> tuple[dict[str, pd.DataFrame], dict[str, Any]]:
+    """Every wanted station's CSV, out of the latest snapshot's bundle.
 
-    Downloaded into the package cache by pooch and re-read from there for a
-    day (:data:`ARCHIVE_MAX_AGE`), after which the daily rebuild is fetched
-    again. ``EASYSNOWDATA_CACHE_DIR`` moves the cache root.
+    Downloaded into the package cache by pooch. A bundle whose release tag is
+    known is cached under that tag and never re-fetched; one downloaded blind
+    is re-fetched after :data:`ARCHIVE_MAX_AGE`. ``EASYSNOWDATA_CACHE_DIR``
+    moves the cache root. Returns the frames and the release metadata.
     """
+    url, info = _snapshot_tarball()
+    tag = info.get("tag")
     path = providers.raster_http.fetch(
-        ARCHIVE_URL,
-        "all_station_csvs.tar.xz",
+        url,
+        f"all_station_csvs-{tag}.tar.xz" if tag else "all_station_csvs.tar.xz",
         subdir="stations",
-        max_age=ARCHIVE_MAX_AGE,
+        max_age=None if tag else ARCHIVE_MAX_AGE,
     )
-    _logger.info("Reading the bundled station archive at %s", path)
+    if tag:
+        _logger.info(
+            "Reading the bundled station archive of snapshot %s (%s) at %s; the "
+            "daily archive on Pages may be ahead of it.",
+            tag,
+            info.get("published_at") or "date unknown",
+            path,
+        )
+    else:
+        _logger.info("Reading the bundled station archive at %s", path)
     frames: dict[str, pd.DataFrame] = {}
     with tarfile.open(path, mode="r:xz") as tar:
         for member in tar:
@@ -305,7 +376,7 @@ def _from_tarball(codes: set[str] | None) -> dict[str, pd.DataFrame]:
                 continue
             frames[code] = _parse_csv(handle.read().decode("utf-8"), code)
     _logger.info("Read %d station CSVs from the archive", len(frames))
-    return frames
+    return frames, {**info, "tarball_url": url}
 
 
 def _from_csvs(codes: list[str]) -> dict[str, pd.DataFrame]:
@@ -420,7 +491,7 @@ def load(
     time
         Any form :func:`easysnowdata.temporal.parse_time` accepts. Each
         station's series is cut to the window before the dense grid is built,
-        so a narrow window is cheap — but the bundle is still downloaded
+        so a narrow window is cheap — on the bundle route it is still downloaded
         whole, because that is how it is published.
     networks
         Keep only these networks.
@@ -432,12 +503,15 @@ def load(
         every station is one or two chunks). Its ``time`` axis is complete
         and daily between the first and last observation, and its values are
         stored as float32 (returned as float64), so they agree with the CSV
-        routes to float32 precision. When the store
-        cannot be read and no *source* was asked for, the tarball route below
-        is used instead, with a warning.
-        ``"github-tarball"`` downloads the one ~28 MB bundle and reads every
-        wanted CSV out of it; its ``time`` axis holds only days on which some
-        station observed.
+        routes to float32 precision. When the store cannot be read and no
+        *source* was asked for, the snapshot route below is used instead,
+        with a warning naming the snapshot.
+        ``"github-tarball"`` downloads the ~28 MB bundle of CSVs attached to
+        that repo's **latest snapshot release** — a few times a year, each
+        with a Zenodo DOI — and reads every wanted CSV out of it. Ask for it
+        when a result should be pinned to a citable snapshot; the Dataset's
+        ``snapshot_tag`` and ``snapshot_published_at`` say which one. Its
+        ``time`` axis holds only days on which some station observed.
         ``"github-csv"`` fetches one CSV per station instead, which needs
         neither a store nor a temporary file.
     hemisphere
@@ -500,19 +574,24 @@ def load(
             if source is not None:
                 raise
             # The store is a build artefact of a Pages deploy; the bundle is
-            # a committed file. Both hold the same observations, so a Pages
-            # outage (or a deploy that has not happened yet) degrades to a
-            # 28 MB download rather than an error (REVAMP_PLAN §9.3).
+            # a GitHub Release asset, served from elsewhere. So a Pages outage
+            # (or a deploy that has not happened yet) degrades to the latest
+            # snapshot — possibly months behind, and the warning says so —
+            # rather than to an error (REVAMP_PLAN §9.3).
+            src = product.source("github-tarball")
+            frames, snapshot = _from_tarball(set(codes) if codes is not None else None)
             _logger.warning(
-                "Could not read the chunked archive at %s (%s); reading the "
-                "bundled CSVs instead.",
+                "Could not read the chunked archive at %s (%s); read the bundled "
+                "CSVs of snapshot %s (%s) instead, which may be behind the daily "
+                "archive.",
                 ZARR_URLS[layout],
                 exc,
+                snapshot.get("tag") or "unknown",
+                snapshot.get("published_at") or "date unknown",
             )
-            src = product.source("github-tarball")
-            frames = _from_tarball(set(codes) if codes is not None else None)
             ds = _to_dataset(frames, wanted_types, codes, inv, hemisphere, window)
-            source_url = ARCHIVE_URL
+            source_url = snapshot["tarball_url"]
+            ds.attrs.update(_snapshot_attrs(snapshot))
         else:
             ds = _finish(grid, inv, hemisphere)
             source_url = ZARR_URLS[layout]
@@ -526,15 +605,25 @@ def load(
         ds = _to_dataset(frames, wanted_types, codes, inv, hemisphere, window)
         source_url = CSV_BASE
     else:
-        frames = _from_tarball(set(codes) if codes is not None else None)
+        frames, snapshot = _from_tarball(set(codes) if codes is not None else None)
         ds = _to_dataset(frames, wanted_types, codes, inv, hemisphere, window)
-        source_url = ARCHIVE_URL
+        source_url = snapshot["tarball_url"]
+        ds.attrs.update(_snapshot_attrs(snapshot))
 
     ds.attrs.update(contract.provenance(product, src, source_url=source_url))
     ds.attrs["interval"] = "daily"
     return ds
 
 
+def _snapshot_attrs(snapshot: dict[str, Any]) -> dict[str, str]:
+    """Which snapshot release a bundle-route Dataset came from, for its attrs."""
+    return {
+        "snapshot_tag": str(snapshot.get("tag") or ""),
+        "snapshot_published_at": str(snapshot.get("published_at") or ""),
+        "snapshot_url": str(snapshot.get("html_url") or ""),
+    }
+
+
 def _types(variables: Any) -> list[str]:
     known = {type_name for type_name, _ in COLUMNS.values()}
     if variables is None:
@@ -640,7 +729,8 @@ PRODUCT = Product(
         "pre-downloaded and published by global_snow_networks: a normalized "
         "station inventory as GeoJSON, a chunked Zarr store on its Pages site "
         "that a query reads only the touched chunks of, and one CSV per "
-        "station bundled into a single ~28 MB archive. The fast path for "
+        "station bundled into a single ~28 MB archive on each snapshot release. "
+        "The fast path for "
         "'everything daily' without hitting five APIs, refreshed daily. Most "
         "stations start around 1980; "
         "a few long snow courses reach back to 1896. SWE and snow depth only; for "
@@ -676,13 +766,14 @@ PRODUCT = Product(
             location=ARCHIVE_URL,
             extent="western US, western Canada, Norway, Yukon, California, BC",
             temporal="1896/present (most stations from ~1980)",
-            latency="daily rebuild",
+            latency="per snapshot release (a few times a year)",
             notes=(
-                "one ~28 MB download holding every station CSV; cached, so "
-                "the whole archive costs one request. The fallback when the "
-                "Pages store cannot be read"
+                "one ~28 MB download holding every station CSV of the latest "
+                "snapshot release (each has a Zenodo DOI); cached per tag. The "
+                "citable route, and the fallback when the Pages store cannot "
+                "be read"
             ),
-            title="global_snow_networks bundled archive",
+            title="global_snow_networks snapshot bundle (latest release)",
             # The inventory and CSV probes were once labelled "SNOTEL/CCSS …"
             # after the retired snotel_ccss_stations entry; the labels were
             # renamed in 0.3 and data_status/history.json rewritten with them,
@@ -694,7 +785,7 @@ PRODUCT = Product(
                 ),
                 Probe(
                     "Snow station archive tarball (global_snow_networks)",
-                    partial(health.http_first_byte, ARCHIVE_URL),
+                    partial(health.http_first_byte, RELEASES_API),
                 ),
             ),
         ),

{easysnowdata-0.3.1 → easysnowdata-0.3.2}/pyproject.toml

@@ -105,7 +105,7 @@ exclude = [
 # The tag it creates is what hatch-vcs reads; the files below are the ones
 # that still carry a literal version.
 [tool.bumpversion]
-current_version = "0.3.1"
+current_version = "0.3.2"
 commit = true
 tag = true
 

{easysnowdata-0.3.1 → easysnowdata-0.3.2}/tests/stations/test_archive.py

@@ -28,17 +28,45 @@ from .conftest import MORSE_LAKE_CODE, PARADISE_CODE, RAINIER
 pytestmark = pytest.mark.allow_hosts(["127.0.0.1"])
 
 
+FAKE_RELEASE = {
+    "tag_name": "v2026.09.22",
+    "published_at": "2026-09-22T19:31:00Z",
+    "html_url": "https://github.com/egagli/global_snow_networks/releases/tag/v2026.09.22",
+    "assets": [
+        {
+            "name": "all_station_csvs-v2026.09.22.tar.xz",
+            "browser_download_url": "https://example.test/all_station_csvs-v2026.09.22.tar.xz",
+        },
+        {
+            "name": "all_station_csvs.tar.xz",
+            "browser_download_url": "https://example.test/all_station_csvs.tar.xz",
+        },
+        {"name": "by_time.zarr-v2026.09.22.zip", "browser_download_url": "x"},
+    ],
+}
+
+
 @pytest.fixture
 def local_archive(station_fixtures, monkeypatch):
     """Point the archive module at the fixtures instead of GitHub."""
     monkeypatch.setattr(
         archive, "INVENTORY_URL", str(station_fixtures["inventory"]), raising=False
     )
-    monkeypatch.setattr(
-        archive.providers.raster_http,
-        "fetch",
-        lambda *a, **k: station_fixtures["archive"],
-    )
+    fetched: list[dict] = []
+
+    def fake_fetch(url, fname=None, **kwargs):
+        fetched.append({"url": url, "fname": fname, **kwargs})
+        return station_fixtures["archive"]
+
+    monkeypatch.setattr(archive.providers.raster_http, "fetch", fake_fetch)
+    station_fixtures["fetched"] = fetched  # type: ignore[assignment]
+
+    def fake_json(url):
+        if url == archive.RELEASES_API:
+            return FAKE_RELEASE
+        raise AssertionError(f"unexpected JSON fetch: {url}")
+
+    monkeypatch.setattr(archive, "_fetch_json", fake_json)
     monkeypatch.setattr(
         archive,
         "ZARR_URLS",
@@ -83,7 +111,10 @@ def test_catalog_entry_is_registered_from_this_module():
 
 def test_urls_point_at_the_published_artefacts():
     assert archive.INVENTORY_URL.endswith("/all_snow_stations.geojson")
-    assert archive.ARCHIVE_URL.endswith("/data/all_station_csvs.tar.xz")
+    assert archive.ARCHIVE_URL.endswith(
+        "/releases/latest/download/all_station_csvs.tar.xz"
+    )
+    assert archive.RELEASES_API.endswith("/global_snow_networks/releases/latest")
     assert archive.csv_url(PARADISE_CODE).endswith(f"/stations/{PARADISE_CODE}.csv")
     assert archive.PAGES_BASE == "https://egagli.github.io/global_snow_networks/archive"
     assert archive.ZARR_URLS["by_time"].endswith("/archive/by_time.zarr")
@@ -184,7 +215,47 @@ def test_tarball_route_builds_the_station_time_dataset(local_archive):
     assert ds.sizes == {"station": 3, "time": 7}
     assert ds["swe"].dtype == np.float64
     assert ds.attrs["source"] == "github-tarball"
-    assert ds.attrs["source_url"] == archive.ARCHIVE_URL
+    # The bundle is the latest snapshot release's fixed-name asset, and the
+    # result says which snapshot it came from.
+    assert ds.attrs["source_url"] == "https://example.test/all_station_csvs.tar.xz"
+    assert ds.attrs["snapshot_tag"] == "v2026.09.22"
+    assert ds.attrs["snapshot_published_at"] == "2026-09-22"
+    assert ds.attrs["snapshot_url"].endswith("/releases/tag/v2026.09.22")
+    fetched = local_archive["fetched"][-1]
+    assert fetched["fname"] == "all_station_csvs-v2026.09.22.tar.xz"  # cached per tag
+    assert fetched["max_age"] is None  # a tagged bundle is immutable
+
+
+def test_latest_snapshot_reads_the_release(monkeypatch):
+    monkeypatch.setattr(archive, "_fetch_json", lambda url: FAKE_RELEASE)
+    info = archive.latest_snapshot()
+    assert info["tag"] == "v2026.09.22"
+    assert info["published_at"] == "2026-09-22"
+    assert info["tarball_url"] == "https://example.test/all_station_csvs.tar.xz"
+
+
+def test_latest_snapshot_accepts_a_release_with_only_the_tagged_bundle(monkeypatch):
+    release = {**FAKE_RELEASE, "assets": FAKE_RELEASE["assets"][:1]}
+    monkeypatch.setattr(archive, "_fetch_json", lambda url: release)
+    assert archive.latest_snapshot()["tarball_url"].endswith("-v2026.09.22.tar.xz")
+
+
+@pytest.mark.recorded
+def test_bundle_route_survives_an_unreachable_releases_api(
+    local_archive, monkeypatch, caplog
+):
+    def boom(url):
+        raise RuntimeError("HTTP 403 rate limited")
+
+    monkeypatch.setattr(archive, "_fetch_json", boom)
+    ds = archive.load(source="github-tarball")
+    assert ds.sizes == {"station": 3, "time": 7}
+    assert ds.attrs["source_url"] == archive.ARCHIVE_URL  # the fixed-name URL, blind
+    assert ds.attrs["snapshot_tag"] == ""
+    fetched = local_archive["fetched"][-1]
+    assert fetched["fname"] == "all_station_csvs.tar.xz"
+    assert fetched["max_age"] == archive.ARCHIVE_MAX_AGE
+    assert "without knowing its tag" in caplog.text
 
 
 @pytest.mark.recorded
@@ -241,7 +312,9 @@ def test_an_unreachable_store_falls_back_to_the_tarball_with_a_warning(
     ds = archive.load()
     assert ds.attrs["source"] == "github-tarball"
     assert ds.sizes == {"station": 3, "time": 7}
-    assert "reading the bundled CSVs instead" in caplog.text
+    assert ds.attrs["snapshot_tag"] == "v2026.09.22"
+    assert "snapshot v2026.09.22 (2026-09-22)" in caplog.text
+    assert "may be behind the daily archive" in caplog.text
 
 
 @pytest.mark.recorded
@@ -377,10 +450,18 @@ def test_live_archive_store_route():
     assert archive.manifest()["built_from_commit"]
 
 
+@pytest.mark.live
+def test_live_latest_snapshot_has_a_bundle():
+    info = archive.latest_snapshot()
+    assert info["tag"].startswith("v")
+    assert info["tarball_url"] and info["tarball_url"].endswith(".tar.xz")
+
+
 @pytest.mark.live
 def test_live_archive_routes_agree():
     when = "2024-01-01/2024-03-31"
     bundled = archive.load([PARADISE_CODE], source="github-tarball", time=when)
+    assert bundled.attrs["snapshot_tag"]
     per_station = archive.load([PARADISE_CODE], source="github-csv", time=when)
     chunked = archive.load([PARADISE_CODE], source="github-pages-zarr", time=when)
     assert bundled.attrs["source"] == "github-tarball"