Update app.py

app.py

@@ -10,7 +10,7 @@ import subprocess
 
 load_dotenv()
 
-# Set API keys HF secrets
+# Set API keys from environment (HF Spaces Secrets or .env)
 os.environ['OPENAI_API_KEY'] = os.environ.get('OPENAI_API_KEY')
 os.environ['ANTHROPIC_API_KEY'] = os.environ.get('ANTHROPIC_API_KEY')
 deepseek_api_key = os.environ.get('DEEPSEEK_API_KEY')
@@ -25,43 +25,52 @@ DEEPSEEK_MODEL = 'deepseek-coder'
 
 system_message = (
     "You are an assistant that reimplements Python code in high performance C++ for an M1 Mac. "
-    "Respond only with C++ code; use comments sparingly and do not provide any explanation other than occasional comments. "
+    "Respond only with C++ code; use comments sparingly. "
     "The C++ response needs to produce an identical output in the fastest possible time."
 )
 
-def user_prompt_for(python):
+# Build prompt
+
+def user_prompt_for(python_code):
     return (
-        "Rewrite this Python code in C++ with the fastest possible implementation that produces identical output in the least time. "
-        "Respond only with C++ code; do not explain your work other than a few comments. "
-        "Pay attention to number types to ensure no int overflows. Remember to #include all necessary C++ packages such as iomanip.\n\n"
-        + python
+        "Rewrite this Python code in C++ with the fastest possible implementation that produces identical output. "
+        "Respond only with C++ code; do not explain your work other than minimal comments. "
+        "Pay attention to number types to prevent overflow and #include all necessary headers.\n\n" + python_code
     )
 
-def messages_for(python):
+def messages_for(python_code):
     return [
         {"role": "system", "content": system_message},
-        {"role": "user", "content": user_prompt_for(python)}
+        {"role": "user", "content": user_prompt_for(python_code)}
     ]
 
-def write_output(cpp):
-    code = cpp.replace("```cpp", "").replace("```", "")
+# Write C++ code to disk
+def write_output(cpp_code):
+    code = cpp_code.replace("```cpp", "").replace("```", "")
     with open("optimized.cpp", "w") as f:
         f.write(code)
 
-def stream_gpt(python):
-    stream = openai.chat.completions.create(model=OPENAI_MODEL, messages=messages_for(python), stream=True)
+# Streaming from models
+
+def stream_gpt(python_code):    
+    stream = openai.chat.completions.create(
+        model=OPENAI_MODEL,
+        messages=messages_for(python_code),
+        stream=True
+    )
     reply = ""
     for chunk in stream:
         fragment = chunk.choices[0].delta.content or ""
         reply += fragment
         yield reply.replace('```cpp\n', '').replace('```', '')
 
-def stream_claude(python):
+
+def stream_claude(python_code):
     result = claude.messages.stream(
         model=CLAUDE_MODEL,
         max_tokens=2000,
         system=system_message,
-        messages=[{"role": "user", "content": user_prompt_for(python)}],
+        messages=[{"role": "user", "content": user_prompt_for(python_code)}],
     )
     reply = ""
     with result as stream:
@@ -69,10 +78,11 @@ def stream_claude(python):
             reply += text
             yield reply.replace('```cpp\n', '').replace('```', '')
 
-def stream_deepseek(python):
+
+def stream_deepseek(python_code):
     stream = deepseek.chat.completions.create(
         model=DEEPSEEK_MODEL,
-        messages=messages_for(python),
+        messages=messages_for(python_code),
         stream=True
     )
     reply = ""
@@ -81,47 +91,72 @@ def stream_deepseek(python):
         reply += fragment
         yield reply.replace('```cpp\n', '').replace('```', '')
 
-def optimize(python, model):
+# Main dispatcher
+def optimize(python_code, model):
     if model == "GPT":
-        result = stream_gpt(python)
+        generator = stream_gpt(python_code)
     elif model == "Claude":
-        result = stream_claude(python)
+        generator = stream_claude(python_code)
     elif model == "DeepSeek":
-        result = stream_deepseek(python)
+        generator = stream_deepseek(python_code)
     else:
-        raise ValueError("Unknown model")
-    for stream_so_far in result:
-        yield stream_so_far
+        raise ValueError(f"Unknown model: {model}")
+    for chunk in generator:
+        yield chunk
 
+# Safe Python execution
 def execute_python(code):
+    output = io.StringIO()
+    sys_stdout = sys.stdout
     try:
-        output = io.StringIO()
         sys.stdout = output
         local_scope = {}
         exec(code, local_scope, local_scope)
     except Exception as e:
         return f"Python error:\n{e}"
     finally:
-        sys.stdout = sys.__stdout__
+        sys.stdout = sys_stdout
     return output.getvalue()
 
+# Improved C++ compile/run with full error capture
 def execute_cpp(code):
     write_output(code)
+    # Compile
+    compile_cmd = ["g++", "-Ofast", "-std=c++17", "-o", "optimized", "optimized.cpp"]
     try:
-        compile_cmd = ["g++", "-Ofast", "-std=c++17", "-o", "optimized", "optimized.cpp"]
-        subprocess.run(compile_cmd, check=True, text=True, capture_output=True)
-        run_cmd = ["./optimized"]
-        run_result = subprocess.run(run_cmd, check=True, text=True, capture_output=True)
+        compile_result = subprocess.run(
+            compile_cmd,
+            text=True,
+            capture_output=True,
+            check=False
+        )
+        if compile_result.returncode != 0:
+            return f"C++ compilation failed:\n{compile_result.stderr}"
+    except Exception as e:
+        return f"C++ compile error:\n{e}"
+
+    # Run
+    run_cmd = ["./optimized"]
+    try:
+        run_result = subprocess.run(
+            run_cmd,
+            text=True,
+            capture_output=True,
+            check=False
+        )
+        if run_result.returncode != 0:
+            return f"C++ runtime error (code {run_result.returncode}):\n{run_result.stderr}"
         return run_result.stdout
-    except subprocess.CalledProcessError as e:
-        return f"C++ error:\n{e.stderr}"
+    except Exception as e:
+        return f"C++ execution exception:\n{e}"
 
+# UI setup
 css = """
 .python {background-color: #306998;}
 .cpp {background-color: #050;}
 """
 
-example_code =  """
+example_code = """
 import time
 
 def calculate(iterations, param1, param2):
@@ -142,7 +177,7 @@ print(f"Execution Time: {(end_time - start_time):.6f} seconds")
 """
 
 with gr.Blocks(css=css) as ui:
-    gr.Markdown("## 🔁 Python To C++ Converter")
+    gr.Markdown("## 🔁 Python to High Performance C++ Converter")
     with gr.Row():
         python = gr.Textbox(label="Python code:", value=example_code, lines=12)
         cpp = gr.Textbox(label="C++ code:", lines=12)