Update app.py

app.py

@@ -5,7 +5,9 @@ import tempfile
 import re
 import ast
 import gradio as gr
-from openai import OpenAI
+import openai
+import requests
+import json
 
 # Extract code blocks from text
 def extract_code_blocks(text):
@@ -54,40 +56,50 @@ def validate_gradio_code(code):
     except Exception as e:
         return False, f"Error validating code: {str(e)}"
 
-# Global variables for app storage
-generated_app = None
-current_code = ""
-
-# Generate app using OpenAI
+# Generate app using direct API call
 def generate_gradio_app(api_key, prompt):
     if not api_key or len(api_key) < 20:
         return None, "Please provide a valid OpenAI API key"
     
     try:
-        client = OpenAI(api_key=api_key)
+        headers = {
+            "Content-Type": "application/json",
+            "Authorization": f"Bearer {api_key}"
+        }
         
-        response = client.chat.completions.create(
-            model="gpt-4o",
-            messages=[
+        data = {
+            "model": "gpt-4o",
+            "messages": [
                 {"role": "system", "content": """You are an expert Gradio developer. 
                 Create a standalone Gradio application based on the user's prompt.
                 Your response should ONLY include Python code without any explanation.
                 The code must:
                 1. Import all necessary libraries
                 2. Define a complete, functional Gradio interface
-                3. Launch the interface with share=False
-                4. Handle errors gracefully
-                5. Be completely self-contained in a single script
-                6. End with a simple if __name__ == "__main__": block that launches the app
+                3. DO NOT include a launch command or if __name__ == "__main__" block
+                4. The interface should be assigned to a variable named 'demo'
+                5. Handle errors gracefully
+                6. Be completely self-contained in a single script
                 """
                 },
                 {"role": "user", "content": prompt}
             ],
-            temperature=0.2,
-            max_tokens=4000
+            "temperature": 0.2,
+            "max_tokens": 4000
+        }
+        
+        response = requests.post(
+            "https://api.openai.com/v1/chat/completions",
+            headers=headers,
+            json=data
         )
         
-        generated_code = response.choices[0].message.content
+        if response.status_code != 200:
+            return None, f"API Error: {response.status_code} - {response.text}"
+        
+        result = response.json()
+        generated_code = result["choices"][0]["message"]["content"]
+        
         code_blocks = extract_code_blocks(generated_code)
         
         if code_blocks:
@@ -98,60 +110,13 @@ def generate_gradio_app(api_key, prompt):
     except Exception as e:
         return None, str(e)
 
-# Load and run generated app
-def load_and_run_gradio_app(code):
-    global generated_app, current_code
-    
-    # Validate code
-    is_valid, error_msg = validate_gradio_code(code)
-    if not is_valid:
-        return None, error_msg
-    
-    # Clean up previous app
-    if generated_app:
-        try:
-            generated_app.close()
-        except:
-            pass
-    
-    # Save code to temp file
-    with tempfile.NamedTemporaryFile(suffix='.py', delete=False) as f:
-        f.write(code.encode('utf-8'))
-        temp_file = f.name
-    
-    try:
-        # Import module
-        module_name = os.path.basename(temp_file).replace('.py', '')
-        spec = importlib.util.spec_from_file_location(module_name, temp_file)
-        module = importlib.util.module_from_spec(spec)
-        sys.modules[module_name] = module
-        spec.loader.exec_module(module)
-        
-        # Find Gradio interface
-        for attr_name in dir(module):
-            attr = getattr(module, attr_name)
-            if isinstance(attr, (gr.Blocks, gr.Interface)):
-                generated_app = attr
-                current_code = code
-                return attr, None
-        
-        return None, "No Gradio interface found in the generated code"
-        
-    except Exception as e:
-        return None, f"Error executing the generated code: {str(e)}"
-    finally:
-        try:
-            os.unlink(temp_file)
-        except:
-            pass
-
 # Create the main UI
 with gr.Blocks(title="AI Gradio App Generator") as demo:
     gr.Markdown("# 🤖 AI Gradio App Generator")
     gr.Markdown("Describe the app you want, and I'll generate it for you using OpenAI's API.")
     
     with gr.Row():
-        with gr.Column(scale=2):
+        with gr.Column():
             api_key = gr.Textbox(
                 label="OpenAI API Key", 
                 placeholder="sk-...",
@@ -173,42 +138,69 @@ with gr.Blocks(title="AI Gradio App Generator") as demo:
                 code_output = gr.Code(language="python", label="Generated Code")
             
             status_output = gr.Markdown("")
-        
-        with gr.Column(scale=3):
-            app_container = gr.HTML("<div style='text-align: center; padding: 50px;'><h3>Your generated app will appear here</h3></div>")
+    
+    app_container = gr.HTML(visible=False)
+    generated_app_container = gr.Group(visible=False)
     
     def on_submit(api_key_input, prompt_text):
         # Generate code
         code, error = generate_gradio_app(api_key_input, prompt_text)
         if error:
-            return None, f"⚠️ Error generating code: {error}", "<div style='text-align: center; padding: 50px;'><h3>Error generating app</h3></div>"
+            return None, f"⚠️ Error generating code: {error}", gr.update(visible=False), gr.update(visible=False)
+        
+        # Validate code
+        is_valid, error_msg = validate_gradio_code(code)
+        if not is_valid:
+            return code, f"⚠️ Error validating code: {error_msg}", gr.update(visible=False), gr.update(visible=False)
         
-        # Load and run app
-        app, run_error = load_and_run_gradio_app(code)
-        if run_error:
-            return code, f"⚠️ Error running the generated app: {run_error}", "<div style='text-align: center; padding: 50px;'><h3>Error running app</h3></div>"
+        # Save code to temp file
+        with tempfile.NamedTemporaryFile(suffix='.py', delete=False) as f:
+            f.write(code.encode('utf-8'))
+            temp_file = f.name
         
-        # Create iframe to display app
-        iframe_html = f'''
-        <div style="border: 1px solid #ddd; border-radius: 8px; padding: 0; overflow: hidden;">
-            <iframe id="appFrame" src="/generated_app" width="100%" height="800px" frameborder="0"></iframe>
-        </div>
-        '''
-        return code, "✅ App generated successfully!", iframe_html
+        try:
+            # Import module
+            module_name = os.path.basename(temp_file).replace('.py', '')
+            spec = importlib.util.spec_from_file_location(module_name, temp_file)
+            module = importlib.util.module_from_spec(spec)
+            sys.modules[module_name] = module
+            spec.loader.exec_module(module)
+            
+            # Get the Gradio interface
+            if hasattr(module, 'demo'):
+                generated_app = module.demo
+                
+                # Clear the container and add the new app
+                return (
+                    code, 
+                    "✅ App generated successfully!", 
+                    gr.update(visible=False),
+                    gr.update(visible=True, value=generated_app)
+                )
+            else:
+                return code, "⚠️ No 'demo' variable found in the generated code", gr.update(visible=False), gr.update(visible=False)
+                
+        except Exception as e:
+            return code, f"⚠️ Error executing the generated code: {str(e)}", gr.update(visible=False), gr.update(visible=False)
+        finally:
+            try:
+                os.unlink(temp_file)
+            except:
+                pass
     
     def on_clear():
-        return "", "", "<div style='text-align: center; padding: 50px;'><h3>Your generated app will appear here</h3></div>"
+        return "", "", gr.update(visible=False), gr.update(visible=False)
     
     submit_btn.click(
         on_submit,
         inputs=[api_key, prompt],
-        outputs=[code_output, status_output, app_container]
+        outputs=[code_output, status_output, app_container, generated_app_container]
     )
     
     clear_btn.click(
         on_clear,
         inputs=[],
-        outputs=[prompt, status_output, app_container]
+        outputs=[prompt, status_output, app_container, generated_app_container]
     )
 
 if __name__ == "__main__":