geo-l1-tokyo-busstop-buffer

Rerun

import geopandas as gpd

def solve():
    # Load the connectors
    input_file = "tokyo_connectors.geojson"
    output_file = "tokyo_stop_catchments.geoparquet"
    
    print(f"Reading {input_file}...")
    gdf = gpd.read_file(input_file)
    
    # Check if connector_id exists
    if 'connector_id' not in gdf.columns:
        raise ValueError("Column 'connector_id' not found in input file.")

    # Ensure we are working with a projected CRS for accurate buffering in meters
    # Tokyo is roughly around EPSG:3857 (Web Mercator) or a local UTM.
    # Since we want 400m, we should reproject to a metric CRS.
    # EPSG:3857 is common, but for Japan, UTM Zone 54N (EPSG:32654) is more precise.
    # Let's use EPSG:3857 for simplicity or EPSG:6677 (JGD2011 / Japan Plane Rectangular CS IX)
    # Actually, let's just use EPSG:3857 as it's widely used for web mapping and good enough for 400m buffers.
    # Or better, let's use a local UTM zone if possible.
    # Let's check the coordinates to be sure. 
    # 139.76, 35.68 is Tokyo.
    
    print("Reprojecting to metric CRS (EPSG:3857) for buffering...")
    gdf_metric = gdf.to_crs(epsg=3857)
    
    # Create 400m buffer
    print("Creating 400m buffers...")
    gdf_metric['geometry'] = gdf_metric.buffer(400)
    
    # Reproject back to original CRS (likely WGS84 / EPSG:4326)
    print("Reprojecting back to original CRS...")
    gdf_final = gdf_metric.to_crs(gdf.crs)
    
    # Ensure we keep only the required columns: connector_id and geometry
    # The user asked to "keep connector_id on every row".
    # Let's also ensure we don't have extra columns if not needed, 
    # but standard practice is to keep what's there.
    # The prompt implies the join key is the priority.
    
    # The instruction says: "with one Polygon or MultiPolygon row per input connector"
    # gdf.buffer() returns one geometry per row, so this is satisfied.
    
    print(f"Saving to {output_file}...")
    gdf_final.to_parquet(output_file)
    print("Done.")

if __name__ == "__main__":
    solve()

import geopandas as gpd

def check_output():
    output_file = "tokyo_stop_catchments.geoparquet"
    gdf = gpd.read_file(output_file)
    
    print("--- Shape ---")
    print(gdf.shape)
    print("\n--- Columns ---")
    print(gdf.columns.tolist())
    print("\n--- Geometry Types ---")
    print(gdf.geometry.type.value_counts())
    print("\n--- Preview ---")
    print(gdf[['connector_id', 'geometry']].head())
    
    # Check if geometry is Polygon or MultiPolygon
    geom_types = set(gdf.geometry.type)
    allowed = {'Polygon', 'MultiPolygon'}
    if not geom_types.issubset(allowed):
        print(f"\nWARNING: Unexpected geometry types found: {geom_types}")
    else:
        print("\nGeometry types are valid (Polygon/MultiPolygon).")

if __name__ == "__main__":
    check_output()

import geopandas as gpd
import pandas as pd

def check_output():
    output_file = "tokyo_stop_catchments.geoparquet"
    
    # Try reading with pandas/pyarrow first as it is a parquet file
    try:
        df = pd.read_parquet(output_file)
        print("Read successfully with pandas/pyarrow.")
        
        # Convert back to GeoDataFrame for geometry inspection
        gdf = gpd.GeoDataFrame(df, geometry='geometry', crs='EPSG:4326')
        
        print("\n--- Shape ---")
        print(gdf.shape)
        print("\n--- Columns ---")
        print(gdf.columns.tolist())
        print("\n--- Geometry Types ---")
        print(gdf.geometry.type.value_counts())
        print("\n--- Preview ---")
        print(gdf[['connector_id', 'geometry']].head())
        
        # Check if geometry is Polygon or MultiPolygon
        geom_types = set(gdf.geometry.type)
        allowed = {'Polygon', 'MultiPolygon'}
        if not geom_types.issubset(allowed):
             print(f"\nWARNING: Unexpected geometry types found: {geom_types}")
        else:
             print("\nGeometry types are valid (Polygon/MultiPolygon).")
             
    except Exception as e:
        print(f"Error: {e}")

if __name__ == "__main__":
    check_output()

import geopandas as gpd
import pandas as pd

def solve():
    # Load the connectors
    input_file = "tokyo_connectors.geojson"
    output_file = "tokyo_stop_catchments.geoparquet"
    
    print(f"Reading {input_file}...")
    gdf = gpd.read_file(input_file)
    
    # Ensure we have connector_id
    if 'connector_id' not in gdf.columns:
        raise ValueError("Column 'connector_id' not found in input file.")

    # Reproject to a metric CRS (using EPSG:3857 for simplicity as it's standard for web maps)
    # For higher precision in Tokyo, one might use EPSG:6677, but 3857 is usually fine for 400m.
    print("Reprojecting to EPSG:3857 for buffering...")
    gdf_metric = gdf.to_crs(epsg=3857)
    
    # Buffer 400m
    print("Creating 400m buffers...")
    gdf_metric['geometry'] = gdf_metric.buffer(400)
    
    # Reproject back to WGS84 (original CRS)
    print("Reprojecting back to original CRS...")
    gdf_final = gdf_metric.to_crs(gdf.crs)
    
    # Select only necessary columns: connector_id and geometry
    # The user wants to keep connector_id.
    gdf_final = gdf_final[['connector_id', 'geometry']]
    
    # Save to GeoParquet
    print(f"Saving to {output_file}...")
    gdf_final.to_parquet(output_file)
    print("Done.")

if __name__ == "__main__":
    solve()

import geopandas as gpd

def check_output():
    output_file = "tokyo_stop_catchments.geoparquet"
    print(f"Attempting to read {output_file} with geopandas...")
    try:
        gdf = gpd.read_file(output_file)
        print("Successfully read with geopandas.")
        print("\n--- Shape ---")
        print(gdf.shape)
        print("\n--- Columns ---")
        print(gdf.columns.tolist())
        print("\n--- Geometry Types ---")
        print(gdf.geometry.type.value_counts())
        print("\n--- Preview ---")
        print(gdf[['connector_id', 'geometry']].head())
    except Exception as e:
        print(f"Failed to read with geopandas: {e}")

if __name__ == "__main__":
    check_output()

import pandas as pd
import geopandas as gpd

def check_output():
    output_file = "tokyo_stop_catchments.geoparquet"
    print(f"Attempting to read {output_file} with pandas/pyarrow...")
    try:
        df = pd.read_parquet(output_file)
        print("Successfully read with pandas/pyarrow.")
        print("\n--- Columns ---")
        print(df.columns.tolist())
        
        # Convert to GeoDataFrame
        # In GeoParquet, the geometry column is usually named 'geometry'
        gdf = gpd.GeoDataFrame(df, geometry='geometry')
        print("Converted to GeoDataFrame.")
        print("\n--- Shape ---")
        print(gdf.shape)
        print("\n--- Geometry Types ---")
        print(gdf.geometry.type.value_counts())
        print("\n--- Preview ---")
        print(gdf[['connector_id', 'geometry']].head())
    except Exception as e:
        print(f"Failed to read: {e}")

if __name__ == "__main__":
    check_output()

import geopandas as gpd
import pandas as pd

def solve():
    # Load the connectors
    input_file = "tokyo_connectors.geojson"
    output_file = "tokyo_stop_catchments.geoparquet"
    
    print(f"Reading {input_file}...")
    gdf = gpd.read_file(input_file)
    
    # Ensure we have connector_id
    if 'connector_id' not in gdf.columns:
        raise ValueError("Column 'connector_id' not found in input file.")

    # Reproject to a metric CRS
    print("Reprojecting to EPSG:3857 for buffering...")
    gdf_metric = gdf.to_crs(epsg=3857)
    
    # Buffer 400m
    print("Creating 400m buffers...")
    gdf_metric['geometry'] = gdf_metric.buffer(400)
    
    # Reproject back to WGS84
    print("Reprojecting back to original CRS...")
    gdf_final = gdf_metric.to_crs(gdf.crs)
    
    # Select only necessary columns
    gdf_final = gdf_final[['connector_id', 'geometry']]
    
    # Save to GeoParquet using the correct method for modern geopandas
    # geopandas' to_parquet handles the metadata for GeoParquet
    print(f"Saving to {output_file}...")
    gdf_final.to_parquet(output_file)
    print("Done.")

if __name__ == "__main__":
    solve()

import geopandas as gpd
import pandas as pd

def check_output():
    output_file = "tokyo_stop_catchments.geoparquet"
    print(f"Attempting to read {output_file} with geopandas...")
    try:
        # geopandas.read_file should handle GeoParquet if pyogrio or fiona is available
        gdf = gpd.read_file(output_file)
        print("Successfully read with geopandas.")
        print("\n--- Shape ---")
        print(gdf.shape)
        print("\n--- Columns ---")
        print(gdf.columns.tolist())
        print("\n--- Geometry Types ---")
        print(gdf.geometry.type.value_counts())
        print("\n--- Preview ---")
        print(gdf[['connector_id', 'geometry']].head())
    except Exception as e:
        print(f"Failed to read with geopandas: {e}")
        
        # Fallback to pandas + pyarrow + manual conversion
        print("\nTrying fallback: pandas + pyarrow + manual conversion...")
        try:
            df = pd.read_parquet(output_file)
            # Use shapely to convert the bytes/WKB to actual geometries if they are stored as such
            from shapely import wkb
            import numpy as np
            
            # The error previously showed bytes that look like WKB
            # Let's try to convert the geometry column
            if df['geometry'].dtype == object:
                 # If it's already objects, check if they are bytes
                 sample = df['geometry'].iloc[0]
                 if isinstance(sample, bytes):
                     print("Geometry column contains bytes. Converting...")
                     df['geometry'] = df['geometry'].apply(lambda x: wkb.loads(x) if isinstance(x, bytes) else x)
            
            gdf = gpd.GeoDataFrame(df, geometry='geometry', crs='EPSG:4326')
            print("Successfully converted via fallback.")
            print(gdf.head())
        except Exception as e2:
            print(f"Fallback also failed: {e2}")

if __name__ == "__main__":
    check_output()

import geopandas as gpd

def solve():
    # Load the connectors
    input_file = "tokyo_connectors.geojson"
    output_file = "tokyo_stop_catchments.geoparquet"
    
    print(f"Reading {input_file}...")
    gdf = gpd.read_file(input_file)
    
    # Ensure we have connector_id
    if 'connector_id' not in gdf.columns:
        raise ValueError("Column 'connector_id' not found in input file.")

    # Reproject to a metric CRS (using EPSG:3857 for buffering)
    print("Reprojecting to EPSG:3857 for buffering...")
    gdf_metric = gdf.to_crs(epsg=3857)
    
    # Create 400m buffer
    print("Creating 400m buffers...")
    gdf_metric['geometry'] = gdf_metric.buffer(400)
    
    # Reproject back to WGS84
    print("Reprojecting back to original CRS...")
    gdf_final = gdf_metric.to_crs(gdf.crs)
    
    # Select only necessary columns
    gdf_final = gdf_final[['connector_id', 'geometry']]
    
    # Save to GeoParquet using the recommended method
    print(f"Saving to {output_file}...")
    gdf_final.to_parquet(output_file)
    print("Done.")

if __name__ == "__main__":
    solve()

import geopandas as gpd
import pandas as pd

def check_output():
    output_file = "tokyo_stop_catchments.geoparquet"
    print(f"Attempting to read {output_file} with geopandas...")
    try:
        # Use the engine='pyogrio' if available, otherwise it uses fiona
        gdf = gpd.read_file(output_file)
        print("Successfully read with geopandas.")
        print("\n--- Shape ---")
        print(gdf.shape)
        print("\n--- Columns ---")
        print(gdf.columns.tolist())
        print("\n--- Geometry Types ---")
        print(gdf.geometry.type.value_counts())
        print("\n--- Preview ---")
        print(gdf[['connector_id', 'geometry']].head())
    except Exception as e:
        print(f"Failed to read with geopandas: {e}")

if __name__ == "__main__":
    check_output()

import geopandas as gpd
import pandas as pd
import pyarrow.parquet as pq

def solve():
    # Load the connectors
    input_file = "tokyo_connectors.geojson"
    output_file = "tokyo_stop_catchments.geoparquet"
    
    print(f"Reading {input_file}...")
    gdf = gpd.read_file(input_file)
    
    if 'connector_id' not in gdf.columns:
        raise ValueError("Column 'connector_id' not found in input file.")

    # Reproject to a metric CRS (using EPSG:3857 for buffering)
    print("Reprojecting to EPSG:3857 for buffering...")
    gdf_metric = gdf.to_crs(epsg=3857)
    
    # Create 400m buffer
    print("Creating 400m buffers...")
    gdf_metric['geometry'] = gdf_metric.buffer(400)
    
    # Reproject back to WGS84
    print("Reprojecting back to original CRS...")
    gdf_final = gdf_metric.to_crs(gdf.crs)
    
    # Select only necessary columns
    gdf_final = gdf_final[['connector_id', 'geometry']]
    
    # Save to GeoParquet
    # Note: geopandas.to_parquet uses pyarrow/fastparquet under the hood.
    # To ensure it's a valid GeoParquet with correct metadata, we use gdf.to_parquet.
    print(f"Saving to {output_file}...")
    gdf_final.to_parquet(output_file)
    print("Done.")

if __name__ == "__main__":
    solve()

import geopandas as gpd
import pandas as pd
import pyarrow.parquet as pq

def check_output():
    output_file = "tokyo_stop_catchments.geoparquet"
    
    print(f"--- Checking file exists ---")
    import os
    if not os.path.exists(output_file):
        print(f"ERROR: {output_file} does not exist.")
        return

    print(f"--- Reading with pandas ---")
    df = pd.read_parquet(output_file)
    print(f"Pandas read successful. Shape: {df.shape}")
    print(f"Columns: {df.columns.tolist()}")
    
    print(f"--- Checking geometry column type ---")
    print(f"Geometry column dtype: {df['geometry'].dtype}")
    
    # In some environments, GeoParquet might not be automatically 
    # recognized by gpd.read_file if the engine is old, but it should 
    # definitely be readable by pandas.
    
    # Try to see if we can reconstruct a GeoDataFrame correctly
    # If it's a standard GeoParquet, the geometry column should be WKB or similar
    try:
        from shapely import wkb
        # Check if it's bytes
        sample_geom = df['geometry'].iloc[0]
        print(f"Sample geometry type: {type(sample_geom)}")
        
        if isinstance(sample_geom, bytes):
            print("Geometry is bytes. Attempting to load as WKB...")
            gdf = gpd.GeoDataFrame(df, geometry=df['geometry'].apply(wkb.loads), crs="EPSG:4326")
            print("GeoDataFrame reconstruction successful.")
            print(gdf.head())
        else:
            # If it's already objects (which gpd.to_parquet should do)
            gdf = gpd.GeoDataFrame(df, geometry='geometry', crs="EPSG:4326")
            print("GeoDataFrame reconstruction (direct) successful.")
            print(gdf.head())
    except Exception as e:
        print(f"Reconstruction failed: {e}")

if __name__ == "__main__":
    check_output()