feat: Add Apple Health XML parser and SQLite database generation

- Add comprehensive Apple Health XML parser with SQLModel
- Parse XML data into SQLite database for efficient querying
- Update app to upload both XML and parsed SQLite to dataset
- Modify MCP server to query SQLite instead of parsing XML
- Add support for workouts query type
- Include all Apple Health data types (records, workouts, correlations, etc.)

🤖 Generated with [Claude Code](https://claude.ai/code)

Co-Authored-By: Claude <[email protected]>

.gitignore

@@ -8,3 +8,6 @@ wheels/
 
 # Virtual environments
 .venv
+.DS_Store
+
+data

app.py

@@ -2,6 +2,8 @@ import gradio as gr
 from huggingface_hub import HfApi, create_repo
 from huggingface_hub.utils import RepositoryNotFoundError
 import os
+import tempfile
+from src.parser.parser import AppleHealthParser
 
 
 def create_interface():
@@ -87,22 +89,42 @@ def create_interface():
                     token=token
                 )
                 
-                # Upload the export.xml file
+                # Upload the export.xml file (first commit)
                 api.upload_file(
                     path_or_fileobj=file_path,
                     path_in_repo="export.xml",
                     repo_id=dataset_repo_id,
                     repo_type="dataset",
-                    token=token
+                    token=token,
+                    commit_message="Initial upload: export.xml"
                 )
                 
+                # Parse the XML file and create SQLite database
+                with tempfile.TemporaryDirectory() as temp_dir:
+                    db_path = os.path.join(temp_dir, "health_data.db")
+                    
+                    # Parse the XML file
+                    parser = AppleHealthParser()
+                    parser.parse_file(file_path, db_path)
+                    
+                    # Upload the SQLite database (second commit)
+                    api.upload_file(
+                        path_or_fileobj=db_path,
+                        path_in_repo="health_data.db",
+                        repo_id=dataset_repo_id,
+                        repo_type="dataset",
+                        token=token,
+                        commit_message="Add parsed SQLite database"
+                    )
+                
                 # Create README for dataset
                 dataset_readme = f"""# Apple Health Data
 
 This is a private dataset containing Apple Health export data for {username}.
 
 ## Files
-- `export.xml`: The Apple Health export file
+- `export.xml`: The original Apple Health export file
+- `health_data.db`: SQLite database with parsed health data
 
 ## Associated MCP Server
 - Space: [{space_repo_id}](https://huggingface.co/spaces/{space_repo_id})
@@ -131,7 +153,7 @@ This dataset is private and contains personal health information. Do not share a
                 # Create MCP server app.py
                 mcp_app_content = f'''import gradio as gr
 from huggingface_hub import hf_hub_download
-import xml.etree.ElementTree as ET
+import sqlite3
 import pandas as pd
 from datetime import datetime
 import json
@@ -139,64 +161,98 @@ import json
 # Download the health data
 DATA_REPO = "{dataset_repo_id}"
 
-def load_health_data():
-    """Load and parse the Apple Health export.xml file."""
+def get_db_connection():
+    """Get a connection to the SQLite database."""
+    # Download the health_data.db file from the dataset
+    db_path = hf_hub_download(
+        repo_id=DATA_REPO,
+        filename="health_data.db",
+        repo_type="dataset",
+        use_auth_token=True
+    )
+    return sqlite3.connect(db_path)
+
+def query_health_data(query_type, start_date=None, end_date=None):
+    """Query the health data based on user input."""
     try:
-        # Download the export.xml file from the dataset
-        file_path = hf_hub_download(
-            repo_id=DATA_REPO,
-            filename="export.xml",
-            repo_type="dataset",
-            use_auth_token=True
-        )
+        conn = get_db_connection()
         
-        # Parse the XML file
-        tree = ET.parse(file_path)
-        root = tree.getroot()
+        if query_type == "summary":
+            # Get summary statistics
+            summary = {{}}
+            
+            # Total records
+            total_records = pd.read_sql_query("SELECT COUNT(*) as count FROM records", conn).iloc[0]['count']
+            summary["Total Records"] = total_records
+            
+            # Record types distribution
+            record_types = pd.read_sql_query(
+                "SELECT type, COUNT(*) as count FROM records GROUP BY type ORDER BY count DESC LIMIT 20", 
+                conn
+            )
+            summary["Top Record Types"] = record_types.set_index('type')['count'].to_dict()
+            
+            # Date range
+            date_range = pd.read_sql_query(
+                "SELECT MIN(start_date) as min_date, MAX(start_date) as max_date FROM records", 
+                conn
+            )
+            summary["Date Range"] = f"{{date_range.iloc[0]['min_date']}} to {{date_range.iloc[0]['max_date']}}"
+            
+            # Workouts count
+            workout_count = pd.read_sql_query("SELECT COUNT(*) as count FROM workouts", conn).iloc[0]['count']
+            summary["Total Workouts"] = workout_count
+            
+            conn.close()
+            return json.dumps(summary, indent=2)
+        
+        elif query_type == "recent":
+            # Build query with date filters
+            query = "SELECT type, value, unit, start_date FROM records"
+            conditions = []
+            
+            if start_date:
+                conditions.append(f"start_date >= '{{start_date}}'")
+            if end_date:
+                conditions.append(f"start_date <= '{{end_date}}'")
+            
+            if conditions:
+                query += " WHERE " + " AND ".join(conditions)
+            
+            query += " ORDER BY start_date DESC LIMIT 20"
+            
+            # Get recent records
+            recent_records = pd.read_sql_query(query, conn)
+            
+            conn.close()
+            return json.dumps(recent_records.to_dict('records'), indent=2)
         
-        # Extract records
-        records = []
-        for record in root.findall('.//Record'):
-            records.append(record.attrib)
+        elif query_type == "workouts":
+            # Get recent workouts
+            query = "SELECT workout_activity_type, duration, total_energy_burned, start_date FROM workouts"
+            conditions = []
+            
+            if start_date:
+                conditions.append(f"start_date >= '{{start_date}}'")
+            if end_date:
+                conditions.append(f"start_date <= '{{end_date}}'")
+            
+            if conditions:
+                query += " WHERE " + " AND ".join(conditions)
+            
+            query += " ORDER BY start_date DESC LIMIT 20"
+            
+            workouts = pd.read_sql_query(query, conn)
+            
+            conn.close()
+            return json.dumps(workouts.to_dict('records'), indent=2)
         
-        return pd.DataFrame(records)
+        else:
+            conn.close()
+            return "Invalid query type"
+            
     except Exception as e:
-        return None
-
-# Load data on startup
-health_df = load_health_data()
-
-def query_health_data(query_type, start_date=None, end_date=None):
-    """Query the health data based on user input."""
-    if health_df is None:
-        return "Error: Could not load health data."
-    
-    df = health_df.copy()
-    
-    # Filter by date if provided
-    if start_date:
-        df = df[df['startDate'] >= start_date]
-    if end_date:
-        df = df[df['endDate'] <= end_date]
-    
-    if query_type == "summary":
-        # Get summary statistics
-        summary = {{
-            "Total Records": len(df),
-            "Record Types": df['type'].value_counts().to_dict() if 'type' in df.columns else {{}},
-            "Date Range": f"{{df['startDate'].min()}} to {{df['endDate'].max()}}" if 'startDate' in df.columns else "N/A"
-        }}
-        return json.dumps(summary, indent=2)
-    
-    elif query_type == "recent":
-        # Get recent records
-        if 'startDate' in df.columns:
-            recent = df.nlargest(10, 'startDate')[['type', 'value', 'startDate', 'unit']].to_dict('records')
-            return json.dumps(recent, indent=2)
-        return "No date information available"
-    
-    else:
-        return "Invalid query type"
+        return f"Error querying database: {{str(e)}}"
 
 # MCP Server Interface
 with gr.Blocks(title="Apple Health MCP Server") as demo:
@@ -205,7 +261,7 @@ with gr.Blocks(title="Apple Health MCP Server") as demo:
     
     with gr.Tab("Query Interface"):
         query_type = gr.Dropdown(
-            choices=["summary", "recent"],
+            choices=["summary", "recent", "workouts"],
             value="summary",
             label="Query Type"
         )
@@ -278,9 +334,10 @@ pandas>=2.0.0
 
 **Private Dataset:** [{dataset_repo_id}]({dataset_url})
 - Your export.xml file has been securely uploaded
+- SQLite database (health_data.db) has been generated from your data
 
 **MCP Server Space:** [{space_repo_id}]({space_url})
-- Query interface for your health data
+- Query interface for your health data using SQLite
 - MCP endpoint configuration included
 
 Both repositories are private and only accessible by you."""

pyproject.toml

@@ -7,6 +7,9 @@ requires-python = ">=3.12"
 dependencies = [
     "gradio>=5.34.0",
     "huggingface-hub>=0.33.0",
+    "lxml>=5.4.0",
+    "sqlmodel>=0.0.24",
+    "tqdm>=4.67.1",
 ]
 
 [dependency-groups]

src/parser/models.py

@@ -0,0 +1,402 @@
+from datetime import datetime
+from enum import Enum
+from typing import TYPE_CHECKING, Optional
+
+from sqlmodel import Field, Relationship, SQLModel
+
+if TYPE_CHECKING:
+    pass
+
+
+# Enums for known types
+class BiologicalSex(str, Enum):
+    MALE = "HKBiologicalSexMale"
+    FEMALE = "HKBiologicalSexFemale"
+    OTHER = "HKBiologicalSexOther"
+    NOT_SET = "HKBiologicalSexNotSet"
+
+
+class BloodType(str, Enum):
+    A_POSITIVE = "HKBloodTypeAPositive"
+    A_NEGATIVE = "HKBloodTypeANegative"
+    B_POSITIVE = "HKBloodTypeBPositive"
+    B_NEGATIVE = "HKBloodTypeBNegative"
+    AB_POSITIVE = "HKBloodTypeABPositive"
+    AB_NEGATIVE = "HKBloodTypeABNegative"
+    O_POSITIVE = "HKBloodTypeOPositive"
+    O_NEGATIVE = "HKBloodTypeONegative"
+    NOT_SET = "HKBloodTypeNotSet"
+
+
+class EyeSide(str, Enum):
+    LEFT = "left"
+    RIGHT = "right"
+
+
+# Base Models
+class TimestampedBase(SQLModel):
+    """Base model for entities with date tracking"""
+
+    start_date: datetime = Field(index=True)  # Indexed for date range queries
+    end_date: datetime = Field(index=True)
+    creation_date: datetime | None = None
+
+
+class SourcedBase(TimestampedBase):
+    """Base model for entities with source tracking"""
+
+    source_name: str
+    source_version: str | None = None
+    device: str | None = None
+
+
+# Main Models
+class HealthData(SQLModel, table=True):
+    """Root health data container"""
+
+    id: int | None = Field(default=None, primary_key=True)
+    locale: str
+    export_date: datetime
+
+    # Personal info
+    date_of_birth: str
+    biological_sex: str
+    blood_type: str
+    fitzpatrick_skin_type: str
+    cardio_fitness_medications_use: str
+
+    # Relationships
+    records: list["Record"] = Relationship(back_populates="health_data")
+    correlations: list["Correlation"] = Relationship(back_populates="health_data")
+    workouts: list["Workout"] = Relationship(back_populates="health_data")
+    activity_summaries: list["ActivitySummary"] = Relationship(
+        back_populates="health_data"
+    )
+    clinical_records: list["ClinicalRecord"] = Relationship(
+        back_populates="health_data"
+    )
+    audiograms: list["Audiogram"] = Relationship(back_populates="health_data")
+    vision_prescriptions: list["VisionPrescription"] = Relationship(
+        back_populates="health_data"
+    )
+
+
+class MetadataEntry(SQLModel, table=True):
+    """Key-value metadata entries with proper polymorphic pattern"""
+
+    id: int | None = Field(default=None, primary_key=True)
+    key: str = Field(index=True)
+    value: str
+
+    # Polymorphic discriminator and ID
+    parent_type: str = Field(index=True)  # 'record', 'correlation', 'workout', etc.
+    parent_id: int = Field(index=True)
+
+
+class CorrelationRecord(SQLModel, table=True):
+    """Link table for Correlation-Record many-to-many"""
+
+    correlation_id: int = Field(foreign_key="correlation.id", primary_key=True)
+    record_id: int = Field(foreign_key="record.id", primary_key=True)
+
+
+class Record(SourcedBase, table=True):
+    """Generic health record"""
+
+    id: int | None = Field(default=None, primary_key=True)
+    type: str = Field(index=True)  # Indexed for filtering
+    unit: str | None = None
+    value: str | None = None
+
+    # Foreign key
+    health_data_id: int | None = Field(
+        default=None, foreign_key="healthdata.id", index=True
+    )
+    health_data: HealthData | None = Relationship(back_populates="records")
+
+    # Relationships
+    heart_rate_variability_list: Optional["HeartRateVariabilityMetadataList"] = (
+        Relationship(back_populates="record")
+    )
+
+    # Many-to-many with correlations
+    correlations: list["Correlation"] = Relationship(
+        back_populates="records", link_model=CorrelationRecord
+    )
+
+
+class Correlation(SourcedBase, table=True):
+    """Groups related records together"""
+
+    id: int | None = Field(default=None, primary_key=True)
+    type: str = Field(index=True)
+
+    # Foreign key
+    health_data_id: int | None = Field(
+        default=None, foreign_key="healthdata.id", index=True
+    )
+    health_data: HealthData | None = Relationship(back_populates="correlations")
+
+    # Relationships
+    records: list[Record] = Relationship(
+        back_populates="correlations", link_model=CorrelationRecord
+    )
+
+
+class HeartRateVariabilityMetadataList(SQLModel, table=True):
+    """Container for HRV instantaneous readings"""
+
+    id: int | None = Field(default=None, primary_key=True)
+
+    # Foreign key
+    record_id: int = Field(
+        foreign_key="record.id", unique=True, index=True
+    )  # One-to-one
+    record: Record = Relationship(back_populates="heart_rate_variability_list")
+
+    # Relationships
+    instantaneous_bpm: list["InstantaneousBeatsPerMinute"] = Relationship(
+        back_populates="hrv_list"
+    )
+
+
+class InstantaneousBeatsPerMinute(SQLModel, table=True):
+    """Individual heart rate reading"""
+
+    id: int | None = Field(default=None, primary_key=True)
+    bpm: int
+    time: datetime
+
+    # Foreign key
+    hrv_list_id: int = Field(
+        foreign_key="heartratevariabilitymetadatalist.id", index=True
+    )
+    hrv_list: HeartRateVariabilityMetadataList = Relationship(
+        back_populates="instantaneous_bpm"
+    )
+
+
+class Workout(SourcedBase, table=True):
+    """Workout activity record"""
+
+    id: int | None = Field(default=None, primary_key=True)
+    workout_activity_type: str = Field(index=True)
+    duration: float | None = None
+    duration_unit: str | None = None
+    total_distance: float | None = None
+    total_distance_unit: str | None = None
+    total_energy_burned: float | None = None
+    total_energy_burned_unit: str | None = None
+
+    # Foreign key
+    health_data_id: int | None = Field(
+        default=None, foreign_key="healthdata.id", index=True
+    )
+    health_data: HealthData | None = Relationship(back_populates="workouts")
+
+    # Relationships
+    events: list["WorkoutEvent"] = Relationship(back_populates="workout")
+    statistics: list["WorkoutStatistics"] = Relationship(back_populates="workout")
+    route: Optional["WorkoutRoute"] = Relationship(back_populates="workout")
+
+
+class WorkoutEvent(SQLModel, table=True):
+    """Event during a workout"""
+
+    id: int | None = Field(default=None, primary_key=True)
+    type: str
+    date: datetime = Field(index=True)
+    duration: float | None = None
+    duration_unit: str | None = None
+
+    # Foreign key
+    workout_id: int = Field(foreign_key="workout.id", index=True)
+    workout: Workout = Relationship(back_populates="events")
+
+
+class WorkoutStatistics(TimestampedBase, table=True):
+    """Statistics for a workout period"""
+
+    id: int | None = Field(default=None, primary_key=True)
+    type: str = Field(index=True)
+    average: float | None = None
+    minimum: float | None = None
+    maximum: float | None = None
+    sum: float | None = None
+    unit: str | None = None
+
+    # Foreign key
+    workout_id: int = Field(foreign_key="workout.id", index=True)
+    workout: Workout = Relationship(back_populates="statistics")
+
+
+class WorkoutRoute(SourcedBase, table=True):
+    """GPS route for workout"""
+
+    id: int | None = Field(default=None, primary_key=True)
+
+    # Foreign key
+    workout_id: int = Field(
+        foreign_key="workout.id", unique=True, index=True
+    )  # One-to-one
+    workout: Workout = Relationship(back_populates="route")
+
+    # File reference
+    file_path: str | None = None
+
+
+class ActivitySummary(SQLModel, table=True):
+    """Daily activity summary"""
+
+    id: int | None = Field(default=None, primary_key=True)
+    date_components: str = Field(
+        index=True, unique=True
+    )  # Indexed and unique for date lookups
+    active_energy_burned: float | None = None
+    active_energy_burned_goal: float | None = None
+    active_energy_burned_unit: str | None = None
+    apple_move_time: float | None = None
+    apple_move_time_goal: float | None = None
+    apple_exercise_time: float | None = None
+    apple_exercise_time_goal: float | None = None
+    apple_stand_hours: int | None = None
+    apple_stand_hours_goal: int | None = None
+
+    # Foreign key
+    health_data_id: int | None = Field(
+        default=None, foreign_key="healthdata.id", index=True
+    )
+    health_data: HealthData | None = Relationship(back_populates="activity_summaries")
+
+
+class ClinicalRecord(SQLModel, table=True):
+    """FHIR clinical record reference"""
+
+    id: int | None = Field(default=None, primary_key=True)
+    type: str
+    identifier: str
+    source_name: str
+    source_url: str
+    fhir_version: str
+    received_date: datetime
+    resource_file_path: str
+
+    # Foreign key
+    health_data_id: int | None = Field(default=None, foreign_key="healthdata.id")
+    health_data: HealthData | None = Relationship(back_populates="clinical_records")
+
+
+class Audiogram(SourcedBase, table=True):
+    """Hearing test data"""
+
+    id: int | None = Field(default=None, primary_key=True)
+    type: str
+
+    # Foreign key
+    health_data_id: int | None = Field(
+        default=None, foreign_key="healthdata.id", index=True
+    )
+    health_data: HealthData | None = Relationship(back_populates="audiograms")
+
+    # Relationships
+    sensitivity_points: list["SensitivityPoint"] = Relationship(
+        back_populates="audiogram"
+    )
+
+
+class SensitivityPoint(SQLModel, table=True):
+    """Hearing sensitivity measurement"""
+
+    id: int | None = Field(default=None, primary_key=True)
+    frequency_value: float
+    frequency_unit: str
+
+    # Left ear measurements
+    left_ear_value: float | None = None
+    left_ear_unit: str | None = None
+    left_ear_masked: bool | None = None
+    left_ear_clamping_range_lower_bound: float | None = None
+    left_ear_clamping_range_upper_bound: float | None = None
+
+    # Right ear measurements
+    right_ear_value: float | None = None
+    right_ear_unit: str | None = None
+    right_ear_masked: bool | None = None
+    right_ear_clamping_range_lower_bound: float | None = None
+    right_ear_clamping_range_upper_bound: float | None = None
+
+    # Foreign key
+    audiogram_id: int = Field(foreign_key="audiogram.id", index=True)
+    audiogram: Audiogram = Relationship(back_populates="sensitivity_points")
+
+
+class VisionPrescription(SQLModel, table=True):
+    """Eye prescription data"""
+
+    id: int | None = Field(default=None, primary_key=True)
+    type: str
+    date_issued: datetime
+    expiration_date: datetime | None = None
+    brand: str | None = None
+
+    # Foreign key
+    health_data_id: int | None = Field(
+        default=None, foreign_key="healthdata.id", index=True
+    )
+    health_data: HealthData | None = Relationship(back_populates="vision_prescriptions")
+
+    # Relationships
+    eye_prescriptions: list["EyePrescription"] = Relationship(
+        back_populates="vision_prescription"
+    )
+    attachments: list["VisionAttachment"] = Relationship(
+        back_populates="vision_prescription"
+    )
+
+
+class EyePrescription(SQLModel, table=True):
+    """Individual eye prescription data"""
+
+    id: int | None = Field(default=None, primary_key=True)
+    eye_side: EyeSide
+
+    # Prescription values
+    sphere: float | None = None
+    sphere_unit: str | None = None
+    cylinder: float | None = None
+    cylinder_unit: str | None = None
+    axis: float | None = None
+    axis_unit: str | None = None
+    add: float | None = None
+    add_unit: str | None = None
+    vertex: float | None = None
+    vertex_unit: str | None = None
+    prism_amount: float | None = None
+    prism_amount_unit: str | None = None
+    prism_angle: float | None = None
+    prism_angle_unit: str | None = None
+    far_pd: float | None = None
+    far_pd_unit: str | None = None
+    near_pd: float | None = None
+    near_pd_unit: str | None = None
+    base_curve: float | None = None
+    base_curve_unit: str | None = None
+    diameter: float | None = None
+    diameter_unit: str | None = None
+
+    # Foreign key
+    vision_prescription_id: int = Field(foreign_key="visionprescription.id", index=True)
+    vision_prescription: VisionPrescription = Relationship(
+        back_populates="eye_prescriptions"
+    )
+
+
+class VisionAttachment(SQLModel, table=True):
+    """Attachment reference for vision prescription"""
+
+    id: int | None = Field(default=None, primary_key=True)
+    identifier: str | None = None
+
+    # Foreign key
+    vision_prescription_id: int = Field(foreign_key="visionprescription.id", index=True)
+    vision_prescription: VisionPrescription = Relationship(back_populates="attachments")

src/parser/parser.py

@@ -0,0 +1,1215 @@
+import os
+from datetime import datetime, timedelta
+from pathlib import Path
+from typing import Any
+from zoneinfo import ZoneInfo
+
+from lxml import etree  # type: ignore[import-untyped]
+from sqlmodel import Session, SQLModel, create_engine, select
+from tqdm import tqdm
+
+from .models import (
+    ActivitySummary,
+    Audiogram,
+    ClinicalRecord,
+    Correlation,
+    CorrelationRecord,
+    EyePrescription,
+    EyeSide,
+    HealthData,
+    HeartRateVariabilityMetadataList,
+    InstantaneousBeatsPerMinute,
+    MetadataEntry,
+    Record,
+    SensitivityPoint,
+    VisionAttachment,
+    VisionPrescription,
+    Workout,
+    WorkoutEvent,
+    WorkoutRoute,
+    WorkoutStatistics,
+)
+
+
+class AppleHealthParser:
+    """Parser for Apple Health export XML files with streaming support."""
+
+    def __init__(self, db_path: str = "data/sqlite.db", bulk_mode: bool = True, data_cutoff: timedelta = timedelta(days=180)):
+        """Initialize parser with database connection.
+        
+        Args:
+            db_path: Path to SQLite database
+            bulk_mode: Enable bulk processing for better performance
+            data_cutoff: Only process records newer than this timedelta (default: 6 months)
+        """
+        # Create data directory if it doesn't exist
+        Path(db_path).parent.mkdir(parents=True, exist_ok=True)
+
+        # Create database engine
+        self.engine = create_engine(f"sqlite:///{db_path}")
+        SQLModel.metadata.create_all(self.engine)
+
+        # Add performance indexes
+        self._create_indexes()
+
+        # Batch processing settings
+        self.bulk_mode = bulk_mode
+        self.batch_size = 5000 if bulk_mode else 1000
+        self.transaction_batch_size = 100  # Commit every N entities
+        self.current_batch: list[Any] = []
+        self.pending_commits = 0
+
+        # Data filtering settings
+        self.data_cutoff = data_cutoff
+        self.cutoff_date = datetime.now(ZoneInfo("Europe/Zurich")) - data_cutoff
+
+        # Bulk processing collections
+        self.records_batch: list[Record] = []
+        self.workouts_batch: list[Workout] = []
+        self.correlations_batch: list[Correlation] = []
+        self.metadata_batch: list[MetadataEntry] = []
+
+        # Maps for deferred ID resolution
+        self.record_temp_ids: dict[str, int] = {}  # temp_id -> actual_id
+        self.workout_temp_ids: dict[str, int] = {}
+        self.correlation_temp_ids: dict[str, int] = {}
+        self.temp_id_counter = 0
+
+        self.stats = {
+            "records": 0,
+            "workouts": 0,
+            "correlations": 0,
+            "activity_summaries": 0,
+            "clinical_records": 0,
+            "audiograms": 0,
+            "vision_prescriptions": 0,
+            "metadata_entries": 0,
+            "hrv_lists": 0,
+            "correlation_records": 0,
+            "errors": 0,
+            "duplicates": 0,
+            "filtered_old": 0,
+        }
+
+    def parse_file(self, xml_path: str) -> None:
+        """Parse Apple Health export XML file using streaming."""
+        print(f"Starting to parse: {xml_path}")
+
+        # Check if file exists
+        if not os.path.exists(xml_path):
+            raise FileNotFoundError(f"XML file not found: {xml_path}")
+
+        # Get file size for progress tracking
+        file_size = os.path.getsize(xml_path)
+        print(f"File size: {file_size / (1024**3):.2f} GB")
+
+        # Clear events to free memory during parsing
+        context = etree.iterparse(
+            xml_path,
+            events=("start", "end"),
+            tag=None,  # Process all tags
+            huge_tree=True,  # Enable parsing of large files
+        )
+
+        # Make iterator return start-end event pairs
+        context = iter(context)
+
+        # Skip to root element
+        event, root = next(context)
+
+        # Current element being processed
+        health_data: HealthData | None = None
+        current_correlation: Correlation | None = None
+        current_workout: Workout | None = None
+        current_audiogram: Audiogram | None = None
+        current_vision_prescription: VisionPrescription | None = None
+        current_record: Record | None = None
+        current_hrv_list: HeartRateVariabilityMetadataList | None = None
+
+        # Track parent elements for metadata
+        current_parent_type: str | None = None
+        current_parent_id: int | None = None
+
+        with Session(self.engine) as session:
+            try:
+                # Process root element first
+                if root.tag == "HealthData":
+                    # Check if HealthData already exists
+                    existing_health_data = session.exec(select(HealthData)).first()
+                    if existing_health_data:
+                        health_data = existing_health_data
+                        print(
+                            f"Using existing HealthData record with ID: {health_data.id}"
+                        )
+                    else:
+                        health_data = self._parse_health_data(root)
+                        session.add(health_data)
+                        session.commit()
+                        print(f"Created HealthData record with ID: {health_data.id}")
+
+                # Create progress bar
+                pbar = tqdm(desc="Processing", unit=" elements", miniters=1000)
+
+                for event, elem in context:
+                    if event == "start":
+                        # Update progress bar
+                        pbar.update(1)
+
+                        # Update description with current stats every 5000 records
+                        total_processed = (
+                            self.stats["records"] + self.stats["duplicates"] + self.stats["filtered_old"]
+                        )
+                        if total_processed % 5000 == 0 and total_processed > 0:
+                            pbar.set_description(
+                                f"Records: {self.stats['records']:,} | "
+                                f"Duplicates: {self.stats['duplicates']:,} | "
+                                f"Filtered: {self.stats['filtered_old']:,} | "
+                                f"Errors: {self.stats['errors']:,}"
+                            )
+
+                        try:
+                            if elem.tag == "HealthData" and not health_data:
+                                # Check if HealthData already exists
+                                existing_health_data = session.exec(
+                                    select(HealthData)
+                                ).first()
+                                if existing_health_data:
+                                    health_data = existing_health_data
+                                else:
+                                    health_data = self._parse_health_data(elem)
+                                    session.add(health_data)
+                                    session.commit()
+
+                            elif elem.tag == "ExportDate" and health_data:
+                                # Update health_data with export date
+                                export_date_str = elem.get("value")
+                                if export_date_str:
+                                    health_data.export_date = self._parse_datetime(
+                                        export_date_str
+                                    )
+                                    session.add(health_data)
+                                    session.commit()
+
+                            elif elem.tag == "Me" and health_data:
+                                # Update health_data with personal info
+                                health_data.date_of_birth = elem.get(
+                                    "HKCharacteristicTypeIdentifierDateOfBirth", ""
+                                )
+                                health_data.biological_sex = elem.get(
+                                    "HKCharacteristicTypeIdentifierBiologicalSex", ""
+                                )
+                                health_data.blood_type = elem.get(
+                                    "HKCharacteristicTypeIdentifierBloodType", ""
+                                )
+                                health_data.fitzpatrick_skin_type = elem.get(
+                                    "HKCharacteristicTypeIdentifierFitzpatrickSkinType",
+                                    "",
+                                )
+                                health_data.cardio_fitness_medications_use = elem.get(
+                                    "HKCharacteristicTypeIdentifierCardioFitnessMedicationsUse",
+                                    "",
+                                )
+                                session.add(health_data)
+                                session.commit()
+
+                            elif (
+                                elem.tag == "Record" and health_data and health_data.id
+                            ):
+                                record = self._parse_record(elem, health_data.id)
+
+                                # Filter by cutoff date
+                                if record.start_date < self.cutoff_date:
+                                    self.stats["filtered_old"] += 1
+                                    continue
+
+                                # Check if inside a correlation - always use individual processing
+                                if current_correlation and current_correlation.id:
+                                    existing = self._check_duplicate_record(
+                                        session, record
+                                    )
+                                    if existing:
+                                        self.stats["duplicates"] += 1
+                                        record = existing
+                                    else:
+                                        session.add(record)
+                                        session.commit()
+
+                                    if record.id:
+                                        existing_link = (
+                                            self._check_duplicate_correlation_record(
+                                                session,
+                                                current_correlation.id,
+                                                record.id,
+                                            )
+                                        )
+                                        if not existing_link:
+                                            link = CorrelationRecord(
+                                                correlation_id=current_correlation.id,
+                                                record_id=record.id,
+                                            )
+                                            self._add_to_batch(session, link)
+                                            self.stats["correlation_records"] += 1
+                                else:
+                                    # Regular records - check for duplicate and use batched commits
+                                    existing = self._check_duplicate_record(
+                                        session, record
+                                    )
+                                    if existing:
+                                        self.stats["duplicates"] += 1
+                                        current_record = existing
+                                        current_parent_type = "record"
+                                        current_parent_id = existing.id
+                                    else:
+                                        session.add(record)
+                                        self.pending_commits += 1
+                                        current_record = record
+                                        current_parent_type = "record"
+                                        # Defer commit for batching
+                                        if (
+                                            self.pending_commits
+                                            >= self.transaction_batch_size
+                                        ):
+                                            session.commit()
+                                            self.pending_commits = 0
+                                        else:
+                                            session.flush()  # Get ID without committing
+                                        current_parent_id = record.id
+                                        self.stats["records"] += 1
+
+                            elif (
+                                elem.tag == "Correlation"
+                                and health_data
+                                and health_data.id
+                            ):
+                                correlation = self._parse_correlation(
+                                    elem, health_data.id
+                                )
+
+                                # Filter by cutoff date
+                                if correlation.start_date < self.cutoff_date:
+                                    self.stats["filtered_old"] += 1
+                                    continue
+
+                                # Check for duplicate
+                                existing = self._check_duplicate_correlation(
+                                    session, correlation
+                                )
+                                if existing:
+                                    self.stats["duplicates"] += 1
+                                    current_correlation = existing
+                                else:
+                                    session.add(correlation)
+                                    self.pending_commits += 1
+                                    current_correlation = correlation
+                                    # Defer commit for batching
+                                    if (
+                                        self.pending_commits
+                                        >= self.transaction_batch_size
+                                    ):
+                                        session.commit()
+                                        self.pending_commits = 0
+                                    else:
+                                        session.flush()  # Get ID without committing
+                                    self.stats["correlations"] += 1
+
+                                current_parent_type = "correlation"
+                                current_parent_id = current_correlation.id
+
+                            elif (
+                                elem.tag == "Workout" and health_data and health_data.id
+                            ):
+                                workout = self._parse_workout(elem, health_data.id)
+
+                                # Filter by cutoff date
+                                if workout.start_date < self.cutoff_date:
+                                    self.stats["filtered_old"] += 1
+                                    continue
+
+                                # Check for duplicate
+                                existing = self._check_duplicate_workout(
+                                    session, workout
+                                )
+                                if existing:
+                                    self.stats["duplicates"] += 1
+                                    current_workout = existing
+                                else:
+                                    session.add(workout)
+                                    self.pending_commits += 1
+                                    current_workout = workout
+                                    # Defer commit for batching
+                                    if (
+                                        self.pending_commits
+                                        >= self.transaction_batch_size
+                                    ):
+                                        session.commit()
+                                        self.pending_commits = 0
+                                    else:
+                                        session.flush()  # Get ID without committing
+                                    self.stats["workouts"] += 1
+
+                                current_parent_type = "workout"
+                                current_parent_id = current_workout.id
+
+                            elif (
+                                elem.tag == "ActivitySummary"
+                                and health_data
+                                and health_data.id
+                            ):
+                                summary = self._parse_activity_summary(
+                                    elem, health_data.id
+                                )
+
+                                # Check for duplicate
+                                existing = self._check_duplicate_activity_summary(
+                                    session, summary
+                                )
+                                if existing:
+                                    self.stats["duplicates"] += 1
+                                else:
+                                    self._add_to_batch(session, summary)
+                                    self.stats["activity_summaries"] += 1
+
+                            elif (
+                                elem.tag == "ClinicalRecord"
+                                and health_data
+                                and health_data.id
+                            ):
+                                clinical = self._parse_clinical_record(
+                                    elem, health_data.id
+                                )
+
+                                # Check for duplicate
+                                existing = self._check_duplicate_clinical_record(
+                                    session, clinical
+                                )
+                                if existing:
+                                    self.stats["duplicates"] += 1
+                                else:
+                                    self._add_to_batch(session, clinical)
+                                    self.stats["clinical_records"] += 1
+
+                            elif (
+                                elem.tag == "Audiogram"
+                                and health_data
+                                and health_data.id
+                            ):
+                                audiogram = self._parse_audiogram(elem, health_data.id)
+
+                                # Filter by cutoff date
+                                if audiogram.start_date < self.cutoff_date:
+                                    self.stats["filtered_old"] += 1
+                                    continue
+
+                                # Check for duplicate
+                                existing = self._check_duplicate_audiogram(
+                                    session, audiogram
+                                )
+                                if existing:
+                                    self.stats["duplicates"] += 1
+                                    current_audiogram = existing
+                                else:
+                                    session.add(audiogram)
+                                    session.commit()
+                                    current_audiogram = audiogram
+                                    self.stats["audiograms"] += 1
+
+                            elif (
+                                elem.tag == "VisionPrescription"
+                                and health_data
+                                and health_data.id
+                            ):
+                                prescription = self._parse_vision_prescription(
+                                    elem, health_data.id
+                                )
+
+                                # Check for duplicate
+                                existing = self._check_duplicate_vision_prescription(
+                                    session, prescription
+                                )
+                                if existing:
+                                    self.stats["duplicates"] += 1
+                                    current_vision_prescription = existing
+                                else:
+                                    session.add(prescription)
+                                    session.commit()
+                                    current_vision_prescription = prescription
+                                    self.stats["vision_prescriptions"] += 1
+
+                            elif (
+                                elem.tag == "MetadataEntry"
+                                and current_parent_type
+                                and current_parent_id
+                            ):
+                                metadata = self._parse_metadata_entry(
+                                    elem, current_parent_type, current_parent_id
+                                )
+                                self._add_to_batch(session, metadata)
+                                self.stats["metadata_entries"] += 1
+
+                            elif (
+                                elem.tag == "HeartRateVariabilityMetadataList"
+                                and current_record
+                                and current_record.id
+                            ):
+                                # Check for existing HRV list
+                                existing_hrv = self._check_duplicate_hrv_list(
+                                    session, current_record.id
+                                )
+                                if existing_hrv:
+                                    current_hrv_list = existing_hrv
+                                    self.stats["duplicates"] += 1
+                                else:
+                                    current_hrv_list = self._parse_hrv_list(
+                                        current_record.id
+                                    )
+                                    session.add(current_hrv_list)
+                                    session.commit()  # Need ID for relationships
+                                    self.stats["hrv_lists"] += 1
+
+                            # Handle nested elements
+                            elif (
+                                elem.tag == "WorkoutEvent"
+                                and current_workout
+                                and current_workout.id
+                            ):
+                                event_obj = self._parse_workout_event(
+                                    elem, current_workout.id
+                                )
+                                self._add_to_batch(session, event_obj)
+
+                            elif (
+                                elem.tag == "WorkoutStatistics"
+                                and current_workout
+                                and current_workout.id
+                            ):
+                                stat = self._parse_workout_statistics(
+                                    elem, current_workout.id
+                                )
+                                self._add_to_batch(session, stat)
+
+                            elif (
+                                elem.tag == "WorkoutRoute"
+                                and current_workout
+                                and current_workout.id
+                            ):
+                                route = self._parse_workout_route(
+                                    elem, current_workout.id
+                                )
+
+                                # Check for duplicate WorkoutRoute
+                                existing = self._check_duplicate_workout_route(
+                                    session, route
+                                )
+                                if existing:
+                                    self.stats["duplicates"] += 1
+                                else:
+                                    session.add(route)
+                                    session.commit()  # Immediate commit due to unique constraint
+
+                            elif (
+                                elem.tag == "SensitivityPoint"
+                                and current_audiogram
+                                and current_audiogram.id
+                            ):
+                                point = self._parse_sensitivity_point(
+                                    elem, current_audiogram.id
+                                )
+                                self._add_to_batch(session, point)
+
+                            elif (
+                                elem.tag == "Prescription"
+                                and current_vision_prescription
+                                and current_vision_prescription.id
+                            ):
+                                prescription = self._parse_eye_prescription(
+                                    elem, current_vision_prescription.id
+                                )
+                                self._add_to_batch(session, prescription)
+
+                            elif (
+                                elem.tag == "Attachment"
+                                and current_vision_prescription
+                                and current_vision_prescription.id
+                            ):
+                                attachment = self._parse_vision_attachment(
+                                    elem, current_vision_prescription.id
+                                )
+                                self._add_to_batch(session, attachment)
+
+                            elif (
+                                elem.tag == "InstantaneousBeatsPerMinute"
+                                and current_hrv_list
+                                and current_hrv_list.id
+                            ):
+                                bpm = self._parse_instantaneous_bpm(
+                                    elem, current_hrv_list.id, current_record.start_date if current_record else None
+                                )
+                                self._add_to_batch(session, bpm)
+
+                        except Exception as e:
+                            self.stats["errors"] += 1
+                            if self.stats["errors"] <= 10:  # Only print first 10 errors
+                                print(f"Error parsing {elem.tag}: {e}")
+
+                    elif event == "end":
+                        # Clear completed elements
+                        if elem.tag == "Correlation":
+                            current_correlation = None
+                            current_parent_type = None
+                            current_parent_id = None
+                        elif elem.tag == "Workout":
+                            current_workout = None
+                            current_parent_type = None
+                            current_parent_id = None
+                        elif elem.tag == "Audiogram":
+                            current_audiogram = None
+                        elif elem.tag == "VisionPrescription":
+                            current_vision_prescription = None
+                        elif elem.tag == "Record" and not current_correlation:
+                            current_record = None
+                            current_parent_type = None
+                            current_parent_id = None
+                        elif elem.tag == "HeartRateVariabilityMetadataList":
+                            current_hrv_list = None
+
+                        # Clear the element to free memory
+                        elem.clear()
+                        # Also remove preceding siblings
+                        while elem.getprevious() is not None:
+                            del elem.getparent()[0]
+
+                # Final commit for any pending transactions
+                if self.pending_commits > 0:
+                    session.commit()
+                    self.pending_commits = 0
+
+                # Flush any remaining batches
+                self._flush_all_batches(session)
+                pbar.close()
+
+            except Exception as e:
+                pbar.close()
+                print(f"Fatal error during parsing: {e}")
+                raise
+
+        # Final statistics
+        self._print_progress()
+        print(f"Parsing complete! Data cutoff: {self.cutoff_date.isoformat()}")
+
+    def _add_to_batch(self, session: Session, obj: Any) -> None:
+        """Add object to batch and flush if necessary."""
+        self.current_batch.append(obj)
+        if len(self.current_batch) >= self.batch_size:
+            self._flush_batch(session)
+
+    def _flush_batch(self, session: Session) -> None:
+        """Flush current batch to database."""
+        if self.current_batch:
+            session.add_all(self.current_batch)
+            session.commit()
+            self.current_batch = []
+
+    def _create_indexes(self) -> None:
+        """Create database indexes for performance."""
+        from sqlalchemy import text
+
+        with Session(self.engine) as session:
+            # Indexes for duplicate checking
+            indexes = [
+                "CREATE INDEX IF NOT EXISTS idx_record_duplicate ON record (type, start_date, end_date, health_data_id, value)",
+                "CREATE INDEX IF NOT EXISTS idx_workout_duplicate ON workout (workout_activity_type, start_date, end_date, health_data_id)",
+                "CREATE INDEX IF NOT EXISTS idx_correlation_duplicate ON correlation (type, start_date, end_date, health_data_id)",
+                "CREATE INDEX IF NOT EXISTS idx_activity_summary_duplicate ON activitysummary (date_components, health_data_id)",
+                "CREATE INDEX IF NOT EXISTS idx_clinical_record_duplicate ON clinicalrecord (identifier, health_data_id)",
+                "CREATE INDEX IF NOT EXISTS idx_audiogram_duplicate ON audiogram (type, start_date, end_date, health_data_id)",
+                "CREATE INDEX IF NOT EXISTS idx_vision_prescription_duplicate ON visionprescription (type, date_issued, health_data_id)",
+                "CREATE INDEX IF NOT EXISTS idx_correlation_record_duplicate ON correlationrecord (correlation_id, record_id)",
+            ]
+            for index_sql in indexes:
+                try:
+                    session.execute(text(index_sql))
+                except Exception as e:
+                    print(f"Index creation warning: {e}")
+            session.commit()
+
+    def _bulk_insert_records(self, session: Session) -> None:
+        """Bulk insert records with batch duplicate checking."""
+        if not self.records_batch:
+            return
+
+        # Group records by type for efficient duplicate checking
+        records_by_type: dict[tuple[str | None, int], list[Record]] = {}
+        for record in self.records_batch:
+            key = (record.type, record.health_data_id or 0)
+            if key not in records_by_type:
+                records_by_type[key] = []
+            records_by_type[key].append(record)
+
+        new_records = []
+        for (record_type, health_data_id), type_records in records_by_type.items():
+            # Batch check for existing records of this type
+            start_dates = [r.start_date for r in type_records]
+            end_dates = [r.end_date for r in type_records]
+
+            # Build query conditions
+            stmt = select(Record).where(
+                Record.type == record_type,
+                Record.health_data_id == health_data_id,
+            )
+
+            if start_dates:
+                from sqlalchemy import or_
+
+                date_conditions = []
+                for i, (start_date, end_date) in enumerate(zip(start_dates, end_dates)):
+                    date_conditions.append(
+                        (Record.start_date == start_date)
+                        & (Record.end_date == end_date)
+                    )
+                if date_conditions:
+                    stmt = stmt.where(or_(*date_conditions))
+
+            existing_records = session.exec(stmt).all()
+
+            # Create lookup set for existing records
+            existing_set: set[tuple[datetime, datetime, str | None]] = set()
+            for existing in existing_records:
+                lookup_key = (existing.start_date, existing.end_date, existing.value)
+                existing_set.add(lookup_key)
+
+            # Filter out duplicates
+            for record in type_records:
+                record_key = (record.start_date, record.end_date, record.value)
+                if record_key in existing_set:
+                    self.stats["duplicates"] += 1
+                else:
+                    new_records.append(record)
+
+        if new_records:
+            session.add_all(new_records)
+            session.commit()
+            self.stats["records"] += len(new_records)
+
+        self.records_batch = []
+
+    def _bulk_insert_workouts(self, session: Session) -> None:
+        """Bulk insert workouts with duplicate checking."""
+        if not self.workouts_batch:
+            return
+
+        new_workouts = []
+        for workout in self.workouts_batch:
+            existing = self._check_duplicate_workout(session, workout)
+            if existing:
+                self.stats["duplicates"] += 1
+            else:
+                new_workouts.append(workout)
+
+        if new_workouts:
+            session.add_all(new_workouts)
+            session.commit()
+            self.stats["workouts"] += len(new_workouts)
+
+        self.workouts_batch = []
+
+    def _bulk_insert_correlations(self, session: Session) -> None:
+        """Bulk insert correlations with duplicate checking."""
+        if not self.correlations_batch:
+            return
+
+        new_correlations = []
+        for correlation in self.correlations_batch:
+            existing = self._check_duplicate_correlation(session, correlation)
+            if existing:
+                self.stats["duplicates"] += 1
+            else:
+                new_correlations.append(correlation)
+
+        if new_correlations:
+            session.add_all(new_correlations)
+            session.commit()
+            self.stats["correlations"] += len(new_correlations)
+
+        self.correlations_batch = []
+
+    def _flush_all_batches(self, session: Session) -> None:
+        """Flush all bulk batches to database."""
+        if self.bulk_mode:
+            self._bulk_insert_records(session)
+            self._bulk_insert_workouts(session)
+            self._bulk_insert_correlations(session)
+            session.commit()
+        self._flush_batch(session)  # Handle remaining objects
+
+    def _print_progress(self) -> None:
+        """Print current parsing progress."""
+        print("Final Statistics:")
+        for key, value in self.stats.items():
+            print(f"  {key}: {value:,}")
+
+    # Duplicate checking methods
+    def _check_duplicate_record(
+        self, session: Session, record: Record
+    ) -> Record | None:
+        """Check if a record already exists."""
+        stmt = select(Record).where(
+            Record.type == record.type,
+            Record.start_date == record.start_date,
+            Record.end_date == record.end_date,
+            Record.health_data_id == record.health_data_id,
+        )
+
+        # Also check value if present
+        if record.value is not None:
+            stmt = stmt.where(Record.value == record.value)
+        else:
+            stmt = stmt.where(Record.value.is_(None))
+
+        return session.exec(stmt).first()
+
+    def _check_duplicate_workout(
+        self, session: Session, workout: Workout
+    ) -> Workout | None:
+        """Check if a workout already exists."""
+        return session.exec(
+            select(Workout).where(
+                Workout.workout_activity_type == workout.workout_activity_type,
+                Workout.start_date == workout.start_date,
+                Workout.end_date == workout.end_date,
+                Workout.health_data_id == workout.health_data_id,
+            )
+        ).first()
+
+    def _check_duplicate_correlation(
+        self, session: Session, correlation: Correlation
+    ) -> Correlation | None:
+        """Check if a correlation already exists."""
+        return session.exec(
+            select(Correlation).where(
+                Correlation.type == correlation.type,
+                Correlation.start_date == correlation.start_date,
+                Correlation.end_date == correlation.end_date,
+                Correlation.health_data_id == correlation.health_data_id,
+            )
+        ).first()
+
+    def _check_duplicate_activity_summary(
+        self, session: Session, summary: ActivitySummary
+    ) -> ActivitySummary | None:
+        """Check if an activity summary already exists."""
+        return session.exec(
+            select(ActivitySummary).where(
+                ActivitySummary.date_components == summary.date_components,
+                ActivitySummary.health_data_id == summary.health_data_id,
+            )
+        ).first()
+
+    def _check_duplicate_clinical_record(
+        self, session: Session, record: ClinicalRecord
+    ) -> ClinicalRecord | None:
+        """Check if a clinical record already exists."""
+        return session.exec(
+            select(ClinicalRecord).where(
+                ClinicalRecord.identifier == record.identifier,
+                ClinicalRecord.health_data_id == record.health_data_id,
+            )
+        ).first()
+
+    def _check_duplicate_audiogram(
+        self, session: Session, audiogram: Audiogram
+    ) -> Audiogram | None:
+        """Check if an audiogram already exists."""
+        return session.exec(
+            select(Audiogram).where(
+                Audiogram.type == audiogram.type,
+                Audiogram.start_date == audiogram.start_date,
+                Audiogram.end_date == audiogram.end_date,
+                Audiogram.health_data_id == audiogram.health_data_id,
+            )
+        ).first()
+
+    def _check_duplicate_vision_prescription(
+        self, session: Session, prescription: VisionPrescription
+    ) -> VisionPrescription | None:
+        """Check if a vision prescription already exists."""
+        return session.exec(
+            select(VisionPrescription).where(
+                VisionPrescription.type == prescription.type,
+                VisionPrescription.date_issued == prescription.date_issued,
+                VisionPrescription.health_data_id == prescription.health_data_id,
+            )
+        ).first()
+
+    def _check_duplicate_correlation_record(
+        self, session: Session, correlation_id: int, record_id: int
+    ) -> CorrelationRecord | None:
+        """Check if a correlation-record link already exists."""
+        return session.exec(
+            select(CorrelationRecord).where(
+                CorrelationRecord.correlation_id == correlation_id,
+                CorrelationRecord.record_id == record_id,
+            )
+        ).first()
+
+    def _check_duplicate_workout_route(
+        self, session: Session, route: WorkoutRoute
+    ) -> WorkoutRoute | None:
+        """Check if a workout route already exists."""
+        return session.exec(
+            select(WorkoutRoute).where(
+                WorkoutRoute.workout_id == route.workout_id,
+            )
+        ).first()
+
+    def _check_duplicate_hrv_list(
+        self, session: Session, record_id: int
+    ) -> HeartRateVariabilityMetadataList | None:
+        """Check if an HRV list already exists for this record."""
+        return session.exec(
+            select(HeartRateVariabilityMetadataList).where(
+                HeartRateVariabilityMetadataList.record_id == record_id,
+            )
+        ).first()
+
+    # Parsing methods remain the same
+    def _parse_datetime(self, date_str: str, base_date: datetime | None = None) -> datetime:
+        """Parse datetime string from Apple Health format.
+        
+        Args:
+            date_str: The datetime or time string to parse
+            base_date: Base date to use for time-only strings (for InstantaneousBeatsPerMinute)
+        """
+        # Check if this is a time-only format like "7:47:41.86 PM"
+        if base_date and ("AM" in date_str or "PM" in date_str) and ":" in date_str and "-" not in date_str:
+            # Parse time-only format and combine with base date
+            try:
+                # Handle formats like "7:47:41.86 PM"
+                time_part = datetime.strptime(date_str, "%I:%M:%S.%f %p").time()
+            except ValueError:
+                try:
+                    # Fallback for formats like "7:47:41 PM" (no microseconds)
+                    time_part = datetime.strptime(date_str, "%I:%M:%S %p").time()
+                except ValueError:
+                    # If all fails, try without seconds
+                    time_part = datetime.strptime(date_str, "%I:%M %p").time()
+            
+            # Combine with base date
+            combined = datetime.combine(base_date.date(), time_part)
+            # Use the same timezone as base_date
+            return combined.replace(tzinfo=base_date.tzinfo)
+        else:
+            # Apple Health standard format: "2023-12-31 23:59:59 +0000"
+            dt = datetime.strptime(date_str, "%Y-%m-%d %H:%M:%S %z")
+            # Convert to preferred timezone
+            return dt.astimezone(ZoneInfo("Europe/Zurich"))
+
+    def _parse_health_data(self, elem: Any) -> HealthData:
+        """Parse HealthData root element."""
+        # HealthData only has locale attribute
+        # ExportDate and Me are child elements that we'll handle separately
+        return HealthData(
+            locale=elem.get("locale", ""),
+            export_date=datetime.now(
+                ZoneInfo("Europe/Zurich")
+            ),  # Will be updated by ExportDate element
+            date_of_birth="",  # Will be updated by Me element
+            biological_sex="",  # Will be updated by Me element
+            blood_type="",  # Will be updated by Me element
+            fitzpatrick_skin_type="",  # Will be updated by Me element
+            cardio_fitness_medications_use="",  # Will be updated by Me element
+        )
+
+    def _parse_record(self, elem: Any, health_data_id: int) -> Record:
+        """Parse Record element."""
+        return Record(
+            type=elem.get("type"),
+            source_name=elem.get("sourceName"),
+            source_version=elem.get("sourceVersion"),
+            device=elem.get("device"),
+            unit=elem.get("unit"),
+            value=elem.get("value"),
+            creation_date=self._parse_datetime(elem.get("creationDate"))
+            if elem.get("creationDate")
+            else None,
+            start_date=self._parse_datetime(elem.get("startDate")),
+            end_date=self._parse_datetime(elem.get("endDate")),
+            health_data_id=health_data_id,
+        )
+
+    def _parse_correlation(self, elem: Any, health_data_id: int) -> Correlation:
+        """Parse Correlation element."""
+        return Correlation(
+            type=elem.get("type"),
+            source_name=elem.get("sourceName"),
+            source_version=elem.get("sourceVersion"),
+            device=elem.get("device"),
+            creation_date=self._parse_datetime(elem.get("creationDate"))
+            if elem.get("creationDate")
+            else None,
+            start_date=self._parse_datetime(elem.get("startDate")),
+            end_date=self._parse_datetime(elem.get("endDate")),
+            health_data_id=health_data_id,
+        )
+
+    def _parse_workout(self, elem: Any, health_data_id: int) -> Workout:
+        """Parse Workout element."""
+        return Workout(
+            workout_activity_type=elem.get("workoutActivityType"),
+            duration=float(elem.get("duration")) if elem.get("duration") else None,
+            duration_unit=elem.get("durationUnit"),
+            total_distance=float(elem.get("totalDistance"))
+            if elem.get("totalDistance")
+            else None,
+            total_distance_unit=elem.get("totalDistanceUnit"),
+            total_energy_burned=float(elem.get("totalEnergyBurned"))
+            if elem.get("totalEnergyBurned")
+            else None,
+            total_energy_burned_unit=elem.get("totalEnergyBurnedUnit"),
+            source_name=elem.get("sourceName"),
+            source_version=elem.get("sourceVersion"),
+            device=elem.get("device"),
+            creation_date=self._parse_datetime(elem.get("creationDate"))
+            if elem.get("creationDate")
+            else None,
+            start_date=self._parse_datetime(elem.get("startDate")),
+            end_date=self._parse_datetime(elem.get("endDate")),
+            health_data_id=health_data_id,
+        )
+
+    def _parse_activity_summary(
+        self, elem: Any, health_data_id: int
+    ) -> ActivitySummary:
+        """Parse ActivitySummary element."""
+        return ActivitySummary(
+            date_components=elem.get("dateComponents"),
+            active_energy_burned=float(elem.get("activeEnergyBurned"))
+            if elem.get("activeEnergyBurned")
+            else None,
+            active_energy_burned_goal=float(elem.get("activeEnergyBurnedGoal"))
+            if elem.get("activeEnergyBurnedGoal")
+            else None,
+            active_energy_burned_unit=elem.get("activeEnergyBurnedUnit"),
+            apple_move_time=float(elem.get("appleMoveTime"))
+            if elem.get("appleMoveTime")
+            else None,
+            apple_move_time_goal=float(elem.get("appleMoveTimeGoal"))
+            if elem.get("appleMoveTimeGoal")
+            else None,
+            apple_exercise_time=float(elem.get("appleExerciseTime"))
+            if elem.get("appleExerciseTime")
+            else None,
+            apple_exercise_time_goal=float(elem.get("appleExerciseTimeGoal"))
+            if elem.get("appleExerciseTimeGoal")
+            else None,
+            apple_stand_hours=int(elem.get("appleStandHours"))
+            if elem.get("appleStandHours")
+            else None,
+            apple_stand_hours_goal=int(elem.get("appleStandHoursGoal"))
+            if elem.get("appleStandHoursGoal")
+            else None,
+            health_data_id=health_data_id,
+        )
+
+    def _parse_clinical_record(self, elem: Any, health_data_id: int) -> ClinicalRecord:
+        """Parse ClinicalRecord element."""
+        return ClinicalRecord(
+            type=elem.get("type"),
+            identifier=elem.get("identifier"),
+            source_name=elem.get("sourceName"),
+            source_url=elem.get("sourceURL"),
+            fhir_version=elem.get("fhirVersion"),
+            received_date=self._parse_datetime(elem.get("receivedDate")),
+            resource_file_path=elem.get("resourceFilePath"),
+            health_data_id=health_data_id,
+        )
+
+    def _parse_audiogram(self, elem: Any, health_data_id: int) -> Audiogram:
+        """Parse Audiogram element."""
+        return Audiogram(
+            type=elem.get("type"),
+            source_name=elem.get("sourceName"),
+            source_version=elem.get("sourceVersion"),
+            device=elem.get("device"),
+            creation_date=self._parse_datetime(elem.get("creationDate"))
+            if elem.get("creationDate")
+            else None,
+            start_date=self._parse_datetime(elem.get("startDate")),
+            end_date=self._parse_datetime(elem.get("endDate")),
+            health_data_id=health_data_id,
+        )
+
+    def _parse_vision_prescription(
+        self, elem: Any, health_data_id: int
+    ) -> VisionPrescription:
+        """Parse VisionPrescription element."""
+        return VisionPrescription(
+            type=elem.get("type"),
+            date_issued=self._parse_datetime(elem.get("dateIssued")),
+            expiration_date=self._parse_datetime(elem.get("expirationDate"))
+            if elem.get("expirationDate")
+            else None,
+            brand=elem.get("brand"),
+            health_data_id=health_data_id,
+        )
+
+    def _parse_workout_event(self, elem: Any, workout_id: int) -> WorkoutEvent:
+        """Parse WorkoutEvent element."""
+        return WorkoutEvent(
+            type=elem.get("type"),
+            date=self._parse_datetime(elem.get("date")),
+            duration=float(elem.get("duration")) if elem.get("duration") else None,
+            duration_unit=elem.get("durationUnit"),
+            workout_id=workout_id,
+        )
+
+    def _parse_workout_statistics(
+        self, elem: Any, workout_id: int
+    ) -> WorkoutStatistics:
+        """Parse WorkoutStatistics element."""
+        return WorkoutStatistics(
+            type=elem.get("type"),
+            start_date=self._parse_datetime(elem.get("startDate")),
+            end_date=self._parse_datetime(elem.get("endDate")),
+            average=float(elem.get("average")) if elem.get("average") else None,
+            minimum=float(elem.get("minimum")) if elem.get("minimum") else None,
+            maximum=float(elem.get("maximum")) if elem.get("maximum") else None,
+            sum=float(elem.get("sum")) if elem.get("sum") else None,
+            unit=elem.get("unit"),
+            workout_id=workout_id,
+        )
+
+    def _parse_workout_route(self, elem: Any, workout_id: int) -> WorkoutRoute:
+        """Parse WorkoutRoute element."""
+        return WorkoutRoute(
+            source_name=elem.get("sourceName"),
+            source_version=elem.get("sourceVersion"),
+            device=elem.get("device"),
+            creation_date=self._parse_datetime(elem.get("creationDate"))
+            if elem.get("creationDate")
+            else None,
+            start_date=self._parse_datetime(elem.get("startDate")),
+            end_date=self._parse_datetime(elem.get("endDate")),
+            file_path=elem.get("filePath"),
+            workout_id=workout_id,
+        )
+
+    def _parse_sensitivity_point(
+        self, elem: Any, audiogram_id: int
+    ) -> SensitivityPoint:
+        """Parse SensitivityPoint element."""
+        return SensitivityPoint(
+            frequency_value=float(elem.get("frequencyValue")),
+            frequency_unit=elem.get("frequencyUnit"),
+            left_ear_value=float(elem.get("leftEarValue"))
+            if elem.get("leftEarValue")
+            else None,
+            left_ear_unit=elem.get("leftEarUnit"),
+            left_ear_masked=elem.get("leftEarMasked") == "true"
+            if elem.get("leftEarMasked")
+            else None,
+            left_ear_clamping_range_lower_bound=float(
+                elem.get("leftEarClampingRangeLowerBound")
+            )
+            if elem.get("leftEarClampingRangeLowerBound")
+            else None,
+            left_ear_clamping_range_upper_bound=float(
+                elem.get("leftEarClampingRangeUpperBound")
+            )
+            if elem.get("leftEarClampingRangeUpperBound")
+            else None,
+            right_ear_value=float(elem.get("rightEarValue"))
+            if elem.get("rightEarValue")
+            else None,
+            right_ear_unit=elem.get("rightEarUnit"),
+            right_ear_masked=elem.get("rightEarMasked") == "true"
+            if elem.get("rightEarMasked")
+            else None,
+            right_ear_clamping_range_lower_bound=float(
+                elem.get("rightEarClampingRangeLowerBound")
+            )
+            if elem.get("rightEarClampingRangeLowerBound")
+            else None,
+            right_ear_clamping_range_upper_bound=float(
+                elem.get("rightEarClampingRangeUpperBound")
+            )
+            if elem.get("rightEarClampingRangeUpperBound")
+            else None,
+            audiogram_id=audiogram_id,
+        )
+
+    def _parse_eye_prescription(
+        self, elem: Any, vision_prescription_id: int
+    ) -> EyePrescription:
+        """Parse Prescription (eye) element."""
+        eye_side = EyeSide.LEFT if elem.get("eye") == "left" else EyeSide.RIGHT
+
+        return EyePrescription(
+            eye_side=eye_side,
+            sphere=float(elem.get("sphere")) if elem.get("sphere") else None,
+            sphere_unit=elem.get("sphereUnit"),
+            cylinder=float(elem.get("cylinder")) if elem.get("cylinder") else None,
+            cylinder_unit=elem.get("cylinderUnit"),
+            axis=float(elem.get("axis")) if elem.get("axis") else None,
+            axis_unit=elem.get("axisUnit"),
+            add=float(elem.get("add")) if elem.get("add") else None,
+            add_unit=elem.get("addUnit"),
+            vertex=float(elem.get("vertex")) if elem.get("vertex") else None,
+            vertex_unit=elem.get("vertexUnit"),
+            prism_amount=float(elem.get("prismAmount"))
+            if elem.get("prismAmount")
+            else None,
+            prism_amount_unit=elem.get("prismAmountUnit"),
+            prism_angle=float(elem.get("prismAngle"))
+            if elem.get("prismAngle")
+            else None,
+            prism_angle_unit=elem.get("prismAngleUnit"),
+            far_pd=float(elem.get("farPD")) if elem.get("farPD") else None,
+            far_pd_unit=elem.get("farPDUnit"),
+            near_pd=float(elem.get("nearPD")) if elem.get("nearPD") else None,
+            near_pd_unit=elem.get("nearPDUnit"),
+            base_curve=float(elem.get("baseCurve")) if elem.get("baseCurve") else None,
+            base_curve_unit=elem.get("baseCurveUnit"),
+            diameter=float(elem.get("diameter")) if elem.get("diameter") else None,
+            diameter_unit=elem.get("diameterUnit"),
+            vision_prescription_id=vision_prescription_id,
+        )
+
+    def _parse_vision_attachment(
+        self, elem: Any, vision_prescription_id: int
+    ) -> VisionAttachment:
+        """Parse Attachment element."""
+        return VisionAttachment(
+            identifier=elem.get("identifier"),
+            vision_prescription_id=vision_prescription_id,
+        )
+
+    def _parse_metadata_entry(
+        self, elem: Any, parent_type: str, parent_id: int
+    ) -> MetadataEntry:
+        """Parse MetadataEntry element."""
+        return MetadataEntry(
+            key=elem.get("key"),
+            value=elem.get("value"),
+            parent_type=parent_type,
+            parent_id=parent_id,
+        )
+
+    def _parse_hrv_list(self, record_id: int) -> HeartRateVariabilityMetadataList:
+        """Parse HeartRateVariabilityMetadataList element."""
+        return HeartRateVariabilityMetadataList(record_id=record_id)
+
+    def _parse_instantaneous_bpm(
+        self, elem: Any, hrv_list_id: int, base_date: datetime | None = None
+    ) -> InstantaneousBeatsPerMinute:
+        """Parse InstantaneousBeatsPerMinute element."""
+        return InstantaneousBeatsPerMinute(
+            bpm=int(elem.get("bpm")),
+            time=self._parse_datetime(elem.get("time"), base_date),
+            hrv_list_id=hrv_list_id,
+        )
+
+
+if __name__ == "__main__":
+    # Example usage
+    parser = AppleHealthParser()
+    parser.parse_file("data/export.xml")

uv.lock

@@ -44,6 +44,9 @@ source = { virtual = "." }
 dependencies = [
     { name = "gradio" },
     { name = "huggingface-hub" },
+    { name = "lxml" },
+    { name = "sqlmodel" },
+    { name = "tqdm" },
 ]
 
 [package.dev-dependencies]
@@ -58,6 +61,9 @@ dev = [
 requires-dist = [
     { name = "gradio", specifier = ">=5.34.0" },
     { name = "huggingface-hub", specifier = ">=0.33.0" },
+    { name = "lxml", specifier = ">=5.4.0" },
+    { name = "sqlmodel", specifier = ">=0.0.24" },
+    { name = "tqdm", specifier = ">=4.67.1" },
 ]
 
 [package.metadata.requires-dev]
@@ -271,6 +277,39 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/ea/72/1e76abc821f8efaaeb2e3bd727a6c97bf87c6a9a0ffacfed0647e587824a/gradio_client-1.10.3-py3-none-any.whl", hash = "sha256:941e7f8d9a160f88487e9780a3db2736a40ea2b8b69d53ffdb306e47ef658b76", size = 323599 },
 ]
 
+[[package]]
+name = "greenlet"
+version = "3.2.3"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/c9/92/bb85bd6e80148a4d2e0c59f7c0c2891029f8fd510183afc7d8d2feeed9b6/greenlet-3.2.3.tar.gz", hash = "sha256:8b0dd8ae4c0d6f5e54ee55ba935eeb3d735a9b58a8a1e5b5cbab64e01a39f365", size = 185752 }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/f3/94/ad0d435f7c48debe960c53b8f60fb41c2026b1d0fa4a99a1cb17c3461e09/greenlet-3.2.3-cp312-cp312-macosx_11_0_universal2.whl", hash = "sha256:25ad29caed5783d4bd7a85c9251c651696164622494c00802a139c00d639242d", size = 271992 },
+    { url = "https://files.pythonhosted.org/packages/93/5d/7c27cf4d003d6e77749d299c7c8f5fd50b4f251647b5c2e97e1f20da0ab5/greenlet-3.2.3-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:88cd97bf37fe24a6710ec6a3a7799f3f81d9cd33317dcf565ff9950c83f55e0b", size = 638820 },
+    { url = "https://files.pythonhosted.org/packages/c6/7e/807e1e9be07a125bb4c169144937910bf59b9d2f6d931578e57f0bce0ae2/greenlet-3.2.3-cp312-cp312-manylinux2014_ppc64le.manylinux_2_17_ppc64le.whl", hash = "sha256:baeedccca94880d2f5666b4fa16fc20ef50ba1ee353ee2d7092b383a243b0b0d", size = 653046 },
+    { url = "https://files.pythonhosted.org/packages/9d/ab/158c1a4ea1068bdbc78dba5a3de57e4c7aeb4e7fa034320ea94c688bfb61/greenlet-3.2.3-cp312-cp312-manylinux2014_s390x.manylinux_2_17_s390x.whl", hash = "sha256:be52af4b6292baecfa0f397f3edb3c6092ce071b499dd6fe292c9ac9f2c8f264", size = 647701 },
+    { url = "https://files.pythonhosted.org/packages/cc/0d/93729068259b550d6a0288da4ff72b86ed05626eaf1eb7c0d3466a2571de/greenlet-3.2.3-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:0cc73378150b8b78b0c9fe2ce56e166695e67478550769536a6742dca3651688", size = 649747 },
+    { url = "https://files.pythonhosted.org/packages/f6/f6/c82ac1851c60851302d8581680573245c8fc300253fc1ff741ae74a6c24d/greenlet-3.2.3-cp312-cp312-manylinux_2_24_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:706d016a03e78df129f68c4c9b4c4f963f7d73534e48a24f5f5a7101ed13dbbb", size = 605461 },
+    { url = "https://files.pythonhosted.org/packages/98/82/d022cf25ca39cf1200650fc58c52af32c90f80479c25d1cbf57980ec3065/greenlet-3.2.3-cp312-cp312-musllinux_1_1_aarch64.whl", hash = "sha256:419e60f80709510c343c57b4bb5a339d8767bf9aef9b8ce43f4f143240f88b7c", size = 1121190 },
+    { url = "https://files.pythonhosted.org/packages/f5/e1/25297f70717abe8104c20ecf7af0a5b82d2f5a980eb1ac79f65654799f9f/greenlet-3.2.3-cp312-cp312-musllinux_1_1_x86_64.whl", hash = "sha256:93d48533fade144203816783373f27a97e4193177ebaaf0fc396db19e5d61163", size = 1149055 },
+    { url = "https://files.pythonhosted.org/packages/1f/8f/8f9e56c5e82eb2c26e8cde787962e66494312dc8cb261c460e1f3a9c88bc/greenlet-3.2.3-cp312-cp312-win_amd64.whl", hash = "sha256:7454d37c740bb27bdeddfc3f358f26956a07d5220818ceb467a483197d84f849", size = 297817 },
+    { url = "https://files.pythonhosted.org/packages/b1/cf/f5c0b23309070ae93de75c90d29300751a5aacefc0a3ed1b1d8edb28f08b/greenlet-3.2.3-cp313-cp313-macosx_11_0_universal2.whl", hash = "sha256:500b8689aa9dd1ab26872a34084503aeddefcb438e2e7317b89b11eaea1901ad", size = 270732 },
+    { url = "https://files.pythonhosted.org/packages/48/ae/91a957ba60482d3fecf9be49bc3948f341d706b52ddb9d83a70d42abd498/greenlet-3.2.3-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:a07d3472c2a93117af3b0136f246b2833fdc0b542d4a9799ae5f41c28323faef", size = 639033 },
+    { url = "https://files.pythonhosted.org/packages/6f/df/20ffa66dd5a7a7beffa6451bdb7400d66251374ab40b99981478c69a67a8/greenlet-3.2.3-cp313-cp313-manylinux2014_ppc64le.manylinux_2_17_ppc64le.whl", hash = "sha256:8704b3768d2f51150626962f4b9a9e4a17d2e37c8a8d9867bbd9fa4eb938d3b3", size = 652999 },
+    { url = "https://files.pythonhosted.org/packages/51/b4/ebb2c8cb41e521f1d72bf0465f2f9a2fd803f674a88db228887e6847077e/greenlet-3.2.3-cp313-cp313-manylinux2014_s390x.manylinux_2_17_s390x.whl", hash = "sha256:5035d77a27b7c62db6cf41cf786cfe2242644a7a337a0e155c80960598baab95", size = 647368 },
+    { url = "https://files.pythonhosted.org/packages/8e/6a/1e1b5aa10dced4ae876a322155705257748108b7fd2e4fae3f2a091fe81a/greenlet-3.2.3-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:2d8aa5423cd4a396792f6d4580f88bdc6efcb9205891c9d40d20f6e670992efb", size = 650037 },
+    { url = "https://files.pythonhosted.org/packages/26/f2/ad51331a157c7015c675702e2d5230c243695c788f8f75feba1af32b3617/greenlet-3.2.3-cp313-cp313-manylinux_2_24_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:2c724620a101f8170065d7dded3f962a2aea7a7dae133a009cada42847e04a7b", size = 608402 },
+    { url = "https://files.pythonhosted.org/packages/26/bc/862bd2083e6b3aff23300900a956f4ea9a4059de337f5c8734346b9b34fc/greenlet-3.2.3-cp313-cp313-musllinux_1_1_aarch64.whl", hash = "sha256:873abe55f134c48e1f2a6f53f7d1419192a3d1a4e873bace00499a4e45ea6af0", size = 1119577 },
+    { url = "https://files.pythonhosted.org/packages/86/94/1fc0cc068cfde885170e01de40a619b00eaa8f2916bf3541744730ffb4c3/greenlet-3.2.3-cp313-cp313-musllinux_1_1_x86_64.whl", hash = "sha256:024571bbce5f2c1cfff08bf3fbaa43bbc7444f580ae13b0099e95d0e6e67ed36", size = 1147121 },
+    { url = "https://files.pythonhosted.org/packages/27/1a/199f9587e8cb08a0658f9c30f3799244307614148ffe8b1e3aa22f324dea/greenlet-3.2.3-cp313-cp313-win_amd64.whl", hash = "sha256:5195fb1e75e592dd04ce79881c8a22becdfa3e6f500e7feb059b1e6fdd54d3e3", size = 297603 },
+    { url = "https://files.pythonhosted.org/packages/d8/ca/accd7aa5280eb92b70ed9e8f7fd79dc50a2c21d8c73b9a0856f5b564e222/greenlet-3.2.3-cp314-cp314-macosx_11_0_universal2.whl", hash = "sha256:3d04332dddb10b4a211b68111dabaee2e1a073663d117dc10247b5b1642bac86", size = 271479 },
+    { url = "https://files.pythonhosted.org/packages/55/71/01ed9895d9eb49223280ecc98a557585edfa56b3d0e965b9fa9f7f06b6d9/greenlet-3.2.3-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:8186162dffde068a465deab08fc72c767196895c39db26ab1c17c0b77a6d8b97", size = 683952 },
+    { url = "https://files.pythonhosted.org/packages/ea/61/638c4bdf460c3c678a0a1ef4c200f347dff80719597e53b5edb2fb27ab54/greenlet-3.2.3-cp314-cp314-manylinux2014_ppc64le.manylinux_2_17_ppc64le.whl", hash = "sha256:f4bfbaa6096b1b7a200024784217defedf46a07c2eee1a498e94a1b5f8ec5728", size = 696917 },
+    { url = "https://files.pythonhosted.org/packages/22/cc/0bd1a7eb759d1f3e3cc2d1bc0f0b487ad3cc9f34d74da4b80f226fde4ec3/greenlet-3.2.3-cp314-cp314-manylinux2014_s390x.manylinux_2_17_s390x.whl", hash = "sha256:ed6cfa9200484d234d8394c70f5492f144b20d4533f69262d530a1a082f6ee9a", size = 692443 },
+    { url = "https://files.pythonhosted.org/packages/67/10/b2a4b63d3f08362662e89c103f7fe28894a51ae0bc890fabf37d1d780e52/greenlet-3.2.3-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:02b0df6f63cd15012bed5401b47829cfd2e97052dc89da3cfaf2c779124eb892", size = 692995 },
+    { url = "https://files.pythonhosted.org/packages/5a/c6/ad82f148a4e3ce9564056453a71529732baf5448ad53fc323e37efe34f66/greenlet-3.2.3-cp314-cp314-manylinux_2_24_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:86c2d68e87107c1792e2e8d5399acec2487a4e993ab76c792408e59394d52141", size = 655320 },
+    { url = "https://files.pythonhosted.org/packages/5c/4f/aab73ecaa6b3086a4c89863d94cf26fa84cbff63f52ce9bc4342b3087a06/greenlet-3.2.3-cp314-cp314-win_amd64.whl", hash = "sha256:8c47aae8fbbfcf82cc13327ae802ba13c9c36753b67e760023fd116bc124a62a", size = 301236 },
+]
+
 [[package]]
 name = "groovy"
 version = "0.1.2"
@@ -399,6 +438,48 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/62/a1/3d680cbfd5f4b8f15abc1d571870c5fc3e594bb582bc3b64ea099db13e56/jinja2-3.1.6-py3-none-any.whl", hash = "sha256:85ece4451f492d0c13c5dd7c13a64681a86afae63a5f347908daf103ce6d2f67", size = 134899 },
 ]
 
+[[package]]
+name = "lxml"
+version = "5.4.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/76/3d/14e82fc7c8fb1b7761f7e748fd47e2ec8276d137b6acfe5a4bb73853e08f/lxml-5.4.0.tar.gz", hash = "sha256:d12832e1dbea4be280b22fd0ea7c9b87f0d8fc51ba06e92dc62d52f804f78ebd", size = 3679479 }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/f8/4c/d101ace719ca6a4ec043eb516fcfcb1b396a9fccc4fcd9ef593df34ba0d5/lxml-5.4.0-cp312-cp312-macosx_10_9_universal2.whl", hash = "sha256:b5aff6f3e818e6bdbbb38e5967520f174b18f539c2b9de867b1e7fde6f8d95a4", size = 8127392 },
+    { url = "https://files.pythonhosted.org/packages/11/84/beddae0cec4dd9ddf46abf156f0af451c13019a0fa25d7445b655ba5ccb7/lxml-5.4.0-cp312-cp312-macosx_10_9_x86_64.whl", hash = "sha256:942a5d73f739ad7c452bf739a62a0f83e2578afd6b8e5406308731f4ce78b16d", size = 4415103 },
+    { url = "https://files.pythonhosted.org/packages/d0/25/d0d93a4e763f0462cccd2b8a665bf1e4343dd788c76dcfefa289d46a38a9/lxml-5.4.0-cp312-cp312-manylinux_2_12_i686.manylinux2010_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:460508a4b07364d6abf53acaa0a90b6d370fafde5693ef37602566613a9b0779", size = 5024224 },
+    { url = "https://files.pythonhosted.org/packages/31/ce/1df18fb8f7946e7f3388af378b1f34fcf253b94b9feedb2cec5969da8012/lxml-5.4.0-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:529024ab3a505fed78fe3cc5ddc079464e709f6c892733e3f5842007cec8ac6e", size = 4769913 },
+    { url = "https://files.pythonhosted.org/packages/4e/62/f4a6c60ae7c40d43657f552f3045df05118636be1165b906d3423790447f/lxml-5.4.0-cp312-cp312-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:7ca56ebc2c474e8f3d5761debfd9283b8b18c76c4fc0967b74aeafba1f5647f9", size = 5290441 },
+    { url = "https://files.pythonhosted.org/packages/9e/aa/04f00009e1e3a77838c7fc948f161b5d2d5de1136b2b81c712a263829ea4/lxml-5.4.0-cp312-cp312-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:a81e1196f0a5b4167a8dafe3a66aa67c4addac1b22dc47947abd5d5c7a3f24b5", size = 4820165 },
+    { url = "https://files.pythonhosted.org/packages/c9/1f/e0b2f61fa2404bf0f1fdf1898377e5bd1b74cc9b2cf2c6ba8509b8f27990/lxml-5.4.0-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:00b8686694423ddae324cf614e1b9659c2edb754de617703c3d29ff568448df5", size = 4932580 },
+    { url = "https://files.pythonhosted.org/packages/24/a2/8263f351b4ffe0ed3e32ea7b7830f845c795349034f912f490180d88a877/lxml-5.4.0-cp312-cp312-manylinux_2_28_aarch64.whl", hash = "sha256:c5681160758d3f6ac5b4fea370495c48aac0989d6a0f01bb9a72ad8ef5ab75c4", size = 4759493 },
+    { url = "https://files.pythonhosted.org/packages/05/00/41db052f279995c0e35c79d0f0fc9f8122d5b5e9630139c592a0b58c71b4/lxml-5.4.0-cp312-cp312-manylinux_2_28_ppc64le.whl", hash = "sha256:2dc191e60425ad70e75a68c9fd90ab284df64d9cd410ba8d2b641c0c45bc006e", size = 5324679 },
+    { url = "https://files.pythonhosted.org/packages/1d/be/ee99e6314cdef4587617d3b3b745f9356d9b7dd12a9663c5f3b5734b64ba/lxml-5.4.0-cp312-cp312-manylinux_2_28_s390x.whl", hash = "sha256:67f779374c6b9753ae0a0195a892a1c234ce8416e4448fe1e9f34746482070a7", size = 4890691 },
+    { url = "https://files.pythonhosted.org/packages/ad/36/239820114bf1d71f38f12208b9c58dec033cbcf80101cde006b9bde5cffd/lxml-5.4.0-cp312-cp312-manylinux_2_28_x86_64.whl", hash = "sha256:79d5bfa9c1b455336f52343130b2067164040604e41f6dc4d8313867ed540079", size = 4955075 },
+    { url = "https://files.pythonhosted.org/packages/d4/e1/1b795cc0b174efc9e13dbd078a9ff79a58728a033142bc6d70a1ee8fc34d/lxml-5.4.0-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:3d3c30ba1c9b48c68489dc1829a6eede9873f52edca1dda900066542528d6b20", size = 4838680 },
+    { url = "https://files.pythonhosted.org/packages/72/48/3c198455ca108cec5ae3662ae8acd7fd99476812fd712bb17f1b39a0b589/lxml-5.4.0-cp312-cp312-musllinux_1_2_ppc64le.whl", hash = "sha256:1af80c6316ae68aded77e91cd9d80648f7dd40406cef73df841aa3c36f6907c8", size = 5391253 },
+    { url = "https://files.pythonhosted.org/packages/d6/10/5bf51858971c51ec96cfc13e800a9951f3fd501686f4c18d7d84fe2d6352/lxml-5.4.0-cp312-cp312-musllinux_1_2_s390x.whl", hash = "sha256:4d885698f5019abe0de3d352caf9466d5de2baded00a06ef3f1216c1a58ae78f", size = 5261651 },
+    { url = "https://files.pythonhosted.org/packages/2b/11/06710dd809205377da380546f91d2ac94bad9ff735a72b64ec029f706c85/lxml-5.4.0-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:aea53d51859b6c64e7c51d522c03cc2c48b9b5d6172126854cc7f01aa11f52bc", size = 5024315 },
+    { url = "https://files.pythonhosted.org/packages/f5/b0/15b6217834b5e3a59ebf7f53125e08e318030e8cc0d7310355e6edac98ef/lxml-5.4.0-cp312-cp312-win32.whl", hash = "sha256:d90b729fd2732df28130c064aac9bb8aff14ba20baa4aee7bd0795ff1187545f", size = 3486149 },
+    { url = "https://files.pythonhosted.org/packages/91/1e/05ddcb57ad2f3069101611bd5f5084157d90861a2ef460bf42f45cced944/lxml-5.4.0-cp312-cp312-win_amd64.whl", hash = "sha256:1dc4ca99e89c335a7ed47d38964abcb36c5910790f9bd106f2a8fa2ee0b909d2", size = 3817095 },
+    { url = "https://files.pythonhosted.org/packages/87/cb/2ba1e9dd953415f58548506fa5549a7f373ae55e80c61c9041b7fd09a38a/lxml-5.4.0-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:773e27b62920199c6197130632c18fb7ead3257fce1ffb7d286912e56ddb79e0", size = 8110086 },
+    { url = "https://files.pythonhosted.org/packages/b5/3e/6602a4dca3ae344e8609914d6ab22e52ce42e3e1638c10967568c5c1450d/lxml-5.4.0-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:ce9c671845de9699904b1e9df95acfe8dfc183f2310f163cdaa91a3535af95de", size = 4404613 },
+    { url = "https://files.pythonhosted.org/packages/4c/72/bf00988477d3bb452bef9436e45aeea82bb40cdfb4684b83c967c53909c7/lxml-5.4.0-cp313-cp313-manylinux_2_12_i686.manylinux2010_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:9454b8d8200ec99a224df8854786262b1bd6461f4280064c807303c642c05e76", size = 5012008 },
+    { url = "https://files.pythonhosted.org/packages/92/1f/93e42d93e9e7a44b2d3354c462cd784dbaaf350f7976b5d7c3f85d68d1b1/lxml-5.4.0-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:cccd007d5c95279e529c146d095f1d39ac05139de26c098166c4beb9374b0f4d", size = 4760915 },
+    { url = "https://files.pythonhosted.org/packages/45/0b/363009390d0b461cf9976a499e83b68f792e4c32ecef092f3f9ef9c4ba54/lxml-5.4.0-cp313-cp313-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:0fce1294a0497edb034cb416ad3e77ecc89b313cff7adbee5334e4dc0d11f422", size = 5283890 },
+    { url = "https://files.pythonhosted.org/packages/19/dc/6056c332f9378ab476c88e301e6549a0454dbee8f0ae16847414f0eccb74/lxml-5.4.0-cp313-cp313-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:24974f774f3a78ac12b95e3a20ef0931795ff04dbb16db81a90c37f589819551", size = 4812644 },
+    { url = "https://files.pythonhosted.org/packages/ee/8a/f8c66bbb23ecb9048a46a5ef9b495fd23f7543df642dabeebcb2eeb66592/lxml-5.4.0-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:497cab4d8254c2a90bf988f162ace2ddbfdd806fce3bda3f581b9d24c852e03c", size = 4921817 },
+    { url = "https://files.pythonhosted.org/packages/04/57/2e537083c3f381f83d05d9b176f0d838a9e8961f7ed8ddce3f0217179ce3/lxml-5.4.0-cp313-cp313-manylinux_2_28_aarch64.whl", hash = "sha256:e794f698ae4c5084414efea0f5cc9f4ac562ec02d66e1484ff822ef97c2cadff", size = 4753916 },
+    { url = "https://files.pythonhosted.org/packages/d8/80/ea8c4072109a350848f1157ce83ccd9439601274035cd045ac31f47f3417/lxml-5.4.0-cp313-cp313-manylinux_2_28_ppc64le.whl", hash = "sha256:2c62891b1ea3094bb12097822b3d44b93fc6c325f2043c4d2736a8ff09e65f60", size = 5289274 },
+    { url = "https://files.pythonhosted.org/packages/b3/47/c4be287c48cdc304483457878a3f22999098b9a95f455e3c4bda7ec7fc72/lxml-5.4.0-cp313-cp313-manylinux_2_28_s390x.whl", hash = "sha256:142accb3e4d1edae4b392bd165a9abdee8a3c432a2cca193df995bc3886249c8", size = 4874757 },
+    { url = "https://files.pythonhosted.org/packages/2f/04/6ef935dc74e729932e39478e44d8cfe6a83550552eaa072b7c05f6f22488/lxml-5.4.0-cp313-cp313-manylinux_2_28_x86_64.whl", hash = "sha256:1a42b3a19346e5601d1b8296ff6ef3d76038058f311902edd574461e9c036982", size = 4947028 },
+    { url = "https://files.pythonhosted.org/packages/cb/f9/c33fc8daa373ef8a7daddb53175289024512b6619bc9de36d77dca3df44b/lxml-5.4.0-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:4291d3c409a17febf817259cb37bc62cb7eb398bcc95c1356947e2871911ae61", size = 4834487 },
+    { url = "https://files.pythonhosted.org/packages/8d/30/fc92bb595bcb878311e01b418b57d13900f84c2b94f6eca9e5073ea756e6/lxml-5.4.0-cp313-cp313-musllinux_1_2_ppc64le.whl", hash = "sha256:4f5322cf38fe0e21c2d73901abf68e6329dc02a4994e483adbcf92b568a09a54", size = 5381688 },
+    { url = "https://files.pythonhosted.org/packages/43/d1/3ba7bd978ce28bba8e3da2c2e9d5ae3f8f521ad3f0ca6ea4788d086ba00d/lxml-5.4.0-cp313-cp313-musllinux_1_2_s390x.whl", hash = "sha256:0be91891bdb06ebe65122aa6bf3fc94489960cf7e03033c6f83a90863b23c58b", size = 5242043 },
+    { url = "https://files.pythonhosted.org/packages/ee/cd/95fa2201041a610c4d08ddaf31d43b98ecc4b1d74b1e7245b1abdab443cb/lxml-5.4.0-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:15a665ad90054a3d4f397bc40f73948d48e36e4c09f9bcffc7d90c87410e478a", size = 5021569 },
+    { url = "https://files.pythonhosted.org/packages/2d/a6/31da006fead660b9512d08d23d31e93ad3477dd47cc42e3285f143443176/lxml-5.4.0-cp313-cp313-win32.whl", hash = "sha256:d5663bc1b471c79f5c833cffbc9b87d7bf13f87e055a5c86c363ccd2348d7e82", size = 3485270 },
+    { url = "https://files.pythonhosted.org/packages/fc/14/c115516c62a7d2499781d2d3d7215218c0731b2c940753bf9f9b7b73924d/lxml-5.4.0-cp313-cp313-win_amd64.whl", hash = "sha256:bcb7a1096b4b6b24ce1ac24d4942ad98f983cd3810f9711bcd0293f43a9d8b9f", size = 3814606 },
+]
+
 [[package]]
 name = "markdown-it-py"
 version = "3.0.0"
@@ -943,6 +1024,48 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/e9/44/75a9c9421471a6c4805dbf2356f7c181a29c1879239abab1ea2cc8f38b40/sniffio-1.3.1-py3-none-any.whl", hash = "sha256:2f6da418d1f1e0fddd844478f41680e794e6051915791a034ff65e5f100525a2", size = 10235 },
 ]
 
+[[package]]
+name = "sqlalchemy"
+version = "2.0.41"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "greenlet", marker = "(python_full_version < '3.14' and platform_machine == 'AMD64') or (python_full_version < '3.14' and platform_machine == 'WIN32') or (python_full_version < '3.14' and platform_machine == 'aarch64') or (python_full_version < '3.14' and platform_machine == 'amd64') or (python_full_version < '3.14' and platform_machine == 'ppc64le') or (python_full_version < '3.14' and platform_machine == 'win32') or (python_full_version < '3.14' and platform_machine == 'x86_64')" },
+    { name = "typing-extensions" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/63/66/45b165c595ec89aa7dcc2c1cd222ab269bc753f1fc7a1e68f8481bd957bf/sqlalchemy-2.0.41.tar.gz", hash = "sha256:edba70118c4be3c2b1f90754d308d0b79c6fe2c0fdc52d8ddf603916f83f4db9", size = 9689424 }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/3e/2a/f1f4e068b371154740dd10fb81afb5240d5af4aa0087b88d8b308b5429c2/sqlalchemy-2.0.41-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:81f413674d85cfd0dfcd6512e10e0f33c19c21860342a4890c3a2b59479929f9", size = 2119645 },
+    { url = "https://files.pythonhosted.org/packages/9b/e8/c664a7e73d36fbfc4730f8cf2bf930444ea87270f2825efbe17bf808b998/sqlalchemy-2.0.41-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:598d9ebc1e796431bbd068e41e4de4dc34312b7aa3292571bb3674a0cb415dd1", size = 2107399 },
+    { url = "https://files.pythonhosted.org/packages/5c/78/8a9cf6c5e7135540cb682128d091d6afa1b9e48bd049b0d691bf54114f70/sqlalchemy-2.0.41-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:a104c5694dfd2d864a6f91b0956eb5d5883234119cb40010115fd45a16da5e70", size = 3293269 },
+    { url = "https://files.pythonhosted.org/packages/3c/35/f74add3978c20de6323fb11cb5162702670cc7a9420033befb43d8d5b7a4/sqlalchemy-2.0.41-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:6145afea51ff0af7f2564a05fa95eb46f542919e6523729663a5d285ecb3cf5e", size = 3303364 },
+    { url = "https://files.pythonhosted.org/packages/6a/d4/c990f37f52c3f7748ebe98883e2a0f7d038108c2c5a82468d1ff3eec50b7/sqlalchemy-2.0.41-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:b46fa6eae1cd1c20e6e6f44e19984d438b6b2d8616d21d783d150df714f44078", size = 3229072 },
+    { url = "https://files.pythonhosted.org/packages/15/69/cab11fecc7eb64bc561011be2bd03d065b762d87add52a4ca0aca2e12904/sqlalchemy-2.0.41-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:41836fe661cc98abfae476e14ba1906220f92c4e528771a8a3ae6a151242d2ae", size = 3268074 },
+    { url = "https://files.pythonhosted.org/packages/5c/ca/0c19ec16858585d37767b167fc9602593f98998a68a798450558239fb04a/sqlalchemy-2.0.41-cp312-cp312-win32.whl", hash = "sha256:a8808d5cf866c781150d36a3c8eb3adccfa41a8105d031bf27e92c251e3969d6", size = 2084514 },
+    { url = "https://files.pythonhosted.org/packages/7f/23/4c2833d78ff3010a4e17f984c734f52b531a8c9060a50429c9d4b0211be6/sqlalchemy-2.0.41-cp312-cp312-win_amd64.whl", hash = "sha256:5b14e97886199c1f52c14629c11d90c11fbb09e9334fa7bb5f6d068d9ced0ce0", size = 2111557 },
+    { url = "https://files.pythonhosted.org/packages/d3/ad/2e1c6d4f235a97eeef52d0200d8ddda16f6c4dd70ae5ad88c46963440480/sqlalchemy-2.0.41-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:4eeb195cdedaf17aab6b247894ff2734dcead6c08f748e617bfe05bd5a218443", size = 2115491 },
+    { url = "https://files.pythonhosted.org/packages/cf/8d/be490e5db8400dacc89056f78a52d44b04fbf75e8439569d5b879623a53b/sqlalchemy-2.0.41-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:d4ae769b9c1c7757e4ccce94b0641bc203bbdf43ba7a2413ab2523d8d047d8dc", size = 2102827 },
+    { url = "https://files.pythonhosted.org/packages/a0/72/c97ad430f0b0e78efaf2791342e13ffeafcbb3c06242f01a3bb8fe44f65d/sqlalchemy-2.0.41-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:a62448526dd9ed3e3beedc93df9bb6b55a436ed1474db31a2af13b313a70a7e1", size = 3225224 },
+    { url = "https://files.pythonhosted.org/packages/5e/51/5ba9ea3246ea068630acf35a6ba0d181e99f1af1afd17e159eac7e8bc2b8/sqlalchemy-2.0.41-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:dc56c9788617b8964ad02e8fcfeed4001c1f8ba91a9e1f31483c0dffb207002a", size = 3230045 },
+    { url = "https://files.pythonhosted.org/packages/78/2f/8c14443b2acea700c62f9b4a8bad9e49fc1b65cfb260edead71fd38e9f19/sqlalchemy-2.0.41-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:c153265408d18de4cc5ded1941dcd8315894572cddd3c58df5d5b5705b3fa28d", size = 3159357 },
+    { url = "https://files.pythonhosted.org/packages/fc/b2/43eacbf6ccc5276d76cea18cb7c3d73e294d6fb21f9ff8b4eef9b42bbfd5/sqlalchemy-2.0.41-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:4f67766965996e63bb46cfbf2ce5355fc32d9dd3b8ad7e536a920ff9ee422e23", size = 3197511 },
+    { url = "https://files.pythonhosted.org/packages/fa/2e/677c17c5d6a004c3c45334ab1dbe7b7deb834430b282b8a0f75ae220c8eb/sqlalchemy-2.0.41-cp313-cp313-win32.whl", hash = "sha256:bfc9064f6658a3d1cadeaa0ba07570b83ce6801a1314985bf98ec9b95d74e15f", size = 2082420 },
+    { url = "https://files.pythonhosted.org/packages/e9/61/e8c1b9b6307c57157d328dd8b8348ddc4c47ffdf1279365a13b2b98b8049/sqlalchemy-2.0.41-cp313-cp313-win_amd64.whl", hash = "sha256:82ca366a844eb551daff9d2e6e7a9e5e76d2612c8564f58db6c19a726869c1df", size = 2108329 },
+    { url = "https://files.pythonhosted.org/packages/1c/fc/9ba22f01b5cdacc8f5ed0d22304718d2c758fce3fd49a5372b886a86f37c/sqlalchemy-2.0.41-py3-none-any.whl", hash = "sha256:57df5dc6fdb5ed1a88a1ed2195fd31927e705cad62dedd86b46972752a80f576", size = 1911224 },
+]
+
+[[package]]
+name = "sqlmodel"
+version = "0.0.24"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "pydantic" },
+    { name = "sqlalchemy" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/86/4b/c2ad0496f5bdc6073d9b4cef52be9c04f2b37a5773441cc6600b1857648b/sqlmodel-0.0.24.tar.gz", hash = "sha256:cc5c7613c1a5533c9c7867e1aab2fd489a76c9e8a061984da11b4e613c182423", size = 116780 }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/16/91/484cd2d05569892b7fef7f5ceab3bc89fb0f8a8c0cde1030d383dbc5449c/sqlmodel-0.0.24-py3-none-any.whl", hash = "sha256:6778852f09370908985b667d6a3ab92910d0d5ec88adcaf23dbc242715ff7193", size = 28622 },
+]
+
 [[package]]
 name = "starlette"
 version = "0.46.2"