PyGeoFetch 2.0.9__py3-none-any.whl → 2.1.0__py3-none-any.whl

pygeofetch/__init__.py

@@ -1,5 +1,5 @@
 """
-PyGeoFetch v2.0.9 — Universal Satellite Data Pipeline.
+PyGeoFetch v2.1.0 — Universal Satellite Data Pipeline.
 
 Unified access to 22+ satellite data providers with a consistent
 Python API and CLI. Supports authentication management, federated search,
@@ -30,7 +30,7 @@ CLI::
     pygeofetch doctor
 """
 
-__version__ = "2.0.9"
+__version__ = "2.1.0"
 __author__ = "PyGeoFetch Contributors"
 __license__ = "MIT"
 

pygeofetch/cli/main.py

@@ -1,5 +1,5 @@
 """
-PyGeoFetch CLI v2.0.9 main entry point.
+PyGeoFetch CLI v2.1.0 main entry point.
 
 Full command reference:
   pygeofetch auth       — credential management
@@ -71,7 +71,7 @@ def cli(
 ) -> None:
     """
     \b
-    PyGeoFetch v2.0.9 — Universal Satellite Data Pipeline
+    PyGeoFetch v2.1.0 — Universal Satellite Data Pipeline
     ===========================================================
     Unified access to 22+ satellite data providers.
 

pygeofetch/insar/unwrap.py

@@ -29,6 +29,7 @@ import zipfile
 import shutil
 import json
 import tempfile
+import io
 from dataclasses import dataclass, field
 from pathlib import Path
 from typing import Any, Dict, Optional, Tuple, Union
@@ -40,17 +41,11 @@ logger = logging.getLogger("pygeofetch.insar.unwrap")
 class UnwrapResult:
     """
     Result of phase unwrapping for one interferogram pair.
-    
-    Mirrors the InterferogramResult.save() pattern: the notebook cell
-    stays focused on orchestration (which pairs, what parameters), while
-    this class handles all file I/O, georeferencing, nodata masking,
-    and optional visualization.
     """
-
-    unwrapped_phase: Any      # float32 array, radians, continuous
-    conncomp: Any             # int32 array, 0 = unreliable/masked
-    coherence: Any            # float32 array, 0-1 (multilooked coherence used)
-    profile: Dict[str, Any]   # rasterio-style profile for georeferencing
+    unwrapped_phase: Any      
+    conncomp: Any             
+    coherence: Any            
+    profile: Dict[str, Any]   
     reference_date: Optional[str] = None
     secondary_date: Optional[str] = None
     nlooks: float = 1.0
@@ -65,29 +60,7 @@ class UnwrapResult:
         save_png: bool = False,
         mask_unreliable: bool = True,
     ) -> Dict[str, Path]:
-        """
-        Save unwrapped phase and connected components as GeoTIFFs.
-
-        Writes:
-            unwrapped_phase.tif   (float32, radians, nodata=-9999)
-            conncomp.tif          (int32, 0=unreliable)
-            coherence.tif         (float32, 0-1)
-            [optional] unwrapped_phase.png, conncomp.png
-
-        Args:
-            output_dir:       Directory to save into.
-            save_png:         If True, also save PNG visualizations.
-            mask_unreliable:  If True (default), pixels with conncomp==0
-                              are set to nodata in the unwrapped phase
-                              GeoTIFF. This is baked in automatically so
-                              every user gets correct nodata handling
-                              without having to remember to do it manually.
-
-        Returns:
-            Dict mapping product name to output path.
-        """
         import numpy as np
-
         try:
             import rasterio
         except ImportError:
@@ -110,7 +83,6 @@ class UnwrapResult:
             "blockysize": 256,
         }
 
-        # ── Unwrapped phase ──
         unw_to_save = self.unwrapped_phase.copy()
         if mask_unreliable:
             unw_to_save[self.conncomp == 0] = -9999.0
@@ -121,89 +93,58 @@ class UnwrapResult:
             dst.write(unw_to_save.astype(np.float32)[np.newaxis])
         paths["unwrapped_phase"] = phase_path
 
-        # ── Connected components ──
         cc_path = out_dir / "conncomp.tif"
         cc_profile = dict(base_profile, dtype="int32", nodata=0)
         with rasterio.open(cc_path, "w", **cc_profile) as dst:
             dst.write(self.conncomp.astype(np.int32)[np.newaxis])
         paths["conncomp"] = cc_path
 
-        # ── Coherence ──
         coh_path = out_dir / "coherence.tif"
         coh_profile = dict(base_profile, dtype="float32", nodata=-1.0)
         with rasterio.open(coh_path, "w", **coh_profile) as dst:
             dst.write(self.coherence.astype(np.float32)[np.newaxis])
         paths["coherence"] = coh_path
 
-        logger.info(
-            "Unwrap products saved → %s (reliable=%.1f%%)",
-            out_dir, self.reliable_fraction * 100,
-        )
+        logger.info("Unwrap products saved → %s (reliable=%.1f%%)", out_dir, self.reliable_fraction * 100)
 
-        # ── Optional PNG visualizations ──
         if save_png:
-            self._save_pngs(out_dir, unw_to_save, paths)
+            self._save_pngs(out_dir)
 
         return paths
 
-    def _save_pngs(self, out_dir: Path, unw_masked, paths: Dict[str, Path]) -> None:
-        """Save PNG visualizations with robust percentile scaling."""
+    def _save_pngs(self, out_dir: Path) -> None:
         import numpy as np
         import matplotlib
-        matplotlib.use("Agg")  # non-interactive backend for headless saving
+        matplotlib.use("Agg")
         import matplotlib.pyplot as plt
 
-        # ── Unwrapped phase PNG ──
         fig, ax = plt.subplots(1, 1, figsize=(14, 8))
         masked_unw = np.ma.masked_where(self.conncomp == 0, self.unwrapped_phase)
         finite_unw = self.unwrapped_phase[self.conncomp > 0]
         if finite_unw.size > 0:
-            vmin = float(np.percentile(finite_unw, 2))
-            vmax = float(np.percentile(finite_unw, 98))
+            vmin, vmax = float(np.percentile(finite_unw, 2)), float(np.percentile(finite_unw, 98))
         else:
             vmin, vmax = -np.pi, np.pi
         im = ax.imshow(masked_unw, cmap="jet", vmin=vmin, vmax=vmax)
-        ax.set_title(
-            f"Unwrapped Phase (rad)\n"
-            f"{self.reference_date} → {self.secondary_date} | "
-            f"reliable={self.reliable_fraction*100:.1f}%"
-        )
+        ax.set_title(f"Unwrapped Phase (rad)\n{self.reference_date} → {self.secondary_date} | reliable={self.reliable_fraction*100:.1f}%")
         fig.colorbar(im, ax=ax, fraction=0.046, pad=0.04)
-        png_path = out_dir / "unwrapped_phase.png"
-        fig.savefig(png_path, dpi=150, bbox_inches="tight")
+        fig.savefig(out_dir / "unwrapped_phase.png", dpi=150, bbox_inches="tight")
         plt.close(fig)
 
-        # ── Connected components PNG ──
         fig, ax = plt.subplots(1, 1, figsize=(14, 8))
         masked_cc = np.ma.masked_where(self.conncomp == 0, self.conncomp)
         ax.imshow(masked_cc, cmap="tab20")
-        ax.set_title(
-            f"Connected Components\n"
-            f"{self.reference_date} → {self.secondary_date} | "
-            f"reliable={self.reliable_fraction*100:.1f}%"
-        )
-        png_path = out_dir / "conncomp.png"
-        fig.savefig(png_path, dpi=150, bbox_inches="tight")
+        ax.set_title(f"Connected Components\n{self.reference_date} → {self.secondary_date}")
+        fig.savefig(out_dir / "conncomp.png", dpi=150, bbox_inches="tight")
         plt.close(fig)
 
-        logger.info("Unwrap PNGs saved → %s", out_dir)
-
 
 def _ensure_snaphu_cli() -> str:
-    """
-    Ensures the SNAPHU CLI executable is available.
-    1. Checks system PATH.
-    2. Checks ~/.pygeofetch/bin/snaphu(.exe).
-    3. If on Windows and missing, downloads the pre-compiled binary from GitHub.
-    """
     exe_name = "snaphu.exe" if platform.system() == "Windows" else "snaphu"
-    
-    # 1. System PATH
     path = shutil.which(exe_name)
     if path:
         return path
         
-    # 2. Local cache
     bin_dir = Path.home() / ".pygeofetch" / "bin"
     bin_dir.mkdir(parents=True, exist_ok=True)
     local_exe = bin_dir / exe_name
@@ -211,12 +152,8 @@ def _ensure_snaphu_cli() -> str:
     if local_exe.exists():
         return str(local_exe)
         
-    # 3. Download if on Windows
     if platform.system() == "Windows":
         logger.info("SNAPHU executable not found. Downloading pre-compiled binary for Windows...")
-        
-        # The official isce-framework/snaphu-py does not provide Windows wheels/binaries.
-        # We use marsfan/SNAPHU-win which reliably hosts pre-compiled Windows binaries.
         api_url = "https://api.github.com/repos/marsfan/SNAPHU-win/releases/latest"
         asset_url = None
         
@@ -224,17 +161,14 @@ def _ensure_snaphu_cli() -> str:
             req = urllib.request.Request(api_url, headers={'User-Agent': 'PyGeoFetch'})
             with urllib.request.urlopen(req, timeout=15) as response:
                 data = json.loads(response.read().decode())
-                
             for asset in data.get("assets", []):
-                name = asset["name"].lower()
-                if name.endswith(".zip") and "snaphu" in name:
+                if asset["name"].lower().endswith(".zip") and "snaphu" in asset["name"].lower():
                     asset_url = asset["browser_download_url"]
                     break
         except Exception as e:
             logger.warning(f"Could not query GitHub API for SNAPHU binary: {e}")
             
         if not asset_url:
-            # Hardcoded fallback to the known working 2.0.7 release
             asset_url = "https://github.com/marsfan/SNAPHU-win/releases/download/2.0.7/snaphu-v2.0.7.zip"
             
         logger.info(f"Downloading SNAPHU from {asset_url}...")
@@ -242,126 +176,82 @@ def _ensure_snaphu_cli() -> str:
             with tempfile.TemporaryDirectory() as tmp_dir:
                 zip_path = Path(tmp_dir) / "snaphu.zip"
                 urllib.request.urlretrieve(asset_url, str(zip_path))
-                
                 with zipfile.ZipFile(zip_path, 'r') as zf:
-                    # Look for snaphu.exe inside the zip (might be in a subfolder)
                     exe_files = [f for f in zf.namelist() if f.lower().endswith(".exe") and "snaphu" in f.lower()]
                     if not exe_files:
                         exe_files = [f for f in zf.namelist() if f.lower().endswith(".exe")]
-                    if not exe_files:
-                        raise RuntimeError("Downloaded zip did not contain an .exe file.")
-                    
                     with zf.open(exe_files[0]) as src, open(local_exe, "wb") as dst:
                         shutil.copyfileobj(src, dst)
-                        
             logger.info(f"SNAPHU downloaded successfully to {local_exe}")
             return str(local_exe)
         except Exception as e:
             raise RuntimeError(f"Failed to download/extract SNAPHU executable: {e}")
             
-    else:
-        raise RuntimeError(
-            "SNAPHU executable not found in PATH.\n"
-            "Please install it using your system package manager:\n"
-            "  Ubuntu/Debian: sudo apt-get install snaphu\n"
-            "  macOS (Homebrew): brew install snaphu\n"
-            "Or install the Python bindings: pip install snaphu"
-        )
-
-def goldstein_filter(
-    interferogram,
-    alpha: float = 0.5,
-    tile_size: int = 32,
-    overlap: float = 0.5,
-):
-    """
-    Adaptive Goldstein phase filter.
-    """
-    import numpy as np
+    raise RuntimeError(
+        "SNAPHU executable not found in PATH.\n"
+        "Please install it using your system package manager:\n"
+        "  Ubuntu/Debian: sudo apt-get install snaphu\n"
+        "  macOS (Homebrew): brew install snaphu\n"
+        "Or install the Python bindings: pip install snaphu"
+    )
+
 
+def goldstein_filter(interferogram, alpha: float = 0.5, tile_size: int = 32, overlap: float = 0.5):
+    import numpy as np
     interferogram = np.asarray(interferogram, dtype=np.complex64)
     h, w = interferogram.shape
     step = max(1, int(tile_size * (1 - overlap)))
     window_1d = np.hanning(tile_size)
     window_2d = np.outer(window_1d, window_1d).astype(np.float32)
-
     output = np.zeros((h, w), dtype=np.complex64)
     weight_sum = np.zeros((h, w), dtype=np.float32)
-
     row_starts = list(range(0, max(1, h - tile_size + 1), step))
     col_starts = list(range(0, max(1, w - tile_size + 1), step))
-    if not row_starts or row_starts[-1] + tile_size < h:
-        row_starts.append(max(0, h - tile_size))
-    if not col_starts or col_starts[-1] + tile_size < w:
-        col_starts.append(max(0, w - tile_size))
-
+    if not row_starts or row_starts[-1] + tile_size < h: row_starts.append(max(0, h - tile_size))
+    if not col_starts or col_starts[-1] + tile_size < w: col_starts.append(max(0, w - tile_size))
     for row_start in row_starts:
         for col_start in col_starts:
             r_end = min(row_start + tile_size, h)
             c_end = min(col_start + tile_size, w)
             tile = interferogram[row_start:r_end, col_start:c_end]
             th, tw = tile.shape
-            if th < 2 or tw < 2:
-                continue
-
+            if th < 2 or tw < 2: continue
             spectrum = np.fft.fft2(tile)
             magnitude = np.abs(spectrum)
             peak = magnitude.max()
-            if peak > 0:
-                filtered_spectrum = spectrum * (magnitude ** alpha) / (peak ** alpha)
-            else:
-                filtered_spectrum = spectrum
+            if peak > 0: filtered_spectrum = spectrum * (magnitude ** alpha) / (peak ** alpha)
+            else: filtered_spectrum = spectrum
             filtered_tile = np.fft.ifft2(filtered_spectrum)
-
             tile_window = window_2d[:th, :tw]
             output[row_start:r_end, col_start:c_end] += filtered_tile * tile_window
             weight_sum[row_start:r_end, col_start:c_end] += tile_window
-
     valid = weight_sum > 0
     output[valid] /= weight_sum[valid]
     output[~valid] = interferogram[~valid]
     return output.astype(np.complex64)
 
 
-def bridge_unwrap_regions(
-    unwrapped_phase,
-    conncomp,
-    bridge_radius: int = 50,
-    min_region_size: int = 100,
-    reference_pixel=None,
-):
-    """
-    Bridging unwrapping-error correction.
-    """
+def bridge_unwrap_regions(unwrapped_phase, conncomp, bridge_radius: int = 50, min_region_size: int = 100, reference_pixel=None):
     import numpy as np
     from scipy.spatial import cKDTree
-
     labels = np.unique(conncomp)
     labels = labels[labels != 0]
     region_sizes = {lbl: int(np.sum(conncomp == lbl)) for lbl in labels}
     valid_labels = [lbl for lbl in labels if region_sizes[lbl] >= min_region_size]
-
-    if not valid_labels:
-        return unwrapped_phase.copy(), {}
-
+    if not valid_labels: return unwrapped_phase.copy(), {}
     valid_labels.sort(key=lambda lbl: region_sizes[lbl], reverse=True)
     if reference_pixel is not None:
         rp_row, rp_col = reference_pixel
         rp_label = int(conncomp[rp_row, rp_col])
         if rp_label == 0 or rp_label not in valid_labels:
-            raise ValueError(
-                f"reference_pixel {reference_pixel} is not part of any "
-                f"valid (reliable, large-enough) region."
-            )
+            raise ValueError(f"reference_pixel {reference_pixel} is not part of any valid region.")
         reference_label = rp_label
     else:
         reference_label = valid_labels[0]
-
     corrected = np.array(unwrapped_phase, dtype=np.float64, copy=True)
     resolved_points = {reference_label: np.column_stack(np.where(conncomp == reference_label))}
     offsets_applied = {reference_label: 0.0}
     remaining = set(valid_labels) - {reference_label}
-
     while remaining:
         best = None
         for lbl in remaining:
@@ -372,11 +262,8 @@ def bridge_unwrap_regions(
                 min_i = int(np.argmin(dist))
                 if best is None or dist[min_i] < best[0]:
                     best = (dist[min_i], lbl, resolved_lbl, lbl_points[min_i], ref_points[idx[min_i]])
-
-        if best is None:
-            break
+        if best is None: break
         _, lbl, target_lbl, point_a, point_b = best
-
         def _local_median(point, region_mask):
             r, c = point
             r0, r1 = max(0, r - bridge_radius), r + bridge_radius + 1
@@ -385,47 +272,28 @@ def bridge_unwrap_regions(
             window_mask = region_mask[r0:r1, c0:c1]
             values = window_phase[window_mask]
             return float(np.median(values)) if len(values) > 0 else float(corrected[r, c])
-
         median_a = _local_median(point_a, conncomp == lbl)
         median_b = _local_median(point_b, conncomp == target_lbl)
         raw_offset = median_b - median_a
         integer_offset = 2 * np.pi * np.round(raw_offset / (2 * np.pi))
-
         corrected[conncomp == lbl] += integer_offset
         offsets_applied[lbl] = integer_offset
         resolved_points[lbl] = np.column_stack(np.where(conncomp == lbl))
         remaining.remove(lbl)
-
     return corrected.astype(np.float32), offsets_applied
 
 
-def multilook(
-    data: Any,
-    looks_azimuth: int = 4,
-    looks_range: int = 1,
-    wrapped_phase: Optional[bool] = None,
-) -> Any:
-    """
-    Average an array down by the given factor in each dimension.
-    """
+def multilook(data: Any, looks_azimuth: int = 4, looks_range: int = 1, wrapped_phase: Optional[bool] = None) -> Any:
     import numpy as np
-
     h, w = data.shape
     h_ml = (h // looks_azimuth) * looks_azimuth
     w_ml = (w // looks_range) * looks_range
     trimmed = data[:h_ml, :w_ml]
     reshaped_shape = (h_ml // looks_azimuth, looks_azimuth, w_ml // looks_range, looks_range)
-
     if np.iscomplexobj(trimmed):
         return trimmed.reshape(reshaped_shape).mean(axis=(1, 3))
-
     if wrapped_phase is None:
-        raise ValueError(
-            "multilook() received real-valued input but wrapped_phase was "
-            "not specified. Pass wrapped_phase=True for wrapped phase, "
-            "or wrapped_phase=False for coherence/unwrapped phase."
-        )
-
+        raise ValueError("multilook() received real-valued input but wrapped_phase was not specified.")
     if wrapped_phase:
         reshaped = np.exp(1j * trimmed).reshape(reshaped_shape)
         return np.angle(reshaped.mean(axis=(1, 3)))
@@ -434,27 +302,16 @@ def multilook(
 
 
 class PhaseUnwrapper:
-    """
-    Phase unwrapping via SNAPHU.
-    """
-
     def __init__(self, cost_mode: str = "defo", init_method: str = "mcf") -> None:
         valid_costs = ("topo", "defo", "smooth", "nostatcosts")
-        if cost_mode not in valid_costs:
-            raise ValueError(f"cost_mode must be one of {valid_costs}, got {cost_mode!r}")
+        if cost_mode not in valid_costs: raise ValueError(f"cost_mode must be one of {valid_costs}")
         valid_inits = ("mcf", "mst")
-        if init_method not in valid_inits:
-            raise ValueError(f"init_method must be one of {valid_inits}, got {init_method!r}")
+        if init_method not in valid_inits: raise ValueError(f"init_method must be one of {valid_inits}")
         self._cost_mode = cost_mode
         self._init_method = init_method
 
     def _unwrap_cli(self, igram, corr, nlooks, min_conncomp_frac, min_region_size):
-        """
-        Fallback unwrapping using the SNAPHU CLI executable.
-        Includes auto-repair for the infamous 0xC0000135 (STATUS_DLL_NOT_FOUND) error.
-        """
         import numpy as np
-        
         cli_path = _ensure_snaphu_cli()
         height, width = igram.shape
         bin_dir = Path(cli_path).parent
@@ -466,27 +323,24 @@ class PhaseUnwrapper:
             unw_path = tmp / "unw.unw"
             cc_path = tmp / "conncomp.cc"
             conf_path = tmp / "snaphu.conf"
-            
             igram.tofile(str(igram_path))
             corr.tofile(str(corr_path))
-            
             nlooks_int = max(1, int(nlooks))
             conf_text = f"""INFILE            igram.cpx
-                    INFILEFORMAT      COMPLEX_DATA
-                    CORRFILE          corr.cor
-                    CORRFILEFORMAT    FLOAT_DATA
-                    OUTFILE           unw.unw
-                    OUTFILEFORMAT     FLOAT_DATA
-                    CONNCOMPFILE      conncomp.cc
-                    CONNCOMPOUTFORMAT UINT_DATA
-                    LINELENGTH        {width}
-                    STATCOSTMODE      {self._cost_mode.upper()}
-                    INITMETHOD        {self._init_method.upper()}
-                    NLOOKSRANGE       {nlooks_int}
-                    NLOOKSAZ          {nlooks_int}
-                    """
+INFILEFORMAT      COMPLEX_DATA
+CORRFILE          corr.cor
+CORRFILEFORMAT    FLOAT_DATA
+OUTFILE           unw.unw
+OUTFILEFORMAT     FLOAT_DATA
+CONNCOMPFILE      conncomp.cc
+CONNCOMPOUTFORMAT UINT_DATA
+LINELENGTH        {width}
+STATCOSTMODE      {self._cost_mode.upper()}
+INITMETHOD        {self._init_method.upper()}
+NLOOKSRANGE       {nlooks_int}
+NLOOKSAZ          {nlooks_int}
+"""
             conf_path.write_text(conf_text)
-            
             cmd = [cli_path, "-f", "snaphu.conf"]
             result = subprocess.run(cmd, capture_output=True, text=True, cwd=str(tmp), timeout=3600)
             return result, unw_path, cc_path
@@ -496,12 +350,8 @@ class PhaseUnwrapper:
             
             # AUTO-REPAIR: Catch Windows STATUS_DLL_NOT_FOUND (0xC0000135)
             if result.returncode in (3221225781, -1073741515):
-                logger.warning(
-                    "SNAPHU crashed with STATUS_DLL_NOT_FOUND (0xC0000135). "
-                    "Auto-bundling MSVC runtime DLLs..."
-                )
+                logger.warning("SNAPHU crashed with STATUS_DLL_NOT_FOUND (0xC0000135). Auto-bundling MSVC runtime DLLs...")
                 self._ensure_msvc_runtime(bin_dir)
-                
                 logger.info("Retrying SNAPHU with bundled DLLs...")
                 result, unw_path, cc_path = _run_snaphu(tmp_dir)
                 
@@ -514,189 +364,72 @@ class PhaseUnwrapper:
         total_pixels = height * width
         labels, counts = np.unique(conncomp, return_counts=True)
         for lbl, count in zip(labels, counts):
-            if lbl == 0:
-                continue
+            if lbl == 0: continue
             if count < min_region_size or (count / total_pixels) < min_conncomp_frac:
                 conncomp[conncomp == lbl] = 0
-                
         return unw, conncomp.astype(np.int32)
 
     def _ensure_msvc_runtime(self, bin_dir: Path):
-        """
-        Fixes the 0xC0000135 (STATUS_DLL_NOT_FOUND) error by downloading 
-        the required MSVC DLLs directly from NuGet (VCRuntime.140 package).
-        This requires ZERO admin rights and ZERO manual installation.
-        """
-        import shutil
-        import zipfile
-        import io
-        import urllib.request
-        
-        required_dlls = ["vcruntime140.dll", "msvcp140.dll"]
+        import shutil, zipfile, io, urllib.request
+        required_dlls = ["vcruntime140.dll", "msvcp140.dll", "vcruntime140_1.dll"]
         missing = [dll for dll in required_dlls if not (bin_dir / dll).exists()]
+        if not missing: return
         
-        if not missing:
-            return
-            
         logger.info(f"SNAPHU requires {missing}. Downloading directly from NuGet (no admin required)...")
-        
-        # NuGet packages are just zip files. We download the VCRuntime.140 package
-        # which contains the exact DLLs we need for x64 Windows.
         nuget_url = "https://www.nuget.org/api/v2/package/VCRuntime.140"
         
         try:
             req = urllib.request.Request(nuget_url, headers={'User-Agent': 'PyGeoFetch'})
             with urllib.request.urlopen(req, timeout=30) as response:
                 nupkg_data = response.read()
-                
             extracted = 0
             with zipfile.ZipFile(io.BytesIO(nupkg_data)) as zf:
                 for name in zf.namelist():
-                    # We only want the 64-bit native DLLs
                     if "win-x64/native/" in name and name.lower().endswith(".dll"):
                         dll_name = Path(name).name
                         if dll_name.lower() in [m.lower() for m in missing]:
                             with zf.open(name) as src, open(bin_dir / dll_name, "wb") as dst:
                                 shutil.copyfileobj(src, dst)
                             extracted += 1
-                            
-            if extracted == len(missing):
+            if extracted > 0:
                 logger.info(f"Successfully extracted {extracted} MSVC DLLs to {bin_dir}. Retrying SNAPHU...")
                 return
             else:
-                raise RuntimeError(f"Could not find all required DLLs in the NuGet package. Found {extracted}/{len(missing)}")
-                
+                raise RuntimeError("Could not find required DLLs in the NuGet package.")
         except Exception as e:
             raise RuntimeError(
                 f"Failed to download/extract MSVC runtime DLLs from NuGet: {e}\n"
                 "As a last resort, please install the Microsoft Visual C++ Redistributable manually from:\n"
-                "https://aka.ms/vs/17/release/vc_redist.x64.exe\n"
-                "Then restart your Jupyter kernel."
+                "https://aka.ms/vs/17/release/vc_redist.x64.exe\nThen restart your Jupyter kernel."
             )
 
-    def unwrap(
-        self,
-        interferogram: Any,
-        coherence: Any,
-        nlooks: float = 1.0,
-        mask: Optional[Any] = None,
-        min_conncomp_frac: float = 0.01,
-        min_region_size: int = 100,
-    ) -> Tuple[Any, Any]:
+    def unwrap(self, interferogram: Any, coherence: Any, nlooks: float = 1.0, mask: Optional[Any] = None, min_conncomp_frac: float = 0.01, min_region_size: int = 100) -> Tuple[Any, Any]:
         np = self._np()
-
-        if np.iscomplexobj(interferogram):
-            igram = interferogram.astype(np.complex64)
-        else:
-            igram = np.exp(1j * interferogram).astype(np.complex64)
-
+        if np.iscomplexobj(interferogram): igram = interferogram.astype(np.complex64)
+        else: igram = np.exp(1j * interferogram).astype(np.complex64)
         corr = np.clip(coherence, 0.0, 1.0).astype(np.float32)
-
-        if mask is not None:
-            corr = np.where(mask, corr, 0.0).astype(np.float32)
-
+        if mask is not None: corr = np.where(mask, corr, 0.0).astype(np.float32)
         corr = np.nan_to_num(corr, nan=0.0, posinf=0.0, neginf=0.0)
-
-        logger.info(
-            "Unwrapping %s pixels (cost=%s, init=%s, nlooks=%.1f)",
-            f"{igram.shape[0]}x{igram.shape[1]}",
-            self._cost_mode,
-            self._init_method,
-            nlooks,
-        )
-
+        logger.info("Unwrapping %s pixels (cost=%s, init=%s, nlooks=%.1f)", f"{igram.shape[0]}x{igram.shape[1]}", self._cost_mode, self._init_method, nlooks)
         try:
-            # Try Python API first (fastest)
             import snaphu
-            unwrapped, conncomp = snaphu.unwrap(
-                igram,
-                corr,
-                nlooks=nlooks,
-                cost=self._cost_mode,
-                init=self._init_method,
-                min_conncomp_frac=min_conncomp_frac,
-                min_region_size=min_region_size,
-            )
+            unwrapped, conncomp = snaphu.unwrap(igram, corr, nlooks=nlooks, cost=self._cost_mode, init=self._init_method, min_conncomp_frac=min_conncomp_frac, min_region_size=min_region_size)
         except ImportError:
-            # Fallback to CLI (solves Windows installation nightmares)
             logger.info("snaphu Python package not found. Falling back to SNAPHU CLI executable...")
-            unwrapped, conncomp = self._unwrap_cli(
-                igram, corr, nlooks, min_conncomp_frac, min_region_size
-            )
+            unwrapped, conncomp = self._unwrap_cli(igram, corr, nlooks, min_conncomp_frac, min_region_size)
         except Exception as exc:
-            raise RuntimeError(
-                f"SNAPHU unwrapping failed: {exc}\n"
-                "Common causes: incompatible array shapes, all-zero coherence, "
-                "or insufficient memory for large scenes."
-            ) from exc
+            raise RuntimeError(f"SNAPHU unwrapping failed: {exc}") from exc
 
         n_unreliable = int(np.sum(conncomp == 0))
         pct = 100 * n_unreliable / conncomp.size
-        if pct > 30:
-            logger.warning(
-                "%.1f%% of pixels are in the unreliable connected component "
-                "(conncomp==0). Consider improving coherence via multilooking.",
-                pct,
-            )
-        else:
-            logger.info("Unwrapping complete — %.1f%% unreliable pixels", pct)
-
+        if pct > 30: logger.warning("%.1f%% of pixels are in the unreliable connected component (conncomp==0).", pct)
+        else: logger.info("Unwrapping complete — %.1f%% unreliable pixels", pct)
         return unwrapped.astype(np.float32), conncomp
 
-    def unwrap_pair(
-        self,
-        interferogram: Any,
-        coherence: Any,
-        profile: Dict[str, Any],
-        reference_date: Optional[str] = None,
-        secondary_date: Optional[str] = None,
-        nlooks: float = 1.0,
-        looks_azimuth: int = 1,
-        looks_range: int = 1,
-        mask: Optional[Any] = None,
-        min_conncomp_frac: float = 0.001,
-        min_region_size: int = 100,
-    ) -> UnwrapResult:
-        """
-        Unwrap a single interferogram pair and return an UnwrapResult.
-        
-        This is the high-level method that combines unwrap() + result
-        packaging. Use this in notebook cells for clean orchestration:
-        
-            result = unwrapper.unwrap_pair(phase_ml, coh_ml, profile,
-                                           looks_azimuth=UNWRAP_LOOKS_AZ, 
-                                           looks_range=UNWRAP_LOOKS_RG)
-            result.save(output_dir / f"{d1}_{d2}", save_png=True)
-        
-        Args:
-            interferogram: Complex interferogram or wrapped phase (radians).
-            coherence:     Coherence array (0-1), same shape.
-            profile:       Rasterio-style profile for georeferencing.
-            reference_date, secondary_date: ISO date strings for labeling.
-            nlooks:        Effective number of looks.
-            looks_azimuth, looks_range: Multilook factors used to produce the
-                                        input arrays. Used to correctly scale
-                                        the georeferencing transform.
-            mask:          Optional boolean mask (True=valid).
-            min_conncomp_frac: Minimum connected component fraction.
-            min_region_size: Minimum region size in pixels.
-        
-        Returns:
-            UnwrapResult with all data packaged and ready to save.
-        """
+    def unwrap_pair(self, interferogram: Any, coherence: Any, profile: Dict[str, Any], reference_date: Optional[str] = None, secondary_date: Optional[str] = None, nlooks: float = 1.0, looks_azimuth: int = 1, looks_range: int = 1, mask: Optional[Any] = None, min_conncomp_frac: float = 0.001, min_region_size: int = 100) -> UnwrapResult:
         import numpy as np
-
-        unwrapped, conncomp = self.unwrap(
-            interferogram, coherence,
-            nlooks=nlooks,
-            mask=mask,
-            min_conncomp_frac=min_conncomp_frac,
-            min_region_size=min_region_size,
-        )
-
+        unwrapped, conncomp = self.unwrap(interferogram, coherence, nlooks=nlooks, mask=mask, min_conncomp_frac=min_conncomp_frac, min_region_size=min_region_size)
         reliable_fraction = float(np.mean(conncomp > 0))
-
-        # Scale the profile transform to match the multilooked arrays
         scaled_profile = dict(profile)
         if looks_azimuth > 1 or looks_range > 1:
             if scaled_profile.get("transform") is not None:
@@ -704,83 +437,32 @@ class PhaseUnwrapper:
                 scaled_profile["transform"] = scaled_profile["transform"] * Affine.scale(looks_range, looks_azimuth)
             scaled_profile["height"] = unwrapped.shape[0]
             scaled_profile["width"] = unwrapped.shape[1]
+        return UnwrapResult(unwrapped_phase=unwrapped, conncomp=conncomp, coherence=coherence, profile=scaled_profile, reference_date=reference_date, secondary_date=secondary_date, nlooks=nlooks, cost_mode=self._cost_mode, init_method=self._init_method, reliable_fraction=reliable_fraction)
 
-        return UnwrapResult(
-            unwrapped_phase=unwrapped,
-            conncomp=conncomp,
-            coherence=coherence,
-            profile=scaled_profile,
-            reference_date=reference_date,
-            secondary_date=secondary_date,
-            nlooks=nlooks,
-            cost_mode=self._cost_mode,
-            init_method=self._init_method,
-            reliable_fraction=reliable_fraction,
-            metadata={
-                "cost_mode": self._cost_mode,
-                "init_method": self._init_method,
-                "nlooks": nlooks,
-                "reliable_fraction": reliable_fraction,
-            },
-        )
-
-    def unwrap_files(
-        self,
-        interferogram_path: Union[str, Path],
-        coherence_path: Union[str, Path],
-        output_path: Union[str, Path],
-        nlooks: float = 1.0,
-        mask_path: Optional[Union[str, Path]] = None,
-    ) -> Path:
+    def unwrap_files(self, interferogram_path: Union[str, Path], coherence_path: Union[str, Path], output_path: Union[str, Path], nlooks: float = 1.0, mask_path: Optional[Union[str, Path]] = None) -> Path:
         np = self._np()
-        try:
-            import rasterio
-        except ImportError:
-            raise ImportError('rasterio required: pip install "pygeofetch[geo]"')
-
+        try: import rasterio
+        except ImportError: raise ImportError('rasterio required: pip install "pygeofetch[geo]"')
         with rasterio.open(interferogram_path) as src:
             profile = src.profile.copy()
             phase = src.read(1).astype(np.float32)
-
         with rasterio.open(coherence_path) as src:
             coherence = src.read(1).astype(np.float32)
-
         mask = None
         if mask_path:
-            with rasterio.open(mask_path) as src:
-                mask = src.read(1).astype(bool)
-
+            with rasterio.open(mask_path) as src: mask = src.read(1).astype(bool)
         unwrapped, conncomp = self.unwrap(phase, coherence, nlooks=nlooks, mask=mask)
-
         out_path = Path(output_path)
         out_path.parent.mkdir(parents=True, exist_ok=True)
-
-        out_profile = {
-            "driver": "GTiff",
-            "dtype": "float32",
-            "count": 1,
-            "height": unwrapped.shape[0],
-            "width": unwrapped.shape[1],
-            "crs": profile.get("crs"),
-            "transform": profile.get("transform"),
-            "nodata": -9999.0,
-            "compress": "deflate",
-            "tiled": True,
-            "blockxsize": 256,
-            "blockysize": 256,
-        }
+        out_profile = {"driver": "GTiff", "dtype": "float32", "count": 1, "height": unwrapped.shape[0], "width": unwrapped.shape[1], "crs": profile.get("crs"), "transform": profile.get("transform"), "nodata": -9999.0, "compress": "deflate", "tiled": True, "blockxsize": 256, "blockysize": 256}
         with rasterio.open(out_path, "w", **out_profile) as dst:
             dst.write(unwrapped[np.newaxis])
             dst.update_tags(1, description="unwrapped_phase_radians")
-
         conncomp_path = out_path.parent / f"{out_path.stem}_conncomp.tif"
         cc_profile = dict(out_profile, dtype="int32", nodata=0)
         with rasterio.open(conncomp_path, "w", **cc_profile) as dst:
             dst.write(conncomp.astype(np.int32)[np.newaxis])
-
-        logger.info(
-            "Unwrapped phase → %s (conncomp → %s)", out_path.name, conncomp_path.name
-        )
+        logger.info("Unwrapped phase → %s (conncomp → %s)", out_path.name, conncomp_path.name)
         return out_path
 
     def _np(self):

pygeofetch/meta.yaml

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

{pygeofetch-2.0.9.dist-info → pygeofetch-2.1.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pygeofetch
-Version: 2.0.9
+Version: 2.1.0
 Summary: Universal satellite data pipeline + geospatial processing platform
 Author-email: Samuel Appiah Kubi <appiahkubis14@gmail.com>
 License: MIT License

{pygeofetch-2.0.9.dist-info → pygeofetch-2.1.0.dist-info}/RECORD

@@ -1,11 +1,11 @@
-pygeofetch/__init__.py,sha256=RDB0ME4m2ADK1BxKVEQB93rq-yfN7pF0uHbl4cafsPo,1990
-pygeofetch/meta.yaml,sha256=PVK-tAx2L30LEg6FaU7zNyFtXmnDybAnQ0SZtd81qHg,1280
+pygeofetch/__init__.py,sha256=L8N1Q9HeHj-WQl0W1f8EFZJ2OjkBFszL4pR5p8sSo5k,1990
+pygeofetch/meta.yaml,sha256=ymM1Zwx7Acs5nqHhu8wSkS-5_FHZvedmax-CdxbXAjI,1280
 pygeofetch/cli/__init__.py,sha256=QZMIIHEgmjGFieucqq9fZ5uephxP9-jdu1s8Q4qqw8o,30
 pygeofetch/cli/auth_commands.py,sha256=YqbrN_BYcAYCaUIYLpSJ_VIw35tKFUiD9Kc55SWbDWg,7742
 pygeofetch/cli/config_commands.py,sha256=1Pps0HLCLPODMlM6SFV8ru3IKCDpexSTz8uKIXvIIF8,3918
 pygeofetch/cli/download_commands.py,sha256=reQ9vmA50mj1zqechjLHAOe_cjBfa1miqfWa8UiIlxU,11741
 pygeofetch/cli/index_commands.py,sha256=IoLGrsSU-lTcBitFFsg8EtucqSKZtNL-0ODj_I8Twew,10020
-pygeofetch/cli/main.py,sha256=UZVPectgQIF29g30UsyQCEZ_HGYBy47LhAvue9Y7PhA,30335
+pygeofetch/cli/main.py,sha256=OuNJCr8oWa3Gtk1ECDsOhriQfSIl2l7SL5DAdl6CCVc,30335
 pygeofetch/cli/pipeline_process_commands.py,sha256=OvuouT35zZlrC-7hWAJRfaY_aUNk4ScK0Fia9WVB_Gw,6904
 pygeofetch/cli/postprocess_commands.py,sha256=kof_f-kjjvYl5eqPqrcNHSOUM_qVkGdSh6-N4vcx2y4,5825
 pygeofetch/cli/preprocess_commands.py,sha256=cFp1VR03Q1pmCwiBWYmS5lXF3NOnzVAq3XgrZh3rBdU,8696
@@ -39,7 +39,7 @@ pygeofetch/insar/splitspectrum_diagnostic.py,sha256=_IlfBs__BW7Yz2RwdmWxfrOspe67
 pygeofetch/insar/stack_selection.py,sha256=ebFwO063cCT9kn3zLPlkYu6fpnfx-SRC90Ch18E7qJk,13157
 pygeofetch/insar/synthetic.py,sha256=FazdaG_u3GR1qk8022T92W2uxDJPg7OJaUSGY0wR0pw,16248
 pygeofetch/insar/timeseries.py,sha256=EtLJiPySMaUWwyNxI2GyfBdkqB4W-uvL-_E_T_POHz4,32063
-pygeofetch/insar/unwrap.py,sha256=c5viQA3H16r7w7UQNiDY35ht_jx-d9-6Q3j0UgUKEt4,30777
+pygeofetch/insar/unwrap.py,sha256=FqvvqpxlmWZ7WfkCQa05vers8LaFO-a8o1QMW3YszKU,22832
 pygeofetch/insar/validate.py,sha256=BZaVvaPNllfDzoPwat0vDA4do6H5xh5Ju_g4r5YNogE,10110
 pygeofetch/insar/visualize.py,sha256=D_KlWkpuOvfjke6ThHcMBkZTRwWn1KdBFNL1TBcy6kI,7543
 pygeofetch/insar/workflow.py,sha256=8IxGgabdz9fDLoGAVrJRCdw16GP3sSDSoFPXyv1RXcg,11713
@@ -104,9 +104,9 @@ pygeofetch/utils/validators.py,sha256=f-k3mGFP4byjimyDymhPEdsz5I16jZacx1HSnwrARj
 pygeofetch/viz/__init__.py,sha256=xf2C9IL4n3bv3oxk8RYkogq7nkuNyt18V-urAoXWRQY,449
 pygeofetch/viz/map.py,sha256=vYO99NvTumCAVXVtXcEzMx_cpmH-FvSVNWl8X0PNSgE,15494
 pygeofetch/viz/plot.py,sha256=I16rdOWb80gcjYDsDvTMzuyek7QHgUNOQxY2RejBAPs,53675
-pygeofetch-2.0.9.dist-info/licenses/LICENSE,sha256=zavMyhODD6NvZTmmKFEtATrngwY4CU_NEtY7lhjxGnI,1075
-pygeofetch-2.0.9.dist-info/METADATA,sha256=0FB9OccvQb0t7uHgSUxB-DRMGqS9O1W0rHNtwhDTliI,43254
-pygeofetch-2.0.9.dist-info/WHEEL,sha256=K260EYznzXsJYBQGqmI8VTxEdiZYNvDZwW9cBh9-_MA,91
-pygeofetch-2.0.9.dist-info/entry_points.txt,sha256=dHiUXLF5xNJ8vgtXZoUQNleEMQUeDPZiKQOE1tW8SDY,55
-pygeofetch-2.0.9.dist-info/top_level.txt,sha256=rOmnZargIfNk99fwVOqt6OJyJvpSTBBAYO5HU37yhHk,11
-pygeofetch-2.0.9.dist-info/RECORD,,
+pygeofetch-2.1.0.dist-info/licenses/LICENSE,sha256=zavMyhODD6NvZTmmKFEtATrngwY4CU_NEtY7lhjxGnI,1075
+pygeofetch-2.1.0.dist-info/METADATA,sha256=YIRKj3ve8llHulK2xAeCY27rzphU2aPOa26dBldgeaM,43254
+pygeofetch-2.1.0.dist-info/WHEEL,sha256=K260EYznzXsJYBQGqmI8VTxEdiZYNvDZwW9cBh9-_MA,91
+pygeofetch-2.1.0.dist-info/entry_points.txt,sha256=dHiUXLF5xNJ8vgtXZoUQNleEMQUeDPZiKQOE1tW8SDY,55
+pygeofetch-2.1.0.dist-info/top_level.txt,sha256=rOmnZargIfNk99fwVOqt6OJyJvpSTBBAYO5HU37yhHk,11
+pygeofetch-2.1.0.dist-info/RECORD,,