Update app.py

app.py

@@ -1,17 +1,60 @@
 import gradio as gr
-import io
+import pickle
 import sys
+import io
 import matplotlib.pyplot as plt
 from PIL import Image
 
-# Function to execute code and capture output
+# File persistence functions
+def save_files(files):
+    """Save the files dictionary to a pickle file."""
+    with open('files.pkl', 'wb') as f:
+        pickle.dump(files, f)
+
+def load_files():
+    """Load the files dictionary from a pickle file or return a default state."""
+    try:
+        with open('files.pkl', 'rb') as f:
+            return pickle.load(f)
+    except FileNotFoundError:
+        return {"main.py": "# Write your code here\nprint('Hello, World!')"}
+
+# File management functions
+def add_file(files):
+    """Add a new file to the files dictionary."""
+    new_file_name = f"file_{len(files)}.py"
+    files[new_file_name] = "# New file"
+    save_files(files)
+    return files, list(files.keys()), new_file_name
+
+def delete_file(file_name, files):
+    """Delete a file from the files dictionary if more than one file exists."""
+    if len(files) > 1:
+        del files[file_name]
+        save_files(files)
+        new_file_name = list(files.keys())[0]
+        return files, list(files.keys()), new_file_name, files[new_file_name]
+    return files, list(files.keys()), file_name, files[file_name]
+
+def update_code(code, file_name, files):
+    """Update the code for a specific file and save the files state."""
+    files[file_name] = code
+    save_files(files)
+    return files
+
+def select_file(file_name, files):
+    """Return the code for the selected file."""
+    return files[file_name]
+
+# Code execution and command functions
 def run_code(code, namespace):
+    """Execute the code, capture output and plots, and display variables."""
     output = io.StringIO()
     sys.stdout = output
     images = []
     try:
         exec(code, namespace)
-        # Capture any matplotlib plots
+        # Capture matplotlib plots
         figs = [plt.figure(i) for i in plt.get_fignums()]
         for fig in figs:
             buf = io.BytesIO()
@@ -20,66 +63,120 @@ def run_code(code, namespace):
             img = Image.open(buf)
             images.append(img)
         plt.close('all')
+        # Get user-defined variables
+        variables = {k: v for k, v in namespace.items() 
+                     if not k.startswith('_') and not callable(v) and not isinstance(v, type(sys))}
+        variables_str = "\nVariables:\n" + "\n".join(f"{k} = {v}" for k, v in variables.items()) if variables else ""
     except Exception as e:
         print(f"Error: {e}")
+        variables_str = ""
     sys.stdout = sys.__stdout__
-    return output.getvalue(), images, namespace
+    return output.getvalue() + variables_str, images, namespace
 
-# Function to load code for the selected file
-def select_file(file_name, files):
-    return files[file_name]
+def run_command(command, namespace, terminal_display):
+    """Execute a single command and append its output to the terminal display."""
+    output = io.StringIO()
+    sys.stdout = output
+    try:
+        exec(command, namespace)
+    except Exception as e:
+        print(f"Error: {e}")
+    sys.stdout = sys.__stdout__
+    command_output = output.getvalue()
+    return (terminal_display + "\n" + command_output).strip()
 
-# Function to update the files state when code is edited
-def update_code(code, file_name, files):
-    files[file_name] = code
-    return files
+# Gradio interface
+with gr.Blocks(title="Python Code Editor") as demo:
+    # Initial states
+    files = gr.State(value=load_files)
+    namespace = gr.State(value={})
 
-# Function to add a new file
-def add_file(files):
-    new_file_name = f"file_{len(files)}.py"
-    files[new_file_name] = "# New file"
-    return files, list(files.keys()), new_file_name
+    # Layout
+    with gr.Row():
+        # Sidebar for file management
+        with gr.Column(scale=1, min_width=200):
+            file_selector = gr.Dropdown(
+                choices=list(load_files().keys()), 
+                label="Select File", 
+                value=list(load_files().keys())[0]
+            )
+            add_file_button = gr.Button("Add File")
+            delete_file_button = gr.Button("Delete File")
+        
+        # Main panel
+        with gr.Column(scale=4):
+            code_input = gr.Code(
+                label="Code Editor", 
+                language="python", 
+                value=load_files()[list(load_files().keys())[0]], 
+                lines=20
+            )
+            # Tabbed bottom panel
+            with gr.Tabs():
+                with gr.TabItem("Output"):
+                    output_display = gr.Textbox(label="Output", lines=10)
+                    image_gallery = gr.Gallery(label="Plots", preview=True)
+                with gr.TabItem("Terminal"):
+                    terminal_display = gr.Textbox(
+                        label="Terminal Output", 
+                        lines=10, 
+                        interactive=False
+                    )
+                    command_input = gr.Textbox(label="Command Input", placeholder="Enter Python command")
+                    run_command_button = gr.Button("Run Command")
+            
+            # Control buttons
+            with gr.Row():
+                run_button = gr.Button("Run Code")
+                clear_button = gr.Button("Clear Output")
+                reset_button = gr.Button("Reset Namespace")
 
-# Function to delete the current file
-def delete_file(file_name, files):
-    if len(files) > 1:  # Prevent deleting the last file
-        del files[file_name]
-        new_file_name = list(files.keys())[0]
-        return files, list(files.keys()), new_file_name, files[new_file_name]
-    else:
-        return files, list(files.keys()), file_name, files[file_name]
+    # Event handlers
+    # File management
+    file_selector.change(
+        fn=select_file, 
+        inputs=[file_selector, files], 
+        outputs=code_input
+    )
+    add_file_button.click(
+        fn=add_file, 
+        inputs=files, 
+        outputs=[files, file_selector, file_selector]
+    )
+    delete_file_button.click(
+        fn=delete_file, 
+        inputs=[file_selector, files], 
+        outputs=[files, file_selector, file_selector, code_input]
+    )
+    code_input.change(
+        fn=update_code, 
+        inputs=[code_input, file_selector, files], 
+        outputs=files
+    )
 
-# Build the interface
-with gr.Blocks(title="Simple IDE with Gradio") as demo:
-    # Initial state
-    initial_files = {"main.py": "# Write your code here\nprint('Hello, World!')"}
-    
-    # State components
-    files = gr.State(initial_files)
-    namespace = gr.State({})
+    # Code execution
+    run_button.click(
+        fn=run_code, 
+        inputs=[code_input, namespace], 
+        outputs=[output_display, image_gallery, namespace]
+    )
     
-    # UI components
-    file_selector = gr.Dropdown(choices=list(initial_files.keys()), label="Select File")
-    code_input = gr.Code(label="Code Editor", language="python", value=initial_files["main.py"])
-    with gr.Row():
-        run_button = gr.Button("Run")
-        add_file_button = gr.Button("Add File")
-        delete_file_button = gr.Button("Delete File")
-        clear_button = gr.Button("Clear Output")
-        reset_button = gr.Button("Reset Namespace")
-    output_display = gr.Textbox(label="Output")
-    image_gallery = gr.Gallery(label="Plots")
+    # Terminal command
+    run_command_button.click(
+        fn=run_command, 
+        inputs=[command_input, namespace, terminal_display], 
+        outputs=terminal_display
+    )
 
-    # Event handlers
-    file_selector.change(select_file, inputs=[file_selector, files], outputs=code_input)
-    code_input.change(update_code, inputs=[code_input, file_selector, files], outputs=files)
-    add_file_button.click(add_file, inputs=files, outputs=[files, file_selector, file_selector])
-    delete_file_button.click(delete_file, inputs=[file_selector, files], 
-                            outputs=[files, file_selector, file_selector, code_input])
-    run_button.click(run_code, inputs=[code_input, namespace], 
-                     outputs=[output_display, image_gallery, namespace])
-    clear_button.click(lambda: ("", []), outputs=[output_display, image_gallery])
-    reset_button.click(lambda: ({}, "", []), outputs=[namespace, output_display, image_gallery])
+    # Clear and reset
+    clear_button.click(
+        fn=lambda: ("", [], ""),
+        outputs=[output_display, image_gallery, terminal_display]
+    )
+    reset_button.click(
+        fn=lambda: ({}, "", [], ""),
+        outputs=[namespace, output_display, image_gallery, terminal_display]
+    )
 
-# Launch the interface
+# Launch the app
 demo.launch()