dd-l1-vienna-gpkg-manifest

Rerun

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

import geopandas as gpd
import json
import fiona

def get_epsg(crs):
    if crs is None:
        return "Unknown"
    try:
        # Attempt to get the EPSG code directly if it's a CRS object or string
        return crs.to_epsg()
    except Exception:
        # If it's a string or doesn't have to_epsg, we might need a different approach
        # For simplicity, let's try a more robust way to extract EPSG
        try:
            from pyproj import CRS
            c = CRS.from_user_input(crs)
            return f"EPSG:{c.to_epsg()}"
        except Exception:
            return str(crs)

def main():
    gpkg_path = 'vienna_planning.gpkg'
    layers = fiona.listlayers(gpkg_path)
    manifest = []

    for layer_name in layers:
        gdf = gpd.read_file(gpkg_path, layer=layer_name)
        
        # layer_name
        name = layer_name
        
        # crs
        # Ensure it's in EPSG:NNNN form
        epsg_code = "Unknown"
        if gdf.crs is not None:
            try:
                epsg_code = f"EPSG:{gdf.crs.to_epsg()}"
            except Exception:
                # Fallback if to_epsg() fails
                try:
                    from pyproj import CRS
                    c = CRS.from_user_input(gdf.crs)
                    if c.to_epsg():
                        epsg_code = f"EPSG:{c.to_epsg()}"
                    else:
                        epsg_code = str(gdf.crs)
                except:
                    epsg_code = str(gdf.crs)

        # geometry_type
        # Check the actual geometry type of the first feature if possible, 
        # or use the layer's type. 
        # The requirement says "matching the layer's native type".
        # Most GeoPandas geometric types are things like 'Point', 'LineString', 'Polygon', 'MultiPolygon'.
        # We can infer this from the geometry column.
        if not gdf.empty:
            geom_type = gdf.geometry.type.iloc[0]
        else:
            # If empty, we still need to know the type. We can get it from fiona.
            with fiona.open(gpkg_path, layer=layer_name) as src:
                geom_type = src.schema['geometry']
                # fiona might return 'Polygon' or 'MultiPolygon'
                # Ensure it matches common types if needed, but usually it does.

        # feature_count
        count = len(gdf)

        # bbox [xmin, ymin, xmax, ymax] in native CRS
        # gdf.total_bounds returns [minx, miny, maxx, maxy]
        bbox = gdf.total_bounds.tolist()

        manifest.append({
            "layer_name": name,
            "crs": epsg_code,
            "geometry_type": geom_type,
            "feature_count": count,
            "bbox": bbox
        })

    with open('manifest.json', 'w') as f:
        json.dump(manifest, f, indent=4)

if __name__ == "__main__":
    main()

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

import geopandas as gpd
import json
import fiona
from pyproj import CRS

def get_epsg_string(gdf_crs):
    if gdf_crs is None:
        return "Unknown"
    try:
        # Using pyproj's CRS to handle different CRS input types
        c = CRS.from_user_input(gdf_crs)
        epsg = c.to_epsg()
        if epsg:
            return f"EPSG:{epsg}"
        else:
            # If no EPSG, return the string representation of the CRS
            return str(c)
    except Exception:
        return str(gdf_crs)

def main():
    gpkg_path = 'vienna_planning.gpkg'
    
    # List layers using fiona directly to avoid heavy dependencies if possible
    # but fiona is already in dependencies.
    layers = fiona.listlayers(gpkg_path)
    manifest = []

    for layer_name in layers:
        # Read the layer
        gdf = gpd.read_file(gpkg_path, layer=layer_name)
        
        # layer_name
        name = layer_name
        
        # crs
        epsg_code = get_epsg_string(gdf.crs)

        # geometry_type
        # The requirement asks for "matching the layer's native type (e.g. Point, LineString, Polygon, MultiPolygon)"
        # geopandas .geometry.type returns these strings.
        if not gdf.empty:
            # We take the type of the first non-null geometry if available
            # or simply use the collection type if it's a single type layer.
            # Most GPKG layers are homogeneous.
            geom_type = gdf.geometry.type.iloc[0]
        else:
            # For empty layers, get type from fiona metadata
            with fiona.open(gpkg_path, layer=layer_name) as src:
                geom_type = src.schema['geometry']
        
        # feature_count
        count = len(gdf)

        # bbox [xmin, ymin, xmax, ymax] in native CRS
        # gdf.total_bounds returns [minx, miny, maxx, maxy]
        bbox = gdf.total_bounds.tolist()

        manifest.append({
            "layer_name": name,
            "crs": epsg_code,
            "geometry_type": geom_type,
            "feature_count": count,
            "bbox": bbox
        })

    with open('manifest.json', 'w') as f:
        json.dump(manifest, f, indent=4)

if __name__ == "__main__":
    main()

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

import geopandas as gpd
import json
from pyproj import CRS

def get_epsg_string(gdf_crs):
    if gdf_crs is None:
        return "Unknown"
    try:
        c = CRS.from_user_input(gdf_crs)
        epsg = c.to_epsg()
        if epsg:
            return f"EPSG:{epsg}"
        else:
            return str(c)
    except Exception:
        return str(gdf_crs)

def main():
    gpkg_path = 'vienna_planning.gpkg'
    
    # Use geopandas to get layer names by reading the driver info or similar
    # but geopandas doesn't have a direct 'list layers' method without fiona.
    # However, we can use the driver and the fact that geopandas uses fiona.
    # Let's try to use geopandas to discover layers by inspecting the file.
    
    import fiona
    layers = fiona.listlayers(gpkg_path)
    
    manifest = []

    for layer_name in layers:
        gdf = gpd.read_file(gpkg_path, layer=layer_name)
        
        name = layer_name
        epsg_code = get_epsg_string(gdf.crs)

        if not gdf.empty:
            # Get the geometry type of the first non-null geometry
            # If it's a mixed geometry layer (rare in GPKG), we just take the first.
            geom_type = gdf.geometry.type.iloc[0]
        else:
            # If empty, get type from fiona
            with fiona.open(gpkg_path, layer=layer_name) as src:
                geom_type = src.schema['geometry']
        
        count = len(gdf)
        bbox = gdf.total_bounds.tolist()

        manifest.append({
            "layer_name": name,
            "crs": epsg_code,
            "geometry_type": geom_type,
            "feature_count": count,
            "bbox": bbox
        })

    with open('manifest.json', 'w') as f:
        json.dump(manifest, f, indent=4)

if __name__ == "__main__":
    main()

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

import geopandas as gpd
import json
import fiona
from pyproj import CRS

def get_epsg_string(gdf_crs):
    if gdf_crs is None:
        return "Unknown"
    try:
        c = CRS.from_user_input(gdf_crs)
        epsg = c.to_epsg()
        if epsg:
            return f"EPSG:{epsg}"
        else:
            return str(c)
    except Exception:
        return str(gdf_crs)

def main():
    gpkg_path = 'vienna_planning.gpkg'
    
    layers = fiona.listlayers(gpkg_path)
    manifest = []

    for layer_name in layers:
        gdf = gpd.read_file(gpkg_path, layer=layer_name)
        
        name = layer_name
        epsg_code = get_epsg_string(gdf.crs)

        if not gdf.empty:
            geom_type = gdf.geometry.type.iloc[0]
        else:
            with fiona.open(gpkg_path, layer=layer_name) as src:
                geom_type = src.schema['geometry']
        
        count = len(gdf)
        bbox = gdf.total_bounds.tolist()

        manifest.append({
            "layer_name": name,
            "crs": epsg_code,
            "geometry_type": geom_type,
            "feature_count": count,
            "bbox": bbox
        })

    with open('manifest.json', 'w') as f:
        json.dump(manifest, f, indent=4)

if __name__ == "__main__":
    main()

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

import geopandas as gpd
import json
from pyproj import CRS
import fiona

def get_epsg_string(gdf_crs):
    if gdf_crs is None:
        return "Unknown"
    try:
        c = CRS.from_user_input(gdf_crs)
        epsg = c.to_epsg()
        if epsg:
            return f"EPSG:{epsg}"
        else:
            return str(c)
    except Exception:
        return str(gdf_crs)

def main():
    gpkg_path = 'vienna_planning.gpkg'
    
    # We will use fiona directly to list layers to avoid potential dependency issues if possible,
    # but since geopandas is required, we might as well use fiona via geopandas' dependency.
    # However, since fiona failed to build earlier, let's check if geopandas works alone.
    # Geopandas uses fiona/pyogrio internally.
    
    try:
        layers = fiona.listlayers(gpkg_path)
    except Exception as e:
        # If fiona is failing, we might need to use another way. 
        # But let's try to see if we can just use geopandas if it's available.
        # Actually, the previous error was a build error for fiona.
        # Let's try to see what's available.
        print(f"Error listing layers: {e}")
        return

    manifest = []

    for layer_name in layers:
        gdf = gpd.read_file(gpkg_path, layer=layer_name)
        
        name = layer_name
        epsg_code = get_epsg_string(gdf.crs)

        if not gdf.empty:
            geom_type = gdf.geometry.type.iloc[0]
        else:
            # Try to get type from fiona if gdf is empty
            try:
                with fiona.open(gpkg_path, layer=layer_name) as src:
                    geom_type = src.schema['geometry']
            except:
                geom_type = "Unknown"
        
        count = len(gdf)
        bbox = gdf.total_bounds.tolist()

        manifest.append({
            "layer_name": name,
            "crs": epsg_code,
            "geometry_type": geom_type,
            "feature_count": count,
            "bbox": bbox
        })

    with open('manifest.json', 'w') as f:
        json.dump(manifest, f, indent=4)

if __name__ == "__main__":
    main()

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

import geopandas as gpd
import json
from pyproj import CRS

def get_epsg_string(gdf_crs):
    if gdf_crs is None:
        return "Unknown"
    try:
        c = CRS.from_user_input(gdf_crs)
        epsg = c.to_epsg()
        if epsg:
            return f"EPSG:{epsg}"
        else:
            return str(c)
    except Exception:
        return str(gdf_crs)

def main():
    gpkg_path = 'vienna_planning.gpkg'
    
    # Since fiona is problematic, let's try to use geopandas's ability to read layers
    # but geopandas doesn't provide a direct way to list all layers without fiona.
    # Let's try to use the pyogrio engine if available, or just try to guess if there's another way.
    # Actually, let's try to use a python library that might be more easily installable.
    # Wait, I can try to use the 'pyogrio' engine in geopandas if it's installed.
    
    # Let's try to use the 'pyogrio' engine which is often faster and might be easier to install.
    # But I don't know if it's there.
    
    # Alternative: use the fact that we can try reading layers by index if we knew how many there are.
    # But we don't.
    
    # Let's try to use 'fiona' again but with a different approach if possible, 
    # or check if 'pyogrio' is an option.
    # Actually, I'll try to see if I can use a simple approach to list layers.
    
    # How about we use 'geopandas' to read all layers by trying to catch errors? No, that's bad.
    
    # Let's try to use the 'pyogrio' engine.
    import subprocess
    
    # Try to get layers using a subprocess call to ogrinfo if it's available
    try:
        result = subprocess.run(['ogrinfo', '-so', gpkg_path], capture_output=True, text=True)
        if result.returncode == 0:
            lines = result.stdout.split('\n')
            layers = []
            for line in lines:
                if 'Layer name:' in line:
                    layers.append(line.split('Layer name:')[1].strip())
            if layers:
                print(f"Found layers using ogrinfo: {layers}")
            else:
                print("ogrinfo found no layers.")
        else:
            print(f"ogrinfo failed: {result.stderr}")
    except Exception as e:
        print(f"ogrinfo call failed: {e}")

    # Actually, let's try to use the subprocess to get layers and then use geopandas to read them.
    
    import subprocess
    try:
        result = subprocess.run(['ogrinfo', '-so', gpkg_path], capture_output=True, text=True)
        layers = []
        if result.returncode == 0:
            for line in result.stdout.split('\n'):
                if 'Layer name:' in line:
                    layers.append(line.split('Layer name:')[1].strip())
        
        if not layers:
            # Fallback: try to use a different ogrinfo command
            result = subprocess.run(['ogrinfo', gpkg_path], capture_output=True, text=True)
            for line in result.stdout.split('\n'):
                if 'Layer name:' in line:
                    layers.append(line.split('Layer name:')[1].strip())
    except Exception as e:
        print(f"Error using ogrinfo: {e}")
        layers = []

    if not layers:
        # If ogrinfo failed, we are stuck. But let's assume it works in this environment.
        return

    manifest = []

    for layer_name in layers:
        try:
            gdf = gpd.read_file(gpkg_path, layer=layer_name)
            
            name = layer_name
            epsg_code = get_epsg_string(gdf.crs)

            if not gdf.empty:
                geom_type = gdf.geometry.type.iloc[0]
            else:
                # If empty, we can't easily get the type from gdf.
                # We'll use ogrinfo output to find the geometry type.
                geom_type = "Unknown"
                # This is a bit of a hack, but we can try to find it in the ogrinfo output for this layer
                # but that's complex. Let's just skip or put Unknown.

            count = len(gdf)
            bbox = gdf.total_bounds.tolist()

            manifest.append({
                "layer_name": name,
                "crs": epsg_code,
                "geometry_type": geom_type,
                "feature_count": count,
                "bbox": bbox
            })
        except Exception as e:
            print(f"Error reading layer {layer_name}: {e}")

    with open('manifest.json', 'w') as f:
        json.dump(manifest, f, indent=4)

if __name__ == "__main__":
    main()

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

import geopandas as gpd
import json
import fiona
from pyproj import CRS

def get_epsg_string(gdf_crs):
    if gdf_crs is None:
        return "Unknown"
    try:
        c = CRS.from_user_input(gdf_crs)
        epsg = c.to_epsg()
        if epsg:
            return f"EPSG:{epsg}"
        else:
            return str(c)
    except Exception:
        return str(gdf_crs)

def main():
    gpkg_path = 'vienna_planning.gpkg'
    
    # Let's try to use fiona again, but maybe it can be installed if I declare it correctly.
    # Actually, the previous error was "Failed to build fiona==1.10.1". 
    # This usually means it's trying to compile from source and failing because of missing system libraries.
    # Let's try to see if there's another way.
    # What if I use 'pyogrio' instead?
    
    try:
        import pyogrio
        layers = pyogrio.list_layers(gpkg_path)
    except ImportError:
        # If pyogrio is not available, try fiona
        try:
            layers = fiona.listlayers(gpkg_path)
        except Exception as e:
            # If both fail, let's try a very desperate measure:
            # use geopandas to read layers one by one if we can find their names.
            # But we can't find their names.
            print(f"Could not list layers: {e}")
            return

    manifest = []

    for layer_name in layers:
        try:
            # Use pyogrio if available, otherwise geopandas (which uses fiona/pyogrio)
            gdf = gpd.read_file(gpkg_path, layer=layer_name)
            
            name = layer_name
            epsg_code = get_epsg_string(gdf.crs)

            if not gdf.empty:
                # Get the geometry type of the first non-null geometry
                geom_type = gdf.geometry.type.iloc[0]
            else:
                # If empty, try to get type from fiona if available
                try:
                    with fiona.open(gpkg_path, layer=layer_name) as src:
                        geom_type = src.schema['geometry']
                except:
                    geom_type = "Unknown"
            
            count = len(gdf)
            bbox = gdf.total_bounds.tolist()

            manifest.append({
                "layer_name": name,
                "crs": epsg_code,
                "geometry_type": geom_type,
                "feature_count": count,
                "bbox": bbox
            })
        except Exception as e:
            print(f"Error reading layer {layer_name}: {e}")

    with open('manifest.json', 'w') as f:
        json.dump(manifest, f, indent=4)

if __name__ == "__main__":
    main()

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

import geopandas as gpd
import json
import pyogrio
from pyproj import CRS

def get_epsg_string(gdf_crs):
    if gdf_crs is None:
        return "Unknown"
    try:
        c = CRS.from_user_input(gdf_crs)
        epsg = c.to_epsg()
        if epsg:
            return f"EPSG:{epsg}"
        else:
            return str(c)
    except Exception:
        return str(gdf_crs)

def main():
    gpkg_path = 'vienna_planning.gpkg'
    
    try:
        layers = pyogrio.list_layers(gpkg_path)
    except Exception as e:
        print(f"Error listing layers: {e}")
        return

    manifest = []

    for layer_name in layers:
        try:
            # Using pyogrio engine directly in geopandas
            gdf = gpd.read_file(gpkg_path, layer=layer_name, engine="pyogrio")
            
            name = layer_name
            epsg_code = get_epsg_string(gdf.crs)

            if not gdf.empty:
                geom_type = gdf.geometry.type.iloc[0]
            else:
                # If empty, try to get type from pyogrio metadata
                # This is a bit tricky, but let's try to get the geometry type from the layer metadata
                meta = pyogrio.read_info(gpkg_path, layer=layer_name)
                geom_type = meta['geometry_type']
            
            count = len(gdf)
            bbox = gdf.total_bounds.tolist()

            manifest.append({
                "layer_name": name,
                "crs": epsg_code,
                "geometry_type": geom_type,
                "feature_count": count,
                "bbox": bbox
            })
        except Exception as e:
            print(f"Error reading layer {layer_name}: {e}")

    with open('manifest.json', 'w') as f:
        json.dump(manifest, f, indent=4)

if __name__ == "__main__":
    main()

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

import geopandas as gpd
import json
import pyogrio
from pyproj import CRS

def get_epsg_string(gdf_crs):
    if gdf_crs is None:
        return "Unknown"
    try:
        c = CRS.from_user_input(gdf_crs)
        epsg = c.to_epsg()
        if epsg:
            return f"EPSG:{epsg}"
        else:
            return str(c)
    except Exception:
        return str(gdf_crs)

def main():
    gpkg_path = 'vienna_planning.gpkg'
    
    try:
        # pyogrio.list_layers might return a list of arrays if the output is strange?
        # Let's check what it actually returns.
        raw_layers = pyogrio.list_layers(gpkg_path)
        print(f"Raw layers: {raw_layers}")
        
        # It seems it's returning an array of [name, type] pairs based on the error message.
        # Let's fix it.
        layers = []
        for item in raw_layers:
            if isinstance(item, (list, tuple, type(raw_layers[0]))): # if it's a list-like
                 # Actually the error said: Error reading layer ['districts' 'Polygon']
                 # This means 'layer_name' was ['districts' 'Polygon']
                 # So raw_layers is likely something like [['districts', 'Polygon'], ['parks', 'MultiPolygon'], ...]
                 # OR it's a numpy array of shape (N, 2)
                 layers.append(item[0])
            else:
                 layers.append(item)
                 
    except Exception as e:
        print(f"Error listing layers: {e}")
        return

    manifest = []

    for layer_name in layers:
        try:
            gdf = gpd.read_file(gpkg_path, layer=layer_name, engine="pyogrio")
            
            name = layer_name
            epsg_code = get_epsg_string(gdf.crs)

            if not gdf.empty:
                geom_type = gdf.geometry.type.iloc[0]
            else:
                meta = pyogrio.read_info(gpkg_path, layer=layer_name)
                geom_type = meta['geometry_type']
            
            count = len(gdf)
            bbox = gdf.total_bounds.tolist()

            manifest.append({
                "layer_name": name,
                "crs": epsg_code,
                "geometry_type": geom_type,
                "feature_count": count,
                "bbox": bbox
            })
        except Exception as e:
            print(f"Error reading layer {layer_name}: {e}")

    with open('manifest.json', 'w') as f:
        json.dump(manifest, f, indent=4)

if __name__ == "__main__":
    main()