PyGeoFetch 1.3.0__tar.gz → 1.4.0__tar.gz

{pygeofetch-1.3.0 → pygeofetch-1.4.0}/CHANGELOG.md

@@ -1,9 +1,9 @@
 # Changelog
 
 All notable changes to PyGeoFetch are documented here.
-Format follows [Keep a Changelog](https://keepachangelog.com/en/1.3.0/).
+Format follows [Keep a Changelog](https://keepachangelog.com/en/1.4.0/).
 
-## [1.3.0] — 2026-07-12
+## [1.4.0] — 2026-07-12
 
 ### Added
 - Federated search across 22+ satellite data providers

{pygeofetch-1.3.0 → pygeofetch-1.4.0}/LICENSE

@@ -1,6 +1,6 @@
 MIT License
 
-Copyright (c) 2024 SatelliteBridge Contributors
+Copyright (c) 2026 Samuel Appiah Kubi
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

{pygeofetch-1.3.0/pygeofetch.egg-info → pygeofetch-1.4.0}/PKG-INFO

@@ -1,11 +1,11 @@
 Metadata-Version: 2.4
 Name: pygeofetch
-Version: 1.3.0
+Version: 1.4.0
 Summary: Universal satellite data pipeline + geospatial processing platform
-Author-email: pygeofetch Contributors <pygeofetch@example.com>
+Author-email: Samuel Appiah Kubi <appiahkubis14@gmail.com>
 License: MIT License
         
-        Copyright (c) 2024 SatelliteBridge Contributors
+        Copyright (c) 2026 Samuel Appiah Kubi
         
         Permission is hereby granted, free of charge, to any person obtaining a copy
         of this software and associated documentation files (the "Software"), to deal
@@ -606,8 +606,8 @@ jupyter lab
 ---
 
 <p align="center">
-  <img src="https://raw.githubusercontent.com/EOCoreINT/pygeofetch/refs/heads/main/docs/images/trend_map.png?token=GHSAT0AAAAAAD4555HVK7XABUW65FV6B3N22S7TNMA" width="48%" />
-  <img src="https://raw.githubusercontent.com/EOCoreINT/pygeofetch/refs/heads/main/docs/images/trend_classification.png?token=GHSAT0AAAAAAD4555HVX7RLHLSCQSBSGCIY2S7TMFQ" width="48%" />
+  <img src="docs/images/trend_map.png" width="48%" />
+  <img src="docs/images/trend_classification.png" width="48%" />
 </p>
 <p align="center"><em>NDVI trend (2018–2024) and severity classification for the Obuasi Municipal District, computed end-to-end with PyGeoFetch — real USGS Landsat data, boundary-clipped before processing.</em></p>
 

{pygeofetch-1.3.0 → pygeofetch-1.4.0}/README.md

@@ -471,8 +471,8 @@ jupyter lab
 ---
 
 <p align="center">
-  <img src="https://raw.githubusercontent.com/EOCoreINT/pygeofetch/refs/heads/main/docs/images/trend_map.png?token=GHSAT0AAAAAAD4555HVK7XABUW65FV6B3N22S7TNMA" width="48%" />
-  <img src="https://raw.githubusercontent.com/EOCoreINT/pygeofetch/refs/heads/main/docs/images/trend_classification.png?token=GHSAT0AAAAAAD4555HVX7RLHLSCQSBSGCIY2S7TMFQ" width="48%" />
+  <img src="docs/images/trend_map.png" width="48%" />
+  <img src="docs/images/trend_classification.png" width="48%" />
 </p>
 <p align="center"><em>NDVI trend (2018–2024) and severity classification for the Obuasi Municipal District, computed end-to-end with PyGeoFetch — real USGS Landsat data, boundary-clipped before processing.</em></p>
 

{pygeofetch-1.3.0 → pygeofetch-1.4.0}/pygeofetch/__init__.py

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

{pygeofetch-1.3.0 → pygeofetch-1.4.0}/pygeofetch/meta.yaml

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

{pygeofetch-1.3.0 → pygeofetch-1.4.0}/pygeofetch/processing/preprocessor.py

@@ -707,15 +707,63 @@ class Preprocessor:
                     transform_geom(geometry_crs, src.crs, shp) for shp in shapes
                 ]
 
-            out_image, out_transform = rasterio_mask(
-                src, shapes, crop=True, all_touched=all_touched
-            )
+            try:
+                out_image, out_transform = rasterio_mask(
+                    src, shapes, crop=True, all_touched=all_touched, nodata=0
+                )
+            except ValueError as exc:
+                if "do not overlap" not in str(exc):
+                    raise
+                # A near-miss (off by a pixel or two), not a gross CRS
+                # mismatch — the geometry and raster ARE in the same CRS
+                # and roughly the same place, but floating-point precision
+                # in the reprojection, or the AOI sitting right at the
+                # edge of the raster's real coverage, can produce a
+                # bounding window that misses by a sliver. Retry once with
+                # a small buffer (a few pixels' worth, computed from the
+                # raster's own resolution) before giving up — a standard,
+                # safe technique for exactly this class of edge case.
+                from shapely.geometry import shape as _shp_shape
+
+                px_size = abs(src.transform[0])
+                buffer_dist = px_size * 3
+                buffered_shapes = [
+                    _shp_shape(s).buffer(buffer_dist).__geo_interface__
+                    for s in shapes
+                ]
+                try:
+                    out_image, out_transform = rasterio_mask(
+                        src, buffered_shapes, crop=True, all_touched=all_touched, nodata=0
+                    )
+                    logger.warning(
+                        f"clip(): initial geometry missed the raster by a "
+                        f"sliver — succeeded after a {buffer_dist:.1f}m "
+                        f"buffer retry. Raster bounds: {tuple(src.bounds)}, "
+                        f"CRS: {src.crs}."
+                    )
+                except ValueError:
+                    # Genuinely doesn't overlap even with a buffer — surface
+                    # the actual bounds so this is diagnosable directly from
+                    # the error, instead of a bare "do not overlap" message.
+                    geom_bounds = _shp_shape(shapes[0]).bounds
+                    raise ValueError(
+                        f"Input shapes do not overlap raster, even after a "
+                        f"buffer retry. Raster bounds: {tuple(src.bounds)} "
+                        f"(CRS: {src.crs}). Geometry bounds (after any CRS "
+                        f"reprojection): {geom_bounds}. If these are wildly "
+                        f"different, the raster's real coverage genuinely "
+                        f"doesn't include this AOI (check you have the "
+                        f"right scene/tile) — if they're close, this may be "
+                        f"a genuine precision edge case worth reporting."
+                    ) from exc
+
             profile = src.profile.copy()
             profile.update(
                 dtype=out_image.dtype,
                 height=out_image.shape[1],
                 width=out_image.shape[2],
                 transform=out_transform,
+                nodata=0,
             )
             with rasterio.open(out_path, "w", **profile) as dst:
                 dst.write(out_image)
@@ -826,11 +874,13 @@ class Preprocessor:
         input: str | Path,
         resolution: float | None = None,
         scale_factor: float | None = None,
+        reference: str | Path | None = None,
         method: str = "bilinear",
         output: str | None = None,
     ) -> ProcessingResult:
         """
-        Resample raster to a different spatial resolution.
+        Resample raster to a different spatial resolution, or align it to
+        exactly match another raster's grid.
 
         Args:
             input:        Input raster.
@@ -838,8 +888,23 @@ class Preprocessor:
                           For geographic CRS, use degrees; for projected, metres.
             scale_factor: Alternatively, a scale factor (0.5 = half resolution,
                           2.0 = double resolution). Cannot combine with resolution.
+            reference:    Alternatively, another raster to match exactly —
+                          same shape, transform, and CRS as this file, not
+                          just the same resolution. Two rasters independently
+                          resampled to "the same resolution" can still have
+                          different origins/extents and fail to line up
+                          pixel-for-pixel; `reference` guarantees they do.
+                          The real, common case this solves: combining
+                          results from two different sensors (e.g. Sentinel-1
+                          SAR at ~10m native resolution and Landsat optical
+                          at 30m) that need to sit on identical pixels before
+                          being compared or combined. Cannot combine with
+                          resolution or scale_factor.
             method:       ``"nearest"``, ``"bilinear"``, ``"cubic"``, ``"lanczos"``,
-                          ``"average"``.
+                          ``"average"``. Use ``"nearest"`` for categorical/
+                          classified data (class codes, masks) — bilinear
+                          and the other continuous-data methods will blend
+                          adjacent classes into meaningless fractional values.
             output:       Output path.
 
         Example::
@@ -848,8 +913,13 @@ class Preprocessor:
             result = client.preprocess.resample("B02_10m.tif", resolution=30)
             # Downsample by factor of 2
             result = client.preprocess.resample("scene.tif", scale_factor=0.5)
+            # Align a SAR classification mask onto an optical raster's exact grid
+            result = client.preprocess.resample(
+                "sar_mask.tif", reference="optical_classified.tif", method="nearest",
+            )
         """
         rasterio = _require_rasterio()
+        np = _require_numpy()
         from rasterio.enums import Resampling as RS
 
         rs_map = {
@@ -862,6 +932,46 @@ class Preprocessor:
         rs_method = rs_map.get(method, RS.bilinear)
 
         inp = Path(input)
+
+        if reference is not None:
+            if resolution is not None or scale_factor is not None:
+                msg = "Provide only one of resolution, scale_factor, or reference"
+                raise ValueError(msg)
+
+            from rasterio.warp import reproject as _warp_reproject
+
+            out_path = _resolve_output(inp, output, "aligned")
+            out_path.parent.mkdir(parents=True, exist_ok=True)
+
+            with rasterio.open(reference) as ref_src:
+                ref_transform, ref_crs = ref_src.transform, ref_src.crs
+                new_h, new_w = ref_src.height, ref_src.width
+
+            with rasterio.open(inp) as src:
+                profile = src.profile.copy()
+                profile.update(height=new_h, width=new_w, transform=ref_transform, crs=ref_crs)
+                data = np.zeros((src.count, new_h, new_w), dtype=src.dtypes[0])
+                for band_idx in range(1, src.count + 1):
+                    _warp_reproject(
+                        source=rasterio.band(src, band_idx),
+                        destination=data[band_idx - 1],
+                        src_transform=src.transform, src_crs=src.crs,
+                        dst_transform=ref_transform, dst_crs=ref_crs,
+                        resampling=rs_method,
+                    )
+
+            with rasterio.open(out_path, "w", **profile) as dst:
+                dst.write(data)
+
+            logger.info(f"Aligned to reference grid → {new_w}×{new_h} → {out_path}")
+            return ProcessingResult(
+                success=True,
+                operation="resample",
+                input_path=inp,
+                output_path=out_path,
+                metadata={"method": method, "new_width": new_w, "new_height": new_h, "reference": str(reference)},
+            )
+
         res_label = str(resolution or scale_factor).replace(".", "p")
         out_path = _resolve_output(inp, output, f"resamp_{res_label}m")
         out_path.parent.mkdir(parents=True, exist_ok=True)
@@ -876,7 +986,7 @@ class Preprocessor:
                 scale_x = scale_factor
                 scale_y = scale_factor
             else:
-                msg = "Provide either resolution or scale_factor"
+                msg = "Provide either resolution, scale_factor, or reference"
                 raise ValueError(msg)
 
             new_h = max(1, int(src.height * scale_y))
@@ -1151,4 +1261,4 @@ class Preprocessor:
             operation=f"composite:{method}",
             output_path=out_path,
             metadata={"n_inputs": len(inputs), "method": method},
-        )
+        )

{pygeofetch-1.3.0 → pygeofetch-1.4.0}/pygeofetch/processing/sar.py

@@ -223,6 +223,7 @@ class SARProcessor:
         threshold: float = -15.0,
         output: str | None = None,
         reference: str | Path | None = None,
+        detect_direction: str = "decrease",
     ) -> ProcessingResult:
         """
         Flood mapping from SAR backscatter via simple threshold or change detection.
@@ -230,17 +231,39 @@ class SARProcessor:
         Args:
             input:     SAR raster in dB (VV or VH polarisation).
             threshold: Backscatter below this = water (typical -15 to -20 dB).
+                     Also sets the change-detection sensitivity (see
+                     detect_direction) as abs(threshold * 0.5).
             output:    Output binary mask (1=water, 0=land, 255=nodata).
             reference: Optional pre-event reference for change-based detection.
+            detect_direction: For change detection only. "decrease" (default)
+                     flags pixels where backscatter DROPPED — the correct
+                     signature for open water (smooth surfaces are
+                     near-specular reflectors). "increase" flags pixels
+                     where backscatter ROSE — the signature of flooded
+                     urban/built-up areas, where water at the base of
+                     buildings creates a double-bounce reflection
+                     (ground-wall-sensor) stronger than dry ground alone.
+                     "both" flags either direction — the most robust
+                     choice when an AOI mixes open water and dense urban
+                     flooding (e.g. Accra), since a one-directional
+                     threshold structurally cannot detect the other
+                     pattern at all, not just detect it poorly.
 
         Example::
 
             result = client.sar.flood_map("post_event.tif",
-                                           reference="pre_event.tif")
+                                           reference="pre_event.tif",
+                                           detect_direction="both")
         """
         np = _require_numpy()
         rasterio = _require_rasterio()
 
+        if detect_direction not in ("decrease", "increase", "both"):
+            raise ValueError(
+                f"detect_direction must be 'decrease', 'increase', or "
+                f"'both', got {detect_direction!r}"
+            )
+
         inp = Path(input)
         out_path = _resolve_output(inp, output, "flood_map")
 
@@ -251,8 +274,14 @@ class SARProcessor:
 
         if reference is not None:
             ref_d, _, _ = self._read(Path(reference), ref_shape=data.shape)
-            change = ref_d - data
-            water_mask = (change > abs(threshold * 0.5)) & valid
+            change = ref_d - data  # positive = backscatter dropped (open water)
+            change_threshold = abs(threshold * 0.5)
+            if detect_direction == "decrease":
+                water_mask = (change > change_threshold) & valid
+            elif detect_direction == "increase":
+                water_mask = (change < -change_threshold) & valid
+            else:  # "both"
+                water_mask = (np.abs(change) > change_threshold) & valid
         else:
             water_mask = (data < threshold) & valid
 
@@ -276,15 +305,23 @@ class SARProcessor:
             dst.write(result[None, :, :])
 
         logger.info("Flood map: %.1f%% water → %s", water_pct, out_path.name)
+        metadata = {
+            "threshold_db": threshold,
+            "water_pct": round(float(water_pct), 2),
+        }
+        if reference is not None:
+            metadata["detect_direction"] = detect_direction
+            decrease_pct = 100 * np.sum((change > change_threshold) & valid) / (np.sum(valid) + 1e-10)
+            increase_pct = 100 * np.sum((change < -change_threshold) & valid) / (np.sum(valid) + 1e-10)
+            metadata["decrease_pct"] = round(float(decrease_pct), 2)
+            metadata["increase_pct"] = round(float(increase_pct), 2)
+
         return ProcessingResult(
             success=True,
             operation="flood_map",
             input_path=inp,
             output_path=out_path,
-            metadata={
-                "threshold_db": threshold,
-                "water_pct": round(float(water_pct), 2),
-            },
+            metadata=metadata,
         )
 
     # ── Coherence ────────────────────────────────────────────────────────
@@ -366,4 +403,4 @@ class SARProcessor:
             operation="coherence",
             output_path=out_path,
             metadata={"mean_coherence": round(mean_coh, 4), "window": window},
-        )
+        )

{pygeofetch-1.3.0 → pygeofetch-1.4.0}/pygeofetch/processor/timeseries.py

@@ -127,6 +127,7 @@ class TimeSeriesAnalyzer:
         self,
         date_bands: Dict[str, Dict[str, Union[str, Path]]],
         precomputed: bool = False,
+        align_grids: bool = True,
     ) -> IndexTimeStack:
         """
         Compute the configured index for every date and stack the results
@@ -141,14 +142,21 @@ class TimeSeriesAnalyzer:
                        but without keeping the profile for zonal use).
             precomputed: Treat date_bands values as ready-made single-band
                        index rasters instead of raw band dicts.
+            align_grids: If a date's raster doesn't share the first date's
+                       grid (different shape, transform, or CRS), reproject
+                       it onto the first date's grid automatically rather
+                       than raising. Default True. This is a real, common
+                       case: different acquisitions of the same AOI can
+                       come from different satellite scene footprints
+                       (tile boundaries, orbit tracks), especially for
+                       elongated or irregularly-shaped AOIs, and end up
+                       with slightly different pixel grids after clipping
+                       even though they cover (nearly) the same area. Set
+                       False to restore the old strict behaviour (raise on
+                       any mismatch) if you specifically want that.
 
         Returns:
             IndexTimeStack — sorted by date, with .as_xarray() available.
-
-        All dates must share the same grid (same CRS, transform, shape) —
-        typically true for repeat acquisitions of the same AOI from the
-        same sensor. Reproject/resample first if that's not the case for
-        your data (see the reproject post-process action).
         """
         np = _require_numpy()
         rasterio = _require_rasterio()
@@ -159,40 +167,68 @@ class TimeSeriesAnalyzer:
         arrays = []
         profile = None
         ref_shape = None
+        ref_transform = None
+        ref_crs = None
 
         si = SpectralIndex(prefer_spyndex=False) if not precomputed else None
 
+        def _read_aligned(path, date, label):
+            nonlocal profile, ref_shape, ref_transform, ref_crs
+            with rasterio.open(path) as src:
+                arr = src.read(1).astype(np.float32)
+                if profile is None:
+                    profile = src.profile.copy()
+                    ref_shape = arr.shape
+                    ref_transform = src.transform
+                    ref_crs = src.crs
+                    return arr
+
+                same_grid = (
+                    arr.shape == ref_shape
+                    and src.transform == ref_transform
+                    and src.crs == ref_crs
+                )
+                if same_grid:
+                    return arr
+
+                if not align_grids:
+                    raise ValueError(
+                        f"{date}/{label}: grid {arr.shape} doesn't match the "
+                        f"first date's grid {ref_shape}. All dates must "
+                        f"share the same grid, or call with align_grids=True "
+                        f"(the default) to align automatically."
+                    )
+
+                from rasterio.warp import reproject, Resampling
+
+                logger.info(
+                    "%s/%s: grid %s differs from the first date's %s — "
+                    "reprojecting onto the first date's grid automatically "
+                    "(align_grids=True). This is expected when different "
+                    "acquisitions come from different scene footprints over "
+                    "the same AOI.",
+                    date, label, arr.shape, ref_shape,
+                )
+                aligned = np.full(ref_shape, np.nan, dtype=np.float32)
+                reproject(
+                    source=arr, destination=aligned,
+                    src_transform=src.transform, src_crs=src.crs,
+                    dst_transform=ref_transform, dst_crs=ref_crs,
+                    resampling=Resampling.bilinear, src_nodata=np.nan, dst_nodata=np.nan,
+                )
+                return aligned
+
         for date in dates:
             entry = date_bands[date]
 
             if precomputed:
-                path = Path(entry)  # type: ignore[arg-type]
-                with rasterio.open(path) as src:
-                    arr = src.read(1).astype(np.float32)
-                    if profile is None:
-                        profile = src.profile.copy()
-                        ref_shape = arr.shape
-                    elif arr.shape != ref_shape:
-                        raise ValueError(
-                            f"{date}: shape {arr.shape} doesn't match the "
-                            f"first date's shape {ref_shape}. All dates must "
-                            f"share the same grid — reproject/resample first."
-                        )
+                arr = _read_aligned(Path(entry), date, "index")  # type: ignore[arg-type]
             else:
                 band_arrays = {}
                 for band_name, band_path in entry.items():
-                    with rasterio.open(Path(band_path)) as src:
-                        arr = src.read(1).astype(np.float32)
-                        if profile is None:
-                            profile = src.profile.copy()
-                            ref_shape = arr.shape
-                        elif arr.shape != ref_shape:
-                            raise ValueError(
-                                f"{date}/{band_name}: shape {arr.shape} doesn't "
-                                f"match the first date's shape {ref_shape}. All "
-                                f"bands/dates must share the same grid."
-                            )
-                    band_arrays[band_name.upper()] = arr
+                    band_arrays[band_name.upper()] = _read_aligned(
+                        Path(band_path), date, band_name
+                    )
                 arr = np.asarray(si.compute(self.index_name, **band_arrays), dtype=np.float32)
 
             arrays.append(arr)
@@ -397,4 +433,4 @@ class TimeSeriesAnalyzer:
         with np.errstate(divide="ignore", invalid="ignore"):
             z = np.where(baseline_std > 0, (target_arr - baseline_mean) / baseline_std, np.nan)
 
-        return z
+        return z

{pygeofetch-1.3.0 → pygeofetch-1.4.0}/pygeofetch/providers/copernicus.py

@@ -338,7 +338,35 @@ class CopernicusProvider(AbstractBaseProvider):
         if query.end_date:
             filters.append(f"ContentDate/Start le {query.end_date}T23:59:59.000Z")
 
-        if query.bbox:
+        # Prefer a real polygon spatial filter over a bounding-box
+        # approximation when a geometry is given. Previously query.geometry
+        # was never checked here at all — only query.bbox — meaning any
+        # search using geometry= (not bbox=) had NO spatial constraint
+        # applied whatsoever: the query scanned Copernicus's entire global
+        # archive for the date/product-type/polarisation criteria, sorted
+        # by most-recent-first, with location playing no role at all. This
+        # is confirmed to be the actual explanation for a real search
+        # returning a Sentinel-1 scene over the Yucatán Peninsula, Mexico
+        # for a query intended for Accra, Ghana — not a GCP-reading or
+        # georeferencing bug downstream, which was independently tested
+        # and ruled out. This is the exact same bug class (a field never
+        # checked at all) found and fixed for USGS earlier — it just
+        # hadn't been checked for Copernicus specifically until now.
+        geometry = getattr(query, "geometry", None)
+        if geometry:
+            geom_type = geometry.get("type", "Polygon")
+            coordinates = geometry.get("coordinates")
+            if coordinates and geom_type == "Polygon":
+                # OData.CSC.Intersects expects a WKT POLYGON — build it
+                # directly from the GeoJSON ring, not a bbox approximation,
+                # so search results are constrained to the real AOI shape.
+                ring = coordinates[0]
+                coord_str = ",".join(f"{lon} {lat}" for lon, lat in ring)
+                polygon = f"POLYGON(({coord_str}))"
+                filters.append(
+                    f"OData.CSC.Intersects(area=geography'SRID=4326;{polygon}')"
+                )
+        elif query.bbox:
             bbox = query.bbox
             polygon = (
                 f"POLYGON(("
@@ -727,10 +755,24 @@ class CopernicusProvider(AbstractBaseProvider):
         for attempt in range(1, max_attempts + 1):
             try:
                 start_time = time.time()
+
+                # Resume from where the previous attempt left off, rather
+                # than deleting the partial file and restarting the whole
+                # download from zero on every retry — confirmed this was
+                # happening: for a multi-GB Sentinel-1 product, a dropped
+                # connection at 1GB+ into the transfer meant every retry
+                # re-downloaded that same 1GB+ again before even reaching
+                # new data, on a connection that had just shown it
+                # couldn't sustain the transfer in the first place.
+                existing_bytes = output_file.stat().st_size if output_file.exists() else 0
+                headers = {"Authorization": f"Bearer {self._session.access_token}"}  # type: ignore
+                if existing_bytes > 0:
+                    headers["Range"] = f"bytes={existing_bytes}-"
+
                 with httpx.stream(
                     "GET",
                     href,
-                    headers={"Authorization": f"Bearer {self._session.access_token}"},  # type: ignore
+                    headers=headers,
                     timeout=options.timeout_seconds,
                     follow_redirects=True,
                 ) as resp:
@@ -749,17 +791,33 @@ class CopernicusProvider(AbstractBaseProvider):
                             response=resp,
                         )
                     self._handle_http_error(resp)
+
+                    # CDSE is documented to sometimes ignore Range headers
+                    # and return the full file (200) instead of resuming
+                    # (206) — check which actually happened rather than
+                    # assume the Range request was honoured.
+                    resumed = existing_bytes > 0 and resp.status_code == 206
+                    if existing_bytes > 0 and resp.status_code == 200:
+                        # Server sent the whole file despite the Range
+                        # request — start writing from scratch, not append,
+                        # or the file would be corrupted with duplicated
+                        # content at the front.
+                        existing_bytes = 0
+
                     total_bytes = int(resp.headers.get("content-length", 0))
-                    bytes_written = 0
+                    if resumed:
+                        total_bytes += existing_bytes
+                    bytes_written = existing_bytes
                     chunk_t0 = time.time()
-                    with open(output_file, "wb") as f:
+                    write_mode = "ab" if resumed else "wb"
+                    with open(output_file, write_mode) as f:
                         for chunk in resp.iter_bytes(
                             chunk_size=int(options.chunk_size_mb * 1024 * 1024)
                         ):
                             f.write(chunk)
                             bytes_written += len(chunk)
                             elapsed = time.time() - chunk_t0
-                            speed = bytes_written / elapsed if elapsed > 0 else 0.0
+                            speed = (bytes_written - existing_bytes) / elapsed if elapsed > 0 else 0.0
                             report_download_progress(bytes_written, total_bytes, speed)
 
                 duration = time.time() - start_time
@@ -782,15 +840,37 @@ class CopernicusProvider(AbstractBaseProvider):
             except Exception as exc:
                 last_error = str(exc)
                 last_error_type = type(exc).__name__
-                output_file.unlink(missing_ok=True)
+                # No longer unconditionally deleting the partial file here —
+                # the next attempt (or the whole retry loop, if this was
+                # the final attempt) needs it intact to resume from.
                 if attempt < max_attempts:
-                    backoff = min(2**attempt, 30)
+                    # Base backoff scaled by how much has already been
+                    # downloaded — a connection that just dropped a
+                    # multi-GB transfer needs meaningfully more recovery
+                    # time than the previous flat min(2**attempt, 30)
+                    # gave it (as little as 1-2 seconds on early attempts,
+                    # confirmed against a real 1GB+ download that had
+                    # just timed out).
+                    current_size_gb = (
+                        output_file.stat().st_size / (1024**3)
+                        if output_file.exists()
+                        else 0
+                    )
+                    size_factor = max(1.0, current_size_gb * 10)
+                    backoff = min(15 * size_factor * attempt, 120)
                     self._logger.warning(
                         f"Download attempt {attempt}/{max_attempts} failed for "
-                        f"{data.id}: {last_error}. Retrying in {backoff}s..."
+                        f"{data.id}: {last_error}. Resuming from "
+                        f"{output_file.stat().st_size / (1024**2):.0f}MB in "
+                        f"{backoff:.0f}s..."
+                        if output_file.exists()
+                        else f"Download attempt {attempt}/{max_attempts} failed for "
+                        f"{data.id}: {last_error}. Retrying in {backoff:.0f}s..."
                     )
                     time.sleep(backoff)
 
+        # Final failure — clean up only now, not on every intermediate retry
+        output_file.unlink(missing_ok=True)
         return DownloadResult(
             status=DownloadStatus.FAILED,
             data_id=data.id,
@@ -917,4 +997,4 @@ class CopernicusProvider(AbstractBaseProvider):
                 "note": "Copernicus provides free access; rate limits may apply",
                 "docs": "https://dataspace.copernicus.eu/terms-and-conditions",
             },
-        )
+        )

pygeofetch-1.4.0/pygeofetch/sar/__init__.py

@@ -0,0 +1,22 @@
+"""
+PyGeoFetch SAR — optional SAR processing layer.
+
+Lightweight backend (sarxarray): pip install "pygeofetch[sar]"
+Heavy backend (SNAP via OST):    pip install "pygeofetch[ost]"
+
+Usage::
+
+    from pygeofetch.sar import SARProcessor, GRDExtractor
+
+    extractor = GRDExtractor(polarisation="VV")
+    vv_path = extractor.extract_band(download_result, output_dir="./data")
+
+    proc   = SARProcessor(backend="sarxarray")  # lightweight
+    result = proc.calibrate(str(vv_path), output_type="sigma0")
+    result = proc.despeckle("calibrated.tif", filter="lee")
+"""
+
+from pygeofetch.sar.extraction import GRDExtractor, georeference_via_gcps_if_needed
+from pygeofetch.sar.processor import SARProcessor
+
+__all__ = ["SARProcessor", "GRDExtractor", "georeference_via_gcps_if_needed"]