Update app.py

app.py

@@ -1,247 +1,381 @@
 import os
-import json
 import subprocess
-import re
-import requests
-from datetime import datetime
-
+import random
+from huggingface_hub import InferenceClient
 import gradio as gr
-from transformers import pipeline, AutoModelForCausalLM, AutoTokenizer, TextGenerationPipeline, AutoModel, RagRetriever, AutoModelForSeq2SeqLM
-import torch
-import tree_sitter
-from tree_sitter import Language, Parser
-import black
-from pylint import lint
-from io import StringIO
-import sys
-from huggingface_hub import Repository, hf_hub_url, HfApi, snapshot_download
-import tempfile
-import logging
-from loguru import logger
-logger.add("app.log", format="{time} {level} {message}", level="INFO")
-
-# Constants
-MODEL_NAME = "bigscience/bloom"
-PROJECT_ROOT = "projects"
-AGENT_DIRECTORY = "agents"
-AVAILABLE_CODE_GENERATIVE_MODELS = [
-    "bigcode/starcoder",
-    "Salesforce/codegen-350M-mono",
-    "microsoft/CodeGPT-small-py",
-    "NinedayWang/PolyCoder-2.7B",
-    "facebook/incoder-1B",
-]
-
-# Load Models and Resources
-tokenizer = AutoTokenizer.from_pretrained(MODEL_NAME)
-model = AutoModelForCausalLM.from_pretrained(MODEL_NAME, torch_dtype=torch.float16)
-pipe = TextGenerationPipeline(model=model, tokenizer=tokenizer)
-
-# Build Tree-sitter parser libraries (if not already built)
-Language.build_library("build/my-languages.so", ["tree-sitter-python", "tree-sitter-javascript"])
-PYTHON_LANGUAGE = Language("build/my-languages.so", "python")
-JAVASCRIPT_LANGUAGE = Language("build/my-languages.so", "javascript")
-parser = Parser()
-
-# Session State Initialization
-if 'chat_history' not in gr.State.session_state:
-    gr.State.chat_history = []
-if 'terminal_history' not in gr.State.session_state:
-    gr.State.terminal_history = []
-if 'workspace_projects' not in gr.State.session_state:
-    gr.State.workspace_projects = {}
-if 'available_agents' not in gr.State.session_state:
-    gr.State.available_agents = []
-if 'current_state' not in gr.State.session_state:
-    gr.State.current_state = {
-        'toolbox': {},
-        'workspace_chat': {}
-    }
-
-# Define is_code function
-def is_code(message):
-    return message.lstrip().startswith("```") or message.lstrip().startswith("code:")
-
-# Define agents variable
-agents = ["python", "javascript", "java"]
-
-# Define load_agent_from_file function
-def load_agent_from_file(agent_name):
+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
+now = datetime.now()
+date_time_str = now.strftime("%Y-%m-%d %H:%M:%S")
+
+client = InferenceClient(
+    "mistralai/Mixtral-8x7B-Instruct-v0.1",
+)
+
+
+############################################
+
+
+VERBOSE = True
+MAX_HISTORY = 125
+
+
+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 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")
     try:
-        with open(os.path.join(AGENT_DIRECTORY, agent_name + ".json"), "r") as f:
-            return json.load(f)
-    except FileNotFoundError:
-        return None
+        
+        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,
 
-# Define load_pipeline function
-def load_pipeline(model_category, model_name):
-    return available_models[model_category][model_name]
+}
 
-# Define execute_translation function
-def execute_translation(code, target_language, pipe):
+def run_action(purpose, task, history, directory, action_name, action_input):
+    print(f'action_name::{action_name}')
     try:
-        output = pipe(code, max_length=1000)[0]["generated_text"]
-        return output
+        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)
     except Exception as e:
-        logger.error(f"Error in execute_translation function: {e}")
-        return "Error: Unable to translate code."
-
-# Refactor using CodeT5+
-def execute_refactoring_codet5(code: str) -> str:
-    """
-    Refactors the provided code using the CodeT5+ model.
+        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,
+        )
+        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 = ""
+
+    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",
+    ),
 
-    Args:
-        code (str): The code to refactor.
 
-    Returns:
-        str: The refactored code.
-    """
-    try:
-        refactor_pipe = pipeline(
-            "text2text-generation",
-            model="Salesforce/codet5p-220m-finetune-Refactor"
-        )
-        prompt = f"Refactor this Python code:\n{code}"
-        output = refactor_pipe(prompt, max_length=1000)[0]["generated_text"]
-        return output
-    except Exception as e:
-        logger.error(f"Error in execute_refactoring_codet5 function: {e}")
-        return "Error: Unable to refactor code."
-
-# Chat interface with agent
-def chat_interface_with_agent(input_text, agent_name, selected_model):
-    """
-    Handles interaction with the selected AI agent.
-    """
-    agent = load_agent_from_file(agent_name)
-    if not agent:
-        return f"Agent {agent_name} not found."
-
-    agent.pipeline = available_models[selected_model]
-    agent_prompt = agent.create_agent_prompt()
-    full_prompt = f"{agent_prompt}\n\nUser: {input_text}\nAgent:"
+]
 
-    try:
-        response = agent.generate_response(full_prompt)
-    except Exception as e:
-        logger.error(f"Error generating agent response: {e}")
-        response = "Error: Unable to process your request."
-
-    return response
-
-# Available models
-available_models = {
-    "Code Generation & Completion": {
-        "Salesforce CodeGen-350M (Mono)": pipeline("text-generation", model="Salesforce/codegen-350M-mono"),
-        "BigCode StarCoder": pipeline("text-generation", model="bigcode/starcoder"),
-        "CodeGPT-small-py": pipeline("text-generation", model="microsoft/CodeGPT-small-py"),
-        "PolyCoder-2.7B": pipeline("text-generation", model="NinedayWang/PolyCoder-2.7B"),
-        "InCoder-1B": pipeline("text-generation", model="facebook/incoder-1B"),
-    },
-    "Code Translation": {
-        "Python to JavaScript": (lambda code, pipe=pipeline("translation", model="transformersbook/codeparrot-translation-en-java"): execute_translation(code, "javascript", pipe), []),
-        "Python to C++": (lambda code, pipe=pipeline("text-generation", model="konodyuk/codeparrot-small-trans-py-cpp"): execute_translation(code, "cpp", pipe), []),
-    },
-    # ... other categories
-}
 
-# Gradio interface with tabs
-with gr.Blocks(title="AI Power Tools for Developers") as demo:
-    # --- State ---
-    code = gr.State("")  # Use gr.State to store code across tabs
-    task_dropdown = gr.State(list(available_models.keys())[0])  # Initialize task dropdown
-    model_dropdown = gr.State(
-        list(available_models[task_dropdown.value].keys())[0]
-    )  # Initialize model dropdown
-
-    def update_model_dropdown(selected_task):
-        models_for_task = list(available_models[selected_task].keys())
-        return gr.Dropdown.update(choices=models_for_task)
-
-    with gr.Tab("Chat & Code"):
-        chatbot = gr.Chatbot(elem_id="chatbot")
-        msg = gr.Textbox(label="Enter your message", placeholder="Type your message here...")
+examples=[["Based on previous interactions, generate an interactive preview of the user's requested application.", None, None, None, None, None, ],
+          ["Utilize the relevant code snippets and components from previous interactions.", None, None, None, None, None, ],
+          ["Assemble a working demo that showcases the core functionality of the application.", None, None, None, None, None, ],
+          ["Present the demo in an interactive environment within the Gradio interface.", None, None, None, None, None,],
+          ["Allow the user to explore and interact with the demo to test its features.",, None, None, None, None, None,],
+          ["Gather feedback from the user about the demo and potential improvements.", None, None, None, None, None,],
+          ["If the user approves of the app's running state you should provide a bash script that will automate all aspects of a local run and also a docker image for ease-of-launch in addition to the huggingface-ready app.py with all functions and gui and the requirements.txt file comprised of all required libraries and packages the application is dependent on, avoiding openai api at all points as we only use huggingface transformers, models, agents, libraries, api.", None, None, None, None, None,],
+
+         ]
+
+
+gr.ChatInterface(
+fn=run,
+title="""Fragmixt\nAgents With Agents,\nSurf With a Purpose""",
+examples=examples,
+concurrency_limit=20,
+with gr.Blocks() as ifacea:
+    gr.HTML("""TEST""")
+ifacea.launch()
+).launch()
+with gr.Blocks() as iface:
+    chatbot=gr.Chatbot(show_label=False, show_share_button=False, show_copy_button=True, likeable=True, layout="panel"),
+    chatbot=gr.Chatbot()
+    msg = gr.Textbox()
+    with gr.Row():
+        submit_b = gr.Button()
         clear = gr.ClearButton([msg, chatbot])
-
-        def user(message, history):
-            if is_code(message):
-                response = ""  # Initialize response
-                task = message.split()[0].lower()  # Extract task keyword
-
-                # Use the selected model or a default one
-                model_category = task_dropdown.value
-                model_name = model_dropdown.value
-                pipeline = load_pipeline(model_category, model_name)
-
-                if task in agents:
-                    agent = load_agent_from_file(task)
-                    try:
-                        response = agent.generate_response(message)
-                    except Exception as e:
-                        logger.error(f"Error executing agent {task}: {e}")
-                        response = f"Error executing agent {task}: {e}"
-                else:
-                    response = "Invalid command or task not found."
-            else:
-                # Process as natural language request
-                response = pipe(message, max_length=1000)[0]["generated_text"]
-
-            return response, history + [(message, response)]
-
-        msg.change(user, inputs=[msg, chatbot], outputs=[chatbot, chatbot])
-        clear.click(lambda: None, None, chatbot, queue=False)
-
-    # Model Selection Tab
-    with gr.Tab("Model Selection"):
-        task_dropdown.render()
-        model_dropdown.render()
-        task_dropdown.change(update_model_dropdown, task_dropdown, model_dropdown)
-
-    # Workspace Tab
-    with gr.Tab("Workspace"):
-        with gr.Row():
-            with gr.Column():
-                code.render()
-                file_output = gr.File(label="Save File As...", interactive=False)
-            with gr.Column():
-                output = gr.Textbox(label="Output")
-
-        run_btn = gr.Button(value="Run Code")
-        upload_btn = gr.UploadButton("Upload Python File", file_types=[".py"])
-        save_button = gr.Button(value="Save Code")
-
-        def run_code(code_str):
-            try:
-                # Save code to a temporary file
-                with open("temp_code.py", "w") as f:
-                    f.write(code_str)
-
-                # Execute the code using subprocess
-                process = subprocess.Popen(["python", "temp_code.py"], stdout=subprocess.PIPE, stderr=subprocess.PIPE)
-                output, error = process.communicate()
-
-                # Return the output and error messages
-                if error:
-                    return "Error: " + error.decode("utf-8")
-                else:
-                    return output.decode("utf-8")
-
-            except Exception as e:
-                logger.error(f"Error running code: {e}")
-                return f"Error running code: {e}"
-
-        def upload_file(file):
-            with open("uploaded_code.py", "wb") as f:
-                f.write(file.file.getvalue())
-            return "File uploaded successfully!"
-
-        def save_code(code_str):
-            file_output.value = code_str
-            return file_output
-
-        run_btn.click(run_code, inputs=[code], outputs=[output])
-        upload_btn.click(upload_file, inputs=[upload_btn], outputs=[output])
-        save_button.click(save_code, inputs=[code], outputs=[file_output])
-
-    demo.launch()
+    submit_b.click(run, [msg,chatbot],[msg,chatbot])
+    msg.submit(run, [msg, chatbot], [msg, chatbot])
+iface.launch()