Update app.py

app.py

@@ -1,151 +1,168 @@
+from huggingface_hub import InferenceClient
 import gradio as gr
-import os
 import random
-import requests
-import asyncio
-from typing import List, Tuple, Any, Callable, Optional
+import prompts
+client = InferenceClient(
+    "mistralai/Mixtral-8x7B-Instruct-v0.1"
+)
+
+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",
+    "CODE_REVIEW_ASSISTANT",
+    "CONTENT_WRITER_EDITOR",
+    #"SOCIAL_MEDIA_MANAGER",
+    #"MEME_GENERATOR",
+    "QUESTION_GENERATOR",
+    #"IMAGE_GENERATOR",
+    "HUGGINGFACE_FILE_DEV",
 
-os.environ['GRADIO__LAUNCHER_LOADING'] = 'True'
+]
+def generate(
+        prompt, history, agent_name=agents[0], sys_prompt="", temperature=0.9, max_new_tokens=256, top_p=0.95, repetition_penalty=1.0,
+):
+    seed = random.randint(1,1111111111111111)
+
+
+    agent=prompts.WEB_DEV
+    if agent_name == "WEB_DEV":
+        agent = prompts.WEB_DEV_SYSTEM_PROMPT
+    if agent_name == "CODE_REVIEW_ASSISTANT":
+        agent = prompts.CODE_REVIEW_ASSISTANT
+    if agent_name == "CONTENT_WRITER_EDITOR":
+        agent = prompts.CONTENT_WRITER_EDITOR
+    if agent_name == "SOCIAL_MEDIA_MANAGER":
+    agent = prompts.SOCIAL_MEDIA_MANAGER        
+    if agent_name == "AI_SYSTEM_PROMPT":
+        agent = prompts.AI_SYSTEM_PROMPT
+    if agent_name == "PYTHON_CODE_DEV":
+        agent = prompts.PYTHON_CODE_DEV        
+    #if agent_name == "MEME_GENERATOR":
+    #    agent = prompts.MEME_GENERATOR  
+    if agent_name == "QUESTION_GENERATOR":
+        agent = prompts.QUESTION_GENERATOR 
+    #if agent_name == "IMAGE_GENERATOR":
+    #     agent = prompts.IMAGE_GENERATOR      
+    if agent_name == "HUGGINGFACE_FILE_DEV":
+        agent = prompts.HUGGINGFACE_FILE_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",
+    ),
 
-def download_file(url: str, save_directory: str) -> str:
-    if not os.path.exists(save_directory):
-        os.makedirs(save_directory)
 
-    resp = requests.get(url)
-    file_name = os.path.basename(url)
-    saved_file_path = os.path.join(save_directory, file_name)
+]
 
-    with open(saved_file_path, 'wb') as f:
-        f.write(resp.content)
+examples=[
+    ["Create a simple web application using Flask", agents[0], None, None, None, None, ],
+    ["Generate a Python script to perform a linear regression analysis", agents[2], None, None, None, None, ],
+    ["Create a Dockerfile for a Node.js application", agents[1], None, None, None, None, ],
+    ["Write a shell script to automate the deployment of a web application to a server", agents[3], None, None, None, None, ],
+    ["Generate a SQL query to retrieve the top 10 most popular products by sales", agents[4], None, None, None, None, ],
+    ["Write a Python script to generate a random password with a given length and complexity", agents[2], None, None, None, None, ],
+    ["Create a simple game in Unity using C#", agents[0], None, None, None, None, ],
+    ["Generate a Java program to implement a binary search algorithm", agents[2], None, None, None, None, ],
+    ["Write a shell script to monitor the CPU usage of a server", agents[1], None, None, None, None, ],
+    ["Create a simple web application using React and Node.js", agents[0], None, None, None, None, ],
+    ["Generate a Python script to perform a sentiment analysis on a given text", agents[2], None, None, None, None, ],
+    ["Write a shell script to automate the backup of a MySQL database", agents[1], None, None, None, None, ],
+    ["Create a simple game in Unreal Engine using C++", agents[3], None, None, None, None, ],
+    ["Generate a Java program to implement a bubble sort algorithm", agents[2], None, None, None, None, ],
+    ["Write a shell script to monitor the memory usage of a server", agents[1], None, None, None, None, ],
+    ["Create a simple web application using Angular and Node.js", agents[0], None, None, None, None, ],
+    ["Generate a Python script to perform a text classification on a given dataset", agents[2], None, None, None, None, ],
+    ["Write a shell script to automate the installation of a software package on a server", agents[1], None, None, None, None, ],
+    ["Create a simple game in Godot using GDScript", agents[3], None, None, None, None, ],
+    ["Generate a Java program to implement a merge sort algorithm", agents[2], None, None, None, None, ],
+    ["Write a shell script to automate the cleanup of temporary files on a server", agents[1], None, None, None, None, ],
+]
 
-    return saved_file_path
 
-def process_download_and_execute(file_urls: List[str], func: Callable[[Optional[List[Any]]], str]) -> Callable[[Any], str]:
-    def wrapper(*args, **kwargs) -> str:
-        processed_histories = []
-
-        for url in file_urls:
-            temp_dir = '/tmp/{}'.format('-'.join(filter(lambda x: x.isalpha(), url)))
-            download_file(url, temp_dir)
-            content = download_file(temp_dir, '/tmp')
-            processed_histories.extend(process_download_results([content]))
-
-        return func(processed_histories, *args, **kwargs)
-
-    return wrapper
-
-def tokenize_markdown(text: str) -> List[Tuple[str, bool]]:
-    lines = filter(bool, map(lambda x: x.strip(), text.split('\n')))
-    histories = []
-    current_chunk = ''
-    was_assistant = False
-
-    for idx, line in enumerate(lines):
-        chunk = '{}. {} '.format(idx + 1, line)
-        first_char = line[0]
-
-        hashtags = ['#', '@']
-        is_hashtag = lambda h: first_char.startswith(h) and h not in current_chunk
-
-        is_starting_line = ('[{' in line) and ('}' in line)
-
-        if is_hashtag(hashtags[was_assistant]):
-            historical_entry = handle_history_line(current_chunk)
-            if historical_entry:
-                histories.append(historical_entry)
-
-            was_assistant = was_assistant ^ (first_char in {'@'})
-            current_chunk = chunk
-        else:
-            current_chunk += chunk
-
-        if is_starting_line and '[inst]' in line:
-            histories.append(handle_history_line(current_chunk))
-            current_chunk = ''
-
-    return histories
-
-def handle_history_line(text: str) -> Optional[Tuple[str, str]]:
-    dash_positions = [-1, -1]
-    for idx, c in enumerate(text):
-        if c == '-':
-            dash_positions[1] = dash_positions[0]
-            dash_positions[0] = idx
-        if c == ' ' and 0 <= dash_positions[0] <= idx <= dash_positions[1]:
-            delimiter = text[dash_positions[0]: idx + 1].strip()
-            return (text[:dash_positions[0]].strip(), delimiter + text[idx + 1:].strip())
-
-    return None
-
-def format_output_context(func: Callable[[Optional[List[Tuple[str, bool]]], str, float, int, float, float], str]) -> Callable[[Optional[List[Tuple[str, bool]]], str], str]:
-    def wrapped(*args, **kwargs) -> str:
-        input_prompt, user_input = args[0][-1], args[1]
-        histories = args[0][:-1]
-
-        sys_prefix = ''
-        human_prefix = '<span style=\'color:blue\'>Human:</span>'
-        ai_prefix = '<span style=\'color:green\'>Assistant:</span>'
-
-        output = '\n\n--- EXPANSION ---\n\n'
-
-        for line in input_prompt.split('\n'):
-            sanitized_line = line.replace('<|endoftext|>', '')
-            output += '{} {}'.format(human_prefix, sanitized_line)
-
-        sep = '\n' + ('-' * 60) + '\n'
-        formatted_user_input = user_input.replace('\n', ' ')
-        output += sep + ai_prefix + ' Question:' + sep + human_prefix + formatted_user_input + '\n\n'
-
-        tokens = tokenize_markdown(formatted_user_input)
-        output += ai_prefix + ' Answer:' + '\n\n'
-
-        return output + func(histories, formatted_user_input, kwargs.pop('temperature'), kwargs.pop('max_new_tokens'), kwargs.pop('top_p'), kwargs.pop('repeat_penalty'))
-
-    return wrapped
-
-async def fetch_and_generate_app(query_iter: Any) -> str:
-    async for token in query_iter:
-        yield token
-
-file_urls = [
-    'https://huggingface.co/spaces/acecalisto3/Mistri/raw/main/agent.py',
-    'https://huggingface.co/spaces/acecalisto3/Mistri/raw/main/alpine.mts',
-    'https://huggingface.co/spaces/acecalisto3/Mistri/raw/main/app.py',
-    'https://huggingface.co/spaces/acecalisto3/Mistri/raw/main/createLlamaPrompt.mts',
-    'https://huggingface.co/spaces/acecalisto3/Mistri/raw/main/createSpace.mts',
-    'https://huggingface.co/spaces/acecalisto3/Mistri/raw/main/cust_types.py',
-    'https://huggingface.co/spaces/acecalisto3/Mistri/raw/main/daisy.mts',
-    'https://huggingface.co/spaces/acecalisto3/Mistri/raw/main/dl.sh',
-    'https://huggingface.co/spaces/acecalisto3/Mistri/raw/main/docker.mts',
-    'https://huggingface.co/spaces/acecalisto3/Mistri/raw/main/generateFiles.mts',
-    'https://huggingface.co/spaces/acecalisto3/Mistri/raw/main/getGradioApp.mts',
-    'https://huggingface.co/spaces/acecalisto3/Mistri/raw/main/getReactApp.mts',
-    'https://huggingface.co/spaces/acecalisto3/Mistri/raw/main/getStreamlitApp.mts',
-    'https://huggingface.co/spaces/acecalisto3/Mistri/raw/main/getWebApp.mts',
-    'https://huggingface.co/spaces/acecalisto3/Mistri/raw/main/gradioDoc.mts',
-    'https://huggingface.co/spaces/acecalisto3/Mistri/raw/main/index.mts',
-    'https://huggingface.co/spaces/acecalisto3/Mistri/raw/main/isPythonOrGradioAppPrompt.mts',
-    'https://huggingface.co/spaces/acecalisto3/Mistri/raw/main/isReactAppPrompt.mts',
-    'https://huggingface.co/spaces/acecalisto3/Mistri/raw/main/isStreamlitAppPrompt.mts',
-    'https://huggingface.co/spaces/acecalisto3/Mistri/raw/main/parseTutorial.mts',
-    'https://huggingface.co/spaces/acecalisto3/Mistri/raw/main/streamlitDoc.mts',
-    'https://huggingface.co/spaces/acecalisto3/Mistri/raw/main/types.mts',
-    'https://huggingface.co/spaces/acecalisto3/Mistri/raw/main/typescript.mts',
-]
+gr.ChatInterface(
+    fn=generate,
+    chatbot=gr.Chatbot(show_label=False, show_share_button=False, show_copy_button=True, likeable=True, layout="panel"),
+    additional_inputs=additional_inputs,
+    title="Mixtral 46.7B",
+    examples=examples,
+    concurrency_limit=20,
+).launch(show_api=False)
+
 
-def execute_mistri_script(_: List[Tuple[str, bool]], __: str) -> str:
-    """Pass function definition"""
-    return ''
-
-execution_fn = process_download_and_execute(file_urls, execute_mistri_script)
-
-execution_fn = process_download_and_execute(file_urls, execute_mistri_script)
-gradedio_interface = gr.Interface(execution_fn,
-                             input_types=['text'],
-                             output_types=['text'],
-                             input_fields=[
-                                 gr.inputs.Textbox(label='Input')],
-                             output_field=gr.outputs.Textbox(label='Output'))
-async def main():
-    await gradio_interface.launch(inline=True)
-asyncio.run(main())