dd-l2-tokyo-overture-schools

Rerun

import geopandas as gpd
import pandas as pd
import json
from shapely.geometry import shape

def solve():
    # Load the bounding box (the 23 wards area)
    # It's a GeoJSON, so we can use geopandas
    wards_bbox = gpd.read_file('/work/tokyo_23wards_bbox.geojson')
    
    # Create a single geometry for the union of all wards if it's multiple features
    # Or just use the geometry itself if it's one large polygon/multipolygon
    wards_geom = wards_bbox.geometry.unary_union

    # Load the places parquet
    # The parquet seems to contain complex types as strings (JSON-like) or bytes
    # We'll load it with pandas first
    df = pd.read_parquet('/work/tokyo_places.parquet')

    # We need to filter for schools. 
    # Based on the preview: categories['primary'] == 'school' or 'education' in categories['alternate']
    # However, looking at the structure: 'categories': {'alternate': array([...]), 'primary': 'school'}
    # Since it's stored as a string in parquet (dtype='str'), we need to parse it.

    def is_school(categories_str):
        try:
            cats = json.loads(categories_str.replace("'", '"')) # Simple attempt to fix single quotes if it's a stringified dict
            # Wait, the preview shows it's a dict in the output, but the index says dtype='str'.
            # Let's check if it's actually a JSON string.
            # If it's a dict-like string:
            if isinstance(categories_str, str):
                # A more robust way to handle the string representation if it's not strict JSON
                import ast
                cats = ast.literal_eval(categories_str)
            else:
                cats = categories_str
                
            primary = cats.get('primary', '').lower()
            alternate = [a.lower() for a in cats.get('alternate', [])]
            
            return primary == 'school' or 'school' in alternate or primary == 'education' or 'education' in alternate
        except:
            return False

    # The preview showed 'categories' was a dict in the Python output but the index said dtype='str'.
    # This often happens with Parquet/Pandas when objects are stored.
    # Let's re-examine the structure.
    
    # Actually, let's iterate and find schools.
    # To be efficient, we'll parse only what we need.

    schools = []

    for _, row in df.iterrows():
        # Parse categories
        cats = row['categories']
        if isinstance(cats, str):
            import ast
            try:
                cats = ast.literal_eval(cats)
            except:
                continue
        
        primary = cats.get('primary', '')
        alternate = cats.get('alternate', [])
        if not isinstance(alternate, list):
            alternate = []
            
        if primary == 'school' or 'school' in alternate or primary == 'education' or 'education' in alternate:
            # Check geometry
            # The geometry in the preview was bytes: b'\x01\x01...'
            # This looks like WKB (Well-Known Binary)
            from shapely import wkb
            try:
                geom = wkb.loads(row['geometry'])
            except:
                # Try parsing as WKT or something else if WKB fails
                continue
            
            # Check if inside wards
            if wards_geom.contains(geom):
                # Parse names
                names = row['names']
                if isinstance(names, str):
                    import ast
                    names = ast.literal_eval(names)
                name_val = names.get('primary', '')

                # Parse addresses
                addresses = row['addresses']
                if isinstance(addresses, str):
                    import ast
                    addresses = ast.literal_eval(addresses)
                
                # The preview showed addresses as an array of dicts
                addr_freeform = ""
                addr_locality = ""
                addr_postcode = ""
                
                if isinstance(addresses, list) and len(addresses) > 0:
                    addr = addresses[0]
                    addr_freeform = addr.get('freeform', '')
                    addr_locality = addr.get('locality', '')
                    addr_postcode = addr.get('postcode', '')

                schools.append({
                    'id': row['id'],
                    'name': name_val,
                    'confidence': row['confidence'],
                    'address_freeform': addr_freeform,
                    'address_locality': addr_locality,
                    'address_postcode': addr_postcode,
                    'geometry': geom
                })

    if not schools:
        print("No schools found.")
        return

    # Create GeoDataFrame
    gdf = gpd.GeoDataFrame(schools, crs=wards_bbox.crs)
    
    # Ensure the column order/names are correct for the output
    # The requirement is: id, name, confidence, address_freeform, address_locality, and address_postcode
    # GeoJSON will include geometry automatically.
    
    output_cols = ['id', 'name', 'confidence', 'address_freeform', 'address_locality', 'address_postcode', 'geometry']
    gdf = gdf[output_cols]

    # Save to GeoJSON
    gdf.to_file('/work/tokyo_schools.geojson', driver='GeoJSON')
    print(f"Successfully saved {len(gdf)} schools to /work/tokyo_schools.geojson")

if __name__ == "__main__":
    solve()