data-update (#3)

- improved data refresh process and updated monumental statussus (aa4d0af14bdb7f392c58213cc3b5e17726f29868)
- update-analysis.ipynb without output cells (c251b378d987e3226e28965aafe9ab019bae213f)
- Fix dotenv dependency (84084e367c32533382ccdc22612dd8cdd4bfc4fb)


Co-authored-by: Ben Verhees <benverhees@users.noreply.huggingface.co>

.gitignore

@@ -7,4 +7,6 @@
 *.jsonl
 *.jsonl.gz
 *.jsonl.gz.part
-*.jsonl.gz.part.
+*.jsonl.gz.part.
+*.sqlite
+*.log

README.md

@@ -61,8 +61,8 @@ size_categories:
 
 For the stasuses of whether an addressable unit is a national monument (`is_rijksmonument`), we looked at two sources:
 
- - Cultural Heritage Agency
- - Het Kadaster
+- Cultural Heritage Agency
+- Het Kadaster
 
 **Please keep in mind that the Cultural Heritage Agency (_RCE_ in the dataset) is the official source for monumental statuses**. However, in our
 data analyses on the national monumental statuses of addressable units in Rotterdam, we concluded that:
@@ -77,6 +77,7 @@ Overall, for us, het Kadaster seemed more up to date than the Cultural Heritage
 ---
 
 ## Special thanks 
+
 to het Kadaster en the Cultural Heritage Agency for their APIs and datasets.
 
 --- 

monumenten.parquet

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:6e1d733285883c030e3aa8d7b4f7a6e3e6982a78a89e25cfbd1e6ba92619c4f5
-size 106947411
+oid sha256:a2b607e43b7e068dc57fb33e816aaac364f0daf8cf1fd0376a3d40f3ab71b966
+size 129082892

process_data.py

@@ -1,229 +0,0 @@
-import asyncio
-import glob
-import json
-import logging
-import multiprocessing
-import os
-import xml.etree.ElementTree as ET
-from datetime import datetime
-from typing import List, Optional, Set
-
-import pandas as pd
-from datasets import Dataset
-from dotenv import load_dotenv
-from monumenten import MonumentenClient
-
-load_dotenv()
-
-# Configure logging
-logging.basicConfig(level=logging.INFO)
-logger = logging.getLogger(__name__)
-
-# Define constants
-XML_DIRECTORY = "vbo_xmls/"
-INTERMEDIATE_CSV_PATH = "verblijfsobjecten_ids.csv"
-FINAL_CSV_PATH = "monumenten.csv"
-
-HF_REPO_ID = "woonstadrotterdam/monumenten"
-HF_TOKEN = os.getenv("HF_TOKEN")
-
-
-def is_valid_identificatie(id_value: str) -> bool:
-    """
-    Validate if the ID is a proper verblijfsobject ID.
-    Valid IDs must be 16 characters long, consist of digits,
-    and have '01' at positions 4-5 (0-indexed).
-    Example: 'xxxx01xxxxxxxxxx' where x is a digit (e.g., '0304010000269586').
-    """
-    if id_value is None:
-        return False
-    return len(id_value) == 16 and id_value.isdigit() and id_value[4:6] == "01"
-
-
-def extract_identificaties(xml_path: str) -> List[str]:
-    """
-    Extract all valid identificatie values from a single XML file using iterative parsing.
-    """
-    identificaties = []
-    try:
-        context = ET.iterparse(xml_path, events=("end",))
-        for event, elem in context:
-            if elem.tag.endswith("identificatie"):
-                id_value = elem.text
-                if is_valid_identificatie(id_value):
-                    identificaties.append(id_value)
-            elem.clear()  # Free memory
-
-        if identificaties:
-            logger.debug(
-                f"Found {len(identificaties)} valid identificatie values in {xml_path}"
-            )
-        return identificaties
-    except Exception as e:
-        logger.error(f"Error parsing XML file {xml_path}: {e}")
-        return []
-
-
-def get_xml_files() -> List[str]:
-    """
-    Get list of XML files from the specified directory.
-    """
-    xml_files = glob.glob(os.path.join(XML_DIRECTORY, "*.xml"))
-    if not xml_files:
-        logger.error(f"No XML files found in {XML_DIRECTORY}")
-    else:
-        logger.info(f"Found {len(xml_files)} XML files in {XML_DIRECTORY}")
-    return xml_files
-
-
-def process_files_parallel(xml_files: List[str]) -> Set[str]:
-    """
-    Process XML files in parallel using multiprocessing.
-    Returns a set of unique identificaties.
-    """
-    unique_identificaties = set()
-
-    logger.info(f"Starting parallel processing of {len(xml_files)} XML files...")
-    with multiprocessing.Pool() as pool:
-        results = pool.imap_unordered(extract_identificaties, xml_files)
-        for i, file_identificaties in enumerate(results):
-            unique_identificaties.update(file_identificaties)
-            if (i + 1) % 100 == 0:  # Log progress every 100 files
-                logger.info(
-                    f"Processed {i + 1}/{len(xml_files)} files. "
-                    f"Current unique identificaties: {len(unique_identificaties)}"
-                )
-
-    logger.info(
-        f"All files processed. Total unique identificaties found: {len(unique_identificaties)}"
-    )
-    return unique_identificaties
-
-
-def create_identificaties_dataframe(unique_ids: Set[str]) -> Optional[pd.DataFrame]:
-    """
-    Create and save DataFrame from unique identificaties.
-    Returns the DataFrame or None if no valid identificaties found.
-    """
-    if not unique_ids:
-        logger.info("No valid identificaties found.")
-        return None
-
-    df = pd.DataFrame(list(unique_ids), columns=["bag_verblijfsobject_id"])
-    logger.info(f"Created DataFrame with {len(df)} unique valid identificaties.")
-
-    # Save intermediate results
-    df.to_csv(INTERMEDIATE_CSV_PATH, index=False)
-    logger.info(f"Saved DataFrame to {INTERMEDIATE_CSV_PATH}")
-
-    # Display info
-    print("\nFirst few rows of the extracted identificaties DataFrame:")
-    print(df.head())
-    print("\nIdentificaties DataFrame Info:")
-    df.info()
-
-    return df
-
-
-async def process_with_monumenten_client(df: pd.DataFrame) -> Optional[pd.DataFrame]:
-    """
-    Process the DataFrame using MonumentenClient.
-    Returns processed DataFrame or None if processing fails.
-    """
-    if df.empty:
-        logger.warning("Empty DataFrame provided to MonumentenClient.")
-        return None
-
-    logger.info(f"Processing {len(df)} identificaties with MonumentenClient...")
-    try:
-        async with MonumentenClient() as client:
-            result_df = await client.process_from_df(
-                df=df, verblijfsobject_id_col="bag_verblijfsobject_id"
-            )
-        logger.info("Finished processing with MonumentenClient.")
-        return result_df
-    except Exception as e:
-        logger.error(f"Error processing with MonumentenClient: {e}")
-        return None
-
-
-def save_final_results(result_df: Optional[pd.DataFrame]) -> None:
-    """
-    Save the final results to CSV if valid data is present.
-    """
-    if result_df is not None and not result_df.empty:
-        result_df.to_csv(FINAL_CSV_PATH, index=False)
-        logger.info(f"Successfully saved final monumenten data to {FINAL_CSV_PATH}")
-        print(f"\nFinal data saved to {FINAL_CSV_PATH}")
-        print(result_df.head())
-        # Push to Hugging Face
-        if push_to_huggingface(result_df):
-            print(f"\nData successfully pushed to Hugging Face dataset: {HF_REPO_ID}")
-        else:
-            print("\nFailed to push data to Hugging Face. Check logs for details.")
-    elif result_df is not None and result_df.empty:
-        logger.info("Processing resulted in an empty DataFrame. Nothing to save.")
-        print("\nProcessing resulted in an empty DataFrame.")
-    else:
-        logger.warning("No valid data to save. Process did not complete successfully.")
-        print("\nProcess did not complete successfully or returned no data.")
-
-
-def push_to_huggingface(result_df: pd.DataFrame) -> bool:
-    """
-    Push the final results to Hugging Face datasets hub using datasets.push_to_hub
-    with a custom split name.
-    Returns True if successful, False otherwise.
-    """
-    if not HF_TOKEN:
-        logger.error("No Hugging Face token found in environment variables (HF_TOKEN)")
-        return False
-
-    if result_df.empty:
-        logger.warning(
-            "Result DataFrame is empty. Skipping push of main dataset to Hugging Face."
-        )
-    else:
-        logger.info(
-            f"Converting DataFrame with {len(result_df)} rows to Hugging Face Dataset."
-        )
-
-        hf_dataset_single = Dataset.from_pandas(result_df)
-
-        hf_dataset_single.push_to_hub(
-            repo_id=HF_REPO_ID,
-            commit_message=f"Update monumenten dataset",
-            token=HF_TOKEN,
-        )
-        logger.info(f"Successfully pushed dataset dictionary to {HF_REPO_ID}")
-
-
-async def main() -> Optional[pd.DataFrame]:
-    """
-    Main function orchestrating the entire process.
-    Returns the final processed DataFrame or None if processing fails.
-    """
-    # Get XML files
-    xml_files = get_xml_files()
-    if not xml_files:
-        return None
-
-    # Process files and get unique identificaties
-    unique_identificaties = process_files_parallel(xml_files)
-
-    # Create DataFrame from unique identificaties
-    df = create_identificaties_dataframe(unique_identificaties)
-    if df is None:
-        return None
-
-    # Process with MonumentenClient
-    result_df = await process_with_monumenten_client(df)
-    return result_df
-
-
-if __name__ == "__main__":
-    # Run main process
-    result_dataframe = asyncio.run(main())
-
-    # Save results
-    save_final_results(result_dataframe)

requirements.txt

@@ -1,4 +1,7 @@
-huggingface-hub
-dotenv
-monumenten==0.3.1
-datasets
+huggingface-hub>=0.31
+python-dotenv>=1
+monumenten==1.1.0
+datasets>=3
+requests>=2
+tqdm>=4
+pandas>=2

run_pipeline.py

@@ -0,0 +1,935 @@
+#!/usr/bin/env python3
+"""
+Combined pipeline: process XML + MonumentenClient -> monumenten.csv,
+then add postcodes via Kadaster -> CSV -> Parquet, with optional Hugging Face push.
+"""
+
+import argparse
+import asyncio
+import glob
+import json
+import logging
+import multiprocessing
+import os
+import signal
+import sqlite3
+import sys
+import threading
+import time
+import xml.etree.ElementTree as ET
+from concurrent.futures import ThreadPoolExecutor, as_completed
+from datetime import datetime
+from logging.handlers import RotatingFileHandler
+from pathlib import Path
+from typing import Dict, Iterable, List, Optional, Sequence, Set, Tuple
+
+import pandas as pd
+import requests
+from datasets import Dataset
+from dotenv import load_dotenv
+from huggingface_hub import HfApi
+from tqdm import tqdm
+
+load_dotenv()
+
+# --------------------- Unified configuration ---------------------
+
+# Paths (stage 1 output = stage 2 input)
+XML_DIRECTORY = "vbo_xmls/"
+INTERMEDIATE_CSV_PATH = "verblijfsobjecten_ids.csv"
+MONUMENTEN_CSV = "monumenten.csv"
+OUTPUT_CSV = "monumenten_with_postcodes.csv"
+OUTPUT_PARQUET = "monumenten.parquet"
+ID_COL = "bag_verblijfsobject_id"
+
+# Postcode stage (Kadaster)
+KADASTER_ENDPOINT = "https://data.kkg.kadaster.nl/service/sparql"
+BATCH_SIZE = 1000
+MAX_RETRIES = 5
+RETRY_DELAY = 10
+MAX_WORKERS = 6
+CHUNK_SIZE = 10000
+CHECKPOINT_INTERVAL = 10
+SQLITE_DB = "postcode_cache.sqlite"
+CHECKPOINT_FILE = "postcode_update_checkpoint.json"
+RESET_CACHE = False
+
+# Hugging Face
+HF_REPO_ID = "woonstadrotterdam/monumenten"
+HF_TOKEN = os.getenv("HF_TOKEN")
+
+# Global flag for graceful shutdown
+shutdown_requested = False
+
+# --------------------- Logging ---------------------
+
+logging.basicConfig(
+    level=logging.INFO,
+    format="%(asctime)s %(levelname)s:%(name)s:%(message)s",
+    handlers=[logging.StreamHandler(sys.stdout)],
+)
+logger = logging.getLogger(__name__)
+try:
+    _fh = RotatingFileHandler(
+        "monumenten.log", maxBytes=5 * 1024 * 1024, backupCount=3
+    )
+    _fh.setLevel(logging.INFO)
+    _fh.setFormatter(logging.Formatter("%(asctime)s %(levelname)s:%(name)s:%(message)s"))
+    logger.addHandler(_fh)
+except Exception as _e:
+    logger.debug(f"Could not attach file logger: {_e}")
+
+# Thread-local storage for requests session
+thread_local = threading.local()
+
+
+def signal_handler(signum, frame):
+    global shutdown_requested
+    logger.info(f"Received signal {signum}. Starting graceful shutdown...")
+    shutdown_requested = True
+
+
+# ===================== Stage 2: Postcode (Kadaster + SQLite) =====================
+
+def get_session() -> requests.Session:
+    if not hasattr(thread_local, "session"):
+        sess = requests.Session()
+        sess.headers.update({
+            "User-Agent": "Monumenten-Postcode-Updater/1.0",
+            "Accept": "application/sparql-results+json",
+            "Content-Type": "application/x-www-form-urlencoded",
+        })
+        adapter = requests.adapters.HTTPAdapter(
+            pool_connections=1, pool_maxsize=1, max_retries=0
+        )
+        sess.mount("http://", adapter)
+        sess.mount("https://", adapter)
+        thread_local.session = sess
+    return thread_local.session
+
+
+def ensure_columns(conn: sqlite3.Connection, table: str, columns: Dict[str, str]):
+    cur = conn.execute(f"PRAGMA table_info({table});")
+    existing = {row[1] for row in cur.fetchall()}
+    for col, col_type in columns.items():
+        if col not in existing:
+            conn.execute(f"ALTER TABLE {table} ADD COLUMN {col} {col_type};")
+    conn.commit()
+
+
+def init_db(db_path: str) -> sqlite3.Connection:
+    conn = sqlite3.connect(db_path)
+    conn.execute("PRAGMA journal_mode=WAL;")
+    conn.execute("PRAGMA synchronous=OFF;")
+    conn.execute("PRAGMA temp_store=MEMORY;")
+    conn.execute(
+        """
+        CREATE TABLE IF NOT EXISTS addresses (
+            identificatie TEXT PRIMARY KEY,
+            postcode TEXT,
+            huisnummer TEXT,
+            straatnaam TEXT,
+            plaatsnaam TEXT
+        )
+        """
+    )
+    ensure_columns(
+        conn,
+        "addresses",
+        {
+            "identificatie": "TEXT",
+            "postcode": "TEXT",
+            "huisnummer": "TEXT",
+            "straatnaam": "TEXT",
+            "plaatsnaam": "TEXT",
+        },
+    )
+    conn.execute("CREATE INDEX IF NOT EXISTS idx_ident ON addresses(identificatie);")
+    conn.commit()
+    return conn
+
+
+def upsert_results(conn: sqlite3.Connection, results: List[Dict]) -> None:
+    if not results:
+        return
+    with conn:
+        conn.executemany(
+            "INSERT OR REPLACE INTO addresses (identificatie, postcode, huisnummer, straatnaam, plaatsnaam) VALUES (?, ?, ?, ?, ?)",
+            [
+                (
+                    r.get("identificatie", ""),
+                    r.get("postcode", ""),
+                    r.get("huisnummer_volledig", ""),
+                    r.get("straatnaam", ""),
+                    r.get("plaatsnaam", ""),
+                )
+                for r in results
+            ],
+        )
+
+
+def fetch_mapping_for_ids(
+    conn: sqlite3.Connection, ids: Sequence[str]
+) -> Dict[str, Tuple[str, str, str, str]]:
+    if not ids:
+        return {}
+    mapping: Dict[str, Tuple[str, str, str, str]] = {}
+    step = 500
+    for i in range(0, len(ids), step):
+        batch = ids[i : i + step]
+        placeholders = ",".join(["?"] * len(batch))
+        rows = conn.execute(
+            f"SELECT identificatie, straatnaam, huisnummer, postcode, plaatsnaam FROM addresses WHERE identificatie IN ({placeholders})",
+            list(batch),
+        ).fetchall()
+        for ident, straat, huisnr, postc, plaats in rows:
+            mapping[ident] = (
+                straat or "",
+                huisnr or "",
+                postc or "",
+                plaats or "",
+            )
+    return mapping
+
+
+def build_query(ids: List[str]) -> str:
+    iri_values = "\n    ".join(
+        f"<https://bag.basisregistraties.overheid.nl/id/verblijfsobject/{vid}>"
+        for vid in ids
+    )
+    return f"""
+PREFIX prov: <http://www.w3.org/ns/prov#>
+PREFIX imx:  <http://modellen.geostandaarden.nl/def/imx-geo#>
+
+SELECT DISTINCT
+  ?identificatie
+  ?postcode
+  ?huisnummer_volledig
+  ?straatnaam
+  ?plaatsnaam
+WHERE {{
+  VALUES ?verblijfsobjectIri {{
+    {iri_values}
+  }}
+
+  ?adres prov:wasDerivedFrom ?verblijfsobjectIri ;
+         imx:isHoofdadres true .
+
+  OPTIONAL {{ ?adres imx:postcode ?postcode . }}
+  OPTIONAL {{ ?adres imx:huisnummer ?huisnummer . }}
+  OPTIONAL {{ ?adres imx:huisletter ?huisletter . }}
+  OPTIONAL {{ ?adres imx:huisnummertoevoeging ?huisnummertoevoeging . }}
+  OPTIONAL {{ ?adres imx:straatnaam ?straatnaam . }}
+  OPTIONAL {{ ?adres imx:plaatsnaam ?plaatsnaam . }}
+
+  BIND(STRAFTER(STR(?verblijfsobjectIri), "https://bag.basisregistraties.overheid.nl/id/verblijfsobject/") AS ?identificatie)
+  BIND(CONCAT(
+        STR(?huisnummer),
+        IF(BOUND(?huisletter), ?huisletter, ""),
+        IF(BOUND(?huisnummertoevoeging), CONCAT("-", ?huisnummertoevoeging), "")
+      ) AS ?huisnummer_volledig)
+}}
+ORDER BY ?identificatie
+""".strip()
+
+
+def query_kadaster(ids: List[str]) -> List[Dict]:
+    session = get_session()
+    for attempt in range(MAX_RETRIES):
+        try:
+            if shutdown_requested:
+                return []
+            form = {"query": build_query(ids), "format": "json"}
+            resp = session.post(KADASTER_ENDPOINT, data=form, timeout=(30, 90))
+            if resp.status_code in (429, 500, 502, 503, 504):
+                retry_after = resp.headers.get("Retry-After")
+                wait_seconds = (
+                    int(retry_after)
+                    if (retry_after and retry_after.isdigit())
+                    else (RETRY_DELAY * (2 ** attempt))
+                )
+                logger.warning(
+                    f"{resp.status_code} for batch {ids[:3]}..., waiting {wait_seconds}s"
+                )
+                time.sleep(wait_seconds)
+                continue
+            resp.raise_for_status()
+            data = resp.json()
+            out: List[Dict] = []
+            for b in data.get("results", {}).get("bindings", []):
+                out.append({
+                    "identificatie": b.get("identificatie", {}).get("value", ""),
+                    "postcode": b.get("postcode", {}).get("value", ""),
+                    "huisnummer_volledig": b.get("huisnummer_volledig", {}).get(
+                        "value", ""
+                    ),
+                    "straatnaam": b.get("straatnaam", {}).get("value", ""),
+                    "plaatsnaam": b.get("plaatsnaam", {}).get("value", ""),
+                })
+            return out
+        except requests.exceptions.RequestException as e:
+            if attempt < MAX_RETRIES - 1:
+                delay = RETRY_DELAY * (2 ** attempt)
+                logger.warning(
+                    f"Request error (attempt {attempt+1}/{MAX_RETRIES}) {e}; sleeping {delay}s"
+                )
+                time.sleep(delay)
+                continue
+            logger.error(f"All attempts failed for batch {ids[:3]}...")
+            return []
+        except Exception as e:
+            logger.error(f"Unexpected error for batch {ids[:3]}...: {e}")
+            return []
+    return []
+
+
+def load_checkpoint(path: str) -> Dict:
+    if Path(path).exists():
+        try:
+            obj = json.load(open(path, "r"))
+            completed = set(obj.get("completed_batches", []))
+            return {"completed_batches": completed}
+        except Exception as e:
+            logger.warning(f"Failed to load checkpoint: {e}")
+    return {"completed_batches": set()}
+
+
+def save_checkpoint(path: str, completed_batches: Iterable[int]):
+    data = {"completed_batches": sorted(int(i) for i in set(completed_batches))}
+    with open(path, "w") as f:
+        json.dump(data, f, indent=2)
+    logger.info(f"Checkpoint saved: {len(data['completed_batches'])} batches completed")
+
+
+def prefetch_to_sqlite(conn: sqlite3.Connection, all_ids: List[str]):
+    logger.info("Prefetching address data into SQLite cache...")
+    batches = [
+        (i // BATCH_SIZE, all_ids[i : i + BATCH_SIZE])
+        for i in range(0, len(all_ids), BATCH_SIZE)
+    ]
+    ckpt = load_checkpoint(CHECKPOINT_FILE)
+    completed = ckpt["completed_batches"]
+
+    with tqdm(total=len(batches), desc="Prefetch batches") as pbar:
+        with ThreadPoolExecutor(max_workers=MAX_WORKERS) as executor:
+            futures = {}
+            for (idx, ids) in batches:
+                if idx in completed:
+                    placeholders = ",".join(["?"] * min(10, len(ids)))
+                    sample_ids = ids[:10]
+                    rows = conn.execute(
+                        f"SELECT COUNT(1) FROM addresses WHERE identificatie IN ({placeholders})",
+                        list(sample_ids),
+                    ).fetchone()
+                    if rows and int(rows[0]) == len(sample_ids):
+                        pbar.update(1)
+                        continue
+                futures[executor.submit(query_kadaster, ids)] = idx
+
+            processed_since_save = 0
+            for fut in as_completed(futures):
+                if shutdown_requested:
+                    break
+                idx = futures[fut]
+                try:
+                    results = fut.result()
+                except Exception as e:
+                    logger.warning(f"Batch {idx} raised: {e}")
+                    results = []
+                upsert_results(conn, results)
+                completed.add(idx)
+                processed_since_save += 1
+                pbar.update(1)
+                if processed_since_save >= CHECKPOINT_INTERVAL:
+                    save_checkpoint(CHECKPOINT_FILE, completed)
+                    processed_since_save = 0
+
+    save_checkpoint(CHECKPOINT_FILE, completed)
+    logger.info("Prefetch stage completed (or interrupted).")
+
+
+def update_csv_from_db(
+    conn: sqlite3.Connection, input_file: str, output_file: str
+):
+    logger.info("Updating CSV using SQLite cache...")
+    first_chunk = True
+    for chunk_idx, chunk in enumerate(
+        pd.read_csv(input_file, chunksize=CHUNK_SIZE, dtype={"bag_verblijfsobject_id": "str"})
+    ):
+        logger.info(f"Processing chunk {chunk_idx + 1}")
+        for col in ["straatnaam", "huisnummer", "postcode", "plaatsnaam"]:
+            if col not in chunk.columns:
+                chunk[col] = ""
+        if "bag_verblijfsobject_id" not in chunk.columns:
+            continue
+        ids = chunk["bag_verblijfsobject_id"].fillna("").astype(str).tolist()
+        mapping = fetch_mapping_for_ids(conn, ids)
+        if mapping:
+            map_df = pd.DataFrame.from_dict(
+                mapping,
+                orient="index",
+                columns=["straatnaam_new", "huisnummer_new", "postcode_new", "plaatsnaam_new"],
+            )
+            map_df.index.name = "bag_verblijfsobject_id"
+            map_df = map_df.reset_index()
+            chunk = chunk.merge(map_df, on="bag_verblijfsobject_id", how="left")
+            for src, dst in [
+                ("straatnaam_new", "straatnaam"),
+                ("huisnummer_new", "huisnummer"),
+                ("postcode_new", "postcode"),
+                ("plaatsnaam_new", "plaatsnaam"),
+            ]:
+                mask = (chunk[dst].isna()) | (chunk[dst] == "")
+                chunk.loc[mask, dst] = chunk.loc[mask, src].fillna("")
+            chunk.drop(
+                columns=["straatnaam_new", "huisnummer_new", "postcode_new", "plaatsnaam_new"],
+                inplace=True,
+            )
+        if first_chunk:
+            chunk.to_csv(output_file, index=False, mode="w")
+            first_chunk = False
+        else:
+            chunk.to_csv(output_file, index=False, mode="a", header=False)
+    logger.info(f"CSV update completed. Output saved to {output_file}")
+
+
+def add_postcode_main(reset_cache: bool = False) -> bool:
+    """Run postcode stage: MONUMENTEN_CSV -> Kadaster + SQLite -> OUTPUT_CSV. Returns True on success."""
+    signal.signal(signal.SIGINT, signal_handler)
+    signal.signal(signal.SIGTERM, signal_handler)
+
+    if not Path(MONUMENTEN_CSV).exists():
+        logger.error(f"Input file {MONUMENTEN_CSV} not found")
+        return False
+
+    if reset_cache:
+        try:
+            if Path(SQLITE_DB).exists():
+                Path(SQLITE_DB).unlink()
+                logger.info("Removed existing SQLite cache for full refresh")
+            if Path(CHECKPOINT_FILE).exists():
+                Path(CHECKPOINT_FILE).unlink()
+                logger.info("Removed existing checkpoint for full refresh")
+        except Exception as e:
+            logger.warning(f"Failed to reset cache/checkpoint: {e}")
+
+    conn = init_db(SQLITE_DB)
+
+    total_rows = 0
+    unique_ids = set()
+    logger.info("Counting total rows and collecting IDs...")
+    for chunk in pd.read_csv(
+        MONUMENTEN_CSV, chunksize=CHUNK_SIZE, dtype={"bag_verblijfsobject_id": "str"}
+    ):
+        total_rows += len(chunk)
+        if "bag_verblijfsobject_id" in chunk.columns:
+            unique_ids.update(chunk["bag_verblijfsobject_id"].dropna().unique())
+    logger.info(f"Total rows: {total_rows:,}")
+    logger.info(f"Unique IDs to process: {len(unique_ids):,}")
+
+    id_list = list(unique_ids)
+    prefetch_to_sqlite(conn, id_list)
+
+    if shutdown_requested:
+        logger.info("Shutdown requested. Exiting before CSV update.")
+        return False
+
+    update_csv_from_db(conn, MONUMENTEN_CSV, OUTPUT_CSV)
+    logger.info("Postcode stage done.")
+    return True
+
+
+# ===================== Parquet and HF push =====================
+
+def csv_to_parquet(csv_path: str, parquet_path: str) -> bool:
+    """Stream CSV to Parquet in chunks to avoid loading 10M+ rows into memory."""
+    try:
+        import pyarrow as pa
+        import pyarrow.parquet as pq
+    except ImportError:
+        logger.error("pyarrow is required for Parquet output. pip install pyarrow")
+        return False
+
+    if not Path(csv_path).exists():
+        logger.error(f"CSV file not found: {csv_path}")
+        return False
+
+    logger.info(f"Writing Parquet from {csv_path} to {parquet_path} (streaming)...")
+    schema = None
+    writer = None
+    try:
+        for chunk_idx, chunk in enumerate(
+            pd.read_csv(
+                csv_path,
+                chunksize=CHUNK_SIZE,
+                dtype={"bag_verblijfsobject_id": str},
+            )
+        ):
+            table = pa.Table.from_pandas(chunk, preserve_index=False)
+            if schema is None:
+                schema = table.schema
+                writer = pq.ParquetWriter(parquet_path, schema)
+            writer.write_table(table)
+            if (chunk_idx + 1) % 100 == 0:
+                logger.info(f"Parquet: wrote {(chunk_idx + 1) * CHUNK_SIZE:,} rows")
+        if writer:
+            writer.close()
+        logger.info(f"Parquet saved to {parquet_path}")
+        return True
+    except Exception as e:
+        logger.error(f"Error writing Parquet: {e}")
+        if writer:
+            try:
+                writer.close()
+            except Exception:
+                pass
+        return False
+
+
+def push_to_huggingface(result_df: pd.DataFrame) -> bool:
+    """Push to HF: sort by postcode, huisnummer; Dataset.from_pandas -> push_to_hub; create date tag."""
+    if not HF_TOKEN:
+        logger.error("No Hugging Face token (HF_TOKEN)")
+        return False
+    if result_df.empty:
+        logger.warning("Result DataFrame is empty. Skipping push.")
+        return False
+    try:
+        logger.info(f"Converting {len(result_df):,} rows to Hugging Face Dataset.")
+        hf_dataset = Dataset.from_pandas(result_df)
+        hf_dataset.push_to_hub(
+            repo_id=HF_REPO_ID,
+            commit_message=f"Update monumenten dataset ({len(result_df):,} rows)",
+            token=HF_TOKEN,
+        )
+        logger.info(f"Successfully pushed to {HF_REPO_ID}")
+        current_date_tag = datetime.now().strftime("%Y-%m-%d")
+        try:
+            api = HfApi(token=HF_TOKEN)
+            api.create_tag(
+                repo_id=HF_REPO_ID,
+                repo_type="dataset",
+                tag=current_date_tag,
+            )
+            logger.info(f"Created tag '{current_date_tag}'")
+        except Exception as e:
+            logger.warning(f"Could not create tag '{current_date_tag}': {e}")
+        return True
+    except Exception as e:
+        logger.error(f"Error pushing to Hugging Face: {e}")
+        return False
+
+
+# ===================== Stage 1: Process (XML + MonumentenClient) =====================
+
+def is_valid_identificatie(id_value: str) -> bool:
+    if id_value is None:
+        return False
+    return (
+        len(id_value) == 16
+        and id_value.isdigit()
+        and id_value[4:6] in ["01", "02", "03"]
+    )
+
+
+def extract_identificaties(xml_path: str) -> List[str]:
+    identificaties = []
+    try:
+        context = ET.iterparse(xml_path, events=("end",))
+        for event, elem in context:
+            if elem.tag.endswith("identificatie"):
+                id_value = elem.text
+                if is_valid_identificatie(id_value):
+                    identificaties.append(id_value)
+            elem.clear()
+        return identificaties
+    except Exception as e:
+        logger.error(f"Error parsing XML file {xml_path}: {e}")
+        return []
+
+
+def get_xml_files() -> List[str]:
+    xml_files = glob.glob(os.path.join(XML_DIRECTORY, "*.xml"))
+    if not xml_files:
+        logger.error(f"No XML files found in {XML_DIRECTORY}")
+    else:
+        logger.info(f"Found {len(xml_files)} XML files in {XML_DIRECTORY}")
+    return xml_files
+
+
+def process_files_parallel(xml_files: List[str]) -> Set[str]:
+    unique_identificaties = set()
+    logger.info(f"Starting parallel processing of {len(xml_files)} XML files...")
+    with multiprocessing.Pool() as pool:
+        results = pool.imap_unordered(extract_identificaties, xml_files)
+        for i, file_identificaties in enumerate(results):
+            unique_identificaties.update(file_identificaties)
+            if (i + 1) % 100 == 0:
+                logger.info(
+                    f"Processed {i + 1}/{len(xml_files)} files. Unique: {len(unique_identificaties)}"
+                )
+    logger.info(f"Total unique identificaties: {len(unique_identificaties)}")
+    return unique_identificaties
+
+
+def create_identificaties_dataframe(unique_ids: Set[str]) -> Optional[pd.DataFrame]:
+    if not unique_ids:
+        logger.info("No valid identificaties found.")
+        return None
+    df = pd.DataFrame(list(unique_ids), columns=["bag_verblijfsobject_id"])
+    logger.info(f"Created DataFrame with {len(df)} unique valid identificaties.")
+    df.to_csv(INTERMEDIATE_CSV_PATH, index=False)
+    logger.info(f"Saved to {INTERMEDIATE_CSV_PATH}")
+    return df
+
+
+def get_processed_ids_set() -> Set[str]:
+    if not os.path.exists(MONUMENTEN_CSV):
+        return set()
+    try:
+        processed_df = pd.read_csv(
+            MONUMENTEN_CSV, dtype={"bag_verblijfsobject_id": str}
+        )
+        processed_ids = set(processed_df["bag_verblijfsobject_id"].unique())
+        logger.info(f"Loaded {len(processed_ids)} processed IDs from {MONUMENTEN_CSV}")
+        return processed_ids
+    except Exception as e:
+        logger.warning(f"Could not load from {MONUMENTEN_CSV}: {e}")
+        return set()
+
+
+def get_unprocessed_ids_df() -> Optional[pd.DataFrame]:
+    if not os.path.exists(INTERMEDIATE_CSV_PATH):
+        logger.warning(f"Source IDs file not found: {INTERMEDIATE_CSV_PATH}")
+        return None
+    source_df = pd.read_csv(
+        INTERMEDIATE_CSV_PATH, dtype={"bag_verblijfsobject_id": str}
+    )
+    if "bag_verblijfsobject_id" not in source_df.columns:
+        logger.error("Source file missing column 'bag_verblijfsobject_id'")
+        return None
+    source_ids = set(source_df["bag_verblijfsobject_id"].unique())
+    logger.info(f"Source IDs: {len(source_ids)}")
+    processed_ids = get_processed_ids_set()
+    if not processed_ids:
+        return source_df
+    unprocessed_ids = source_ids - processed_ids
+    logger.info(f"Unprocessed: {len(unprocessed_ids)}")
+    if not unprocessed_ids:
+        logger.info("All IDs have been processed!")
+        return None
+    unprocessed_df = pd.DataFrame(
+        list(unprocessed_ids), columns=["bag_verblijfsobject_id"]
+    )
+    unprocessed_df.to_csv("unprocessed_ids.csv", index=False)
+    logger.info("Saved unprocessed IDs to unprocessed_ids.csv")
+    return unprocessed_df
+
+
+def load_existing_progress() -> Optional[pd.DataFrame]:
+    if os.path.exists(MONUMENTEN_CSV):
+        try:
+            existing_df = pd.read_csv(
+                MONUMENTEN_CSV, dtype={"bag_verblijfsobject_id": str}
+            )
+            if not existing_df.empty:
+                logger.info(
+                    f"Loaded existing progress from {MONUMENTEN_CSV}: {len(existing_df)} rows"
+                )
+                return existing_df
+        except Exception as e:
+            logger.warning(f"Could not load from {MONUMENTEN_CSV}: {e}")
+    return None
+
+
+async def process_with_monumenten_client_resume(
+    df: pd.DataFrame,
+) -> Optional[pd.DataFrame]:
+    if df.empty:
+        logger.warning("Empty DataFrame provided to MonumentenClient.")
+        return None
+
+    from monumenten import MonumentenClient
+
+    total_rows = len(df)
+    if total_rows >= 10_000:
+        batch_size = max(1, total_rows // 100)
+        num_batches = 100
+    else:
+        batch_size = max(1, total_rows // 10)
+        num_batches = 10
+    logger.info(
+        f"Processing {total_rows} unprocessed in {num_batches} batches of ~{batch_size}"
+    )
+
+    existing_results = load_existing_progress()
+    processed_df = existing_results if existing_results is not None else pd.DataFrame()
+
+    try:
+        async with MonumentenClient() as client:
+            for batch_num in range(num_batches):
+                start_idx = batch_num * batch_size
+                end_idx = min(start_idx + batch_size, total_rows)
+                if start_idx >= total_rows:
+                    break
+                current_batch = df.iloc[start_idx:end_idx].copy()
+                logger.info(
+                    f"Batch {batch_num + 1}/{num_batches}: rows {start_idx + 1}-{end_idx}"
+                )
+                try:
+                    start_time = time.time()
+                    batch_result = await client.process_from_df(
+                        df=current_batch,
+                        verblijfsobject_id_col="bag_verblijfsobject_id",
+                    )
+                    if batch_result is not None and not batch_result.empty:
+                        allowed_ids = set(
+                            current_batch["bag_verblijfsobject_id"].astype(str).unique()
+                        )
+                        out_of_batch_mask = (
+                            ~batch_result["bag_verblijfsobject_id"]
+                            .astype(str)
+                            .isin(allowed_ids)
+                        )
+                        if out_of_batch_mask.any():
+                            batch_result = batch_result.loc[~out_of_batch_mask].copy()
+                        if batch_result.empty:
+                            continue
+                        processed_df = pd.concat(
+                            [processed_df, batch_result], ignore_index=True
+                        )
+                        processed_df = processed_df.drop_duplicates(
+                            subset=["bag_verblijfsobject_id"], keep="first"
+                        )
+                        processed_df["bag_verblijfsobject_id"] = processed_df[
+                            "bag_verblijfsobject_id"
+                        ].astype(str)
+                        processed_df.to_csv(MONUMENTEN_CSV, index=False)
+                        logger.info(
+                            f"Batch {batch_num + 1} done. Total rows: {len(processed_df)}"
+                        )
+                except Exception as e:
+                    logger.error(f"Error processing batch {batch_num + 1}: {e}")
+                    if not processed_df.empty:
+                        processed_df = processed_df.drop_duplicates(
+                            subset=["bag_verblijfsobject_id"], keep="first"
+                        )
+                        processed_df.to_csv(MONUMENTEN_CSV, index=False)
+                    continue
+
+        processed_df = processed_df.drop_duplicates(
+            subset=["bag_verblijfsobject_id"], keep="first"
+        )
+        logger.info(f"Final dataset: {len(processed_df)} unique IDs")
+        return processed_df
+    except Exception as e:
+        logger.error(f"Error with MonumentenClient: {e}")
+        if not processed_df.empty:
+            processed_df = processed_df.drop_duplicates(
+                subset=["bag_verblijfsobject_id"], keep="first"
+            )
+            processed_df.to_csv(MONUMENTEN_CSV, index=False)
+        return processed_df if not processed_df.empty else None
+
+
+def save_final_results(result_df: Optional[pd.DataFrame]) -> None:
+    """Save stage 1 results to MONUMENTEN_CSV (no HF push; that's in pipeline)."""
+    if result_df is not None and not result_df.empty:
+        result_df = result_df.drop_duplicates(
+            subset=["bag_verblijfsobject_id"], keep="first"
+        )
+        result_df["bag_verblijfsobject_id"] = result_df["bag_verblijfsobject_id"].astype(
+            str
+        )
+        result_df.to_csv(MONUMENTEN_CSV, index=False)
+        logger.info(f"Saved final monumenten data to {MONUMENTEN_CSV}")
+    elif result_df is not None and result_df.empty:
+        logger.info("Processing resulted in empty DataFrame.")
+    else:
+        logger.warning("No valid data to save.")
+
+
+def cleanup_existing_duplicates() -> None:
+    if not os.path.exists(MONUMENTEN_CSV):
+        return
+    try:
+        df = pd.read_csv(MONUMENTEN_CSV, dtype={"bag_verblijfsobject_id": str})
+        original_count = len(df)
+        df_clean = df.drop_duplicates(
+            subset=["bag_verblijfsobject_id"], keep="first"
+        )
+        if len(df_clean) < original_count:
+            df_clean.to_csv(MONUMENTEN_CSV, index=False)
+            logger.info(f"Removed {original_count - len(df_clean)} duplicates")
+    except Exception as e:
+        logger.error(f"Error cleaning duplicates: {e}")
+
+
+def remove_ids_not_in_source() -> None:
+    if not os.path.exists(MONUMENTEN_CSV) or not os.path.exists(INTERMEDIATE_CSV_PATH):
+        return
+    try:
+        results_df = pd.read_csv(
+            MONUMENTEN_CSV, dtype={"bag_verblijfsobject_id": str}
+        )
+        source_df = pd.read_csv(
+            INTERMEDIATE_CSV_PATH, dtype={"bag_verblijfsobject_id": str}
+        )
+        source_ids = set(source_df["bag_verblijfsobject_id"].unique())
+        in_source_mask = results_df["bag_verblijfsobject_id"].isin(source_ids)
+        results_df_filtered = results_df[in_source_mask].copy()
+        if len(results_df_filtered) < len(results_df):
+            results_df_filtered.to_csv(MONUMENTEN_CSV, index=False)
+            logger.info(
+                f"Removed {len(results_df) - len(results_df_filtered)} rows not in source"
+            )
+    except Exception as e:
+        logger.error(f"Error filtering non-source IDs: {e}")
+
+
+def verify_data_integrity() -> None:
+    if not os.path.exists(MONUMENTEN_CSV):
+        return
+    try:
+        df = pd.read_csv(MONUMENTEN_CSV, dtype={"bag_verblijfsobject_id": str})
+        total_rows = len(df)
+        unique_ids = df["bag_verblijfsobject_id"].nunique()
+        logger.info(f"Data integrity: total={total_rows}, unique={unique_ids}")
+    except Exception as e:
+        logger.error(f"Error verifying: {e}")
+
+
+async def process_main() -> Optional[pd.DataFrame]:
+    remove_ids_not_in_source()
+    cleanup_existing_duplicates()
+    verify_data_integrity()
+
+    if os.path.exists(INTERMEDIATE_CSV_PATH):
+        logger.info(f"Found {INTERMEDIATE_CSV_PATH}, using resume logic...")
+        try:
+            unprocessed_df = get_unprocessed_ids_df()
+            if unprocessed_df is None:
+                logger.info("All IDs processed.")
+                return load_existing_progress()
+            logger.info(f"Found {len(unprocessed_df)} IDs to process")
+            return await process_with_monumenten_client_resume(unprocessed_df)
+        except Exception as e:
+            logger.error(f"Resume error: {e}")
+
+    xml_files = get_xml_files()
+    if not xml_files:
+        return None
+    unique_identificaties = process_files_parallel(xml_files)
+    df = create_identificaties_dataframe(unique_identificaties)
+    if df is None:
+        return None
+    return await process_with_monumenten_client_resume(df)
+
+
+async def process_until_complete() -> Optional[pd.DataFrame]:
+    attempt = 1
+    max_attempts = 100
+    while attempt <= max_attempts:
+        logger.info(f"=== Attempt {attempt}/{max_attempts} ===")
+        try:
+            result_df = await process_main()
+            if result_df is not None and not result_df.empty:
+                unprocessed_df = get_unprocessed_ids_df()
+                if unprocessed_df is None:
+                    logger.info("All IDs processed successfully.")
+                    return result_df
+                logger.info(f"Incomplete: {len(unprocessed_df)} IDs remain. Restarting...")
+                await asyncio.sleep(5)
+                attempt += 1
+                continue
+            attempt += 1
+        except KeyboardInterrupt:
+            logger.info("Interrupted. Saving progress...")
+            if "result_df" in locals() and result_df is not None and not result_df.empty:
+                save_final_results(result_df)
+            return result_df if "result_df" in locals() else None
+        except Exception as e:
+            logger.error(f"Attempt {attempt} error: {e}")
+            await asyncio.sleep(10)
+            attempt += 1
+    logger.error(f"Max attempts ({max_attempts}) reached.")
+    return None
+
+
+# ===================== CLI and entry =====================
+
+def run_full(push: bool, reset_postcode_cache: bool) -> None:
+    result = asyncio.run(process_until_complete())
+    if result is not None:
+        save_final_results(result)
+    if not Path(MONUMENTEN_CSV).exists():
+        logger.error("Stage 1 did not produce monumenten.csv. Skipping stage 2.")
+        return
+    if not add_postcode_main(reset_cache=reset_postcode_cache):
+        return
+    if not csv_to_parquet(OUTPUT_CSV, OUTPUT_PARQUET):
+        return
+    if push:
+        df = pd.read_parquet(OUTPUT_PARQUET)
+        if "straatnaam" in df.columns and "huisnummer" in df.columns:
+            df = df.sort_values(by=["straatnaam", "huisnummer"]).reset_index(drop=True)
+        push_to_huggingface(df)
+
+
+def run_process_only() -> None:
+    result = asyncio.run(process_until_complete())
+    if result is not None:
+        save_final_results(result)
+    logger.info("Process stage done.")
+
+
+def run_postcode_only(push: bool, reset_postcode_cache: bool) -> None:
+    if not Path(MONUMENTEN_CSV).exists():
+        logger.error(f"{MONUMENTEN_CSV} not found. Run stage 'process' first.")
+        return
+    if not add_postcode_main(reset_cache=reset_postcode_cache):
+        return
+    if not csv_to_parquet(OUTPUT_CSV, OUTPUT_PARQUET):
+        return
+    if push:
+        df = pd.read_parquet(OUTPUT_PARQUET)
+        if "postcode" in df.columns and "huisnummer" in df.columns:
+            df = df.sort_values(by=["postcode", "huisnummer"]).reset_index(drop=True)
+        push_to_huggingface(df)
+
+
+def main():
+    parser = argparse.ArgumentParser(
+        description="Monumenten pipeline: process XML + postcodes -> Parquet (optional HF push)"
+    )
+    parser.add_argument(
+        "--stage",
+        choices=["full", "process", "postcode"],
+        default="full",
+        help="full (default): process then postcode then Parquet; process: only stage 1; postcode: only stage 2 + Parquet",
+    )
+    parser.add_argument(
+        "--push",
+        action="store_true",
+        help="After writing Parquet, push to Hugging Face (requires HF_TOKEN)",
+    )
+    parser.add_argument(
+        "--reset-postcode-cache",
+        action="store_true",
+        help="Force full postcode refresh (clear SQLite cache and checkpoint)",
+    )
+    args = parser.parse_args()
+
+    if args.stage == "full":
+        run_full(push=args.push, reset_postcode_cache=args.reset_postcode_cache)
+    elif args.stage == "process":
+        run_process_only()
+    else:
+        run_postcode_only(
+            push=args.push, reset_postcode_cache=args.reset_postcode_cache
+        )
+    logger.info("Done.")
+
+
+if __name__ == "__main__":
+    main()

update-analysis.ipynb

@@ -0,0 +1,277 @@
+{
+  "cells": [
+    {
+      "cell_type": "markdown",
+      "id": "87cab8dc",
+      "metadata": {},
+      "source": [
+        "## Update Analysis\n",
+        "\n",
+        "This Notebook contains the analysis of the update from the old dataset to the new one."
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "id": "962fa8db",
+      "metadata": {},
+      "outputs": [],
+      "source": [
+        "import pandas as pd\n",
+        "import numpy as np"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "id": "16823168",
+      "metadata": {},
+      "outputs": [],
+      "source": [
+        "# Login using e.g. `huggingface-cli login` to access this dataset\n",
+        "old = df = pd.read_parquet(\"hf://datasets/woonstadrotterdam/monumenten/monumenten.parquet\")"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "id": "8a11d0e5",
+      "metadata": {},
+      "outputs": [],
+      "source": [
+        "old"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "id": "8bfe4964",
+      "metadata": {},
+      "outputs": [],
+      "source": [
+        "new = pd.read_csv('monumenten.csv', dtype={'bag_verblijfsobject_id': 'str'})"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "id": "e0c4b452",
+      "metadata": {},
+      "outputs": [],
+      "source": [
+        "new"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "id": "026d6b45",
+      "metadata": {},
+      "outputs": [],
+      "source": [
+        "def difference_report(old, new, id_col=\"bag_verblijfsobject_id\", columns=None, treat_na_equal=True):\n",
+        "    \"\"\"\n",
+        "    Compare two DataFrames that share an ID column and (mostly) the same other columns.\n",
+        "    Returns a long 'difference report' with:\n",
+        "      - rows missing in one DF (column='ALL')\n",
+        "      - cell-level changes for common IDs\n",
+        "      - change_type identifying NA transitions and other value changes\n",
+        "\n",
+        "    Params\n",
+        "    ------\n",
+        "    id_col : str\n",
+        "        Name of the ID column.\n",
+        "    columns : list[str] | None\n",
+        "        Columns (excluding id_col) to compare. If None, uses intersection of old/new.\n",
+        "    treat_na_equal : bool\n",
+        "        If True, NaN == NaN (no diff). If False, NaN vs NaN will be reported as diff.\n",
+        "    \"\"\"\n",
+        "    # Basic checks\n",
+        "    if old[id_col].duplicated().any() or new[id_col].duplicated().any():\n",
+        "        raise ValueError(\"Duplicate IDs detected. Ensure unique IDs before comparing.\")\n",
+        "\n",
+        "    # Choose comparable columns (intersection by default, preserving old order)\n",
+        "    if columns is None:\n",
+        "        columns = [c for c in old.columns if c != id_col and c in new.columns]\n",
+        "    else:\n",
+        "        # ensure the id column isn't in 'columns'\n",
+        "        columns = [c for c in columns if c != id_col]\n",
+        "\n",
+        "    # Align by ID (index) and columns\n",
+        "    a = old.set_index(id_col)[columns]\n",
+        "    b = new.set_index(id_col)[columns]\n",
+        "\n",
+        "    # Missing IDs\n",
+        "    only_in_old = a.index.difference(b.index)\n",
+        "    only_in_new = b.index.difference(a.index)\n",
+        "\n",
+        "    missing1 = pd.DataFrame({\n",
+        "        id_col: only_in_old,\n",
+        "        \"column\": \"ALL\",\n",
+        "        \"old\": \"Row not in new\",\n",
+        "        \"new\": pd.NA,\n",
+        "        \"change_type\": \"row_removed\"\n",
+        "    })\n",
+        "\n",
+        "    missing2 = pd.DataFrame({\n",
+        "        id_col: only_in_new,\n",
+        "        \"column\": \"ALL\",\n",
+        "        \"old\": pd.NA,\n",
+        "        \"new\": \"Row is new\",\n",
+        "        \"change_type\": \"row_added\"\n",
+        "    })\n",
+        "\n",
+        "    # Compare common IDs\n",
+        "    common_idx = a.index.intersection(b.index)\n",
+        "    a2 = a.loc[common_idx, columns].sort_index()\n",
+        "    b2 = b.loc[common_idx, columns].sort_index()\n",
+        "\n",
+        "    # Build masks explicitly to capture NA transitions\n",
+        "    a_na = a2.isna()\n",
+        "    b_na = b2.isna()\n",
+        "    both_na = a_na & b_na\n",
+        "    na_xor = a_na ^ b_na\n",
+        "    neq_non_na = (a2 != b2) & ~a_na & ~b_na\n",
+        "\n",
+        "    if treat_na_equal:\n",
+        "        mask = na_xor | neq_non_na\n",
+        "    else:\n",
+        "        mask = na_xor | both_na | neq_non_na\n",
+        "\n",
+        "    # Stack with dropna=False so NA values are preserved in the result\n",
+        "    diff_cells_idx = mask.stack(future_stack=True).pipe(lambda s: s[s].index)\n",
+        "\n",
+        "    vals_old = a2.stack(future_stack=True)\n",
+        "    vals_new = b2.stack(future_stack=True)\n",
+        "\n",
+        "    diffs_long = (\n",
+        "        pd.concat({\"old\": vals_old, \"new\": vals_new}, axis=1)\n",
+        "          .loc[diff_cells_idx]\n",
+        "          .reset_index()\n",
+        "          .rename(columns={\"level_0\": id_col, \"level_1\": \"column\"})\n",
+        "    )\n",
+        "\n",
+        "    # Change type labeling\n",
+        "    is_old_na = diffs_long[\"old\"].isna()\n",
+        "    is_new_na = diffs_long[\"new\"].isna()\n",
+        "    diffs_long[\"change_type\"] = np.where(\n",
+        "        is_old_na & ~is_new_na, \"from_null\",\n",
+        "        np.where(~is_old_na & is_new_na, \"to_null\", \"value_changed\")\n",
+        "    )\n",
+        "\n",
+        "    # Combine missing + changed\n",
+        "    out = pd.concat([missing1, missing2, diffs_long], ignore_index=True)\n",
+        "\n",
+        "    # Nice ordering\n",
+        "    out = out.sort_values([id_col, \"column\"], kind=\"mergesort\").reset_index(drop=True)\n",
+        "    return out"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "id": "eefc6d96",
+      "metadata": {},
+      "outputs": [],
+      "source": [
+        "# Harmonize integer-like numeric columns to avoid int vs float diffs\n",
+        "for col in [\"rijksmonument_nummer\"]:\n",
+        "    if col in old.columns:\n",
+        "        old[col] = pd.to_numeric(old[col], errors=\"coerce\").astype(\"Int64\")\n",
+        "    if col in new.columns:\n",
+        "        new[col] = pd.to_numeric(new[col], errors=\"coerce\").astype(\"Int64\")\n",
+        "\n",
+        "# Keep all columns that exist in both (include beschermd_gezicht_naam, grondslag, rijksmonument_url/nummer). Drop only old-only cols.\n",
+        "drop_cols = [c for c in old.columns if c not in new.columns]  # e.g. straatnaam, huisnummer, postcode, plaatsnaam\n",
+        "old_for_diff = old.drop(columns=drop_cols, errors=\"ignore\").drop_duplicates().copy()\n",
+        "new_for_diff = new.copy()\n",
+        "old_for_diff[\"bag_verblijfsobject_id\"] = old_for_diff[\"bag_verblijfsobject_id\"].astype(str)\n",
+        "new_for_diff[\"bag_verblijfsobject_id\"] = new_for_diff[\"bag_verblijfsobject_id\"].astype(str)\n",
+        "\n",
+        "difference = difference_report(old_for_diff, new_for_diff)"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "id": "a5e21313",
+      "metadata": {},
+      "outputs": [],
+      "source": [
+        "# Diagnostic: why would difference be empty?\n",
+        "# 1) Ensure ID has same type in both (parquet often has int, CSV has str -> no index overlap)\n",
+        "_id = \"bag_verblijfsobject_id\"\n",
+        "old_clean = old.drop(columns=[\"beschermd_gezicht_naam\", \"grondslag_gemeentelijk_monument\", \"rijksmonument_url\", \"rijksmonument_nummer\"], errors=\"ignore\").drop_duplicates()\n",
+        "new_clean = new.drop(columns=[\"beschermd_gezicht_naam\", \"grondslag_gemeentelijk_monument\", \"rijksmonument_url\", \"rijksmonument_nummer\"], errors=\"ignore\")\n",
+        "old_clean[_id] = old_clean[_id].astype(str)\n",
+        "new_clean[_id] = new_clean[_id].astype(str)\n",
+        "cols = [c for c in old_clean.columns if c != _id and c in new_clean.columns]\n",
+        "a_idx = old_clean.set_index(_id)[cols].index\n",
+        "b_idx = new_clean.set_index(_id)[cols].index\n",
+        "only_old = a_idx.difference(b_idx)\n",
+        "only_new = b_idx.difference(a_idx)\n",
+        "common = a_idx.intersection(b_idx)\n",
+        "print(\"old rows:\", len(old_clean), \"  new rows:\", len(new_clean))\n",
+        "print(\"comparable columns:\", cols)\n",
+        "print(\"IDs only in old:\", len(only_old), \"  only in new:\", len(only_new), \"  in both:\", len(common))\n",
+        "print(\"old ID dtype:\", old[_id].dtype, \"  new ID dtype:\", new[_id].dtype)"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "id": "8992ebb7",
+      "metadata": {},
+      "outputs": [],
+      "source": [
+        "counts = difference.loc[\n",
+        "    lambda df: ~df[\"column\"].isin([\n",
+        "        \"beschermd_gezicht_naam\",\n",
+        "        \"grondslag_gemeentelijk_monument\",\n",
+        "        \"rijksmonument_url\",\n",
+        "        \"rijksmonument_nummer\"\n",
+        "    ])\n",
+        "].groupby([\"column\", \"old\", \"new\", \"change_type\"], dropna=False).size().reset_index(name=\"count\")"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "id": "ef420c13",
+      "metadata": {},
+      "outputs": [],
+      "source": [
+        "counts"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "id": "ca126bfb",
+      "metadata": {},
+      "outputs": [],
+      "source": []
+    }
+  ],
+  "metadata": {
+    "kernelspec": {
+      "display_name": ".venv",
+      "language": "python",
+      "name": "python3"
+    },
+    "language_info": {
+      "codemirror_mode": {
+        "name": "ipython",
+        "version": 3
+      },
+      "file_extension": ".py",
+      "mimetype": "text/x-python",
+      "name": "python",
+      "nbconvert_exporter": "python",
+      "pygments_lexer": "ipython3",
+      "version": "3.13.11"
+    }
+  },
+  "nbformat": 4,
+  "nbformat_minor": 5
+}