Update README.md

README.md

@@ -2,305 +2,4 @@
 license: mit
 ---
 
-Download the AEF GTI 
-
-```bash
-wget https://data.source.coop/tge-labs/aef/v1/annual/aef_index.parquet
-```
-
-Convert using the following code:
-
-```python
-import polars as pl
-import shapely
-from shapely import wkb
-import pyarrow as pa
-import pyarrow.parquet as pq
-import json
-
-pl.Config.set_verbose(True)
-
-path = "aef_index.parquet"
-table = pq.read_table(path)
-
-new_cols = []
-for field, col in zip(table.schema, table.columns):
-    if isinstance(field.type, pa.ExtensionType):
-        new_cols.append(col.cast(field.type.storage_type))
-    else:
-        new_cols.append(col)
-
-clean_table = pa.Table.from_arrays(
-    new_cols,
-    schema=pa.schema([
-        pa.field(
-            field.name,
-            field.type.storage_type if isinstance(field.type, pa.ExtensionType) else field.type
-        )
-        for field in table.schema
-    ])
-)
-
-df = pl.from_arrow(clean_table)
-
-def make_geom(row: dict) -> bytes:
-    geom = shapely.box(
-        row["wgs84_west"],
-        row["wgs84_south"],
-        row["wgs84_east"],
-        row["wgs84_north"],
-    )
-    return wkb.dumps(geom, hex=False)
-
-df = df.with_columns([
-    pl.struct([
-        pl.col("wgs84_west").alias("xmin"),
-        pl.col("wgs84_south").alias("ymin"),
-        pl.col("wgs84_east").alias("xmax"),
-        pl.col("wgs84_north").alias("ymax"),
-    ]).alias("bbox"),
-    pl.struct(["wgs84_west", "wgs84_south", "wgs84_east", "wgs84_north"])
-      .map_elements(make_geom, return_dtype=pl.Binary)
-      .alias("geometry"),
-])
-
-def make_assets(row: dict) -> str:
-    assets = {
-        "data": {
-            "href": row["path"],
-            "type": "image/tiff; application=geotiff",
-            "roles": ["data"]
-        }
-    }
-    return json.dumps(assets)
-
-df_lazy = df.lazy()
-
-df_stac_lazy = df_lazy.with_columns([
-    pl.col("fid").cast(pl.String).alias("id"),
-    pl.lit("Feature").alias("type"),
-    pl.col("bbox"),
-    pl.col("geometry"),
-    pl.concat_str([
-        pl.col("year").cast(pl.String),
-        pl.lit("-01-01T00:00:00Z"),
-    ]).alias("datetime"),
-    pl.col("crs").alias("proj:epsg"),
-    pl.struct(["path"]).map_elements(make_assets, return_dtype=pl.String).alias("assets"),
-])
-
-df_stac = df_stac_lazy.collect()
-
-df_stac = df_stac.with_columns([
-    pl.col("geometry").cast(pl.Binary),
-])
-
-table = df_stac.to_arrow()
-
-new_arrays = []
-new_fields = []
-for i, field in enumerate(table.schema):
-    col = table.column(i)
-    if field.name == "bbox":
-        if not pa.types.is_struct(field.type):
-            bbox_data = col.to_pylist()
-            bbox_structs = [
-                {"xmin": float(row[0]), "ymin": float(row[1]), "xmax": float(row[2]), "ymax": float(row[3])}
-                if isinstance(row, (list, tuple)) and len(row) == 4
-                else row
-                for row in bbox_data
-            ]
-            col = pa.array(bbox_structs, type=pa.struct([
-                pa.field("xmin", pa.float64()),
-                pa.field("ymin", pa.float64()),
-                pa.field("xmax", pa.float64()),
-                pa.field("ymax", pa.float64()),
-            ]))
-        new_fields.append(pa.field("bbox", pa.struct([
-            pa.field("xmin", pa.float64()),
-            pa.field("ymin", pa.float64()),
-            pa.field("xmax", pa.float64()),
-            pa.field("ymax", pa.float64()),
-        ])))
-        new_arrays.append(col)
-    elif field.name == "geometry":
-        if not pa.types.is_binary(field.type):
-            col = col.cast(pa.binary())
-        new_fields.append(pa.field("geometry", pa.binary()))
-        new_arrays.append(col)
-    else:
-        new_fields.append(field)
-        new_arrays.append(col)
-
-table = pa.Table.from_arrays(new_arrays, schema=pa.schema(new_fields))
-
-metadata = {
-    b"geo": b"""{
-        "version": "1.1.0",
-        "primary_column": "geometry",
-        "columns": {
-            "geometry": {
-                "encoding": "WKB",
-                "geometry_types": ["Polygon"]
-            }
-        }
-    }""",
-    b"stac_version": b"1.0.0"
-}
-
-pq.write_table(
-    table.replace_schema_metadata(metadata),
-    "aef-index-stac-geoparquet.parquet",
-    compression="zstd"
-)
-
-assert len(df_stac) == len(table)
-```
-
-Validated using the following code
-
-```python
-import pyarrow.parquet as pq
-import pyarrow as pa
-import json
-from shapely import wkb
-import geopandas as gpd
-import numpy as np
-from typing import Any
-
-def validate_stac_geoparquet(filepath: str) -> dict[str, Any]:
-    results: dict[str, Any] = {}
-    
-    try:
-        table = pq.read_table(filepath)
-        results["file_readable"] = True
-    except Exception as e:
-        results["file_readable"] = False
-        results["error"] = str(e)
-        return results
-    
-    required_stac_fields = {"id", "type", "geometry", "bbox", "datetime", "assets"}
-    schema_fields = {field.name for field in table.schema}
-    missing_fields = required_stac_fields - schema_fields
-    
-    results["has_required_fields"] = len(missing_fields) == 0
-    if missing_fields:
-        results["missing_fields"] = list(missing_fields)
-    
-    metadata = table.schema.metadata
-    if metadata:
-        results["has_metadata"] = True
-        
-        geo_meta = metadata.get(b"geo")
-        stac_meta = metadata.get(b"stac_version")
-        
-        results["has_geo_metadata"] = geo_meta is not None
-        results["has_stac_version"] = stac_meta is not None
-        
-        if geo_meta:
-            try:
-                geo_json = json.loads(geo_meta.decode())
-                results["geo_version"] = geo_json.get("version")
-                results["primary_column"] = geo_json.get("primary_column")
-                results["geometry_encoding"] = geo_json.get("columns", {}).get("geometry", {}).get("encoding")
-                results["geometry_types"] = geo_json.get("columns", {}).get("geometry", {}).get("geometry_types")
-            except Exception as e:
-                results["geo_metadata_parse_error"] = str(e)
-        
-        if stac_meta:
-            results["stac_version"] = stac_meta.decode()
-    else:
-        results["has_metadata"] = False
-    
-    geometry_field = table.schema.field("geometry")
-    results["geometry_type_is_binary"] = pa.types.is_binary(geometry_field.type)
-    
-    bbox_field = table.schema.field("bbox")
-    results["bbox_type_is_struct"] = pa.types.is_struct(bbox_field.type)
-    if pa.types.is_struct(bbox_field.type):
-        struct_fields = {f.name for f in bbox_field.type}
-        results["bbox_has_required_fields"] = {"xmin", "ymin", "xmax", "ymax"}.issubset(struct_fields)
-    
-    try:
-        gdf = gpd.read_parquet(filepath)
-        results["geopandas_readable"] = True
-        results["row_count"] = len(gdf)
-        
-        sample_row = gdf.iloc[0]
-        results["sample_geometry_valid"] = sample_row.geometry.is_valid
-        results["sample_geometry_type"] = sample_row.geometry.geom_type
-        
-        if "bbox" in gdf.columns:
-            bbox = sample_row["bbox"]
-            results["sample_bbox_type"] = str(type(bbox))
-            results["sample_bbox_value"] = str(bbox)
-            
-            is_dict = isinstance(bbox, dict)
-            results["sample_bbox_is_dict"] = is_dict
-            
-            if is_dict:
-                has_fields = all(k in bbox for k in ["xmin", "ymin", "xmax", "ymax"])
-                results["sample_bbox_has_fields"] = has_fields
-                if has_fields:
-                    results["sample_bbox_valid"] = (
-                        float(bbox["xmin"]) < float(bbox["xmax"]) and 
-                        float(bbox["ymin"]) < float(bbox["ymax"])
-                    )
-                else:
-                    results["sample_bbox_valid"] = False
-            else:
-                results["sample_bbox_valid"] = False
-        
-        sample_bbox_pyarrow = table.column("bbox")[0].as_py()
-        results["pyarrow_bbox_type"] = str(type(sample_bbox_pyarrow))
-        results["pyarrow_bbox_value"] = str(sample_bbox_pyarrow)
-        results["pyarrow_bbox_valid"] = (
-            isinstance(sample_bbox_pyarrow, dict) and
-            all(k in sample_bbox_pyarrow for k in ["xmin", "ymin", "xmax", "ymax"]) and
-            sample_bbox_pyarrow["xmin"] < sample_bbox_pyarrow["xmax"] and
-            sample_bbox_pyarrow["ymin"] < sample_bbox_pyarrow["ymax"]
-        )
-        
-        if "assets" in gdf.columns:
-            try:
-                assets = json.loads(sample_row["assets"])
-                results["sample_assets_valid_json"] = True
-                results["sample_assets_is_dict"] = isinstance(assets, dict)
-            except Exception:
-                results["sample_assets_valid_json"] = False
-        
-        if "datetime" in gdf.columns:
-            results["sample_datetime"] = str(sample_row["datetime"])
-        
-        if "id" in gdf.columns:
-            results["sample_id"] = str(sample_row["id"])
-            
-    except Exception as e:
-        results["geopandas_readable"] = False
-        results["geopandas_error"] = str(e)
-    
-    all_valid = all(
-        v is True 
-        for k, v in results.items() 
-        if isinstance(v, bool) and k not in {"sample_geometry_valid", "sample_bbox_valid", "sample_assets_valid_json", "sample_assets_is_dict", "sample_bbox_is_dict", "sample_bbox_has_fields"}
-    )
-    results["overall_valid"] = all_valid
-    
-    return results
-
-validation_results = validate_stac_geoparquet("aef-index-stac-geoparquet.parquet")
-
-print("STAC GeoParquet Validation Results:")
-print("=" * 50)
-for key, value in sorted(validation_results.items()):
-    if isinstance(value, bool):
-        status = "✓" if value else "✗"
-        print(f"{status} {key}: {value}")
-    else:
-        print(f"  {key}: {value}")
-
-if validation_results.get("overall_valid"):
-    print("\n✓ File is valid STAC GeoParquet!")
-else:
-    print("\n✗ File has validation issues. See details above.")
-```
+Code for the conversion is available here https://gist.github.com/isaaccorley/3cf87bfe9a8f41fff429aafb45decdab