feat: add memberships

README.md

@@ -3,6 +3,8 @@ license: cc0-1.0
 configs:
 - config_name: persons
   data_files: "databases/persons.parquet"
+- config_name: memberships
+  data_files: "databases/memberships.parquet"
 tags:
 - philippines
 - politicians
@@ -26,7 +28,18 @@ This dataset currently contains:
 - **Last Name**: Person's last name
 - **Name Suffix**: Jr., Sr., I, II, III, IV, etc. (if applicable)
 
-*More entity types (groups, positions, etc.) will be added in the future.*
+### Memberships
+Political party affiliations and positions held by persons, including:
+- **ID**: Unique membership identifier
+- **Person ID**: Links to the person record
+- **Party**: Political party affiliation
+- **Region**: Geographic region (e.g., "National Capital Region", "Region III")
+- **Province**: Province name
+- **Locality**: City or municipality (optional)
+- **Position**: Position held (e.g., "Representative", "Governor", "Mayor")
+- **Year**: Year of the position/membership
+
+*More entity types (groups, etc.) will be added in the future.*
 
 ## Using the Dataset
 
@@ -35,6 +48,7 @@ This dataset currently contains:
 You can explore the data directly in your browser using the **Dataset Viewer** tab above.
 
 - Select **"persons"** from the config dropdown to view person records
+- Select **"memberships"** to view political positions and party affiliations
 - Additional entity types will appear in the dropdown as they're added
 
 The data is available in Parquet format for easy viewing and filtering.
@@ -48,6 +62,10 @@ from datasets import load_dataset
 persons = load_dataset("bettergovph/raw-philippine-data", "persons")
 print(persons['train'][0])
 
+# Load memberships data
+memberships = load_dataset("bettergovph/raw-philippine-data", "memberships")
+print(memberships['train'][0])
+
 # Future: Load other entity types
 # groups = load_dataset("bettergovph/raw-philippine-data", "groups")
 ```
@@ -67,6 +85,9 @@ Example queries:
 -- Count all persons
 SELECT COUNT(*) FROM persons;
 
+-- Count all memberships
+SELECT COUNT(*) FROM memberships;
+
 -- Find all persons with "Jr." suffix
 SELECT * FROM persons WHERE name_suffix = 'Jr.' LIMIT 10;
 
@@ -79,11 +100,37 @@ FROM persons
 WHERE name_suffix IS NOT NULL
 GROUP BY name_suffix
 ORDER BY count DESC;
+
+-- Find all mayors in a specific region
+SELECT p.first_name, p.last_name, m.province, m.locality, m.year
+FROM memberships m
+JOIN persons p ON m.person_id = p.id
+WHERE m.position = 'Mayor'
+  AND m.region = 'National Capital Region'
+ORDER BY m.year DESC
+LIMIT 10;
+
+-- Count positions by party affiliation
+SELECT party, position, COUNT(*) as count
+FROM memberships
+WHERE party IS NOT NULL
+GROUP BY party, position
+ORDER BY count DESC
+LIMIT 20;
+
+-- Find persons with multiple political positions
+SELECT p.first_name, p.last_name, COUNT(*) as position_count
+FROM persons p
+JOIN memberships m ON p.id = m.person_id
+GROUP BY p.id, p.first_name, p.last_name
+HAVING COUNT(*) > 1
+ORDER BY position_count DESC
+LIMIT 10;
 ```
 
 ## Data Sources
 
-The raw data comes from TOML files in the `data/person/` directory. Each person has their own TOML file with their information.
+The raw data comes from TOML files in the `data/person/` directory. Each person has their own TOML file with their information, including an optional `memberships` array that contains their political positions and party affiliations.
 
 ## Regenerating the Dataset
 
@@ -95,13 +142,23 @@ pip install -r requirements.txt
 
 # Load data and export to Parquet
 python scripts/load_persons_to_db.py --export-parquet
+
+# Optional: Use larger batch size for faster loading (recommended for 45k+ files)
+python scripts/load_persons_to_db.py --export-parquet --batch-size 5000
 ```
 
 This will create:
 - `databases/data.duckdb` - DuckDB database for SQL queries
-- `databases/persons.parquet` - Parquet file for the Hugging Face dataset viewer
+- `databases/persons.parquet` - Persons table in Parquet format
+- `databases/memberships.parquet` - Memberships table in Parquet format
+
+The script uses batch inserts for performance and includes:
+- Progress tracking with percentage complete
+- Error logging to `databases/load_errors.log`
+- Total execution time reporting
+- Graceful handling of Ctrl+C interruptions
 
-**Note:** Future entity types (groups, positions, etc.) will also generate their own parquet files in the `databases/` folder.
+**Note:** Future entity types (groups, etc.) will also generate their own parquet files in the `databases/` folder.
 
 ## Contributing
 

databases/data.duckdb

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:82433f465a60e793068d978c267fc8247e50afe187c3e226f132d3c5ff9385d1
-size 19935232
+oid sha256:bb25fdfa27ed0962309f0abe2a8983f871098cc9ca82f362cf10ca7626e6321f
+size 16003072

databases/memberships.parquet

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:d3012fe1d67c6b7df46183cde46c424a319553ef79d707a1ec244d4910d27a5e
+size 2665310

scripts/load_persons_to_db.py

@@ -11,6 +11,9 @@ import argparse
 from pathlib import Path
 import tomlkit
 import duckdb
+import logging
+from datetime import datetime
+from typing import Tuple, List, Optional
 
 # Add parent directory to path to import schemas and config
 sys.path.insert(0, str(Path(__file__).parent.parent))
@@ -52,9 +55,28 @@ def create_memberships_table(conn: duckdb.DuckDBPyConnection):
     conn.execute(create_sql)
 
 
-def load_persons_to_db(data_dir: Path, db_path: Path, export_parquet: bool = False, parquet_path: Path = None):
-    """Load all person TOML files into the DuckDB database."""
+def load_persons_to_db(
+    data_dir: Path,
+    db_path: Path,
+    export_parquet: bool = False,
+    parquet_path: Path = None,
+    memberships_parquet_path: Path = None,
+    batch_size: int = 1000,
+    progress_interval: int = 100
+):
+    """Load all person TOML files into the DuckDB database with batch inserts."""
+    # Setup error logging
+    error_log_path = db_path.parent / 'load_errors.log'
+    logging.basicConfig(
+        filename=str(error_log_path),
+        level=logging.ERROR,
+        format='%(asctime)s - %(message)s',
+        filemode='w'  # Overwrite previous log
+    )
+
     print(f"Connecting to database: {db_path}")
+    print(f"Error log: {error_log_path}")
+    print(f"Batch size: {batch_size}")
     conn = duckdb.connect(str(db_path))
 
     # Create tables with explicit schema
@@ -65,7 +87,13 @@ def load_persons_to_db(data_dir: Path, db_path: Path, export_parquet: bool = Fal
     insert_person_sql = PERSON_SCHEMA.get_insert_sql()
     insert_membership_sql = MEMBERSHIP_SCHEMA.get_insert_sql()
 
-    # Load data within a single transaction for performance
+    # Get all TOML files
+    print("\nScanning for TOML files...")
+    toml_files = list(get_person_toml_files(data_dir))
+    total_files = len(toml_files)
+    print(f"Found {total_files} files to process")
+
+    # Load data with parallel processing and batch inserts
     print("\nLoading person data...")
     loaded_count = 0
     error_count = 0
@@ -73,74 +101,130 @@ def load_persons_to_db(data_dir: Path, db_path: Path, export_parquet: bool = Fal
     memberships_loaded_count = 0
     unknown_fields_seen = set()
 
-    # Start explicit transaction
-    conn.execute("BEGIN TRANSACTION")
+    # Batches for accumulating records
+    person_batch = []
+    membership_batch = []
+
+    # Track timing for ETA
+    start_time = datetime.now()
+
+    def flush_batches():
+        """Helper to insert accumulated batches and commit."""
+        nonlocal loaded_count, memberships_loaded_count
+
+        if not person_batch and not membership_batch:
+            return
+
+        batch_size_to_commit = len(person_batch)
+        print(f"  Committing batch of {batch_size_to_commit} records...", end='', flush=True)
+
+        try:
+            conn.execute("BEGIN TRANSACTION")
+
+            # Batch insert persons
+            if person_batch:
+                conn.executemany(insert_person_sql, person_batch)
+                loaded_count += len(person_batch)
 
+            # Batch insert memberships
+            if membership_batch:
+                conn.executemany(insert_membership_sql, membership_batch)
+                memberships_loaded_count += len(membership_batch)
+
+            conn.execute("COMMIT")
+            print(f" done!")
+
+        except Exception as e:
+            conn.execute("ROLLBACK")
+            logging.error(f"Batch insert failed: {e}")
+            print(f"\n  Warning: Batch insert failed, see error log")
+
+        person_batch.clear()
+        membership_batch.clear()
+
+    # Process files sequentially
     try:
-        for toml_file in get_person_toml_files(data_dir):
+        for toml_file in toml_files:
             try:
+                # Read and parse TOML file
                 person_data = load_toml_file(toml_file)
+                person_id = person_data.get('id')
+                memberships = person_data.get('memberships', [])
 
                 # Warn about unknown fields (helps catch typos)
-                # Skip 'memberships' as it's handled separately
                 for field in person_data.keys():
                     if field not in PERSON_SCHEMA.schema and field != 'memberships' and field not in unknown_fields_seen:
-                        print(f"  Warning: Unknown field '{field}' found in {toml_file.name} (will be ignored)")
+                        print(f"  Warning: Unknown field '{field}' (will be ignored)")
                         unknown_fields_seen.add(field)
 
-                # Build values list in the same order as field_order
-                # Apply transformation for nested/complex types
+                # Build values list for person
                 values = [
                     transform_value(field, person_data.get(field), PERSON_SCHEMA.nested_fields)
                     for field in PERSON_SCHEMA.field_order
                 ]
+                person_batch.append(values)
 
-                # Insert person data
-                conn.execute(insert_person_sql, values)
-
-                # Extract and insert memberships for this person
-                person_id = person_data.get('id')
-                memberships = person_data.get('memberships', [])
-
+                # Add memberships to batch
                 for idx, membership in enumerate(memberships):
-                    # Generate unique ID for membership: person_id + index
                     membership_id = f"{person_id}_m{idx}"
-
                     membership_values = [
                         membership_id,
                         person_id,
                         membership.get('party'),
                         membership.get('region'),
                         membership.get('province'),
-                        membership.get('locality'),  # May be None/missing
+                        membership.get('locality'),
                         membership.get('position'),
                         membership.get('year'),
                     ]
-
-                    conn.execute(insert_membership_sql, membership_values)
-                    memberships_loaded_count += 1
-
-                loaded_count += 1
-                processed_count += 1
-
-                # Progress indicator
-                if processed_count % 100 == 0:
-                    print(f"  Processed {processed_count} files...")
+                    membership_batch.append(membership_values)
 
             except Exception as e:
+                # File processing failed
                 error_count += 1
-                processed_count += 1
-                print(f"  Error loading {toml_file}: {e}")
+                logging.error(f"{toml_file}: {e}")
+
+            processed_count += 1
+
+            # Flush batches when reaching batch size
+            if len(person_batch) >= batch_size:
+                flush_batches()
+
+            # Progress indicator
+            if processed_count % progress_interval == 0 or processed_count == total_files:
+                pct = (processed_count / total_files * 100) if total_files > 0 else 0
+                # Show committed + pending records
+                pending = len(person_batch)
+                total_loaded = loaded_count + pending
+                print(f"  [{pct:5.1f}%] {processed_count}/{total_files} files | "
+                      f"{total_loaded} loaded ({loaded_count} committed, {pending} pending) | "
+                      f"{error_count} errors")
+
+    except KeyboardInterrupt:
+        print("\n\n*** Interrupted by user (Ctrl+C) ***")
+        print("Flushing any pending records to database...")
+        flush_batches()
+
+        # Calculate time up to interruption
+        end_time = datetime.now()
+        total_seconds = (end_time - start_time).total_seconds()
+        total_minutes = total_seconds / 60
+
+        print(f"\nPartial load completed:")
+        print(f"  Files processed: {processed_count}/{total_files}")
+        print(f"  Records loaded: {loaded_count}")
+        print(f"  Errors: {error_count}")
+        print(f"  Time elapsed: {total_minutes:.1f} minutes ({total_seconds:.0f} seconds)")
+        conn.close()
+        sys.exit(1)
 
-        # Commit transaction
-        conn.execute("COMMIT")
-        print("  Transaction committed")
+    # Flush any remaining records
+    flush_batches()
 
-    except Exception as e:
-        # Rollback on error
-        conn.execute("ROLLBACK")
-        print(f"  Transaction rolled back due to error: {e}")
-        raise
+    # Calculate total time
+    end_time = datetime.now()
+    total_seconds = (end_time - start_time).total_seconds()
+    total_minutes = total_seconds / 60
 
     # Show summary
     print(f"\n{'='*60}")
@@ -148,6 +232,9 @@ def load_persons_to_db(data_dir: Path, db_path: Path, export_parquet: bool = Fal
     print(f"  Total files processed: {processed_count}")
     print(f"  Successfully loaded: {loaded_count}")
     print(f"  Errors: {error_count}")
+    print(f"  Total time: {total_minutes:.1f} minutes ({total_seconds:.0f} seconds)")
+    if error_count > 0:
+        print(f"  Error details logged to: {error_log_path}")
 
     # Show database stats
     persons_count = conn.execute("SELECT COUNT(*) as total FROM persons").fetchone()
@@ -190,21 +277,34 @@ def load_persons_to_db(data_dir: Path, db_path: Path, export_parquet: bool = Fal
     if export_parquet:
         print(f"\n{'='*60}")
         print("Exporting to Parquet format...")
-        print(f"Output path: {parquet_path}")
 
+        # Export persons table
+        print(f"\nExporting persons table...")
+        print(f"  Output: {parquet_path}")
         try:
             conn.execute(f"COPY persons TO '{parquet_path}' (FORMAT PARQUET)")
-
-            # Get file size for confirmation
             if parquet_path.exists():
                 file_size = parquet_path.stat().st_size
                 file_size_mb = file_size / (1024 * 1024)
-                print(f"✓ Successfully exported to Parquet")
-                print(f"  File size: {file_size_mb:.2f} MB")
+                print(f"  ✓ Successfully exported persons.parquet ({file_size_mb:.2f} MB)")
+            else:
+                print("  ⚠ Export completed but file not found")
+        except Exception as e:
+            print(f"  ✗ Error exporting persons: {e}")
+
+        # Export memberships table
+        print(f"\nExporting memberships table...")
+        print(f"  Output: {memberships_parquet_path}")
+        try:
+            conn.execute(f"COPY memberships TO '{memberships_parquet_path}' (FORMAT PARQUET)")
+            if memberships_parquet_path.exists():
+                file_size = memberships_parquet_path.stat().st_size
+                file_size_mb = file_size / (1024 * 1024)
+                print(f"  ✓ Successfully exported memberships.parquet ({file_size_mb:.2f} MB)")
             else:
-                print("⚠ Export completed but file not found")
+                print("  ⚠ Export completed but file not found")
         except Exception as e:
-            print(f"✗ Error exporting to Parquet: {e}")
+            print(f"  ✗ Error exporting memberships: {e}")
 
         print(f"{'='*60}")
 
@@ -247,13 +347,31 @@ Examples:
     parser.add_argument(
         '--export-parquet',
         action='store_true',
-        help='Export the persons table to Parquet format after loading'
+        help='Export the persons and memberships tables to Parquet format after loading'
     )
     parser.add_argument(
         '--parquet-path',
         type=Path,
         default=Path(__file__).parent.parent / 'databases' / 'persons.parquet',
-        help='Path for the exported Parquet file (default: databases/persons.parquet)'
+        help='Path for the exported persons Parquet file (default: databases/persons.parquet)'
+    )
+    parser.add_argument(
+        '--memberships-parquet-path',
+        type=Path,
+        default=Path(__file__).parent.parent / 'databases' / 'memberships.parquet',
+        help='Path for the exported memberships Parquet file (default: databases/memberships.parquet)'
+    )
+    parser.add_argument(
+        '--batch-size',
+        type=int,
+        default=1000,
+        help='Number of records to insert per batch/transaction (default: 1000)'
+    )
+    parser.add_argument(
+        '--progress-interval',
+        type=int,
+        default=100,
+        help='Show progress every N files (default: 100)'
     )
 
     args = parser.parse_args()
@@ -266,7 +384,15 @@ Examples:
     # Create databases directory if it doesn't exist
     args.db_path.parent.mkdir(parents=True, exist_ok=True)
 
-    load_persons_to_db(args.data_dir, args.db_path, args.export_parquet, args.parquet_path)
+    load_persons_to_db(
+        args.data_dir,
+        args.db_path,
+        args.export_parquet,
+        args.parquet_path,
+        args.memberships_parquet_path,
+        args.batch_size,
+        args.progress_interval
+    )
 
 
 if __name__ == '__main__':