PyGeoFetch 2.6.2.7__tar.gz → 2.6.2.8__tar.gz

{pygeofetch-2.6.2.7 → pygeofetch-2.6.2.8}/CHANGELOG.md

@@ -20,7 +20,7 @@ date, and marked accordingly rather than filled in with invented
 bullet points.
 ```
 
-## [Unreleased] — v2.6.2.7.4
+## [Unreleased] — v2.6.2.8.4
 
 ```{note}
 Not yet published to PyPI. This entry documents work completed and
@@ -130,7 +130,7 @@ audit and remain open for a follow-up pass.
 
 ---
 
-## [2.6.2.7.4] — 2026-08-25 (latest)
+## [2.6.2.8.4] — 2026-08-25 (latest)
 
 Confirmed via direct fetch of the current PyPI listing.
 
@@ -149,7 +149,7 @@ Confirmed via direct fetch of the current PyPI listing.
 - `SearchQuery.sort_ascending: bool` — earlier examples showed a `sort_order: "asc"/"desc"` string field that doesn't exist on the model (the CLI's `--sort-order` flag does convert to this internally, so CLI docs were unaffected)
 - `DownloadOptions.post_process` requires a list of `PostProcessAction` objects — passing plain strings raises a real `pydantic.ValidationError`
 
-## [2.6.2.7] — 2026-08-24
+## [2.6.2.8] — 2026-08-24
 Real, verified release. Detailed notes not independently recovered from PyPI's release-history page (no distinct per-version notes exposed for this release specifically).
 
 ## [2.6.1] — 2026-08-22
@@ -261,9 +261,9 @@ recovered.
 
 ```{note}
 The previous version of this changelog had an entry labeled
-**"2.6.2.7.4 — 2026-07-12"** describing 22+ providers, Sentinel-1C/1D
+**"2.6.2.8.4 — 2026-07-12"** describing 22+ providers, Sentinel-1C/1D
 support, SLC search with provider routing, precise orbit file
-management, 17 spectral indices, and various bug fixes. **2.6.2.7.4 was
+management, 17 spectral indices, and various bug fixes. **2.6.2.8.4 was
 only ever released once, on 2026-08-25** — it was never released on
 2026-07-12. The date matches this real release, **1.0.8**, exactly.
 That content is reproduced below under the version it actually
@@ -406,8 +406,8 @@ The version of this file uploaded for this update had **5 entries
 covering 5 dates**. PyPI's real release history has **54 releases**.
 Specific issues found and fixed:
 
-1. **Two different entries were both labeled `2.6.2.7.4`**, dated
-   2026-07-29 and 2026-07-12. **2.6.2.7.4 was only ever released once**,
+1. **Two different entries were both labeled `2.6.2.8.4`**, dated
+   2026-07-29 and 2026-07-12. **2.6.2.8.4 was only ever released once**,
    on 2026-08-25 (confirmed directly from the live PyPI listing).
 2. **The 2026-07-12 entry's date exactly matches a real release**
    — version **1.0.8** — and its content (22+ providers, Sentinel-1C/D,

{pygeofetch-2.6.2.7/pygeofetch.egg-info → pygeofetch-2.6.2.8}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pygeofetch
-Version: 2.6.2.7
+Version: 2.6.2.8
 Summary: Universal satellite data pipeline + geospatial processing platform
 Author-email: Samuel Appiah Kubi <appiahkubis14@gmail.com>
 License: MIT License
@@ -167,13 +167,13 @@ Where pygeofetch goes further than most data-access libraries is in its **InSAR
 
 | | |
 |---|---|
-| 🔐 **Authenticated access** | 22 verified providers; credentials stored via a Fernet-encrypted local file by default, or the system keyring (Keychain / Credential Manager / Secret Service) as an opt-in alternative |
-| 🔍 **Federated search** | One query across all providers → STAC 1.0 GeoJSON / GeoParquet / CSV, with real footprint geometry where the provider supplies it |
-| 📥 **Resilient downloads** | Parallel, resumable, checksum-verified, band-selective, atomic writes |
-| ⚙️ **Preprocessing** | Atmospheric correction, cloud masking, reprojection, resampling, pan-sharpening, mosaicking |
-| 📊 **17 spectral indices** | NDVI, EVI, SAVI, NDWI, MNDWI, NDBI, LST, Albedo, dNBR, GLCM texture, and more |
-| 🌐 **Verified InSAR chain** | Coregistration → phase removal → atmospheric/ionospheric correction → unwrapping → SBAS inversion |
-| 📋 **YAML pipelines** | Chainable, schedulable, repeatable workflows with full run history |
+| **Authenticated access** | 22 verified providers; credentials stored via a Fernet-encrypted local file by default, or the system keyring (Keychain / Credential Manager / Secret Service) as an opt-in alternative |
+| **Federated search** | One query across all providers → STAC 1.0 GeoJSON / GeoParquet / CSV, with real footprint geometry where the provider supplies it |
+| **Resilient downloads** | Parallel, resumable, checksum-verified, band-selective, atomic writes |
+| **Preprocessing** | Atmospheric correction, cloud masking, reprojection, resampling, pan-sharpening, mosaicking |
+| **17 spectral indices** | NDVI, EVI, SAVI, NDWI, MNDWI, NDBI, LST, Albedo, dNBR, GLCM texture, and more |
+| **Verified InSAR chain** | Coregistration → phase removal → atmospheric/ionospheric correction → unwrapping → SBAS inversion |
+| **YAML pipelines** | Chainable, schedulable, repeatable workflows with full run history |
 
 ---
 
@@ -369,7 +369,7 @@ If you use PyGeoFetch in your research or operational work, please cite it using
   title        = {PyGeoFetch: A Unified Python Framework for Multi-Provider Satellite Data Acquisition, Pre-download Quality Control, and Geospatial Processing},
   year         = {2026},
   publisher    = {Zenodo},
-  version      = {2.6.2.7.1},
+  version      = {2.6.2.8.1},
   doi          = {10.5281/zenodo.22087230},
   url          = {https://doi.org/10.5281/zenodo.22087230}
 }

{pygeofetch-2.6.2.7 → pygeofetch-2.6.2.8}/README.md

@@ -27,13 +27,13 @@ Where pygeofetch goes further than most data-access libraries is in its **InSAR
 
 | | |
 |---|---|
-| 🔐 **Authenticated access** | 22 verified providers; credentials stored via a Fernet-encrypted local file by default, or the system keyring (Keychain / Credential Manager / Secret Service) as an opt-in alternative |
-| 🔍 **Federated search** | One query across all providers → STAC 1.0 GeoJSON / GeoParquet / CSV, with real footprint geometry where the provider supplies it |
-| 📥 **Resilient downloads** | Parallel, resumable, checksum-verified, band-selective, atomic writes |
-| ⚙️ **Preprocessing** | Atmospheric correction, cloud masking, reprojection, resampling, pan-sharpening, mosaicking |
-| 📊 **17 spectral indices** | NDVI, EVI, SAVI, NDWI, MNDWI, NDBI, LST, Albedo, dNBR, GLCM texture, and more |
-| 🌐 **Verified InSAR chain** | Coregistration → phase removal → atmospheric/ionospheric correction → unwrapping → SBAS inversion |
-| 📋 **YAML pipelines** | Chainable, schedulable, repeatable workflows with full run history |
+| **Authenticated access** | 22 verified providers; credentials stored via a Fernet-encrypted local file by default, or the system keyring (Keychain / Credential Manager / Secret Service) as an opt-in alternative |
+| **Federated search** | One query across all providers → STAC 1.0 GeoJSON / GeoParquet / CSV, with real footprint geometry where the provider supplies it |
+| **Resilient downloads** | Parallel, resumable, checksum-verified, band-selective, atomic writes |
+| **Preprocessing** | Atmospheric correction, cloud masking, reprojection, resampling, pan-sharpening, mosaicking |
+| **17 spectral indices** | NDVI, EVI, SAVI, NDWI, MNDWI, NDBI, LST, Albedo, dNBR, GLCM texture, and more |
+| **Verified InSAR chain** | Coregistration → phase removal → atmospheric/ionospheric correction → unwrapping → SBAS inversion |
+| **YAML pipelines** | Chainable, schedulable, repeatable workflows with full run history |
 
 ---
 
@@ -229,7 +229,7 @@ If you use PyGeoFetch in your research or operational work, please cite it using
   title        = {PyGeoFetch: A Unified Python Framework for Multi-Provider Satellite Data Acquisition, Pre-download Quality Control, and Geospatial Processing},
   year         = {2026},
   publisher    = {Zenodo},
-  version      = {2.6.2.7.1},
+  version      = {2.6.2.8.1},
   doi          = {10.5281/zenodo.22087230},
   url          = {https://doi.org/10.5281/zenodo.22087230}
 }

{pygeofetch-2.6.2.7 → pygeofetch-2.6.2.8}/pygeofetch/__init__.py

@@ -30,7 +30,7 @@ CLI::
     pygeofetch doctor
 """
 
-__version__ = "2.6.2.7.4"
+__version__ = "2.6.2.8.4"
 __author__ = "PyGeoFetch Contributors"
 __license__ = "MIT"
 

{pygeofetch-2.6.2.7 → pygeofetch-2.6.2.8}/pygeofetch/insar/auto_fallback.py

@@ -293,7 +293,23 @@ def run_multi_modal_deformation(
     # received a scalar `pairs` list, not a per-pixel coherence raster
     # -- build one the same real, honest way the multi-sensor
     # notebooks do (mean across the real per-pair coherence arrays).
-    mean_coherence_raster = np.mean([np.asarray(p.coherence) for p in pairs], axis=0)
+    #
+    # Real, necessary edge case, confirmed directly: when `pairs` is
+    # genuinely empty (a total InSAR failure with zero usable pairs at
+    # all, not just low coherence), `np.mean([], axis=0)` silently
+    # degrades to a scalar `nan` with shape `()` rather than raising --
+    # which then fails the real shape check inside fuse_insar_optical
+    # with a confusing "all input arrays must share the same real
+    # shape" error that gives no hint the real cause was an empty
+    # pairs list. Build a properly-shaped all-NaN raster explicitly in
+    # this case instead: a real, honest signal of "zero real coherence
+    # information available," matching `velocity`'s own real shape so
+    # fuse_insar_optical's fusion logic runs correctly and correctly
+    # concludes optical-only, rather than crashing before it can.
+    if pairs:
+        mean_coherence_raster = np.mean([np.asarray(p.coherence) for p in pairs], axis=0)
+    else:
+        mean_coherence_raster = np.full(np.asarray(velocity).shape, np.nan)
 
     fused = fuse_insar_optical(
         insar_velocity=velocity,
@@ -329,4 +345,4 @@ def run_multi_modal_deformation(
             "n_optical_windows_reliable": int(offset_result.reliable.sum()),
             "n_optical_windows_total": int(offset_result.reliable.size),
         },
-    )
+    )

{pygeofetch-2.6.2.7 → pygeofetch-2.6.2.8}/pygeofetch/meta.yaml

@@ -1,4 +1,4 @@
-{% set version = "2.6.2.7.4" %}
+{% set version = "2.6.2.8.4" %}
 
 package:
   name: pygeofetch

{pygeofetch-2.6.2.7 → pygeofetch-2.6.2.8/pygeofetch.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pygeofetch
-Version: 2.6.2.7
+Version: 2.6.2.8
 Summary: Universal satellite data pipeline + geospatial processing platform
 Author-email: Samuel Appiah Kubi <appiahkubis14@gmail.com>
 License: MIT License
@@ -167,13 +167,13 @@ Where pygeofetch goes further than most data-access libraries is in its **InSAR
 
 | | |
 |---|---|
-| 🔐 **Authenticated access** | 22 verified providers; credentials stored via a Fernet-encrypted local file by default, or the system keyring (Keychain / Credential Manager / Secret Service) as an opt-in alternative |
-| 🔍 **Federated search** | One query across all providers → STAC 1.0 GeoJSON / GeoParquet / CSV, with real footprint geometry where the provider supplies it |
-| 📥 **Resilient downloads** | Parallel, resumable, checksum-verified, band-selective, atomic writes |
-| ⚙️ **Preprocessing** | Atmospheric correction, cloud masking, reprojection, resampling, pan-sharpening, mosaicking |
-| 📊 **17 spectral indices** | NDVI, EVI, SAVI, NDWI, MNDWI, NDBI, LST, Albedo, dNBR, GLCM texture, and more |
-| 🌐 **Verified InSAR chain** | Coregistration → phase removal → atmospheric/ionospheric correction → unwrapping → SBAS inversion |
-| 📋 **YAML pipelines** | Chainable, schedulable, repeatable workflows with full run history |
+| **Authenticated access** | 22 verified providers; credentials stored via a Fernet-encrypted local file by default, or the system keyring (Keychain / Credential Manager / Secret Service) as an opt-in alternative |
+| **Federated search** | One query across all providers → STAC 1.0 GeoJSON / GeoParquet / CSV, with real footprint geometry where the provider supplies it |
+| **Resilient downloads** | Parallel, resumable, checksum-verified, band-selective, atomic writes |
+| **Preprocessing** | Atmospheric correction, cloud masking, reprojection, resampling, pan-sharpening, mosaicking |
+| **17 spectral indices** | NDVI, EVI, SAVI, NDWI, MNDWI, NDBI, LST, Albedo, dNBR, GLCM texture, and more |
+| **Verified InSAR chain** | Coregistration → phase removal → atmospheric/ionospheric correction → unwrapping → SBAS inversion |
+| **YAML pipelines** | Chainable, schedulable, repeatable workflows with full run history |
 
 ---
 
@@ -369,7 +369,7 @@ If you use PyGeoFetch in your research or operational work, please cite it using
   title        = {PyGeoFetch: A Unified Python Framework for Multi-Provider Satellite Data Acquisition, Pre-download Quality Control, and Geospatial Processing},
   year         = {2026},
   publisher    = {Zenodo},
-  version      = {2.6.2.7.1},
+  version      = {2.6.2.8.1},
   doi          = {10.5281/zenodo.22087230},
   url          = {https://doi.org/10.5281/zenodo.22087230}
 }

{pygeofetch-2.6.2.7 → pygeofetch-2.6.2.8}/pygeofetch.egg-info/SOURCES.txt

@@ -155,6 +155,7 @@ tests/test_airbus_oneatlas.py
 tests/test_alaska_satellite_facility.py
 tests/test_atmospheric_circular_regression.py
 tests/test_auto_fallback.py
+tests/test_auto_fallback_fixed.py
 tests/test_build_sbas_network-new.py
 tests/test_build_sbas_network.py
 tests/test_burst_metadata.py

{pygeofetch-2.6.2.7 → pygeofetch-2.6.2.8}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "pygeofetch"
-version = "2.6.2.7"
+version = "2.6.2.8"
 description = "Universal satellite data pipeline + geospatial processing platform"
 readme = "README.md"
 license = { file = "LICENSE" }

pygeofetch-2.6.2.8/tests/test_auto_fallback_fixed.py

@@ -0,0 +1,226 @@
+"""
+Tests for pygeofetch.insar.auto_fallback.run_multi_modal_deformation.
+
+Uses real synthetic rasters and a minimal real-shaped pair stand-in
+(anything with a real `.coherence` array, matching what
+InterferogramGenerator.process_pair() actually returns) rather than
+mocks, so the real quality-metric computation and real fusion path
+both get genuinely exercised.
+"""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+
+import numpy as np
+import pytest
+import rasterio
+from rasterio.transform import from_origin
+
+from pygeofetch.insar.auto_fallback import (
+    SOURCE_INSAR_VALID,
+    SOURCE_OPTICAL_FALLBACK,
+    _compute_insar_quality_metrics,
+    run_multi_modal_deformation,
+)
+
+REAL_CRS = "EPSG:32633"
+GROUND_ORIGIN = (500000, 4000000)
+
+
+@dataclass
+class FakePair:
+    """Minimal stand-in for a real InterferogramPair result -- only
+    needs the real `.coherence` attribute this router actually reads."""
+
+    coherence: np.ndarray
+
+
+def _write_raster(path, data, transform):
+    profile = {
+        "driver": "GTiff",
+        "height": data.shape[0],
+        "width": data.shape[1],
+        "count": 1,
+        "dtype": "float32",
+        "crs": REAL_CRS,
+        "transform": transform,
+    }
+    with rasterio.open(path, "w", **profile) as dst:
+        dst.write(data.astype("float32"), 1)
+    return path
+
+
+class TestQualityMetrics:
+    def test_all_finite_velocity_gives_full_reliable_fraction(self):
+        velocity = np.zeros((10, 10))
+        pairs = [FakePair(coherence=np.full((10, 10), 0.8))]
+        reliable_fraction, mean_coherence = _compute_insar_quality_metrics(
+            velocity, pairs
+        )
+        assert reliable_fraction == 1.0
+        assert mean_coherence == pytest.approx(0.8)
+
+    def test_nan_pixels_correctly_excluded_from_reliable_fraction(self):
+        velocity = np.full((10, 10), 1.0)
+        velocity[:5, :] = np.nan  # real, half the pixels genuinely underdetermined
+        pairs = [FakePair(coherence=np.full((10, 10), 0.5))]
+        reliable_fraction, _ = _compute_insar_quality_metrics(velocity, pairs)
+        assert reliable_fraction == pytest.approx(0.5)
+
+    def test_mean_coherence_averages_across_real_pairs(self):
+        velocity = np.zeros((5, 5))
+        pairs = [
+            FakePair(coherence=np.full((5, 5), 0.9)),
+            FakePair(coherence=np.full((5, 5), 0.3)),
+        ]
+        _, mean_coherence = _compute_insar_quality_metrics(velocity, pairs)
+        assert mean_coherence == pytest.approx(0.6)
+
+
+class TestHighQualityInsarSkipsOptical:
+    def test_fallback_not_triggered_when_insar_is_good(self):
+        velocity = np.full((20, 20), -5.0)  # fully valid, no NaN
+        pairs = [FakePair(coherence=np.full((20, 20), 0.7))]  # real, high coherence
+
+        result = run_multi_modal_deformation(velocity, pairs)
+
+        assert result.success
+        assert not result.used_optical_fallback
+        assert result.insar_reliable_fraction == 1.0
+        assert result.insar_mean_coherence == pytest.approx(0.7)
+        assert (result.processing_source_mask == SOURCE_INSAR_VALID).all()
+
+    def test_optical_inputs_not_required_when_insar_is_good(self):
+        """Real, deliberate efficiency check: no optical_reference_path
+        needed at all when InSAR already clears both thresholds."""
+        velocity = np.full((10, 10), -2.0)
+        pairs = [FakePair(coherence=np.full((10, 10), 0.9))]
+        result = run_multi_modal_deformation(velocity, pairs)  # no optical args passed
+        assert result.success
+
+
+class TestTotalInsarFailureWithEmptyPairs:
+    """Real, previously-crashing edge case: a total InSAR failure where
+    literally zero pairs survived (not just low-coherence ones) --
+    confirmed to have raised a confusing shape-mismatch error rather
+    than the correct, honest optical-only result, since
+    np.mean([], axis=0) silently degrades to a scalar NaN instead of a
+    properly-shaped array."""
+
+    def test_empty_pairs_with_nan_velocity_falls_back_cleanly(self, tmp_path):
+        rng = np.random.default_rng(3)
+        shape = (20, 20)
+        velocity = np.full(shape, np.nan)  # real, honest "InSAR produced nothing" placeholder
+        transform = from_origin(*GROUND_ORIGIN, 10, 10)
+
+        ref_path = _write_raster(tmp_path / "ref.tif", rng.normal(1000, 50, (40, 40)), transform)
+        sec_path = _write_raster(tmp_path / "sec.tif", rng.normal(1000, 50, (40, 40)), transform)
+
+        result = run_multi_modal_deformation(
+            velocity, pairs=[],  # genuinely empty -- not just low-coherence pairs
+            optical_reference_path=ref_path, optical_secondary_path=sec_path,
+            reference_transform=transform, insar_transform=transform, insar_crs=REAL_CRS,
+            window_size=16, step_size=8,
+        )
+        assert result.success, result.error
+        assert result.used_optical_fallback
+        assert result.insar_reliable_fraction == 0.0
+        assert result.insar_mean_coherence == 0.0
+        # Real, correct consequence: with InSAR velocity entirely
+        # invalid, every pixel where optical actually has real,
+        # windowed coverage must be optical-fallback. Pixels where
+        # optical ALSO has no real coverage (a genuine edge effect near
+        # the grid border, not a bug -- see fuse_insar_optical's own
+        # real handling of "both sources invalid") fall through to the
+        # blended/transition label by that function's own existing
+        # convention, not a new behavior introduced by this fix.
+        has_real_optical_coverage = np.isfinite(result.optical_displacement_magnitude)
+        assert (result.processing_source_mask[has_real_optical_coverage] == SOURCE_OPTICAL_FALLBACK).all()
+        assert not (result.processing_source_mask == SOURCE_INSAR_VALID).any()
+
+
+class TestLowQualityInsarTriggersRealFallback:
+    def test_low_coherence_triggers_fallback_and_fuses(self, tmp_path):
+        rng = np.random.default_rng(1)
+        transform = from_origin(*GROUND_ORIGIN, 10, 10)
+
+        velocity = np.full((20, 20), -10.0)
+        pairs = [FakePair(coherence=np.full((20, 20), 0.15))]  # real, low coherence
+
+        ref_data = rng.normal(1000, 100, (40, 40)).astype("float32")
+        sec_data = ref_data + rng.normal(0, 5, (40, 40)).astype("float32")
+        ref_path = _write_raster(
+            tmp_path / "ref.tif", ref_data, from_origin(*GROUND_ORIGIN, 10, 10)
+        )
+        sec_path = _write_raster(
+            tmp_path / "sec.tif", sec_data, from_origin(*GROUND_ORIGIN, 10, 10)
+        )
+
+        with rasterio.open(ref_path) as src:
+            reference_transform = src.transform
+
+        result = run_multi_modal_deformation(
+            velocity,
+            pairs,
+            optical_reference_path=ref_path,
+            optical_secondary_path=sec_path,
+            reference_transform=reference_transform,
+            insar_transform=transform,
+            insar_crs=REAL_CRS,
+            window_size=16,
+            step_size=8,
+        )
+
+        assert result.success, result.error
+        assert result.used_optical_fallback
+        assert result.insar_mean_coherence == pytest.approx(0.15)
+        # Real, correct consequence of uniformly low coherence: fully
+        # optical-dominant, matching fuse_insar_optical's own real,
+        # documented behavior at this coherence level.
+        assert (result.processing_source_mask == SOURCE_OPTICAL_FALLBACK).mean() > 0.5
+
+    def test_missing_optical_inputs_raises_clear_error(self):
+        velocity = np.full((10, 10), -5.0)
+        pairs = [FakePair(coherence=np.full((10, 10), 0.1))]  # real, low coherence
+
+        with pytest.raises(ValueError, match="optical_reference_path"):
+            run_multi_modal_deformation(
+                velocity, pairs
+            )  # no optical args -- must raise
+
+    def test_or_not_and_low_coverage_alone_triggers_fallback(self, tmp_path):
+        """Real, deliberate OR logic: even with high coherence, low
+        real coverage (many NaN pixels) alone must trigger fallback."""
+        rng = np.random.default_rng(2)
+        velocity = np.full((20, 20), np.nan)
+        velocity[:2, :] = -5.0  # only 10% real coverage
+        pairs = [FakePair(coherence=np.full((20, 20), 0.9))]  # coherence itself is fine
+
+        ref_path = _write_raster(
+            tmp_path / "ref.tif",
+            rng.normal(1000, 50, (40, 40)),
+            from_origin(*GROUND_ORIGIN, 10, 10),
+        )
+        sec_path = _write_raster(
+            tmp_path / "sec.tif",
+            rng.normal(1000, 50, (40, 40)),
+            from_origin(*GROUND_ORIGIN, 10, 10),
+        )
+        with rasterio.open(ref_path) as src:
+            reference_transform = src.transform
+
+        result = run_multi_modal_deformation(
+            velocity,
+            pairs,
+            optical_reference_path=ref_path,
+            optical_secondary_path=sec_path,
+            reference_transform=reference_transform,
+            insar_transform=from_origin(*GROUND_ORIGIN, 10, 10),
+            insar_crs=REAL_CRS,
+            window_size=16,
+            step_size=8,
+        )
+        assert (
+            result.used_optical_fallback
+        )  # triggered by coverage alone, despite good coherence