new

src/.streamlit/config.toml

@@ -1,11 +0,0 @@
-[global]
-developmentMode = false
-
-[browser]
-gatherUsageStats = false
-
-[theme]
-primaryColor = "#FF6B6B"
-backgroundColor = "#FFFFFF"
-secondaryBackgroundColor = "#F0F2F6"
-textColor = "#262730" 

src/DEPLOYMENT.md

@@ -1,168 +0,0 @@
-# 🚀 Deployment Guide: Hugging Face Spaces
-
-## Quick Start (5 minutes)
-
-### Step 1: Prepare Your Repository
-1. **Create a GitHub repository** with your project files
-2. **Upload all files** from this directory to your GitHub repo
-3. **Make sure you have**:
-   - `app.py` (main Streamlit app)
-   - `fine.py` (AI tutor implementation)
-   - `requirements.txt` (dependencies)
-   - `README.md` (documentation)
-
-### Step 2: Create Hugging Face Space
-1. **Go to** [huggingface.co/spaces](https://huggingface.co/spaces)
-2. **Click** "Create new Space"
-3. **Fill in the details**:
-   - **Owner**: Your HF username
-   - **Space name**: `ai-programming-tutor`
-   - **License**: Choose appropriate license
-   - **SDK**: Select **Streamlit**
-   - **Python version**: 3.10
-4. **Click** "Create Space"
-
-### Step 3: Connect Your Repository
-1. **In your Space settings**, go to "Repository" tab
-2. **Select** "GitHub repository"
-3. **Choose** your GitHub repository
-4. **Set the main file** to `app.py`
-5. **Click** "Save"
-
-### Step 4: Upload Your Fine-tuned Model
-1. **In your Space**, go to "Files" tab
-2. **Create a folder** called `model`
-3. **Upload your fine-tuned model files**:
-   - `model-00001-of-00006.safetensors`
-   - `model-00002-of-00006.safetensors`
-   - `model-00003-of-00006.safetensors`
-   - `model-00004-of-00006.safetensors`
-   - `model-00005-of-00006.safetensors`
-   - `model-00006-of-00006.safetensors`
-   - `config.json`
-   - `tokenizer.json`
-   - `tokenizer.model`
-   - `tokenizer_config.json`
-   - `special_tokens_map.json`
-   - `generation_config.json`
-
-### Step 5: Update Model Path
-1. **Edit** `app.py` in your Space
-2. **Change the model path** to:
-   ```python
-   model_path = "./model"  # Path to uploaded model
-   ```
-3. **Save** the changes
-
-### Step 6: Deploy
-1. **Your Space will automatically build** and deploy
-2. **Wait for the build to complete** (5-10 minutes)
-3. **Your app will be live** at: `https://huggingface.co/spaces/YOUR_USERNAME/ai-programming-tutor`
-
-## 🎯 Advanced Configuration
-
-### Hardware Settings
-- **CPU**: Default (sufficient for inference)
-- **GPU**: T4 (recommended for faster inference)
-- **Memory**: 16GB+ (required for 7B model)
-
-### Environment Variables
-Add these in your Space settings:
-```
-TOKENIZERS_PARALLELISM=false
-DATASETS_DISABLE_MULTIPROCESSING=1
-```
-
-### Custom Domain (Optional)
-1. **In Space settings**, go to "Settings" tab
-2. **Enable** "Custom domain"
-3. **Add your domain** (e.g., `tutor.yourdomain.com`)
-
-## 🔧 Troubleshooting
-
-### Common Issues
-
-**Issue**: Model not loading
-- **Solution**: Check model path and file structure
-- **Debug**: Look at Space logs in "Settings" → "Logs"
-
-**Issue**: Out of memory
-- **Solution**: Upgrade to GPU hardware
-- **Alternative**: Use demo mode
-
-**Issue**: Build fails
-- **Solution**: Check `requirements.txt` for missing dependencies
-- **Debug**: Review build logs
-
-### Performance Optimization
-
-1. **Enable GPU** in Space settings
-2. **Use model quantization** for faster inference
-3. **Implement caching** for repeated requests
-4. **Add rate limiting** to prevent abuse
-
-## 📊 Monitoring
-
-### Usage Analytics
-- **View usage** in Space settings
-- **Monitor performance** with built-in metrics
-- **Track user engagement** through logs
-
-### Cost Management
-- **Free tier**: 16 hours/month GPU time
-- **Pro tier**: $9/month for unlimited GPU
-- **Enterprise**: Custom pricing
-
-## 🌐 Sharing Your App
-
-### Public Access
-1. **Set Space to public** in settings
-2. **Share the URL** with users
-3. **Add to HF Spaces showcase**
-
-### Embedding
-```html
-<iframe
-  src="https://huggingface.co/spaces/YOUR_USERNAME/ai-programming-tutor"
-  width="100%"
-  height="800px"
-  frameborder="0"
-></iframe>
-```
-
-## 🔒 Security Considerations
-
-1. **Input validation** for code submissions
-2. **Rate limiting** to prevent abuse
-3. **Content filtering** for inappropriate code
-4. **User authentication** (optional)
-
-## 📈 Scaling
-
-### For High Traffic
-1. **Upgrade to Pro tier** for unlimited GPU
-2. **Implement caching** with Redis
-3. **Use load balancing** for multiple instances
-4. **Monitor performance** and optimize
-
-### For Production Use
-1. **Add user authentication**
-2. **Implement logging** and analytics
-3. **Set up monitoring** and alerts
-4. **Create backup** and recovery procedures
-
-## 🎉 Success!
-
-Your AI Programming Tutor is now live and accessible to students worldwide! 
-
-**Next steps**:
-1. **Test thoroughly** with different code examples
-2. **Gather user feedback** and iterate
-3. **Share with your target audience**
-4. **Monitor usage** and improve based on data
-
-## 📞 Support
-
-- **Hugging Face Docs**: [docs.huggingface.co](https://docs.huggingface.co)
-- **Spaces Documentation**: [huggingface.co/docs/hub/spaces](https://huggingface.co/docs/hub/spaces)
-- **Community Forum**: [discuss.huggingface.co](https://discuss.huggingface.co) 

src/README.md

@@ -1,185 +0,0 @@
-# 🎓 Generative AI for Programming Education
-
-## 🚀 Live Demo
-**Hugging Face Spaces**: [Coming Soon - Deploy using DEPLOYMENT.md guide]
-
-## 📋 Problem Statement
-Current programming education struggles with high dropout rates, inefficient feedback loops, and a lack of personalized learning—problems exacerbated by limited instructor bandwidth. While Generative AI (e.g., Copilot, ChatGPT) can help, most tools prioritize productivity over learning, offering code solutions without explanations or tailored guidance. This risks student over-reliance without deeper comprehension.
-
-## 🎯 Solution
-To address this gap, we fine-tuned **CodeLlama-7B** to provide structured, educational code feedback—not just correct answers. Our model analyzes student code and delivers:
-
-- **Instant, actionable reviews** (e.g., "This loop can be optimized from O(n²) to O(n) using a hashmap")
-- **Beginner-friendly explanations** (e.g., "In Python, list.append() modifies the list in-place but returns None—that's why your print() shows None")
-- **Personalized adaptation** (e.g., adjusting feedback depth based on inferred skill level)
-
-Unlike generic AI tools, our system is explicitly designed for education, balancing correctness, pedagogy, and ethical safeguards against over-reliance.
-
-## ✨ Features
-
-### 🧠 **Fine-tuned CodeLlama-7B Model**
-- Trained on **code review** and **code feedback** datasets
-- **7B parameters** for comprehensive understanding
-- **Educational focus** rather than productivity optimization
-
-### 📊 **Progressive Learning Interface**
-- **5-stage educational process**:
-  1. **Code Analysis** - Strengths, weaknesses, issues
-  2. **Improvement Guide** - Step-by-step instructions
-  3. **Learning Points** - Key concepts and objectives
-  4. **Comprehension Quiz** - Test understanding
-  5. **Code Fix** - Improved solution (only after learning)
-
-### 🎓 **Educational Features**
-- **Student Level Adaptation** (Beginner/Intermediate/Advanced)
-- **Comprehension Questions** generated by the model
-- **Learning Objectives** for each feedback
-- **Step-by-step improvement guides**
-- **Algorithm complexity explanations**
-
-### 🛡️ **Ethical Safeguards**
-- **Progressive learning flow** prevents solution jumping
-- **Comprehension testing** before showing fixes
-- **Educational explanations** rather than quick answers
-- **Best practices promotion**
-
-## 🚀 **Hugging Face Spaces Deployment**
-
-### **Hardware Specifications**
-- **CPU**: 2 vCPU (virtual CPU cores)
-- **RAM**: 16 GB
-- **Plan**: FREE tier
-- **Storage**: Sufficient for model and application
-
-### **Optimization Features**
-- ✅ **16GB RAM optimization** for fine-tuned model
-- ✅ **CPU-only inference** (no GPU required)
-- ✅ **Memory management** with gradient checkpointing
-- ✅ **Demo mode** for immediate testing
-- ✅ **Progressive loading** with fallback options
-
-### **Performance Expectations**
-- **Demo Mode**: Instant response
-- **Fine-tuned Model**: 5-10 minutes initial loading
-- **Memory Usage**: Optimized for 16GB constraint
-- **Concurrent Users**: Limited by CPU cores
-
-## 🛠️ Installation & Setup
-
-### **Local Development**
-```bash
-# Clone the repository
-git clone https://github.com/TomoriFarouk/GenAI-For-Programming-Language.git
-cd GenAI-For-Programming-Language
-
-# Install dependencies
-pip install -r requirements.txt
-
-# Run the application
-streamlit run app.py
-```
-
-### **Hugging Face Spaces Deployment**
-Follow the detailed guide in `DEPLOYMENT.md` for step-by-step instructions.
-
-## 📁 Project Structure
-
-```
-GenAI-For-Programming-Language/
-├── app.py                    # Main Streamlit interface (HF Spaces optimized)
-├── fine.py                   # Fine-tuned model integration
-├── config.py                 # Configuration settings
-├── requirements.txt          # Dependencies
-├── README.md                 # This file
-├── DEPLOYMENT.md            # HF Spaces deployment guide
-├── .gitignore               # Excludes model files
-├── .gitattributes           # File type configuration
-└── example_usage.py         # Usage examples
-```
-
-## 🧠 Model Architecture
-
-### **Base Model**
-- **CodeLlama-7B-Instruct-hf**
-- **7 billion parameters**
-- **Code-specific training**
-
-### **Fine-tuning Datasets**
-1. **Code Review Dataset**: Structured feedback on code quality
-2. **Code Feedback Dataset**: Educational explanations and improvements
-
-### **Training Process**
-- **LoRA fine-tuning** for efficiency
-- **Educational prompt engineering**
-- **Multi-stage feedback generation**
-
-## 🎯 Usage Examples
-
-### **Input Code**
-```python
-def find_duplicates(numbers):
-    x = []
-    for i in range(len(numbers)):
-        for j in range(i+1, len(numbers)):
-            if numbers[i] == numbers[j]:
-                x.append(numbers[i])
-    return x
-```
-
-### **Generated Feedback**
-1. **Analysis**: Identifies O(n²) complexity, poor variable naming
-2. **Improvement Guide**: Step-by-step optimization instructions
-3. **Learning Points**: Algorithm complexity, naming conventions
-4. **Quiz**: "What is the time complexity and how to improve it?"
-5. **Code Fix**: Optimized O(n) solution with better naming
-
-## 🔧 Configuration
-
-### **Model Settings**
-- **Path**: `./model` (for HF Spaces)
-- **Device**: CPU-optimized for 16GB RAM
-- **Memory**: Gradient checkpointing enabled
-
-### **Educational Settings**
-- **Student Levels**: Beginner, Intermediate, Advanced
-- **Feedback Types**: Syntax, Logic, Optimization, Style
-- **Learning Objectives**: Comprehensive programming concepts
-
-## 🚀 Performance
-
-### **Local Environment**
-- **GPU**: Recommended for faster inference
-- **RAM**: 16GB+ recommended
-- **Storage**: 30GB+ for model files
-
-### **Hugging Face Spaces**
-- **CPU**: 2 vCPU (sufficient for inference)
-- **RAM**: 16GB (optimized for this constraint)
-- **Loading Time**: 5-10 minutes for fine-tuned model
-- **Demo Mode**: Instant response
-
-## 🤝 Contributing
-
-1. Fork the repository
-2. Create a feature branch
-3. Make your changes
-4. Test thoroughly
-5. Submit a pull request
-
-## 📄 License
-
-This project is licensed under the MIT License - see the LICENSE file for details.
-
-## 🙏 Acknowledgments
-
-- **CodeLlama team** for the base model
-- **Hugging Face** for the Spaces platform
-- **Streamlit** for the web interface framework
-
-## 📞 Contact
-
-For questions or support, please open an issue on GitHub.
-
----
-
-**🎓 Empowering programming education through AI-driven, structured learning experiences.** 

src/config.py

@@ -1,126 +0,0 @@
-"""
-Configuration file for the Generative AI Programming Education project
-"""
-
-import os
-from pathlib import Path
-
-# Model Configuration
-MODEL_CONFIG = {
-    # Path to your fine-tuned CodeLlama-7B model
-    "model_path": "./model",  # For Hugging Face Spaces deployment
-
-    # Model generation parameters
-    "max_new_tokens": 512,
-    "temperature": 0.7,
-    "do_sample": True,
-    "top_p": 0.9,
-    "top_k": 50,
-
-    # Input processing
-    "max_input_length": 2048,
-    "truncation": True,
-
-    # Device configuration
-    "device_map": "auto",
-    "torch_dtype": "float16",
-    "trust_remote_code": True
-}
-
-# Dataset Configuration (for reference)
-DATASET_CONFIG = {
-    "code_review_dataset": "path/to/your/code_review_dataset",
-    "code_feedback_dataset": "path/to/your/code_feedback_dataset",
-    "training_data_format": "json",  # or "csv", "txt"
-}
-
-# Educational Levels
-STUDENT_LEVELS = {
-    "beginner": {
-        "description": "Students new to programming",
-        "feedback_style": "explanatory",
-        "include_basics": True,
-        "complexity_threshold": "low"
-    },
-    "intermediate": {
-        "description": "Students with basic programming knowledge",
-        "feedback_style": "balanced",
-        "include_basics": False,
-        "complexity_threshold": "medium"
-    },
-    "advanced": {
-        "description": "Students with strong programming background",
-        "feedback_style": "technical",
-        "include_basics": False,
-        "complexity_threshold": "high"
-    }
-}
-
-# Feedback Types
-FEEDBACK_TYPES = [
-    "syntax",
-    "logic",
-    "optimization",
-    "style",
-    "explanation",
-    "comprehensive_review",
-    "educational_guidance"
-]
-
-# Learning Objectives
-LEARNING_OBJECTIVES = [
-    "syntax",
-    "basic_python",
-    "control_flow",
-    "loops",
-    "variables",
-    "code_cleanliness",
-    "algorithms",
-    "complexity",
-    "optimization",
-    "naming_conventions",
-    "readability",
-    "code_analysis",
-    "best_practices",
-    "learning",
-    "improvement"
-]
-
-# Logging Configuration
-LOGGING_CONFIG = {
-    "level": "INFO",
-    "format": "%(asctime)s - %(name)s - %(levelname)s - %(message)s",
-    "file": "programming_education_ai.log"
-}
-
-# Ethical Safeguards
-ETHICAL_CONFIG = {
-    "prevent_over_reliance": True,
-    "encourage_learning": True,
-    "provide_explanations": True,
-    "suggest_alternatives": True,
-    "promote_best_practices": True
-}
-
-
-def get_model_path():
-    """Get the model path from environment variable or config"""
-    return os.getenv("FINETUNED_MODEL_PATH", MODEL_CONFIG["model_path"])
-
-
-def validate_config():
-    """Validate the configuration settings"""
-    model_path = get_model_path()
-    if not os.path.exists(model_path):
-        print(f"Warning: Model path does not exist: {model_path}")
-        print("Please update the model_path in config.py or set FINETUNED_MODEL_PATH environment variable")
-        return False
-    return True
-
-
-if __name__ == "__main__":
-    print("Configuration loaded successfully!")
-    print(f"Model path: {get_model_path()}")
-    print(f"Student levels: {list(STUDENT_LEVELS.keys())}")
-    print(f"Feedback types: {FEEDBACK_TYPES}")
-    validate_config()

src/example_usage.py

@@ -1,186 +0,0 @@
-"""
-Example Usage of the Comprehensive Educational Feedback System
-"""
-
-from fine import ProgrammingEducationAI
-import json
-
-
-def main():
-    print("🎓 Comprehensive Educational Feedback System")
-    print("=" * 60)
-
-    # Initialize the system
-    # Update this path to your actual fine-tuned model
-    model_path = r"C:\Users\farou\OneDrive - Aston University\finetunning"
-    ai_tutor = ProgrammingEducationAI(model_path)
-
-    try:
-        # Load the model
-        print("Loading fine-tuned model...")
-        ai_tutor.load_model()
-        print("✅ Model loaded successfully!")
-
-        # Example 1: Beginner student code
-        print("\n" + "="*60)
-        print("EXAMPLE 1: BEGINNER STUDENT")
-        print("="*60)
-
-        beginner_code = """
-def find_duplicates(numbers):
-    x = []
-    for i in range(len(numbers)):
-        for j in range(i+1, len(numbers)):
-            if numbers[i] == numbers[j]:
-                x.append(numbers[i])
-    return x
-
-result = find_duplicates([1, 2, 3, 2, 4, 5, 3])
-print(result)
-"""
-
-        print("Student Code:")
-        print(beginner_code)
-
-        feedback = ai_tutor.generate_comprehensive_feedback(
-            beginner_code, "beginner")
-        display_comprehensive_feedback(feedback)
-
-        # Example 2: Intermediate student code
-        print("\n" + "="*60)
-        print("EXAMPLE 2: INTERMEDIATE STUDENT")
-        print("="*60)
-
-        intermediate_code = """
-def fibonacci(n):
-    if n <= 1:
-        return n
-    return fibonacci(n-1) + fibonacci(n-2)
-
-# Calculate first 10 Fibonacci numbers
-for i in range(10):
-    print(fibonacci(i))
-"""
-
-        print("Student Code:")
-        print(intermediate_code)
-
-        feedback = ai_tutor.generate_comprehensive_feedback(
-            intermediate_code, "intermediate")
-        display_comprehensive_feedback(feedback)
-
-        # Example 3: Advanced student code
-        print("\n" + "="*60)
-        print("EXAMPLE 3: ADVANCED STUDENT")
-        print("="*60)
-
-        advanced_code = """
-class DataProcessor:
-    def __init__(self, data):
-        self.data = data
-    
-    def process(self):
-        result = []
-        for item in self.data:
-            if item > 0:
-                result.append(item * 2)
-        return result
-
-processor = DataProcessor([1, -2, 3, -4, 5])
-output = processor.process()
-print(output)
-"""
-
-        print("Student Code:")
-        print(advanced_code)
-
-        feedback = ai_tutor.generate_comprehensive_feedback(
-            advanced_code, "advanced")
-        display_comprehensive_feedback(feedback)
-
-    except Exception as e:
-        print(f"❌ Error: {e}")
-        print(
-            "💡 Make sure to update the model_path to point to your actual fine-tuned model.")
-
-
-def display_comprehensive_feedback(feedback):
-    """Display comprehensive feedback in a formatted way"""
-
-    print("\n📊 COMPREHENSIVE FEEDBACK")
-    print("-" * 40)
-
-    # Analysis
-    print("\n✅ STRENGTHS:")
-    for i, strength in enumerate(feedback.strengths, 1):
-        print(f"   {i}. {strength}")
-
-    print("\n❌ WEAKNESSES:")
-    for i, weakness in enumerate(feedback.weaknesses, 1):
-        print(f"   {i}. {weakness}")
-
-    print("\n⚠️ ISSUES:")
-    for i, issue in enumerate(feedback.issues, 1):
-        print(f"   {i}. {issue}")
-
-    # Educational content
-    print("\n📝 STEP-BY-STEP IMPROVEMENT:")
-    for i, step in enumerate(feedback.step_by_step_improvement, 1):
-        print(f"   Step {i}: {step}")
-
-    print("\n🎓 LEARNING POINTS:")
-    for i, point in enumerate(feedback.learning_points, 1):
-        print(f"   {i}. {point}")
-
-    print(f"\n📋 REVIEW SUMMARY:")
-    print(f"   {feedback.review_summary}")
-
-    # Interactive elements
-    print(f"\n❓ COMPREHENSION QUESTION:")
-    print(f"   Q: {feedback.comprehension_question}")
-    print(f"   A: {feedback.comprehension_answer}")
-    print(f"   Explanation: {feedback.explanation}")
-
-    # Code fixes
-    print(f"\n🔧 IMPROVED CODE:")
-    print(feedback.improved_code)
-
-    print(f"\n💡 FIX EXPLANATION:")
-    print(f"   {feedback.fix_explanation}")
-
-    # Metadata
-    print(f"\n📊 METADATA:")
-    print(f"   Student Level: {feedback.student_level}")
-    print(f"   Learning Objectives: {', '.join(feedback.learning_objectives)}")
-    print(
-        f"   Estimated Time to Improve: {feedback.estimated_time_to_improve}")
-
-
-def save_feedback_to_json(feedback, filename):
-    """Save feedback to JSON file for later analysis"""
-    feedback_dict = {
-        "code_snippet": feedback.code_snippet,
-        "student_level": feedback.student_level,
-        "strengths": feedback.strengths,
-        "weaknesses": feedback.weaknesses,
-        "issues": feedback.issues,
-        "step_by_step_improvement": feedback.step_by_step_improvement,
-        "learning_points": feedback.learning_points,
-        "review_summary": feedback.review_summary,
-        "comprehension_question": feedback.comprehension_question,
-        "comprehension_answer": feedback.comprehension_answer,
-        "explanation": feedback.explanation,
-        "improved_code": feedback.improved_code,
-        "fix_explanation": feedback.fix_explanation,
-        "learning_objectives": feedback.learning_objectives,
-        "estimated_time_to_improve": feedback.estimated_time_to_improve
-    }
-
-    with open(filename, 'w') as f:
-        json.dump(feedback_dict, f, indent=2)
-
-    print(f"💾 Feedback saved to {filename}")
-
-
-if __name__ == "__main__":
-    main()

src/fine.py

@@ -1,949 +0,0 @@
-"""
-Generative AI for Enhancing Programming Education
-================================================
-
-This project implements a fine-tuned CodeLlama-7B model to provide structured,
-educational code feedback for programming students.
-
-Problem Statement:
-- High dropout rates in programming education
-- Inefficient feedback loops
-- Lack of personalized learning
-- Limited instructor bandwidth
-- Current AI tools prioritize productivity over learning
-
-Solution:
-- Fine-tuned CodeLlama-7B for educational feedback
-- Structured, actionable code reviews
-- Beginner-friendly explanations
-- Personalized adaptation based on skill level
-- Educational focus with ethical safeguards
-
-Author: [Your Name]
-Date: [Current Date]
-"""
-
-import re
-from dataclasses import dataclass
-from typing import Dict, List, Optional, Tuple
-import logging
-import json
-from transformers import AutoTokenizer, AutoModelForCausalLM
-import os
-import gc
-import torch
-import warnings
-warnings.filterwarnings("ignore", category=UserWarning)
-
-# --- Critical Environment Setup (Must be before imports) ---
-os.environ["TOKENIZERS_PARALLELISM"] = "false"
-os.environ["DATASETS_DISABLE_MULTIPROCESSING"] = "1"
-
-# Clear any existing CUDA cache (only if CUDA is available)
-if torch.cuda.is_available():
-    os.environ["PYTORCH_CUDA_ALLOC_CONF"] = "max_split_size_mb:128,garbage_collection_threshold:0.6"
-    torch.cuda.empty_cache()
-    gc.collect()
-
-
-# Configure logging
-logging.basicConfig(level=logging.INFO)
-logger = logging.getLogger(__name__)
-
-
-def clear_cuda_cache():
-    """Clear CUDA cache and run garbage collection"""
-    if torch.cuda.is_available():
-        torch.cuda.empty_cache()
-        torch.cuda.synchronize()
-    gc.collect()
-
-
-def get_system_memory():
-    """Get system memory information"""
-    try:
-        import psutil
-        memory = psutil.virtual_memory()
-        print(
-            f"System RAM: {memory.used / (1024**3):.1f}GB / {memory.total / (1024**3):.1f}GB used ({memory.percent:.1f}%)")
-    except Exception as e:
-        print(f"Could not get system memory info: {e}")
-
-
-def get_gpu_memory():
-    """Get GPU memory information (if available)"""
-    if torch.cuda.is_available():
-        try:
-            import subprocess
-            result = subprocess.run(['nvidia-smi', '--query-gpu=memory.used,memory.total', '--format=csv,nounits,noheader'],
-                                    capture_output=True, text=True)
-            lines = result.stdout.strip().split('\n')
-            for i, line in enumerate(lines):
-                used, total = map(int, line.split(', '))
-                print(
-                    f"GPU {i}: {used}MB / {total}MB used ({used/total*100:.1f}%)")
-        except Exception as e:
-            print(f"Could not get GPU memory info: {e}")
-    else:
-        print("No GPU available - using CPU only")
-
-
-@dataclass
-class CodeFeedback:
-    """Data structure for storing code feedback"""
-    code_snippet: str
-    feedback_type: str  # 'syntax', 'logic', 'optimization', 'style', 'explanation'
-    feedback_message: str
-    suggested_improvement: Optional[str] = None
-    difficulty_level: str = 'beginner'  # 'beginner', 'intermediate', 'advanced'
-    learning_objectives: List[str] = None
-
-
-@dataclass
-class ComprehensiveFeedback:
-    """Comprehensive feedback structure with all educational components"""
-    code_snippet: str
-    student_level: str
-
-    # Analysis
-    strengths: List[str]
-    weaknesses: List[str]
-    issues: List[str]
-
-    # Educational content
-    step_by_step_improvement: List[str]
-    learning_points: List[str]
-    review_summary: str
-
-    # Interactive elements
-    comprehension_question: str
-    comprehension_answer: str
-    explanation: str
-
-    # Code fixes
-    improved_code: str
-    fix_explanation: str
-
-    # Metadata
-    difficulty_level: str
-    learning_objectives: List[str]
-    estimated_time_to_improve: str
-
-
-class ProgrammingEducationAI:
-    """
-    Main class for the fine-tuned CodeLlama model for programming education
-    """
-
-    def __init__(self, model_path: str = "TomoriFarouk/codellama-7b-programming-education"):
-        """
-        Initialize the fine-tuned model and tokenizer
-
-        Args:
-            model_path: Path to your fine-tuned CodeLlama-7B model
-        """
-        self.model_path = model_path
-        self.tokenizer = None
-        self.model = None
-        self.feedback_templates = self._load_feedback_templates()
-        self.code_review_prompt_template = self._load_code_review_prompt()
-        self.code_feedback_prompt_template = self._load_code_feedback_prompt()
-        self.comprehensive_feedback_prompt = self._load_comprehensive_feedback_prompt()
-        self.comprehension_question_prompt = self._load_comprehension_question_prompt()
-        self.code_fix_prompt = self._load_code_fix_prompt()
-
-    def _load_code_review_prompt(self) -> str:
-        """Load the code review prompt template used during fine-tuning"""
-        return """You are an expert programming tutor. Review the following student code and provide educational feedback.
-
-Student Code:
-{code}
-
-Student Level: {level}
-
-Please provide:
-1. Syntax errors (if any)
-2. Logic errors (if any)
-3. Style improvements
-4. Optimization suggestions
-5. Educational explanations
-
-Feedback:"""
-
-    def _load_code_feedback_prompt(self) -> str:
-        """Load the code feedback prompt template used during fine-tuning"""
-        return """You are a helpful programming tutor. The student has written this code:
-
-{code}
-
-Student Level: {level}
-
-Provide constructive, educational feedback that helps the student learn. Focus on:
-- What they did well
-- What can be improved
-- Why the improvement matters
-- How to implement the improvement
-
-Feedback:"""
-
-    def _load_feedback_templates(self) -> Dict[str, str]:
-        """Load predefined feedback templates for different scenarios"""
-        return {
-            "syntax_error": "I notice there's a syntax issue in your code. {error_description}. "
-            "Here's what's happening: {explanation}. "
-            "Try this correction: {suggestion}",
-
-            "logic_error": "Your code has a logical issue. {problem_description}. "
-            "The problem is: {explanation}. "
-            "Consider this approach: {suggestion}",
-
-            "optimization": "Your code works, but we can make it more efficient! "
-                           "Current complexity: {current_complexity}. "
-                           "Optimized version: {optimized_complexity}. "
-                           "Here's how: {explanation}",
-
-            "style_improvement": "Great work! Here's a style tip: {tip}. "
-            "This makes your code more readable and maintainable.",
-
-            "concept_explanation": "Let me explain this concept: {concept}. "
-            "In simple terms: {simple_explanation}. "
-            "Example: {example}"
-        }
-
-    def load_model(self):
-        """
-        Load the fine-tuned model and tokenizer optimized for HF Spaces
-        """
-        try:
-            # Get HF token for private model access
-            hf_token = os.getenv("HF_TOKEN", None)
-
-            logger.info("Loading tokenizer...")
-            self.tokenizer = AutoTokenizer.from_pretrained(
-                self.model_path,
-                trust_remote_code=True,
-                token=hf_token  # Use token for private models
-            )
-
-            # Set padding token
-            if self.tokenizer.pad_token is None:
-                self.tokenizer.pad_token = self.tokenizer.eos_token
-                self.tokenizer.pad_token_id = self.tokenizer.eos_token_id
-
-            logger.info(
-                f"Tokenizer loaded - Vocab size: {len(self.tokenizer)}")
-
-            # Load model optimized for HF Spaces (16GB RAM, 2 vCPU)
-            print("Loading model optimized for HF Spaces (16GB RAM, 2 vCPU)...")
-            self.model = AutoModelForCausalLM.from_pretrained(
-                self.model_path,
-                torch_dtype=torch.float32,
-                device_map=None,  # Force CPU for HF Spaces
-                low_cpu_mem_usage=True,
-                trust_remote_code=True,
-                offload_folder="offload",  # Offload to disk if needed
-                token=hf_token  # Use token for private models
-            )
-            # Enable gradient checkpointing for memory savings
-            self.model.gradient_checkpointing_enable()
-
-            logger.info("Fine-tuned model loaded successfully")
-            logger.info(f"Model loaded on devices: {self.model.hf_device_map}")
-
-        except Exception as e:
-            logger.error(f"Error loading fine-tuned model: {e}")
-            raise
-
-    def generate_code_review(self, code: str, student_level: str = "beginner") -> str:
-        """
-        Generate code review using the fine-tuned model
-
-        Args:
-            code: Student's code to review
-            student_level: Student's skill level
-
-        Returns:
-            Generated code review feedback
-        """
-        if not self.model or not self.tokenizer:
-            raise ValueError("Model not loaded. Call load_model() first.")
-
-        # Format the prompt using the template from fine-tuning
-        prompt = self.code_review_prompt_template.format(
-            code=code,
-            level=student_level
-        )
-
-        # Tokenize input
-        inputs = self.tokenizer(
-            prompt, return_tensors="pt", truncation=True, max_length=2048)
-
-        # Generate response
-        with torch.no_grad():
-            outputs = self.model.generate(
-                inputs.input_ids,
-                max_new_tokens=512,
-                temperature=0.7,
-                do_sample=True,
-                pad_token_id=self.tokenizer.eos_token_id
-            )
-
-        # Decode response
-        response = self.tokenizer.decode(outputs[0], skip_special_tokens=True)
-
-        # Extract only the generated part (after the prompt)
-        generated_text = response[len(prompt):].strip()
-
-        return generated_text
-
-    def generate_educational_feedback(self, code: str, student_level: str = "beginner") -> str:
-        """
-        Generate educational feedback using the fine-tuned model
-
-        Args:
-            code: Student's code to provide feedback on
-            student_level: Student's skill level
-
-        Returns:
-            Generated educational feedback
-        """
-        if not self.model or not self.tokenizer:
-            raise ValueError("Model not loaded. Call load_model() first.")
-
-        # Format the prompt using the template from fine-tuning
-        prompt = self.code_feedback_prompt_template.format(
-            code=code,
-            level=student_level
-        )
-
-        # Tokenize input
-        inputs = self.tokenizer(
-            prompt, return_tensors="pt", truncation=True, max_length=2048)
-
-        # Generate response
-        with torch.no_grad():
-            outputs = self.model.generate(
-                inputs.input_ids,
-                max_new_tokens=512,
-                temperature=0.7,
-                do_sample=True,
-                pad_token_id=self.tokenizer.eos_token_id
-            )
-
-        # Decode response
-        response = self.tokenizer.decode(outputs[0], skip_special_tokens=True)
-
-        # Extract only the generated part (after the prompt)
-        generated_text = response[len(prompt):].strip()
-
-        return generated_text
-
-    def analyze_student_code(self, code: str, student_level: str = "beginner") -> List[CodeFeedback]:
-        """
-        Analyze student code and provide educational feedback using the fine-tuned model
-
-        Args:
-            code: The student's code to analyze
-            student_level: Student's skill level ('beginner', 'intermediate', 'advanced')
-
-        Returns:
-            List of CodeFeedback objects
-        """
-        feedback_list = []
-
-        # Use fine-tuned model for comprehensive code review
-        try:
-            code_review = self.generate_code_review(code, student_level)
-            educational_feedback = self.generate_educational_feedback(
-                code, student_level)
-
-            # Create structured feedback from model output
-            feedback_list.append(CodeFeedback(
-                code_snippet=code,
-                feedback_type="comprehensive_review",
-                feedback_message=code_review,
-                difficulty_level=student_level,
-                learning_objectives=["code_analysis", "best_practices"]
-            ))
-
-            feedback_list.append(CodeFeedback(
-                code_snippet=code,
-                feedback_type="educational_guidance",
-                feedback_message=educational_feedback,
-                difficulty_level=student_level,
-                learning_objectives=["learning", "improvement"]
-            ))
-
-        except Exception as e:
-            logger.warning(
-                f"Fine-tuned model failed, falling back to rule-based analysis: {e}")
-            # Fallback to rule-based analysis if model fails
-            feedback_list = self._fallback_analysis(code, student_level)
-
-        return feedback_list
-
-    def _fallback_analysis(self, code: str, student_level: str) -> List[CodeFeedback]:
-        """Fallback analysis using rule-based methods if fine-tuned model fails"""
-        feedback_list = []
-
-        # Analyze syntax
-        syntax_feedback = self._check_syntax(code, student_level)
-        if syntax_feedback:
-            feedback_list.append(syntax_feedback)
-
-        # Analyze logic and structure
-        logic_feedback = self._check_logic(code, student_level)
-        if logic_feedback:
-            feedback_list.extend(logic_feedback)
-
-        # Check for optimization opportunities
-        optimization_feedback = self._check_optimization(code, student_level)
-        if optimization_feedback:
-            feedback_list.append(optimization_feedback)
-
-        # Provide style suggestions
-        style_feedback = self._check_style(code, student_level)
-        if style_feedback:
-            feedback_list.append(style_feedback)
-
-        return feedback_list
-
-    def _check_syntax(self, code: str, student_level: str) -> Optional[CodeFeedback]:
-        """Check for syntax errors and provide educational feedback"""
-        # This would integrate with the fine-tuned model
-        # For now, using basic pattern matching as placeholder
-
-        common_syntax_errors = {
-            r"print\s*\([^)]*\)\s*$": "Remember to add a colon after print statements in some contexts",
-            r"if\s+[^:]+$": "Don't forget the colon after your if condition",
-            r"for\s+[^:]+$": "Don't forget the colon after your for loop",
-        }
-
-        for pattern, message in common_syntax_errors.items():
-            if re.search(pattern, code):
-                return CodeFeedback(
-                    code_snippet=code,
-                    feedback_type="syntax",
-                    feedback_message=message,
-                    difficulty_level=student_level,
-                    learning_objectives=["syntax", "basic_python"]
-                )
-
-        return None
-
-    def _check_logic(self, code: str, student_level: str) -> List[CodeFeedback]:
-        """Check for logical errors and provide educational feedback"""
-        feedback_list = []
-
-        # Check for infinite loops
-        if "while True:" in code and "break" not in code:
-            feedback_list.append(CodeFeedback(
-                code_snippet=code,
-                feedback_type="logic",
-                feedback_message="This while loop will run forever! Make sure to include a break statement or condition to exit the loop.",
-                difficulty_level=student_level,
-                learning_objectives=["control_flow", "loops"]
-            ))
-
-        # Check for unused variables
-        # This is a simplified check - the actual model would be more sophisticated
-        if "x = " in code and "x" not in code.replace("x = ", ""):
-            feedback_list.append(CodeFeedback(
-                code_snippet=code,
-                feedback_type="logic",
-                feedback_message="You created variable 'x' but didn't use it. Consider removing unused variables to keep your code clean.",
-                difficulty_level=student_level,
-                learning_objectives=["variables", "code_cleanliness"]
-            ))
-
-        return feedback_list
-
-    def _check_optimization(self, code: str, student_level: str) -> Optional[CodeFeedback]:
-        """Check for optimization opportunities"""
-        # Check for nested loops that could be optimized
-        if code.count("for") > 1 and code.count("in range") > 1:
-            return CodeFeedback(
-                code_snippet=code,
-                feedback_type="optimization",
-                feedback_message="You have nested loops here. Consider if you can optimize this to O(n) instead of O(n²).",
-                suggested_improvement="Use a hashmap or set to reduce complexity",
-                difficulty_level=student_level,
-                learning_objectives=["algorithms",
-                                     "complexity", "optimization"]
-            )
-
-        return None
-
-    def _check_style(self, code: str, student_level: str) -> Optional[CodeFeedback]:
-        """Check for style improvements"""
-        # Check for meaningful variable names
-        if "x" in code or "y" in code or "z" in code:
-            return CodeFeedback(
-                code_snippet=code,
-                feedback_type="style",
-                feedback_message="Consider using more descriptive variable names instead of x, y, z. This makes your code easier to understand.",
-                difficulty_level=student_level,
-                learning_objectives=["naming_conventions", "readability"]
-            )
-
-        return None
-
-    def generate_explanation(self, concept: str, student_level: str) -> str:
-        """
-        Generate explanations for programming concepts based on student level
-
-        Args:
-            concept: The concept to explain
-            student_level: Student's skill level
-
-        Returns:
-            Explanation tailored to the student's level
-        """
-        explanations = {
-            "variables": {
-                "beginner": "Variables are like labeled boxes where you store information. Think of 'name = \"John\"' as putting \"John\" in a box labeled 'name'.",
-                "intermediate": "Variables are memory locations that store data. They have a name, type, and value. Python is dynamically typed, so the type is inferred.",
-                "advanced": "Variables in Python are references to objects in memory. They're dynamically typed and use reference counting for memory management."
-            },
-            "loops": {
-                "beginner": "Loops repeat code multiple times. 'for' loops are great when you know how many times to repeat, 'while' loops when you don't.",
-                "intermediate": "Loops control program flow. 'for' iterates over sequences, 'while' continues until a condition is False. Consider time complexity.",
-                "advanced": "Loops are fundamental control structures. Python's 'for' is actually a foreach loop. Consider iterator patterns and generator expressions."
-            }
-        }
-
-        return explanations.get(concept, {}).get(student_level, f"Explanation for {concept} at {student_level} level")
-
-    def _load_comprehensive_feedback_prompt(self) -> str:
-        """Load the comprehensive feedback prompt template"""
-        return """You are an expert programming tutor. Provide comprehensive educational feedback for the following student code.
-
-Student Code:
-{code}
-
-Student Level: {level}
-
-Please provide a detailed analysis in the following JSON format:
-
-{{
-    "strengths": ["strength1", "strength2", "strength3"],
-    "weaknesses": ["weakness1", "weakness2", "weakness3"],
-    "issues": ["issue1", "issue2", "issue3"],
-    "step_by_step_improvement": [
-        "Step 1: Description of first improvement",
-        "Step 2: Description of second improvement",
-        "Step 3: Description of third improvement"
-    ],
-    "learning_points": [
-        "Learning point 1: What the student should understand",
-        "Learning point 2: Key concept to grasp",
-        "Learning point 3: Best practice to follow"
-    ],
-    "review_summary": "A comprehensive review of the code highlighting key areas for improvement",
-    "learning_objectives": ["objective1", "objective2", "objective3"],
-    "estimated_time_to_improve": "5-10 minutes"
-}}
-
-Focus on educational value and constructive feedback that helps the student learn and improve."""
-
-    def _load_comprehension_question_prompt(self) -> str:
-        """Load the comprehension question generation prompt"""
-        return """Based on the learning points and improvements discussed, generate a comprehension question to test the student's understanding.
-
-Learning Points: {learning_points}
-Code Issues: {issues}
-Student Level: {level}
-
-Generate a question that tests understanding of the key concepts discussed. The question should be appropriate for the student's level.
-
-Format your response as JSON:
-{{
-    "question": "Your comprehension question here",
-    "answer": "The correct answer",
-    "explanation": "Detailed explanation of why this answer is correct"
-}}
-
-Make the question challenging but fair for the student's level."""
-
-    def _load_code_fix_prompt(self) -> str:
-        """Load the code fix generation prompt"""
-        return """You are an expert programming tutor. Based on the analysis and learning points, provide an improved version of the student's code.
-
-Original Code:
-{code}
-
-Issues Identified: {issues}
-Learning Points: {learning_points}
-Student Level: {level}
-
-Provide an improved version of the code that addresses the issues while maintaining educational value. Include comments to explain the improvements.
-
-Format your response as JSON:
-{{
-    "improved_code": "The improved code with comments",
-    "fix_explanation": "Detailed explanation of what was changed and why"
-}}
-
-Focus on educational improvements that help the student understand better practices."""
-
-    def adapt_feedback_complexity(self, feedback: CodeFeedback, student_level: str) -> CodeFeedback:
-        """
-        Adapt feedback complexity based on student level
-
-        Args:
-            feedback: Original feedback
-            student_level: Student's skill level
-
-        Returns:
-            Adapted feedback
-        """
-        if student_level == "beginner":
-            # Simplify language and add more examples
-            feedback.feedback_message = feedback.feedback_message.replace(
-                "O(n²)", "quadratic time (slower)"
-            ).replace(
-                "O(n)", "linear time (faster)"
-            )
-        elif student_level == "advanced":
-            # Add more technical details
-            if "optimization" in feedback.feedback_type:
-                feedback.feedback_message += " Consider the space-time tradeoff and cache locality."
-
-        return feedback
-
-    def generate_comprehensive_feedback(self, code: str, student_level: str = "beginner") -> ComprehensiveFeedback:
-        """
-        Generate comprehensive educational feedback with all components
-
-        Args:
-            code: Student's code to analyze
-            student_level: Student's skill level
-
-        Returns:
-            ComprehensiveFeedback object with all educational components
-        """
-        if not self.model or not self.tokenizer:
-            raise ValueError("Model not loaded. Call load_model() first.")
-
-        try:
-            # Step 1: Generate comprehensive analysis
-            comprehensive_analysis = self._generate_comprehensive_analysis(
-                code, student_level)
-
-            # Step 2: Generate comprehension question
-            comprehension_data = self._generate_comprehension_question(
-                comprehensive_analysis["learning_points"],
-                comprehensive_analysis["issues"],
-                student_level
-            )
-
-            # Step 3: Generate improved code
-            code_fix_data = self._generate_code_fix(
-                code,
-                comprehensive_analysis["issues"],
-                comprehensive_analysis["learning_points"],
-                student_level
-            )
-
-            # Create comprehensive feedback object
-            return ComprehensiveFeedback(
-                code_snippet=code,
-                student_level=student_level,
-                strengths=comprehensive_analysis["strengths"],
-                weaknesses=comprehensive_analysis["weaknesses"],
-                issues=comprehensive_analysis["issues"],
-                step_by_step_improvement=comprehensive_analysis["step_by_step_improvement"],
-                learning_points=comprehensive_analysis["learning_points"],
-                review_summary=comprehensive_analysis["review_summary"],
-                comprehension_question=comprehension_data["question"],
-                comprehension_answer=comprehension_data["answer"],
-                explanation=comprehension_data["explanation"],
-                improved_code=code_fix_data["improved_code"],
-                fix_explanation=code_fix_data["fix_explanation"],
-                difficulty_level=student_level,
-                learning_objectives=comprehensive_analysis["learning_objectives"],
-                estimated_time_to_improve=comprehensive_analysis["estimated_time_to_improve"]
-            )
-
-        except Exception as e:
-            logger.error(f"Error generating comprehensive feedback: {e}")
-            # Return a basic comprehensive feedback if model fails
-            return self._create_fallback_comprehensive_feedback(code, student_level)
-
-    def _generate_comprehensive_analysis(self, code: str, student_level: str) -> Dict:
-        """Generate comprehensive analysis using the fine-tuned model"""
-        prompt = self.comprehensive_feedback_prompt.format(
-            code=code,
-            level=student_level
-        )
-
-        response = self._generate_model_response(prompt)
-
-        try:
-            # Try to parse JSON response
-            import json
-            return json.loads(response)
-        except json.JSONDecodeError:
-            logger.warning("Failed to parse JSON response, using fallback")
-            return self._create_fallback_analysis(code, student_level)
-
-    def _generate_comprehension_question(self, learning_points: List[str], issues: List[str], student_level: str) -> Dict:
-        """Generate comprehension question using the fine-tuned model"""
-        prompt = self.comprehension_question_prompt.format(
-            learning_points=", ".join(learning_points),
-            issues=", ".join(issues),
-            level=student_level
-        )
-
-        response = self._generate_model_response(prompt)
-
-        try:
-            import json
-            return json.loads(response)
-        except json.JSONDecodeError:
-            logger.warning(
-                "Failed to parse comprehension question JSON, using fallback")
-            return {
-                "question": "What is the main concept you learned from this code review?",
-                "answer": "The main concept is understanding code structure and best practices.",
-                "explanation": "This question tests your understanding of the key learning points discussed."
-            }
-
-    def _generate_code_fix(self, code: str, issues: List[str], learning_points: List[str], student_level: str) -> Dict:
-        """Generate improved code using the fine-tuned model"""
-        prompt = self.code_fix_prompt.format(
-            code=code,
-            issues=", ".join(issues),
-            learning_points=", ".join(learning_points),
-            level=student_level
-        )
-
-        response = self._generate_model_response(prompt)
-
-        try:
-            import json
-            return json.loads(response)
-        except json.JSONDecodeError:
-            logger.warning("Failed to parse code fix JSON, using fallback")
-            return {
-                "improved_code": "# Improved version of your code\n# Add comments and improvements here",
-                "fix_explanation": "This is a fallback improved version. The model should provide specific improvements."
-            }
-
-    def _generate_model_response(self, prompt: str) -> str:
-        """Generate response from the fine-tuned model"""
-        inputs = self.tokenizer(
-            prompt, return_tensors="pt", truncation=True, max_length=2048)
-
-        # Move to CPU if no GPU available
-        if not torch.cuda.is_available():
-            inputs = {k: v.cpu() for k, v in inputs.items()}
-
-        with torch.no_grad():
-            outputs = self.model.generate(
-                inputs.input_ids,
-                max_new_tokens=512,
-                temperature=0.7,
-                do_sample=True,
-                pad_token_id=self.tokenizer.eos_token_id
-            )
-
-        response = self.tokenizer.decode(outputs[0], skip_special_tokens=True)
-        return response[len(prompt):].strip()
-
-    def _create_fallback_analysis(self, code: str, student_level: str) -> Dict:
-        """Create fallback analysis when model fails"""
-        return {
-            "strengths": ["Your code has a clear structure", "You're using appropriate data types"],
-            "weaknesses": ["Could improve variable naming", "Consider adding comments"],
-            "issues": ["Basic syntax and style issues"],
-            "step_by_step_improvement": [
-                "Step 1: Add descriptive variable names",
-                "Step 2: Include comments explaining your logic",
-                "Step 3: Consider code optimization"
-            ],
-            "learning_points": [
-                "Good variable naming improves code readability",
-                "Comments help others understand your code",
-                "Always consider efficiency in your solutions"
-            ],
-            "review_summary": "Your code works but could be improved with better practices.",
-            "learning_objectives": ["code_quality", "best_practices", "readability"],
-            "estimated_time_to_improve": "10-15 minutes"
-        }
-
-    def _create_fallback_comprehensive_feedback(self, code: str, student_level: str) -> ComprehensiveFeedback:
-        """Create fallback comprehensive feedback when model fails"""
-        fallback_analysis = self._create_fallback_analysis(code, student_level)
-
-        return ComprehensiveFeedback(
-            code_snippet=code,
-            student_level=student_level,
-            strengths=fallback_analysis["strengths"],
-            weaknesses=fallback_analysis["weaknesses"],
-            issues=fallback_analysis["issues"],
-            step_by_step_improvement=fallback_analysis["step_by_step_improvement"],
-            learning_points=fallback_analysis["learning_points"],
-            review_summary=fallback_analysis["review_summary"],
-            comprehension_question="What is the importance of good variable naming in programming?",
-            comprehension_answer="Good variable naming makes code more readable and maintainable.",
-            explanation="Descriptive variable names help other developers (and yourself) understand what the code does.",
-            improved_code="# Improved version\n# Add your improvements here",
-            fix_explanation="This is a fallback version. The model should provide specific improvements.",
-            difficulty_level=student_level,
-            learning_objectives=fallback_analysis["learning_objectives"],
-            estimated_time_to_improve=fallback_analysis["estimated_time_to_improve"]
-        )
-
-
-def main():
-    """Main function to demonstrate the system with fine-tuned model"""
-    print("Generative AI for Programming Education")
-    print("Using Fine-tuned CodeLlama-7B Model")
-    print("=" * 50)
-
-    # System information
-    print(f"Available GPUs: {torch.cuda.device_count()}")
-    if torch.cuda.is_available():
-        print("GPU Memory before loading:")
-        get_gpu_memory()
-    else:
-        print("System Memory before loading:")
-        get_system_memory()
-
-    # Initialize the system with your fine-tuned model path
-    # Update this path to point to your actual fine-tuned model
-    model_path = r"C:\Users\farou\OneDrive - Aston University\finetunning"
-    ai_tutor = ProgrammingEducationAI(model_path)
-
-    try:
-        # Load the fine-tuned model
-        print("Loading fine-tuned model...")
-        ai_tutor.load_model()
-        print("✓ Model loaded successfully!")
-
-        # Clear cache after loading
-        clear_cuda_cache()
-        if torch.cuda.is_available():
-            print("GPU Memory after loading:")
-            get_gpu_memory()
-        else:
-            print("System Memory after loading:")
-            get_system_memory()
-
-        # Example student code for testing
-        student_code = """
-def find_duplicates(numbers):
-    x = []
-    for i in range(len(numbers)):
-        for j in range(i+1, len(numbers)):
-            if numbers[i] == numbers[j]:
-                x.append(numbers[i])
-    return x
-
-# Test the function
-result = find_duplicates([1, 2, 3, 2, 4, 5, 3])
-print(result)
-"""
-
-        print(f"\nAnalyzing student code:\n{student_code}")
-
-        # Get feedback using fine-tuned model
-        feedback_list = ai_tutor.analyze_student_code(student_code, "beginner")
-
-        print("\n" + "="*50)
-        print("FINE-TUNED MODEL FEEDBACK:")
-        print("="*50)
-
-        for i, feedback in enumerate(feedback_list, 1):
-            print(f"\n{i}. {feedback.feedback_type.upper()}:")
-            print(f"   {feedback.feedback_message}")
-            if feedback.suggested_improvement:
-                print(f"   Suggestion: {feedback.suggested_improvement}")
-            print(
-                f"   Learning objectives: {', '.join(feedback.learning_objectives)}")
-
-        # Demonstrate direct model calls
-        print("\n" + "="*50)
-        print("DIRECT MODEL GENERATION:")
-        print("="*50)
-
-        # Code review
-        print("\n1. CODE REVIEW:")
-        code_review = ai_tutor.generate_code_review(student_code, "beginner")
-        print(code_review)
-
-        # Educational feedback
-        print("\n2. EDUCATIONAL FEEDBACK:")
-        educational_feedback = ai_tutor.generate_educational_feedback(
-            student_code, "beginner")
-        print(educational_feedback)
-
-        # Demonstrate comprehensive feedback system
-        print("\n" + "="*50)
-        print("COMPREHENSIVE EDUCATIONAL FEEDBACK SYSTEM:")
-        print("="*50)
-
-        comprehensive_feedback = ai_tutor.generate_comprehensive_feedback(
-            student_code, "beginner")
-
-        # Display comprehensive feedback
-        print("\n📊 CODE ANALYSIS:")
-        print("="*30)
-
-        print("\n✅ STRENGTHS:")
-        for i, strength in enumerate(comprehensive_feedback.strengths, 1):
-            print(f"   {i}. {strength}")
-
-        print("\n❌ WEAKNESSES:")
-        for i, weakness in enumerate(comprehensive_feedback.weaknesses, 1):
-            print(f"   {i}. {weakness}")
-
-        print("\n⚠️ ISSUES:")
-        for i, issue in enumerate(comprehensive_feedback.issues, 1):
-            print(f"   {i}. {issue}")
-
-        print("\n📝 STEP-BY-STEP IMPROVEMENT GUIDE:")
-        print("="*40)
-        for i, step in enumerate(comprehensive_feedback.step_by_step_improvement, 1):
-            print(f"   Step {i}: {step}")
-
-        print("\n🎓 LEARNING POINTS:")
-        print("="*25)
-        for i, point in enumerate(comprehensive_feedback.learning_points, 1):
-            print(f"   {i}. {point}")
-
-        print("\n📋 REVIEW SUMMARY:")
-        print("="*20)
-        print(f"   {comprehensive_feedback.review_summary}")
-
-        print("\n❓ COMPREHENSION QUESTION:")
-        print("="*30)
-        print(f"   Question: {comprehensive_feedback.comprehension_question}")
-        print(f"   Answer: {comprehensive_feedback.comprehension_answer}")
-        print(f"   Explanation: {comprehensive_feedback.explanation}")
-
-        print("\n🔧 IMPROVED CODE:")
-        print("="*20)
-        print(comprehensive_feedback.improved_code)
-
-        print("\n💡 FIX EXPLANATION:")
-        print("="*20)
-        print(f"   {comprehensive_feedback.fix_explanation}")
-
-        print("\n📊 METADATA:")
-        print("="*15)
-        print(f"   Student Level: {comprehensive_feedback.student_level}")
-        print(
-            f"   Learning Objectives: {', '.join(comprehensive_feedback.learning_objectives)}")
-        print(
-            f"   Estimated Time to Improve: {comprehensive_feedback.estimated_time_to_improve}")
-
-    except Exception as e:
-        print(f"Error: {e}")
-        print(
-            "Make sure to update the model_path variable to point to your fine-tuned model.")
-
-
-if __name__ == "__main__":
-    main()

src/requirements.txt

@@ -1 +0,0 @@
-streamlit>=1.28.0 

src/streamlit_app.py

@@ -1,229 +1,40 @@
-"""
-AI Programming Tutor - Full Version with Fine-tuned Model Support
-Works on Hugging Face Spaces with fallback to demo mode
-Version: 2.0 - No Demo Fallback, Shows Detailed Errors
-"""
-
+import altair as alt
+import numpy as np
+import pandas as pd
 import streamlit as st
-import os
-
-# Configure page
-st.set_page_config(
-    page_title="AI Programming Tutor",
-    page_icon="🤖",
-    layout="wide"
-)
-
-# Try to import the fine-tuned model components
-try:
-    from fine import ProgrammingEducationAI, ComprehensiveFeedback
-    MODEL_AVAILABLE = True
-except Exception as e:
-    MODEL_AVAILABLE = False
-
-# Note: Using public model - no HF_TOKEN required
-HF_TOKEN = None  # Set to None for public model
-
-
-# Demo feedback function removed - app now shows actual errors instead of falling back to demo
-
-
-def main():
-    st.title("🤖 AI Programming Tutor")
-    st.markdown("### Enhancing Programming Education with Generative AI")
-
-    # Sidebar for model selection
-    with st.sidebar:
-        st.header("⚙️ Settings")
-
-        if MODEL_AVAILABLE:
-            model_option = st.selectbox(
-                "Choose Model:",
-                ["Use Demo Mode", "Use Fine-tuned Model"],
-                help="Demo mode works immediately. Fine-tuned model requires loading."
-            )
-        else:
-            model_option = "Use Demo Mode"
-            st.warning("⚠️ Fine-tuned model not available - using demo mode")
-            st.info(
-                "💡 To enable AI model: Make sure your model is uploaded to HF Model Hub as public")
-
-        student_level = st.selectbox(
-            "Student Level:",
-            ["beginner", "intermediate", "advanced"],
-            help="Adjusts feedback complexity"
-        )
-
-        st.markdown("---")
-        st.markdown("### 📚 About")
-        st.markdown("""
-        This AI tutor provides structured feedback on programming code:
-        
-        - **Strengths**: What you did well
-        - **Weaknesses**: Areas for improvement
-        - **Issues**: Problems to fix
-        - **Improvements**: Step-by-step guidance
-        - **Learning Points**: Key concepts to understand
-        - **Questions**: Test your comprehension
-        - **Code Fix**: Improved version
-        """)
-
-        # Show model status
-        if MODEL_AVAILABLE:
-            st.success("✅ Fine-tuned model available")
-            st.success("🌐 Using public model - no authentication required")
-
-            # Show current model path
-            st.info(f"📁 Model path: FaroukTomori/codellama-7b-programming-education")
-
-            # Show if model is loaded in session
-            if 'ai_tutor' in st.session_state:
-                st.success("✅ Model loaded in session")
-            else:
-                st.info("⏳ Model not loaded yet - will load when you analyze code")
-        else:
-            st.error("❌ Fine-tuned model not available")
-            st.error("🔍 Check the import error above to fix the issue")
-
-    # Main content
-    st.markdown("---")
 
-    # Code input
-    code_input = st.text_area(
-        "📝 Enter your code here:",
-        height=200,
-        placeholder="def hello_world():\n    print('Hello, World!')\n    return 'success'",
-        help="Paste your Python code here for analysis"
-    )
-
-    if st.button("🚀 Analyze Code", type="primary"):
-        if not code_input.strip():
-            st.warning("⚠️ Please enter some code to analyze")
-            return
-
-        with st.spinner("🤖 Analyzing your code..."):
-            try:
-                if model_option == "Use Fine-tuned Model" and MODEL_AVAILABLE:
-                    # Check if model is already loaded
-                    if 'ai_tutor' not in st.session_state:
-                        with st.spinner("🚀 Loading fine-tuned model (this may take 5-10 minutes on HF Spaces)..."):
-                            try:
-                                # Use Hugging Face Model Hub
-                                # Replace with your actual model name
-                                model_path = "FaroukTomori/codellama-7b-programming-education"
-
-                                # Using public model - no authentication required
-                                st.info(
-                                    "🌐 Using public model - no authentication required")
-
-                                st.info(
-                                    f"🔍 Attempting to load model from: {model_path}")
-
-                                ai_tutor = ProgrammingEducationAI(model_path)
-                                st.success(
-                                    "✅ Model class instantiated successfully")
-
-                                ai_tutor.load_model()
-                                st.session_state['ai_tutor'] = ai_tutor
-                                st.success(
-                                    "✅ Fine-tuned model loaded successfully!")
-                            except Exception as e:
-                                st.error(f"❌ Error loading model: {e}")
-                                st.error("🔍 Full error details:")
-                                st.code(str(e), language="text")
-                                st.info(
-                                    "💡 Check the error above to fix the model loading issue")
-                                return  # Stop here and show the error
-
-                    if 'ai_tutor' in st.session_state:
-                        # Use fine-tuned model
-                        try:
-                            feedback = st.session_state['ai_tutor'].generate_comprehensive_feedback(
-                                code_input, student_level)
-                            st.success(
-                                "✅ Feedback generated using fine-tuned model!")
-                        except Exception as e:
-                            st.error(f"❌ Error generating feedback: {e}")
-                            st.error("🔍 Full error details:")
-                            st.code(str(e), language="text")
-                            st.info(
-                                "💡 Check the error above to fix the feedback generation issue")
-                            return
-                    else:
-                        # Model failed to load - show error instead of falling back
-                        st.error(
-                            "❌ Model failed to load - cannot generate feedback")
-                        st.info("💡 Fix the model loading error above first")
-                        return
-                else:
-                    # Model not available or not selected - show error
-                    if not MODEL_AVAILABLE:
-                        st.error("❌ Fine-tuned model components not available")
-                        st.error("🔍 Check the import error in the sidebar")
-                        return
-                    else:
-                        st.error(
-                            "❌ Please select 'Use Fine-tuned Model' to analyze with AI")
-                        st.info("💡 The model is available but not selected")
-                        return
-
-                # Display AI feedback in tabs
-                tab1, tab2, tab3, tab4, tab5, tab6, tab7 = st.tabs([
-                    "✅ Strengths", "❌ Weaknesses", "🚨 Issues",
-                    "📈 Improvements", "🎓 Learning", "❓ Questions", "🔧 Code Fix"
-                ])
-
-                with tab1:
-                    st.subheader("✅ Code Strengths")
-                    for strength in feedback.strengths:
-                        st.markdown(f"• {strength}")
-
-                with tab2:
-                    st.subheader("❌ Areas for Improvement")
-                    for weakness in feedback.weaknesses:
-                        st.markdown(f"• {weakness}")
-
-                with tab3:
-                    st.subheader("🚨 Issues to Address")
-                    for issue in feedback.issues:
-                        st.markdown(f"• {issue}")
-
-                with tab4:
-                    st.subheader("📈 Step-by-Step Improvements")
-                    for i, step in enumerate(feedback.step_by_step_improvement, 1):
-                        st.markdown(f"**Step {i}:** {step}")
-
-                with tab5:
-                    st.subheader("🎓 Key Learning Points")
-                    for point in feedback.learning_points:
-                        st.markdown(f"• {point}")
-
-                with tab6:
-                    st.subheader("❓ Comprehension Questions")
-                    st.markdown(
-                        f"**Question:** {feedback.comprehension_question}")
-                    st.markdown(f"**Answer:** {feedback.comprehension_answer}")
-                    st.markdown(f"**Explanation:** {feedback.explanation}")
-
-                with tab7:
-                    st.subheader("🔧 Improved Code")
-                    st.code(feedback.improved_code, language="python")
-                    st.markdown("**What Changed:**")
-                    st.info(feedback.fix_explanation)
-
-                st.success(
-                    "✅ Analysis complete! Review each tab for comprehensive feedback.")
+"""
+# Welcome to Streamlit!
 
-            except Exception as e:
-                st.error(f"❌ Error during analysis: {e}")
-                st.error("🔍 Full error details:")
-                st.code(str(e), language="text")
-                st.info("💡 Check the error above to understand what went wrong")
+Edit `/streamlit_app.py` to customize this app to your heart's desire :heart:.
+If you have any questions, checkout our [documentation](https://docs.streamlit.io) and [community
+forums](https://discuss.streamlit.io).
 
+In the meantime, below is an example of what you can do with just a few lines of code:
+"""
 
-if __name__ == "__main__":
-    try:
-        main()
-    except Exception as e:
-        st.error(f"❌ Application error: {e}")
-        st.info("💡 Please refresh the page and try again")
+num_points = st.slider("Number of points in spiral", 1, 10000, 1100)
+num_turns = st.slider("Number of turns in spiral", 1, 300, 31)
+
+indices = np.linspace(0, 1, num_points)
+theta = 2 * np.pi * num_turns * indices
+radius = indices
+
+x = radius * np.cos(theta)
+y = radius * np.sin(theta)
+
+df = pd.DataFrame({
+    "x": x,
+    "y": y,
+    "idx": indices,
+    "rand": np.random.randn(num_points),
+})
+
+st.altair_chart(alt.Chart(df, height=700, width=700)
+    .mark_point(filled=True)
+    .encode(
+        x=alt.X("x", axis=None),
+        y=alt.Y("y", axis=None),
+        color=alt.Color("idx", legend=None, scale=alt.Scale()),
+        size=alt.Size("rand", legend=None, scale=alt.Scale(range=[1, 150])),
+    ))