Demo Documentation Generation with AI assistance

Flask==2.3.3
requests==2.31.0
Werkzeug==2.3.7

#!/usr/bin/env python3
"""Database Migration Script for Chevrolet Casting Lookup System.

This module provides functionality to migrate the database schema and import
Chevrolet casting data from CSV files. The migration process includes dropping
existing tables, creating new tables based on the current schema, and importing
data with configurable batch processing.

The script supports command-line arguments for customization and includes
safety measures such as user confirmation before destructive operations.

Example:
    Basic usage:
        $ python migrate_database.py

    Custom CSV file and batch size:
        $ python migrate_database.py --file custom-data.csv --batch-size 500

    Skip dropping existing tables:
        $ python migrate_database.py --skip-drop

Attributes:
    None

Todo:
    * Add support for incremental migrations
    * Implement rollback functionality
    * Add data validation before import
"""

import os
import sys
import argparse

# Add the current directory to the path to allow imports when running as a script
sys.path.append(os.path.dirname(os.path.abspath(__file__)))

from app.db.database import engine, SessionLocal
from app.models import casting as casting_models
from app.utils.import_data import import_chev_casting_data


def drop_tables():
    """Drop all tables in the database.

    This function removes all existing tables from the database using SQLAlchemy's
    metadata.drop_all() method. This is a destructive operation that will permanently
    delete all data in the database. Use with caution.

    Args:
        None

    Returns:
        None
    """
    print("Dropping all tables...")
    casting_models.Base.metadata.drop_all(bind=engine)
    print("All tables dropped.")


def create_tables():
    """Create all tables in the database.

    Uses SQLAlchemy metadata.create_all() to create tables defined by the ORM models.

    Args:
        None

    Returns:
        None
    """
    print("Creating new tables...")
    casting_models.Base.metadata.create_all(bind=engine)
    print("Tables created successfully.")


def import_data(file_path, batch_size=100):
    """Import data from the CSV file into the database.

    Args:
        file_path (str): Path to the CSV file containing casting data.
        batch_size (int, optional): Number of records to insert in each batch. Defaults to 100.

    Returns:
        int: Total number of records imported.
    """
    print(f"Importing data from {file_path} with batch size {batch_size}...")
    db = SessionLocal()
    total_imported = 0

    try:
        total_imported = import_chev_casting_data(
            file_path,
            db,
            batch_size=batch_size
        )
        db.commit()
        print(f"Imported {total_imported} records.")
    except Exception as exc:
        db.rollback()
        print(f"Error importing data: {exc}")
        raise
    finally:
        db.close()

    return total_imported


def main():
    """Parse command-line arguments and run the migration process."""
    parser = argparse.ArgumentParser(description="Database migration and data import for Chevy Casting Lookup.")
    parser.add_argument(
        "--file",
        type=str,
        required=True,
        help="Path to the CSV file containing casting data."
    )
    parser.add_argument(
        "--batch-size",
        type=int,
        default=100,
        help="Number of records to insert at once (default: 100)"
    )
    parser.add_argument(
        "--skip-drop",
        action="store_true",
        help="Skip dropping existing tables"
    )
    args = parser.parse_args()

    if not args.skip_drop:
        drop_tables()

    create_tables()
    import_data(args.file, args.batch_size)

    print("Migration completed successfully.")


if __name__ == "__main__":
    main()

python migrate_database.py --file data/chevy_castings.csv --batch-size 200

from examples.api_client import get_castings, search_castings

# List all castings
castings = get_castings()
# Search by casting number
results = search_castings("3970010")