Added multi language support

utils.py

@@ -1,12 +1,15 @@
 import sys
+import os
+import subprocess
 from io import StringIO
 import contextlib
-import json
+import tempfile
 from datetime import datetime
+from typing import Tuple
 
 @contextlib.contextmanager
 def capture_output():
-    """Capture stdout and stderr"""
+    """Capture stdout and stderr for Python code"""
     stdout, stderr = StringIO(), StringIO()
     old_out, old_err = sys.stdout, sys.stderr
     try:
@@ -15,32 +18,130 @@ def capture_output():
     finally:
         sys.stdout, sys.stderr = old_out, old_err
 
-def execute_code(code: str, stdin: str = "") -> tuple:
+def execute_code(code: str, stdin: str = "", language: str = "python") -> Tuple[str, str, str]:
     """
-    Execute the provided code and return stdout, stderr and any exceptions
+    Execute code in the specified language and return (stdout, stderr, exception)
+    
+    Currently supports: python (default). Other languages scaffolded.
     """
+    try:
+        if language == "python":
+            return _execute_python(code, stdin)
+
+        elif language == "c":
+            return _execute_c(code, stdin)
+
+        elif language == "cpp":
+            return _execute_cpp(code, stdin)
+
+        elif language == "java":
+            return _execute_java(code, stdin)
+
+        elif language == "js":
+            return _execute_javascript(code, stdin)
+
+        elif language == "csharp":
+            return _execute_csharp(code, stdin)
+
+        else:
+            return "", f"Unsupported language: {language}", None
+
+    except Exception as e:
+        return "", "", str(e)
+
+
+def _execute_python(code: str, stdin: str) -> Tuple[str, str, str]:
     with capture_output() as (stdout, stderr):
         try:
-            # Create a generator for stdin lines
             inputs = iter(stdin.splitlines())
-
-            # Proper lambda that accepts optional prompt
             input_override = lambda prompt='': next(inputs, '')
-
             local_vars = {"input": input_override}
             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)
 
+
+def _run_subprocess(cmd, stdin_input=None) -> Tuple[str, str, str]:
+    try:
+        result = subprocess.run(
+            cmd,
+            input=stdin_input.encode() if stdin_input else None,
+            stdout=subprocess.PIPE,
+            stderr=subprocess.PIPE,
+            timeout=10
+        )
+        return result.stdout.decode(), result.stderr.decode(), None
+    except Exception as e:
+        return "", "", str(e)
+
+
+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)
+
+
+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)
+
+
+def _execute_java(code: str, stdin: str):
+    with tempfile.TemporaryDirectory() as tmp:
+        class_name = "Main"
+        source_path = os.path.join(tmp, f"{class_name}.java")
+        with open(source_path, "w") as f:
+            f.write(code)
+        compile_cmd = ["javac", source_path]
+        compile_out, compile_err, exc = _run_subprocess(compile_cmd)
+        if exc or compile_err:
+            return compile_out, compile_err, exc
+        return _run_subprocess(["java", "-cp", tmp, class_name], stdin)
+
+
+def _execute_javascript(code: str, stdin: str):
+    with tempfile.NamedTemporaryFile(suffix=".js", delete=False, mode="w") as f:
+        f.write(code)
+        temp_path = f.name
+    try:
+        return _run_subprocess(["node", temp_path], stdin)
+    finally:
+        os.remove(temp_path)
+
+
+def _execute_csharp(code: str, stdin: str):
+    with tempfile.TemporaryDirectory() as tmp:
+        source_path = os.path.join(tmp, "main.cs")
+        binary_path = os.path.join(tmp, "main.exe")
+        with open(source_path, "w") as f:
+            f.write(code)
+        compile_cmd = ["mcs", source_path, "-out:" + 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(["mono", binary_path], stdin)
+
+
 def export_session(code: str, output: str, error: str) -> dict:
-    """
-    Create an exportable session object
-    """
     return {
         "timestamp": datetime.now().isoformat(),
         "code": code,
         "output": output,
         "error": error
-    }
+    }