Update app.py

app.py

@@ -2,6 +2,63 @@ import tensorflow
 import torch
 import gradio as gr
 from transformers import pipeline, AutoModelForCausalLM, AutoTokenizer
+import gradio as gr
+import importlib
+import subprocess
+import sys
+import io
+import threading
+import time
+from flask import Flask
+
+def install_and_import(package_name):
+    """Installs a package using pip and imports it."""
+    subprocess.check_call(["pip", "install", package_name])
+    return importlib.import_module(package_name)
+
+def extract_package_name(input_str):
+    """Extracts the package name from a PyPI URL or pip command."""
+    if input_str.startswith("https://pypi.org/project/"):
+        return input_str.split("/")[-2]
+    elif input_str.startswith("pip install "):
+        return input_str.split(" ")[2]
+    else:
+        return input_str
+
+def create_interface_from_input(input_str):
+    """
+    Creates a Gradio interface with buttons for functions from a package.
+    """
+    try:
+        package_name = extract_package_name(input_str)
+        module = install_and_import(package_name)
+
+        # Handle Flask application context if needed
+        if 'flask' in sys.modules or 'flask_restful' in sys.modules:
+            app = Flask(__name__)
+            with app.app_context():
+                functions = [getattr(module, name) for name in dir(module) if callable(getattr(module, name))]
+        else:
+            functions = [getattr(module, name) for name in dir(module) if callable(getattr(module, name))]
+
+        function_list = [(func.__name__, func) for func in functions if not func.__name__.startswith("_")]
+        return function_list, f"Interface for `{package_name}`"
+
+    except Exception as e:
+        return [], str(e)
+
+def execute_pip_command(command, add_message):
+    """Executes a pip command and streams the output."""
+    process = subprocess.Popen(command.split(), stdout=subprocess.PIPE, stderr=subprocess.PIPE, text=True)
+    while True:
+        output = process.stdout.readline()
+        if output == '' and process.poll() is not None:
+            break
+        if output:
+            add_message("System", f"```\n{output.strip()}\n```")
+            time.sleep(0.1)  # Simulate delay for more realistic streaming
+    rc = process.poll()
+    return rc
 
 # --- Load the NLP pipeline for text classification ---
 classifier = pipeline("text-classification")
@@ -62,6 +119,71 @@ with gr.Blocks() as demo_text:
     output_text = gr.Textbox(label="Generated Text")
     input_text.submit(generate_text, inputs=input_text, outputs=output_text)
 
-# --- Launch the Gradio app ---
-demo.launch(share=True)  # Share the app publicly
-demo_text.launch(share=True)
+def handle_chat(input_text, history):
+    """Handles the chat input and updates the chat history."""
+    def add_message(sender, message):
+        history.append((sender, message))
+
+    add_message("User", input_text)
+
+    if input_text.startswith("pip install ") or input_text.startswith("https://pypi.org/project/"):
+        package_name = extract_package_name(input_text)
+        add_message("System", f"Installing `{package_name}`...")
+
+        execute_pip_command(input_text, add_message)
+        
+        function_list, message = create_interface_from_input(input_text)
+        add_message("System", message)
+        
+        if function_list:
+            functions_str = "\n".join([f" - {name}()" for name, _ in function_list])
+            add_message("System", f"Available functions:\n{functions_str}")
+
+        return history, function_list
+    else:
+        # Check if the input is to call a function
+        if '(' in input_text and ')' in input_text:
+            func_name = input_text.split('(')[0].strip()
+            func_args = input_text.split('(')[1].split(')')[0].strip()
+            
+            if func_args:
+                func_args = [arg.strip() for arg in func_args.split(',')]
+
+            # Find the function in the current dynamic interface
+            for name, func in dynamic_functions:
+                if func_name == name:
+                    try:
+                        result = func(*func_args)
+                        add_message("System", f"Result of {func_name}({', '.join(func_args)}): {result}")
+                    except Exception as e:
+                        add_message("System", f"Error: {str(e)}")
+                    break
+            else:
+                add_message("System", f"Function '{func_name}' not found.")
+        else:
+            add_message("System", "Invalid function call. Please use the format 'function_name(arg1, arg2, ...)'")
+
+        return history, dynamic_functions
+
+# Initialize dynamic functions list to store available functions
+dynamic_functions = []
+
+# Gradio app
+with gr.Blocks() as demo:
+    with gr.Row():
+        chat_interface = gr.Chatbot()
+    
+    with gr.Row():
+        chat_input = gr.Textbox(placeholder="Enter pip command or package URL", show_label=False)
+        submit_button = gr.Button("Submit")
+
+    def chat_handler(input_text, history):
+        global dynamic_functions
+        history, new_functions = handle_chat(input_text, history)
+        dynamic_functions = new_functions
+        return history
+
+    submit_button.click(fn=chat_handler, inputs=[chat_input, chat_interface], outputs=[chat_interface])
+    chat_input.submit(fn=chat_handler, inputs=[chat_input, chat_interface], outputs=[chat_interface])
+
+demo.launch()