omop-lite 0.0.17__py3-none-any.whl → 0.1.0__py3-none-any.whl

omop_lite/__init__.py

@@ -1,37 +0,0 @@
-from omop_lite.settings import settings
-from omop_lite.db import create_database
-import logging
-from importlib.metadata import version
-
-
-def main() -> None:
-    """
-    Main function to create the OMOP Lite database.
-
-    This function will create the schema if it doesn't exist,
-    create the tables, load the data, and run the update migrations.
-    """
-    logging.basicConfig(level=settings.log_level)
-    logger = logging.getLogger(__name__)
-    logger.info(f"Starting OMOP Lite {version('omop-lite')}")
-    logger.debug(f"Settings: {settings.model_dump()}")
-    db = create_database()
-
-    # Handle schema creation if not using 'public'
-    if settings.schema_name != "public":
-        if db.schema_exists(settings.schema_name):
-            logger.info(f"Schema '{settings.schema_name}' already exists")
-            return
-        else:
-            db.create_schema(settings.schema_name)
-
-    # Continue with table creation, data loading, etc.
-    db.create_tables()
-    db.load_data()
-    db.add_constraints()
-
-    logger.info("OMOP Lite database created successfully")
-
-
-if __name__ == "__main__":
-    main()

omop_lite/cli.py

@@ -0,0 +1,915 @@
+from omop_lite.settings import Settings
+from omop_lite.db import create_database
+import logging
+from importlib.metadata import version
+import typer
+from rich.console import Console
+from rich.progress import (
+    Progress,
+    SpinnerColumn,
+    TextColumn,
+    BarColumn,
+    TaskProgressColumn,
+)
+from rich.panel import Panel
+from rich.table import Table
+from rich.prompt import Confirm
+import time
+
+console = Console()
+
+app = typer.Typer(
+    name="omop-lite",
+    help="Get an OMOP CDM database running quickly.",
+    add_completion=False,
+    no_args_is_help=False,
+)
+
+
+def _create_settings(
+    db_host: str = "db",
+    db_port: int = 5432,
+    db_user: str = "postgres",
+    db_password: str = "password",
+    db_name: str = "omop",
+    synthetic: bool = False,
+    synthetic_number: int = 100,
+    data_dir: str = "data",
+    schema_name: str = "public",
+    dialect: str = "postgresql",
+    log_level: str = "INFO",
+    fts_create: bool = False,
+    delimiter: str = "\t",
+) -> Settings:
+    """Create settings with validation."""
+    # Validate dialect
+    if dialect not in ["postgresql", "mssql"]:
+        raise typer.BadParameter("dialect must be either 'postgresql' or 'mssql'")
+
+    return Settings(
+        db_host=db_host,
+        db_port=db_port,
+        db_user=db_user,
+        db_password=db_password,
+        db_name=db_name,
+        synthetic=synthetic,
+        synthetic_number=synthetic_number,
+        data_dir=data_dir,
+        schema_name=schema_name,
+        dialect=dialect,
+        log_level=log_level,
+        fts_create=fts_create,
+        delimiter=delimiter,
+    )
+
+
+def _setup_logging(settings: Settings) -> logging.Logger:
+    """Setup logging with the given settings."""
+    logging.basicConfig(level=settings.log_level)
+    logger = logging.getLogger(__name__)
+    logger.info(f"Starting OMOP Lite {version('omop-lite')}")
+    logger.debug(f"Settings: {settings.model_dump()}")
+    return logger
+
+
+@app.callback(invoke_without_command=True)
+def callback(
+    ctx: typer.Context,
+    db_host: str = typer.Option(
+        "db", "--db-host", "-h", envvar="DB_HOST", help="Database host"
+    ),
+    db_port: int = typer.Option(
+        5432, "--db-port", "-p", envvar="DB_PORT", help="Database port"
+    ),
+    db_user: str = typer.Option(
+        "postgres", "--db-user", "-u", envvar="DB_USER", help="Database user"
+    ),
+    db_password: str = typer.Option(
+        "password", "--db-password", envvar="DB_PASSWORD", help="Database password"
+    ),
+    db_name: str = typer.Option(
+        "omop", "--db-name", "-d", envvar="DB_NAME", help="Database name"
+    ),
+    synthetic: bool = typer.Option(
+        False, "--synthetic", envvar="SYNTHETIC", help="Use synthetic data"
+    ),
+    synthetic_number: int = typer.Option(
+        100,
+        "--synthetic-number",
+        envvar="SYNTHETIC_NUMBER",
+        help="Number of synthetic records",
+    ),
+    data_dir: str = typer.Option(
+        "data", "--data-dir", envvar="DATA_DIR", help="Data directory"
+    ),
+    schema_name: str = typer.Option(
+        "public", "--schema-name", envvar="SCHEMA_NAME", help="Database schema name"
+    ),
+    dialect: str = typer.Option(
+        "postgresql",
+        "--dialect",
+        envvar="DIALECT",
+        help="Database dialect (postgresql or mssql)",
+    ),
+    log_level: str = typer.Option(
+        "INFO", "--log-level", envvar="LOG_LEVEL", help="Logging level"
+    ),
+    fts_create: bool = typer.Option(
+        False,
+        "--fts-create",
+        envvar="FTS_CREATE",
+        help="Create full-text search indexes",
+    ),
+    delimiter: str = typer.Option(
+        "\t", "--delimiter", envvar="DELIMITER", help="CSV delimiter"
+    ),
+) -> None:
+    """
+    Create the OMOP Lite database (default command).
+
+    This command will create the schema if it doesn't exist,
+    create the tables, load the data, and run the update migrations.
+
+    All settings can be configured via environment variables or command-line arguments.
+    Command-line arguments take precedence over environment variables.
+    """
+    if ctx.invoked_subcommand is None:
+        # This is the default command (no subcommand specified)
+        settings = _create_settings(
+            db_host=db_host,
+            db_port=db_port,
+            db_user=db_user,
+            db_password=db_password,
+            db_name=db_name,
+            synthetic=synthetic,
+            synthetic_number=synthetic_number,
+            data_dir=data_dir,
+            schema_name=schema_name,
+            dialect=dialect,
+            log_level=log_level,
+            fts_create=fts_create,
+            delimiter=delimiter,
+        )
+
+        # Show startup info
+        console.print(
+            Panel(
+                f"[bold blue]OMOP Lite[/bold blue] v{version('omop-lite')}\n"
+                f"[dim]Creating OMOP CDM database...[/dim]",
+                title="🚀 Starting Pipeline",
+                border_style="blue",
+            )
+        )
+
+        db = create_database(settings)
+
+        # Handle schema creation if not using 'public'
+        if settings.schema_name != "public":
+            if db.schema_exists(settings.schema_name):
+                console.print(f"ℹ️  Schema '{settings.schema_name}' already exists")
+                return
+            else:
+                with console.status("[bold green]Creating schema...", spinner="dots"):
+                    db.create_schema(settings.schema_name)
+                console.print(f"✅ Schema '{settings.schema_name}' created")
+
+        # Progress bar for the main pipeline
+        with Progress(
+            SpinnerColumn(),
+            TextColumn("[progress.description]{task.description}"),
+            BarColumn(),
+            TaskProgressColumn(),
+            console=console,
+        ) as progress:
+            # Create tables
+            task1 = progress.add_task("[cyan]Creating tables...", total=1)
+            db.create_tables()
+            progress.update(task1, completed=1)
+
+            # Load data
+            task2 = progress.add_task("[yellow]Loading data...", total=1)
+            db.load_data()
+            progress.update(task2, completed=1)
+
+            # Add constraints
+            task3 = progress.add_task("[green]Adding constraints...", total=1)
+            db.add_all_constraints()
+            progress.update(task3, completed=1)
+
+        console.print(
+            Panel(
+                "[bold green]✅ OMOP Lite database created successfully![/bold green]\n"
+                f"[dim]Database: {settings.db_name}\n"
+                f"Schema: {settings.schema_name}\n"
+                f"Dialect: {settings.dialect}[/dim]",
+                title="🎉 Success",
+                border_style="green",
+            )
+        )
+
+
+@app.command()
+def test(
+    db_host: str = typer.Option(
+        "db", "--db-host", "-h", envvar="DB_HOST", help="Database host"
+    ),
+    db_port: int = typer.Option(
+        5432, "--db-port", "-p", envvar="DB_PORT", help="Database port"
+    ),
+    db_user: str = typer.Option(
+        "postgres", "--db-user", "-u", envvar="DB_USER", help="Database user"
+    ),
+    db_password: str = typer.Option(
+        "password", "--db-password", envvar="DB_PASSWORD", help="Database password"
+    ),
+    db_name: str = typer.Option(
+        "omop", "--db-name", "-d", envvar="DB_NAME", help="Database name"
+    ),
+    schema_name: str = typer.Option(
+        "public", "--schema-name", envvar="SCHEMA_NAME", help="Database schema name"
+    ),
+    dialect: str = typer.Option(
+        "postgresql",
+        "--dialect",
+        envvar="DIALECT",
+        help="Database dialect (postgresql or mssql)",
+    ),
+    log_level: str = typer.Option(
+        "INFO", "--log-level", envvar="LOG_LEVEL", help="Logging level"
+    ),
+) -> None:
+    """
+    Test database connectivity and basic operations.
+
+    This command tests the database connection and performs basic operations
+    without creating tables or loading data.
+    """
+    settings = _create_settings(
+        db_host=db_host,
+        db_port=db_port,
+        db_user=db_user,
+        db_password=db_password,
+        db_name=db_name,
+        schema_name=schema_name,
+        dialect=dialect,
+        log_level=log_level,
+    )
+
+    try:
+        with console.status(
+            "[bold blue]Testing database connection...", spinner="dots"
+        ):
+            db = create_database(settings)
+
+        # Create results table
+        table = Table(title="Database Test Results")
+        table.add_column("Test", style="cyan", no_wrap=True)
+        table.add_column("Status", style="bold")
+        table.add_column("Details", style="dim")
+
+        # Test connection
+        table.add_row(
+            "Database Connection", "✅ PASS", f"Connected to {settings.db_name}"
+        )
+
+        # Test schema
+        if db.schema_exists(settings.schema_name):
+            table.add_row(
+                "Schema Check", "✅ PASS", f"Schema '{settings.schema_name}' exists"
+            )
+        else:
+            table.add_row(
+                "Schema Check",
+                "ℹ️  INFO",
+                f"Schema '{settings.schema_name}' does not exist (normal)",
+            )
+
+        # Test basic operations
+        with console.status("[bold green]Testing basic operations...", spinner="dots"):
+            time.sleep(0.5)  # Simulate operation
+        table.add_row("Basic Operations", "✅ PASS", "All operations successful")
+
+        console.print(table)
+        console.print(
+            Panel(
+                "[bold green]✅ Database test completed successfully![/bold green]",
+                title="🎯 Test Results",
+                border_style="green",
+            )
+        )
+
+    except Exception as e:
+        console.print(
+            Panel(
+                f"[bold red]❌ Database test failed[/bold red]\n\n[red]{e}[/red]",
+                title="💥 Test Failed",
+                border_style="red",
+            )
+        )
+        raise typer.Exit(1)
+
+
+@app.command()
+def create_tables(
+    db_host: str = typer.Option(
+        "db", "--db-host", "-h", envvar="DB_HOST", help="Database host"
+    ),
+    db_port: int = typer.Option(
+        5432, "--db-port", "-p", envvar="DB_PORT", help="Database port"
+    ),
+    db_user: str = typer.Option(
+        "postgres", "--db-user", "-u", envvar="DB_USER", help="Database user"
+    ),
+    db_password: str = typer.Option(
+        "password", "--db-password", envvar="DB_PASSWORD", help="Database password"
+    ),
+    db_name: str = typer.Option(
+        "omop", "--db-name", "-d", envvar="DB_NAME", help="Database name"
+    ),
+    schema_name: str = typer.Option(
+        "public", "--schema-name", envvar="SCHEMA_NAME", help="Database schema name"
+    ),
+    dialect: str = typer.Option(
+        "postgresql",
+        "--dialect",
+        envvar="DIALECT",
+        help="Database dialect (postgresql or mssql)",
+    ),
+    log_level: str = typer.Option(
+        "INFO", "--log-level", envvar="LOG_LEVEL", help="Logging level"
+    ),
+) -> None:
+    """
+    Create only the database tables.
+
+    This command creates the schema (if needed) and the tables,
+    but does not load data or add constraints.
+    """
+    settings = _create_settings(
+        db_host=db_host,
+        db_port=db_port,
+        db_user=db_user,
+        db_password=db_password,
+        db_name=db_name,
+        schema_name=schema_name,
+        dialect=dialect,
+        log_level=log_level,
+    )
+
+    logger = _setup_logging(settings)
+    db = create_database(settings)
+
+    # Handle schema creation if not using 'public'
+    if settings.schema_name != "public":
+        if db.schema_exists(settings.schema_name):
+            logger.info(f"Schema '{settings.schema_name}' already exists")
+        else:
+            db.create_schema(settings.schema_name)
+
+    # Create tables only
+    db.create_tables()
+    logger.info("✅ Tables created successfully")
+
+
+@app.command()
+def load_data(
+    db_host: str = typer.Option(
+        "db", "--db-host", "-h", envvar="DB_HOST", help="Database host"
+    ),
+    db_port: int = typer.Option(
+        5432, "--db-port", "-p", envvar="DB_PORT", help="Database port"
+    ),
+    db_user: str = typer.Option(
+        "postgres", "--db-user", "-u", envvar="DB_USER", help="Database user"
+    ),
+    db_password: str = typer.Option(
+        "password", "--db-password", envvar="DB_PASSWORD", help="Database password"
+    ),
+    db_name: str = typer.Option(
+        "omop", "--db-name", "-d", envvar="DB_NAME", help="Database name"
+    ),
+    synthetic: bool = typer.Option(
+        False, "--synthetic", envvar="SYNTHETIC", help="Use synthetic data"
+    ),
+    synthetic_number: int = typer.Option(
+        100,
+        "--synthetic-number",
+        envvar="SYNTHETIC_NUMBER",
+        help="Number of synthetic records",
+    ),
+    data_dir: str = typer.Option(
+        "data", "--data-dir", envvar="DATA_DIR", help="Data directory"
+    ),
+    schema_name: str = typer.Option(
+        "public", "--schema-name", envvar="SCHEMA_NAME", help="Database schema name"
+    ),
+    dialect: str = typer.Option(
+        "postgresql",
+        "--dialect",
+        envvar="DIALECT",
+        help="Database dialect (postgresql or mssql)",
+    ),
+    log_level: str = typer.Option(
+        "INFO", "--log-level", envvar="LOG_LEVEL", help="Logging level"
+    ),
+    delimiter: str = typer.Option(
+        "\t", "--delimiter", envvar="DELIMITER", help="CSV delimiter"
+    ),
+) -> None:
+    """
+    Load data into existing tables.
+
+    This command loads data into tables that must already exist.
+    Use create-tables first if tables don't exist.
+    """
+    settings = _create_settings(
+        db_host=db_host,
+        db_port=db_port,
+        db_user=db_user,
+        db_password=db_password,
+        db_name=db_name,
+        synthetic=synthetic,
+        synthetic_number=synthetic_number,
+        data_dir=data_dir,
+        schema_name=schema_name,
+        dialect=dialect,
+        log_level=log_level,
+        delimiter=delimiter,
+    )
+
+    db = create_database(settings)
+
+    # Load data with progress
+    with Progress(
+        SpinnerColumn(),
+        TextColumn("[progress.description]{task.description}"),
+        BarColumn(),
+        TaskProgressColumn(),
+        console=console,
+    ) as progress:
+        task = progress.add_task("[yellow]Loading data...", total=1)
+        db.load_data()
+        progress.update(task, completed=1)
+
+    console.print(
+        Panel(
+            "[bold green]✅ Data loaded successfully![/bold green]",
+            title="📊 Data Loading Complete",
+            border_style="green",
+        )
+    )
+
+
+@app.command()
+def add_constraints(
+    db_host: str = typer.Option(
+        "db", "--db-host", "-h", envvar="DB_HOST", help="Database host"
+    ),
+    db_port: int = typer.Option(
+        5432, "--db-port", "-p", envvar="DB_PORT", help="Database port"
+    ),
+    db_user: str = typer.Option(
+        "postgres", "--db-user", "-u", envvar="DB_USER", help="Database user"
+    ),
+    db_password: str = typer.Option(
+        "password", "--db-password", envvar="DB_PASSWORD", help="Database password"
+    ),
+    db_name: str = typer.Option(
+        "omop", "--db-name", "-d", envvar="DB_NAME", help="Database name"
+    ),
+    schema_name: str = typer.Option(
+        "public", "--schema-name", envvar="SCHEMA_NAME", help="Database schema name"
+    ),
+    dialect: str = typer.Option(
+        "postgresql",
+        "--dialect",
+        envvar="DIALECT",
+        help="Database dialect (postgresql or mssql)",
+    ),
+    log_level: str = typer.Option(
+        "INFO", "--log-level", envvar="LOG_LEVEL", help="Logging level"
+    ),
+) -> None:
+    """
+    Add all constraints (primary keys, foreign keys, and indices).
+
+    This command adds all types of constraints to existing tables.
+    Tables must exist and should have data loaded.
+    """
+    settings = _create_settings(
+        db_host=db_host,
+        db_port=db_port,
+        db_user=db_user,
+        db_password=db_password,
+        db_name=db_name,
+        schema_name=schema_name,
+        dialect=dialect,
+        log_level=log_level,
+    )
+
+    db = create_database(settings)
+
+    # Add all constraints with progress
+    with Progress(
+        SpinnerColumn(),
+        TextColumn("[progress.description]{task.description}"),
+        BarColumn(),
+        TaskProgressColumn(),
+        console=console,
+    ) as progress:
+        task = progress.add_task("[green]Adding constraints...", total=3)
+
+        # Primary keys
+        progress.update(task, description="[cyan]Adding primary keys...")
+        db.add_primary_keys()
+        progress.advance(task)
+
+        # Foreign keys
+        progress.update(task, description="[cyan]Adding foreign key constraints...")
+        db.add_constraints()
+        progress.advance(task)
+
+        # Indices
+        progress.update(task, description="[cyan]Adding indices...")
+        db.add_indices()
+        progress.advance(task)
+
+    console.print(
+        Panel(
+            "[bold green]✅ All constraints added successfully![/bold green]\n\n"
+            "[dim]• Primary keys\n"
+            "• Foreign key constraints\n"
+            "• Indices[/dim]",
+            title="🔗 Constraints Added",
+            border_style="green",
+        )
+    )
+
+
+@app.command()
+def add_primary_keys(
+    db_host: str = typer.Option(
+        "db", "--db-host", "-h", envvar="DB_HOST", help="Database host"
+    ),
+    db_port: int = typer.Option(
+        5432, "--db-port", "-p", envvar="DB_PORT", help="Database port"
+    ),
+    db_user: str = typer.Option(
+        "postgres", "--db-user", "-u", envvar="DB_USER", help="Database user"
+    ),
+    db_password: str = typer.Option(
+        "password", "--db-password", envvar="DB_PASSWORD", help="Database password"
+    ),
+    db_name: str = typer.Option(
+        "omop", "--db-name", "-d", envvar="DB_NAME", help="Database name"
+    ),
+    schema_name: str = typer.Option(
+        "public", "--schema-name", envvar="SCHEMA_NAME", help="Database schema name"
+    ),
+    dialect: str = typer.Option(
+        "postgresql",
+        "--dialect",
+        envvar="DIALECT",
+        help="Database dialect (postgresql or mssql)",
+    ),
+    log_level: str = typer.Option(
+        "INFO", "--log-level", envvar="LOG_LEVEL", help="Logging level"
+    ),
+) -> None:
+    """
+    Add only primary keys to existing tables.
+
+    This command adds primary key constraints to existing tables.
+    Tables must exist and should have data loaded.
+    """
+    settings = _create_settings(
+        db_host=db_host,
+        db_port=db_port,
+        db_user=db_user,
+        db_password=db_password,
+        db_name=db_name,
+        schema_name=schema_name,
+        dialect=dialect,
+        log_level=log_level,
+    )
+
+    logger = _setup_logging(settings)
+    db = create_database(settings)
+
+    # Add primary keys only
+    db.add_primary_keys()
+    logger.info("✅ Primary keys added successfully")
+
+
+@app.command()
+def add_foreign_keys(
+    db_host: str = typer.Option(
+        "db", "--db-host", "-h", envvar="DB_HOST", help="Database host"
+    ),
+    db_port: int = typer.Option(
+        5432, "--db-port", "-p", envvar="DB_PORT", help="Database port"
+    ),
+    db_user: str = typer.Option(
+        "postgres", "--db-user", "-u", envvar="DB_USER", help="Database user"
+    ),
+    db_password: str = typer.Option(
+        "password", "--db-password", envvar="DB_PASSWORD", help="Database password"
+    ),
+    db_name: str = typer.Option(
+        "omop", "--db-name", "-d", envvar="DB_NAME", help="Database name"
+    ),
+    schema_name: str = typer.Option(
+        "public", "--schema-name", envvar="SCHEMA_NAME", help="Database schema name"
+    ),
+    dialect: str = typer.Option(
+        "postgresql",
+        "--dialect",
+        envvar="DIALECT",
+        help="Database dialect (postgresql or mssql)",
+    ),
+    log_level: str = typer.Option(
+        "INFO", "--log-level", envvar="LOG_LEVEL", help="Logging level"
+    ),
+) -> None:
+    """
+    Add only foreign key constraints to existing tables.
+
+    This command adds foreign key constraints to existing tables.
+    Tables must exist and should have data loaded.
+    Primary keys should be added first.
+    """
+    settings = _create_settings(
+        db_host=db_host,
+        db_port=db_port,
+        db_user=db_user,
+        db_password=db_password,
+        db_name=db_name,
+        schema_name=schema_name,
+        dialect=dialect,
+        log_level=log_level,
+    )
+
+    logger = _setup_logging(settings)
+    db = create_database(settings)
+
+    # Add foreign key constraints only
+    db.add_constraints()
+    logger.info("✅ Foreign key constraints added successfully")
+
+
+@app.command()
+def add_indices(
+    db_host: str = typer.Option(
+        "db", "--db-host", "-h", envvar="DB_HOST", help="Database host"
+    ),
+    db_port: int = typer.Option(
+        5432, "--db-port", "-p", envvar="DB_PORT", help="Database port"
+    ),
+    db_user: str = typer.Option(
+        "postgres", "--db-user", "-u", envvar="DB_USER", help="Database user"
+    ),
+    db_password: str = typer.Option(
+        "password", "--db-password", envvar="DB_PASSWORD", help="Database password"
+    ),
+    db_name: str = typer.Option(
+        "omop", "--db-name", "-d", envvar="DB_NAME", help="Database name"
+    ),
+    schema_name: str = typer.Option(
+        "public", "--schema-name", envvar="SCHEMA_NAME", help="Database schema name"
+    ),
+    dialect: str = typer.Option(
+        "postgresql",
+        "--dialect",
+        envvar="DIALECT",
+        help="Database dialect (postgresql or mssql)",
+    ),
+    log_level: str = typer.Option(
+        "INFO", "--log-level", envvar="LOG_LEVEL", help="Logging level"
+    ),
+) -> None:
+    """
+    Add only indices to existing tables.
+
+    This command adds indices to existing tables.
+    Tables must exist and should have data loaded.
+    """
+    settings = _create_settings(
+        db_host=db_host,
+        db_port=db_port,
+        db_user=db_user,
+        db_password=db_password,
+        db_name=db_name,
+        schema_name=schema_name,
+        dialect=dialect,
+        log_level=log_level,
+    )
+
+    logger = _setup_logging(settings)
+    db = create_database(settings)
+
+    # Add indices only
+    db.add_indices()
+    logger.info("✅ Indices added successfully")
+
+
+@app.command()
+def drop(
+    db_host: str = typer.Option(
+        "db", "--db-host", "-h", envvar="DB_HOST", help="Database host"
+    ),
+    db_port: int = typer.Option(
+        5432, "--db-port", "-p", envvar="DB_PORT", help="Database port"
+    ),
+    db_user: str = typer.Option(
+        "postgres", "--db-user", "-u", envvar="DB_USER", help="Database user"
+    ),
+    db_password: str = typer.Option(
+        "password", "--db-password", envvar="DB_PASSWORD", help="Database password"
+    ),
+    db_name: str = typer.Option(
+        "omop", "--db-name", "-d", envvar="DB_NAME", help="Database name"
+    ),
+    schema_name: str = typer.Option(
+        "public", "--schema-name", envvar="SCHEMA_NAME", help="Database schema name"
+    ),
+    dialect: str = typer.Option(
+        "postgresql",
+        "--dialect",
+        envvar="DIALECT",
+        help="Database dialect (postgresql or mssql)",
+    ),
+    log_level: str = typer.Option(
+        "INFO", "--log-level", envvar="LOG_LEVEL", help="Logging level"
+    ),
+    tables_only: bool = typer.Option(
+        False, "--tables-only", help="Drop only tables, not the schema"
+    ),
+    schema_only: bool = typer.Option(
+        False, "--schema-only", help="Drop only the schema (and all its contents)"
+    ),
+    confirm: bool = typer.Option(False, "--confirm", help="Skip confirmation prompt"),
+) -> None:
+    """
+    Drop tables and/or schema from the database.
+
+    This command can drop tables, schema, or everything.
+    Use with caution as this will permanently delete data.
+    """
+    if not confirm:
+        # Create a warning panel
+        warning_text = ""
+        if tables_only:
+            warning_text = f"[bold red]⚠️  WARNING[/bold red]\n\nThis will drop [bold]ALL TABLES[/bold] in schema '{schema_name}'.\n\n[red]This action cannot be undone![/red]"
+        elif schema_only:
+            warning_text = f"[bold red]⚠️  WARNING[/bold red]\n\nThis will drop [bold]SCHEMA '{schema_name}'[/bold] and [bold]ALL ITS CONTENTS[/bold].\n\n[red]This action cannot be undone![/red]"
+        else:
+            warning_text = f"[bold red]⚠️  WARNING[/bold red]\n\nThis will drop [bold]ALL TABLES[/bold] and [bold]SCHEMA '{schema_name}'[/bold].\n\n[red]This action cannot be undone![/red]"
+
+        console.print(
+            Panel(warning_text, title="🗑️  Drop Operation", border_style="red")
+        )
+
+        if not Confirm.ask("Are you sure you want to continue?", default=False):
+            console.print("[yellow]Operation cancelled.[/yellow]")
+            raise typer.Exit()
+
+    settings = _create_settings(
+        db_host=db_host,
+        db_port=db_port,
+        db_user=db_user,
+        db_password=db_password,
+        db_name=db_name,
+        schema_name=schema_name,
+        dialect=dialect,
+        log_level=log_level,
+    )
+
+    db = create_database(settings)
+
+    try:
+        with console.status("[bold red]Dropping database objects...", spinner="dots"):
+            if tables_only:
+                db.drop_tables()
+                console.print(
+                    Panel(
+                        f"[bold green]✅ All tables in schema '{schema_name}' dropped successfully![/bold green]",
+                        title="🗑️  Tables Dropped",
+                        border_style="green",
+                    )
+                )
+            elif schema_only:
+                if schema_name == "public":
+                    console.print(
+                        Panel(
+                            "[yellow]⚠️  Cannot drop 'public' schema, dropping tables instead[/yellow]",
+                            title="⚠️  Schema Protection",
+                            border_style="yellow",
+                        )
+                    )
+                    db.drop_tables()
+                    console.print(
+                        Panel(
+                            "[bold green]✅ All tables dropped successfully![/bold green]",
+                            title="🗑️  Tables Dropped",
+                            border_style="green",
+                        )
+                    )
+                else:
+                    db.drop_schema(schema_name)
+                    console.print(
+                        Panel(
+                            f"[bold green]✅ Schema '{schema_name}' dropped successfully![/bold green]",
+                            title="🗑️  Schema Dropped",
+                            border_style="green",
+                        )
+                    )
+            else:
+                db.drop_all(schema_name)
+                console.print(
+                    Panel(
+                        f"[bold green]✅ Database completely dropped![/bold green]\n\n[dim]Schema: {schema_name}\nDatabase: {settings.db_name}[/dim]",
+                        title="🗑️  Database Dropped",
+                        border_style="green",
+                    )
+                )
+
+    except Exception as e:
+        console.print(
+            Panel(
+                f"[bold red]❌ Drop operation failed[/bold red]\n\n[red]{e}[/red]",
+                title="💥 Drop Failed",
+                border_style="red",
+            )
+        )
+        raise typer.Exit(1)
+
+
+@app.command()
+def help_commands() -> None:
+    """
+    Show detailed help for all available commands.
+    """
+    table = Table(
+        title="OMOP Lite Commands", show_header=True, header_style="bold magenta"
+    )
+    table.add_column("Command", style="cyan", no_wrap=True)
+    table.add_column("Description", style="white")
+    table.add_column("Use Case", style="dim")
+
+    table.add_row(
+        "[default]",
+        "Create complete OMOP database (tables + data + constraints)",
+        "Quick start, development, Docker",
+    )
+    table.add_row(
+        "test",
+        "Test database connectivity and basic operations",
+        "Verify connection, troubleshoot",
+    )
+    table.add_row(
+        "create-tables",
+        "Create only the database tables",
+        "Step-by-step setup, custom workflows",
+    )
+    table.add_row(
+        "load-data", "Load data into existing tables", "Reload data, update datasets"
+    )
+    table.add_row(
+        "add-constraints",
+        "Add all constraints (primary keys, foreign keys, indices)",
+        "Complete constraint setup",
+    )
+    table.add_row(
+        "add-primary-keys",
+        "Add only primary key constraints",
+        "Granular constraint control",
+    )
+    table.add_row(
+        "add-foreign-keys",
+        "Add only foreign key constraints",
+        "Granular constraint control",
+    )
+    table.add_row("add-indices", "Add only indices", "Granular constraint control")
+    table.add_row("drop", "Drop tables and/or schema", "Cleanup, reset database")
+    table.add_row(
+        "help-commands", "Show this help table", "Discover available commands"
+    )
+
+    console.print(table)
+    console.print(
+        Panel(
+            "[bold blue]💡 Tip:[/bold blue] Use [cyan]omop-lite <command> --help[/cyan] for detailed command options\n\n"
+            "[bold green]🚀 Quick Start:[/bold green] [cyan]omop-lite --synthetic[/cyan]",
+            title="ℹ️  Usage Tips",
+            border_style="blue",
+        )
+    )
+
+
+def main_cli():
+    """Entry point for the CLI."""
+    app()
+
+
+if __name__ == "__main__":
+    main_cli()

omop_lite/db/__init__.py

@@ -1,15 +1,15 @@
 from .base import Database
 from .postgres import PostgresDatabase
 from .sqlserver import SQLServerDatabase
-from omop_lite.settings import settings
+from omop_lite.settings import Settings
 
 
-def create_database() -> Database:
+def create_database(settings: Settings) -> Database:
     """Factory function to create the appropriate database instance."""
     if settings.dialect == "postgresql":
-        return PostgresDatabase()
+        return PostgresDatabase(settings)
     elif settings.dialect == "mssql":
-        return SQLServerDatabase()
+        return SQLServerDatabase(settings)
     else:
         raise ValueError(f"Unsupported dialect: {settings.dialect}")
 

omop_lite/db/base.py

@@ -5,7 +5,8 @@ from typing import Union, Optional
 import logging
 from importlib.resources import files
 from importlib.abc import Traversable
-from omop_lite.settings import settings
+from omop_lite.settings import Settings
+from sqlalchemy.sql import text
 
 logger = logging.getLogger(__name__)
 
@@ -13,7 +14,8 @@ logger = logging.getLogger(__name__)
 class Database(ABC):
     """Abstract base class for database operations"""
 
-    def __init__(self) -> None:
+    def __init__(self, settings: Settings) -> None:
+        self.settings = settings
         self.engine: Optional[Engine] = None
         self.metadata: Optional[MetaData] = None
         self.file_path: Optional[Union[Path, Traversable]] = None
@@ -42,6 +44,11 @@ class Database(ABC):
             "VOCABULARY",
         ]
 
+    @property
+    def dialect(self) -> str:
+        """Get the database dialect."""
+        return self.settings.dialect
+
     @abstractmethod
     def create_schema(self, schema_name: str) -> None:
         """Create a new schema."""
@@ -75,15 +82,61 @@ class Database(ABC):
         self._execute_sql_file(self.file_path.joinpath("ddl.sql"))
         self.refresh_metadata()
 
-    def add_constraints(self) -> None:
-        """Add constraints to the tables in the database.
-        
-        Executes the sql files for the given data directory.
-        """
+    def add_primary_keys(self) -> None:
+        """Add primary keys to the tables in the database."""
         self._execute_sql_file(self.file_path.joinpath("primary_keys.sql"))
+
+    def add_constraints(self) -> None:
+        """Add constraints to the tables in the database."""
         self._execute_sql_file(self.file_path.joinpath("constraints.sql"))
+
+    def add_indices(self) -> None:
+        """Add indices to the tables in the database."""
         self._execute_sql_file(self.file_path.joinpath("indices.sql"))
 
+    def add_all_constraints(self) -> None:
+        """Add all constraints, primary keys, and indices to the tables in the database.
+
+        This is a convenience method that calls all three constraint methods.
+        """
+        self.add_primary_keys()
+        self.add_constraints()
+        self.add_indices()
+
+    def drop_tables(self) -> None:
+        """Drop all tables in the database."""
+        if not self.metadata or not self.engine:
+            raise RuntimeError("Database not properly initialized")
+
+        # Drop all tables in reverse dependency order
+        self.metadata.drop_all(bind=self.engine)
+        logger.info("✅ All tables dropped successfully")
+
+    def drop_schema(self, schema_name: str) -> None:
+        """Drop a schema and all its contents."""
+        if not self.engine:
+            raise RuntimeError("Database engine not initialized")
+
+        with self.engine.connect() as connection:
+            if self.dialect == "postgresql":
+                connection.execute(
+                    text(f'DROP SCHEMA IF EXISTS "{schema_name}" CASCADE')
+                )
+            else:  # SQL Server
+                connection.execute(text(f"DROP SCHEMA IF EXISTS [{schema_name}]"))
+            connection.commit()
+            logger.info(f"✅ Schema '{schema_name}' dropped successfully")
+
+    def drop_all(self, schema_name: str) -> None:
+        """Drop everything: tables and schema.
+
+        This is a convenience method that drops tables first, then the schema.
+        """
+        self.drop_tables()
+        if schema_name != "public":
+            self.drop_schema(schema_name)
+        logger.info("✅ Database completely dropped")
+
     def load_data(self) -> None:
         """Load data into tables."""
         data_dir = self._get_data_dir()
@@ -111,15 +164,15 @@ class Database(ABC):
         Common implementation for all databases.
         """
 
-        if settings.synthetic:
-            if settings.synthetic_number == 1000:
+        if self.settings.synthetic:
+            if self.settings.synthetic_number == 1000:
                 return files("omop_lite.synthetic.1000")
             return files("omop_lite.synthetic.100")
-        data_dir = Path(settings.data_dir)
+        data_dir = Path(self.settings.data_dir)
         if not data_dir.exists():
             raise FileNotFoundError(f"Data directory {data_dir} does not exist")
         return data_dir
-    
+
     def _get_delimiter(self) -> str:
         """
         Return the delimiter based on the dialect.
@@ -131,22 +184,22 @@ class Database(ABC):
 
         This is used to determine the delimiter for the COPY command.
         """
-        if settings.synthetic:
-            if settings.synthetic_number == 1000:
+        if self.settings.synthetic:
+            if self.settings.synthetic_number == 1000:
                 return ","
-            return settings.delimiter
+            return self.settings.delimiter
         else:
-            return settings.delimiter
-        
+            return self.settings.delimiter
+
     def _get_quote(self) -> str:
         """
         Return the quote based on the dialect.
         Common implementation for all databases.
         """
-        if settings.synthetic:
-            if settings.synthetic_number == 1000:
+        if self.settings.synthetic:
+            if self.settings.synthetic_number == 1000:
                 return '"'
-        return '\b'
+        return "\b"
 
     def _execute_sql_file(self, file_path: Union[str, Traversable]) -> None:
         """
@@ -157,7 +210,7 @@ class Database(ABC):
             file_path = str(file_path)
 
         with open(file_path, "r") as f:
-            sql = f.read().replace("@cdmDatabaseSchema", settings.schema_name)
+            sql = f.read().replace("@cdmDatabaseSchema", self.settings.schema_name)
 
         if not self.engine:
             raise RuntimeError("Database engine not initialized")

omop_lite/db/postgres.py

@@ -2,7 +2,7 @@ from sqlalchemy import create_engine, MetaData, text
 from importlib.resources import files
 import logging
 from .base import Database
-from omop_lite.settings import settings
+from omop_lite.settings import Settings
 from typing import Union
 from pathlib import Path
 from importlib.abc import Traversable
@@ -11,8 +11,8 @@ logger = logging.getLogger(__name__)
 
 
 class PostgresDatabase(Database):
-    def __init__(self) -> None:
-        super().__init__()
+    def __init__(self, settings: Settings) -> None:
+        super().__init__(settings)
         self.db_url = f"postgresql+psycopg2://{settings.db_user}:{settings.db_password}@{settings.db_host}:{settings.db_port}/{settings.db_name}"
         self.engine = create_engine(self.db_url)
         self.metadata = MetaData(schema=settings.schema_name)
@@ -30,7 +30,7 @@ class PostgresDatabase(Database):
     def add_constraints(self) -> None:
         """
         Add primary keys, constraints, and indices.
-        
+
         Override to add full-text search.
         """
         super().add_constraints()
@@ -41,7 +41,7 @@ class PostgresDatabase(Database):
         if not self.engine:
             raise RuntimeError("Database engine not initialized")
 
-        if not settings.fts_create:
+        if not self.settings.fts_create:
             logger.info("Full-text search creation disabled")
             return
 
@@ -60,7 +60,7 @@ class PostgresDatabase(Database):
     def _bulk_load(self, table_name: str, file_path: Union[Path, Traversable]) -> None:
         if not self.engine:
             raise RuntimeError("Database engine not initialized")
-        
+
         delimiter = self._get_delimiter()
         quote = self._get_quote()
 
@@ -71,7 +71,7 @@ class PostgresDatabase(Database):
                 try:
                     with open(str(file_path), "r") as f:
                         cursor.copy_expert(
-                            f"COPY {settings.schema_name}.{table_name} FROM STDIN WITH (FORMAT csv, DELIMITER E'{delimiter}', NULL '', QUOTE E'{quote}', HEADER, ENCODING 'UTF8')",
+                            f"COPY {self.settings.schema_name}.{table_name} FROM STDIN WITH (FORMAT csv, DELIMITER E'{delimiter}', NULL '', QUOTE E'{quote}', HEADER, ENCODING 'UTF8')",
                             f,
                         )
                     connection.commit()

omop_lite/db/sqlserver.py

@@ -3,7 +3,7 @@ from sqlalchemy import create_engine, MetaData, text
 from importlib.resources import files
 import logging
 from .base import Database
-from omop_lite.settings import settings
+from omop_lite.settings import Settings
 from typing import Union
 from pathlib import Path
 from importlib.abc import Traversable
@@ -12,8 +12,8 @@ logger = logging.getLogger(__name__)
 
 
 class SQLServerDatabase(Database):
-    def __init__(self) -> None:
-        super().__init__()
+    def __init__(self, settings: Settings) -> None:
+        super().__init__(settings)
         self.db_url = f"mssql+pyodbc://{settings.db_user}:{settings.db_password}@{settings.db_host}:{settings.db_port}/{settings.db_name}?driver=ODBC+Driver+18+for+SQL+Server&TrustServerCertificate=yes"
         self.engine = create_engine(self.db_url)
         self.metadata = MetaData(schema=settings.schema_name)
@@ -37,18 +37,25 @@ class SQLServerDatabase(Database):
         with open(str(file_path), "r", encoding="utf-8", newline="") as f:
             reader = csv.reader(f, delimiter=delimiter)
             headers = next(reader)
-            
+
             columns = ", ".join(f"[{col}]" for col in headers)
             placeholders = ", ".join(["?" for _ in headers])
-            insert_sql = f"INSERT INTO {settings.schema_name}.[{table_name}] ({columns}) VALUES ({placeholders})"
+            insert_sql = f"INSERT INTO {self.settings.schema_name}.[{table_name}] ({columns}) VALUES ({placeholders})"
 
             conn = self.engine.raw_connection()
             try:
                 cursor = conn.cursor()
                 for line_no, row in enumerate(reader, start=2):
-                    if len(row) != len(headers):
-                        print(f"Row {line_no} skipped: expected {len(headers)} values, got {len(row)} – {row}")
-                        continue
+                    # Pad short rows
+                    if len(row) < len(headers):
+                        row += [None] * (len(headers) - len(row))
+                        logger.info(f"Row {line_no} padded: {row}")
+                    elif len(row) > len(headers):
+                        logger.info(
+                            f"Row {line_no} trimmed: too many values ({len(row)}), expected {len(headers)} – trimming."
+                        )
+                        row = row[: len(headers)]
+
                     cursor.execute(insert_sql, row)
                 conn.commit()
             finally:

omop_lite/settings.py

@@ -1,23 +1,30 @@
 from pydantic_settings import BaseSettings
 from typing import Literal
+from pydantic import Field
 
 
 class Settings(BaseSettings):
     """Settings for OMOP Lite."""
 
-    db_host: str = "db"
-    db_port: int = 5432
-    db_user: str = "postgres"
-    db_password: str = "password"
-    db_name: str = "omop"
-    synthetic: bool = False
-    synthetic_number: int = 100
-    data_dir: str = "data"
-    schema_name: str = "public"
-    dialect: Literal["postgresql", "mssql"] = "postgresql"
-    log_level: str = "INFO"
-    fts_create: bool = False
-    delimiter: str = "\t"
+    db_host: str = Field(default="db", description="Database host")
+    db_port: int = Field(default=5432, description="Database port")
+    db_user: str = Field(default="postgres", description="Database user")
+    db_password: str = Field(default="password", description="Database password")
+    db_name: str = Field(default="omop", description="Database name")
+    synthetic: bool = Field(default=False, description="Use synthetic data")
+    synthetic_number: int = Field(
+        default=100, description="Number of synthetic records"
+    )
+    data_dir: str = Field(default="data", description="Data directory")
+    schema_name: str = Field(default="public", description="Database schema name")
+    dialect: Literal["postgresql", "mssql"] = Field(
+        default="postgresql", description="Database dialect"
+    )
+    log_level: str = Field(default="INFO", description="Logging level")
+    fts_create: bool = Field(
+        default=False, description="Create full-text search indexes"
+    )
+    delimiter: str = Field(default="\t", description="CSV delimiter")
 
     class Config:
         env_file = ".env"

{omop_lite-0.0.17.dist-info → omop_lite-0.1.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: omop-lite
-Version: 0.0.17
+Version: 0.1.0
 Summary: Get an OMOP CDM database running quickly.
 License-File: LICENSE
 Requires-Python: >=3.13
@@ -8,6 +8,7 @@ Requires-Dist: psycopg2-binary>=2.9.10
 Requires-Dist: pydantic-settings>=2.8.1
 Requires-Dist: pyodbc>=5.2.0
 Requires-Dist: sqlalchemy>=2.0.39
+Requires-Dist: typer>=0.16.0
 Description-Content-Type: text/markdown
 
 # omop-lite
@@ -106,6 +107,10 @@ Install with custom values:
 helm install omop-lite omop-lite/omop-lite -f values.yaml
 ```
 
+### CLI
+
+`uv run omop-lite --help`
+
 #### Using Your Own Data
 
 To use your own data with the Helm chart:

{omop_lite-0.0.17.dist-info → omop_lite-0.1.0.dist-info}/RECORD

@@ -1,9 +1,10 @@
-omop_lite/__init__.py,sha256=3inxCodvpMu3j4ID1v5RIJopSFyNpdm8XioO_vQ_IsE,1118
-omop_lite/settings.py,sha256=234EK12WAHy2aRlahw415qArfBFPWCFa0ANYWt2T15s,641
-omop_lite/db/__init__.py,sha256=Wlu-tkFf2M6jkHJE020dim1ziCGia0cFxS7UOqcE28o,568
-omop_lite/db/base.py,sha256=RA2dMzgB-dkR0R5Rv6HZqnYf726gXGRJ0G9cPGoc-gg,5992
-omop_lite/db/postgres.py,sha256=inURED1rk9LMIWojN7qszQjdj2M3nj0fcMCPB0TPW3o,3083
-omop_lite/db/sqlserver.py,sha256=K_8VZVSR6bqzVMIbY2gRJOxrkY6F16_vzyBCtmYdt04,2361
+omop_lite/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+omop_lite/cli.py,sha256=CyJOuE0THMKWE76lvYzVnAjJV6KB54XxOzn8er_AMYE,29566
+omop_lite/settings.py,sha256=o25IVG-7yNYNCBEaDjr1yKB0cqgo2mEAhxYK_yNGquA,1334
+omop_lite/db/__init__.py,sha256=muVGkAqc6VCvzegol2dA8Nex8lT1hxbNv6fIB_DMyo4,602
+omop_lite/db/base.py,sha256=A_VSMES5XBoIxQU7e3sAb-LCIlsPRVO4Q5z8TiLpbw0,8027
+omop_lite/db/postgres.py,sha256=2A1_1BwTKPwsJMHs90MSDgsO95d1d8C97VRjzGtVK5E,3105
+omop_lite/db/sqlserver.py,sha256=KGa28DE6e05zWKlbp5bLxGqQzl2hyZx88EzWSOE2nnA,2691
 omop_lite/scripts/fts.sql,sha256=PMZOImGgF0Dszqx_0BFPXBDf-7xdzt-klMmOG1wwGQ4,173
 omop_lite/scripts/mssql/constraints.sql,sha256=y_nlWWiyR8EZ_9LtEl4-6qksXplqGT9yUsU_R9w2pZ8,32206
 omop_lite/scripts/mssql/ddl.sql,sha256=kcU2f0n8XIQDAD2uqXicpAwKwkS3801Vos3b2llgQIM,19522
@@ -39,8 +40,8 @@ omop_lite/synthetic/1000/OBSERVATION_PERIOD.csv,sha256=O6YvudsW5AL2sx124hyW1YhP9
 omop_lite/synthetic/1000/PERSON.csv,sha256=ObojT1gFHrpmCnCfjO6G77VBzf-MrBMpRpd8L4wOk_o,113287
 omop_lite/synthetic/1000/PROCEDURE_OCCURRENCE.csv,sha256=iBGRwi6RGysHYBfjQxmEaUDGDqDtSCIN3ABMDRZKPvE,1555130
 omop_lite/synthetic/1000/VISIT_OCCURRENCE.csv,sha256=qYiSW_C4En8u5dKr2sKLzG9rdYjaK72XHUnmtDF8OJs,3863798
-omop_lite-0.0.17.dist-info/METADATA,sha256=kvHtFrY4p9IZ-ZDKdPgj52t25J2QIQJnn-vRiao2NgI,5372
-omop_lite-0.0.17.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-omop_lite-0.0.17.dist-info/entry_points.txt,sha256=2Y60p_74OjOkkEh0EK7yDD5c2blbD-ZGDij8-fVgXdM,45
-omop_lite-0.0.17.dist-info/licenses/LICENSE,sha256=muHgK_sUsFJ3OnDh62vGn2QH4sf_SymtlfFqp8tF9n0,1075
-omop_lite-0.0.17.dist-info/RECORD,,
+omop_lite-0.1.0.dist-info/METADATA,sha256=p4uRjjbPh-KFmpE8QbZawIDmlkjglJuo5oxnbMEpeSo,5436
+omop_lite-0.1.0.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+omop_lite-0.1.0.dist-info/entry_points.txt,sha256=7034mTJjTTHudlTC05GHTdaIEDSVnTRdzOEAuD1pO5E,53
+omop_lite-0.1.0.dist-info/licenses/LICENSE,sha256=muHgK_sUsFJ3OnDh62vGn2QH4sf_SymtlfFqp8tF9n0,1075
+omop_lite-0.1.0.dist-info/RECORD,,

omop_lite-0.1.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+omop-lite = omop_lite.cli:main_cli

omop_lite-0.0.17.dist-info/entry_points.txt

@@ -1,2 +0,0 @@
-[console_scripts]
-omop-lite = omop_lite:main