Updating

utils.py

@@ -1,17 +1,17 @@
+import os
 import sys
 import random
-import os
-import subprocess
-from io import StringIO
-import contextlib
 import tempfile
+import subprocess
 import requests
+from io import StringIO
 from datetime import datetime
 from typing import Tuple
+import contextlib
 
+# --- Utility context manager to capture stdout/stderr (for Python execution) ---
 @contextlib.contextmanager
 def capture_output():
-    """Capture stdout and stderr for Python code"""
     stdout, stderr = StringIO(), StringIO()
     old_out, old_err = sys.stdout, sys.stderr
     try:
@@ -20,64 +20,7 @@ def capture_output():
     finally:
         sys.stdout, sys.stderr = old_out, old_err
 
-def _execute_with_onecompiler(code: str, stdin: str, language: str, filename: str) -> Tuple[str, str, str]:
-    keys = [os.environ["ONECOMPILER_API_KEY"], os.environ["ONECOMPILER_API_KEY1"]]
-    first_key = random.choice(keys)
-
-    result = _call_onecompiler_api(first_key, code, stdin, language, filename)
-    
-    if _is_quota_or_invalid(result):
-        # Fallback: try all keys one-by-one until one works
-        for key in keys:
-            if key == first_key:
-                continue  # Already tried this one
-            result = _call_onecompiler_api(key, code, stdin, language, filename)
-            if not _is_quota_or_invalid(result):
-                return result
-    
-    return result  # Either success, or last failed response
-
-
-def _call_onecompiler_api(key: str, code: str, stdin: str, language: str, filename: str) -> Tuple[str, str, str]:
-    url = "https://onecompiler-apis.p.rapidapi.com/api/v1/run"
-    headers = {
-        "Content-Type": "application/json",
-        "x-rapidapi-host": "onecompiler-apis.p.rapidapi.com",
-        "x-rapidapi-key": key
-    }
-    payload = {
-        "language": language.lower(),
-        "stdin": stdin,
-        "files": [
-            {
-                "name": filename,
-                "content": code
-            }
-        ]
-    }
-
-    try:
-        response = requests.post(url, json=payload, headers=headers, timeout=10)
-        data = response.json()
-
-        if data.get("status") == "failed":
-            return "", "", f"OneCompiler Error: {data.get('error')}"
-        
-        return (
-            data.get("stdout", "").strip(),
-            data.get("stderr", "") or "",
-            data.get("exception", "")
-        )
-    except Exception as e:
-        return "", "", str(e)
-
-
-def _is_quota_or_invalid(result: Tuple[str, str, str]) -> bool:
-    _, _, error = result
-    if not error:
-        return False
-    return any(token in error.lower() for token in ["quota", "e002", "e003", "invalid", "exhausted"])
-
+# --- Public API to execute code ---
 def execute_code(code: str, stdin: str = "", language: str = "cpp") -> Tuple[str, str, str]:
     try:
         if language == "Python":
@@ -97,19 +40,43 @@ def execute_code(code: str, stdin: str = "", language: str = "cpp") -> Tuple[str
     except Exception as e:
         return "", "", str(e)
 
-
+# --- Python Execution ---
 def _execute_python(code: str, stdin: str) -> Tuple[str, str, str]:
     with capture_output() as (stdout, stderr):
         try:
             inputs = iter(stdin.splitlines())
-            input_override = lambda prompt='': next(inputs, '')
-            local_vars = {"input": input_override}
+            local_vars = {"input": lambda _: next(inputs, "")}
             exec(code, {}, local_vars)
             return stdout.getvalue().strip(), stderr.getvalue().strip(), None
         except Exception as e:
             return stdout.getvalue().strip(), stderr.getvalue().strip(), str(e)
 
+# --- C Execution ---
+def _execute_c(code: str, stdin: str):
+    return _compile_and_run(code, stdin, ext="c", compiler="gcc")
 
+# --- C++ Execution ---
+def _execute_cpp(code: str, stdin: str):
+    return _compile_and_run(code, stdin, ext="cpp", compiler="g++")
+
+# --- Compilation helper ---
+def _compile_and_run(code: str, stdin: str, ext: str, compiler: str):
+    with tempfile.TemporaryDirectory() as tmp:
+        source = os.path.join(tmp, f"main.{ext}")
+        binary = os.path.join(tmp, "main.out")
+
+        with open(source, "w") as f:
+            f.write(code)
+
+        compile_cmd = [compiler, source, "-o", binary]
+        comp_out, comp_err, comp_exc = _run_subprocess(compile_cmd)
+
+        if comp_exc or comp_err:
+            return comp_out, comp_err, comp_exc
+
+        return _run_subprocess([binary], stdin)
+
+# --- Run subprocess and capture output ---
 def _run_subprocess(cmd, stdin_input=None) -> Tuple[str, str, str]:
     try:
         result = subprocess.run(
@@ -123,33 +90,59 @@ def _run_subprocess(cmd, stdin_input=None) -> Tuple[str, str, str]:
     except Exception as e:
         return "", "", str(e)
 
+# --- Java, JS, C# via OneCompiler API ---
+def _execute_with_onecompiler(code: str, stdin: str, language: str, filename: str) -> Tuple[str, str, str]:
+    keys = [os.environ["ONECOMPILER_API_KEY"], os.environ["ONECOMPILER_API_KEY1"]]
+    primary_key = random.choice(keys)
 
-def _execute_c(code: str, stdin: str):
-    with tempfile.TemporaryDirectory() as tmp:
-        source_path = os.path.join(tmp, "main.c")
-        binary_path = os.path.join(tmp, "main.out")
-        with open(source_path, "w") as f:
-            f.write(code)
-        compile_cmd = ["gcc", source_path, "-o", binary_path]
-        compile_out, compile_err, exc = _run_subprocess(compile_cmd)
-        if exc or compile_err:
-            return compile_out, compile_err, exc
-        return _run_subprocess([binary_path], stdin)
+    result = _call_onecompiler_api(primary_key, code, stdin, language, filename)
 
+    if _is_quota_or_invalid(result):
+        for key in keys:
+            if key == primary_key:
+                continue
+            result = _call_onecompiler_api(key, code, stdin, language, filename)
+            if not _is_quota_or_invalid(result):
+                break
 
-def _execute_cpp(code: str, stdin: str):
-    with tempfile.TemporaryDirectory() as tmp:
-        source_path = os.path.join(tmp, "main.cpp")
-        binary_path = os.path.join(tmp, "main.out")
-        with open(source_path, "w") as f:
-            f.write(code)
-        compile_cmd = ["g++", source_path, "-o", binary_path]
-        compile_out, compile_err, exc = _run_subprocess(compile_cmd)
-        if exc or compile_err:
-            return compile_out, compile_err, exc
-        return _run_subprocess([binary_path], stdin)
+    return result
+
+def _call_onecompiler_api(key: str, code: str, stdin: str, language: str, filename: str) -> Tuple[str, str, str]:
+    url = "https://onecompiler-apis.p.rapidapi.com/api/v1/run"
+    headers = {
+        "Content-Type": "application/json",
+        "x-rapidapi-host": "onecompiler-apis.p.rapidapi.com",
+        "x-rapidapi-key": key,
+    }
+    payload = {
+        "language": language.lower(),
+        "stdin": stdin,
+        "files": [{"name": filename, "content": code}]
+    }
+
+    try:
+        response = requests.post(url, json=payload, headers=headers, timeout=10)
+        data = response.json()
+
+        if data.get("status") == "failed":
+            return "", "", f"OneCompiler Error: {data.get('error')}"
 
+        return (
+            data.get("stdout", "").strip(),
+            data.get("stderr", "") or "",
+            data.get("exception", "")
+        )
+    except Exception as e:
+        return "", "", str(e)
+
+def _is_quota_or_invalid(result: Tuple[str, str, str]) -> bool:
+    _, _, error = result
+    if not error:
+        return False
+    error = error.lower()
+    return any(term in error for term in ["quota", "e002", "e003", "invalid", "exhausted"])
 
+# --- Export utility ---
 def export_session(code: str, output: str, error: str) -> dict:
     return {
         "timestamp": datetime.now().isoformat(),