Demo Documentation Generation with AI assistance

A Flask-based web interface for the Chevy Casting Lookup API. This application provides search and browse functionality for Chevrolet casting numbers and their specifications.

## Features

- Quick Casting Search: Direct lookup by casting number
- Advanced Search: Search by years, CID, main caps, or comments
- Browse All: Paginated view of all casting numbers
- Detailed Views: Comprehensive information for each casting
- Responsive Design: Mobile-friendly interface using Bootstrap
- Real-time API Status: Shows connection status to the FastAPI backend

## Prerequisites

- Python 3.7+
- FastAPI backend running on port 8000 (from the main project)
- Modern web browser

## Installation

1. Create and activate a virtual environment, then install dependencies from `requirements.txt`.

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

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

    Uses SQLAlchemy metadata to create tables based on the current models.
    """
    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 to import.
        batch_size (int): Number of records to insert per batch (default: 100).
    """
    print(f"Importing data from {file_path}...")

    # Create database session
    db = SessionLocal()

    try:
        total_imported = import_chev_casting_data(
            file_path,
            db,
            batch_size=batch_size
        )
        print(f"Imported {total_imported} records.")
    finally:
        db.close()

#!/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
"""

import argparse

parser = argparse.ArgumentParser(
    description="Migrate the database and optionally import casting data from CSV."
)
parser.add_argument(
    "--file",
    type=str,
    default="data/castings.csv",
    help="Path to the CSV file to import (default: data/castings.csv)"
)
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()

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.

    Args:
        None

    Returns:
        None

    Todo:
        * Add support for incremental migrations
        * Implement rollback functionality
        * Add data validation before import
    """
    casting_models.Base.metadata.drop_all(bind=engine)

Welcome to the Chevy Casting Lookup application! This guide helps you search for Chevrolet engine casting numbers and their specifications.

## Table of Contents

1. What is Chevy Casting Lookup?
2. Getting Started
3. Using the Web Interface
4. Understanding Casting Information
5. Advanced Features
6. API Usage
7. Troubleshooting
8. Tips and Best Practices

## What is Chevy Casting Lookup?

The application is a database tool for identifying and researching Chevrolet engine casting numbers. It helps you:
- Identify engine specifications by casting number
- Find production years for specific castings
- Compare engine specifications across different years
- Research engine displacement, power ratings, and construction details

## Using the Web Interface

### Advanced Search
- Find 4-bolt main engines: enter `4-bolt` in the Main Caps field

### Understanding Search Results
Search results show a table with:
- Casting Number: The unique identifier
- Years: Production years
- CID: Engine displacement
- Power Range: Low and high power ratings (if available)
- Main Caps: Main bearing configuration
- Actions: "View Details" button for more information

### Detailed Casting View
Clicking "View Details" shows:
- Casting number
- Production years
- Displacement (CID)
- Power ratings
- Main cap configuration
- Additional notes/comments

from examples.api_client import get_castings, search_castings

# Get all castings
castings = get_castings("http://localhost:8000")

# Search for 350 engines
results = search_castings("http://localhost:8000", cid=350)