updated app.py 2

app.py

@@ -1,4 +1,4 @@
-# app.py - CodeLab Stage 3: Semantic Analysis - Enhanced Version
+# app.py - CodeLab Stage 3: Semantic Analysis - Fixed Version
 import gradio as gr
 import torch
 from transformers import AutoTokenizer, AutoModel, T5ForConditionalGeneration, T5Tokenizer
@@ -120,18 +120,17 @@ class SemanticAnalyzer:
         except Exception as e:
             logger.error(f"❌ Error in CodeT5 analysis: {str(e)}")
             return self._fallback_analysis(code)
-
     
     def _fallback_analysis(self, code: str) -> Dict[str, Any]:
-    """Fallback analysis when AI models fail"""
-    lines_count = len(code.split('\n'))
-    return {
-        'code_summary': f'Python function with {lines_count} lines',
-        'logic_patterns': self.extract_logic_patterns_enhanced(code),
-        'approach_analysis': self.analyze_approach_enhanced(code),
-        'complexity_analysis': self.analyze_complexity_enhanced(code),
-        'semantic_quality': self.assess_semantic_quality(code)
-    }
+        """Fallback analysis when AI models fail"""
+        lines_count = len(code.split('\n'))
+        return {
+            'code_summary': f'Python function with {lines_count} lines',
+            'logic_patterns': self.extract_logic_patterns_enhanced(code),
+            'approach_analysis': self.analyze_approach_enhanced(code),
+            'complexity_analysis': self.analyze_complexity_enhanced(code),
+            'semantic_quality': self.assess_semantic_quality(code)
+        }
     
     def extract_logic_patterns_enhanced(self, code: str) -> List[str]:
         """Enhanced logical pattern extraction"""
@@ -152,10 +151,10 @@ class SemanticAnalyzer:
         if 'return' in code: patterns.append('return_statement')
         
         # Advanced patterns with regex
-        if re.search(r'for\\s+\\w+\\s+in\\s+range', code): patterns.append('indexed_iteration')
-        if re.search(r'for\\s+\\w+\\s+in\\s+enumerate', code): patterns.append('indexed_enumeration')
-        if re.search(r'if\\s+.*[<>]=?.*:', code): patterns.append('comparison_logic')
-        if re.search(r'\\[.*\\]', code): patterns.append('list_operations')
+        if re.search(r'for\s+\w+\s+in\s+range', code): patterns.append('indexed_iteration')
+        if re.search(r'for\s+\w+\s+in\s+enumerate', code): patterns.append('indexed_enumeration')
+        if re.search(r'if\s+.*[<>]=?.*:', code): patterns.append('comparison_logic')
+        if re.search(r'\[.*\]', code): patterns.append('list_operations')
         
         # Error handling patterns
         if 'try:' in code or 'except' in code: patterns.append('error_handling')
@@ -191,7 +190,7 @@ class SemanticAnalyzer:
         # Advanced approaches
         elif 'enumerate' in code:
             return 'enumerated_iteration_approach'
-        elif re.search(r'def\\s+\\w+.*def\\s+\\w+', code):
+        elif re.search(r'def\s+\w+.*def\s+\w+', code):
             return 'nested_function_approach'
         else:
             return 'custom_logic_approach'
@@ -214,7 +213,7 @@ class SemanticAnalyzer:
                 return 'O(1)'
         
         def estimate_space_complexity(code):
-            if 'sorted(' in code or re.search(r'\\[.*for.*\\]', code):
+            if 'sorted(' in code or re.search(r'\[.*for.*\]', code):
                 return 'O(n)'
             elif '[' in code and ']' in code:
                 return 'O(n)'
@@ -236,7 +235,7 @@ class SemanticAnalyzer:
         }
         
         # Readability assessment
-        lines = code.split('\\n')
+        lines = code.split('\n')
         total_score = 10
         
         # Check for comments or docstrings
@@ -245,7 +244,7 @@ class SemanticAnalyzer:
             total_score += 1
         
         # Check for meaningful variable names
-        if re.search(r'\\b(max_val|min_val|result|answer|total)\\b', code):
+        if re.search(r'\b(max_val|min_val|result|answer|total)\b', code):
             quality_metrics['best_practices'].append('meaningful_variables')
             total_score += 1
         
@@ -279,7 +278,7 @@ class SemanticAnalyzer:
             # Pattern-based solution generation (more reliable than AI generation)
             if 'max' in question_lower and 'min' not in question_lower:
                 return {
-                    'code': 'def find_max(numbers):\\n    """Find maximum value in a list"""\\n    if not numbers:\\n        return None\\n    return max(numbers)',
+                    'code': 'def find_max(numbers):\n    """Find maximum value in a list"""\n    if not numbers:\n        return None\n    return max(numbers)',
                     'explanation': 'Optimal solution using built-in max() function with input validation',
                     'approach': 'builtin_optimized',
                     'complexity': {'time': 'O(n)', 'space': 'O(1)'},
@@ -288,7 +287,7 @@ class SemanticAnalyzer:
                 }
             elif 'min' in question_lower and 'max' not in question_lower:
                 return {
-                    'code': 'def find_min(numbers):\\n    """Find minimum value in a list"""\\n    if not numbers:\\n        return None\\n    return min(numbers)',
+                    'code': 'def find_min(numbers):\n    """Find minimum value in a list"""\n    if not numbers:\n        return None\n    return min(numbers)',
                     'explanation': 'Optimal solution using built-in min() function with input validation',
                     'approach': 'builtin_optimized',
                     'complexity': {'time': 'O(n)', 'space': 'O(1)'},
@@ -297,7 +296,7 @@ class SemanticAnalyzer:
                 }
             elif 'sum' in question_lower or 'total' in question_lower:
                 return {
-                    'code': 'def calculate_sum(numbers):\\n    """Calculate sum of numbers in a list"""\\n    return sum(numbers)',
+                    'code': 'def calculate_sum(numbers):\n    """Calculate sum of numbers in a list"""\n    return sum(numbers)',
                     'explanation': 'Optimal solution using built-in sum() function',
                     'approach': 'builtin_optimized',
                     'complexity': {'time': 'O(n)', 'space': 'O(1)'},
@@ -357,7 +356,7 @@ class SemanticAnalyzer:
     def _template_solution(self, question_text: str) -> Dict[str, Any]:
         """Template-based fallback solution"""
         return {
-            'code': 'def solution(data):\\n    """Template solution"""\\n    # Implementation needed\\n    return data[0] if data else None',
+            'code': 'def solution(data):\n    """Template solution"""\n    # Implementation needed\n    return data[0] if data else None',
             'explanation': 'Template solution - implementation needed based on specific requirements',
             'approach': 'template_fallback',
             'complexity': 'O(1)',
@@ -475,8 +474,8 @@ class SemanticAnalyzer:
     def _clean_code_for_analysis(self, code: str) -> str:
         """Clean code for better analysis"""
         # Remove excessive whitespace
-        lines = [line.strip() for line in code.split('\\n') if line.strip()]
-        return '\\n'.join(lines)
+        lines = [line.strip() for line in code.split('\n') if line.strip()]
+        return '\n'.join(lines)
 
 # Initialize the analyzer (with lazy loading)
 analyzer = None
@@ -701,7 +700,7 @@ demo = gr.Interface(
             label="Student Code",
             placeholder="Enter Python code here...",
             lines=12,
-            value="def find_max(numbers):\\n    max_val = numbers[0]\\n    for num in numbers:\\n        if num > max_val:\\n            max_val = num\\n    return max_val"
+            value="def find_max(numbers):\n    max_val = numbers[0]\n    for num in numbers:\n        if num > max_val:\n            max_val = num\n    return max_val"
         ),
         gr.Textbox(
             label="Question Text",
@@ -719,24 +718,24 @@ demo = gr.Interface(
         lines=25,
         show_copy_button=True
     ),
-    title="🧠 CodeLab Semantic Analysis - Stage 3 (Enhanced)",
+    title="🧠 CodeLab Semantic Analysis - Stage 3 (Fixed)",
     description="""
     Advanced semantic analysis using CodeBERT and CodeT5 models for educational code evaluation.
     This system analyzes code semantics, generates optimal solutions, and provides educational insights.
     """,
     examples=[
         [
-            "def find_max(numbers):\\n    return max(numbers)",
+            "def find_max(numbers):\n    return max(numbers)",
             "Find the maximum number in a list",
             True
         ],
         [
-            "def find_min(arr):\\n    minimum = arr[0]\\n    for i in range(1, len(arr)):\\n        if arr[i] < minimum:\\n            minimum = arr[i]\\n    return minimum",
+            "def find_min(arr):\n    minimum = arr[0]\n    for i in range(1, len(arr)):\n        if arr[i] < minimum:\n            minimum = arr[i]\n    return minimum",
             "Find the minimum number in an array", 
             True
         ],
         [
-            "def calculate_sum(nums):\\n    total = 0\\n    for num in nums:\\n        total += num\\n    return total",
+            "def calculate_sum(nums):\n    total = 0\n    for num in nums:\n        total += num\n    return total",
             "Calculate the sum of all numbers in a list",
             True
         ]