07_python_project_generator/

07_python_project_generator.rs

//! Python Project Generator Example
//!
//! This example demonstrates how to use a Ceylon Agent to:
//! - Create goal-based tasks for generating Python projects
//! - Support multiple Python project types (web apps, CLI tools, libraries, data science)
//! - Generate project structure, configuration files, and boilerplate code
//! - Extract and organize generated files
//! - Display project statistics
//!
//! The agent will:
//! 1. Analyze requirements for a Python project
//! 2. Generate project structure and configuration files
//! 3. Create essential modules, dependencies, and setup files
//! 4. Output complete generated code organized by file
//!
//! Run with: cargo run --example 07_python_project_generator --manifest-path ceylon/Cargo.toml

use ceylon_next::agent::Agent;
use ceylon_next::goal::{Goal, GoalStatus};
use ceylon_next::tasks::{OutputData, TaskRequest};
use std::collections::HashMap;
use std::fs::{self, File};
use std::io::{self, Write};
use std::path::Path;

// ============================================
// Helper: Extract task output
// ============================================

fn extract_output_text(output: &OutputData) -> String {
    match output {
        OutputData::Text(text) => text.clone(),
        OutputData::File(bytes) => String::from_utf8_lossy(bytes).to_string(),
        _ => "No text output available".to_string(),
    }
}

// ============================================
// Helper function to parse output by file
// ============================================

fn parse_output_by_file(output: &str) -> HashMap<String, String> {
    let mut files: HashMap<String, String> = HashMap::new();
    let mut current_file = String::new();
    let mut current_content = String::new();

    for line in output.lines() {
        if line.starts_with("=== FILE:") {
            // Save previous file if exists
            if !current_file.is_empty() && !current_content.is_empty() {
                files.insert(current_file.clone(), current_content.trim().to_string());
            }

            // Extract filename
            if let Some(filename) = line
                .strip_prefix("=== FILE:")
                .and_then(|s| s.strip_suffix(" ==="))
            {
                current_file = filename.trim().to_string();
                current_content.clear();
            }
        } else if !current_file.is_empty() {
            current_content.push_str(line);
            current_content.push('\n');
        }
    }

    // Save last file
    if !current_file.is_empty() && !current_content.is_empty() {
        files.insert(current_file, current_content.trim().to_string());
    }

    files
}

// ============================================
// Helper function to write files to disk
// ============================================

fn write_files_to_disk(files: &HashMap<String, String>, base_dir_name: &str) -> io::Result<()> {
    // Base directory (current_dir/generated_python_project)
    let mut base_path = std::env::current_dir()?;
    base_path.push(base_dir_name);

    // Create base dir if it doesn't exist
    fs::create_dir_all(&base_path)?;

    for (filename, content) in files {
        // Support nested paths in filename (e.g., src/main.py or tests/test_main.py)
        let file_path = base_path.join(filename);

        if let Some(parent) = file_path.parent() {
            fs::create_dir_all(parent)?;
        }

        let mut f = File::create(&file_path)?;
        f.write_all(content.as_bytes())?;

        println!("✓ Wrote: {}", file_path.display());
    }

    Ok(())
}

// ============================================
// Example 1: Basic Python CLI Application
// ============================================

async fn example_1_basic_cli_app() {
    println!("=== Example 1: Generate a Basic Python CLI Application ===\n");

    let mut agent = Agent::new("PythonCliGenerator", "ollama::gemma3:latest");

    // Create a goal for generating a Python CLI app
    let mut goal = Goal::new(
        "Generate a Python command-line application with core structure".to_string()
    );

    // Define success criteria
    goal.add_criterion("requirements.txt with dependencies listed".to_string());
    goal.add_criterion("setup.py or pyproject.toml for packaging".to_string());
    goal.add_criterion("Main CLI entry point with argument parsing".to_string());
    goal.add_criterion("Command structure with subcommands".to_string());
    goal.add_criterion("Basic error handling and logging".to_string());
    goal.add_criterion("README.md with usage instructions".to_string());
    goal.add_criterion(".gitignore for Python projects".to_string());

    // Define sub-goals (steps to generate the app)
    goal.add_sub_goal("Analyze Python CLI best practices".to_string(), 0);
    goal.add_sub_goal("Generate project structure and directories".to_string(), 1);
    goal.add_sub_goal("Create requirements.txt with dependencies (Click, Typer, etc)".to_string(), 2);
    goal.add_sub_goal("Generate pyproject.toml or setup.py".to_string(), 3);
    goal.add_sub_goal("Create main CLI module with argument parser".to_string(), 4);
    goal.add_sub_goal("Generate subcommands and command handlers".to_string(), 5);
    goal.add_sub_goal("Create utility modules and helpers".to_string(), 6);
    goal.add_sub_goal("Add logging and error handling".to_string(), 7);
    goal.add_sub_goal("Generate README with installation and usage".to_string(), 8);

    goal.status = GoalStatus::InProgress;
    agent.set_goal(goal.clone());

    // Create a task to generate a Python CLI app
    let task = TaskRequest::new(
        "Generate a professional Python command-line application with the following structure:\n\
         1. Modern argument parsing using Click or Typer\n\
         2. Multiple subcommands (e.g., init, run, config, help)\n\
         3. Configuration file support (YAML or JSON)\n\
         4. Logging with different verbosity levels\n\
         5. Error handling and graceful failure messages\n\
         6. Proper project structure with src/ and tests/ directories\n\
         7. pyproject.toml or setup.py for packaging\n\
         8. requirements.txt with dev dependencies\n\
         9. .gitignore for Python\n\
         10. Comprehensive README with examples\n\
         The app should be production-ready and follow Python best practices (PEP 8)."
    );

    println!("📝 Task: Generate a Python CLI Application\n");
    println!("🎯 Success Criteria:");
    for criterion in &goal.success_criteria {
        println!("  • {}", criterion.description);
    }

    println!("\n⏳ Agent is generating the Python CLI app...\n");
    let response = agent.run(task).await;

    // Extract and display the output
    let output = extract_output_text(&response.result());
    println!("📄 Generated Output:\n");
    println!("{}\n", output);

    // Show progress
    println!("📊 Goal Progress: {}%", goal.get_progress());
    println!("Status: {:?}", goal.status);

    println!("\n✅ Example 1 completed!\n");
}

// ============================================
// Example 2: Python Web API with FastAPI
// ============================================

async fn example_2_fastapi_web_app() {
    println!("\n=== Example 2: Generate Python FastAPI Web Application ===\n");

    let mut agent = Agent::new("FastApiGenerator", "ollama::gemma3:latest");

    let mut goal = Goal::new(
        "Generate a complete FastAPI web application with database integration".to_string()
    );

    // Success criteria for FastAPI app
    goal.add_criterion("FastAPI application structure with routers".to_string());
    goal.add_criterion("Database models using SQLAlchemy".to_string());
    goal.add_criterion("RESTful API endpoints with CRUD operations".to_string());
    goal.add_criterion("Request/response schemas using Pydantic".to_string());
    goal.add_criterion("Authentication and authorization middleware".to_string());
    goal.add_criterion("Database migrations with Alembic".to_string());
    goal.add_criterion("Configuration management with environment variables".to_string());
    goal.add_criterion("Unit and integration test examples".to_string());
    goal.add_criterion("Docker setup for containerization".to_string());

    // Sub-goals
    goal.add_sub_goal("Design REST API endpoints structure".to_string(), 0);
    goal.add_sub_goal("Create Pydantic models for request/response validation".to_string(), 1);
    goal.add_sub_goal("Set up SQLAlchemy ORM with database models".to_string(), 2);
    goal.add_sub_goal("Implement CRUD routers for resources".to_string(), 3);
    goal.add_sub_goal("Add authentication and JWT tokens".to_string(), 4);
    goal.add_sub_goal("Create Alembic migrations setup".to_string(), 5);
    goal.add_sub_goal("Set up configuration with environment variables".to_string(), 6);
    goal.add_sub_goal("Create test fixtures and example tests".to_string(), 7);
    goal.add_sub_goal("Generate Docker and docker-compose files".to_string(), 8);
    goal.add_sub_goal("Create comprehensive API documentation".to_string(), 9);

    goal.status = GoalStatus::InProgress;
    agent.set_goal(goal.clone());

    let task = TaskRequest::new(
        "Generate a production-ready FastAPI web application with:\n\
         1. Modular project structure with routers for different resources\n\
         2. Pydantic models for request/response validation\n\
         3. SQLAlchemy ORM setup with database models\n\
         4. CRUD operations for users, products, and orders\n\
         5. JWT authentication and authorization middleware\n\
         6. Role-based access control (RBAC)\n\
         7. Alembic database migrations\n\
         8. Environment configuration (.env support)\n\
         9. Error handling with proper HTTP status codes\n\
         10. Logging configuration\n\
         11. Unit tests with pytest\n\
         12. Integration tests with test database\n\
         13. Docker and docker-compose for local development\n\
         14. requirements.txt with all dependencies\n\
         15. Comprehensive API documentation\n\
         Use async/await patterns, follow REST conventions, and include examples."
    );

    println!("📝 Task: Generate FastAPI Web Application\n");
    println!("🎯 FastAPI Features:");
    for criterion in &goal.success_criteria {
        println!("  ✓ {}", criterion.description);
    }

    println!("\n⏳ Agent is generating FastAPI app...\n");
    let response = agent.run(task).await;

    let output = extract_output_text(&response.result());
    println!("📄 Generated Output:\n");
    println!("{}\n", output);

    println!("📊 Goal Progress: {}%", goal.get_progress());
    println!("\n✅ Example 2 completed!\n");
}

// ============================================
// Example 3: Python Data Science Project
// ============================================

async fn example_3_data_science_project() {
    println!("\n=== Example 3: Generate Python Data Science Project ===\n");

    let mut agent = Agent::new("DataScienceGenerator", "ollama::gemma3:latest");

    let mut goal = Goal::new(
        "Generate a data science project with ML pipeline and analysis".to_string()
    );

    goal.add_criterion("Project structure following cookiecutter-data-science".to_string());
    goal.add_criterion("Data loading and preprocessing modules".to_string());
    goal.add_criterion("Exploratory data analysis (EDA) notebooks".to_string());
    goal.add_criterion("Feature engineering pipeline".to_string());
    goal.add_criterion("Model training and evaluation".to_string());
    goal.add_criterion("Hyperparameter tuning setup".to_string());
    goal.add_criterion("Model persistence and versioning".to_string());
    goal.add_criterion("Visualization utilities".to_string());
    goal.add_criterion("Unit tests for data pipeline".to_string());

    goal.add_sub_goal("Create cookiecutter-style directory structure".to_string(), 0);
    goal.add_sub_goal("Set up Jupyter notebook for EDA".to_string(), 1);
    goal.add_sub_goal("Create data loading and preprocessing modules".to_string(), 2);
    goal.add_sub_goal("Implement feature engineering pipeline".to_string(), 3);
    goal.add_sub_goal("Set up scikit-learn model training".to_string(), 4);
    goal.add_sub_goal("Create model evaluation and metrics".to_string(), 5);
    goal.add_sub_goal("Implement hyperparameter tuning with GridSearchCV".to_string(), 6);
    goal.add_sub_goal("Add model persistence with joblib/pickle".to_string(), 7);
    goal.add_sub_goal("Create visualization utilities with matplotlib/seaborn".to_string(), 8);
    goal.add_sub_goal("Write tests for data pipeline".to_string(), 9);

    goal.status = GoalStatus::InProgress;
    agent.set_goal(goal.clone());

    let task = TaskRequest::new(
        "Generate a comprehensive Python data science project with:\n\
         1. Proper project structure for data science work\n\
         2. Data loading module supporting CSV, JSON, Parquet\n\
         3. Data preprocessing and validation pipeline\n\
         4. Exploratory Data Analysis (EDA) notebook template\n\
         5. Feature engineering module\n\
         6. Model training with scikit-learn or XGBoost\n\
         7. Cross-validation and evaluation metrics\n\
         8. Hyperparameter tuning with GridSearchCV/RandomSearch\n\
         9. Model persistence and loading utilities\n\
         10. Visualization utilities (matplotlib, seaborn, plotly)\n\
         11. Unit tests for data loading and preprocessing\n\
         12. Configuration management for experiments\n\
         13. Logging for training pipeline\n\
         14. Requirements.txt with ML libraries (pandas, numpy, scikit-learn)\n\
         15. Makefile for common tasks\n\
         16. README with dataset description and results\n\
         Include example workflows and best practices for reproducibility."
    );

    println!("📝 Task: Generate Data Science Project\n");
    println!("🎯 Data Science Features:");
    for criterion in &goal.success_criteria {
        println!("  ✓ {}", criterion.description);
    }

    println!("\n⏳ Agent is generating data science project...\n");
    let response = agent.run(task).await;

    let output = extract_output_text(&response.result());
    println!("📄 Generated Output:\n");
    println!("{}\n", output);

    println!("📊 Goal Progress: {}%", goal.get_progress());
    println!("\n✅ Example 3 completed!\n");
}

// ============================================
// Example 4: Python Package/Library
// ============================================

async fn example_4_python_library() {
    println!("\n=== Example 4: Generate Python Library/Package ===\n");

    let mut agent = Agent::new("PythonLibraryGenerator", "ollama::gemma3:latest");

    let mut goal = Goal::new(
        "Generate a well-structured Python package ready for distribution".to_string()
    );

    goal.add_criterion("Proper package structure with namespace".to_string());
    goal.add_criterion("setup.py and pyproject.toml for distribution".to_string());
    goal.add_criterion("Comprehensive docstrings and type hints".to_string());
    goal.add_criterion("Unit tests with pytest".to_string());
    goal.add_criterion("Documentation with Sphinx".to_string());
    goal.add_criterion("CI/CD configuration (GitHub Actions)".to_string());
    goal.add_criterion("Version management strategy".to_string());
    goal.add_criterion("Contributing guidelines".to_string());

    goal.add_sub_goal("Create package structure with __init__.py files".to_string(), 0);
    goal.add_sub_goal("Write setup.py and pyproject.toml".to_string(), 1);
    goal.add_sub_goal("Create core modules with type hints".to_string(), 2);
    goal.add_sub_goal("Add comprehensive docstrings".to_string(), 3);
    goal.add_sub_goal("Create test structure with pytest".to_string(), 4);
    goal.add_sub_goal("Set up documentation with Sphinx".to_string(), 5);
    goal.add_sub_goal("Create GitHub Actions workflows".to_string(), 6);
    goal.add_sub_goal("Add CONTRIBUTING.md and CODE_OF_CONDUCT.md".to_string(), 7);
    goal.add_sub_goal("Create MANIFEST.in and manifest files".to_string(), 8);

    goal.status = GoalStatus::InProgress;
    agent.set_goal(goal.clone());

    let task = TaskRequest::new(
        "Generate a professional Python library/package with:\n\
         1. Standard package structure (src layout)\n\
         2. __init__.py with version and exports\n\
         3. Core modules with complete implementations\n\
         4. Type hints throughout (PEP 484)\n\
         5. Comprehensive docstrings (Google style)\n\
         6. setup.py with metadata\n\
         7. pyproject.toml with build system\n\
         8. MANIFEST.in for package data\n\
         9. Pytest test structure with fixtures\n\
         10. pytest.ini configuration\n\
         11. Sphinx documentation setup\n\
         12. GitHub Actions workflow for CI/CD\n\
         13. Pre-commit hooks configuration\n\
         14. LICENSE (MIT or Apache 2.0)\n\
         15. .gitignore for Python\n\
         16. README.md with installation and usage\n\
         17. CONTRIBUTING.md for contributors\n\
         18. CODE_OF_CONDUCT.md\n\
         19. Changelog/HISTORY.md template\n\
         20. Version management with __version__\n\
         Include examples for public API and best practices for library development."
    );

    println!("📝 Task: Generate Python Library Package\n");
    println!("🎯 Library Features:");
    for criterion in &goal.success_criteria {
        println!("  ✓ {}", criterion.description);
    }

    println!("\n⏳ Agent is generating Python library...\n");
    let response = agent.run(task).await;

    let output = extract_output_text(&response.result());
    println!("📄 Generated Output:\n");
    println!("{}\n", output);

    println!("📊 Goal Progress: {}%", goal.get_progress());
    println!("\n✅ Example 4 completed!\n");
}

// ============================================
// Example 5: Django Web Application
// ============================================

async fn example_5_django_web_app() {
    println!("\n=== Example 5: Generate Django Web Application ===\n");

    let mut agent = Agent::new("DjangoGenerator", "ollama::gemma3:latest");

    let mut goal = Goal::new(
        "Generate a complete Django web application with admin and authentication".to_string()
    );

    goal.add_criterion("Django project structure with multiple apps".to_string());
    goal.add_criterion("Custom user model implementation".to_string());
    goal.add_criterion("Database models for core features".to_string());
    goal.add_criterion("Admin interface customization".to_string());
    goal.add_criterion("Views and URL routing".to_string());
    goal.add_criterion("Templates with Bootstrap styling".to_string());
    goal.add_criterion("Authentication and permissions".to_string());
    goal.add_criterion("Database migrations".to_string());
    goal.add_criterion("Django REST Framework API".to_string());

    goal.add_sub_goal("Create Django project and app structure".to_string(), 0);
    goal.add_sub_goal("Design and implement custom user model".to_string(), 1);
    goal.add_sub_goal("Create models for core features".to_string(), 2);
    goal.add_sub_goal("Configure admin interface".to_string(), 3);
    goal.add_sub_goal("Create views and templates".to_string(), 4);
    goal.add_sub_goal("Set up URL routing".to_string(), 5);
    goal.add_sub_goal("Implement authentication views".to_string(), 6);
    goal.add_sub_goal("Create Django REST Framework serializers".to_string(), 7);
    goal.add_sub_goal("Set up static files and media handling".to_string(), 8);

    goal.status = GoalStatus::InProgress;
    agent.set_goal(goal.clone());

    let task = TaskRequest::new(
        "Generate a full-featured Django web application with:\n\
         1. Django project structure with multiple apps\n\
         2. Custom user model extending AbstractBaseUser\n\
         3. Models for main features (e.g., Blog posts, Comments, Categories)\n\
         4. Django ORM relationships (ForeignKey, ManyToMany)\n\
         5. Admin interface with custom actions\n\
         6. Class-based views (ListView, DetailView, CreateView)\n\
         7. Django templates with template inheritance\n\
         8. Bootstrap styling integration\n\
         9. Authentication and login required decorators\n\
         10. Permission-based access control\n\
         11. Database migrations\n\
         12. Forms with validation\n\
         13. Django REST Framework setup\n\
         14. API serializers and viewsets\n\
         15. Pagination and filtering\n\
         16. Settings for dev and production\n\
         17. Environment variable configuration\n\
         18. Logging configuration\n\
         19. Tests with Django TestCase\n\
         20. Static files and media management\n\
         21. Docker setup\n\
         22. Requirements.txt\n\
         Include examples and docstrings following Django conventions."
    );

    println!("📝 Task: Generate Django Web Application\n");
    println!("🎯 Django Features:");
    for criterion in &goal.success_criteria {
        println!("  ✓ {}", criterion.description);
    }

    println!("\n⏳ Agent is generating Django app...\n");
    let response = agent.run(task).await;

    let output = extract_output_text(&response.result());
    println!("📄 Generated Output:\n");
    println!("{}\n", output);

    println!("📊 Goal Progress: {}%", goal.get_progress());
    println!("\n✅ Example 5 completed!\n");
}

// ============================================
// Example 6: Output Extraction and Organization
// ============================================

async fn example_6_output_extraction() {
    println!("\n=== Example 6: Output Extraction and File Organization ===\n");

    let mut agent = Agent::new("PythonFileProcessor", "ollama::gemma3:latest");

    // Create a task to generate specific files
    let task = TaskRequest::new(
        "Generate ONLY the following Python project files in proper format:\n\
         1. A requirements.txt with common Python dependencies\n\
         2. A setup.py for package setup\n\
         3. A .gitignore for Python projects\n\
         4. A main.py entry point\n\
         5. A config.py module\n\
         Format each file with proper headers like:\n\
         === FILE: requirements.txt ===\n\
         [file content]\n\
         === FILE: setup.py ===\n\
         [file content]\n\
         Make sure each file is complete and ready to use."
    );

    println!("📝 Task: Generate Core Python Project Files\n");
    println!("⏳ Processing...\n");

    let response = agent.run(task).await;
    let output = extract_output_text(&response.result());

    // Parse output by file
    let files: HashMap<String, String> = parse_output_by_file(&output);

    println!("📦 Generated Python Files:\n");
    let mut total_lines = 0;
    let mut total_bytes = 0;

    for (filename, content) in &files {
        let lines = content.lines().count();
        let bytes = content.len();
        total_lines += lines;
        total_bytes += bytes;

        println!("📄 File: {}", filename);
        println!("   Lines: {}", lines);
        println!("   Size: {} bytes", bytes);

        if lines <= 10 {
            println!("   Preview:");
            for line in content.lines() {
                println!("     {}", line);
            }
        }
        println!();
    }

    println!("📊 Project Statistics:");
    println!("  Total Files: {}", files.len());
    println!("  Total Lines: {}", total_lines);
    println!("  Total Size: {} bytes", total_bytes);

    // Attempt to write files to disk
    let output_folder = "generated_python_project";
    match write_files_to_disk(&files, output_folder) {
        Ok(_) => {
            let mut full_path = std::env::current_dir().unwrap();
            full_path.push(output_folder);
            println!("\n✅ All files written to: {}", full_path.display());
        }
        Err(e) => {
            eprintln!("\n⚠️  Failed to write files to disk: {}", e);
        }
    }

    println!("\n✅ Example 6 completed!\n");
}

// ============================================
// Main function
// ============================================

#[tokio::main]
async fn main() {
    println!("🚀 Ceylon Agent - Python Project Generator Examples\n");
    println!("This example demonstrates how to use Ceylon agents to:");
    println!("  • Generate Python projects of various types");
    println!("  • Create project structures and configuration files");
    println!("  • Generate boilerplate code and dependencies");
    println!("  • Extract and organize generated files\n");
    println!("━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\n");

    // Run examples
    example_1_basic_cli_app().await;
    example_2_fastapi_web_app().await;
    example_3_data_science_project().await;
    example_4_python_library().await;
    example_5_django_web_app().await;
    example_6_output_extraction().await;

    println!("━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━");
    println!("\n✅ All Python project generator examples completed successfully!\n");

    println!("📚 Key Takeaways:");
    println!("  1. Goals structure project generation into clear steps");
    println!("  2. Success criteria define required files and features");
    println!("  3. Different Python project types have distinct requirements");
    println!("  4. Extract output and parse by file sections");
    println!("  5. Combine with tools for actual file system operations\n");

    println!("🔗 Python Project Types Demonstrated:");
    println!("  • CLI Applications (Click, Typer, argparse)");
    println!("  • Web APIs (FastAPI with async patterns)");
    println!("  • Data Science (ML pipelines with scikit-learn)");
    println!("  • Libraries/Packages (for PyPI distribution)");
    println!("  • Web Frameworks (Django with full-stack features)\n");

    println!("⚙️ Next steps:");
    println!("  • Add tools to write generated files to disk");
    println!("  • Create tools for running pip install, pytest, and other commands");
    println!("  • Integrate with virtual environment creation");
    println!("  • Add validation tools to verify Python syntax");
    println!("  • Store generated code in memory for multi-step workflows");
    println!("  • Add tools for running linting (flake8, black) and type checking (mypy)\n");

    println!("💡 Example: Connecting to Tools");
    println!("```rust");
    println!("// Create file writing tool");
    println!("let file_tool = FileWriterTool::new(\"/path/to/project\");");
    println!("agent.add_tool(Arc::new(file_tool));");
    println!("");
    println!("// Create virtual environment tool");
    println!("let venv_tool = VenvTool::new();");
    println!("agent.add_tool(Arc::new(venv_tool));");
    println!("");
    println!("// Agent can now create complete projects");
    println!("let response = agent.run(task).await;");
    println!("```\n");
}

/*

PYTHON PROJECT GENERATION WORKFLOW:

1. ANALYZE PROJECT TYPE
   └─ Determine project category (CLI, Web, Library, etc)
   └─ Identify required dependencies
   └─ Plan directory structure

2. CREATE GOAL
   └─ Define what files project should contain
   └─ List success criteria (setup.py, tests, etc)
   └─ Break into generation steps

3. CREATE TASK
   └─ Request comprehensive project generation
   └─ Include tech stack and frameworks
   └─ Specify features and structure

4. RUN AGENT
   └─ Agent generates code and configuration
   └─ Returns as OutputData::Text

5. EXTRACT OUTPUT
   └─ Convert OutputData to String
   └─ Parse by file sections (=== FILE: name ===)
   └─ Extract individual files

6. SAVE TO DISK (optional with tools)
   └─ Create project directory structure
   └─ Write each file to correct location
   └─ Create virtual environment
   └─ Run pip install from requirements.txt

EXAMPLE OUTPUT STRUCTURE:

=== FILE: requirements.txt ===
fastapi==0.104.0
sqlalchemy==2.0.0
pydantic==2.0.0
python-dotenv==1.0.0

=== FILE: setup.py ===
from setuptools import setup, find_packages

setup(
    name="my-project",
    version="0.1.0",
    ...
)

=== FILE: pyproject.toml ===
[build-system]
requires = ["setuptools>=45", "wheel"]
build-backend = "setuptools.build_meta"

[project]
name = "my-project"
version = "0.1.0"

=== FILE: main.py ===
def main():
    print("Hello, World!")

if __name__ == "__main__":
    main()

PYTHON PROJECT TYPES SUPPORTED:

1. CLI APPLICATIONS
   └─ Click, Typer, argparse
   └─ Single-file or modular
   └─ Good for utility scripts

2. WEB FRAMEWORKS
   └─ FastAPI (async, modern)
   └─ Flask (lightweight)
   └─ Django (full-featured)

3. LIBRARIES/PACKAGES
   └─ Designed for PyPI distribution
   └─ Proper metadata and versioning
   └─ Comprehensive documentation

4. DATA SCIENCE PROJECTS
   └─ Jupyter notebooks
   └─ ML pipelines
   └─ Data analysis workflows

5. DESKTOP APPLICATIONS
   └─ PyQt, Tkinter, PySimpleGUI
   └─ GUI frameworks
   └─ Cross-platform support

*/