Update app.py

app.py

@@ -4,19 +4,23 @@ import subprocess
 import importlib
 import io
 import contextlib
+import traceback
 from pygments import highlight
 from pygments.lexers import PythonLexer
 from pygments.formatters import HtmlFormatter
 import matplotlib.pyplot as plt
 import numpy as np
 import pandas as pd
+import seaborn as sns
+import plotly.express as px
+import black
 
 # Function to install packages dynamically
 def install_package(package):
     subprocess.check_call([sys.executable, "-m", "pip", "install", package])
 
 # Function to execute user code with output capturing and visualization support
-def execute_code(code, libraries):
+def execute_code(code, libraries, timeout):
     # Install libraries
     for library in libraries.splitlines():
         if library.strip():
@@ -33,6 +37,8 @@ def execute_code(code, libraries):
                 'plt': plt,
                 'np': np,
                 'pd': pd,
+                'sns': sns,
+                'px': px,
             }
             exec(code, exec_globals)
         
@@ -40,41 +46,93 @@ def execute_code(code, libraries):
         if plt.get_fignums():
             plt.savefig('plot.png')
             plt.close()
-            return output.getvalue(), error_output.getvalue(), 'plot.png'
+            return output.getvalue(), error_output.getvalue(), 'plot.png', None
+        elif 'fig' in exec_globals and isinstance(exec_globals['fig'], px.Figure):
+            exec_globals['fig'].write_image('plot.png')
+            return output.getvalue(), error_output.getvalue(), 'plot.png', None
         else:
-            return output.getvalue(), error_output.getvalue(), None
+            return output.getvalue(), error_output.getvalue(), None, None
     except Exception as e:
-        return "", str(e), None
+        return "", traceback.format_exc(), None, None
 
 # Function to highlight Python code
 def highlight_code(code):
     return highlight(code, PythonLexer(), HtmlFormatter(style="monokai"))
 
+# Function to format code using Black
+def format_code(code):
+    try:
+        formatted_code = black.format_str(code, mode=black.FileMode())
+        return formatted_code, "Code formatted successfully!"
+    except Exception as e:
+        return code, f"Formatting error: {str(e)}"
+
+# Function to generate sample code
+def generate_sample_code(sample_type):
+    samples = {
+        "Basic": "print('Hello, World!')\n\nfor i in range(5):\n    print(i)",
+        "Numpy": "import numpy as np\n\narr = np.array([1, 2, 3, 4, 5])\nprint(arr.mean())\nprint(arr.std())",
+        "Pandas": "import pandas as pd\n\ndf = pd.DataFrame({'A': [1, 2, 3], 'B': [4, 5, 6]})\nprint(df.describe())",
+        "Matplotlib": "import matplotlib.pyplot as plt\n\nx = [1, 2, 3, 4, 5]\ny = [2, 4, 6, 8, 10]\n\nplt.plot(x, y)\nplt.title('Simple Line Plot')\nplt.xlabel('X-axis')\nplt.ylabel('Y-axis')",
+        "Seaborn": "import seaborn as sns\n\ntips = sns.load_dataset('tips')\nsns.scatterplot(x='total_bill', y='tip', data=tips)",
+        "Plotly": "import plotly.express as px\n\ndf = px.data.gapminder().query('year == 2007')\nfig = px.scatter(df, x='gdpPercap', y='lifeExp', size='pop', color='continent', hover_name='country', log_x=True, size_max=60)\nfig.show()"
+    }
+    return samples.get(sample_type, "")
+
 # Define the Gradio interface
-with gr.Blocks(css=".gradio-container {background-color: #f0f0f0;}") as demo:
-    gr.Markdown("# Advanced Python Code Executor")
+with gr.Blocks(theme=gr.themes.Soft()) as demo:
+    gr.Markdown("# Advanced Python Code Executor and Formatter")
     
     with gr.Tabs():
         with gr.TabItem("Code Execution"):
             with gr.Row():
                 with gr.Column(scale=2):
-                    code_input = gr.Code(label="Python Code", language="python", lines=10)
-                    libraries_input = gr.TextArea(label="Libraries (one per line)", placeholder="e.g.\nrequests\nscipy", lines=3)
-                    execute_button = gr.Button("Run Code", variant="primary")
+                    code_input = gr.Code(label="Python Code", language="python", lines=15)
+                    with gr.Row():
+                        libraries_input = gr.TextArea(label="Libraries (one per line)", placeholder="e.g.\nrequests\nscipy", lines=2)
+                        timeout_input = gr.Number(label="Timeout (seconds)", value=30, minimum=1, maximum=300)
+                    with gr.Row():
+                        execute_button = gr.Button("Run Code", variant="primary")
+                        clear_button = gr.Button("Clear", variant="secondary")
+                    sample_dropdown = gr.Dropdown(choices=["Basic", "Numpy", "Pandas", "Matplotlib", "Seaborn", "Plotly"], label="Load Sample Code")
                 with gr.Column(scale=1):
                     output = gr.Textbox(label="Standard Output", lines=10)
                     error_output = gr.Textbox(label="Error Output", lines=5)
                     plot_output = gr.Image(label="Plot Output")
+                    file_output = gr.File(label="Generated Files")
+        
+        with gr.TabItem("Code Formatting"):
+            code_to_format = gr.Code(label="Enter Python code to format", language="python", lines=15)
+            format_button = gr.Button("Format Code")
+            formatted_code = gr.Code(label="Formatted Code", language="python", lines=15)
+            format_message = gr.Textbox(label="Formatting Message")
         
         with gr.TabItem("Code Highlighting"):
-            code_to_highlight = gr.Code(label="Enter Python code to highlight", language="python", lines=10)
+            code_to_highlight = gr.Code(label="Enter Python code to highlight", language="python", lines=15)
             highlight_button = gr.Button("Highlight Code")
             highlighted_code = gr.HTML(label="Highlighted Code")
     
     execute_button.click(
         fn=execute_code,
-        inputs=[code_input, libraries_input],
-        outputs=[output, error_output, plot_output]
+        inputs=[code_input, libraries_input, timeout_input],
+        outputs=[output, error_output, plot_output, file_output]
+    )
+    
+    clear_button.click(
+        lambda: ("", "", "", None, None),
+        outputs=[code_input, output, error_output, plot_output, file_output]
+    )
+    
+    sample_dropdown.change(
+        fn=generate_sample_code,
+        inputs=[sample_dropdown],
+        outputs=[code_input]
+    )
+    
+    format_button.click(
+        fn=format_code,
+        inputs=[code_to_format],
+        outputs=[formatted_code, format_message]
     )
     
     highlight_button.click(
@@ -87,13 +145,25 @@ with gr.Blocks(css=".gradio-container {background-color: #f0f0f0;}") as demo:
     ## Features:
     - Execute Python code with custom library imports
     - Capture and display standard output and error messages separately
-    - Support for data visualization with matplotlib
+    - Support for data visualization with matplotlib, seaborn, and plotly
+    - Code formatting using Black
     - Code highlighting for better readability
-    - Tab-based interface for different functionalities
+    - Sample code generator for quick starts
+    - Timeout setting for code execution
+    - Clear button to reset inputs and outputs
+    
+    ## Pre-imported Libraries:
+    - `plt` for matplotlib
+    - `np` for numpy
+    - `pd` for pandas
+    - `sns` for seaborn
+    - `px` for plotly express
     
     ## Tips:
-    - Use `plt` for matplotlib, `np` for numpy, and `pd` for pandas (pre-imported)
-    - Your plot will automatically be displayed if you use `plt.plot()` or similar functions
+    - Use the sample code dropdown for quick examples
+    - Your plot will automatically be displayed if you use plotting functions
+    - Adjust the timeout if your code needs more execution time
+    - Use the formatting tab to clean up your code structure
     """)
 
 # Launch the interface