Upload 2 files

app.py

@@ -0,0 +1,123 @@
+import gradio as gr
+import numpy as np
+import pandas as pd
+import matplotlib.pyplot as plt
+import seaborn as sns
+from io import StringIO
+import sys
+import contextlib
+from sklearn import datasets, metrics, model_selection, preprocessing
+import warnings
+warnings.filterwarnings('ignore')
+
+# Capture output helper
+@contextlib.contextmanager
+def capture_output():
+    new_out, new_err = StringIO(), StringIO()
+    old_out, old_err = sys.stdout, sys.stderr
+    try:
+        sys.stdout, sys.stderr = new_out, new_err
+        yield sys.stdout, sys.stderr
+    finally:
+        sys.stdout, sys.stderr = old_out, old_err
+
+def execute_code(code: str):
+    """
+    Execute the provided Python code and return the output
+    """
+    # Initialize output components
+    output_text = ""
+    output_plot = None
+    output_df = None
+    
+    # Create a namespace for code execution
+    namespace = {
+        'np': np,
+        'pd': pd,
+        'plt': plt,
+        'sns': sns,
+        'datasets': datasets,
+        'metrics': metrics,
+        'model_selection': model_selection,
+        'preprocessing': preprocessing
+    }
+    
+    try:
+        # Capture print outputs
+        with capture_output() as (out, err):
+            # Execute the code
+            exec(code, namespace)
+            
+            # Capture print statements
+            output_text = out.getvalue()
+            if err.getvalue():
+                output_text += "\nErrors:\n" + err.getvalue()
+        
+        # Check if there's a plot
+        if plt.gcf().axes:
+            output_plot = plt.gcf()
+            plt.close()
+        
+        # Check for DataFrame output
+        for var in namespace:
+            if isinstance(namespace[var], pd.DataFrame):
+                output_df = namespace[var]
+                break
+                
+    except Exception as e:
+        output_text = f"Error: {str(e)}"
+    
+    return output_text, output_plot, output_df
+
+# Create the Gradio interface
+with gr.Blocks() as demo:
+    gr.Markdown("""
+    # Python Data Science Code Executor
+    Execute Python code with access to common data science libraries:
+    - NumPy (np)
+    - Pandas (pd) 
+    - Matplotlib (plt)
+    - Seaborn (sns)
+    - Scikit-learn (datasets, metrics, model_selection, preprocessing)
+    """)
+    
+    with gr.Row():
+        with gr.Column():
+            code_input = gr.Code(
+                label="Python Code",
+                language="python",
+                value="""# Example: Load and visualize iris dataset
+from sklearn.datasets import load_iris
+iris = load_iris()
+df = pd.DataFrame(iris.data, columns=iris.feature_names)
+df['target'] = iris.target
+
+# Create a scatter plot
+plt.figure(figsize=(10, 6))
+plt.scatter(df['sepal length (cm)'], df['sepal width (cm)'], c=df['target'])
+plt.xlabel('Sepal Length (cm)')
+plt.ylabel('Sepal Width (cm)')
+plt.title('Iris Dataset - Sepal Length vs Width')
+
+# Print first few rows
+print("First 5 rows of the dataset:")
+print(df.head())
+"""
+            )
+            run_button = gr.Button("Execute Code", variant="primary")
+        
+        with gr.Column():
+            output_text = gr.Textbox(label="Output", lines=5)
+            output_plot = gr.Plot(label="Plot Output")
+            output_df = gr.Dataframe(label="DataFrame Output")
+    
+    # Handle code execution
+    run_button.click(
+        fn=execute_code,
+        inputs=[code_input],
+        outputs=[output_text, output_plot, output_df]
+    )
+
+# Launch the app
+if __name__ == "__main__":
+    demo.launch()

requirements.txt

@@ -0,0 +1,6 @@
+gradio>=4.0.0
+numpy>=1.24.0
+pandas>=2.0.0
+matplotlib>=3.7.0
+seaborn>=0.12.0
+scikit-learn>=1.2.0