demo update

app.py

@@ -3,85 +3,74 @@ 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.
-    Args:
-        text: str, model prediciton text.
-    Rets:
-        code_pieces: list[str], code pieces in the text.
-    """
+    """Extract code pieces from a text string."""
     code_pieces = []
     while "```python" in text:
         st_idx = text.index("```python") + 10
-        # end_idx = text.index("```", st_idx)
         if "```" in text[st_idx:]:
             end_idx = text.index("```", st_idx)
-        else: 
+        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)
+    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."""
-
-# INSTRUCTION = """Follow the instruction below to create the slide. 
-# If the instruction is long and specific, follow the instruction carefully and add all elements as required; 
-# if it is short and concise, you will need to create some content (text, image, layout) and implement it into the slide.
-# {}
+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."""
 
-# Finally, your code should save the pptx file to path "{}"."""
+# Load the user instruction template
 with open('agent_no_image_new_lib.prompt', 'r') as f:
     INSTRUCTION = f.read()
 
-import glob
-import time
-import shutil
 def list_files_in_directory(directory):
     """Lists all files in the given directory."""
     return set(glob.glob(os.path.join(directory, "*")))
 
-def cleanup_temp_files(temp_files):
-    """Deletes a list of temporary files if they exist."""
-    for temp_file in temp_files:
-        try:
-            if os.path.exists(temp_file):
-                shutil.rmtree(temp_file)
-                os.remove(temp_file)
-                print(f"Deleted temporary file: {temp_file}")
-        except Exception as e:
-            print(f"Failed to delete {temp_file}: {e}")
+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")
 
-def create_pptx(api_key, instruction, model_name="gpt-4o", max_tokens=4096):
     try:
         # Set OpenAI API key
         openai.api_key = api_key
 
-        # Create OpenAI client
+        # Create an OpenAI client
         client = openai.OpenAI(api_key=api_key)
 
         # Prepare messages for the chat completion
         messages = [{"role": "system", "content": SYSTEM_MESSAGE}]
-        pptx_path = "output.pptx"
         instruction_message = INSTRUCTION.replace("INSERT_INSTRUCTION_HERE", instruction)
         messages.append({"role": "user", "content": instruction_message})
+
         # Capture the directory state before execution
-        working_directory = os.getcwd()
-        files_before = list_files_in_directory(working_directory)
-        # Retry up to 3 times
+        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:
-                # Call OpenAI's GPT model
                 response = client.chat.completions.create(
                     model=model_name,
                     messages=messages,
@@ -89,43 +78,36 @@ def create_pptx(api_key, instruction, model_name="gpt-4o", max_tokens=4096):
                     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
 
-                # Save the generated code
-                code_file = "generated_slide_code.py"
-                with open(code_file, "w") as f:
+                code_file = os.path.join(working_dir, "generated_slide_code.py")
+                with open(code_file, "w", encoding="utf-8") as f:
                     f.write(generated_code)
 
                 # Execute the generated code
-                result = subprocess.run(["python", code_file], capture_output=True, text=True, check=True)
+                result = subprocess.run(
+                    ["python", code_file],
+                    capture_output=True, 
+                    text=True, 
+                    check=True, 
+                    cwd=working_dir
+                )
                 print(result.stdout)
-                
-                # Capture the directory state after execution
-                files_after = list_files_in_directory(working_directory)
-                temp_files = files_after - files_before  # Identify newly created files
-
-                # Convert the pptx to jpg for preview
-                # preview_image = "image_previews/output.jpg"
-                # command = [
-                #     "libreoffice",
-                #     "--headless",
-                #     "--convert-to", "jpg",
-                #     "--outdir", "image_previews",
-                #     pptx_path
-                # ]
-                # subprocess.run(command)
-                # temp_files.add(preview_image) 
-
-                # If successful, return the result
+
+                # 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
-                # , preview_image
             except subprocess.CalledProcessError as e:
-                print(f"Attempt {attempt + 1} failed: {e.stderr}")
+                print(f"Attempt {attempt + 1} failed:\n{e.stderr}\n")
 
-        # Fallback: Use default code if all attempts fail
-        print("All 3 attempts failed. Running default code.")
+        # If all attempts fail, run default code
+        print("All attempts failed. Running default code.")
         default_code = f"""
 from pptx import Presentation
 
@@ -139,38 +121,48 @@ content.text = "{instruction}"
 
 ppt.save("output.pptx")
 """
-        code_file = "default_slide_code.py"
-        with open(code_file, "w") as f:
+        code_file = os.path.join(working_dir, "default_slide_code.py")
+        with open(code_file, "w", encoding="utf-8") as f:
             f.write(default_code)
-        
-        # Execute the default code
-        subprocess.run(["python", code_file], capture_output=True, text=True, check=True)
-
-        # Convert the pptx to jpg for preview
-        # preview_image = "image_previews/output.jpg"
-        # command = [
-        #     "libreoffice",
-        #     "--headless",
-        #     "--convert-to", "jpg",
-        #     "--outdir", "image_previews",
-        #     pptx_path
-        # ]
-        # subprocess.run(command)
+
+        subprocess.run(
+            ["python", code_file],
+            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:
-        # Cleanup temporary files
-        files_before.add("output.pptx")
-        temp_files = list_files_in_directory(working_directory) - files_before
-        cleanup_temp_files(temp_files)
+        # 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
 
-# Create a Gradio interface
 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)
-    return status, pptx_path
+    # Prepend the warning to the final status
+    return f"{warning_message}\n{status}", pptx_path
 
 iface = gr.Interface(
     fn=gradio_demo,
@@ -179,12 +171,16 @@ iface = gr.Interface(
         gr.Textbox(label="Instruction", placeholder="Enter your slide instruction here...")
     ],
     outputs=[
-        gr.Textbox(label="Status"),
+        gr.Textbox(label="Status", lines=5),
         gr.File(label="Download Slide"),
-        # gr.Image(label="Slide Preview", type="filepath")
     ],
     title="AutoPresent",
-    description="Automatically Generate a presentation slide"
+    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."
+    )
 )
 
-iface.launch()
+if __name__ == "__main__":
+    iface.launch()