Update app.py

app.py

@@ -4,22 +4,16 @@ import random
 import json
 from datetime import datetime
 
-from huggingface_hub import (
-    InferenceClient,
-    cached_download,
-    hf_hub_url
-)
+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 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,
@@ -28,278 +22,219 @@ from agent import (
     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')"
-    }
-}
-
-#--- NLP Model (Example using Hugging Face) ---
-nlp_model_names = [
-    "google/flan-t5-small",
-    "Qwen/CodeQwen1.5-7B-Chat-GGUF",
-    "bartowski/Codestral-22B-v0.1-GGUF",
-    "bartowski/AutoCoder-GGUF"
-]
-
-nlp_models = []
-
-for nlp_model_name in nlp_model_names:
-    try:
-        cached_download(hf_hub_url(nlp_model_name, revision="main"))
-        nlp_models.append(InferenceClient(nlp_model_name))
-    except:
-        nlp_models.append(None)
-
-#--- Function to get NLP model response ---
-def get_nlp_response(input_text, model_index):
-    if nlp_models[model_index]:
-        response = nlp_models[model_index].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,
+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')"
+            }
         }
-
-    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)
-        elif command.startswith("deploy "):
-            app_name = command.split("deploy ", 1)[1].strip()
-            output = deploy_to_huggingface(app_name)
-        else:
-            # Attempt to execute command as Python code
+        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:
-                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:
+                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."
+
+    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 self.components_registry[type]["properties"].copy()
+
+        def to_dict(self):
+            return {
+                "id": self.id,
+                "type": self.type,
+                "properties": self.properties,
+            }
+
+        def render(self):
+            if self.type == "Dropdown":
+                self.properties["choices"] = str(self.properties["choices"]).replace("[", "").replace("]", "").replace("'", "")
+            return self.components_registry[self.type]["code_snippet"].format(**self.properties)
+
+    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):
+        if component_type in self.components_registry:
+            new_component = self.Component(component_type)
+            self.app_state["components"].append(new_component.to_dict())
             return (
-                None,
-                f"Error: Component with ID {component_id} not found.\n",
+                self.update_app_canvas(),
+                f"System: Added component: {component_type}\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)
-    else:
-        model_index = 0  # Select the model to use for chat response
-        response = get_nlp_response(message, model_index)
-        if response:
-            return history, terminal_history + f"User: {message}\nAssistant: {response}"
         else:
-            return history, terminal_history + f"User: {message}\nAssistant: I'm sorry, I couldn't generate a response. Please try again.\n"
-
-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
-
-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:
-
---- 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],
-)
-
---- 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,
-)
-
-iface.launch()
+            return None, f"Error: Invalid component type: {component_type}\n"
+
+    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):
+        # Logic to understand 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 None, f"Error: Invalid action: {action}\n"
+                else:
+                    return None, f"Error: Component with ID {component_id} not found\n"
+            else:
+                return None, f"Error: Failed to parse action from NLP response\n"
+
+    def run(self):
+        print("Welcome to the Python App Builder!")
+        print("Type 'help' to see the available commands.")
+        print("-" * 50)
+        while True:
+            input_text = input("Enter input: ")
+            output, system_message = self.process_input(input_text)
+            if output:
+                print(output)
+            if system_message:
+                print(system_message)
+
+
+if __name__ == "__main__":
+    app = App()
+    app.run()