feat: add loader

requirements.txt

@@ -0,0 +1,2 @@
+tomlkit==0.13.3
+duckdb==1.4.1

schemas/README.md

@@ -0,0 +1,122 @@
+# Schemas
+
+This directory contains schema definitions for various entity types in the raw Philippine data project.
+
+## Structure
+
+- `base.py` - Base classes and utilities for all schemas
+- `person.py` - Schema definition for persons
+- Add more entity schemas as needed
+
+## How to Define a New Schema
+
+### 1. Create a new schema file
+
+Create `schemas/your_entity.py`:
+
+```python
+from schemas.base import SchemaDefinition
+
+YOUR_ENTITY_SCHEMA = SchemaDefinition(
+    table_name='your_entities',
+    schema={
+        'id': 'VARCHAR PRIMARY KEY',
+        'name': 'VARCHAR',
+        'nested_field': 'JSON',
+    },
+    field_order=['id', 'name', 'nested_field'],
+    nested_fields=set(['nested_field'])
+)
+```
+
+### 2. Create a loader script
+
+Create `scripts/load_your_entity_to_db.py`:
+
+```python
+import sys
+import argparse
+from pathlib import Path
+sys.path.insert(0, str(Path(__file__).parent.parent))
+
+from schemas.your_entity import YOUR_ENTITY_SCHEMA
+from schemas.base import transform_value
+from config import DATABASE_PATH
+
+# Then use YOUR_ENTITY_SCHEMA.get_create_table_sql(), etc.
+# Add argparse with --db-path argument for flexibility
+# Default database: databases/data.duckdb (shared across all entities)
+```
+
+### 3. Update the schema as needed
+
+When adding new fields:
+1. Add to `schema` dict with SQL type
+2. Add to `field_order` list
+3. If nested (dict/array), add to `nested_fields` set
+
+## Schema Definition Reference
+
+### `SchemaDefinition` class
+
+**Attributes:**
+- `table_name` (str): Name of the database table
+- `schema` (dict): Field names → SQL types
+- `field_order` (list): Ordered list of fields for INSERT
+- `nested_fields` (set): Fields containing JSON/nested data
+
+**Methods:**
+- `get_create_table_sql()`: Returns CREATE TABLE statement
+- `get_insert_sql()`: Returns INSERT statement with placeholders
+
+### `transform_value()` function
+
+Transforms TOML values for database storage:
+- Converts dicts/lists to JSON for nested fields
+- Passes through primitive types unchanged
+- Handles None values
+
+**Usage:**
+```python
+from schemas.base import transform_value
+
+value = transform_value(
+    field_name='positions',
+    value={'title': 'Mayor'},
+    nested_fields={'positions'}
+)
+# Returns: '{"title": "Mayor"}'
+```
+
+## Adding Nested Fields
+
+For nested data (objects, arrays):
+
+1. Add field to schema with `JSON` type:
+   ```python
+   schema={'positions': 'JSON'}
+   ```
+
+2. Add to nested_fields set:
+   ```python
+   nested_fields=set(['positions'])
+   ```
+
+3. Use transform_value when inserting:
+   ```python
+   values = [
+       transform_value(field, data.get(field), SCHEMA.nested_fields)
+       for field in SCHEMA.field_order
+   ]
+   ```
+
+## Database Configuration
+
+All loader scripts use the shared `config.py` file which defines:
+- **DATABASE_PATH**: Default path to `databases/data.duckdb` (shared by all entities)
+- All entities (persons, groups, etc.) are stored in the same database as separate tables
+- Use `--db-path` CLI argument to override the default database path
+
+## Examples
+
+- **Person schema**: `person.py` - Basic schema with flat fields

schemas/__init__.py

@@ -0,0 +1,6 @@
+"""
+Schema definitions for raw Philippine data.
+
+This package contains schema definitions for various entity types
+(persons, groups, etc.) that define how data is structured in the database.
+"""

schemas/base.py

@@ -0,0 +1,83 @@
+"""
+Base utilities for schema definitions.
+
+Provides common functionality for transforming and validating data
+across different entity types.
+"""
+
+import json
+from typing import Any, Dict, Set
+from dataclasses import dataclass
+
+
+@dataclass
+class SchemaDefinition:
+    """
+    Base schema definition for an entity type.
+
+    Attributes:
+        table_name: Name of the database table
+        schema: Dict mapping field names to SQL types
+        field_order: List of fields in order for INSERT statements
+        nested_fields: Set of field names that contain nested/complex data
+    """
+    table_name: str
+    schema: Dict[str, str]
+    field_order: list[str]
+    nested_fields: Set[str]
+
+    def get_create_table_sql(self) -> str:
+        """Generate CREATE TABLE SQL statement."""
+        columns = [f"{field} {field_type}" for field, field_type in self.schema.items()]
+        return f"""
+            CREATE TABLE IF NOT EXISTS {self.table_name} (
+                {', '.join(columns)}
+            )
+        """
+
+    def get_insert_sql(self) -> str:
+        """Generate INSERT SQL statement."""
+        placeholders = ', '.join(['?' for _ in self.field_order])
+        return f"""
+            INSERT INTO {self.table_name} ({', '.join(self.field_order)})
+            VALUES ({placeholders})
+            ON CONFLICT (id) DO NOTHING
+        """
+
+
+def transform_value(field_name: str, value: Any, nested_fields: Set[str]) -> Any:
+    """
+    Transform a field value for database storage.
+
+    Handles nested objects, arrays, and type conversions.
+
+    Args:
+        field_name: Name of the field being transformed
+        value: The value to transform
+        nested_fields: Set of field names that should be stored as JSON
+
+    Returns:
+        Transformed value ready for database insertion
+    """
+    if value is None:
+        return None
+
+    # Check if this field should be stored as JSON
+    if field_name in nested_fields:
+        if isinstance(value, (dict, list)):
+            return json.dumps(value)
+        elif isinstance(value, str):
+            # Already a string, assume it's valid JSON or plain text
+            return value
+        else:
+            # Convert other types to JSON
+            return json.dumps(value)
+
+    # Handle non-nested complex types that shouldn't be in the data
+    if isinstance(value, (dict, list)):
+        # Warn: this field has nested data but isn't marked as nested_fields
+        # Store as JSON anyway to avoid data loss
+        return json.dumps(value)
+
+    # Return primitive types as-is
+    return value

schemas/person.py

@@ -0,0 +1,31 @@
+"""
+Schema definition for persons.
+
+Update this file when adding new fields to the person data model.
+"""
+
+from schemas.base import SchemaDefinition
+
+
+# Define the person schema
+PERSON_SCHEMA = SchemaDefinition(
+    table_name='persons',
+    schema={
+        'id': 'VARCHAR PRIMARY KEY',
+        'first_name': 'VARCHAR',
+        'last_name': 'VARCHAR',
+        # Add new fields here as needed:
+        # 'middle_name': 'VARCHAR',
+        # 'birth_date': 'DATE',
+        # 'positions': 'JSON',  # For nested arrays of positions
+        # 'addresses': 'JSON',  # For nested address objects
+        # etc.
+    },
+    field_order=['id', 'first_name', 'last_name'],
+    nested_fields=set([
+        # Add nested field names here:
+        # 'positions',
+        # 'addresses',
+        # 'metadata',
+    ])
+)

scripts/load_persons_to_db.py

@@ -0,0 +1,179 @@
+#!/usr/bin/env python3
+"""
+Load person data from TOML files into a DuckDB database.
+
+This script scans the data/person directory for TOML files and loads them
+into a local DuckDB database for duplicate detection and processing.
+"""
+
+import sys
+import argparse
+from pathlib import Path
+import tomlkit
+import duckdb
+
+# Add parent directory to path to import schemas and config
+sys.path.insert(0, str(Path(__file__).parent.parent))
+
+from schemas.person import PERSON_SCHEMA
+from schemas.base import transform_value
+from config import DATABASE_PATH, PERSON_DATA_DIR
+
+
+def load_toml_file(file_path: Path) -> dict:
+    """Load and parse a TOML file."""
+    with open(file_path, 'r', encoding='utf-8') as f:
+        return tomlkit.load(f)
+
+
+def get_person_toml_files(data_dir: Path):
+    """Recursively find all TOML files in the person data directory (generator)."""
+    return data_dir.glob('**/*.toml')
+
+
+def create_persons_table(conn: duckdb.DuckDBPyConnection):
+    """Create the persons table using the explicit schema."""
+    create_sql = PERSON_SCHEMA.get_create_table_sql()
+
+    print(f"Creating table '{PERSON_SCHEMA.table_name}' with {len(PERSON_SCHEMA.schema)} columns:")
+    print(f"  Fields: {', '.join(PERSON_SCHEMA.field_order)}")
+
+    conn.execute(create_sql)
+
+
+def load_persons_to_db(data_dir: Path, db_path: Path):
+    """Load all person TOML files into the DuckDB database."""
+    print(f"Connecting to database: {db_path}")
+    conn = duckdb.connect(str(db_path))
+
+    # Create table with explicit schema
+    create_persons_table(conn)
+
+    # Build INSERT statement using schema definition
+    insert_sql = PERSON_SCHEMA.get_insert_sql()
+
+    # Load data within a single transaction for performance
+    print("\nLoading person data...")
+    loaded_count = 0
+    error_count = 0
+    processed_count = 0
+    unknown_fields_seen = set()
+
+    # Start explicit transaction
+    conn.execute("BEGIN TRANSACTION")
+
+    try:
+        for toml_file in get_person_toml_files(data_dir):
+            try:
+                person_data = load_toml_file(toml_file)
+
+                # Warn about unknown fields (helps catch typos)
+                for field in person_data.keys():
+                    if field not in PERSON_SCHEMA.schema and field not in unknown_fields_seen:
+                        print(f"  Warning: Unknown field '{field}' found in {toml_file.name} (will be ignored)")
+                        unknown_fields_seen.add(field)
+
+                # Build values list in the same order as field_order
+                # Apply transformation for nested/complex types
+                values = [
+                    transform_value(field, person_data.get(field), PERSON_SCHEMA.nested_fields)
+                    for field in PERSON_SCHEMA.field_order
+                ]
+
+                # Insert person data
+                conn.execute(insert_sql, values)
+
+                loaded_count += 1
+                processed_count += 1
+
+                # Progress indicator
+                if processed_count % 100 == 0:
+                    print(f"  Processed {processed_count} files...")
+
+            except Exception as e:
+                error_count += 1
+                processed_count += 1
+                print(f"  Error loading {toml_file}: {e}")
+
+        # Commit transaction
+        conn.execute("COMMIT")
+        print("  Transaction committed")
+
+    except Exception as e:
+        # Rollback on error
+        conn.execute("ROLLBACK")
+        print(f"  Transaction rolled back due to error: {e}")
+        raise
+
+    # Show summary
+    print(f"\n{'='*60}")
+    print(f"Load complete!")
+    print(f"  Total files processed: {processed_count}")
+    print(f"  Successfully loaded: {loaded_count}")
+    print(f"  Errors: {error_count}")
+
+    # Show database stats
+    result = conn.execute("SELECT COUNT(*) as total FROM persons").fetchone()
+    print(f"  Total persons in database: {result[0]}")
+    print(f"{'='*60}")
+
+    # Show sample data
+    print("\nSample data (first 5 rows):")
+    sample = conn.execute("""
+        SELECT id, first_name, last_name
+        FROM persons
+        LIMIT 5
+    """).fetchall()
+
+    for row in sample:
+        print(f"  {row[0]}: {row[1]} {row[2]}")
+
+    conn.close()
+    print(f"\nDatabase saved to: {db_path}")
+
+
+def main():
+    """Main entry point."""
+    parser = argparse.ArgumentParser(
+        description='Load person data from TOML files into a DuckDB database',
+        formatter_class=argparse.RawDescriptionHelpFormatter,
+        epilog="""
+Examples:
+  # Use default database path (databases/data.duckdb)
+  python scripts/load_persons_to_db.py
+
+  # Specify custom database path
+  python scripts/load_persons_to_db.py --db-path /path/to/custom.duckdb
+
+  # Use a different data directory
+  python scripts/load_persons_to_db.py --data-dir /path/to/person/data
+        """
+    )
+    parser.add_argument(
+        '--db-path',
+        type=Path,
+        default=DATABASE_PATH,
+        help=f'Path to the DuckDB database (default: {DATABASE_PATH})'
+    )
+    parser.add_argument(
+        '--data-dir',
+        type=Path,
+        default=PERSON_DATA_DIR,
+        help=f'Path to the person data directory (default: {PERSON_DATA_DIR})'
+    )
+
+    args = parser.parse_args()
+
+    # Validate data directory exists
+    if not args.data_dir.exists():
+        print(f"Error: Data directory not found: {args.data_dir}")
+        sys.exit(1)
+
+    # 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)
+
+
+if __name__ == '__main__':
+    main()