Update app.py

app.py

@@ -1,170 +1,261 @@
+# app.py - Robust version with fallback
 import gradio as gr
-from model_wrapper import CodeDebuggerWrapper
 import logging
+import traceback
 
-# Set up logging for the main app
-logging.basicConfig(level=logging.INFO)
+# Set up logging
+logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(levelname)s - %(message)s')
 logger = logging.getLogger(__name__)
 
-# Global variable to store the debugger instance
+# Global debugger instance
 debugger = None
+debugger_status = "🔄 Initializing..."
 
 def initialize_debugger():
-    """Initialize the debugger with proper error handling."""
-    global debugger
+    """Initialize the debugger with comprehensive error handling."""
+    global debugger, debugger_status
+    
     try:
-        logger.info("🚀 Initializing Code Debugger...")
-        debugger = CodeDebuggerWrapper()
-        logger.info("✅ Debugger initialized successfully!")
-        return "✅ Model loaded successfully!"
-    except Exception as e:
-        error_msg = f"❌ Failed to initialize debugger: {str(e)}"
-        logger.error(error_msg)
-        return error_msg
+        logger.info("🚀 Starting debugger initialization...")
+        debugger_status = "🔄 Loading AI model..."
+        
+        # First, try the main model wrapper
+        try:
+            from model_wrapper import CodeDebuggerWrapper
+            logger.info("Attempting to load main model wrapper...")
+            debugger = CodeDebuggerWrapper()
+            debugger_status = "✅ AI model loaded successfully!"
+            logger.info("✅ Main model wrapper loaded successfully")
+            return debugger_status
+            
+        except Exception as main_error:
+            logger.warning(f"Main model wrapper failed: {str(main_error)[:200]}...")
+            logger.debug(f"Full error: {traceback.format_exc()}")
+            
+            # Try fallback debugger
+            try:
+                from model_wrapper import FallbackDebugger
+                logger.info("Falling back to rule-based debugger...")
+                debugger = FallbackDebugger()
+                debugger_status = "⚠️ Using fallback debugger (AI model unavailable)"
+                logger.info("✅ Fallback debugger loaded")
+                return debugger_status
+                
+            except Exception as fallback_error:
+                logger.error(f"Fallback debugger also failed: {fallback_error}")
+                debugger_status = "❌ Both AI and fallback debuggers failed"
+                return debugger_status
+    
+    except Exception as critical_error:
+        logger.error(f"Critical initialization error: {critical_error}")
+        logger.error(f"Full traceback: {traceback.format_exc()}")
+        debugger_status = f"❌ Critical error: {str(critical_error)[:100]}..."
+        return debugger_status
 
 def debug_code(code: str):
-    """Debug code with proper error handling."""
-    global debugger
+    """Debug code with comprehensive error handling."""
+    global debugger, debugger_status
     
+    # Input validation
     if not code or not code.strip():
         return "❌ Please paste some code to debug."
     
-    # Initialize debugger if not already done
+    # Initialize debugger if needed
     if debugger is None:
-        init_result = initialize_debugger()
-        if "❌" in init_result:
-            return init_result
+        logger.info("Debugger not initialized, initializing now...")
+        status = initialize_debugger()
+        if "❌" in status:
+            return f"{status}\n\n🔧 **Manual Analysis:**\n{manual_debug_fallback(code)}"
     
+    # Try to debug with loaded debugger
     try:
-        logger.info("🐞 Processing code debug request...")
+        logger.info("🐞 Processing debug request...")
         result = debugger.debug(code)
         logger.info("✅ Debug request completed")
         return result
+        
+    except Exception as debug_error:
+        logger.error(f"Debug processing failed: {debug_error}")
+        logger.error(f"Full traceback: {traceback.format_exc()}")
+        
+        # Ultimate fallback
+        return f"❌ Debug processing failed: {str(debug_error)[:100]}...\n\n🔧 **Manual Analysis:**\n{manual_debug_fallback(code)}"
+
+def manual_debug_fallback(code: str) -> str:
+    """Ultimate fallback - basic syntax checking."""
+    try:
+        issues = []
+        lines = code.split('\n')
+        
+        for i, line in enumerate(lines, 1):
+            stripped = line.strip()
+            if not stripped or stripped.startswith('#'):
+                continue
+            
+            # Check for missing colons
+            control_keywords = ['if ', 'elif ', 'else:', 'for ', 'while ', 'def ', 'class ', 'try:', 'except', 'finally:']
+            if any(keyword in stripped for keyword in control_keywords):
+                if not stripped.endswith(':') and 'else:' not in stripped and 'try:' not in stripped and 'finally:' not in stripped:
+                    issues.append(f"Line {i}: Possible missing colon (:)")
+            
+            # Check for unbalanced parentheses
+            if stripped.count('(') != stripped.count(')'):
+                issues.append(f"Line {i}: Unbalanced parentheses")
+            
+            # Check for unbalanced quotes
+            single_quotes = stripped.count("'")
+            double_quotes = stripped.count('"')
+            if single_quotes % 2 != 0:
+                issues.append(f"Line {i}: Unbalanced single quotes")
+            if double_quotes % 2 != 0:
+                issues.append(f"Line {i}: Unbalanced double quotes")
+        
+        # Generate response
+        result = f"**Your Code:**\n```python\n{code}\n```\n\n"
+        
+        if issues:
+            result += "**Potential Issues Found:**\n"
+            for issue in issues:
+                result += f"• {issue}\n"
+        else:
+            result += "**No obvious syntax errors detected.**\n"
+        
+        result += "\n**Debugging Checklist:**\n"
+        result += "• ✓ Check for missing colons after if/for/def statements\n"
+        result += "• ✓ Verify proper indentation (4 spaces per level)\n"
+        result += "• ✓ Ensure parentheses and quotes are balanced\n"
+        result += "• ✓ Check for typos in variable names\n"
+        result += "• ✓ Verify all imports are included\n"
+        result += "• ✓ Look for logic errors in conditions\n"
+        
+        return result
+        
     except Exception as e:
-        error_msg = f"❌ Error during model inference: {str(e)}"
-        logger.error(error_msg)
-        return error_msg
+        return f"Even manual analysis failed: {e}\n\nOriginal code:\n{code}"
 
-# Create the Gradio interface
-def create_interface():
+def get_status():
+    """Get current system status."""
+    global debugger_status
+    return debugger_status
+
+def create_app():
     """Create the Gradio interface."""
     
-    # Custom CSS for better styling
-    css = """
-    .gradio-container {
-        font-family: 'Arial', sans-serif;
-    }
-    .gr-button {
-        background: linear-gradient(45deg, #FF6B6B, #4ECDC4);
-        border: none;
-        color: white;
-        font-weight: bold;
-    }
-    .gr-button:hover {
-        transform: translateY(-2px);
-        box-shadow: 0 4px 8px rgba(0,0,0,0.2);
-    }
-    """
-    
-    with gr.Blocks(css=css, title="🐞 AI Code Debugger", theme=gr.themes.Soft()) as demo:
+    with gr.Blocks(
+        title="🐞 AI Code Debugger",
+        theme=gr.themes.Soft(),
+        css="""
+        .status-box { 
+            background: linear-gradient(45deg, #f0f0f0, #e0e0e0); 
+            border-radius: 10px; 
+            padding: 10px; 
+        }
+        .code-box {
+            font-family: 'Consolas', 'Monaco', monospace;
+            font-size: 14px;
+        }
+        """
+    ) as demo:
+        
         # Header
-        gr.Markdown(
-            """
-            # 🐞 AI Code Debugger
-            ### Fine-tuned AI model for debugging Python code
-            
-            **Instructions:**
-            1. Paste your Python code in the input box below
-            2. Click "🔧 Debug Code" to get suggestions and fixes
-            3. The AI will analyze your code and provide improvements
-            
-            ---
-            """
-        )
+        gr.Markdown("""
+        # 🐞 AI Code Debugger
+        ### Fine-tuned AI model for debugging Python code
         
-        # Status indicator
-        status_box = gr.Textbox(
-            value="🔄 Initializing model...",
+        **How to use:**
+        1. Paste your Python code in the left box
+        2. Click "🔧 Debug Code" 
+        3. Get AI-powered suggestions and fixes
+        """)
+        
+        # Status display
+        status_display = gr.Textbox(
             label="📊 System Status",
+            value="🔄 Loading...",
             interactive=False,
-            max_lines=2
+            elem_classes=["status-box"]
         )
         
         # Main interface
         with gr.Row():
             with gr.Column(scale=1):
-                code_input = gr.Code(
-                    language="python",
-                    lines=15,
-                    value="""# Paste your Python code here
-# Example:
-def fibonacci(n):
-    if n <= 1
-        return n
-    else:
-        return fibonacci(n-1) + fibonacci(n-2)
-
-print(fibonacci(10))""",
+                code_input = gr.Textbox(
+                    lines=16,
+                    placeholder="Paste your Python code here...",
                     label="🔍 Input Code",
-                    elem_id="code_input"
+                    elem_classes=["code-box"],
+                    value="""# Example: Function with syntax error
+def calculate_average(numbers):
+    total = 0
+    for num in numbers
+        total += num
+    return total / len(numbers)
+
+# Test with empty list (will cause error)
+result = calculate_average([])
+print(result)"""
                 )
                 
-                debug_btn = gr.Button(
-                    "🔧 Debug Code",
-                    variant="primary",
-                    size="lg",
-                    elem_id="debug_button"
-                )
+                with gr.Row():
+                    debug_btn = gr.Button(
+                        "🔧 Debug Code", 
+                        variant="primary", 
+                        size="lg"
+                    )
+                    clear_btn = gr.Button(
+                        "🗑️ Clear", 
+                        variant="secondary"
+                    )
             
             with gr.Column(scale=1):
-                output = gr.Code(
-                    language="python",
-                    lines=15,
-                    label="✨ Debugged Code / Suggestions",
-                    elem_id="code_output"
+                output = gr.Textbox(
+                    lines=16,
+                    label="✨ Debug Results",
+                    placeholder="Debug results will appear here...",
+                    elem_classes=["code-box"]
                 )
         
         # Examples section
-        gr.Markdown("### 📝 Example Issues to Try:")
+        gr.Markdown("### 📚 Example Problems:")
         
-        examples = [
-            ["""def calculate_average(numbers):
-    total = 0
-    for num in numbers:
-        total += num
-    return total / len(numbers)
+        example_codes = [
+            # Syntax error example
+            ["""def greet(name):
+    if name
+        print(f"Hello, {name}!")
+    else:
+        print("Hello, stranger!")
 
-# This will cause division by zero error
-result = calculate_average([])
-print(result)"""],
+greet("Alice")"""],
             
-            ["""import math
-
-def find_roots(a, b, c):
-    discriminant = b**2 - 4*a*c
-    root1 = (-b + math.sqrt(discriminant)) / (2*a)
-    root2 = (-b - math.sqrt(discriminant)) / (2*a)
-    return root1, root2
+            # Logic error example  
+            ["""def find_maximum(numbers):
+    max_num = 0  # Bug: assumes all numbers are positive
+    for num in numbers:
+        if num > max_num:
+            max_num = num
+    return max_num
 
-# This might have issues with negative discriminant
-print(find_roots(1, 2, 5))"""],
+result = find_maximum([-5, -2, -8, -1])
+print(f"Maximum: {result}")"""],
             
-            ["""def process_list(items):
+            # Runtime error example
+            ["""def divide_list(numbers, divisor):
     result = []
-    for i in range(len(items)):
-        if items[i] > 0:
-            result.append(items[i] * 2)
+    for num in numbers:
+        result.append(num / divisor)
     return result
 
-# Test the function
-data = [1, -2, 3, -4, 5]
-print(process_list(data))"""]
+# This will cause division by zero
+data = [10, 20, 30]
+divided = divide_list(data, 0)
+print(divided)"""],
         ]
         
         gr.Examples(
-            examples=examples,
+            examples=example_codes,
             inputs=code_input,
-            label="Click any example to load it:"
+            label="Click any example to load:"
         )
         
         # Event handlers
@@ -174,33 +265,36 @@ print(process_list(data))"""]
             outputs=output
         )
         
-        # Initialize on startup
+        clear_btn.click(
+            lambda: ("", ""),
+            outputs=[code_input, output]
+        )
+        
+        # Initialize status on load
         demo.load(
             fn=initialize_debugger,
-            outputs=status_box
+            outputs=status_display
         )
         
         # Footer
-        gr.Markdown(
-            """
-            ---
-            
-            **Tips for better results:**
-            - Include complete, runnable code snippets
-            - Add comments explaining what you expect the code to do
-            - Include any error messages you're seeing
-            
-            **Model:** `Girinath11/aiml_code_debug_model` | **Framework:** Transformers + Gradio
-            """
-        )
+        gr.Markdown("""
+        ---
+        **Model:** `Girinath11/aiml_code_debug_model` | **Fallback:** Rule-based analysis
+        
+        **Tips for better results:**
+        • Include complete, runnable code snippets
+        • Add comments explaining expected behavior  
+        • Include any error messages you're seeing
+        """)
     
     return demo
 
-# Main execution
 if __name__ == "__main__":
-    # Create and launch the interface
-    demo = create_interface()
-    
-    # Launch with appropriate settings for Hugging Face Spaces
-    demo.launch(
-        share=True)
+    try:
+        logger.info("🚀 Starting Code Debugger application...")
+        demo = create_app()
+        
+        # Launch the app
+        demo.launch(
+            share=True
+        )