PyGeoFetch 2.6.2.8__tar.gz → 2.6.3.0__tar.gz

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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pygeofetch
-Version: 2.6.2.8
+Version: 2.6.3.0
 Summary: Universal satellite data pipeline + geospatial processing platform
 Author-email: Samuel Appiah Kubi <appiahkubis14@gmail.com>
 License: MIT License
@@ -369,7 +369,7 @@ If you use PyGeoFetch in your research or operational work, please cite it using
   title        = {PyGeoFetch: A Unified Python Framework for Multi-Provider Satellite Data Acquisition, Pre-download Quality Control, and Geospatial Processing},
   year         = {2026},
   publisher    = {Zenodo},
-  version      = {2.6.2.8.1},
+  version      = {2.6.3.0.1},
   doi          = {10.5281/zenodo.22087230},
   url          = {https://doi.org/10.5281/zenodo.22087230}
 }

{pygeofetch-2.6.2.8 → pygeofetch-2.6.3.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.2.8.1},
+  version      = {2.6.3.0.1},
   doi          = {10.5281/zenodo.22087230},
   url          = {https://doi.org/10.5281/zenodo.22087230}
 }

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

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

pygeofetch-2.6.3.0/pygeofetch/cli/classify_commands.py

@@ -0,0 +1,112 @@
+"""CLI commands for pixel classification."""
+
+from __future__ import annotations
+
+import sys
+
+import click
+from rich.console import Console
+
+# from pygeofetch.cli.index_commands import clip_options, _parse_bbox
+
+console = Console()
+
+
+def _engine():
+    from pygeofetch.core.engine import PyGeoFetch
+
+    return PyGeoFetch(log_level="WARNING")
+
+
+def _pr(result, name):
+    if result.success:
+        size_mb = (
+            result.output_path.stat().st_size / (1024 * 1024)
+            if result.output_path and result.output_path.exists()
+            else 0
+        )
+        console.print(
+            f"[green]✓[/] {name} → {result.output_path}"
+            f" ({size_mb:.1f} MB, {result.duration_seconds:.2f}s)"
+        )
+        meta = result.metadata or {}
+        for k, v in meta.items():
+            if k != "classification_report":
+                console.print(f"  {k}: {v}")
+    else:
+        console.print(f"[red]✗[/] {name} failed: {result.error}")
+        sys.exit(1)
+
+
+@click.group()
+def classify() -> None:
+    """Pixel classification — unsupervised K-means and supervised Random Forest/SVM."""
+
+
+@classify.command("kmeans")
+@click.argument("inputs", nargs=-1, type=click.Path(exists=True))
+@click.option("--clusters", "-k", default=5, show_default=True, type=int, help="Number of clusters.")
+@click.option("--output", "-o", default=None)
+@click.option("--random-state", default=42, show_default=True, type=int)
+# @clip_options
+def kmeans_cmd(inputs, clusters, output, random_state, bbox, geometry, geometry_crs):
+    """Unsupervised K-means clustering. No training data needed.
+
+    Example: pygeofetch classify kmeans B02.tif B03.tif B04.tif B08.tif -k 5
+    """
+    if len(inputs) < 1:
+        console.print("[red]Provide at least 1 input band raster[/]")
+        sys.exit(1)
+    e = _engine()
+    r = e.classify.kmeans(
+        inputs=list(inputs), n_clusters=clusters, output=output, random_state=random_state,
+        bbox=bbox, geometry=geometry, geometry_crs=geometry_crs,
+    )
+    _pr(r, f"K-means ({clusters} clusters)")
+
+
+@classify.command("train")
+@click.argument("inputs", nargs=-1, type=click.Path(exists=True))
+@click.option("--training-data", required=True, type=click.Path(exists=True), help="Vector file (GeoJSON/Shapefile) with labeled training geometries.")
+@click.option("--class-field", required=True, help="Attribute column holding the real class label.")
+@click.option("--output-model", "-o", required=True, help="Where to save the trained model.")
+@click.option("--model-type", default="random_forest", type=click.Choice(["random_forest", "svm"]), show_default=True)
+@click.option("--n-estimators", default=100, show_default=True, type=int, help="Random Forest tree count.")
+@click.option("--test-size", default=0.2, show_default=True, type=float, help="Fraction of samples held out for real accuracy reporting.")
+def train_cmd(inputs, training_data, class_field, output_model, model_type, n_estimators, test_size):
+    """Train a supervised classifier from labeled vector training samples.
+
+    Example: pygeofetch classify train B02.tif B03.tif B04.tif B08.tif
+              --training-data samples.geojson --class-field land_cover -o model.joblib
+    """
+    if len(inputs) < 1:
+        console.print("[red]Provide at least 1 input band raster[/]")
+        sys.exit(1)
+    e = _engine()
+    r = e.classify.train(
+        inputs=list(inputs), training_data=training_data, class_field=class_field,
+        output_model=output_model, model_type=model_type, n_estimators=n_estimators,
+        test_size=test_size,
+    )
+    _pr(r, f"train ({model_type})")
+
+
+@classify.command("predict")
+@click.argument("inputs", nargs=-1, type=click.Path(exists=True))
+@click.option("--model", "-m", required=True, type=click.Path(exists=True), help="A model trained via 'classify train'.")
+@click.option("--output", "-o", default=None)
+# @clip_options
+def predict_cmd(inputs, model, output, bbox, geometry, geometry_crs):
+    """Apply a trained model to a real raster stack, producing a classification map.
+
+    Example: pygeofetch classify predict B02.tif B03.tif B04.tif B08.tif -m model.joblib
+    """
+    if len(inputs) < 1:
+        console.print("[red]Provide at least 1 input band raster[/]")
+        sys.exit(1)
+    e = _engine()
+    r = e.classify.predict(
+        inputs=list(inputs), model=model, output=output,
+        bbox=bbox, geometry=geometry, geometry_crs=geometry_crs,
+    )
+    _pr(r, "predict")

{pygeofetch-2.6.2.8 → pygeofetch-2.6.3.0}/pygeofetch/cli/index_commands.py

@@ -16,6 +16,37 @@ def _engine():
     return PyGeoFetch(log_level="WARNING")
 
 
+def _parse_bbox(ctx, param, value):
+    if value is None:
+        return None
+    try:
+        parts = [float(x.strip()) for x in value.split(",")]
+    except ValueError:
+        raise click.BadParameter("must be 4 comma-separated numbers: minx,miny,maxx,maxy") from None
+    if len(parts) != 4:
+        raise click.BadParameter("must be exactly 4 comma-separated numbers: minx,miny,maxx,maxy")
+    return tuple(parts)
+
+
+def clip_options(f):
+    """Shared --bbox/--geometry/--geometry-crs options, added to every
+    index command whose underlying method supports post-computation
+    clipping."""
+    f = click.option(
+        "--bbox", callback=_parse_bbox, default=None,
+        help="Clip the result to minx,miny,maxx,maxy (comma-separated).",
+    )(f)
+    f = click.option(
+        "--geometry", default=None, type=click.Path(exists=True),
+        help="Clip the result to a GeoJSON file's geometry instead of a bbox.",
+    )(f)
+    f = click.option(
+        "--geometry-crs", default="EPSG:4326", show_default=True,
+        help="CRS of --bbox/--geometry coordinates.",
+    )(f)
+    return f
+
+
 def _pr(result, name):
     if result.success:
         size_mb = (
@@ -50,22 +81,67 @@ def index() -> None:
     "--nir", required=True, type=click.Path(exists=True), help="NIR band (e.g. B08.tif)"
 )
 @click.option("--output", "-o", default=None)
-def ndvi_cmd(red, nir, output):
-    """NDVI — Normalized Difference Vegetation Index. Range: -1 to +1. Vegetation > 0.3."""
+@click.option(
+    "--chunked", is_flag=True,
+    help="Process in memory-safe tiles for large rasters (e.g. drone orthomosaics) that exceed available RAM or the 4GB GeoTIFF limit.",
+)
+@click.option("--tile-size", default=1024, show_default=True, type=int, help="Tile edge length in pixels when --chunked is set.")
+@clip_options
+def ndvi_cmd(red, nir, output, chunked, tile_size, bbox, geometry, geometry_crs):
+    """NDVI — Normalized Difference Vegetation Index. Range: -1 to +1. Vegetation > 0.3.
+
+    Pass the SAME path to --red and --nir to auto-detect both bands from
+    one merged multi-band image (e.g. a drone orthomosaic), using its
+    real, embedded band descriptions.
+    """
     e = _engine()
-    r = e.indices.ndvi(red=red, nir=nir, output=output)
+    r = e.indices.ndvi(red=red, nir=nir, output=output, chunked=chunked, tile_size=tile_size, bbox=bbox, geometry=geometry, geometry_crs=geometry_crs)
     _pr(r, "NDVI")
 
 
+@index.command("ndre")
+@click.option(
+    "--rededge", required=True, type=click.Path(exists=True), help="Red edge band"
+)
+@click.option(
+    "--nir", required=True, type=click.Path(exists=True), help="NIR band"
+)
+@click.option("--output", "-o", default=None)
+@click.option(
+    "--chunked", is_flag=True,
+    help="Process in memory-safe tiles for large rasters that exceed available RAM or the 4GB GeoTIFF limit.",
+)
+@click.option("--tile-size", default=1024, show_default=True, type=int, help="Tile edge length in pixels when --chunked is set.")
+@clip_options
+def ndre_cmd(rededge, nir, output, chunked, tile_size, bbox, geometry, geometry_crs):
+    """NDRE — Normalized Difference Red Edge Index. Range: -1 to +1.
+
+    Less prone to saturation than NDVI in dense canopy -- useful for
+    crop stress and chlorophyll monitoring from drone multispectral
+    sensors. Pass the SAME path to --rededge and --nir to auto-detect
+    both bands from one merged multi-band image.
+    """
+    e = _engine()
+    r = e.indices.ndre(rededge=rededge, nir=nir, output=output, chunked=chunked, tile_size=tile_size, bbox=bbox, geometry=geometry, geometry_crs=geometry_crs)
+    _pr(r, "NDRE")
+
+
 @index.command("evi")
 @click.option("--blue", required=True, type=click.Path(exists=True))
 @click.option("--red", required=True, type=click.Path(exists=True))
 @click.option("--nir", required=True, type=click.Path(exists=True))
 @click.option("--output", "-o", default=None)
-def evi_cmd(blue, red, nir, output):
-    """EVI — Enhanced Vegetation Index. Better than NDVI in high-biomass areas."""
+@click.option("--chunked", is_flag=True, help="Process in memory-safe tiles for large rasters.")
+@click.option("--tile-size", default=1024, show_default=True, type=int)
+@clip_options
+def evi_cmd(blue, red, nir, output, chunked, tile_size, bbox, geometry, geometry_crs):
+    """EVI — Enhanced Vegetation Index. Better than NDVI in high-biomass areas.
+
+    Pass the SAME path to --blue, --red, and --nir to auto-detect all
+    three bands from one merged multi-band image.
+    """
     e = _engine()
-    r = e.indices.evi(blue=blue, red=red, nir=nir, output=output)
+    r = e.indices.evi(blue=blue, red=red, nir=nir, output=output, chunked=chunked, tile_size=tile_size, bbox=bbox, geometry=geometry, geometry_crs=geometry_crs)
     _pr(r, "EVI")
 
 
@@ -74,10 +150,17 @@ def evi_cmd(blue, red, nir, output):
 @click.option("--nir", required=True, type=click.Path(exists=True))
 @click.option("--soil-l", default=0.5, show_default=True, type=float)
 @click.option("--output", "-o", default=None)
-def savi_cmd(red, nir, soil_l, output):
-    """SAVI — Soil Adjusted Vegetation Index. Reduces soil brightness influence."""
+@click.option("--chunked", is_flag=True, help="Process in memory-safe tiles for large rasters.")
+@click.option("--tile-size", default=1024, show_default=True, type=int)
+@clip_options
+def savi_cmd(red, nir, soil_l, output, chunked, tile_size, bbox, geometry, geometry_crs):
+    """SAVI — Soil Adjusted Vegetation Index. Reduces soil brightness influence.
+
+    Pass the SAME path to --red and --nir to auto-detect both bands
+    from one merged multi-band image.
+    """
     e = _engine()
-    r = e.indices.savi(red=red, nir=nir, L=soil_l, output=output)
+    r = e.indices.savi(red=red, nir=nir, L=soil_l, output=output, chunked=chunked, tile_size=tile_size, bbox=bbox, geometry=geometry, geometry_crs=geometry_crs)
     _pr(r, "SAVI")
 
 
@@ -85,10 +168,17 @@ def savi_cmd(red, nir, soil_l, output):
 @click.option("--green", required=True, type=click.Path(exists=True))
 @click.option("--nir", required=True, type=click.Path(exists=True))
 @click.option("--output", "-o", default=None)
-def ndwi_cmd(green, nir, output):
-    """NDWI — Normalized Difference Water Index. Water > 0."""
+@click.option("--chunked", is_flag=True, help="Process in memory-safe tiles for large rasters.")
+@click.option("--tile-size", default=1024, show_default=True, type=int)
+@clip_options
+def ndwi_cmd(green, nir, output, chunked, tile_size, bbox, geometry, geometry_crs):
+    """NDWI — Normalized Difference Water Index. Water > 0.
+
+    Pass the SAME path to --green and --nir to auto-detect both bands
+    from one merged multi-band image.
+    """
     e = _engine()
-    r = e.indices.ndwi(green=green, nir=nir, output=output)
+    r = e.indices.ndwi(green=green, nir=nir, output=output, chunked=chunked, tile_size=tile_size, bbox=bbox, geometry=geometry, geometry_crs=geometry_crs)
     _pr(r, "NDWI")
 
 
@@ -96,10 +186,17 @@ def ndwi_cmd(green, nir, output):
 @click.option("--green", required=True, type=click.Path(exists=True))
 @click.option("--swir1", required=True, type=click.Path(exists=True))
 @click.option("--output", "-o", default=None)
-def mndwi_cmd(green, swir1, output):
-    """MNDWI — Modified NDWI. Better separation of water from built-up areas."""
+@click.option("--chunked", is_flag=True, help="Process in memory-safe tiles for large rasters.")
+@click.option("--tile-size", default=1024, show_default=True, type=int)
+@clip_options
+def mndwi_cmd(green, swir1, output, chunked, tile_size, bbox, geometry, geometry_crs):
+    """MNDWI — Modified NDWI. Better separation of water from built-up areas.
+
+    Pass the SAME path to --green and --swir1 to auto-detect both
+    bands from one merged multi-band image.
+    """
     e = _engine()
-    r = e.indices.mndwi(green=green, swir1=swir1, output=output)
+    r = e.indices.mndwi(green=green, swir1=swir1, output=output, chunked=chunked, tile_size=tile_size, bbox=bbox, geometry=geometry, geometry_crs=geometry_crs)
     _pr(r, "MNDWI")
 
 
@@ -107,10 +204,17 @@ def mndwi_cmd(green, swir1, output):
 @click.option("--nir", required=True, type=click.Path(exists=True))
 @click.option("--swir1", required=True, type=click.Path(exists=True))
 @click.option("--output", "-o", default=None)
-def ndbi_cmd(nir, swir1, output):
-    """NDBI — Normalized Difference Built-up Index. Urban > 0."""
+@click.option("--chunked", is_flag=True, help="Process in memory-safe tiles for large rasters.")
+@click.option("--tile-size", default=1024, show_default=True, type=int)
+@clip_options
+def ndbi_cmd(nir, swir1, output, chunked, tile_size, bbox, geometry, geometry_crs):
+    """NDBI — Normalized Difference Built-up Index. Urban > 0.
+
+    Pass the SAME path to --nir and --swir1 to auto-detect both bands
+    from one merged multi-band image.
+    """
     e = _engine()
-    r = e.indices.ndbi(nir=nir, swir1=swir1, output=output)
+    r = e.indices.ndbi(nir=nir, swir1=swir1, output=output, chunked=chunked, tile_size=tile_size, bbox=bbox, geometry=geometry, geometry_crs=geometry_crs)
     _pr(r, "NDBI")
 
 
@@ -118,10 +222,17 @@ def ndbi_cmd(nir, swir1, output):
 @click.option("--green", required=True, type=click.Path(exists=True))
 @click.option("--swir1", required=True, type=click.Path(exists=True))
 @click.option("--output", "-o", default=None)
-def ndsi_cmd(green, swir1, output):
-    """NDSI — Snow Index. Snow > 0.4."""
+@click.option("--chunked", is_flag=True, help="Process in memory-safe tiles for large rasters.")
+@click.option("--tile-size", default=1024, show_default=True, type=int)
+@clip_options
+def ndsi_cmd(green, swir1, output, chunked, tile_size, bbox, geometry, geometry_crs):
+    """NDSI — Snow Index. Snow > 0.4.
+
+    Pass the SAME path to --green and --swir1 to auto-detect both
+    bands from one merged multi-band image.
+    """
     e = _engine()
-    r = e.indices.ndsi(green=green, swir1=swir1, output=output)
+    r = e.indices.ndsi(green=green, swir1=swir1, output=output, chunked=chunked, tile_size=tile_size, bbox=bbox, geometry=geometry, geometry_crs=geometry_crs)
     _pr(r, "NDSI")
 
 
@@ -129,10 +240,17 @@ def ndsi_cmd(green, swir1, output):
 @click.option("--nir", required=True, type=click.Path(exists=True))
 @click.option("--swir1", required=True, type=click.Path(exists=True))
 @click.option("--output", "-o", default=None)
-def ndmi_cmd(nir, swir1, output):
-    """NDMI — Moisture Index. Sensitive to canopy water content."""
+@click.option("--chunked", is_flag=True, help="Process in memory-safe tiles for large rasters.")
+@click.option("--tile-size", default=1024, show_default=True, type=int)
+@clip_options
+def ndmi_cmd(nir, swir1, output, chunked, tile_size, bbox, geometry, geometry_crs):
+    """NDMI — Moisture Index. Sensitive to canopy water content.
+
+    Pass the SAME path to --nir and --swir1 to auto-detect both bands
+    from one merged multi-band image.
+    """
     e = _engine()
-    r = e.indices.ndmi(nir=nir, swir1=swir1, output=output)
+    r = e.indices.ndmi(nir=nir, swir1=swir1, output=output, chunked=chunked, tile_size=tile_size, bbox=bbox, geometry=geometry, geometry_crs=geometry_crs)
     _pr(r, "NDMI")
 
 
@@ -140,10 +258,17 @@ def ndmi_cmd(nir, swir1, output):
 @click.option("--nir", required=True, type=click.Path(exists=True))
 @click.option("--swir2", required=True, type=click.Path(exists=True))
 @click.option("--output", "-o", default=None)
-def nbr_cmd(nir, swir2, output):
-    """NBR — Normalized Burn Ratio. Use dNBR for burn severity."""
+@click.option("--chunked", is_flag=True, help="Process in memory-safe tiles for large rasters.")
+@click.option("--tile-size", default=1024, show_default=True, type=int)
+@clip_options
+def nbr_cmd(nir, swir2, output, chunked, tile_size, bbox, geometry, geometry_crs):
+    """NBR — Normalized Burn Ratio. Use dNBR for burn severity.
+
+    Pass the SAME path to --nir and --swir2 to auto-detect both bands
+    from one merged multi-band image.
+    """
     e = _engine()
-    r = e.indices.nbr(nir=nir, swir2=swir2, output=output)
+    r = e.indices.nbr(nir=nir, swir2=swir2, output=output, chunked=chunked, tile_size=tile_size, bbox=bbox, geometry=geometry, geometry_crs=geometry_crs)
     _pr(r, "NBR")
 
 
@@ -262,10 +387,16 @@ def albedo_cmd(inputs, sensor, output):
     "--expr", "-e", required=True, help="Python expression. Bands as B[0], B[1], ..."
 )
 @click.option("--output", "-o", default=None)
-def band_math_cmd(inputs, expr, output):
+@click.option(
+    "--chunked", is_flag=True,
+    help="Process in memory-safe tiles for large rasters (e.g. drone orthomosaics) that exceed available RAM or the 4GB GeoTIFF limit.",
+)
+@click.option("--tile-size", default=1024, show_default=True, type=int, help="Tile edge length in pixels when --chunked is set.")
+@clip_options
+def band_math_cmd(inputs, expr, output, chunked, tile_size, bbox, geometry, geometry_crs):
     """Arbitrary band arithmetic. Example: --expr '(B[1]-B[0])/(B[1]+B[0])'."""
     e = _engine()
-    r = e.indices.band_math(inputs=list(inputs), expression=expr, output=output)
+    r = e.indices.band_math(inputs=list(inputs), expression=expr, output=output, chunked=chunked, tile_size=tile_size, bbox=bbox, geometry=geometry, geometry_crs=geometry_crs)
     _pr(r, f"band-math ({expr[:40]})")
 
 
@@ -276,4 +407,4 @@ def stack_cmd(inputs, output):
     """Stack single-band rasters into a multi-band GeoTIFF."""
     e = _engine()
     r = e.indices.stack(inputs=list(inputs), output=output)
-    _pr(r, f"stack ({len(inputs)} bands)")
+    _pr(r, f"stack ({len(inputs)} bands)")

{pygeofetch-2.6.2.8 → pygeofetch-2.6.3.0}/pygeofetch/cli/main.py

@@ -27,6 +27,7 @@ from pygeofetch.cli.config_commands import config
 from pygeofetch.cli.download_commands import download
 from pygeofetch.cli.index_commands import index
 from pygeofetch.cli.multisensor_commands import multisensor
+from pygeofetch.cli.classify_commands import classify
 from pygeofetch.cli.optical_commands import optical
 from pygeofetch.cli.pipeline_process_commands import proc_pipeline
 from pygeofetch.cli.postprocess_commands import post
@@ -107,6 +108,7 @@ cli.add_command(sar)
 cli.add_command(proc_pipeline)
 cli.add_command(optical)
 cli.add_command(multisensor)
+cli.add_command(classify)
 
 
 # ---------------------------------------------------------------------------
@@ -212,6 +214,98 @@ def version(as_json: bool) -> None:
         )
 
 
+# ---------------------------------------------------------------------------
+# GEOCODE
+# ---------------------------------------------------------------------------
+
+
+@cli.command()
+@click.argument("query")
+@click.option("--limit", default=1, show_default=True, type=int, help="Max results to return.")
+def geocode(query: str, limit: int) -> None:
+    """Look up a place name and get its coordinates and bounding box.
+
+    Example: pygeofetch geocode "Nairobi, Kenya"
+
+    The printed bbox is ready to paste directly into a SearchQuery.
+    """
+    from pygeofetch.utils.geocoding import geocode as _geocode
+
+    try:
+        results = _geocode(query, limit=limit)
+    except Exception as exc:
+        console.print(f"[red]✗[/] geocode failed: {exc}")
+        sys.exit(1)
+
+    if not results:
+        console.print(f"[yellow]No results found for[/] {query!r}")
+        return
+
+    for r in results:
+        console.print(f"[green]{r['display_name']}[/]")
+        console.print(f"  lat/lon: {r['lat']}, {r['lon']}")
+        console.print(f"  bbox (min_lon, min_lat, max_lon, max_lat): {r['bbox']}")
+
+
+@cli.command(name="reverse-geocode")
+@click.argument("lat", type=float)
+@click.argument("lon", type=float)
+def reverse_geocode_cmd(lat: float, lon: float) -> None:
+    """Look up the real place name at a coordinate.
+
+    Example: pygeofetch reverse-geocode -1.286389 36.817223
+    """
+    from pygeofetch.utils.geocoding import reverse_geocode as _reverse_geocode
+
+    try:
+        place = _reverse_geocode(lat, lon)
+    except Exception as exc:
+        console.print(f"[red]✗[/] reverse-geocode failed: {exc}")
+        sys.exit(1)
+
+    if place is None:
+        console.print(f"[yellow]No real place found at[/] ({lat}, {lon})")
+        return
+    console.print(f"[green]{place['display_name']}[/]")
+
+
+# ---------------------------------------------------------------------------
+# INSAR FEASIBILITY
+# ---------------------------------------------------------------------------
+
+
+@cli.command(name="assess-feasibility")
+@click.option("--bbox", required=True, help="min_lon,min_lat,max_lon,max_lat")
+@click.option("--start-date", required=True)
+@click.option("--end-date", required=True)
+@click.option("--max-temporal-baseline", default=72, show_default=True, type=int)
+@click.option("--deep-check", is_flag=True, help="Also run real, live burst-sync screening on the best track (costs real network calls).")
+def assess_feasibility_cmd(bbox, start_date, end_date, max_temporal_baseline, deep_check) -> None:
+    """Assess InSAR feasibility for an AOI before downloading anything.
+
+    Example: pygeofetch assess-feasibility --bbox 18.85,50.15,19.15,50.35 \\
+             --start-date 2016-01-01 --end-date 2021-06-30
+
+    Reports the real, largest temporally-connected component per track
+    -- an honest upper bound, not a guarantee InSAR will work.
+    """
+    from pygeofetch.core.engine import PyGeoFetch
+    from pygeofetch.insar.feasibility import assess_insar_feasibility
+
+    try:
+        bbox_tuple = tuple(float(x) for x in bbox.split(","))
+    except ValueError:
+        console.print("[red]--bbox must be 4 comma-separated numbers[/]")
+        sys.exit(1)
+
+    client = PyGeoFetch(log_level="WARNING")
+    report = assess_insar_feasibility(
+        client, bbox_tuple, start_date, end_date,
+        max_temporal_baseline_days=max_temporal_baseline, deep_check=deep_check,
+    )
+    report.print_summary()
+
+
 # ---------------------------------------------------------------------------
 # DOCTOR
 # ---------------------------------------------------------------------------
@@ -923,4 +1017,4 @@ def main() -> None:
 
 
 if __name__ == "__main__":
-    main()
+    main()

{pygeofetch-2.6.2.8 → pygeofetch-2.6.3.0}/pygeofetch/cli/postprocess_commands.py

@@ -183,3 +183,51 @@ def cog_cmd(input, compress, blocksize, output):
     e = _engine()
     r = e.post.cog(input, compress=compress, blocksize=blocksize, output=output)
     _pr(r, f"COG ({compress}, {blocksize}px)")
+
+
+@post.command("overlay")
+@click.argument("left", type=click.Path(exists=True))
+@click.argument("right", type=click.Path(exists=True))
+@click.option("--output", "-o", required=True)
+@click.option("--how", default="intersection", show_default=True,
+              type=click.Choice(["intersection", "union", "difference", "symmetric_difference", "identity"]))
+def overlay_cmd(left, right, output, how):
+    """Real polygon overlay between two vector layers.
+
+    Example: pygeofetch post overlay flood.geojson parcels.geojson -o flooded_parcels.geojson --how intersection
+    """
+    e = _engine()
+    r = e.post.overlay(left, right, output=output, how=how)
+    _pr(r, f"overlay ({how})")
+
+
+@post.command("dissolve")
+@click.argument("input", type=click.Path(exists=True))
+@click.option("--output", "-o", required=True)
+@click.option("--by", default=None, help="Attribute column to group by before dissolving.")
+@click.option("--aggfunc", default="first", show_default=True, help="How to aggregate other columns within each group.")
+def dissolve_cmd(input, output, by, aggfunc):
+    """Merge polygons sharing the same attribute value into single geometries.
+
+    Example: pygeofetch post dissolve parcels.geojson -o zones.geojson --by land_use
+    """
+    e = _engine()
+    r = e.post.dissolve(input, output=output, by=by, aggfunc=aggfunc)
+    _pr(r, f"dissolve (by={by})")
+
+
+@post.command("spatial-join")
+@click.argument("left", type=click.Path(exists=True))
+@click.argument("right", type=click.Path(exists=True))
+@click.option("--output", "-o", required=True)
+@click.option("--how", default="inner", show_default=True, type=click.Choice(["inner", "left", "right"]))
+@click.option("--predicate", default="intersects", show_default=True,
+              type=click.Choice(["intersects", "contains", "within", "touches", "crosses", "overlaps"]))
+def spatial_join_cmd(left, right, output, how, predicate):
+    """Attach attributes from one vector layer to another by real spatial relationship.
+
+    Example: pygeofetch post spatial-join points.geojson zones.geojson -o joined.geojson --predicate within
+    """
+    e = _engine()
+    r = e.post.spatial_join(left, right, output=output, how=how, predicate=predicate)
+    _pr(r, f"spatial-join ({predicate})")