app.py

import os, io, sys, subprocess, shutil
from dotenv import load_dotenv
from openai import OpenAI
from google import genai
from google.genai import types
import gradio as gr
from datetime import datetime
from placeholder_python_code import pi_1, pi_2
from css_elements import css_elements

### Environment
load_dotenv(".env")
OPENAI_API_KEY = os.getenv("OPENAI_API_KEY")
ANTHROPIC_API_KEY = os.getenv("ANTHROPIC_API_KEY")
GEMINI_API_KEY = os.getenv("GEMINI_API_KEY")

### Initialize
openai_client = OpenAI(api_key=OPENAI_API_KEY)
gemini_client = genai.Client(api_key=GEMINI_API_KEY)
OPENAI_MODEL = "gpt-5-mini-2025-08-07"
GEMINI_MODEL = "gemini-1.5-flash"


def system_message_for_python() -> str:
    system_message = """
        You are an assistant that reimplements Python code in high performance C++
        for an M1 Mac.
    """.strip()

    system_message += """
        Respond only with C++; use comments sparingly and do not provide any
        explanation other than occasion comments.
    """.strip()

    system_message += """
        The C++ response needs to produce an identical output in the 
        fastest possible time. 
    """.strip()

    return system_message

current_time = datetime.now().strftime("%Y%m%d_%H:%M:%S")

def user_prompt_for_python(python_code):
    user_prompt = """
        Rewrite this Python code in C++ with the fastest possible implementation
        that produces identical output in the least time.
    """.strip()
    user_prompt += """
        Respond only with C++ code; do not explain your work other than the real code. 
        And also do not include ```cpp and as such. But just working code only!
    """.strip()
    user_prompt += """
        Pay attention to number types to ensure no int overflows. Remember to #include 
        all necessary C++ packages such as iomanip.\n\n
    """.strip()
    user_prompt += python_code

    return user_prompt

def messages_for_python(python):
    return [
        {"role": "system", "content": system_message_for_python()},
        {"role": "user", "content": user_prompt_for_python(python)}
    ]

### remove ```cpp and ```
### cpp is a file extension of C++ code
def write_output(cpp: str):
    code = cpp.replace("```cpp", "").replace("```", "")
    with open(f"/tmp/optimized-{current_time}.cpp", "w") as f:
        f.write(code)

def convert_and_optimize_code_with_openai(python: str):
    stream = openai_client.chat.completions.create(
        model=OPENAI_MODEL,
        messages=messages_for_python(python),
        stream=True
    )
    stream_response = ""
    for chunk in stream:
        fragment = chunk.choices[0].delta.content or ""
        stream_response += fragment
        # print(fragment, end="", flush=True)

        yield fragment

def convert_and_optimize_code_with_gemini(python: str):
    user_prompt = user_prompt_for_python(python)

    stream = gemini_client.models.generate_content_stream(
        model=GEMINI_MODEL,
        contents=user_prompt,
        config=types.GenerateContentConfig(
            system_instruction=system_message_for_python()
        ),
    )

    for chunk in stream:
        stream_response = getattr(chunk, "text", "")
        if stream_response:
            yield stream_response

    ### OR THIS -- Gemini model returns an object other than string. So it needs to retrieve the text
    # for chunk in stream:
    #     if chunk.text:
    #         yield chunk.text


# convert_and_optimize_code_with_openai(pi_1)


###============================= GRADIO UI ================================###

def stream_text_on_ui(model, pi):
    """
    :param model: The selected LLM model used for converting Python code to C++
    :param pi: Input Python code string
    :yield response: Each chunk of stream data(generated text) received from LLM call
    """
    response = ""
    if model == "GPT-5":
        stream_res = convert_and_optimize_code_with_openai(pi)
    elif model == "Gemini":
        stream_res = convert_and_optimize_code_with_gemini(pi)
    else:
        raise ValueError("Unknown model...")
    ### another loop to take in the streaming chunk
    for chunk in stream_res:
        response += chunk
        response = response.replace("```cpp", "").replace("```", "").replace("cpp", "")
        yield response

def run_python_code(code: str):
    output = io.StringIO()
    old_stdout = sys.stdout
    try:
        sys.stdout = output
        ### For proper ISOLATION: use a fresh globals __main__ dict
        exec(code, {"__name__": "__main__"})
        return output.getvalue()
    except Exception as e:
        return output.getvalue() + f"-- {e}"
    finally:
        sys.stdout = old_stdout

### subprocess used to connect to the external programs (g++ for c++ build and compile)
def run_cpp_code(code: str):
    write_output(code)
    try:
        compiler = shutil.which("clang++") or shutil.which("g++")
        if not compiler:
            return "Error: No C++ compiler found in container."
            
        ### 1. Compile the code
        compile_cmd = [
            compiler, "-O3", "-ffast-math", "-std=c++17",
             "-o", "/tmp/optimized",
            f"/tmp/optimized-{current_time}.cpp"
        ]
        subprocess.run(
            compile_cmd, check=True, text=True, capture_output=True
        )

        ### 2. Run the code
        run_cmd = [f"/tmp/optimized"]
        run_result = subprocess.run(
            run_cmd, check=True, text=True, capture_output=True
        )
        return run_result.stdout
    except subprocess.CalledProcessError as e:
        return f"An error occurred:\n{e.stderr}"


with gr.Blocks(
    css=css_elements,
    title="Python To C++ Code Convertor"
) as ui:
    with gr.Row():
        pi_textbox = gr.Textbox(label="Place Python Code Here:", lines=20, value=pi_1)
        cpp_output = gr.Textbox(label="C++ Code Converted:", lines=20)

    with gr.Row():
        model_selection = gr.Dropdown(
            choices=["GPT-5", "Gemini"],
            label="Select Model",
            value="GPT-5",
            interactive=True
        )

    with gr.Row():
        convert_btn = gr.Button(value="Convert", size="lg")

    with gr.Row():
        run_py_btn = gr.Button(value="Run Python")
        run_cpp_btn = gr.Button(value="Run C++")

    with gr.Row():
        python_out = gr.TextArea(label="Python Result:", elem_classes=["python"])
        cpp_out = gr.TextArea(label="C++ Result:", elem_classes=["cpp"])

    convert_btn.click(
        fn=stream_text_on_ui,
        inputs=[model_selection, pi_textbox],
        outputs=cpp_output
    )

    run_py_btn.click(
        fn=run_python_code,
        inputs=pi_textbox,
        outputs=python_out
    )
    run_cpp_btn.click(
        fn=run_cpp_code,
        inputs=cpp_output,
        outputs=cpp_out
    )


port = int(os.getenv("PORT", 7860))
ui.launch(server_name="0.0.0.0", server_port=port)