Click vs Typer for Geospatial Workflows

pip install "typer[all]>=0.12" geopandas pyogrio pyproj rasterio shapely

# geo_cli/__init__.py
import sys

try:
    import rasterio  # noqa: F401
    import pyogrio   # noqa: F401
    import pyproj    # noqa: F401
except ImportError as exc:
    sys.exit(
        f"Missing geospatial dependency: {exc}\n"
        "Install with: pip install rasterio pyogrio pyproj"
    )

# geo_cli/app.py
import typer
from pathlib import Path

app = typer.Typer(
    name="geocli",
    help="Geospatial batch transformer — reproject, clip, and validate spatial data.",
    no_args_is_help=True,
)
vector_app = typer.Typer(no_args_is_help=True)
raster_app = typer.Typer(no_args_is_help=True)

app.add_typer(vector_app, name="vector", help="Vector file operations (GeoJSON, GPKG, Shapefile).")
app.add_typer(raster_app, name="raster", help="Raster file operations (GeoTIFF, COG, NetCDF).")

# geo_cli/validators.py
import typer
import pyproj

def validate_epsg(value: int) -> int:
    """Reject codes not registered in the local PROJ database."""
    try:
        pyproj.CRS.from_epsg(value)
    except pyproj.exceptions.CRSError as exc:
        raise typer.BadParameter(
            f"EPSG:{value} is not valid in the current PROJ database: {exc}"
        )
    return value

def validate_bbox(value: str) -> tuple[float, float, float, float]:
    """Parse and validate 'minx,miny,maxx,maxy' bounding box string."""
    try:
        parts = [float(p) for p in value.split(",")]
    except ValueError:
        raise typer.BadParameter("Bounding box must be four comma-separated floats.")
    if len(parts) != 4:
        raise typer.BadParameter("Expected exactly four values: minx,miny,maxx,maxy.")
    minx, miny, maxx, maxy = parts
    if minx >= maxx or miny >= maxy:
        raise typer.BadParameter("minx must be less than maxx, and miny less than maxy.")
    return (minx, miny, maxx, maxy)

# Click equivalent
import click

class EPSGType(click.ParamType):
    name = "epsg"

    def convert(self, value, param, ctx):
        try:
            code = int(value)
            pyproj.CRS.from_epsg(code)
            return code
        except (ValueError, pyproj.exceptions.CRSError) as exc:
            self.fail(f"EPSG:{value} is invalid: {exc}", param, ctx)

EPSG = EPSGType()

# geo_cli/commands/vector.py
from __future__ import annotations

import sys
from pathlib import Path
from typing import Annotated

import typer
import geopandas as gpd
from rich.progress import track

from geo_cli.app import vector_app
from geo_cli.validators import validate_epsg

@vector_app.command("reproject")
def reproject_vectors(
    input_dir: Annotated[Path, typer.Argument(
        help="Directory containing GeoJSON or GPKG files.",
        exists=True,
        file_okay=False,
        dir_okay=True,
        readable=True,
    )],
    target_epsg: Annotated[int, typer.Option(
        "--epsg",
        help="Target EPSG code, validated against the PROJ registry.",
        callback=validate_epsg,
    )] = 4326,
    overwrite: Annotated[bool, typer.Option(
        "--overwrite/--no-overwrite",
        help="Overwrite existing output files.",
    )] = False,
) -> None:
    """Reproject all GeoJSON and GPKG files in a directory to a target CRS."""
    # Defer heavy import until command body — keeps help text fast
    patterns = ("*.gpkg", "*.geojson", "*.shp")
    files: list[Path] = []
    for pat in patterns:
        files.extend(input_dir.glob(pat))

    if not files:
        typer.echo(f"No vector files found in {input_dir}", err=True)
        raise typer.Exit(code=2)

    failed: list[str] = []

    for path in track(files, description="Reprojecting…"):
        out_path = path.parent / f"{path.stem}_epsg{target_epsg}.gpkg"

        if out_path.exists() and not overwrite:
            typer.echo(f"Skipping {path.name} — output exists (use --overwrite).", err=True)
            continue

        try:
            # pyogrio engine avoids fiona's per-feature overhead
            gdf: gpd.GeoDataFrame = gpd.read_file(path, engine="pyogrio")

            if gdf.crs is None:
                raise ValueError(f"No CRS defined in {path.name}; set one before reprojecting.")

            gdf = gdf.to_crs(epsg=target_epsg)
            gdf.to_file(out_path, driver="GPKG", engine="pyogrio")

        except Exception as exc:  # noqa: BLE001
            typer.echo(f"ERROR {path.name}: {exc}", err=True)
            failed.append(path.name)

    if failed:
        typer.echo(f"\n{len(failed)} file(s) failed: {', '.join(failed)}", err=True)
        raise typer.Exit(code=1)

    raise typer.Exit(code=0)

# geo_cli/config.py
from __future__ import annotations

import os
from pathlib import Path

import yaml

_CONFIG_FILE = Path.home() / ".config" / "geocli" / "config.yaml"

_DEFAULTS: dict[str, int | str | bool] = {
    "default_epsg": 4326,
    "workers": 4,
    "overwrite": False,
}

def load_config() -> dict[str, int | str | bool]:
    cfg = dict(_DEFAULTS)
    if _CONFIG_FILE.exists():
        with _CONFIG_FILE.open() as fh:
            file_cfg: dict = yaml.safe_load(fh) or {}
        cfg.update(file_cfg)
    # Environment variables override the YAML file
    if epsg := os.environ.get("GEOCLI_DEFAULT_EPSG"):
        cfg["default_epsg"] = int(epsg)
    if workers := os.environ.get("GEOCLI_WORKERS"):
        cfg["workers"] = int(workers)
    return cfg

from geo_cli.config import load_config

_cfg = load_config()

@vector_app.command("reproject")
def reproject_vectors(
    input_dir: Annotated[Path, typer.Argument(...)],
    target_epsg: Annotated[int, typer.Option(
        "--epsg",
        callback=validate_epsg,
        envvar="GEOCLI_DEFAULT_EPSG",  # Typer also reads this automatically
    )] = _cfg["default_epsg"],  # type: ignore[assignment]
    ...
) -> None:
    ...

import logging

logger = logging.getLogger("geocli.reproject")

# Inside the processing loop:
src_crs = gdf.crs.to_epsg()
logger.info("Reprojecting %s from EPSG:%s to EPSG:%s", path.name, src_crs, target_epsg)

import rasterio.drivers

def assert_drivers(*names: str) -> None:
    available = rasterio.drivers.raster_driver_extensions()
    missing = [n for n in names if n.lower() not in available]
    if missing:
        raise RuntimeError(f"GDAL drivers not available: {missing}. Rebuild with --enable-driver flags.")

# Create a tiny test GeoPackage
python - <<'EOF'
import geopandas as gpd
from shapely.geometry import Point

gdf = gpd.GeoDataFrame(
    {"name": ["test_point"]},
    geometry=[Point(13.405, 52.52)],  # Berlin, WGS84
    crs="EPSG:4326"
)
gdf.to_file("/tmp/test_input.gpkg", driver="GPKG")
EOF

# Run the reproject command
geocli vector reproject /tmp --epsg 32633
echo "Exit code: $?"

# Verify output CRS
python - <<'EOF'
import geopandas as gpd
gdf = gpd.read_file("/tmp/test_input_epsg32633.gpkg")
assert gdf.crs.to_epsg() == 32633, f"Expected EPSG:32633, got {gdf.crs}"
print("CRS verified:", gdf.crs)
EOF