dd-l2-bangkok-multicrs-audit

Rerun

import geopandas as gpd
import pandas as pd
import fiona
from fiona.crs import CRS

def detect_encoding(gdf):
    """
    Check for mojibake in text columns.
    A simple heuristic: if we see common mojibake patterns or 
    if the strings look like they were decoded incorrectly (e.g. 'é' instead of 'é').
    Actually, the prompt asks to report 'latin1-mojibake' or 'utf-8'.
    We can check if any text columns contain sequences that look like Latin-1 interpreted as UTF-8.
    """
    # We'll check all object columns
    text_cols = gdf.select_dtypes(include=['object']).columns
    
    # Heuristic: if we see sequences like à followed by something, it's often mojibake.
    # Or if we can't decode it. But geopandas usually handles the decoding.
    # If the data was read as utf-8 but is actually latin-1, we see characters like Ã.
    
    mojibake_detected = False
    for col in text_cols:
        for val in gdf[col].dropna().unique():
            if isinstance(val, str):
                # Check for common mojibake patterns
                # e.g., 'Ã' is a very common indicator of UTF-8 bytes interpreted as Latin-1
                # or vice-versa. 
                # Let's look for the specific pattern of 'Ã' followed by a character.
                if "Ã" in val:
                    mojibake_detected = True
                    break
        if mojibake_detected:
            break
            
    return "latin1-mojibake" if mojibake_detected else "utf-8"

def audit_gpkg(filepath):
    layers = fiona.listlayers(filepath)
    audit_results = []

    for layer in layers:
        gdf = gpd.read_file(filepath, layer=layer)
        
        # CRS
        # fiona CRS is a dict, we want to format it as EPSG:NNNN
        crs_info = gdf.crs
        if crs_info is not None:
            if hasattr(crs_info, 'to_epsg'):
                epsg_code = crs_info.to_epsg()
                declared_crs = f"EPSG:{epsg_code}" if epsg_code else str(crs_info)
            else:
                # Fallback for some types of CRS
                declared_crs = str(crs_info)
        else:
            declared_crs = "None"

        # Geometry Type
        # We'll take the type of the first geometry if it exists
        if not gdf.empty:
            geom_type = gdf.geometry.type.iloc[0]
            # Get sample coordinates
            sample_geom = gdf.geometry.iloc[0]
            if sample_geom.is_empty:
                # try to find first non-empty
                non_empty = gdf[~gdf.geometry.is_empty]
                if not non_empty.empty:
                    sample_geom = non_empty.geometry.iloc[0]
                    sample_x, sample_y = sample_geom.x, sample_geom.y
                else:
                    sample_x, sample_y = None, None
            else:
                sample_x, sample_y = sample_geom.x, sample_geom.y
        else:
            geom_type = "None"
            sample_x, sample_y = None, None

        feature_count = len(gdf)
        encoding = detect_encoding(gdf)

        audit_results.append({
            "layer_name": layer,
            "declared_crs": declared_crs,
            "geometry_type": geom_type,
            "feature_count": feature_count,
            "sample_x": sample_x,
            "sample_y": sample_y,
            "encoding_detected": encoding
        })

    return pd.DataFrame(audit_results)

if __name__ == "__main__":
    input_file = "/work/bangkok_contractor_delivery.gpkg"
    output_file = "/work/crs_audit.csv"
    
    df = audit_gpkg(input_file)
    df.to_csv(output_file, index=False)
    print(f"Audit complete. Results written to {output_file}")
    print(df)