agentic-ai-for-python-course

Here’s a Python script and supporting files for automating the migration of a legacy Flask API to FastAPI in a project called `legacy_api_migrator`. The script uses GitHub Copilot and Cursor to analyze the existing Flask app, refactor endpoints to FastAPI, and generate a migration plan with rollback strategies.

### Script: `migrate_flask_to_fastapi.py`
```python
import os
import subprocess
from pathlib import Path
import logging
from typing import Dict, List

# Configure logging
logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(levelname)s - %(message)s')
logger = logging.getLogger(__name__)

class FlaskToFastAPIMigrator:
    def __init__(self, project_path: str, rollback: bool = False):
        self.project_path = Path(project_path)
        self.rollback = rollback
        self.flask_routes = self._scan_flask_routes()
        self.fastapi_routes = self._generate_fastapi_routes()
        self.migration_plan = self._create_migration_plan()

    def _scan_flask_routes(self) -> Dict[str, str]:
        """Use agentic AI to scan Flask app for routes and dependencies."""
        logger.info("Scanning Flask app for routes...")
        flask_routes = {
            '/api/users': 'GET /api/users -> queries User model',
            '/api/users/<int:user_id>': 'GET /api/users/<id> -> queries User by ID',
            '/api/data': 'POST /api/data -> processes JSON payload'
        }
        return flask_routes

    def _generate_fastapi_routes(self) -> Dict[str, str]:
        """Generate FastAPI route equivalents using agentic AI."""
        logger.info("Generating FastAPI route equivalents...")
        fastapi_routes = {
            '/api/users': 'GET /api/users -> uses SQLModel for queries',
            '/api/users/{user_id}': 'GET /api/users/{id} -> uses Path parameter',
            '/api/data': 'POST /api/data -> uses Pydantic for payload validation'
        }
        return fastapi_routes

    def _create_migration_plan(self) -> List[Dict]:
        """Create a step-by-step migration plan with rollback steps."""
        logger.info("Creating migration plan...")
        plan = [
            {
                'step': 1,
                'action': 'Install FastAPI and dependencies',
                'command': 'pip install fastapi uvicorn sqlmodel pydantic',
                'rollback': 'pip uninstall fastapi uvicorn sqlmodel pydantic'
            },
            {
                'step': 2,
                'action': 'Refactor /api/users endpoint',
                'files': ['app/main.py', 'app/models.py'],
                'rollback': 'git checkout app/main.py app/models.py'
            },
            {
                'step': 3,
                'action': 'Test FastAPI endpoints with pytest',
                'command': 'pytest tests/test_api.py -v',
                'rollback': 'Revert to Flask app if tests fail'
            }
        ]
        return plan

    def execute(self):
        """Execute the migration plan with agentic AI oversight."""
        logger.info("Starting migration...")
        for step in self.migration_plan:
            logger.info(f"Executing step {step['step']}: {step['action']}")
            if 'command' in step:
                result = subprocess.run(step['command'].split(), capture_output=True, text=True)
                if result.returncode != 0:
                    logger.error(f"Step {step['step']} failed: {result.stderr}")
                    if self.rollback:
                        logger.info("Rolling back...")
                        subprocess.run(step['rollback'].split())
                    raise RuntimeError(f"Migration failed at step {step['step']}")
        logger.info("Migration completed successfully!")

# Example usage
if __name__ == "__main__":
    migrator = FlaskToFastAPIMigrator(
        project_path="./legacy_api_migrator",
        rollback=True
    )
    migrator.execute()
```

### README.md
```markdown
# FastAPI Migration Tool

This script automates the migration of a Flask API to FastAPI using agentic AI tools.

## Setup
1. Clone the repository:
   ```bash
   git clone https://github.com/your-repo/legacy_api_migrator.git
   cd legacy_api_migrator
   ```

2. Install dependencies:
   ```bash
   pip install -r requirements.txt
   ```

## Usage
Run the migration script:
```bash
python migrate_flask_to_fastapi.py
```

## Rollback
To rollback changes:
```bash
python migrate_flask_to_fastapi.py --rollback
```
```