Update app.py

app.py

@@ -34,39 +34,41 @@ class ErrorReporter(Reporter):
 def check_code_with_pyflakes(code_str: str) -> str:
     """
     Analyzes a string of Python code using pyflakes and returns a formatted error report.
-    Crucially, it filters out warnings related to star imports (`from manim import *`).
+    This version uses a robust blocklist to filter out all warnings related to star imports.
     Returns an empty string if no definite errors are found.
     """
     reporter = ErrorReporter()
     check(code_str, "scene.py", reporter=reporter)
     
+    # A blocklist of warning substrings to completely ignore.
+    IGNORE_SUBSTRINGS = [
+        "may be undefined, or defined from star imports",
+        "undefined names"
+    ]
+    
     filtered_errors = []
     for err in reporter.errors:
         err_str = str(err)
-        # --- START: Updated Filtering Logic ---
-        # We now ignore BOTH types of star import warnings.
-        is_star_import_warning = "may be undefined, or defined from star imports" in err_str
-        is_general_import_warning = "'undefined names' found" in err_str
-
-        if not is_star_import_warning and not is_general_import_warning:
+        # If the error message contains any of the substrings in our blocklist, we ignore it.
+        if not any(sub in err_str for sub in IGNORE_SUBSTRINGS):
             filtered_errors.append(err_str)
-        # --- END: Updated Filtering Logic ---
 
     if not filtered_errors:
-        return "" # No errors found
+        return "" # No real errors found
         
-    # Format the filtered error list into a user-friendly string
     error_report = "Static analysis found potential errors:\n"
     for err in filtered_errors:
-        # We now process the filtered list, not the original one.
-        match = re.search(r'scene\.py:(\d+):.*(undefined name.*)', str(err))
-        if match:
-            line_num = match.group(1)
-            error_msg = match.group(2)
-            error_report += f"- Line {line_num}: {error_msg}\n"
+        # Use a simpler, more robust formatting logic
+        parts = err.split(':', 2)
+        if len(parts) == 3:
+            try:
+                line_num = parts[1]
+                message = parts[2].strip()
+                error_report += f"- Line {line_num}: {message}\n"
+            except:
+                error_report += f"- {err}\n" # Fallback for unexpected format
         else:
-            # Add a catch-all for other potential errors like syntax errors
-            error_report += f"- {err}\n"
+            error_report += f"- {err}\n" # Fallback
             
     return error_report