Spaces:
Sleeping
Sleeping
| import os | |
| import subprocess | |
| import random | |
| import json | |
| from datetime import datetime | |
| 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, 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 | |
| class App: | |
| def __init__(self): | |
| self.app_state = {"components": []} | |
| self.terminal_history = "" | |
| self.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')" | |
| } | |
| } | |
| self.nlp_model_names = [ | |
| "google/flan-t5-small", | |
| "Qwen/CodeQwen1.5-7B-Chat-GGUF", | |
| "bartowski/Codestral-22B-v0.1-GGUF", | |
| "bartowski/AutoCoder-GGUF" | |
| ] | |
| self.nlp_models = [] | |
| self.initialize_nlp_models() | |
| def initialize_nlp_models(self): | |
| for nlp_model_name in self.nlp_model_names: | |
| try: | |
| cached_download(hf_hub_url(nlp_model_name, revision="main")) | |
| self.nlp_models.append(InferenceClient(nlp_model_name)) | |
| except: | |
| self.nlp_models.append(None) | |
| def get_nlp_response(self, input_text, model_index): | |
| if self.nlp_models[model_index]: | |
| response = self.nlp_models[model_index].text_generation(input_text) | |
| return response.generated_text | |
| else: | |
| return "NLP model not available." | |
| def update_app_canvas(self): | |
| components_html = "".join([f"<div>Component ID: {component['id']}, Type: {component['type']}, Properties: {component['properties']}</div>" for component in self.app_state["components"]]) | |
| return components_html | |
| def add_component(self, component_type, properties=None): | |
| try: | |
| new_component = { | |
| "type": component_type, | |
| "properties": properties or {} | |
| } | |
| self.app_state["components"].append(new_component) | |
| except Exception as e: | |
| print(f"Error adding component: {e}") | |
| def run_terminal_command(self, command, history): | |
| output = "" | |
| try: | |
| if command.startswith("add "): | |
| component_type = command.split("add ")[1] | |
| return self.add_component(component_type) | |
| elif command.startswith("search "): | |
| query = command.split("search ")[1] | |
| return google(query) | |
| elif command.startswith("i search "): | |
| query = command.split("i search ")[1] | |
| return i_s(query) | |
| elif command.startswith("safe search "): | |
| query = command.split("safesearch ")[1] | |
| return safe_search(query) | |
| elif command.startswith("read "): | |
| file_path = command.split("read ")[1] | |
| return parse_file_content(file_path) | |
| elif command == "task": | |
| return TASK_PROMPT | |
| elif command == "modify": | |
| return MODIFY_PROMPT | |
| elif command == "log": | |
| return LOG_PROMPT | |
| elif command.startswith("understand test results "): | |
| test_results = command.split("understand test results ")[1] | |
| return self.understand_test_results(test_results) | |
| elif command.startswith("compress history"): | |
| return self.compress_history(history) | |
| elif command == "help": | |
| return self.get_help_message() | |
| elif command == "exit": | |
| exit() | |
| else: | |
| output = subprocess.check_output(command, shell=True).decode("utf-8") | |
| except Exception as e: | |
| output = str(e) | |
| return output or "No output\n" | |
| def compress_history(self, history): | |
| compressed_history = "" | |
| lines = history.strip().split("\n") | |
| for line in lines: | |
| if not line.strip().startswith("#"): | |
| compressed_history += line + "\n" | |
| return compressed_history | |
| def understand_test_results(self, test_results): | |
| return UNDERSTAND_TEST_RESULTS_PROMPT | |
| def get_help_message(self): | |
| return """ | |
| Available commands: | |
| - add [component_type]: Add a component to the app canvas | |
| - search [query]: Perform a Google search | |
| - i search [query]: Perform an intelligent search | |
| - safe search [query]: Perform a safe search | |
| - read [file_path]: Read and parse the content of a Python module | |
| - task: Prompt for a task to perform | |
| - modify: Prompt to modify a component property | |
| - log: Prompt to log a response | |
| - understand test results [test_results]: Understand test results | |
| - compress history: Compress the terminal history by removing comments | |
| - help: Show this help message | |
| - exit: Exit the program | |
| """ | |
| def process_input(self, input_text): | |
| if input_text.strip().startswith("/"): | |
| command = input_text.strip().lstrip("/") | |
| output = self.run_terminal_command(command, self.terminal_history) | |
| self.terminal_history += f"{input_text}\n{output}\n" | |
| return output, "" | |
| else: | |
| model_index = random.randint(0, len(self.nlp_models)-1) | |
| response = self.get_nlp_response(input_text, model_index) | |
| component_id, action, property_name, property_value = parse_action(response) | |
| if component_id: | |
| component = next((comp for comp in self.app_state["components"] if comp["id"] == component_id), None) | |
| if component: | |
| if action == "update": | |
| component["properties"][property_name] = property_value | |
| return self.update_app_canvas(), f"System: Updated property '{property_name}' of component with ID {component_id}\n" | |
| elif action == "remove": | |
| self.app_state["components"].remove(component) | |
| return self.update_app_canvas(), f"System: Removed component with ID {component_id}\n" | |
| else: | |
| return "", f"Error: Invalid action: {action}\n" | |
| else: | |
| return "", f"Error: Component with ID {component_id} not found\n" | |
| else: | |
| return "", f"Error: Failed to parse action from NLP response\n" | |
| def build_app(self): | |
| with gr.Blocks() as demo: | |
| for component in self.app_state["components"]: | |
| component_type = component["type"] | |
| properties = component["properties"] | |
| if component_type == "Button": | |
| gr.Button(value=properties["label"], variant="primary") | |
| elif component_type == "Text Input": | |
| gr.Textbox(label=properties["placeholder"]) | |
| elif component_type == "Image": | |
| gr.Image(label=properties["alt"]) | |
| elif component_type == "Dropdown": | |
| gr.Dropdown(choices=properties["choices"], label="Dropdown") | |
| with gr.Tab("Terminal"): | |
| gr.Markdown("## Terminal") | |
| terminal_input = gr.Textbox(label="Input") | |
| terminal_output = gr.Textbox(label="Output") | |
| run_terminal_command_button = gr.Button("Run Command") | |
| run_terminal_command_button.click( | |
| self.run_terminal_command, | |
| inputs=[terminal_input], | |
| outputs=[terminal_output] | |
| ) | |
| with gr.Tab("NLP Models"): | |
| gr.Markdown("## Available NLP Models") | |
| model_index = gr.Slider(label="Model Index", minimum=0, maximum=len(self.nlp_model_names)-1, step=1) | |
| input_text = gr.Textbox(label="Input Text") | |
| get_nlp_response_button = gr.Button("Get NLP Response") | |
| get_nlp_response_button.click( | |
| self.get_nlp_response, | |
| inputs=[input_text, model_index], | |
| outputs="text" | |
| ) | |
| return demo | |
| def run(self): | |
| self._print_welcome_message() | |
| while True: | |
| try: | |
| input_text = self._get_user_input() | |
| if input_text.lower() == 'exit': | |
| break | |
| elif input_text.lower() == 'launch': | |
| self.launch_app() | |
| continue | |
| output, system_message = self.process_input(input_text) | |
| self._display_output(output, system_message) | |
| except EOFError: | |
| print("Error: Input reading interrupted. Please provide valid input.") | |
| except KeyboardInterrupt: | |
| print("\nApplication stopped by user.") | |
| break | |
| except Exception as e: | |
| print(f"An error occurred: {str(e)}") | |
| def _print_welcome_message(self): | |
| print("Welcome to the Python App Builder!") | |
| print("Type 'help' to see the available commands.") | |
| print("Type 'launch' to build | |
| print("Type 'launch' to build and launch the Gradio app.") | |
| print("Type 'exit' to quit the application.") | |
| print("-" * 50) | |
| def _get_user_input(self): | |
| return input("Enter input: ").strip() | |
| def _display_output(self, output, system_message): | |
| if output: | |
| print(output) | |
| if system_message: | |
| print(system_message) | |
| def launch_app(self): | |
| demo = self.build_app() | |
| demo.launch() | |
| def main(): | |
| try: | |
| app = App() | |
| demo = app.build_app() | |
| demo.launch() | |
| except Exception as e: | |
| print(f"Error launching app: {e}") | |
| if __name__ == "__main__": | |
| main() | |
| def run(self): | |
| self._print_welcome_message() | |
| while True: | |
| try: | |
| input_text = self._get_user_input() | |
| if input_text.lower() == 'exit': | |
| break | |
| elif input_text.lower() == 'launch': | |
| self.launch_app() | |
| continue | |
| output, system_message = self.process_input(input_text) | |
| self._display_output(output, system_message) | |
| except EOFError: | |
| print("Error: Input reading interrupted. Please provide valid input.") | |
| except KeyboardInterrupt: | |
| print("\nApplication stopped by user.") | |
| break | |
| except Exception as e: | |
| print(f"An error occurred: {str(e)}") | |
| def _print_welcome_message(self): | |
| print("Welcome to the Python App Builder!") | |
| print("Type 'help' to see the available commands.") | |
| print("Type 'launch' to build and launch the Gradio app.") | |
| print("Type 'exit' to quit the application.") | |
| print("-" * 50) | |
| def _get_user_input(self): | |
| return input("Enter input: ").strip() | |
| def _display_output(self, output, system_message): | |
| if output: | |
| print(output) | |
| if system_message: | |
| print(system_message) | |
| def launch_app(self): | |
| demo = self.build_app() | |
| demo.launch() | |
| def main(): | |
| try: | |
| app = App() | |
| demo = app.build_app() | |
| demo.launch() | |
| except Exception as e: | |
| print(f"Error launching app: {e}") | |
| if __name__ == "__main__": | |
| main() |