dd-l1-vienna-gpkg-manifest

Rerun

# /// script
# requires-python = ">=3.12"
# dependencies = ["geopandas", "fiona", "pyproj"]
# ///

import geopandas as gpd
import fiona
import json

def get_manifest(gpkg_path):
    layers = fiona.listlayers(gpkg_path)
    manifest = []
    
    for layer_name in layers:
        # Read the layer
        gdf = gpd.read_file(gpkg_path, layer=layer_name)
        
        # Get CRS in EPSG:NNNN form
        # gdf.crs.to_epsg() returns the EPSG code as an integer or None
        epsg_code = gdf.crs.to_epsg()
        if epsg_code is not None:
            crs_str = f"EPSG:{epsg_code}"
        else:
            # If to_epsg fails, try to get it from the CRS directly or fallback
            # For this task, we assume it's possible or we'll handle the string
            crs_str = str(gdf.crs)

        # Get geometry type
        # The most common types are Point, LineString, Polygon, MultiPoint, MultiLineString, MultiPolygon
        # geopandas uses shapely types. We can get the type from the first geometry if it exists.
        if not gdf.empty:
            geom_type = gdf.geometry.iloc[0].geom_type
        else:
            geom_type = "Unknown"

        # Feature count
        feature_count = len(gdf)

        # Bounding box [xmin, ymin, xmax, ymax]
        if not gdf.empty:
            bounds = gdf.total_bounds # [xmin, ymin, xmax, ymax]
            bbox = bounds.tolist()
        else:
            bbox = [0.0, 0.0, 0.0, 0.0]

        manifest.append({
            "layer_name": layer_name,
            "crs": crs_str,
            "geometry_type": geom_type,
            "feature_count": feature_count,
            "bbox": bbox
        })
        
    return manifest

if __name__ == "__main__":
    gpkg_file = "vienna_planning.gpkg"
    manifest_data = get_manifest(gpkg_file)
    
    with open("manifest.json", "w") as f:
        json.dump(manifest_data, f, indent=4)
    
    print("Manifest generated successfully.")

# /// script
# requires-python = ">=3.12"
# dependencies = ["geopandas", "pyproj"]
# ///

import geopandas as gpd
import json

def get_manifest(gpkg_path):
    # Use geopandas engine directly if possible, or fiona if available.
    # geopandas' read_file can use fiona under the hood, but we'll try to 
    # get layers another way if fiona installation is tricky.
    
    import fiona
    layers = fiona.listlayers(gpkg_path)
    manifest = []
    
    for layer_name in layers:
        # Read the layer
        gdf = gpd.read_file(gpkg_path, layer=layer_name)
        
        # Get CRS in EPSG:NNNN form
        # gdf.crs.to_epsg() returns the EPSG code as an integer or None
        epsg_code = gdf.crs.to_epsg()
        if epsg_code is not None:
            crs_str = f"EPSG:{epsg_code}"
        else:
            # Fallback to string representation if to_epsg is None
            # We want to try and ensure it looks like EPSG:XXXX if possible
            crs_str = str(gdf.crs)

        # Get geometry type
        # Use the first geometry to determine type
        if not gdf.empty:
            # geopandas geometry series may contain different types
            # We'll take the type of the first non-null geometry
            first_geom = gdf.geometry.dropna().iloc[0] if not gdf.geometry.dropna().empty else None
            if first_geom:
                geom_type = first_geom.geom_type
            else:
                geom_type = "Unknown"
        else:
            geom_type = "Unknown"

        # Feature count
        feature_count = len(gdf)

        # Bounding box [xmin, ymin, xmax, ymax]
        if not gdf.empty:
            bounds = gdf.total_bounds # [xmin, ymin, xmax, ymax]
            bbox = [float(x) for x in bounds]
        else:
            bbox = [0.0, 0.0, 0.0, 0.0]

        manifest.append({
            "layer_name": layer_name,
            "crs": crs_str,
            "geometry_type": geom_type,
            "feature_count": feature_count,
            "bbox": bbox
        })
        
    return manifest

if __name__ == "__main__":
    gpkg_file = "vienna_planning.gpkg"
    try:
        manifest_data = get_manifest(gpkg_file)
        with open("manifest.json", "w") as f:
            json.dump(manifest_data, f, indent=4)
        print("Manifest generated successfully.")
    except Exception as e:
        print(f"Error: {e}")

# /// script
# requires-python = ">=3.12"
# dependencies = ["geopandas", "pyproj", "fiona"]
# ///

import geopandas as gpd
import fiona
import json

def get_manifest(gpkg_path):
    layers = fiona.listlayers(gpkg_path)
    manifest = []
    
    for layer_name in layers:
        gdf = gpd.read_file(gpkg_path, layer=layer_name)
        
        # Handle CRS
        epsg_code = gdf.crs.to_epsg()
        if epsg_code is not None:
            crs_str = f"EPSG:{epsg_code}"
        else:
            # Fallback if EPSG is not directly available via to_epsg
            # Often it might be there in the proj4 or wkt
            crs_str = str(gdf.crs)
            # Try to extract EPSG from CRS if it's not in EPSG:NNNN form
            # This is a bit of a hack but let's try to be cleaner
            if "EPSG" in crs_str:
                import re
                match = re.search(r'EPSG[:\s]+(\d+)', crs_str)
                if match:
                    crs_str = f"EPSG:{match.group(1)}"

        # Geometry Type
        if not gdf.empty:
            # Use the type of the first geometry
            geom_type = gdf.geometry.iloc[0].geom_type
        else:
            geom_type = "Unknown"

        # Feature Count
        feature_count = len(gdf)

        # Bounding Box
        if not gdf.empty:
            bbox = gdf.total_bounds.tolist()
        else:
            bbox = [0.0, 0.0, 0.0, 0.0]

        manifest.append({
            "layer_name": layer_name,
            "crs": crs_str,
            "geometry_type": geom_type,
            "feature_count": feature_count,
            "bbox": bbox
        })
        
    return manifest

if __name__ == "__main__":
    gpkg_file = "vienna_planning.gpkg"
    manifest_data = get_manifest(gpkg_file)
    with open("manifest.json", "w") as f:
        json.dump(manifest_data, f, indent=4)
    print("Done")

# /// script
# requires-python = ">=3.12"
# dependencies = ["geopandas", "pyproj"]
# ///

import geopandas as gpd
import json

def get_manifest(gpkg_path):
    import fiona
    # We'll use fiona's listlayers if it's already installed in the environment
    # even if it's not explicitly in our dependency list (it's a dependency of geopandas)
    layers = fiona.listlayers(gpkg_path)
    manifest = []
    
    for layer_name in layers:
        gdf = gpd.read_file(gpkg_path, layer=layer_name)
        
        # Get CRS in EPSG:NNNN form
        epsg_code = gdf.crs.to_epsg()
        if epsg_code is not None:
            crs_str = f"EPSG:{epsg_code}"
        else:
            # If to_epsg fails, try to extract it
            crs_str = str(gdf.crs)
            import re
            match = re.search(r'EPSG[:\s]+(\d+)', crs_str)
            if match:
                crs_str = f"EPSG:{match.group(1)}"

        # Geometry type
        if not gdf.empty:
            # We want the most representative geometry type (e.g. MultiPolygon -> Polygon? No, instruction says "matching the layer's native type")
            # shapely geom_type returns things like 'Polygon', 'MultiPolygon', 'Point', etc.
            geom_type = gdf.geometry.iloc[0].geom_type
        else:
            geom_type = "Unknown"

        # Feature count
        feature_count = len(gdf)

        # Bounding box [xmin, ymin, xmax, ymax]
        if not gdf.empty:
            bounds = gdf.total_bounds # [xmin, ymin, xmax, ymax]
            bbox = [float(x) for x in bounds]
        else:
            bbox = [0.0, 0.0, 0.0, 0.0]

        manifest.append({
            "layer_name": layer_name,
            "crs": crs_str,
            "geometry_type": geom_type,
            "feature_count": feature_count,
            "bbox": bbox
        })
        
    return manifest

if __name__ == "__main__":
    gpkg_file = "vienna_planning.gpkg"
    manifest_data = get_manifest(gpkg_file)
    
    with open("manifest.json", "w") as f:
        json.dump(manifest_data, f, indent=4)
    
    print("Manifest generated successfully.")

# /// script
# requires-python = ">=3.12"
# dependencies = ["geopandas", "pyproj"]
# ///

import geopandas as gpd
import json
import re

def get_manifest(gpkg_path):
    # Using geopandas' internal way to list layers if fiona isn't easily installable
    # actually, geopandas.read_file doesn't have a list_layers method directly.
    # But we can use the engine to find layers.
    # Let's try using the engine=pyogrio if available, but first let's check if we can get layers via geopandas itself.
    
    # Another way to list layers in a GPKG is using the engine directly if it is available.
    # Since fiona is failing to build, let's try to see if geopandas can do it.
    
    # Wait, I can try to use the 'pyogrio' engine if it is already installed.
    # If not, I'll try to use fiona but let's check the error again.
    # The error was "Failed to build fiona". This is because it's trying to build from source.
    # Let's try to use geopandas to read the file.
    
    # Actually, I'll use a trick: geopandas often uses fiona or pyogrio.
    # Let's try to use the fiona-less way if possible.
    # Actually, I can just use the engine 'pyogrio' if it's installed.
    
    import fiona # This might fail, but let's see if we can use it if it's already in the environment
    # If it's not in the environment, we have a problem.
    # But wait, the user is asking me to solve a task. I should be able to do it.
    
    # Let's try to list layers using the pyogrio engine if available, 
    # or just check the error of the previous attempt.
    pass

# Let's try to write a script that doesn't rely on fiona being built.
# Maybe it's already installed in the environment?

# /// script
# requires-python = ">=3.12"
# dependencies = ["geopandas", "pyproj", "pyogrio"]
# ///

import geopandas as gpd
import json
import re

def get_manifest(gpkg_path):
    import pyogrio
    layers = pyogrio.list_layers(gpkg_path)
    manifest = []
    
    for layer_name in layers:
        gdf = gpd.read_file(gpkg_path, layer=layer_name, engine="pyogrio")
        
        # Get CRS in EPSG:NNNN form
        epsg_code = gdf.crs.to_epsg()
        if epsg_code is not None:
            crs_str = f"EPSG:{epsg_code}"
        else:
            crs_str = str(gdf.crs)
            match = re.search(r'EPSG[:\s]+(\d+)', crs_str)
            if match:
                crs_str = f"EPSG:{match.group(1)}"

        # Geometry type
        if not gdf.empty:
            geom_type = gdf.geometry.iloc[0].geom_type
        else:
            geom_type = "Unknown"

        # Feature count
        feature_count = len(gdf)

        # Bounding box [xmin, ymin, xmax, ymax]
        if not gdf.empty:
            bounds = gdf.total_bounds # [xmin, ymin, xmax, ymax]
            bbox = [float(x) for x in bounds]
        else:
            bbox = [0.0, 0.0, 0.0, 0.0]

        manifest.append({
            "layer_name": layer_name,
            "crs": crs_str,
            "geometry_type": geom_type,
            "feature_count": feature_count,
            "bbox": bbox
        })
        
    return manifest

if __name__ == "__main__":
    gpkg_file = "vienna_planning.gpkg"
    try:
        manifest_data = get_manifest(gpkg_file)
        with open("manifest.json", "w") as f:
            json.dump(manifest_data, f, indent=4)
        print("Manifest generated successfully.")
    except Exception as e:
        print(f"Error: {e}")

# /// script
# requires-python = ">=3.12"
# dependencies = ["geopandas", "pyproj", "pyogrio"]
# ///

import geopandas as gpd
import json
import re

def get_manifest(gpkg_path):
    import pyogrio
    layers = pyogrio.list_layers(gpkg_path)
    manifest = []
    
    for layer_name in layers:
        # layer_name is likely a string or a single-element array
        if isinstance(layer_name, (list, type(pyogrio.list_layers(gpkg_path)[0]))):
             layer_name = layer_name[0]
             
        gdf = gpd.read_file(gpkg_path, layer=str(layer_name), engine="pyogrio")
        
        # Get CRS in EPSG:NNNN form
        epsg_code = gdf.crs.to_epsg()
        if epsg_code is not None:
            crs_str = f"EPSG:{epsg_code}"
        else:
            crs_str = str(gdf.crs)
            match = re.search(r'EPSG[:\s]+(\d+)', crs_str)
            if match:
                crs_str = f"EPSG:{match.group(1)}"

        # Geometry type
        if not gdf.empty:
            geom_type = gdf.geometry.iloc[0].geom_type
        else:
            geom_type = "Unknown"

        # Feature count
        feature_count = len(gdf)

        # Bounding box [xmin, ymin, xmax, ymax]
        if not gdf.empty:
            bounds = gdf.total_bounds # [xmin, ymin, xmax, ymax]
            bbox = [float(x) for x in bounds]
        else:
            bbox = [0.0, 0.0, 0.0, 0.0]

        manifest.append({
            "layer_name": str(layer_name),
            "crs": crs_str,
            "geometry_type": geom_type,
            "feature_count": feature_count,
            "bbox": bbox
        })
        
    return manifest

if __name__ == "__main__":
    gpkg_file = "vienna_planning.gpkg"
    try:
        manifest_data = get_manifest(gpkg_file)
        with open("manifest.json", "w") as f:
            json.dump(manifest_data, f, indent=4)
        print("Manifest generated successfully.")
    except Exception as e:
        import traceback
        traceback.print_exc()
        print(f"Error: {e}")