better script

app.py

@@ -1,41 +1,58 @@
 import gradio as gr
 import json
-import torch
-from transformers import AutoTokenizer, AutoModelForCausalLM, pipeline
+import time
 import logging
-from pathlib import Path
+import re
+from typing import Dict, Any, List, Tuple
+from concurrent.futures import ThreadPoolExecutor, as_completed
+import threading
+from datetime import datetime
+import os
 import tempfile
-import time
+
+# Hugging Face Transformers
+import torch
+from transformers import AutoTokenizer, AutoModelForCausalLM, pipeline
+import gc
 
 # Setup logging
-logging.basicConfig(level=logging.INFO)
+logging.basicConfig(
+    level=logging.INFO,
+    format='%(asctime)s - %(levelname)s - %(message)s'
+)
 logger = logging.getLogger(__name__)
 
 class SyllabusFormatter:
     def __init__(self, model_name="microsoft/Phi-3-mini-4k-instruct"):
+        """Initialize the formatter with Phi-3 model"""
         self.model_name = model_name
         self.tokenizer = None
         self.model = None
         self.pipe = None
-        self.processed_count = 0
-        self.total_count = 0
+        self.is_model_loaded = False
+        self.processing_lock = threading.Lock()
         
-    def setup_model(self):
-        """Download and setup the Phi model"""
+    def load_model(self):
+        """Load the Phi-3 model with optimizations"""
+        if self.is_model_loaded:
+            return True
+            
         try:
+            logger.info(f"Loading model: {self.model_name}")
+            
             # Load tokenizer
             self.tokenizer = AutoTokenizer.from_pretrained(
                 self.model_name,
                 trust_remote_code=True
             )
             
-            # Load model with 8-bit quantization for efficiency
+            # Load model with optimizations
             self.model = AutoModelForCausalLM.from_pretrained(
                 self.model_name,
-                torch_dtype=torch.float16,
-                device_map="auto",
+                torch_dtype=torch.float16 if torch.cuda.is_available() else torch.float32,
+                device_map="auto" if torch.cuda.is_available() else None,
                 trust_remote_code=True,
-                load_in_8bit=True
+                low_cpu_mem_usage=True
             )
             
             # Create pipeline
@@ -43,23 +60,21 @@ class SyllabusFormatter:
                 "text-generation",
                 model=self.model,
                 tokenizer=self.tokenizer,
-                max_new_tokens=2048,
-                temperature=0.1,
-                do_sample=True,
-                top_p=0.9,
-                repetition_penalty=1.1
+                device=0 if torch.cuda.is_available() else -1,
+                torch_dtype=torch.float16 if torch.cuda.is_available() else torch.float32
             )
             
-            logger.info("Model setup complete!")
+            self.is_model_loaded = True
+            logger.info("Model loaded successfully!")
             return True
             
         except Exception as e:
-            logger.error(f"Error setting up model: {str(e)}")
+            logger.error(f"Error loading model: {str(e)}")
             return False
-
+    
     def create_formatting_prompt(self, unit_content: str, unit_name: str, subject_name: str = "") -> str:
-        """Create a very clear, focused prompt for formatting syllabus content"""
-        prompt = f"""<|system|>You are a professional academic syllabus formatter. Your ONLY job is to take badly formatted syllabus content and make it beautifully organized and readable.
+        """Create a focused prompt for formatting syllabus content"""
+        prompt = f"""<|system|>You are a professional academic syllabus formatter. Your job is to take poorly formatted syllabus content and make it beautifully organized and readable.
 
 RULES:
 1. PRESERVE every single word, topic, and concept from the original
@@ -83,254 +98,406 @@ Unit: {unit_name}
 Original content (poorly formatted):
 {unit_content}
 
-Task: Reformat this content to be beautifully organized and readable. Do NOT add any new information - only restructure what's already there. Make it professional and easy to scan.<|end|>
+Task: Reformat this content to be beautifully organized and readable. Do NOT add any new information - only restructure what's already there.<|end|>
 
 <|assistant|>"""
         return prompt
     
-    def format_unit_content(self, unit_content: str, unit_name: str, subject_name: str = "", progress=None) -> str:
-        """Format a single unit's content using the AI model"""
+    def format_single_unit(self, unit_data: Tuple[str, str, str, str, str]) -> Tuple[str, str, str, str, str]:
+        """Format a single unit's content"""
+        branch, semester, subject, unit_name, unit_content = unit_data
+        
         try:
-            # Create prompt
-            prompt = self.create_formatting_prompt(unit_content, unit_name, subject_name)
-            
-            # Generate formatted content
-            response = self.pipe(prompt)
-            
-            # Extract formatted content
-            generated_text = response[0]['generated_text']
-            assistant_start = generated_text.find("<|assistant|>")
-            if assistant_start != -1:
-                formatted_content = generated_text[assistant_start + len("<|assistant|>"):].strip()
-            else:
-                formatted_content = generated_text.strip()
-            
-            # Clean up and validate
-            formatted_content = self.clean_generated_content(formatted_content)
-            if not self.validate_formatted_content(unit_content, formatted_content):
-                return unit_content
+            with self.processing_lock:
+                # Create prompt
+                prompt = self.create_formatting_prompt(unit_content, unit_name, subject)
                 
-            return formatted_content
-            
+                # Generate formatted content
+                response = self.pipe(
+                    prompt,
+                    max_new_tokens=2048,
+                    temperature=0.1,
+                    do_sample=True,
+                    top_p=0.9,
+                    repetition_penalty=1.1,
+                    pad_token_id=self.tokenizer.eos_token_id,
+                    eos_token_id=self.tokenizer.eos_token_id
+                )
+                
+                # Extract formatted content
+                generated_text = response[0]['generated_text']
+                assistant_start = generated_text.find("<|assistant|>")
+                
+                if assistant_start != -1:
+                    formatted_content = generated_text[assistant_start + len("<|assistant|>"):].strip()
+                else:
+                    formatted_content = generated_text[len(prompt):].strip()
+                
+                # Clean up the content
+                formatted_content = self.clean_generated_content(formatted_content)
+                
+                # Validate content
+                if self.validate_formatted_content(unit_content, formatted_content):
+                    return (branch, semester, subject, unit_name, formatted_content)
+                else:
+                    logger.warning(f"Validation failed for {subject} - {unit_name}")
+                    return (branch, semester, subject, unit_name, unit_content)
+                    
         except Exception as e:
-            logger.error(f"Error formatting content: {str(e)}")
-            return unit_content
-            
+            logger.error(f"Error formatting {subject} - {unit_name}: {str(e)}")
+            return (branch, semester, subject, unit_name, unit_content)
+    
+    def clean_generated_content(self, content: str) -> str:
+        """Clean up generated content"""
+        # Remove special tokens
+        content = re.sub(r'<\|.*?\|>', '', content)
+        
+        # Remove AI commentary
+        lines = content.split('\n')
+        cleaned_lines = []
+        
+        for line in lines:
+            line = line.strip()
+            if (line.startswith("Here") and ("formatted" in line.lower() or "organized" in line.lower())) or \
+               line.startswith("I have") or line.startswith("The content has been") or \
+               line.startswith("Note:") or line.startswith("This formatted version"):
+                continue
+            if line:
+                cleaned_lines.append(line)
+        
+        content = '\n'.join(cleaned_lines)
+        
+        # Fix spacing
+        content = re.sub(r'\n\s*\n\s*\n+', '\n\n', content)
+        content = re.sub(r'\n([A-Z][^:\n]*:)\n', r'\n\n\1\n', content)
+        
+        return content.strip()
+    
     def validate_formatted_content(self, original: str, formatted: str) -> bool:
-        """Validate that formatted content preserves all important information"""
-        # Basic validation
+        """Validate that formatted content preserves important information"""
         if len(formatted) < len(original) * 0.4:
             return False
+        
+        # Check for preservation of key terms
+        original_words = set(re.findall(r'\b[A-Z][a-z]*(?:[A-Z][a-z]*)*\b', original))
+        formatted_words = set(re.findall(r'\b[A-Z][a-z]*(?:[A-Z][a-z]*)*\b', formatted))
+        
+        missing_terms = original_words - formatted_words
+        if len(missing_terms) > len(original_words) * 0.3:
+            return False
+        
         return True
-            
-    def clean_generated_content(self, content: str) -> str:
-        """Clean up generated content"""
-        # Remove special tokens
-        for token in ["<|system|>", "<|user|>", "<|assistant|>"]:
-            content = content.replace(token, "")
-            
-        # Clean up extra whitespace
-        content = "\n".join(line.strip() for line in content.split("\n") if line.strip())
+    
+    def extract_units_for_processing(self, syllabus_data: Dict[str, Any]) -> List[Tuple[str, str, str, str, str]]:
+        """Extract all units for concurrent processing"""
+        units = []
         
-        return content
-
-    def process_syllabus_file(self, syllabus_data: dict, progress=gr.Progress()) -> dict:
-        """Process the entire syllabus file with progress updates"""
-        try:
-            # Count total units
-            total_units = 0
-            processed = 0
-            
-            def count_units(data):
-                count = 0
-                if isinstance(data, dict):
-                    for value in data.values():
-                        if isinstance(value, dict):
-                            count += count_units(value)
-                        elif isinstance(value, str) and "Unit" in str(value):
-                            count += 1
-                return count
-            
-            total_units = count_units(syllabus_data.get("syllabus", {}))
-            logger.info(f"Total units to process: {total_units}")
-            
-            # Process each branch
-            for branch_name, branch_data in syllabus_data.get("syllabus", {}).items():
-                if not isinstance(branch_data, dict):
+        for branch_name, branch_data in syllabus_data.get("syllabus", {}).items():
+            if not isinstance(branch_data, dict):
+                continue
+                
+            for sem_name, sem_data in branch_data.items():
+                if not isinstance(sem_data, dict):
                     continue
                     
-                # Process each semester
-                for sem_name, sem_data in branch_data.items():
-                    if not isinstance(sem_data, dict):
+                for subject_name, subject_data in sem_data.items():
+                    if not isinstance(subject_data, dict) or "content" not in subject_data:
                         continue
                         
-                    # Process each subject
-                    for subject_name, subject_data in sem_data.items():
-                        if not isinstance(subject_data, dict) or "content" not in subject_data:
-                            continue
-                            
-                        content = subject_data["content"]
-                        if not isinstance(content, dict):
-                            continue
-                        
-                        # Format each unit
-                        for unit_name, unit_content in content.items():
-                            if not unit_name.startswith("Unit") or not isinstance(unit_content, str):
-                                continue
-                            
-                            processed += 1
-                            progress(processed / total_units, desc=f"Processing {unit_name} in {subject_name}...")
-                            
-                            # Format the unit content
-                            formatted_content = self.format_unit_content(
-                                unit_content, 
-                                unit_name, 
-                                subject_name
-                            )
-                            
-                            # Update the content
-                            syllabus_data["syllabus"][branch_name][sem_name][subject_name]["content"][unit_name] = formatted_content
+                    content = subject_data["content"]
+                    if not isinstance(content, dict):
+                        continue
+                    
+                    for unit_name, unit_content in content.items():
+                        if unit_name.startswith("Unit") and isinstance(unit_content, str):
+                            units.append((branch_name, sem_name, subject_name, unit_name, unit_content))
+        
+        return units
+    
+    def format_syllabus_concurrent(self, syllabus_data: Dict[str, Any], progress_callback=None, max_workers=4) -> Dict[str, Any]:
+        """Format syllabus using concurrent processing"""
+        if not self.is_model_loaded:
+            if not self.load_model():
+                raise Exception("Failed to load model")
+        
+        # Extract units for processing
+        units = self.extract_units_for_processing(syllabus_data)
+        total_units = len(units)
+        
+        logger.info(f"Processing {total_units} units with {max_workers} workers")
+        
+        # Process units concurrently
+        processed_units = {}
+        completed_count = 0
+        
+        with ThreadPoolExecutor(max_workers=max_workers) as executor:
+            # Submit all tasks
+            future_to_unit = {executor.submit(self.format_single_unit, unit): unit for unit in units}
             
-            # Add formatting metadata
-            if "metadata" not in syllabus_data:
-                syllabus_data["metadata"] = {}
+            # Process completed tasks
+            for future in as_completed(future_to_unit):
+                try:
+                    branch, semester, subject, unit_name, formatted_content = future.result()
+                    
+                    # Store the result
+                    key = f"{branch}|{semester}|{subject}|{unit_name}"
+                    processed_units[key] = formatted_content
+                    
+                    completed_count += 1
+                    progress = (completed_count / total_units) * 100
+                    
+                    if progress_callback:
+                        progress_callback(progress, f"Processed {subject} - {unit_name}")
+                    
+                    logger.info(f"Completed {completed_count}/{total_units} ({progress:.1f}%)")
+                    
+                except Exception as e:
+                    logger.error(f"Error processing unit: {str(e)}")
+        
+        # Update the syllabus data with formatted content
+        for branch_name, branch_data in syllabus_data.get("syllabus", {}).items():
+            if not isinstance(branch_data, dict):
+                continue
                 
-            syllabus_data["metadata"].update({
-                "lastFormatted": time.strftime("%Y-%m-%dT%H:%M:%SZ"),
-                "formattingModel": "Phi-3 Mini",
-                "unitsProcessed": processed,
-                "version": "1.0"
-            })
-            
-            return syllabus_data
-            
-        except Exception as e:
-            logger.error(f"Error processing syllabus: {str(e)}")
-            raise gr.Error(f"Error processing syllabus: {str(e)}")
-
-# Initialize the formatter
-formatter = None
+            for sem_name, sem_data in branch_data.items():
+                if not isinstance(sem_data, dict):
+                    continue
+                    
+                for subject_name, subject_data in sem_data.items():
+                    if not isinstance(subject_data, dict) or "content" not in subject_data:
+                        continue
+                        
+                    content = subject_data["content"]
+                    if not isinstance(content, dict):
+                        continue
+                    
+                    for unit_name in content.keys():
+                        if unit_name.startswith("Unit"):
+                            key = f"{branch_name}|{sem_name}|{subject_name}|{unit_name}"
+                            if key in processed_units:
+                                syllabus_data["syllabus"][branch_name][sem_name][subject_name]["content"][unit_name] = processed_units[key]
+        
+        # Add metadata
+        if "metadata" not in syllabus_data:
+            syllabus_data["metadata"] = {}
+        
+        syllabus_data["metadata"]["lastFormatted"] = datetime.now().isoformat()
+        syllabus_data["metadata"]["formattingNote"] = "Content formatted using Phi-3 AI for enhanced readability"
+        syllabus_data["metadata"]["originalContentPreserved"] = True
+        syllabus_data["metadata"]["unitsProcessed"] = completed_count
+        syllabus_data["metadata"]["formattingModel"] = self.model_name
+        syllabus_data["metadata"]["version"] = "2.0"
+        syllabus_data["metadata"]["processedConcurrently"] = True
+        syllabus_data["metadata"]["maxWorkers"] = max_workers
+        
+        return syllabus_data
 
-def setup_formatter():
-    global formatter
-    if formatter is None:
-        formatter = SyllabusFormatter()
-        return formatter.setup_model()
-    return True
+# Global formatter instance
+formatter = SyllabusFormatter()
 
-def process_file(file):
-    """Process the uploaded syllabus file"""
+def format_syllabus_file(file_path, max_workers=4, progress=gr.Progress()):
+    """Main function to format syllabus file"""
     try:
-        # Setup formatter if needed
-        if not setup_formatter():
-            raise gr.Error("Failed to setup the formatting model. Please try again.")
+        # Load JSON file
+        with open(file_path, 'r', encoding='utf-8') as f:
+            syllabus_data = json.load(f)
+        
+        # Count units
+        units = formatter.extract_units_for_processing(syllabus_data)
+        total_units = len(units)
         
-        # Read and parse JSON
-        content = file.read()
-        syllabus_data = json.loads(content)
+        progress(0, f"Found {total_units} units to process")
         
-        # Process syllabus
-        formatted_data = formatter.process_syllabus_file(syllabus_data)
+        # Progress callback
+        def update_progress(percent, message):
+            progress(percent/100, message)
+        
+        # Format the syllabus
+        formatted_data = formatter.format_syllabus_concurrent(
+            syllabus_data, 
+            progress_callback=update_progress,
+            max_workers=max_workers
+        )
         
         # Save to temporary file
-        with tempfile.NamedTemporaryFile(mode='w', suffix='.json', delete=False) as tmp:
-            json.dump(formatted_data, tmp, indent=2)
-            return tmp.name
-            
-    except json.JSONDecodeError:
-        raise gr.Error("Invalid JSON file. Please check your syllabus file format.")
+        with tempfile.NamedTemporaryFile(mode='w', suffix='.json', delete=False, encoding='utf-8') as f:
+            json.dump(formatted_data, f, indent=2, ensure_ascii=False)
+            temp_path = f.name
+        
+        progress(1.0, f"Completed! Processed {total_units} units")
+        
+        return temp_path, f"✅ Successfully formatted {total_units} units!"
+        
     except Exception as e:
-        raise gr.Error(f"Error processing file: {str(e)}")
-
-# Custom theme
-theme = gr.themes.Soft(
-    primary_hue="indigo",
-    secondary_hue="blue",
-).set(
-    body_background_fill="#fafafa",
-    body_background_fill_dark="#1a1a1a",
-    button_primary_background_fill="*primary_500",
-    button_primary_background_fill_hover="*primary_600"
-)
-
-# Gradio interface
-title = "📚 Syllabus Formatter"
-description = """
-Transform your syllabus into a beautifully formatted, easy-to-read document using AI.
-
-### Features:
-- Preserves all original content
-- Improves readability and organization
-- Creates logical grouping and sections
-- Adds professional formatting
-
-Simply upload your JSON syllabus file and get a formatted version back!
-"""
-
-css = """
-.feedback {
-    margin-top: 20px;
-    padding: 10px;
-    border-radius: 8px;
-    background-color: #f0f9ff;
-    border: 1px solid #bae6fd;
-}
-.dark .feedback {
-    background-color: #082f49;
-    border-color: #075985;
-}
-"""
+        error_msg = f"❌ Error: {str(e)}"
+        logger.error(error_msg)
+        return None, error_msg
 
-with gr.Blocks(theme=theme, css=css) as iface:
-    gr.Markdown(f"# {title}")
-    gr.Markdown(description)
+def create_sample_json():
+    """Create a sample JSON file for testing"""
+    sample_data = {
+        "metadata": {
+            "totalFiles": 1,
+            "generatedAt": datetime.now().isoformat(),
+            "source": "Sample syllabus for testing",
+            "description": "Sample syllabus content"
+        },
+        "syllabus": {
+            "CSE": {
+                "SEM1": {
+                    "Mathematics": {
+                        "extractedFrom": {
+                            "path": "CSE > SEM1 > Mathematics",
+                            "branch": "CSE",
+                            "semester": "SEM1",
+                            "subject": "Mathematics"
+                        },
+                        "content": {
+                            "Unit I": "Differential Calculus: Limits, continuity, derivatives, applications of derivatives, maxima and minima, curve sketching, related rates, optimization problems, L'Hospital's rule, Taylor series, Partial derivatives, total differential, chain rule, implicit differentiation, Jacobians.",
+                            "Unit II": "Integral Calculus: Integration techniques, definite integrals, applications of integrals, area under curves, volume of solids, arc length, surface area, Multiple integrals, double integrals, triple integrals, change of variables, applications in geometry and physics."
+                        }
+                    }
+                }
+            }
+        }
+    }
     
-    with gr.Row():
-        with gr.Column():
-            file_input = gr.File(
-                label="Upload Syllabus JSON",
-                file_types=[".json"],
-                type="binary"  # Use binary type for file upload
-            )
-            process_btn = gr.Button("🪄 Format Syllabus", variant="primary")
+    with tempfile.NamedTemporaryFile(mode='w', suffix='.json', delete=False, encoding='utf-8') as f:
+        json.dump(sample_data, f, indent=2, ensure_ascii=False)
+        return f.name
+
+# Gradio Interface
+def create_interface():
+    with gr.Blocks(
+        title="Syllabus Formatter - AI-Powered JSON Syllabus Formatter",
+        theme=gr.themes.Soft(
+            primary_hue="blue",
+            secondary_hue="purple",
+            neutral_hue="gray"
+        )
+    ) as interface:
+        
+        gr.HTML("""
+        <div style="text-align: center; padding: 20px; background: linear-gradient(135deg, #667eea 0%, #764ba2 100%); color: white; border-radius: 10px; margin-bottom: 20px;">
+            <h1 style="font-size: 2.5em; margin-bottom: 10px;">🎓 Syllabus Formatter</h1>
+            <p style="font-size: 1.2em; opacity: 0.9;">AI-Powered JSON Syllabus Content Formatter using Phi-3</p>
+            <p style="font-size: 1em; opacity: 0.8;">Upload your JSON syllabus file and get beautifully formatted content with concurrent processing for speed!</p>
+        </div>
+        """)
+        
+        with gr.Row():
+            with gr.Column(scale=1):
+                gr.HTML("""
+                <div style="background: #f8f9fa; padding: 15px; border-radius: 8px; margin-bottom: 15px;">
+                    <h3>📋 Instructions:</h3>
+                    <ol>
+                        <li>Upload your JSON syllabus file</li>
+                        <li>Choose number of concurrent workers (1-8)</li>
+                        <li>Click "Format Syllabus" to start processing</li>
+                        <li>Download the formatted JSON file</li>
+                    </ol>
+                    <p><strong>Note:</strong> Only syllabus content will be formatted, metadata remains unchanged.</p>
+                </div>
+                """)
+                
+                file_input = gr.File(
+                    label="📁 Upload JSON Syllabus File",
+                    file_types=[".json"],
+                    type="filepath"
+                )
+                
+                workers_slider = gr.Slider(
+                    minimum=1,
+                    maximum=8,
+                    value=4,
+                    step=1,
+                    label="🔄 Concurrent Workers",
+                    info="More workers = faster processing (but more memory usage)"
+                )
+                
+                format_btn = gr.Button(
+                    "🚀 Format Syllabus",
+                    variant="primary",
+                    size="lg"
+                )
+                
+                sample_btn = gr.Button(
+                    "📝 Download Sample JSON",
+                    variant="secondary"
+                )
             
-    output_file = gr.File(
-        label="Download Formatted Syllabus"
-    )
-    
-    with gr.Row():
-        feedback = gr.Markdown(
-            value="Upload a JSON syllabus file to begin...",
-            elem_classes=["feedback"]
+            with gr.Column(scale=1):
+                status_output = gr.Textbox(
+                    label="📊 Status",
+                    lines=3,
+                    interactive=False
+                )
+                
+                download_output = gr.File(
+                    label="📥 Download Formatted JSON",
+                    visible=False
+                )
+                
+                gr.HTML("""
+                <div style="background: #e3f2fd; padding: 15px; border-radius: 8px; margin-top: 15px;">
+                    <h3>✨ Features:</h3>
+                    <ul>
+                        <li>🤖 Powered by Microsoft Phi-3 AI model</li>
+                        <li>⚡ Concurrent processing for speed</li>
+                        <li>🔒 Preserves all original content</li>
+                        <li>📊 Real-time progress tracking</li>
+                        <li>🎯 Formats only syllabus content, not metadata</li>
+                        <li>✅ Validation to ensure content integrity</li>
+                    </ul>
+                </div>
+                """)
+        
+        # Event handlers
+        def format_handler(file_path, max_workers):
+            if file_path is None:
+                return "❌ Please upload a JSON file first.", gr.update(visible=False)
+            
+            try:
+                result_path, message = format_syllabus_file(file_path, int(max_workers))
+                if result_path:
+                    return message, gr.update(visible=True, value=result_path)
+                else:
+                    return message, gr.update(visible=False)
+            except Exception as e:
+                return f"❌ Error: {str(e)}", gr.update(visible=False)
+        
+        def sample_handler():
+            sample_path = create_sample_json()
+            return gr.update(visible=True, value=sample_path)
+        
+        format_btn.click(
+            format_handler,
+            inputs=[file_input, workers_slider],
+            outputs=[status_output, download_output]
         )
+        
+        sample_btn.click(
+            sample_handler,
+            outputs=[gr.File(label="📥 Sample JSON File", visible=True)]
+        )
+        
+        gr.HTML("""
+        <div style="text-align: center; padding: 15px; margin-top: 20px; border-top: 1px solid #ddd;">
+            <p style="color: #666;">
+                Built with ❤️ using Hugging Face Spaces | 
+                Powered by Microsoft Phi-3 | 
+                Optimized for concurrent processing
+            </p>
+        </div>
+        """)
     
-    def update_feedback(file):
-        return "Processing your syllabus... This may take a few minutes depending on the size."
-        
-    # Setup click event
-    process_btn.click(
-        fn=update_feedback,
-        inputs=[file_input],
-        outputs=[feedback],
-        queue=False
-    ).then(
-        fn=process_file,
-        inputs=[file_input],
-        outputs=[output_file]
-    ).success(
-        fn=lambda: "✨ Syllabus formatting complete! You can now download the formatted file.",
-        outputs=[feedback]
-    )
-
-    gr.Markdown("""
-    ### 📝 Notes:
-    - The formatter preserves all original content while improving organization
-    - Processing time depends on the size of your syllabus
-    - For large files, please be patient as the AI processes each section
-    
-    Made with ❤️ using Microsoft's Phi-3 Mini model
-    """)
+    return interface
 
-# Launch in dev mode
+# Launch the app
 if __name__ == "__main__":
-    iface.launch()
+    interface = create_interface()
+    interface.launch(
+        server_name="0.0.0.0",
+        server_port=7860,
+        share=True
+    )

gradio_app.py

@@ -1,466 +1,503 @@
-import gradio as gr
-from model.analyzer import analyze_content
-import asyncio
-import time
-import httpx
-import subprocess
-import atexit
-
-# Start the API server
-def start_api_server():
-    # Start uvicorn in a subprocess
-    process = subprocess.Popen(["uvicorn", "script_search_api:app", "--reload"])
-    return process
-
-# Stop the API server
-def stop_api_server(process):
-    process.terminate()
-
-# Register the exit handler
-api_process = start_api_server()
-atexit.register(stop_api_server, api_process)
-
-
-custom_css = """
-* {
-    font-family: 'Inter', system-ui, sans-serif;
-    transition: all 0.3s cubic-bezier(0.4, 0, 0.2, 1);
-}
-
-.gradio-container {
-    background: #0a0a0a !important;
-    color: #fff !important;
-    min-height: 100vh;
-    position: relative;
-    overflow: hidden;
-}
-
-/* Subtle Animated Background */
-.gradio-container::before {
-    content: '';
-    position: fixed;
-    top: 0;
-    left: 0;
-    right: 0;
-    bottom: 0;
-    background: 
-        linear-gradient(125deg, 
-            #0a0a0a 0%, 
-            rgba(218, 165, 32, 0.03) 30%,
-            rgba(218, 165, 32, 0.05) 50%,
-            rgba(218, 165, 32, 0.03) 70%,
-            #0a0a0a 100%);
-    animation: subtleGradient 20s ease infinite;
-    background-size: 400% 400%;
-    z-index: 0;
-}
-
-/* Premium Particles Effect */
-.gradio-container::after {
-    content: '';
-    position: fixed;
-    top: 0;
-    left: 0;
-    width: 100%;
-    height: 100%;
-    background: radial-gradient(circle at center, transparent 0%, #0a0a0a 70%),
-                url("data:image/svg+xml,%3Csvg width='100' height='100' viewBox='0 0 100 100' xmlns='http://www.w3.org/2000/svg'%3E%3Ccircle cx='50' cy='50' r='1' fill='rgba(218, 165, 32, 0.08)'/%3E%3C/svg%3E");
-    opacity: 0.3;
-    animation: floatingParticles 30s linear infinite;
-    z-index: 1;
-}
-
-/* Luxurious Header */
-.treat-title {
-    text-align: center;
-    padding: 3rem 1rem;
-    position: relative;
-    overflow: hidden;
-    z-index: 2;
-    background: linear-gradient(180deg, 
-        rgba(218, 165, 32, 0.05),
-        transparent 70%);
-}
-
-.treat-title::before {
-    content: '';
-    position: absolute;
-    top: 0;
-    left: 50%;
-    width: 60%;
-    height: 1px;
-    background: linear-gradient(90deg, 
-        transparent,
-        rgba(218, 165, 32, 0.3),
-        transparent);
-    transform: translateX(-50%);
-    animation: luxuryScan 5s ease-in-out infinite;
-}
-
-.treat-title h1 {
-    font-size: 4.5rem;
-    font-weight: 800;
-    background: linear-gradient(135deg, 
-        #996515 0%,
-        #DAA520 25%,
-        #FFD700 50%,
-        #DAA520 75%,
-        #996515 100%);
-    background-size: 200% auto;
-    -webkit-background-clip: text;
-    -webkit-text-fill-color: transparent;
-    margin-bottom: 0.5rem;
-    letter-spacing: -0.05em;
-    animation: goldenFlow 8s ease infinite;
-    position: relative;
-}
-
-.treat-title h1::after {
-    content: attr(data-text);
-    position: absolute;
-    left: 0;
-    top: 0;
-    width: 100%;
-    height: 100%;
-    background: linear-gradient(135deg, 
-        transparent 0%,
-        rgba(218, 165, 32, 0.4) 50%,
-        transparent 100%);
-    background-size: 200% auto;
-    -webkit-background-clip: text;
-    -webkit-text-fill-color: transparent;
-    opacity: 0.5;
-    animation: premiumGlow 4s ease-in-out infinite;
-}
-
-/* Premium Content Areas */
-.tabs {
-    background: rgba(10, 10, 10, 0.95);
-    border: 1px solid rgba(218, 165, 32, 0.15);
-    border-radius: 16px;
-    padding: 1rem;
-    margin: 0 1rem 2rem 1rem;
-    position: relative;
-    z-index: 2;
-    backdrop-filter: blur(10px);
-    box-shadow: 0 0 30px rgba(218, 165, 32, 0.05);
-}
-
-.tabs::before {
-    content: '';
-    position: absolute;
-    top: -1px;
-    left: -1px;
-    right: -1px;
-    bottom: -1px;
-    background: linear-gradient(45deg,
-        rgba(218, 165, 32, 0.1),
-        transparent,
-        rgba(218, 165, 32, 0.1));
-    border-radius: 16px;
-    z-index: -1;
-    animation: luxuryBorder 6s ease-in-out infinite;
-}
-
-.content-area {
-    background: rgba(10, 10, 10, 0.95) !important;
-    border: 1px solid rgba(218, 165, 32, 0.15) !important;
-    border-radius: 12px !important;
-    padding: 1.5rem !important;
-    backdrop-filter: blur(10px);
-    position: relative;
-}
-
-/* Premium Input Fields */
-.gradio-textbox textarea {
-    background: rgba(10, 10, 10, 0.9) !important;
-    border: 1px solid rgba(218, 165, 32, 0.2) !important;
-    border-radius: 8px !important;
-    color: rgba(255, 255, 255, 0.9) !important;
-    font-size: 0.95rem !important;
-    line-height: 1.6 !important;
-    padding: 1rem !important;
-}
-
-.gradio-textbox textarea:focus {
-    border-color: #DAA520 !important;
-    box-shadow: 0 0 20px rgba(218, 165, 32, 0.1) !important;
-    background: rgba(10, 10, 10, 0.95) !important;
-    transform: translateY(-2px);
-}
-
-/* Luxury Buttons */
-.gradio-button {
-    background: linear-gradient(45deg, 
-        #996515,
-        #DAA520,
-        #FFD700,
-        #DAA520) !important;
-    background-size: 200% auto !important;
-    border: none !important;
-    border-radius: 8px !important;
-    color: #0a0a0a !important;
-    font-weight: 600 !important;
-    font-size: 0.95rem !important;
-    padding: 0.75rem 1.5rem !important;
-    letter-spacing: 0.025em !important;
-    position: relative;
-    overflow: hidden;
-    transition: all 0.3s ease !important;
-    animation: goldenFlow 4s ease infinite;
-}
-
-.gradio-button:hover {
-    transform: translateY(-2px);
-    box-shadow: 0 5px 20px rgba(218, 165, 32, 0.2) !important;
-}
-
-/* Premium Footer */
-.footer {
-    text-align: center;
-    padding: 2rem 0;
-    margin-top: 3rem;
-    font-size: 1.0rem;
-    position: relative;
-    z-index: 2;
-}
-
-.footer p {
-    color: rgba(218, 165, 32, 0.8);
-}
-
-.footer .heart {
-    color: #DAA520;
-    animation: luxuryPulse 2s ease infinite;
-}
-
-.footer .name {
-    color: #DAA520;
-    text-decoration: none;
-    transition: all 0.3s ease;
-    padding: 0 4px;
-}
-
-.footer .name:hover {
-    color: #FFD700;
-}
-
-footer {
-    visibility: hidden;
-}
-
-/* Premium Animations */
-@keyframes subtleGradient {
-    0% { background-position: 0% 50%; }
-    50% { background-position: 100% 50%; }
-    100% { background-position: 0% 50%; }
-}
-
-@keyframes floatingParticles {
-    0% { transform: translateY(0); }
-    100% { transform: translateY(-100%); }
-}
-
-@keyframes luxuryScan {
-    0% { transform: translateX(-150%) scaleX(0.3); opacity: 0; }
-    50% { transform: translateX(-50%) scaleX(1); opacity: 0.5; }
-    100% { transform: translateX(50%) scaleX(0.3); opacity: 0; }
-}
-
-@keyframes goldenFlow {
-    0% { background-position: 0% 50%; }
-    50% { background-position: 100% 50%; }
-    100% { background-position: 0% 50%; }
-}
-
-@keyframes premiumGlow {
-    0% { opacity: 0.2; transform: scale(1); }
-    50% { opacity: 0.4; transform: scale(1.01); }
-    100% { opacity: 0.2; transform: scale(1); }
-}
-
-@keyframes luxuryBorder {
-    0% { opacity: 0.3; }
-    50% { opacity: 0.7; }
-    100% { opacity: 0.3; }
-}
-
-@keyframes luxuryPulse {
-    0% { transform: scale(1); opacity: 0.8; }
-    50% { transform: scale(1.1); opacity: 1; }
-    100% { transform: scale(1); opacity: 0.8; }
-}
-"""
-# Start the API server
-def start_api_server():
-    # Start uvicorn in a subprocess
-    process = subprocess.Popen(["uvicorn", "script_search_api:app", "--reload"])
-    return process
-
-# Stop the API server
-def stop_api_server(process):
-    process.terminate()
-
-# Register the exit handler
-api_process = start_api_server()
-atexit.register(stop_api_server, api_process)
-
-async def analyze_with_progress(movie_name, progress=gr.Progress()):
-    """Handle analysis with progress updates in Gradio"""
-    try:
-        async with httpx.AsyncClient(timeout=60.0) as client:
-            # Start the analysis
-            response = await client.get(
-                "http://localhost:8000/api/start_analysis",
-                params={"movie_name": movie_name}
-            )
-            response.raise_for_status()
-            task_id = response.json()["task_id"]
-            
-            # Poll for progress
-            while True:
-                progress_response = await client.get(
-                    f"http://localhost:8000/api/progress/{task_id}"
-                )
-                progress_response.raise_for_status()
-                status = progress_response.json()
-                
-                # Update Gradio progress
-                progress(status["progress"], desc=status["status"])
-                
-                if status["is_complete"]:
-                    if status["error"]:
-                        return f"Error: {status['error']}"
-                    elif status["result"]:
-                        triggers = status["result"].get("detected_triggers", [])
-                        if not triggers or triggers == ["None"]:
-                            return "✓ No triggers detected in the content."
-                        else:
-                            trigger_list = "\n".join([f"• {trigger}" for trigger in triggers])
-                            return f"⚠ Triggers Detected:\n{trigger_list}"
-                    break
-                
-                await asyncio.sleep(0.5)
-    
-    except Exception as e:
-        return f"Error: {str(e)}"
-
-def analyze_with_loading(text, progress=gr.Progress()):
-    """
-    Synchronous wrapper for the async analyze_content function with smooth progress updates
-    """
-    # Initialize progress
-    progress(0, desc="Starting analysis...")
-    
-    # Initial setup phase - smoother progression
-    for i in range(25):
-        time.sleep(0.04)  # Slightly longer sleep for smoother animation
-        progress((i + 1) / 100, desc="Initializing analysis...")
-    
-    # Pre-processing phase
-    for i in range(25, 45):
-        time.sleep(0.03)
-        progress((i + 1) / 100, desc="Pre-processing content...")
-    
-    # Perform analysis
-    progress(0.45, desc="Analyzing content...")
-    try:
-        result = asyncio.run(analyze_content(text))
-        
-        # Analysis progress simulation
-        for i in range(45, 75):
-            time.sleep(0.03)
-            progress((i + 1) / 100, desc="Processing results...")
-            
-    except Exception as e:
-        return f"Error during analysis: {str(e)}"
-    
-    # Final processing with smooth progression
-    for i in range(75, 100):
-        time.sleep(0.02)
-        progress((i + 1) / 100, desc="Finalizing results...")
-    
-    # Format the results
-    triggers = result["detected_triggers"]
-    if triggers == ["None"]:
-        return "✓ No triggers detected in the content."
-    else:
-        trigger_list = "\n".join([f"• {trigger}" for trigger in triggers])
-        return f"⚠ Triggers Detected:\n{trigger_list}"
-
-# Update the Gradio interface with new styling
-import gradio as gr
-from model.analyzer import analyze_content
-import asyncio
-import time
-import httpx
-import subprocess
-import atexit
-
-# Keep your existing CSS and server setup code...
-# [Previous code until the interface definition remains the same]
-
-# Update the Gradio interface with fixed button handling
-with gr.Blocks(css=custom_css, theme=gr.themes.Monochrome()) as iface:
-    # Title section
-    gr.HTML("""
-        <div class="treat-title">
-            <h1 data-text="TREAT R1">TREAT R1</h1>
-            <p>Trigger Recognition for Enjoyable and Appropriate Television</p>
-        </div>
-    """)
-    
-    with gr.Tabs() as tabs:
-        with gr.Tab("Content Analysis"):  # Changed from TabItem to Tab
-            with gr.Column():
-                input_text = gr.Textbox(
-                    label="ANALYZE CONTENT",
-                    placeholder="Enter the content you want to analyze...",
-                    lines=8
-                )
-                analyze_btn = gr.Button("✨ Analyze")
-        
-        with gr.Tab("Movie Search"):  # Changed from TabItem to Tab
-            with gr.Column():
-                search_query = gr.Textbox(
-                    label="SEARCH MOVIES",
-                    placeholder="Type a movie title to search...",
-                    lines=1
-                )
-                search_button = gr.Button("🔍 Search")
-    
-    output_text = gr.Textbox(
-        label="ANALYSIS RESULTS",
-        lines=5,
-        interactive=False
-    )
-    
-    status_text = gr.Markdown(
-        value=""
-    )
-    
-    # Define click events
-    analyze_btn.click(
-        fn=analyze_with_loading,
-        inputs=input_text,
-        outputs=output_text
-    )
-    
-    search_button.click(
-        fn=analyze_with_progress,
-        inputs=search_query,
-        outputs=output_text
-    )
-
-    gr.HTML("""
-        <div class="footer">
-            <p>Made with <span class="heart">💖</span> by <a href="https://www.linkedin.com/in/kubermehta/" target="_blank">Kuber Mehta</a></p>
-        </div>
-    """)
-
-if __name__ == "__main__":
-    iface.launch(
-        share=False,
-        debug=True,
-        show_error=True
+import gradio as gr
+import json
+import time
+import logging
+import re
+from typing import Dict, Any, List, Tuple
+from concurrent.futures import ThreadPoolExecutor, as_completed
+import threading
+from datetime import datetime
+import os
+import tempfile
+
+# Hugging Face Transformers
+import torch
+from transformers import AutoTokenizer, AutoModelForCausalLM, pipeline
+import gc
+
+# Setup logging
+logging.basicConfig(
+    level=logging.INFO,
+    format='%(asctime)s - %(levelname)s - %(message)s'
+)
+logger = logging.getLogger(__name__)
+
+class SyllabusFormatter:
+    def __init__(self, model_name="microsoft/Phi-3-mini-4k-instruct"):
+        """Initialize the formatter with Phi-3 model"""
+        self.model_name = model_name
+        self.tokenizer = None
+        self.model = None
+        self.pipe = None
+        self.is_model_loaded = False
+        self.processing_lock = threading.Lock()
+        
+    def load_model(self):
+        """Load the Phi-3 model with optimizations"""
+        if self.is_model_loaded:
+            return True
+            
+        try:
+            logger.info(f"Loading model: {self.model_name}")
+            
+            # Load tokenizer
+            self.tokenizer = AutoTokenizer.from_pretrained(
+                self.model_name,
+                trust_remote_code=True
+            )
+            
+            # Load model with optimizations
+            self.model = AutoModelForCausalLM.from_pretrained(
+                self.model_name,
+                torch_dtype=torch.float16 if torch.cuda.is_available() else torch.float32,
+                device_map="auto" if torch.cuda.is_available() else None,
+                trust_remote_code=True,
+                low_cpu_mem_usage=True
+            )
+            
+            # Create pipeline
+            self.pipe = pipeline(
+                "text-generation",
+                model=self.model,
+                tokenizer=self.tokenizer,
+                device=0 if torch.cuda.is_available() else -1,
+                torch_dtype=torch.float16 if torch.cuda.is_available() else torch.float32
+            )
+            
+            self.is_model_loaded = True
+            logger.info("Model loaded successfully!")
+            return True
+            
+        except Exception as e:
+            logger.error(f"Error loading model: {str(e)}")
+            return False
+    
+    def create_formatting_prompt(self, unit_content: str, unit_name: str, subject_name: str = "") -> str:
+        """Create a focused prompt for formatting syllabus content"""
+        prompt = f"""<|system|>You are a professional academic syllabus formatter. Your job is to take poorly formatted syllabus content and make it beautifully organized and readable.
+
+RULES:
+1. PRESERVE every single word, topic, and concept from the original
+2. NEVER add explanations, examples, or new content
+3. ONLY restructure and format the existing text
+4. Use clear headings, bullet points, and logical grouping
+5. Separate different topics with proper spacing
+6. Make it scannable and easy to read
+
+FORMAT STYLE:
+- Use main topic headings with proper capitalization
+- Group related subtopics under main topics
+- Use bullet points (•) for lists of concepts
+- Use sub-bullets (◦) for details under main bullets
+- Separate major sections with line breaks
+- Keep technical terms exactly as written<|end|>
+
+<|user|>Subject: {subject_name}
+Unit: {unit_name}
+
+Original content (poorly formatted):
+{unit_content}
+
+Task: Reformat this content to be beautifully organized and readable. Do NOT add any new information - only restructure what's already there.<|end|>
+
+<|assistant|>"""
+        return prompt
+    
+    def format_single_unit(self, unit_data: Tuple[str, str, str, str, str]) -> Tuple[str, str, str, str, str]:
+        """Format a single unit's content"""
+        branch, semester, subject, unit_name, unit_content = unit_data
+        
+        try:
+            with self.processing_lock:
+                # Create prompt
+                prompt = self.create_formatting_prompt(unit_content, unit_name, subject)
+                
+                # Generate formatted content
+                response = self.pipe(
+                    prompt,
+                    max_new_tokens=2048,
+                    temperature=0.1,
+                    do_sample=True,
+                    top_p=0.9,
+                    repetition_penalty=1.1,
+                    pad_token_id=self.tokenizer.eos_token_id,
+                    eos_token_id=self.tokenizer.eos_token_id
+                )
+                
+                # Extract formatted content
+                generated_text = response[0]['generated_text']
+                assistant_start = generated_text.find("<|assistant|>")
+                
+                if assistant_start != -1:
+                    formatted_content = generated_text[assistant_start + len("<|assistant|>"):].strip()
+                else:
+                    formatted_content = generated_text[len(prompt):].strip()
+                
+                # Clean up the content
+                formatted_content = self.clean_generated_content(formatted_content)
+                
+                # Validate content
+                if self.validate_formatted_content(unit_content, formatted_content):
+                    return (branch, semester, subject, unit_name, formatted_content)
+                else:
+                    logger.warning(f"Validation failed for {subject} - {unit_name}")
+                    return (branch, semester, subject, unit_name, unit_content)
+                    
+        except Exception as e:
+            logger.error(f"Error formatting {subject} - {unit_name}: {str(e)}")
+            return (branch, semester, subject, unit_name, unit_content)
+    
+    def clean_generated_content(self, content: str) -> str:
+        """Clean up generated content"""
+        # Remove special tokens
+        content = re.sub(r'<\|.*?\|>', '', content)
+        
+        # Remove AI commentary
+        lines = content.split('\n')
+        cleaned_lines = []
+        
+        for line in lines:
+            line = line.strip()
+            if (line.startswith("Here") and ("formatted" in line.lower() or "organized" in line.lower())) or \
+               line.startswith("I have") or line.startswith("The content has been") or \
+               line.startswith("Note:") or line.startswith("This formatted version"):
+                continue
+            if line:
+                cleaned_lines.append(line)
+        
+        content = '\n'.join(cleaned_lines)
+        
+        # Fix spacing
+        content = re.sub(r'\n\s*\n\s*\n+', '\n\n', content)
+        content = re.sub(r'\n([A-Z][^:\n]*:)\n', r'\n\n\1\n', content)
+        
+        return content.strip()
+    
+    def validate_formatted_content(self, original: str, formatted: str) -> bool:
+        """Validate that formatted content preserves important information"""
+        if len(formatted) < len(original) * 0.4:
+            return False
+        
+        # Check for preservation of key terms
+        original_words = set(re.findall(r'\b[A-Z][a-z]*(?:[A-Z][a-z]*)*\b', original))
+        formatted_words = set(re.findall(r'\b[A-Z][a-z]*(?:[A-Z][a-z]*)*\b', formatted))
+        
+        missing_terms = original_words - formatted_words
+        if len(missing_terms) > len(original_words) * 0.3:
+            return False
+        
+        return True
+    
+    def extract_units_for_processing(self, syllabus_data: Dict[str, Any]) -> List[Tuple[str, str, str, str, str]]:
+        """Extract all units for concurrent processing"""
+        units = []
+        
+        for branch_name, branch_data in syllabus_data.get("syllabus", {}).items():
+            if not isinstance(branch_data, dict):
+                continue
+                
+            for sem_name, sem_data in branch_data.items():
+                if not isinstance(sem_data, dict):
+                    continue
+                    
+                for subject_name, subject_data in sem_data.items():
+                    if not isinstance(subject_data, dict) or "content" not in subject_data:
+                        continue
+                        
+                    content = subject_data["content"]
+                    if not isinstance(content, dict):
+                        continue
+                    
+                    for unit_name, unit_content in content.items():
+                        if unit_name.startswith("Unit") and isinstance(unit_content, str):
+                            units.append((branch_name, sem_name, subject_name, unit_name, unit_content))
+        
+        return units
+    
+    def format_syllabus_concurrent(self, syllabus_data: Dict[str, Any], progress_callback=None, max_workers=4) -> Dict[str, Any]:
+        """Format syllabus using concurrent processing"""
+        if not self.is_model_loaded:
+            if not self.load_model():
+                raise Exception("Failed to load model")
+        
+        # Extract units for processing
+        units = self.extract_units_for_processing(syllabus_data)
+        total_units = len(units)
+        
+        logger.info(f"Processing {total_units} units with {max_workers} workers")
+        
+        # Process units concurrently
+        processed_units = {}
+        completed_count = 0
+        
+        with ThreadPoolExecutor(max_workers=max_workers) as executor:
+            # Submit all tasks
+            future_to_unit = {executor.submit(self.format_single_unit, unit): unit for unit in units}
+            
+            # Process completed tasks
+            for future in as_completed(future_to_unit):
+                try:
+                    branch, semester, subject, unit_name, formatted_content = future.result()
+                    
+                    # Store the result
+                    key = f"{branch}|{semester}|{subject}|{unit_name}"
+                    processed_units[key] = formatted_content
+                    
+                    completed_count += 1
+                    progress = (completed_count / total_units) * 100
+                    
+                    if progress_callback:
+                        progress_callback(progress, f"Processed {subject} - {unit_name}")
+                    
+                    logger.info(f"Completed {completed_count}/{total_units} ({progress:.1f}%)")
+                    
+                except Exception as e:
+                    logger.error(f"Error processing unit: {str(e)}")
+        
+        # Update the syllabus data with formatted content
+        for branch_name, branch_data in syllabus_data.get("syllabus", {}).items():
+            if not isinstance(branch_data, dict):
+                continue
+                
+            for sem_name, sem_data in branch_data.items():
+                if not isinstance(sem_data, dict):
+                    continue
+                    
+                for subject_name, subject_data in sem_data.items():
+                    if not isinstance(subject_data, dict) or "content" not in subject_data:
+                        continue
+                        
+                    content = subject_data["content"]
+                    if not isinstance(content, dict):
+                        continue
+                    
+                    for unit_name in content.keys():
+                        if unit_name.startswith("Unit"):
+                            key = f"{branch_name}|{sem_name}|{subject_name}|{unit_name}"
+                            if key in processed_units:
+                                syllabus_data["syllabus"][branch_name][sem_name][subject_name]["content"][unit_name] = processed_units[key]
+        
+        # Add metadata
+        if "metadata" not in syllabus_data:
+            syllabus_data["metadata"] = {}
+        
+        syllabus_data["metadata"]["lastFormatted"] = datetime.now().isoformat()
+        syllabus_data["metadata"]["formattingNote"] = "Content formatted using Phi-3 AI for enhanced readability"
+        syllabus_data["metadata"]["originalContentPreserved"] = True
+        syllabus_data["metadata"]["unitsProcessed"] = completed_count
+        syllabus_data["metadata"]["formattingModel"] = self.model_name
+        syllabus_data["metadata"]["version"] = "2.0"
+        syllabus_data["metadata"]["processedConcurrently"] = True
+        syllabus_data["metadata"]["maxWorkers"] = max_workers
+        
+        return syllabus_data
+
+# Global formatter instance
+formatter = SyllabusFormatter()
+
+def format_syllabus_file(file_path, max_workers=4, progress=gr.Progress()):
+    """Main function to format syllabus file"""
+    try:
+        # Load JSON file
+        with open(file_path, 'r', encoding='utf-8') as f:
+            syllabus_data = json.load(f)
+        
+        # Count units
+        units = formatter.extract_units_for_processing(syllabus_data)
+        total_units = len(units)
+        
+        progress(0, f"Found {total_units} units to process")
+        
+        # Progress callback
+        def update_progress(percent, message):
+            progress(percent/100, message)
+        
+        # Format the syllabus
+        formatted_data = formatter.format_syllabus_concurrent(
+            syllabus_data, 
+            progress_callback=update_progress,
+            max_workers=max_workers
+        )
+        
+        # Save to temporary file
+        with tempfile.NamedTemporaryFile(mode='w', suffix='.json', delete=False, encoding='utf-8') as f:
+            json.dump(formatted_data, f, indent=2, ensure_ascii=False)
+            temp_path = f.name
+        
+        progress(1.0, f"Completed! Processed {total_units} units")
+        
+        return temp_path, f"✅ Successfully formatted {total_units} units!"
+        
+    except Exception as e:
+        error_msg = f"❌ Error: {str(e)}"
+        logger.error(error_msg)
+        return None, error_msg
+
+def create_sample_json():
+    """Create a sample JSON file for testing"""
+    sample_data = {
+        "metadata": {
+            "totalFiles": 1,
+            "generatedAt": datetime.now().isoformat(),
+            "source": "Sample syllabus for testing",
+            "description": "Sample syllabus content"
+        },
+        "syllabus": {
+            "CSE": {
+                "SEM1": {
+                    "Mathematics": {
+                        "extractedFrom": {
+                            "path": "CSE > SEM1 > Mathematics",
+                            "branch": "CSE",
+                            "semester": "SEM1",
+                            "subject": "Mathematics"
+                        },
+                        "content": {
+                            "Unit I": "Differential Calculus: Limits, continuity, derivatives, applications of derivatives, maxima and minima, curve sketching, related rates, optimization problems, L'Hospital's rule, Taylor series, Partial derivatives, total differential, chain rule, implicit differentiation, Jacobians.",
+                            "Unit II": "Integral Calculus: Integration techniques, definite integrals, applications of integrals, area under curves, volume of solids, arc length, surface area, Multiple integrals, double integrals, triple integrals, change of variables, applications in geometry and physics."
+                        }
+                    }
+                }
+            }
+        }
+    }
+    
+    with tempfile.NamedTemporaryFile(mode='w', suffix='.json', delete=False, encoding='utf-8') as f:
+        json.dump(sample_data, f, indent=2, ensure_ascii=False)
+        return f.name
+
+# Gradio Interface
+def create_interface():
+    with gr.Blocks(
+        title="Syllabus Formatter - AI-Powered JSON Syllabus Formatter",
+        theme=gr.themes.Soft(
+            primary_hue="blue",
+            secondary_hue="purple",
+            neutral_hue="gray"
+        )
+    ) as interface:
+        
+        gr.HTML("""
+        <div style="text-align: center; padding: 20px; background: linear-gradient(135deg, #667eea 0%, #764ba2 100%); color: white; border-radius: 10px; margin-bottom: 20px;">
+            <h1 style="font-size: 2.5em; margin-bottom: 10px;">🎓 Syllabus Formatter</h1>
+            <p style="font-size: 1.2em; opacity: 0.9;">AI-Powered JSON Syllabus Content Formatter using Phi-3</p>
+            <p style="font-size: 1em; opacity: 0.8;">Upload your JSON syllabus file and get beautifully formatted content with concurrent processing for speed!</p>
+        </div>
+        """)
+        
+        with gr.Row():
+            with gr.Column(scale=1):
+                gr.HTML("""
+                <div style="background: #f8f9fa; padding: 15px; border-radius: 8px; margin-bottom: 15px;">
+                    <h3>📋 Instructions:</h3>
+                    <ol>
+                        <li>Upload your JSON syllabus file</li>
+                        <li>Choose number of concurrent workers (1-8)</li>
+                        <li>Click "Format Syllabus" to start processing</li>
+                        <li>Download the formatted JSON file</li>
+                    </ol>
+                    <p><strong>Note:</strong> Only syllabus content will be formatted, metadata remains unchanged.</p>
+                </div>
+                """)
+                
+                file_input = gr.File(
+                    label="📁 Upload JSON Syllabus File",
+                    file_types=[".json"],
+                    type="filepath"
+                )
+                
+                workers_slider = gr.Slider(
+                    minimum=1,
+                    maximum=8,
+                    value=4,
+                    step=1,
+                    label="🔄 Concurrent Workers",
+                    info="More workers = faster processing (but more memory usage)"
+                )
+                
+                format_btn = gr.Button(
+                    "🚀 Format Syllabus",
+                    variant="primary",
+                    size="lg"
+                )
+                
+                sample_btn = gr.Button(
+                    "📝 Download Sample JSON",
+                    variant="secondary"
+                )
+            
+            with gr.Column(scale=1):
+                status_output = gr.Textbox(
+                    label="📊 Status",
+                    lines=3,
+                    interactive=False
+                )
+                
+                download_output = gr.File(
+                    label="📥 Download Formatted JSON",
+                    visible=False
+                )
+                
+                gr.HTML("""
+                <div style="background: #e3f2fd; padding: 15px; border-radius: 8px; margin-top: 15px;">
+                    <h3>✨ Features:</h3>
+                    <ul>
+                        <li>🤖 Powered by Microsoft Phi-3 AI model</li>
+                        <li>⚡ Concurrent processing for speed</li>
+                        <li>🔒 Preserves all original content</li>
+                        <li>📊 Real-time progress tracking</li>
+                        <li>🎯 Formats only syllabus content, not metadata</li>
+                        <li>✅ Validation to ensure content integrity</li>
+                    </ul>
+                </div>
+                """)
+        
+        # Event handlers
+        def format_handler(file_path, max_workers):
+            if file_path is None:
+                return "❌ Please upload a JSON file first.", gr.update(visible=False)
+            
+            try:
+                result_path, message = format_syllabus_file(file_path, int(max_workers))
+                if result_path:
+                    return message, gr.update(visible=True, value=result_path)
+                else:
+                    return message, gr.update(visible=False)
+            except Exception as e:
+                return f"❌ Error: {str(e)}", gr.update(visible=False)
+        
+        def sample_handler():
+            sample_path = create_sample_json()
+            return gr.update(visible=True, value=sample_path)
+        
+        format_btn.click(
+            format_handler,
+            inputs=[file_input, workers_slider],
+            outputs=[status_output, download_output]
+        )
+        
+        sample_btn.click(
+            sample_handler,
+            outputs=[gr.File(label="📥 Sample JSON File", visible=True)]
+        )
+        
+        gr.HTML("""
+        <div style="text-align: center; padding: 15px; margin-top: 20px; border-top: 1px solid #ddd;">
+            <p style="color: #666;">
+                Built with ❤️ using Hugging Face Spaces | 
+                Powered by Microsoft Phi-3 | 
+                Optimized for concurrent processing
+            </p>
+        </div>
+        """)
+    
+    return interface
+
+# Launch the app
+if __name__ == "__main__":
+    interface = create_interface()
+    interface.launch(
+        server_name="0.0.0.0",
+        server_port=7860,
+        share=True
     )