Update main.py

main.py

@@ -8,9 +8,20 @@ import time
 import re
 import os
 from pathlib import Path
+from fastapi.middleware.cors import CORSMiddleware
 
+# Initialize FastAPI app (critical to name it 'app')
 app = FastAPI(title="Code Evaluation & Optimization API")
 
+# Required CORS configuration
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=["*"],
+    allow_credentials=True,
+    allow_methods=["*"],
+    allow_headers=["*"],
+)
+
 # --- Environment Setup ---
 CACHE_DIR = Path("/.cache/huggingface")
 CACHE_DIR.mkdir(parents=True, exist_ok=True)
@@ -30,37 +41,21 @@ try:
         device_map="auto",
         torch_dtype=torch.float16,
         cache_dir=str(CACHE_DIR)
-    )
 except Exception as e:
     raise RuntimeError(f"Failed to load model: {str(e)}")
 
-# --- Request Models ---
+# --- Request Model ---
 class CodeRequest(BaseModel):
     code: str
     language: str = "python"  # Default to Python
 
 # --- Helper Functions ---
-def detect_language(user_code: str) -> str:
-    """Detect programming language based on code patterns"""
-    patterns = {
-        "python": ["def ", "print(", "import "],
-        "java": ["public static void main", "System.out.println"],
-        "cpp": ["#include <iostream>", "cout <<"],
-        "javascript": ["function ", "console.log"]
-    }
-
-    for lang, keywords in patterns.items():
-        if any(keyword in user_code for keyword in keywords):
-            return lang
-    return "unknown"
-
 def evaluate_code(user_code: str, lang: str) -> dict:
     """Evaluate code for correctness, performance, and security"""
     start_time = time.time()
     file_ext = {"python": "py", "java": "java", "cpp": "cpp", "javascript": "js"}.get(lang, "txt")
     filename = f"temp_script.{file_ext}"
 
-    # Save user code to a temporary file
     with open(filename, "w") as f:
         f.write(user_code)
 
@@ -74,12 +69,11 @@ def evaluate_code(user_code: str, lang: str) -> dict:
     try:
         if lang in commands:
             result = subprocess.run(" ".join(commands[lang]), 
-                                  capture_output=True, 
-                                  text=True, 
-                                  timeout=5, 
-                                  shell=True)
+                                capture_output=True, 
+                                text=True, 
+                                timeout=5, 
+                                shell=True)
             exec_time = time.time() - start_time
-
             correctness = 1 if result.returncode == 0 else 0
             error_message = None if correctness else result.stderr.strip()
         else:
@@ -92,7 +86,6 @@ def evaluate_code(user_code: str, lang: str) -> dict:
     readability_score = 20 if len(user_code) < 200 else 10
     efficiency_score = 30 if exec_time < 1 else 10
     security_score = 20 if "eval(" not in user_code and "exec(" not in user_code else 0
-
     total_score = (correctness * 50) + readability_score + efficiency_score + security_score
 
     feedback = []
@@ -104,10 +97,8 @@ def evaluate_code(user_code: str, lang: str) -> dict:
 
     if efficiency_score < 30:
         feedback.append("⚡ Performance Issue: Code took longer to execute. Optimize loops or calculations.")
-
     if readability_score < 20:
         feedback.append("📖 Readability Issue: Code is lengthy. Break into smaller functions.")
-
     if security_score == 0:
         feedback.append("🔒 Security Risk: Avoid using eval() or exec().")
 
@@ -120,16 +111,14 @@ def evaluate_code(user_code: str, lang: str) -> dict:
     }
 
 def optimize_code_ai(user_code: str, lang: str) -> str:
-    """Generate optimized code using AI and formatting"""
+    """Generate optimized code using AI"""
     try:
-        # Basic formatting first
         if lang == "python":
             user_code = autopep8.fix_code(user_code)
             user_code = re.sub(r"eval\((.*)\)", r"int(\1)  # Removed eval for security", user_code)
             user_code = re.sub(r"/ 0", "/ 1  # Fixed division by zero", user_code)
         
-        # AI-powered optimization
-        prompt = f"Optimize this {lang} code for efficiency and security:\n```{lang}\n{user_code}\n```\nOptimized version:"
+        prompt = f"Optimize this {lang} code:\n```{lang}\n{user_code}\n```\nOptimized version:"
         inputs = tokenizer(prompt, return_tensors="pt").to(model.device)
         
         with torch.no_grad():
@@ -137,7 +126,6 @@ def optimize_code_ai(user_code: str, lang: str) -> str:
         
         optimized_code = tokenizer.decode(outputs[0], skip_special_tokens=True)
         
-        # Extract just the code block if LLM added explanation
         code_match = re.search(r'```(?:python)?\n(.*?)\n```', optimized_code, re.DOTALL)
         if code_match:
             optimized_code = code_match.group(1)
@@ -149,7 +137,6 @@ def optimize_code_ai(user_code: str, lang: str) -> str:
 # --- API Endpoints ---
 @app.post("/evaluate")
 async def evaluate_endpoint(request: CodeRequest):
-    """Evaluate code for correctness and quality"""
     try:
         result = evaluate_code(request.code, request.language)
         return {"status": "success", "result": result}
@@ -158,7 +145,6 @@ async def evaluate_endpoint(request: CodeRequest):
 
 @app.post("/optimize")
 async def optimize_endpoint(request: CodeRequest):
-    """Generate optimized version of the code"""
     try:
         optimized = optimize_code_ai(request.code, request.language)
         return {"status": "success", "optimized_code": optimized}
@@ -168,12 +154,15 @@ async def optimize_endpoint(request: CodeRequest):
 @app.get("/")
 def health_check():
     return {
-        "status": "Code Evaluation API is running!",
-        "model_loaded": MODEL_NAME,
-        "cache_dir": str(CACHE_DIR)
+        "status": "API is running",
+        "model": MODEL_NAME,
+        "endpoints": {
+            "evaluate": "POST /evaluate",
+            "optimize": "POST /optimize"
+        }
     }
 
-# For local testing
+# Required for Hugging Face Spaces
 if __name__ == "__main__":
     import uvicorn
-    uvicorn.run(app, host="0.0.0.0", port=7860)
+    uvicorn.run("main:app", host="0.0.0.0", port=7860)