PyGeoFetch 2.6.4.0__tar.gz → 2.6.5.0__tar.gz

{pygeofetch-2.6.4.0 → pygeofetch-2.6.5.0}/CHANGELOG.md

@@ -20,7 +20,7 @@ date, and marked accordingly rather than filled in with invented
 bullet points.
 ```
 
-## [Unreleased] — v2.6.4.0.4
+## [Unreleased] — v2.6.5.0.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.4.0.4] — 2026-08-25 (latest)
+## [2.6.5.0.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.4.0] — 2026-08-24
+## [2.6.5.0] — 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.4.0.4 — 2026-07-12"** describing 22+ providers, Sentinel-1C/1D
+**"2.6.5.0.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.4.0.4 was
+management, 17 spectral indices, and various bug fixes. **2.6.5.0.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.4.0.4`**, dated
-   2026-07-29 and 2026-07-12. **2.6.4.0.4 was only ever released once**,
+1. **Two different entries were both labeled `2.6.5.0.4`**, dated
+   2026-07-29 and 2026-07-12. **2.6.5.0.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.4.0/pygeofetch.egg-info → pygeofetch-2.6.5.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pygeofetch
-Version: 2.6.4.0
+Version: 2.6.5.0
 Summary: Universal satellite data pipeline + geospatial processing platform
 Author-email: Samuel Appiah Kubi <appiahkubis14@gmail.com>
 License: MIT License
@@ -26,7 +26,7 @@ License: MIT License
         SOFTWARE.
         
 Project-URL: Homepage, https://www.eocoreint.com/
-Project-URL: Documentation, https://appiahkubis14.github.io/pygeofetch-docs/
+Project-URL: Documentation, https://pygeofetch.readthedocs.io/en/latest/ 
 Project-URL: Repository, https://github.com/EOCoreINT/pygeofetch
 Project-URL: Bug Tracker, https://github.com/EOCoreINT/pygeofetch/issues
 Keywords: satellite,remote-sensing,GIS,earth-observation,geospatial,SAR,Sentinel,Landsat
@@ -371,7 +371,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.4.0.1},
+  version      = {2.6.5.0.1},
   doi          = {10.5281/zenodo.22087230},
   url          = {https://doi.org/10.5281/zenodo.22087230}
 }

{pygeofetch-2.6.4.0 → pygeofetch-2.6.5.0}/README.md

@@ -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.4.0.1},
+  version      = {2.6.5.0.1},
   doi          = {10.5281/zenodo.22087230},
   url          = {https://doi.org/10.5281/zenodo.22087230}
 }

{pygeofetch-2.6.4.0 → pygeofetch-2.6.5.0}/pygeofetch/__init__.py

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

pygeofetch-2.6.5.0/pygeofetch/insar/network_thinning.py

@@ -0,0 +1,285 @@
+"""
+Download-budget thinning that never breaks the interferometric network.
+
+A full Sentinel-1 SLC is ~7.5 GB, so a 4-year, 6-day-repeat stack is >1.6 TB.
+Most time-series work does not need every acquisition, so this module picks an
+evenly spaced subset of acquisition *dates* -- and guarantees the result is
+still a connected SBAS network:
+
+* every kept date has at least one partner within ``max_temporal_baseline_days``
+  (and, where possible, ``min_redundancy`` partners);
+* the number of disconnected components is never larger than in the full
+  stack (data gaps in the archive cannot be repaired, but thinning will not
+  create new ones);
+* if a download budget cannot be met without disconnecting the network, the
+  network wins and the report says by how much the budget was exceeded.
+
+Pure functions, no network, no I/O.
+"""
+
+from __future__ import annotations
+
+import math
+from collections.abc import Sequence
+from dataclasses import dataclass, field
+from datetime import date
+
+
+def _d(iso: str) -> date:
+    return date.fromisoformat(iso[:10])
+
+
+def _days(a: str, b: str) -> int:
+    return (_d(b) - _d(a)).days
+
+
+@dataclass
+class NetworkStats:
+    """Connectivity of the temporal-baseline-limited pair graph."""
+
+    n_dates: int
+    n_pairs: int
+    n_components: int
+    min_redundancy: int  # smallest number of partners any date has
+    weak_dates: list[str] = field(default_factory=list)  # dates below target
+
+
+@dataclass
+class ThinningResult:
+    kept: list[str]
+    dropped: list[str]
+    requested_days: int | None
+    effective_days: int | None
+    gb_per_scene: float
+    gb_before: float
+    gb_after: float
+    max_gb: float | None
+    budget_met: bool
+    stats_before: NetworkStats
+    stats_after: NetworkStats
+    notes: list[str] = field(default_factory=list)
+
+    @property
+    def changed(self) -> bool:
+        return bool(self.dropped)
+
+
+def network_stats(
+    dates: Sequence[str],
+    max_temporal_baseline_days: int,
+    min_redundancy: int = 2,
+) -> NetworkStats:
+    """Union-find over pairs closer than ``max_temporal_baseline_days``."""
+    ds = sorted(set(dates))
+    n = len(ds)
+    parent = list(range(n))
+
+    def find(i: int) -> int:
+        while parent[i] != i:
+            parent[i] = parent[parent[i]]
+            i = parent[i]
+        return i
+
+    degree = [0] * n
+    pairs = 0
+    ords = [_d(x).toordinal() for x in ds]
+    for i in range(n):
+        j = i + 1
+        while j < n and ords[j] - ords[i] <= max_temporal_baseline_days:
+            pairs += 1
+            degree[i] += 1
+            degree[j] += 1
+            ri, rj = find(i), find(j)
+            if ri != rj:
+                parent[ri] = rj
+            j += 1
+    comps = len({find(i) for i in range(n)}) if n else 0
+    weak = [ds[i] for i in range(n) if degree[i] < min_redundancy]
+    return NetworkStats(
+        n_dates=n,
+        n_pairs=pairs,
+        n_components=comps,
+        min_redundancy=min(degree) if n else 0,
+        weak_dates=weak,
+    )
+
+
+def _cadence_pick(dates: list[str], every_days: int) -> list[str]:
+    """Evenly spaced subset: after each kept date take the acquisition closest
+    to ``last + every_days`` (never nearer than half a step)."""
+    if not dates or every_days <= 1:
+        return list(dates)
+    ords = [_d(x).toordinal() for x in dates]
+    kept_idx = [0]
+    while True:
+        last = ords[kept_idx[-1]]
+        target = last + every_days
+        floor = last + max(1, every_days // 2)
+        best: int | None = None
+        for j in range(kept_idx[-1] + 1, len(dates)):
+            if ords[j] < floor:
+                continue
+            if best is None or abs(ords[j] - target) < abs(ords[best] - target):
+                best = j
+            if ords[j] > target:
+                break
+        if best is None:
+            break
+        kept_idx.append(best)
+    kept = [dates[i] for i in kept_idx]
+    # keep the final acquisition so the time span is not silently shortened
+    if kept[-1] != dates[-1] and _days(kept[-1], dates[-1]) >= every_days // 2:
+        kept.append(dates[-1])
+    return kept
+
+
+def _repair_connectivity(
+    kept: list[str],
+    all_dates: list[str],
+    max_tb: int,
+    target_components: int,
+) -> tuple[list[str], list[str]]:
+    """Add back the dropped dates that reconnect the network."""
+    kept_set = set(kept)
+    added: list[str] = []
+    while network_stats(sorted(kept_set), max_tb).n_components > target_components:
+        cur = network_stats(sorted(kept_set), max_tb).n_components
+        best, best_c = None, cur
+        for d in all_dates:
+            if d in kept_set:
+                continue
+            c = network_stats(sorted(kept_set | {d}), max_tb).n_components
+            if c < best_c:
+                best, best_c = d, c
+        if best is None:
+            # no single date helps (gap wider than 2x baseline): bridge the
+            # widest remaining gap with its midpoint-most dropped date
+            ks = sorted(kept_set)
+            gaps = [
+                (_days(a, b), a, b) for a, b in zip(ks, ks[1:]) if _days(a, b) > max_tb
+            ]
+            if not gaps:
+                break
+            _, a, b = max(gaps)
+            mid = (_d(a).toordinal() + _d(b).toordinal()) / 2
+            cand = [d for d in all_dates if a < d < b and d not in kept_set]
+            if not cand:
+                break
+            best = min(cand, key=lambda d: abs(_d(d).toordinal() - mid))
+        kept_set.add(best)
+        added.append(best)
+    return sorted(kept_set), added
+
+
+def thin_dates(
+    dates: Sequence[str],
+    *,
+    max_temporal_baseline_days: int,
+    thin_to_days: int | None = None,
+    max_download_gb: float | None = None,
+    gb_per_scene: float = 7.5,
+    min_redundancy: int = 2,
+) -> ThinningResult:
+    """Choose a connected, evenly spaced subset of ``dates``."""
+    all_dates = sorted(set(dates))
+    before = network_stats(all_dates, max_temporal_baseline_days, min_redundancy)
+    gb_before = len(all_dates) * gb_per_scene
+    notes: list[str] = []
+
+    def finish(kept: list[str], eff: int | None, met: bool) -> ThinningResult:
+        kept = sorted(kept)
+        after = network_stats(kept, max_temporal_baseline_days, min_redundancy)
+        return ThinningResult(
+            kept=kept,
+            dropped=[d for d in all_dates if d not in set(kept)],
+            requested_days=thin_to_days,
+            effective_days=eff,
+            gb_per_scene=gb_per_scene,
+            gb_before=gb_before,
+            gb_after=len(kept) * gb_per_scene,
+            max_gb=max_download_gb,
+            budget_met=met,
+            stats_before=before,
+            stats_after=after,
+            notes=notes,
+        )
+
+    if len(all_dates) < 3 or (thin_to_days is None and max_download_gb is None):
+        return finish(all_dates, None, True)
+
+    span = _days(all_dates[0], all_dates[-1])
+    # Largest step that still gives every date `min_redundancy` partners.
+    step_cap = max(1, max_temporal_baseline_days // max(1, min_redundancy))
+
+    step = thin_to_days or 1
+    if thin_to_days and thin_to_days > step_cap:
+        notes.append(
+            f"thin_to_days={thin_to_days} lowered to {step_cap}: with a "
+            f"{max_temporal_baseline_days}-day temporal baseline a coarser "
+            f"cadence leaves dates with fewer than {min_redundancy} partners."
+        )
+        step = step_cap
+
+    budget_n: int | None = None
+    if max_download_gb is not None:
+        budget_n = max(2, int(max_download_gb // gb_per_scene))
+        needed = math.ceil(span / max(1, step)) + 1
+        if needed > budget_n:
+            step = max(step, math.ceil(span / max(1, budget_n - 1)))
+
+    # The network must stay connected: step can never exceed the baseline.
+    hard_cap = max(1, max_temporal_baseline_days)
+    if step > hard_cap:
+        notes.append(
+            f"A {step}-day cadence would disconnect the network (temporal "
+            f"baseline {max_temporal_baseline_days} d); using {hard_cap} d."
+        )
+        step = hard_cap
+
+    kept = _cadence_pick(all_dates, step)
+    kept, added = _repair_connectivity(
+        kept, all_dates, max_temporal_baseline_days, before.n_components
+    )
+    if added:
+        notes.append(
+            f"{len(added)} date(s) added back to keep the network connected: "
+            f"{', '.join(added[:5])}{' ...' if len(added) > 5 else ''}."
+        )
+
+    # Trim only if over budget AND removal cannot disconnect anything.
+    if budget_n is not None and len(kept) > budget_n:
+        base = network_stats(kept, max_temporal_baseline_days).n_components
+        while len(kept) > budget_n and len(kept) > 2:
+            order = sorted(
+                range(1, len(kept) - 1),
+                key=lambda i: _days(kept[i - 1], kept[i + 1]),
+            )
+            for i in order:
+                trial = kept[:i] + kept[i + 1 :]
+                if (
+                    network_stats(trial, max_temporal_baseline_days).n_components
+                    <= base
+                ):
+                    kept = trial
+                    break
+            else:
+                break
+
+    met = budget_n is None or len(kept) <= budget_n
+    if not met:
+        notes.append(
+            f"Budget of {max_download_gb:g} GB would need <= {budget_n} scenes, "
+            f"but keeping the network connected needs {len(kept)} "
+            f"({len(kept) * gb_per_scene:.0f} GB). Raise the budget or the "
+            f"temporal baseline (max_temporal_baseline_days)."
+        )
+    return finish(kept, step, met)
+
+
+def date_groups(scenes: Sequence[object]) -> dict[str, list[object]]:
+    """Group scene objects by acquisition date (``scene.datetime``)."""
+    out: dict[str, list[object]] = {}
+    for s in scenes:
+        key = str(getattr(s, "datetime", ""))[:10]
+        out.setdefault(key, []).append(s)
+    return out

{pygeofetch-2.6.4.0 → pygeofetch-2.6.5.0}/pygeofetch/insar/preflight.py

@@ -212,6 +212,10 @@ class PreflightGate:
         max_runtime_s: Optional[float] = 900.0,
         log_file: Optional[Any] = None,
         print_summary: bool = True,
+        # Download budget:
+        thin_to_days: Optional[int] = None,
+        max_download_gb: Optional[float] = None,
+        gb_per_scene: float = 7.5,
     ) -> None:
         """
         Notebook-friendly options (all optional):
@@ -231,7 +235,24 @@ class PreflightGate:
                        per-day file in the system temp folder; the path is
                        shown in the summary and on ``report.log_file``).
         print_summary: print ``report.summary()`` when ``run()`` finishes.
+
+        Download budget (both off by default; nothing changes unless set):
+
+        thin_to_days:    keep roughly one acquisition per this many days
+                         (e.g. 12 or 24) instead of every one.
+        max_download_gb: upper limit for the estimated download; the cadence
+                         is coarsened until the estimate fits.
+        gb_per_scene:    size used for that estimate (Sentinel-1 SLC ~7.5 GB).
+
+        Thinning always keeps the interferometric network connected (see
+        :mod:`pygeofetch.insar.network_thinning`).  If a budget cannot be met
+        without disconnecting it, the network wins and the report says so.
+        It runs BEFORE the burst/orbit check, so fewer scenes also means far
+        fewer network requests.
         """
+        self.thin_to_days = thin_to_days
+        self.max_download_gb = max_download_gb
+        self.gb_per_scene = float(gb_per_scene)
         self.verbose = verbose
         self.show_progress = show_progress
         self.max_workers = max(1, int(max_workers))
@@ -340,6 +361,10 @@ class PreflightGate:
         selected, cov_issues = self._check_coverage(selected)
         issues.extend(cov_issues)
 
+        # Check 2b: optional download budget (thin dates, keep network connected)
+        selected, thin_issues, thinning = self._apply_download_budget(selected)
+        issues.extend(thin_issues)
+
         # Check 3: temporal sampling / predicted SBAS connectivity
         issues.extend(self._check_temporal_network(selected))
 
@@ -348,8 +373,21 @@ class PreflightGate:
         selected, burst_issues = self._screen_burst_families(selected, geometry_report)
         issues.extend(burst_issues)
 
+        issues.extend(self._recheck_network_after_screening(selected, thinning))
+
         # Build the provenance manifest from everything we now know
         manifest = self._build_manifest(selected, search_report, issues)
+        if thinning is not None:
+            manifest["thinning"] = {
+                "requested_days": thinning.requested_days,
+                "effective_days": thinning.effective_days,
+                "max_download_gb": thinning.max_gb,
+                "gb_before": thinning.gb_before,
+                "gb_after": thinning.gb_after,
+                "budget_met": thinning.budget_met,
+                "dropped_dates": thinning.dropped,
+                "notes": thinning.notes,
+            }
 
         # Decide go/no-go
         severity = self._overall_severity(issues)
@@ -479,6 +517,97 @@ class PreflightGate:
             )
         return kept, issues
 
+    # ── Check 2b: download budget ─────────────────────────────────────────
+    def _apply_download_budget(
+        self, selected: List[Any]
+    ) -> Tuple[List[Any], List[PreflightIssue], Optional[Any]]:
+        if self.thin_to_days is None and self.max_download_gb is None:
+            return selected, [], None
+        from pygeofetch.insar.network_thinning import thin_dates
+
+        dates = [str(s.datetime)[:10] for s in selected]
+        res = thin_dates(
+            dates,
+            max_temporal_baseline_days=self.max_temporal_baseline_days,
+            thin_to_days=self.thin_to_days,
+            max_download_gb=self.max_download_gb,
+            gb_per_scene=self.gb_per_scene,
+            min_redundancy=self.min_network_redundancy,
+        )
+        if not res.changed and not res.notes:
+            return selected, [], res
+        keep = set(res.kept)
+        new_sel = [s for s in selected if str(s.datetime)[:10] in keep]
+        a, b = res.stats_after, res.stats_before
+        detail = (
+            f"{len(res.kept)} of {len(set(dates))} dates kept "
+            f"(~{res.effective_days} d cadence), "
+            f"{res.gb_before:.0f} -> {res.gb_after:.0f} GB; network: "
+            f"{a.n_components} component(s) (was {b.n_components}), every "
+            f"date has >= {a.min_redundancy} partner(s) within "
+            f"{self.max_temporal_baseline_days} d."
+        )
+        issues = [
+            PreflightIssue(
+                code="DOWNLOAD_BUDGET_APPLIED",
+                severity=SEVERITY_GREEN,
+                message="Download size reduced by thinning acquisition dates.",
+                auto_fixed=True,
+                fix_detail=detail,
+            )
+        ]
+        if not res.budget_met or res.notes:
+            issues.append(
+                PreflightIssue(
+                    code="DOWNLOAD_BUDGET_NOTE",
+                    severity=SEVERITY_YELLOW if not res.budget_met else SEVERITY_GREEN,
+                    message=" ".join(res.notes),
+                )
+            )
+        if a.weak_dates and a.n_components <= b.n_components:
+            issues.append(
+                PreflightIssue(
+                    code="THINNED_NETWORK_REDUNDANCY",
+                    severity=SEVERITY_YELLOW,
+                    message=(
+                        f"{len(a.weak_dates)} date(s) have fewer than "
+                        f"{self.min_network_redundancy} partners after thinning. "
+                        f"The network is connected but thin; raise "
+                        f"max_temporal_baseline_days or max_download_gb for "
+                        f"more redundancy."
+                    ),
+                )
+            )
+        return new_sel, issues, res
+
+    def _recheck_network_after_screening(
+        self, selected: List[Any], thinning: Optional[Any]
+    ) -> List[PreflightIssue]:
+        """The burst check can drop dates after thinning; confirm the final
+        set is still as connected as the full archive was."""
+        if thinning is None:
+            return []
+        from pygeofetch.insar.network_thinning import network_stats
+
+        dates = sorted({str(s.datetime)[:10] for s in selected})
+        st = network_stats(
+            dates, self.max_temporal_baseline_days, self.min_network_redundancy
+        )
+        if st.n_components > thinning.stats_before.n_components:
+            return [
+                PreflightIssue(
+                    code="NETWORK_DISCONNECTED_AFTER_SCREEN",
+                    severity=SEVERITY_RED,
+                    message=(
+                        f"After burst/orbit screening the thinned network has "
+                        f"{st.n_components} disconnected parts (full archive: "
+                        f"{thinning.stats_before.n_components}). Use a finer "
+                        f"thin_to_days or a larger max_download_gb."
+                    ),
+                )
+            ]
+        return []
+
     # ── Check 3: temporal network prediction ──────────────────────────────
     def _check_temporal_network(self, selected: List[Any]) -> List[PreflightIssue]:
         """
@@ -1210,7 +1339,7 @@ class PreflightGate:
         # ── FIX: BANDWIDTH & DOWNLOAD MANIFEST ──
         # Calculate estimated bandwidth and build a concrete manifest of
         # what will actually be downloaded, preventing surprise disk fills.
-        ESTIMATED_GB_PER_SLC_SCENE = 7.5  # Sentinel-1 IW SLC average size
+        ESTIMATED_GB_PER_SLC_SCENE = self.gb_per_scene  # Sentinel-1 IW SLC ~7.5
         estimated_bandwidth_gb = len(selected) * ESTIMATED_GB_PER_SLC_SCENE
 
         download_manifest = []

{pygeofetch-2.6.4.0 → pygeofetch-2.6.5.0}/pygeofetch/meta.yaml

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

{pygeofetch-2.6.4.0 → pygeofetch-2.6.5.0/pygeofetch.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pygeofetch
-Version: 2.6.4.0
+Version: 2.6.5.0
 Summary: Universal satellite data pipeline + geospatial processing platform
 Author-email: Samuel Appiah Kubi <appiahkubis14@gmail.com>
 License: MIT License
@@ -26,7 +26,7 @@ License: MIT License
         SOFTWARE.
         
 Project-URL: Homepage, https://www.eocoreint.com/
-Project-URL: Documentation, https://appiahkubis14.github.io/pygeofetch-docs/
+Project-URL: Documentation, https://pygeofetch.readthedocs.io/en/latest/ 
 Project-URL: Repository, https://github.com/EOCoreINT/pygeofetch
 Project-URL: Bug Tracker, https://github.com/EOCoreINT/pygeofetch/issues
 Keywords: satellite,remote-sensing,GIS,earth-observation,geospatial,SAR,Sentinel,Landsat
@@ -371,7 +371,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.4.0.1},
+  version      = {2.6.5.0.1},
   doi          = {10.5281/zenodo.22087230},
   url          = {https://doi.org/10.5281/zenodo.22087230}
 }

{pygeofetch-2.6.4.0 → pygeofetch-2.6.5.0}/pygeofetch.egg-info/SOURCES.txt

@@ -67,6 +67,7 @@ pygeofetch/insar/geolocation.py
 pygeofetch/insar/gpu.py
 pygeofetch/insar/interferogram.py
 pygeofetch/insar/ionosphere.py
+pygeofetch/insar/network_thinning.py
 pygeofetch/insar/offset_geometry.py
 pygeofetch/insar/offset_tracking.py
 pygeofetch/insar/preflight.py
@@ -213,6 +214,7 @@ tests/test_models.py
 tests/test_monitor.py
 tests/test_nasa_earthdata_cloud_s3_fix.py
 tests/test_nasa_earthdata_public_search.py
+tests/test_network_thinning.py
 tests/test_noaa_big_data.py
 tests/test_offset_tracking.py
 tests/test_opentopography_pointcloud_usgs.py

{pygeofetch-2.6.4.0 → pygeofetch-2.6.5.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "pygeofetch"
-version = "2.6.4.0"
+version = "2.6.5.0"
 description = "Universal satellite data pipeline + geospatial processing platform"
 readme = "README.md"
 license = { file = "LICENSE" }
@@ -235,7 +235,7 @@ pygeofetch = "pygeofetch.cli.main:cli"
 
 [project.urls]
 Homepage      = "https://www.eocoreint.com/"
-Documentation = "https://appiahkubis14.github.io/pygeofetch-docs/"
+Documentation = "https://pygeofetch.readthedocs.io/en/latest/ "
 Repository    = "https://github.com/EOCoreINT/pygeofetch"
 "Bug Tracker" = "https://github.com/EOCoreINT/pygeofetch/issues"