Update app.py

app.py

@@ -9,7 +9,6 @@ from i_search import i_search as i_s
 from datetime import datetime
 import logging
 import json
-import nltk  # Import nltk for sentence tokenization
 
 now = datetime.now()
 date_time_str = now.strftime("%Y-%m-%d %H:%M:%S")
@@ -25,7 +24,7 @@ logging.basicConfig(
     format="%(asctime)s - %(levelname)s - %(message)s",
 )
 
-agents = [
+agents =[
     "WEB_DEV",
     "AI_SYSTEM_PROMPT",
     "PYTHON_CODE_DEV"
@@ -81,12 +80,12 @@ thought:
 """
 
 def format_prompt(message, history, max_history_turns=2):
-  prompt = "<s>"
+  prompt = " "
   # Keep only the last 'max_history_turns' turns
   for user_prompt, bot_response in history[-max_history_turns:]:
-    prompt += f"[INST] {user_prompt} [/INST]"
-    prompt += f" {bot_response}</s> "
-  prompt += f"[INST] {message} [/INST]"
+    prompt += f"[INST] {user_prompt} [/  "
+    prompt += f" {bot_response}"
+  prompt += f"[INST] {message} [/  "
   return prompt
 
 def run_gpt(
@@ -146,7 +145,7 @@ def compress_history(purpose, task, history, directory):
 def call_search(purpose, task, history, directory, action_input):
     logging.info(f"CALLING SEARCH: {action_input}")
     try:
-        
+
         if "http" in action_input:
             if "<" in action_input:
                 action_input = action_input.strip("<")
@@ -160,7 +159,7 @@ def call_search(purpose, task, history, directory, action_input):
         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)
+        history += "observation: {}\n".format(e)
     return "MAIN", None, history, task
 
 def call_main(purpose, task, history, directory, action_input):
@@ -291,236 +290,13 @@ def run(purpose,history):
 ################################################
 
 def format_prompt(message, history, max_history_turns=5):
-  prompt = "<s>"
+  prompt = " "
   # Keep only the last 'max_history_turns' turns
   for user_prompt, bot_response in history[-max_history_turns:]:
-    prompt += f"[INST] {user_prompt} [/INST]"
-    prompt += f" {bot_response}</s> "
-  prompt += f"[INST] {message} [/INST]"
+    prompt += f"[INST] {user_prompt} [/  "
+    prompt += f" {bot_response}"
+  prompt += f"[INST] {message} [/  "
   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=2048, top_p=0.95, repetition_penalty=1.0,
-):
-    seed = random.randint(1,1111111111111111)
-
-    # Correct the line:
-    if agent_name == "WEB_DEV":
-        agent = "You are a helpful AI assistant. You are a web developer."
-    if agent_name == "AI_SYSTEM_PROMPT":
-        agent = "You are a helpful AI assistant. You are an AI system."
-    if agent_name == "PYTHON_CODE_DEV":
-        agent = "You are a helpful AI assistant. You are a Python code developer."
-    system_prompt = agent
-    temperature = float(temperature)
-    if temperature < 1e-2:
-        temperature = 1e-2
-    top_p = float(top_p)
-
-
-
-def generate_text_chunked(input_text, model, generation_parameters, max_tokens_to_generate):
-    """Generates text in chunks to avoid token limit errors."""
-    sentences = nltk.sent_tokenize(input_text)
-    generated_text = []
-    generator = pipeline('text-generation', model=model)
-
-    for sentence in sentences:
-        # Tokenize the sentence and check if it's within the limit
-        tokens = generator.tokenizer(sentence).input_ids
-        if len(tokens) + max_tokens_to_generate <= 32768:
-            # Generate text for this chunk
-            response = generator(sentence, max_length=max_tokens_to_generate, **generation_parameters)
-            generated_text.append(response[0]['generated_text'])
-        else:
-            # Handle cases where the sentence is too long
-            # You could split the sentence further or skip it
-            print(f"Sentence too long: {sentence}") 
-
-    return ''.join(generated_text)
-
-    formatted_prompt = format_prompt(prompt, history, max_history_turns=5)  # Truncated history
-    logging.info(f"Formatted Prompt: {formatted_prompt}")
-    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",
-    ),
-
-
-]
-
-examples = [
-    ["Help me set up TypeScript configurations and integrate ts-loader in my existing React project.",
-"Update Webpack Configurations",
-"Install Dependencies",
-"Configure Ts-Loader",
-"TypeChecking Rules Setup",
-"React Specific Settings",
-"Compilation Options",
-"Test Runner Configuration"],
-
-["Guide me through building a serverless microservice using AWS Lambda and API Gateway, connecting to DynamoDB for storage.",
-"Set Up AWS Account",
-"Create Lambda Function",
-"APIGateway Integration",
-"Define DynamoDB Table Scheme",
-"Connect Service To DB",
-"Add Authentication Layers",
-"Monitor Metrics and Set Alarms"],
-
-["Migrate our current monolithic PHP application towards containerized services using Docker and Kubernetes for scalability.",
-"Architectural Restructuring Plan",
-"Containerisation Process With Docker",
-"Service Orchestration With Kubernetes",
-"Load Balancing Strategies",
-"Persistent Storage Solutions",
-"Network Policies Enforcement",
-"Continuous Integration / Continuous Delivery"],
-
-["Provide guidance on integrating WebAssembly modules compiled from C++ source files into an ongoing web project.",
-"Toolchain Selection (Emscripten vs. LLVM)",
-"Setting Up Compiler Environment",
-".cpp Source Preparation",
-"Module Building Approach",
-"Memory Management Considerations",
-"Performance Tradeoffs",
-"Seamless Web Assembly Embedding"]
-]
-
-def parse_action(line):
-    action_name, action_input = line.strip("action: ").split("=")
-    action_input = action_input.strip()
-    return action_name, action_input
-
-def get_file_tree(path):
-    """
-    Recursively explores a directory and returns a nested dictionary representing its file tree.
-    """
-    tree = {}
-    for item in os.listdir(path):
-        item_path = os.path.join(path, item)
-        if os.path.isdir(item_path):
-            tree[item] = get_file_tree(item_path)
-        else:
-            tree[item] = None
-    return tree
-
-def display_file_tree(tree, indent=0):
-    """
-    Prints a formatted representation of the file tree.
-    """
-    for name, subtree in tree.items():
-        print(f"{'  ' * indent}{name}")
-        if subtree is not None:
-            display_file_tree(subtree, indent + 1)
-
-def project_explorer(path):
-    """
-    Displays the file tree of a given path in a Streamlit app.
-    """
-    tree = get_file_tree(path)
-    display_file_tree(tree)
-
-def chat_app_logic(message, history, agent_name, sys_prompt, temperature, max_new_tokens, top_p, repetition_penalty):
-    # Your existing code here
-    
-    try:
-        # Attempt to join the generator output
-        response = ''.join(generate(
-            model=model,
-            messages=messages,
-            stream=True,
-            temperature=0.7,
-            max_tokens=1500
-        ))
-    except TypeError:
-        # If joining fails, collect the output in a list
-        response_parts = []
-        for part in generate(
-            model=model,
-            messages=messages,
-            stream=True,
-            temperature=0.7,
-            max_tokens=1500
-        ):
-            if isinstance(part, str):
-                response_parts.append(part)
-            elif isinstance(part, dict) and 'content' in part:
-                response_parts.append(part['content']),
-        
-        response = ''.join(response_parts,
-        # Run the model and get the response (convert generator to string)
-            prompt=message,
-            history=history,
-            agent_name=agent_name,
-            sys_prompt=sys_prompt,
-            temperature=temperature,
-            max_new_tokens=max_new_tokens,
-            top_p=top_p,
-            repetition_penalty=repetition_penalty,
-                          )
-        history.append((message, response))
-        return history
-
-    return history
 
 def main():
     with gr.Blocks() as demo:
@@ -554,11 +330,11 @@ def main():
         with gr.Tab("Chat App"):
             history = gr.State([])
             for example in examples:
-                gr.Button(value=example[0]).click(lambda: chat_app_logic, inputs=[(example[0], message, purpose)], outputs=chatbot)
+                gr.Button(example[0]).click(lambda event, x=example[0]: chat_app_logic, inputs=[x, message, purpose], outputs=chatbot)
 
             # Connect components to the chat app logic
-            submit_button.click(chat_app_logic, inputs=[message, history, agent_name, sys_prompt, temperature, max_new_tokens, top_p, repetition_penalty], outputs=chatbot)
-            message.submit(chat_app_logic, inputs=[ history, message, agent_name, sys_prompt, temperature, max_new_tokens, top_p, repetition_penalty], outputs=chatbot)
+            submit_button.click(lambda event, x=message, h=history: chat_app_logic, inputs=[x, h], outputs=chatbot)
+            message.submit(lambda event, x=message, h=history: chat_app_logic, inputs=[x, h], outputs=chatbot)
         # Connect components to the project explorer
         explore_button.click(project_explorer, inputs=[project_path], outputs=project_output)