Update app.py

app.py

@@ -2,7 +2,7 @@ import streamlit as st
 from transformers import AutoTokenizer, AutoModelForSequenceClassification
 import ast
 import astor
-import os
+import traceback
 
 # Initialize Hugging Face model and tokenizer
 MODEL_NAME = "microsoft/codebert-base"
@@ -27,7 +27,7 @@ def analyze_code(code):
     
     return results
 
-# Function to detect and fix bugs
+# Function to detect and fix bugs, including logical errors
 def detect_and_fix_bugs(code):
     suggestions = []
     fixed_code = code
@@ -35,33 +35,77 @@ def detect_and_fix_bugs(code):
     try:
         tree = ast.parse(code)
 
-        # Example: Check for missing except blocks in try statements
+        # Detect undefined variable usage
         for node in ast.walk(tree):
-            if isinstance(node, ast.Try):
-                if not any(isinstance(handler, ast.ExceptHandler) for handler in node.handlers):
-                    suggestions.append("Add an 'except' block to handle exceptions in the 'try' statement.")
-                    # Add a generic except block as a fix
-                    new_handler = ast.ExceptHandler(type=None, name=None, body=[ast.Pass()])
-                    node.handlers.append(new_handler)
-
-        # Example: Check for missing comments
-        if not any(isinstance(node, ast.Expr) and isinstance(node.value, ast.Str) for node in tree.body):
-            suggestions.append("Consider adding a module-level docstring or comments to improve code clarity.")
-            # Add a module-level docstring as a fix
-            docstring = ast.Expr(value=ast.Str(s="""Add a description of the module here."""))
-            tree.body.insert(0, docstring)
+            if isinstance(node, ast.Name) and isinstance(node.ctx, ast.Load):
+                if node.id not in {n.id for n in ast.walk(tree) if isinstance(n, ast.Name) and isinstance(n.ctx, ast.Store)}:
+                    suggestions.append(f"Variable '{node.id}' is used but not defined.")
+
+        undefined_variables = [
+            node.id for node in ast.walk(tree)
+            if isinstance(node, ast.Name) and isinstance(node.ctx, ast.Load) and
+            node.id not in {n.id for n in ast.walk(tree) if isinstance(n, ast.Name) and isinstance(n.ctx, ast.Store)}
+        ]
+        for var in undefined_variables:
+            fix_statement = ast.Assign(targets=[ast.Name(id=var, ctx=ast.Store())], value=ast.Constant(value=None))
+            tree.body.insert(0, fix_statement)
+            suggestions.append(f"Added a definition for variable '{var}'.")
+
+        # Detect unused variables
+        assigned_vars = {n.id for n in ast.walk(tree) if isinstance(n, ast.Name) and isinstance(n.ctx, ast.Store)}
+        used_vars = {n.id for n in ast.walk(tree) if isinstance(n, ast.Name) and isinstance(n.ctx, ast.Load)}
+        unused_vars = assigned_vars - used_vars
+        for var in unused_vars:
+            suggestions.append(f"Variable '{var}' is defined but never used.")
+
+        # Detect missing imports
+        import_names = {n.name for n in ast.walk(tree) if isinstance(n, ast.Import)}
+        for node in ast.walk(tree):
+            if isinstance(node, ast.Call) and hasattr(node.func, 'id') and node.func.id not in import_names:
+                suggestions.append(f"Missing import for '{node.func.id}'.")
+
+        # Detect invalid function calls
+        for node in ast.walk(tree):
+            if isinstance(node, ast.Call):
+                if isinstance(node.func, ast.Name):
+                    if not any(isinstance(n, ast.FunctionDef) and n.name == node.func.id for n in ast.walk(tree)):
+                        suggestions.append(f"Function '{node.func.id}' is called but not defined.")
+
+        # Detect type mismatches (example: adding string to integer)
+        for node in ast.walk(tree):
+            if isinstance(node, ast.BinOp):
+                left = node.left
+                right = node.right
+                if isinstance(left, ast.Constant) and isinstance(right, ast.Constant):
+                    if type(left.value) != type(right.value):
+                        suggestions.append(f"Type mismatch in operation: '{left.value}' ({type(left.value).__name__}) and '{right.value}' ({type(right.value).__name__}).")
+
+        # Detect logical errors (example: unreachable code)
+        for i, node in enumerate(tree.body):
+            if isinstance(node, ast.If):
+                if isinstance(node.test, ast.Constant) and node.test.value is False:
+                    suggestions.append(f"Unreachable code detected at line {node.lineno}.")
+                elif isinstance(node.test, ast.Constant) and node.test.value is True:
+                    suggestions.append(f"Redundant condition always True at line {node.lineno}.")
+
+        # Detect duplicate keys in dictionaries
+        for node in ast.walk(tree):
+            if isinstance(node, ast.Dict):
+                keys = [k.value for k in node.keys if isinstance(k, ast.Constant)]
+                if len(keys) != len(set(keys)):
+                    suggestions.append("Duplicate keys detected in dictionary.")
 
         # Convert the modified AST back to code
         fixed_code = astor.to_source(tree)
 
     except Exception as e:
-        suggestions.append(f"Error analyzing code: {e}")
+        suggestions.append(f"Error analyzing code: {traceback.format_exc()}")
 
     return suggestions, fixed_code
 
 # Streamlit app UI
 st.title("Code Quality, Bug Detection, and Auto-Correction Tool")
-st.markdown("Analyze your code for syntax issues, quality, bugs, and get suggested corrections.")
+st.markdown("Analyze your code for syntax issues, quality, bugs, logical errors, and get suggested corrections.")
 
 # File uploader
 uploaded_file = st.file_uploader("Upload a Python code file", type=["py"])