app.py

import gradio as gr
import sys
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, timeout):
    # Install libraries
    for library in libraries.splitlines():
        if library.strip():
            install_package(library.strip())
    
    # Prepare output capturing
    output = io.StringIO()
    error_output = io.StringIO()
    
    # Execute the code
    try:
        with contextlib.redirect_stdout(output), contextlib.redirect_stderr(error_output):
            exec_globals = {
                'plt': plt,
                'np': np,
                'pd': pd,
                'sns': sns,
                'px': px,
            }
            exec(code, exec_globals)
        
        # Check if a plot was created
        if plt.get_fignums():
            plt.savefig('plot.png')
            plt.close()
            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, None
    except Exception as e:
        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(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=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=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, 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(
        fn=highlight_code,
        inputs=[code_to_highlight],
        outputs=[highlighted_code]
    )

    gr.Markdown("""
    ## Features:
    - Execute Python code with custom library imports
    - Capture and display standard output and error messages separately
    - Support for data visualization with matplotlib, seaborn, and plotly
    - Code formatting using Black
    - Code highlighting for better readability
    - 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 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
demo.launch()