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_layer_info(gpkg_path):
    layers_info = []
    
    # Use fiona to list layers and their metadata
    layers = fiona.listlayers(gpkg_path)
    
    for layer_name in layers:
        # Read the layer using geopandas
        gdf = gpd.read_file(gpkg_path, layer=layer_name)
        
        # Get CRS in EPSG:NNNN format
        # Note: gdf.crs might be a string or a pyproj object
        # We want to ensure it's in EPSG:XXXX format
        if gdf.crs is not None:
            try:
                epsg_code = gdf.crs.to_epsg()
                crs_str = f"EPSG:{epsg_code}"
            except Exception:
                # Fallback if to_epsg() fails
                crs_str = str(gdf.crs)
        else:
            crs_str = "Unknown"
            
        # Get geometry type (the most common one in the layer)
        # gdf.geom_type returns the type for the whole GeoDataFrame
        geometry_type = gdf.geom_type.iloc[0] if not gdf.empty else "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]
            
        layers_info.append({
            "layer_name": layer_name,
            "crs": crs_str,
            "geometry_type": geometry_type,
            "feature_count": feature_count,
            "bbox": bbox
        })
        
    return layers_info

if __name__ == "__main__":
    gpkg_path = "vienna_planning.gpkg"
    manifest = get_layer_info(gpkg_path)
    
    with open("manifest.json", "w") as f:
        json.dump(manifest, f, indent=4)
    
    print("Successfully created manifest.json")

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

import geopandas as gpd
import json

def get_layer_info(gpkg_path):
    layers_info = []
    
    # Use engine='pyogrio' for better compatibility and speed if available
    # First, list layers
    try:
        import pyogrio
        layers = pyogrio.list_layers(gpkg_path)
    except ImportError:
        # Fallback to geopandas default if pyogrio is not available (unlikely if we requested it)
        import fiona
        layers = fiona.listlayers(gpkg_path)
    
    for layer_name in layers:
        # Read the layer
        gdf = gpd.read_file(gpkg_path, layer=layer_name)
        
        # Get CRS in EPSG:NNNN format
        crs_str = "Unknown"
        if gdf.crs is not None:
            epsg_code = gdf.crs.to_epsg()
            if epsg_code is not None:
                crs_str = f"EPSG:{epsg_code}"
            else:
                # Fallback if to_epsg() returns None
                crs_str = gdf.crs.to_string()
            
        # Get geometry type
        # In newer geopandas, gdf.geom_type might be a property or a Series.
        # If it's a Series, we take the first value.
        if hasattr(gdf, 'geom_type') and isinstance(gdf.geom_type, (str, type(None))):
             geometry_type = gdf.geom_type
        elif not gdf.empty:
             geometry_type = gdf.geom_type.iloc[0]
        else:
             geometry_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]
            
        layers_info.append({
            "layer_name": layer_name,
            "crs": crs_str,
            "geometry_type": geometry_type,
            "feature_count": feature_count,
            "bbox": bbox
        })
        
    return layers_info

if __name__ == "__main__":
    gpkg_path = "vienna_planning.gpkg"
    manifest = get_layer_info(gpkg_path)
    
    with open("manifest.json", "w") as f:
        json.dump(manifest, f, indent=4)
    
    print("Successfully created manifest.json")

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

import geopandas as gpd
import json

def get_layer_info(gpkg_path):
    layers_info = []
    
    # Use pyogrio to list layers
    import pyogrio
    layers = pyogrio.list_layers(gpkg_path)
    
    # pyogrio.list_layers might return a numpy array, so we convert to list
    if hasattr(layers, 'tolist'):
        layers = layers.tolist()
    
    for layer_name in layers:
        # Read the layer
        gdf = gpd.read_file(gpkg_path, layer=str(layer_name))
        
        # Get CRS in EPSG:NNNN format
        crs_str = "Unknown"
        if gdf.crs is not None:
            epsg_code = gdf.crs.to_epsg()
            if epsg_code is not None:
                crs_str = f"EPSG:{epsg_code}"
            else:
                crs_str = gdf.crs.to_string()
            
        # Get geometry type
        if not gdf.empty:
            # gdf.geom_type is a Series in newer geopandas versions
            # or it might be a single string in older ones.
            # For GeoDataFrame, we want the general geometry type.
            geometry_type = gdf.geom_type.iloc[0] if hasattr(gdf.geom_type, 'iloc') else gdf.geom_type
        else:
            geometry_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]
            
        layers_info.append({
            "layer_name": str(layer_name),
            "crs": crs_str,
            "geometry_type": str(geometry_type),
            "feature_count": int(feature_count),
            "bbox": bbox
        })
        
    return layers_info

if __name__ == "__main__":
    gpkg_path = "vienna_planning.gpkg"
    manifest = get_layer_info(gpkg_path)
    
    with open("manifest.json", "w") as f:
        json.dump(manifest, f, indent=4)
    
    print("Successfully created manifest.json")

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

import geopandas as gpd
import json
import pyogrio

def get_layer_info(gpkg_path):
    layers_info = []
    
    # Use pyogrio to list layers
    layers = pyogrio.list_layers(gpkg_path)
    
    # pyogrio.list_layers might return a numpy array or a list
    if hasattr(layers, 'tolist'):
        layers = layers.tolist()
    
    # In case layers is a single string or something unexpected, make it a list
    if isinstance(layers, str):
        layers = [layers]
        
    for layer_name in layers:
        # layer_name might be an array or a string. Ensure it is a string.
        # The previous error suggested layer_name might have been something weird.
        # Let's check if layer_name is actually a string.
        ln = str(layer_name)
        
        try:
            # Read the layer
            gdf = gpd.read_file(gpkg_path, layer=ln)
            
            # Get CRS in EPSG:NNNN format
            crs_str = "Unknown"
            if gdf.crs is not None:
                epsg_code = gdf.crs.to_epsg()
                if epsg_code is not None:
                    crs_str = f"EPSG:{epsg_code}"
                else:
                    crs_str = gdf.crs.to_string()
                
            # Get geometry type
            if not gdf.empty:
                # In newer geopandas, gdf.geom_type is a Series
                if hasattr(gdf.geom_type, 'iloc'):
                    geometry_type = gdf.geom_type.iloc[0]
                else:
                    geometry_type = gdf.geom_type
            else:
                geometry_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]
                
            layers_info.append({
                "layer_name": ln,
                "crs": crs_str,
                "geometry_type": str(geometry_type),
                "feature_count": int(feature_count),
                "bbox": bbox
            })
        except Exception as e:
            print(f"Error reading layer {ln}: {e}")
            
    return layers_info

if __name__ == "__main__":
    gpkg_path = "vienna_planning.gpkg"
    manifest = get_layer_info(gpkg_path)
    
    with open("manifest.json", "w") as f:
        json.dump(manifest, f, indent=4)
    
    print("Successfully created manifest.json")

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

import geopandas as gpd
import json
import pyogrio

def get_layer_info(gpkg_path):
    layers_info = []
    
    # Use pyogrio to list layers
    layers = pyogrio.list_layers(gpkg_path)
    
    # pyogrio.list_layers might return a numpy array or a list
    if hasattr(layers, 'tolist'):
        layers = layers.tolist()
    
    # In case layers is a single string or something unexpected, make it a list
    if isinstance(layers, str):
        layers = [layers]
        
    for layer_name in layers:
        # It seems pyogrio.list_layers is returning something unexpected
        # In the error message: Layer '['districts', 'Polygon']' could not be opened
        # It looks like the layer name is being interpreted as a list?
        # Let's see what layer_name actually is.
        
        # If layer_name is a list/tuple/array, it's not a simple layer name.
        # Let's try to inspect it.
        
        if isinstance(layer_name, (list, tuple)):
            # If it is a list/tuple, maybe the layer name is the first element?
            # But wait, why would list_layers return a list of lists?
            # The error says Layer '['districts', 'Polygon']' could not be opened.
            # That means layer_name was ['districts', 'Polygon'] (as a string representation)
            # This is very strange for list_layers.
            
            # Let's try taking the first element if it's a list-like object.
            # Or maybe it's a 2D array?
            pass

        ln = layer_name
        if hasattr(ln, '__iter__') and not isinstance(ln, (str, bytes)):
             # If it's an iterable (like a list or numpy array) but not a string,
             # we might have a problem. Let's try to get the first element.
             try:
                 ln = ln[0]
             except:
                 ln = str(ln)
        
        ln = str(ln)
        
        try:
            # Read the layer
            gdf = gpd.read_file(gpkg_path, layer=ln)
            
            # Get CRS in EPSG:NNNN format
            crs_str = "Unknown"
            if gdf.crs is not None:
                epsg_code = gdf.crs.to_epsg()
                if epsg_code is not None:
                    crs_str = f"EPSG:{epsg_code}"
                else:
                    crs_str = gdf.crs.to_string()
                
            # Get geometry type
            if not gdf.empty:
                if hasattr(gdf.geom_type, 'iloc'):
                    geometry_type = gdf.geom_type.iloc[0]
                else:
                    geometry_type = gdf.geom_type
            else:
                geometry_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]
                
            layers_info.append({
                "layer_name": ln,
                "crs": crs_str,
                "geometry_type": str(geometry_type),
                "feature_count": int(feature_count),
                "bbox": bbox
            })
        except Exception as e:
            print(f"Error reading layer {ln}: {e}")
            
    return layers_info

if __name__ == "__main__":
    gpkg_path = "vienna_planning.gpkg"
    
    # Let's debug by printing what layers are actually being returned.
    import pyogrio
    layers = pyogrio.list_layers(gpkg_path)
    print(f"DEBUG: layers = {layers}")
    
    manifest = get_layer_info(gpkg_path)
    
    with open("manifest.json", "w") as f:
        json.dump(manifest, f, indent=4)
    
    print("Successfully created manifest.json")

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

import geopandas as gpd
import json
import pyogrio
import numpy as np

def get_layer_info(gpkg_path):
    layers_info = []
    
    # Use pyogrio to list layers
    layers = pyogrio.list_layers(gpkg_path)
    
    # From DEBUG output, layers is a numpy array of shape (N, 2)
    # where each row is [layer_name, geometry_type]
    # We want to iterate through the rows and use the first column as layer name.
    
    for row in layers:
        ln = str(row[0])
        
        try:
            # Read the layer
            gdf = gpd.read_file(gpkg_path, layer=ln)
            
            # Get CRS in EPSG:NNNN format
            crs_str = "Unknown"
            if gdf.crs is not None:
                epsg_code = gdf.crs.to_epsg()
                if epsg_code is not None:
                    crs_str = f"EPSG:{epsg_code}"
                else:
                    crs_str = gdf.crs.to_string()
                
            # Get geometry type
            if not gdf.empty:
                if hasattr(gdf.geom_type, 'iloc'):
                    geometry_type = gdf.geom_type.iloc[0]
                else:
                    geometry_type = gdf.geom_type
            else:
                geometry_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]
                
            layers_info.append({
                "layer_name": ln,
                "crs": crs_str,
                "geometry_type": str(geometry_type),
                "feature_count": int(feature_count),
                "bbox": bbox
            })
        except Exception as e:
            print(f"Error reading layer {ln}: {e}")
            
    return layers_info

if __name__ == "__main__":
    gpkg_path = "vienna_planning.gpkg"
    manifest = get_layer_info(gpkg_path)
    
    with open("manifest.json", "w") as f:
        json.dump(manifest, f, indent=4)
    
    print("Successfully created manifest.json")