geo-data-audit 0.1.0__py3-none-any.whl

geo_audit/__init__.py

@@ -0,0 +1,3 @@
+"""geo-audit: Audit heterogeneous geospatial datasets."""
+
+__version__ = "0.1.0"

geo_audit/cli.py

@@ -0,0 +1,205 @@
+"""Main CLI entry point."""
+
+import sys
+from datetime import datetime
+from pathlib import Path
+
+import typer
+from rich.console import Console
+
+from geo_audit.coordinates import detect_coordinate_columns, detect_planar_coordinates
+from geo_audit.discovery import discover_files, get_file_size
+from geo_audit.findings import (
+    build_audit_summary,
+    compute_dataset_readiness,
+    generate_findings,
+)
+from geo_audit.loaders import (
+    calculate_bounding_box,
+    calculate_bounding_box_from_coords,
+    infer_geometry_types,
+    load_dataset,
+    profile_columns,
+)
+from geo_audit.models import (
+    AuditReport,
+    DatasetInfo,
+    FileFormat,
+)
+from geo_audit.quality import detect_exact_duplicates
+from geo_audit.reporting import generate_json_report, generate_terminal_report
+from geo_audit.spatial import compute_cross_dataset_overlaps
+
+APP_HELP = (
+    "Audit heterogeneous geospatial datasets for data-quality "
+    "and spatial-consistency problems."
+)
+
+app = typer.Typer(
+    name="geo-audit",
+    help=APP_HELP,
+    add_completion=False,
+)
+
+# Separate console for progress (stderr) and report (stdout)
+progress_console = Console(
+    stderr=True, force_terminal=True, color_system="standard", legacy_windows=False
+)
+
+
+@app.command()
+def audit(
+    input_dir: Path = typer.Argument(..., help="Directory containing geospatial datasets"),
+    output: Path | None = typer.Option(
+        None, "--output", "-o", help="Output file path (only with --format json)"
+    ),
+    format: str = typer.Option("terminal", "--format", "-f", help="Output format: terminal, json"),
+):
+    """Audit geospatial datasets in a directory."""
+    if not input_dir.exists() or not input_dir.is_dir():
+        progress_console.print(f"[red]Error: {input_dir} is not a valid directory[/red]")
+        raise typer.Exit(1)
+
+    if output and format != "json":
+        progress_console.print("[red]Error: --output only works with --format json[/red]")
+        raise typer.Exit(1)
+
+    datasets = []
+
+    for file_path, file_format in discover_files(input_dir):
+        if format == "terminal":
+            progress_console.print(f"[dim]Processing {file_path.name}...[/dim]")
+        ds_info = process_dataset(file_path, file_format)
+        datasets.append(ds_info)
+
+    if not datasets:
+        progress_console.print("[yellow]No supported datasets found[/yellow]")
+        raise typer.Exit(0)
+
+    overlaps = compute_cross_dataset_overlaps(datasets)
+
+    # Generate findings and readiness
+    findings = generate_findings(datasets)
+    dataset_readiness = compute_dataset_readiness(datasets, findings)
+    summary = build_audit_summary(datasets, findings)
+
+    report = AuditReport(
+        datasets=datasets,
+        cross_dataset_overlaps=overlaps,
+        summary=summary.to_dict(),
+        generated_at=datetime.now().isoformat(),
+        findings=findings,
+        dataset_readiness=dataset_readiness,
+    )
+
+    if format == "json":
+        json_output = generate_json_report(report)
+        if output:
+            output.write_text(json_output)
+            # Don't print success message to stdout in JSON mode
+        else:
+            # Print JSON to stdout (only JSON, no progress messages)
+            sys.stdout.write(json_output + "\n")
+    else:
+        generate_terminal_report(report)
+
+
+def process_dataset(file_path: Path, file_format: FileFormat) -> DatasetInfo:
+    """Process a single dataset and return DatasetInfo."""
+    file_size = get_file_size(file_path)
+    data, parse_errors = load_dataset(file_path, file_format)
+
+    if data is None or (hasattr(data, 'empty') and data.empty):
+        return DatasetInfo(
+            filename=file_path.name,
+            format=file_format,
+            row_count=0,
+            columns=[],
+            column_profiles=[],
+            file_size_bytes=file_size,
+            parse_errors=parse_errors,
+        )
+
+    if file_format == FileFormat.CSV:
+        columns = list(data.columns)
+        column_profiles = profile_columns(data)
+        row_count = len(data)
+
+        coord_info = detect_coordinate_columns(data)
+        planar_info = detect_planar_coordinates(data)
+
+        duplicate_count = 0
+        duplicate_pct = 0.0
+        if coord_info.lat_column and coord_info.lon_column:
+            duplicate_count, duplicate_pct = detect_exact_duplicates(
+                data, coord_info.lat_column, coord_info.lon_column
+            )
+
+        bounding_box = None
+        if coord_info.lat_column and coord_info.lon_column:
+            bounding_box = calculate_bounding_box_from_coords(
+                data, coord_info.lat_column, coord_info.lon_column
+            )
+
+        # Warnings kept for backward compatibility in DatasetInfo
+        warnings = []
+        if coord_info.lat_column and coord_info.lon_column:
+            if coord_info.missing_percentage > 5:
+                warnings.append(f"{coord_info.missing_percentage:.1f}% missing coordinates")
+            if coord_info.invalid_percentage > 0:
+                warnings.append(f"{coord_info.invalid_percentage:.1f}% invalid coordinates")
+            if duplicate_pct > 1:
+                warnings.append(f"{duplicate_pct:.1f}% exact duplicate locations")
+        if planar_info:
+            if planar_info.missing_percentage > 5:
+                msg = f"Planar coordinates ({planar_info.x_column}/{planar_info.y_column}): "
+                msg += f"{planar_info.missing_percentage:.1f}% missing"
+                warnings.append(msg)
+
+        return DatasetInfo(
+            filename=file_path.name,
+            format=file_format,
+            row_count=row_count,
+            columns=columns,
+            column_profiles=column_profiles,
+            file_size_bytes=file_size,
+            coordinate_info=coord_info,
+            planar_coordinate_info=planar_info,
+            bounding_box=bounding_box,
+            duplicate_count=duplicate_count,
+            duplicate_percentage=duplicate_pct,
+            parse_errors=parse_errors,
+            warnings=warnings,
+        )
+
+    else:
+        columns = [c for c in data.columns if c != 'geometry']
+        non_geom = data.drop(columns=['geometry']) if 'geometry' in data.columns else data
+        column_profiles = profile_columns(non_geom)
+        row_count = len(data)
+
+        geometry_types = infer_geometry_types(data)
+        crs = str(data.crs) if data.crs else None
+        bounding_box = calculate_bounding_box(data)
+
+        warnings = []
+        if crs is None:
+            warnings.append("No CRS declared in file (GeoJSON spec assumes WGS84)")
+
+        return DatasetInfo(
+            filename=file_path.name,
+            format=file_format,
+            row_count=row_count,
+            columns=columns,
+            column_profiles=column_profiles,
+            file_size_bytes=file_size,
+            geometry_types=geometry_types,
+            crs=crs,
+            bounding_box=bounding_box,
+            parse_errors=parse_errors,
+            warnings=warnings,
+        )
+
+
+if __name__ == "__main__":
+    app()

geo_audit/coordinates.py

@@ -0,0 +1,115 @@
+"""Coordinate detection and validation."""
+
+
+import pandas as pd
+
+from geo_audit.models import CoordinateInfo, PlanarCoordinateInfo
+
+LAT_PATTERNS = [
+    "latitude", "lat", "lat_dd", "lat_ddm", "lat_dms",
+    "y_lat", "ycoord_lat", "gps_lat", "gps_latitude",
+]
+
+LON_PATTERNS = [
+    "longitude", "lon", "lng", "long",
+    "lon_dd", "lon_ddm", "lon_dms",
+    "x_lon", "xcoord_lon", "gps_lon", "gps_longitude",
+]
+
+PLANAR_PATTERNS = [
+    ("x", "y"),
+    ("x_coord", "y_coord"),
+    ("xcoordinate", "ycoordinate"),
+    ("easting", "northing"),
+]
+
+
+def detect_coordinate_columns(df: pd.DataFrame) -> CoordinateInfo:
+    """Detect latitude/longitude columns in a DataFrame.
+
+    Only explicit latitude/longitude column names are treated as geographic coordinates.
+    Generic x/y or easting/northing columns are NOT assumed to be lat/lon.
+    """
+    cols_lower = {c.lower().strip(): c for c in df.columns}
+    info = CoordinateInfo()
+
+    lat_col = _find_column(cols_lower, LAT_PATTERNS)
+    lon_col = _find_column(cols_lower, LON_PATTERNS)
+
+    if lat_col and lon_col:
+        info.lat_column = lat_col
+        info.lon_column = lon_col
+        info.detection_method = "explicit_lat_lon"
+        info.confidence = 0.95
+        _validate_coordinates(df, info)
+
+    return info
+
+
+def detect_planar_coordinates(df: pd.DataFrame) -> PlanarCoordinateInfo | None:
+    """Detect planar coordinate columns (x/y, easting/northing).
+
+    These are NOT validated as lat/lon since their CRS is unknown.
+    Returns info about the columns if found.
+    """
+    cols_lower = {c.lower().strip(): c for c in df.columns}
+
+    for x_pat, y_pat in PLANAR_PATTERNS:
+        x_col = _find_column(cols_lower, [x_pat])
+        y_col = _find_column(cols_lower, [y_pat])
+        if x_col and y_col:
+            total = len(df)
+            missing = int(df[x_col].isna().sum() | df[y_col].isna().sum())
+            return PlanarCoordinateInfo(
+                x_column=x_col,
+                y_column=y_col,
+                detection_method="planar_heuristic",
+                count=total,
+                missing_count=missing,
+            )
+    return None
+
+
+def _find_column(cols_lower: dict[str, str], patterns: list[str]) -> str | None:
+    """Find a column matching any of the patterns."""
+    for pat in patterns:
+        if pat in cols_lower:
+            return cols_lower[pat]
+    return None
+
+
+def _validate_coordinates(df: pd.DataFrame, info: CoordinateInfo) -> None:
+    """Validate coordinate values as lat/lon."""
+    lat_col = info.lat_column
+    lon_col = info.lon_column
+
+    if not lat_col or not lon_col:
+        return
+
+    total = len(df)
+    info.total_count = total
+
+    lat_series = pd.to_numeric(df[lat_col], errors="coerce")
+    lon_series = pd.to_numeric(df[lon_col], errors="coerce")
+
+    missing_mask = lat_series.isna() | lon_series.isna()
+    info.missing_count = int(missing_mask.sum())
+
+    valid_rows_lat = lat_series[~missing_mask]
+    valid_rows_lon = lon_series[~missing_mask]
+    if valid_rows_lat.empty:
+        info.valid_count = 0
+        info.invalid_count = 0
+        return
+
+    lat_valid = (valid_rows_lat >= -90) & (valid_rows_lat <= 90)
+    lon_valid = (valid_rows_lon >= -180) & (valid_rows_lon <= 180)
+    both_valid = lat_valid & lon_valid
+
+    info.valid_count = int(both_valid.sum())
+    info.invalid_count = int((~both_valid).sum())
+
+
+def validate_lat_lon(lat: float, lon: float) -> bool:
+    """Check if lat/lon values are valid."""
+    return -90 <= lat <= 90 and -180 <= lon <= 180

geo_audit/discovery.py

@@ -0,0 +1,40 @@
+"""Dataset discovery module."""
+
+from collections.abc import Iterator
+from pathlib import Path
+
+from geo_audit.models import FileFormat
+
+SUPPORTED_EXTENSIONS = {
+    ".csv": FileFormat.CSV,
+    ".geojson": FileFormat.GEOJSON,
+    ".json": FileFormat.GEOJSON,
+}
+
+
+def discover_files(root: Path) -> Iterator[tuple[Path, FileFormat]]:
+    """Recursively discover supported files in a directory."""
+    if not root.exists():
+        raise FileNotFoundError(f"Path does not exist: {root}")
+    if not root.is_dir():
+        raise NotADirectoryError(f"Path is not a directory: {root}")
+
+    for path in root.rglob("*"):
+        if path.is_file():
+            ext = path.suffix.lower()
+            if ext in SUPPORTED_EXTENSIONS:
+                yield path, SUPPORTED_EXTENSIONS[ext]
+
+
+def get_file_format(path: Path) -> FileFormat:
+    """Determine file format from extension."""
+    ext = path.suffix.lower()
+    return SUPPORTED_EXTENSIONS.get(ext, FileFormat.UNKNOWN)
+
+
+def get_file_size(path: Path) -> int:
+    """Get file size in bytes."""
+    try:
+        return path.stat().st_size
+    except OSError:
+        return 0