app.py

import gradio as gr
import os
import openai
import subprocess
import base64
import shutil
import glob
import uuid
import time

def encode_image(image_path):
    with open(image_path, 'rb') as image_file:
        return base64.b64encode(image_file.read()).decode('utf-8')

def extract_code_pieces(text: str, concat: bool = True) -> list[str]:
    """Extract code pieces from a text string."""
    code_pieces = []
    while "```python" in text:
        st_idx = text.index("```python") + 10
        if "```" in text[st_idx:]:
            end_idx = text.index("```", st_idx)
        else:
            end_idx = len(text)
        code_pieces.append(text[st_idx:end_idx].strip())
        text = text[end_idx+3:].strip()
    if concat:
        return "\n\n".join(code_pieces)
    return code_pieces

SYSTEM_MESSAGE = """* You are an expert presentation slides designer who creates modern, fashionable, and stylish slides using Python code. Your job is to generate the required PPTX slide by writing and executing a Python script. Make sure to follow the guidelines below and do not skip any of them:
1.  Ensure your code can successfully execute. If needed, you can also write tests to verify your code.
2.  Maintain proper spacing and arrangements of elements in the slide: make sure to keep sufficient spacing between different elements; do not make elements overlap or overflow to the slide page.
3.  Carefully select the colors of text, shapes, and backgrounds, to ensure all contents are readable.
4.  The slides should not look empty or incomplete. When filling the content in the slides, maintain good design and layout."""

# Load the user instruction template
with open('agent_no_image_new_lib.prompt', 'r') as f:
    INSTRUCTION = f.read()

def list_files_in_directory(directory):
    """Lists all files in the given directory."""
    return set(glob.glob(os.path.join(directory, "*")))

def create_pptx(api_key, instruction, model_name="gpt-4o", max_tokens=4096):
    """
    Generates a PPTX from instructions using GPT, isolating all new files 
    in a unique directory so multiple requests don't conflict.
    """
    unique_id = str(uuid.uuid4())[:8]        # Short unique directory name
    working_dir = f"temp_work_{unique_id}"   # e.g. temp_work_3f2b1d4c
    os.makedirs(working_dir, exist_ok=True)

    # The name of the PPTX we intend to produce
    pptx_path = os.path.join(working_dir, "output.pptx")

    try:
        # Set OpenAI API key
        openai.api_key = api_key

        # Create an OpenAI client
        client = openai.OpenAI(api_key=api_key)

        # Prepare messages for the chat completion
        messages = [{"role": "system", "content": SYSTEM_MESSAGE}]
        instruction_message = INSTRUCTION.replace("INSERT_INSTRUCTION_HERE", instruction)
        messages.append({"role": "user", "content": instruction_message})

        # Capture the directory state before execution
        files_before = list_files_in_directory(working_dir)

        # Try up to 3 times to generate code and run it
        for attempt in range(3):
            try:
                response = client.chat.completions.create(
                    model=model_name,
                    messages=messages,
                    max_tokens=max_tokens,
                    n=1,
                )
                generated_code = extract_code_pieces(response.choices[0].message.content, concat=True)
                # Replace references to other library with local SlidesLib
                generated_code = generated_code.replace("from library import", "from SlidesLib import")
                generated_code = generated_code.replace("generate_image(", f"generate_image({repr(api_key)},")
                generated_code = "from SlidesLib import *\n\n" + generated_code

                code_filename = "generated_slide_code.py"  
                code_file_path = os.path.join(working_dir, code_filename)

                with open(code_file_path, "w", encoding="utf-8") as f:
                    f.write(generated_code)

                # >>> FIX: Pass only the filename to python, and specify cwd
                result = subprocess.run(
                    ["python", code_filename],  
                    capture_output=True,
                    text=True,
                    check=True,
                    cwd=working_dir
                )
                print(result.stdout)

                # Check for newly created files
                files_after = list_files_in_directory(working_dir)
                temp_files = files_after - files_before

                # If successful, return
                return "Slide generated successfully! Download your slide below.", pptx_path
            except subprocess.CalledProcessError as e:
                print(f"Attempt {attempt + 1} failed:\n{e.stderr}\n")

        # If all attempts fail, run default code
        print("All attempts failed. Running default code.")
        default_code = f"""
from pptx import Presentation

ppt = Presentation()
slide = ppt.slides.add_slide(ppt.slide_layouts[5])
title = slide.shapes.title
title.text = "Insert Title Here"

content = slide.placeholders[0]
content.text = "{instruction}"

ppt.save("output.pptx")
"""
        code_filename = "default_slide_code.py"
        code_file_path = os.path.join(working_dir, code_filename)

        with open(code_file_path, "w", encoding="utf-8") as f:
            f.write(default_code)

        subprocess.run(
            ["python", code_filename],
            capture_output=True, 
            text=True, 
            check=True,
            cwd=working_dir
        )

        return "Default slide generated after 3 attempts failed.", pptx_path

    except Exception as e:
        return f"An error occurred: {str(e)}", None

    finally:
        # We won't automatically delete the working_dir here if we want the user 
        # to be able to download the pptx. Otherwise, we could do cleanup.
        pass

def gradio_demo(api_key, instruction):
    """
    The Gradio demo function. It calls create_pptx, returns
    the status string, and the path to the PPTX file.
    """
    # 1) Important: Warn the user about key usage.
    if not api_key:
        return ("Warning: No OpenAI API key provided. Please provide a valid key "
                "to generate slides."), None
    else:
        # Additional caution about potential key leaks
        warning_message = (
            "Caution: Your OpenAI API key is used to generate the slide. "
            "Make sure you trust this environment, as keys can appear in logs. "
            "We recommend using a disposable or restricted-scope key if possible.\n"
        )

    status, pptx_path = create_pptx(api_key, instruction)
    # Prepend the warning to the final status
    return f"{warning_message}\n{status}", pptx_path

iface = gr.Interface(
    fn=gradio_demo,
    inputs=[
        gr.Textbox(label="OpenAI API Key", type="password"),
        gr.Textbox(label="Instruction", placeholder="Enter your slide instruction here...")
    ],
    outputs=[
        gr.Textbox(label="Status", lines=5),
        gr.File(label="Download Slide"),
    ],
    title="AutoPresent",
    description=(
        "Automatically Generate a presentation slide.\n\n"
        "**WARNING**: Please be cautious with your OpenAI API key. "
        "Logs or server code might store it temporarily. **We suggest one-time use.**"
    )
)

if __name__ == "__main__":
    iface.launch()