Update app.py

app.py

@@ -1,7 +1,7 @@
 import os
 import subprocess
 import random
-from huggingface_hub import InferenceClient
+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
@@ -21,364 +21,341 @@ from agent import (
 )
 from utils import parse_action, parse_file_content, read_python_module_structure
 from datetime import datetime
-now = datetime.now()
-date_time_str = now.strftime("%Y-%m-%d %H:%M:%S")
+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...
+}
 
-client = InferenceClient(
-    "mistralai/Mixtral-8x7B-Instruct-v0.1",
-)
+# --- 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
 
 
-VERBOSE = True
-MAX_HISTORY = 125
+# --- 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 format_prompt(message, history):
-  prompt = "<s>"
-  for user_prompt, bot_response in history:
-    prompt += f"[INST] {user_prompt} [/INST]"
-    prompt += f" {bot_response}</s> "
-  prompt += f"[INST] {message} [/INST]"
-  return prompt
 
+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"
 
-def run_gpt(
-    prompt_template,
-    stop_tokens,
-    max_tokens,
-    purpose,
-    **prompt_kwargs,
-):
-    seed = random.randint(1,1111111111111111)
-    print (seed)
-    generate_kwargs = dict(
-        temperature=1.0,
-        max_new_tokens=2096,
-        top_p=0.99,
-        repetition_penalty=1.7,
-        do_sample=True,
-        seed=seed,
-    )
 
-    
-    content = PREFIX.format(
-        date_time_str=date_time_str,
-        purpose=purpose,
-        safe_search=safe_search,
-    ) + prompt_template.format(**prompt_kwargs)
-    if VERBOSE:
-        print(LOG_PROMPT.format(content))
-    
-    
-    #formatted_prompt = format_prompt(f"{system_prompt}, {prompt}", history)
-    #formatted_prompt = format_prompt(f'{content}', history)
-
-    stream = client.text_generation(content, **generate_kwargs, stream=True, details=True, return_full_text=False)
-    resp = ""
-    for response in stream:
-        resp += response.token.text
-
-    if VERBOSE:
-        print(LOG_RESPONSE.format(resp))
-    return resp
-
-
-def compress_history(purpose, task, history, directory):
-    resp = run_gpt(
-        COMPRESS_HISTORY_PROMPT,
-        stop_tokens=["observation:", "task:", "action:", "thought:"],
-        max_tokens=5096,
-        purpose=purpose,
-        task=task,
-        history=history,
-    )
-    history = "observation: {}\n".format(resp)
-    return history
-    
-def call_search(purpose, task, history, directory, action_input):
-    print("CALLING SEARCH")
+# --- 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:
-        
-        if "http" in action_input:
-            if "<" in action_input:
-                action_input = action_input.strip("<")
-            if ">" in action_input:
-                action_input = action_input.strip(">")
-            
-            response = i_s(action_input)
-            #response = google(search_return)
-            print(response)
-            history += "observation: search result is: {}\n".format(response)
-        else:
-            history += "observation: I need to provide a valid URL to 'action: SEARCH action_input=https://URL'\n"
-    except Exception as e:
-        history += "observation: {}'\n".format(e)
-    return "MAIN", None, history, task
-
-def call_main(purpose, task, history, directory, action_input):
-    resp = run_gpt(
-        ACTION_PROMPT,
-        stop_tokens=["observation:", "task:", "action:","though:"],
-        max_tokens=5096,
-        purpose=purpose,
-        task=task,
-        history=history,
-    )
-    lines = resp.strip().strip("\n").split("\n")
-    for line in lines:
-        if line == "":
-            continue
-        if line.startswith("thought: "):
-            history += "{}\n".format(line)
-        elif line.startswith("action: "):
-            
-            action_name, action_input = parse_action(line)
-            print (f'ACTION_NAME :: {action_name}')
-            print (f'ACTION_INPUT :: {action_input}')
-            
-            history += "{}\n".format(line)
-            if "COMPLETE" in action_name or "COMPLETE" in action_input:
-                task = "END"
-                return action_name, action_input, history, task
-            else:
-                return action_name, action_input, history, task
-        else:
-            history += "{}\n".format(line)
-            #history += "observation: the following command did not produce any useful output: '{}', I need to check the commands syntax, or use a different command\n".format(line)
-            
-            #return action_name, action_input, history, task
-            #assert False, "unknown action: {}".format(line)
-    return "MAIN", None, history, task
-
-
-def call_set_task(purpose, task, history, directory, action_input):
-    task = run_gpt(
-        TASK_PROMPT,
-        stop_tokens=[],
-        max_tokens=2048,
-        purpose=purpose,
-        task=task,
-        history=history,
-    ).strip("\n")
-    history += "observation: task has been updated to: {}\n".format(task)
-    return "MAIN", None, history, task
-
-def end_fn(purpose, task, history, directory, action_input):
-    task = "END"
-    return "COMPLETE", "COMPLETE", history, task
-
-NAME_TO_FUNC = {
-    "MAIN": call_main,
-    "UPDATE-TASK": call_set_task,
-    "SEARCH": call_search,
-    "COMPLETE": end_fn,
+        with open(filename, "r") as f:
+            app_state = json.load(f)
+    except FileNotFoundError:
+        print("App state file not found. Starting with a blank slate.")
 
-}
 
-def run_action(purpose, task, history, directory, action_name, action_input):
-    print(f'action_name::{action_name}')
+# --- 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:
-        if "RESPONSE" in action_name or "COMPLETE" in action_name:
-            action_name="COMPLETE"
-            task="END"
-            return action_name, "COMPLETE", history, task
-    
-        # compress the history when it is long
-        if len(history.split("\n")) > MAX_HISTORY:
-            if VERBOSE:
-                print("COMPRESSING HISTORY")
-            history = compress_history(purpose, task, history, directory)
-        if not action_name in NAME_TO_FUNC:
-            action_name="MAIN"
-        if action_name == "" or action_name == None:
-            action_name="MAIN"
-        assert action_name in NAME_TO_FUNC
-    
-        print("RUN: ", action_name, action_input)
-        return NAME_TO_FUNC[action_name](purpose, task, history, directory, action_input)
+        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:
-        history += "observation: the previous command did not produce any useful output, I need to check the commands syntax, or use a different command\n"
-
-        return "MAIN", None, history, task
-
-def run(purpose,history):
-    
-    #print(purpose)
-    #print(hist)
-    task=None
-    directory="./"
-    if history:
-        history=str(history).strip("[]")
-    if not history:
-        history = ""
-    
-    action_name = "UPDATE-TASK" if task is None else "MAIN"
-    action_input = None
-    while True:
-        print("")
-        print("")
-        print("---")
-        print("purpose:", purpose)
-        print("task:", task)
-        print("---")
-        print(history)
-        print("---")
-
-        action_name, action_input, history, task = run_action(
-            purpose,
-            task,
-            history,
-            directory,
-            action_name,
-            action_input,
+        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],
         )
-        yield (history)
-        #yield ("",[(purpose,history)])
-        if task == "END":
-            return (history)
-            #return ("", [(purpose,history)])
-
-
-
-################################################
-
-def format_prompt(message, history):
-  prompt = "<s>"
-  for user_prompt, bot_response in history:
-    prompt += f"[INST] {user_prompt} [/INST]"
-    prompt += f" {bot_response}</s> "
-  prompt += f"[INST] {message} [/INST]"
-  return prompt
-agents =[
-    "WEB_DEV",
-    "AI_SYSTEM_PROMPT",
-    "PYTHON_CODE_DEV"
-]
-def generate(
-        prompt, history, agent_name=agents[0], sys_prompt="", temperature=0.9, max_new_tokens=256, top_p=0.95, repetition_penalty=1.7,
-):
-    seed = random.randint(1,1111111111111111)
-
-    agent=prompts.WEB_DEV
-    if agent_name == "WEB_DEV":
-        agent = prompts.WEB_DEV
-    if agent_name == "AI_SYSTEM_PROMPT":
-        agent = prompts.AI_SYSTEM_PROMPT
-    if agent_name == "PYTHON_CODE_DEV":
-        agent = prompts.PYTHON_CODE_DEV        
-    system_prompt=agent
-    temperature = float(temperature)
-    if temperature < 1e-2:
-        temperature = 1e-2
-    top_p = float(top_p)
-
-    generate_kwargs = dict(
-        temperature=temperature,
-        max_new_tokens=max_new_tokens,
-        top_p=top_p,
-        repetition_penalty=repetition_penalty,
-        do_sample=True,
-        seed=seed,
-    )
 
-    formatted_prompt = format_prompt(f"{system_prompt}, {prompt}", history)
-    stream = client.text_generation(formatted_prompt, **generate_kwargs, stream=True, details=True, return_full_text=False)
-    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],
+            )
 
-    for response in stream:
-        output += response.token.text
-        yield output
-    return output
-
-
-additional_inputs=[
-    gr.Dropdown(
-        label="Agents",
-        choices=[s for s in agents],
-        value=agents[0],
-        interactive=True,
-        ),
-    gr.Textbox(
-        label="System Prompt",
-        max_lines=1,
-        interactive=True,
-    ),
-    gr.Slider(
-        label="Temperature",
-        value=0.9,
-        minimum=0.0,
-        maximum=1.0,
-        step=0.05,
-        interactive=True,
-        info="Higher values produce more diverse outputs",
-    ),
-
-    gr.Slider(
-        label="Max new tokens",
-        value=1048*10,
-        minimum=0,
-        maximum=1048*10,
-        step=64,
-        interactive=True,
-        info="The maximum numbers of new tokens",
-    ),
-    gr.Slider(
-        label="Top-p (nucleus sampling)",
-        value=0.90,
-        minimum=0.0,
-        maximum=1,
-        step=0.05,
-        interactive=True,
-        info="Higher values sample more low-probability tokens",
-    ),
-    gr.Slider(
-        label="Repetition penalty",
-        value=1.2,
-        minimum=1.0,
-        maximum=2.0,
-        step=0.05,
-        interactive=True,
-        info="Penalize repeated tokens",
-    ),
-
-
-]
-
-examples = [
-    ["What is the latest version of Python and what are the new features in this version?", None, None, None, None, None, ],
-    ["Can you explain the difference between a class and an object in object-oriented programming?", None, None, None, None, None, ],
-    ["What are the benefits of using a version control system like Git, and how can I get started with it?", None, None, None, None, None, ],
-    ["I'm trying to build a web application using a microservices architecture. Can you suggest some tools and frameworks that would be suitable for this project?", None, None, None, None, None, ],
-    ["Can you explain the concept of functional programming and how it can be used in modern programming languages?", None, None, None, None, None, ],
-    ["What are the best practices for writing clean and maintainable code, and how can I ensure that my code adheres to these standards?", None, None, None, None, None, ],
-    ["I'm working on a machine learning project and I need to preprocess my data. Can you suggest some libraries and tools that would be useful for this task?", None, None, None, None, None, ],
-    ["What are the key differences between SQL and NoSQL databases, and when should I use each type of database?", None, None, None, None, None, ],
-]
-
-
-# Define the main Gradio interface
-with gr.Blocks() as iface:  
-    # Chat Interface
-    chat_interface = gr.ChatInterface(
-        fn=run,
-        title="""Fragmixt: Autonomous Agents With Agents...Surf With a Purpose!""",
-        examples=examples,
-        concurrency_limit=20,
-    )
+    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,
+        )
 
-    # Other components within the same interface
     with gr.Row():
-        msg = gr.Textbox()
-        submit_b = gr.Button()
-        clear = gr.ClearButton([msg, chat_interface]) 
+        # --- 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")
 
-    # Event handling
-    submit_b.click(run, [msg, chat_interface], [msg, chat_interface])
-    msg.submit(run, [msg, chat_interface], [msg, chat_interface]) 
+        save_button.click(save_app_state)
+        load_button.click(load_app_state)
 
-# Launch the interface
+    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()