Spaces:
Sleeping
Sleeping
| import os | |
| import subprocess | |
| import random | |
| from huggingface_hub import InferenceClient, cached_download, hf_hub_url | |
| import gradio as gr | |
| from safe_search import safe_search | |
| from i_search import google | |
| from i_search import i_search as i_s | |
| from agent import ( | |
| ACTION_PROMPT, | |
| ADD_PROMPT, | |
| COMPRESS_HISTORY_PROMPT, | |
| LOG_PROMPT, | |
| LOG_RESPONSE, | |
| MODIFY_PROMPT, | |
| PREFIX, | |
| SEARCH_QUERY, | |
| READ_PROMPT, | |
| TASK_PROMPT, | |
| UNDERSTAND_TEST_RESULTS_PROMPT, | |
| ) | |
| from utils import parse_action, parse_file_content, read_python_module_structure | |
| from datetime import datetime | |
| import json | |
| # --- Global Variables for App State --- | |
| app_state = {"components": []} | |
| terminal_history = "" | |
| # --- Component Library --- | |
| components_registry = { | |
| "Button": { | |
| "properties": {"label": "Click Me", "onclick": ""}, | |
| "description": "A clickable button", | |
| "code_snippet": 'gr.Button(value="{label}", variant="primary")', | |
| }, | |
| "Text Input": { | |
| "properties": {"value": "", "placeholder": "Enter text"}, | |
| "description": "A field for entering text", | |
| "code_snippet": 'gr.Textbox(label="{placeholder}")', | |
| }, | |
| "Image": { | |
| "properties": {"src": "#", "alt": "Image"}, | |
| "description": "Displays an image", | |
| "code_snippet": 'gr.Image(label="{alt}")', | |
| }, | |
| "Dropdown": { | |
| "properties": {"choices": ["Option 1", "Option 2"], "value": ""}, | |
| "description": "A dropdown menu for selecting options", | |
| "code_snippet": 'gr.Dropdown(choices={choices}, label="Dropdown")', | |
| }, | |
| # Add more components here... | |
| } | |
| # --- NLP Model (Example using Hugging Face) --- | |
| nlp_model_name = "google/flan-t5-small" | |
| # Check if the model exists in the cache | |
| try: | |
| cached_download(hf_hub_url(nlp_model_name, revision="main")) | |
| nlp_model = InferenceClient(nlp_model_name) | |
| except: | |
| nlp_model = None | |
| # --- Function to get NLP model response --- | |
| def get_nlp_response(input_text): | |
| if nlp_model: | |
| response = nlp_model.text_generation(input_text) | |
| return response.generated_text | |
| else: | |
| return "NLP model not available." | |
| # --- Component Class --- | |
| class Component: | |
| def __init__(self, type, properties=None, id=None): | |
| self.id = id or random.randint(1000, 9999) | |
| self.type = type | |
| self.properties = properties or components_registry[type]["properties"].copy() | |
| def to_dict(self): | |
| return { | |
| "id": self.id, | |
| "type": self.type, | |
| "properties": self.properties, | |
| } | |
| def render(self): | |
| # Properly format choices for Dropdown | |
| if self.type == "Dropdown": | |
| self.properties["choices"] = ( | |
| str(self.properties["choices"]) | |
| .replace("[", "") | |
| .replace("]", "") | |
| .replace("'", "") | |
| ) | |
| return components_registry[self.type]["code_snippet"].format( | |
| **self.properties | |
| ) | |
| # --- Function to update the app canvas (for preview) --- | |
| def update_app_canvas(): | |
| components_html = "".join( | |
| [ | |
| f"<div>Component ID: {component['id']}, Type: {component['type']}, Properties: {component['properties']}</div>" | |
| for component in app_state["components"] | |
| ] | |
| ) | |
| return components_html | |
| # --- Function to handle component addition --- | |
| def add_component(component_type): | |
| if component_type in components_registry: | |
| new_component = Component(component_type) | |
| app_state["components"].append(new_component.to_dict()) | |
| return ( | |
| update_app_canvas(), | |
| f"System: Added component: {component_type}\n", | |
| ) | |
| else: | |
| return None, f"Error: Invalid component type: {component_type}\n" | |
| # --- Function to handle terminal input --- | |
| def run_terminal_command(command, history): | |
| global terminal_history | |
| output = "" | |
| try: | |
| # Basic command parsing (expand with NLP) | |
| if command.startswith("add "): | |
| component_type = command.split("add ", 1)[1].strip() | |
| _, output = add_component(component_type) | |
| elif command.startswith("set "): | |
| _, output = set_component_property(command) | |
| elif command.startswith("search "): | |
| search_query = command.split("search ", 1)[1].strip() | |
| output = i_s(search_query) | |
| else: | |
| # Attempt to execute command as Python code | |
| try: | |
| result = subprocess.check_output( | |
| command, shell=True, stderr=subprocess.STDOUT, text=True | |
| ) | |
| output = result | |
| except Exception as e: | |
| output = f"Error executing Python code: {str(e)}" | |
| except Exception as e: | |
| output = f"Error: {str(e)}" | |
| finally: | |
| terminal_history += f"User: {command}\n" | |
| terminal_history += f"{output}\n" | |
| return terminal_history | |
| def set_component_property(command): | |
| try: | |
| # Improved 'set' command parsing | |
| set_parts = command.split(" ", 2)[1:] | |
| if len(set_parts) != 2: | |
| raise ValueError("Invalid 'set' command format.") | |
| component_id = int(set_parts[0]) # Use component ID | |
| property_name, property_value = set_parts[1].split("=", 1) | |
| # Find component by ID | |
| component_found = False | |
| for component in app_state["components"]: | |
| if component["id"] == component_id: | |
| if property_name in component["properties"]: | |
| component["properties"][ | |
| property_name.strip() | |
| ] = property_value.strip() | |
| component_found = True | |
| return ( | |
| update_app_canvas(), | |
| f"System: Property '{property_name}' set to '{property_value}' for component {component_id}\n", | |
| ) | |
| else: | |
| return ( | |
| None, | |
| f"Error: Property '{property_name}' not found in component {component_id}\n", | |
| ) | |
| if not component_found: | |
| return ( | |
| None, | |
| f"Error: Component with ID {component_id} not found.\n", | |
| ) | |
| except Exception as e: | |
| return None, f"Error: Invalid 'set' command format or error setting property: {str(e)}\n" | |
| # --- Function to handle chat interaction --- | |
| def run_chat(message, history): | |
| global terminal_history | |
| if message.startswith("!"): | |
| command = message[1:] | |
| terminal_history = run_terminal_command(command, history) | |
| return history, terminal_history | |
| else: | |
| # ... (Your regular chat response generation) | |
| return history, terminal_history | |
| # --- Code Generation --- | |
| def generate_python_code(app_name): | |
| code = f""" | |
| import gradio as gr | |
| # Define your Gradio components here | |
| with gr.Blocks() as {app_name}: | |
| """ | |
| for component in app_state["components"]: | |
| code += " " + Component(**component).render() + "\n" | |
| code += f""" | |
| {app_name}.launch() | |
| """ | |
| return code | |
| # --- Save/Load App State --- | |
| def save_app_state(filename="app_state.json"): | |
| with open(filename, "w") as f: | |
| json.dump(app_state, f) | |
| def load_app_state(filename="app_state.json"): | |
| global app_state | |
| try: | |
| with open(filename, "r") as f: | |
| app_state = json.load(f) | |
| except FileNotFoundError: | |
| print("App state file not found. Starting with a blank slate.") | |
| # --- Hugging Face Deployment --- | |
| def deploy_to_huggingface(app_name): | |
| # Generate Python code | |
| code = generate_python_code(app_name) | |
| # Create requirements.txt | |
| with open("requirements.txt", "w") as f: | |
| f.write("gradio==3.32.0\n") | |
| # Create the app.py file | |
| with open("app.py", "w") as f: | |
| f.write(code) | |
| # Execute the deployment command | |
| try: | |
| subprocess.run( | |
| [ | |
| "huggingface-cli", | |
| "repo", | |
| "create", | |
| "--type", | |
| "space", | |
| "--space_sdk", | |
| "gradio", | |
| app_name, | |
| ], | |
| check=True, | |
| ) | |
| subprocess.run( | |
| ["git", "init"], cwd=f"./{app_name}", check=True | |
| ) | |
| subprocess.run( | |
| ["git", "add", "."], cwd=f"./{app_name}", check=True | |
| ) | |
| subprocess.run( | |
| ['git', 'commit', '-m', '"Initial commit"'], cwd=f"./{app_name}", check=True | |
| ) | |
| subprocess.run( | |
| ["git", "push", "https://huggingface.co/spaces/" + app_name, "main"], cwd=f"./{app_name}", check=True | |
| ) | |
| return ( | |
| f"Successfully deployed to Hugging Face Spaces: https://huggingface.co/spaces/{app_name}" | |
| ) | |
| except Exception as e: | |
| return f"Error deploying to Hugging Face Spaces: {e}" | |
| # --- Gradio Interface --- | |
| with gr.Blocks() as iface: | |
| with gr.Row(): | |
| # --- Chat Interface --- | |
| chat_history = gr.Chatbot(label="Chat with Agent") | |
| chat_input = gr.Textbox(label="Your Message") | |
| chat_button = gr.Button("Send") | |
| chat_button.click( | |
| run_chat, | |
| inputs=[chat_input, chat_history], | |
| outputs=[chat_history, terminal_output], | |
| ) | |
| with gr.Row(): | |
| # --- App Builder Section --- | |
| app_canvas = gr.HTML( | |
| "<div>App Canvas Preview:</div>", label="App Canvas" | |
| ) | |
| with gr.Column(): | |
| component_list = gr.Dropdown( | |
| choices=list(components_registry.keys()), label="Components" | |
| ) | |
| add_button = gr.Button("Add Component") | |
| add_button.click( | |
| add_component, | |
| inputs=component_list, | |
| outputs=[app_canvas, terminal_output], | |
| ) | |
| with gr.Row(): | |
| # --- Terminal --- | |
| terminal_output = gr.Textbox( | |
| lines=8, label="Terminal", value=terminal_history | |
| ) | |
| terminal_input = gr.Textbox(label="Enter Command") | |
| terminal_button = gr.Button("Run") | |
| terminal_button.click( | |
| run_terminal_command, | |
| inputs=[terminal_input, terminal_output], | |
| outputs=terminal_output, | |
| ) | |
| with gr.Row(): | |
| # --- Code Generation --- | |
| code_output = gr.Code( | |
| generate_python_code("app_name"), | |
| language="python", | |
| label="Generated Code", | |
| ) | |
| app_name_input = gr.Textbox(label="App Name") | |
| generate_code_button = gr.Button("Generate Code") | |
| generate_code_button.click( | |
| generate_python_code, | |
| inputs=[app_name_input], | |
| outputs=code_output, | |
| ) | |
| with gr.Row(): | |
| # --- Save/Load Buttons --- | |
| save_button = gr.Button("Save App State") | |
| load_button = gr.Button("Load App State") | |
| save_button.click(save_app_state) | |
| load_button.click(load_app_state) | |
| with gr.Row(): | |
| # --- Deploy Button --- | |
| deploy_button = gr.Button("Deploy to Hugging Face") | |
| deploy_output = gr.Textbox(label="Deployment Output") | |
| deploy_button.click( | |
| deploy_to_huggingface, | |
| inputs=[app_name_input], | |
| outputs=[deploy_output], | |
| ) | |
| iface.launch() |