fio-l1-vienna-shapefile-recovery

Rerun

import geopandas as gpd
import pandas as pd
import json

def solve():
    # Load column map
    # The CSV seems to have an index column and two columns: truncated and original
    # Looking at the content: "     1	truncated,original" is the header or part of it.
    # Let's try reading it with pandas and see what happens.
    
    try:
        # Reading with sep=None to let pandas detect the separator (it looks like tabs or mixed)
        # Based on the 'Read' output, it might be a tab or spaces.
        # Let's try reading it directly.
        df_map = pd.read_csv('column_map.csv', sep=None, engine='python')
        print("Column map loaded successfully:")
        print(df_map)
    except Exception as e:
        print(f"Error reading column_map.csv: {e}")
        return

    # Create the mapping dictionary: {truncated: original}
    # Looking at the data: 
    # 1  truncated,original
    # 2  KATASTRALG,KATASTRALGEMEINDE_NAME
    # ...
    # It seems the first column is an index.
    # The columns are 'truncated' and 'original' (or similar)
    
    # Let's inspect the columns of df_map
    print(f"DataFrame columns: {df_map.columns.tolist()}")
    
    # We need to handle the potential leading index/whitespace issues.
    # The column names in the dataframe might be slightly different.
    # Let's identify which columns correspond to truncated and original.
    
    # Let's assume the columns are the ones containing the mapping.
    # Based on the text: "     1	truncated,original"
    # This looks like:
    # Col 0: Index
    # Col 1: truncated
    # Col 2: original
    
    # Let's rename columns to be safe or find them.
    # We'll use a more robust way to find the columns.
    mapping = {}
    for _, row in df_map.iterrows():
        # We expect truncated to be in one and original in another.
        # Based on the content:
        # row[1] is truncated, row[2] is original (or similar)
        # Let's try to find the column names that aren't the index.
        
        # Let's find column names that aren't the first one if it's just an index.
        # Or just use positional indexing if we are sure.
        
        # In the 'Read' output:
        # "     1	truncated,original"
        # This suggests the first row of data might be the header.
        pass

    # Let's refine the mapping extraction.
    # Let's assume the column names are 'truncated' and 'original'.
    # If they are not, we will look for them.
    
    # Looking at the 'Read' output again:
    #      1	truncated,original
    #      2	KATASTRALG,KATASTRALGEMEINDE_NAME
    # ...
    # It looks like the first column is a row index.
    
    # Let's try to strip whitespace from column names.
    df_map.columns = [str(c).strip() for c in df_map.columns]
    
    # If 'truncated' and 'original' are in the columns:
    if 'truncated' in df_map.columns and 'original' in df_map.columns:
        mapping = dict(zip(df_map['truncated'], df_map['original']))
    else:
        # Fallback: try to find them by position
        # Assuming columns are [Index, truncated, original]
        # Or [truncated, original]
        print("Could not find 'truncated' and 'original' columns by name. Trying positional.")
        # If the first column is an index (like 1, 2, 3...), the next two should be the ones.
        # Let's assume the mapping is in the last two columns.
        cols = df_map.columns.tolist()
        if len(cols) >= 2:
            # Try to see if the second to last is truncated and last is original
            # Or if it's columns[1] and columns[2]
            # Let's just use the last two columns for now.
            mapping = dict(zip(df_map.iloc[:, -2], df_map.iloc[:, -1]))
        else:
            print("Failed to extract mapping from CSV.")
            return

    print(f"Extracted mapping: {mapping}")

    # Load the shapefile
    try:
        gdf = gpd.read_file('parcels.shp')
        print("Shapefile loaded successfully.")
        print(f"Original columns: {gdf.columns.tolist()}")
    except Exception as e:
        print(f"Error reading shapefile: {e}")
        return

    # Rename columns
    # We only rename if the truncated name exists in the columns
    gdf = gdf.rename(columns=mapping)
    print(f"Renamed columns: {gdf.columns.tolist()}")

    # Ensure geometry is Polygon or MultiPolygon
    # Geopandas usually handles this, but let's verify.
    # We'll filter if there's anything else, but usually, it's fine.
    
    # Export to GeoJSON
    try:
        # GeoJSON doesn't support all data types well, but standard ones are fine.
        # We use to_json or write via fiona/pyogrio
        gdf.to_file('parcels.geojson', driver='GeoJSON')
        print("Successfully saved parcels.geojson")
    except Exception as e:
        print(f"Error saving GeoJSON: {e}")

if __name__ == "__main__":
    solve()