Spaces:
Running
Running
import gradio as gr | |
import urllib.request | |
import requests | |
import bs4 | |
import lxml | |
import os | |
#import subprocess | |
from huggingface_hub import InferenceClient,HfApi | |
import random | |
import json | |
import datetime | |
#from query import tasks | |
from prompts import ( | |
FINDER, | |
COMPRESS_HISTORY_PROMPT, | |
COMPRESS_DATA_PROMPT, | |
COMPRESS_DATA_PROMPT_SMALL, | |
LOG_PROMPT, | |
LOG_RESPONSE, | |
PREFIX, | |
TASK_PROMPT, | |
) | |
api=HfApi() | |
client = InferenceClient( | |
"mistralai/Mixtral-8x7B-Instruct-v0.1" | |
) | |
def parse_action(string: str): | |
print("PARSING:") | |
print(string) | |
assert string.startswith("action:") | |
idx = string.find("action_input=") | |
print(idx) | |
if idx == -1: | |
print ("idx == -1") | |
print (string[8:]) | |
return string[8:], None | |
print ("last return:") | |
print (string[8 : idx - 1]) | |
print (string[idx + 13 :].strip("'").strip('"')) | |
return string[8 : idx - 1], string[idx + 13 :].strip("'").strip('"') | |
VERBOSE = True | |
MAX_HISTORY = 100 | |
MAX_DATA = 20000 | |
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, | |
seed, | |
purpose, | |
**prompt_kwargs, | |
): | |
timestamp=datetime.datetime.now() | |
print(seed) | |
generate_kwargs = dict( | |
temperature=0.9, | |
max_new_tokens=max_tokens, | |
top_p=0.95, | |
repetition_penalty=1.0, | |
do_sample=True, | |
seed=seed, | |
) | |
content = PREFIX.format( | |
timestamp=timestamp, | |
purpose=purpose, | |
) + 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}', **prompt_kwargs['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 | |
#yield resp | |
if VERBOSE: | |
print(LOG_RESPONSE.format(resp)) | |
return resp | |
def compress_data(c,purpose, task, history, result): | |
seed=random.randint(1,1000000000) | |
print (c) | |
#tot=len(purpose) | |
#print(tot) | |
divr=int(c)/MAX_DATA | |
divi=int(divr)+1 if divr != int(divr) else int(divr) | |
chunk = int(int(c)/divr) | |
print(f'chunk:: {chunk}') | |
print(f'divr:: {divr}') | |
print (f'divi:: {divi}') | |
out = [] | |
#out="" | |
s=0 | |
e=chunk | |
print(f'e:: {e}') | |
new_history="" | |
task = f'Compile this data to fulfill the task: {task}, and complete the purpose: {purpose}\n' | |
for z in range(divi): | |
print(f's:e :: {s}:{e}') | |
hist = history[s:e] | |
resp = run_gpt( | |
COMPRESS_DATA_PROMPT, | |
stop_tokens=["observation:", "task:", "action:", "thought:"], | |
max_tokens=2048, | |
seed=seed, | |
purpose=purpose, | |
task=task, | |
knowledge=new_history, | |
history=hist, | |
).strip('\n') | |
new_history = resp | |
print (resp) | |
out+=resp | |
e=e+chunk | |
s=s+chunk | |
''' | |
resp = run_gpt( | |
COMPRESS_DATA_PROMPT, | |
stop_tokens=["observation:", "task:", "action:", "thought:"], | |
max_tokens=2048, | |
seed=seed, | |
purpose=purpose, | |
task=task, | |
knowledge=new_history, | |
history=result, | |
) | |
''' | |
print ("final" + resp) | |
history = "result: {}\n".format(resp) | |
return history | |
def compress_history(purpose, task, history): | |
resp = run_gpt( | |
COMPRESS_HISTORY_PROMPT, | |
stop_tokens=["observation:", "task:", "action:", "thought:"], | |
max_tokens=1024, | |
seed=random.randint(1,1000000000), | |
purpose=purpose, | |
task=task, | |
history=history, | |
) | |
history = "observation: {}\n".format(resp) | |
return history | |
def call_main(purpose, task, history, action_input, result): | |
resp = run_gpt( | |
FINDER, | |
stop_tokens=["observation:", "task:"], | |
max_tokens=2048, | |
seed=random.randint(1,1000000000), | |
purpose=purpose, | |
task=task, | |
history=history, | |
) | |
lines = resp.strip().strip("\n").split("\n") | |
#history="" | |
for line in lines: | |
if line == "": | |
continue | |
if line.startswith("thought: "): | |
history += "{}\n".format(line) | |
if line.startswith("action: "): | |
action_name, action_input = parse_action(line) | |
print(f'ACTION::{action_name} -- INPUT :: {action_input}') | |
#history += "{}\n".format(line) | |
return action_name, action_input, history, task, result | |
else: | |
pass | |
#history += "{}\n".format(line) | |
#assert False, "unknown action: {}".format(line) | |
#return "UPDATE-TASK", None, history, task | |
if "VERBOSE": | |
print(history) | |
return "MAIN", None, history, task, result | |
def call_set_task(purpose, task, history, action_input, result): | |
task = run_gpt( | |
TASK_PROMPT, | |
stop_tokens=[], | |
max_tokens=1024, | |
seed=random.randint(1,1000000000), | |
purpose=purpose, | |
task=task, | |
history=history, | |
).strip("\n") | |
history += "observation: task has been updated to: {}\n".format(task) | |
return "MAIN", None, history, task, result | |
########################################################### | |
def search_all(url): | |
source="" | |
return source | |
def find_all(purpose,task,history, url, result): | |
return_list=[] | |
print (url) | |
print (f"trying URL:: {url}") | |
try: | |
if url != "" and url != None: | |
out = [] | |
source = requests.get(url) | |
if source.status_code ==200: | |
soup = bs4.BeautifulSoup(source.content,'lxml') | |
rawp=(f'RAW TEXT RETURNED: {soup.text}') | |
cnt=0 | |
cnt+=len(rawp) | |
out.append(rawp) | |
out.append("HTML fragments: ") | |
q=("a","p","span","content","article") | |
for p in soup.find_all("a"): | |
out.append([{"LINK TITLE":p.get('title'),"URL":p.get('href'),"STRING":p.string}]) | |
c=0 | |
out = str(out) | |
rl = len(out) | |
print(f'rl:: {rl}') | |
for i in str(out): | |
if i == " " or i=="," or i=="\n" or i=="/" or i=="." or i=="<": | |
c +=1 | |
print (f'c:: {c}') | |
if c > MAX_HISTORY: | |
print("compressing...") | |
rawp = compress_data(c,purpose,task,out,result) | |
result += rawp | |
else: | |
rawp = out | |
#print (rawp) | |
#print (f'out:: {out}') | |
history += "observation: the search results are:\n {}\n".format(rawp) | |
task = "compile report or complete?" | |
return "MAIN", None, history, task, result | |
else: | |
history += f"observation: That URL string returned an error: {source.status_code}, I should try a different URL string\n" | |
#result="Still Working..." | |
return "MAIN", None, history, task, result | |
else: | |
history += "observation: An Error occured\nI need to trigger a search using the following syntax:\naction: SCRAPE_WEBSITE action_input=URL\n" | |
return "MAIN", None, history, task, result | |
except Exception as e: | |
print (e) | |
history += "observation: I need to trigger a search using the following syntax:\naction: SCRAPE_WEBSITE action_input=URL\n" | |
return "MAIN", None, history, task, result | |
#else: | |
# history = "observation: The search query I used did not return a valid response" | |
return "MAIN", None, history, task, result | |
################################# | |
NAME_TO_FUNC = { | |
"MAIN": call_main, | |
"UPDATE-TASK": call_set_task, | |
"SEARCH_ENGINE": find_all, | |
"SCRAPE_WEBSITE": find_all, | |
} | |
def run_action(purpose, task, history, action_name, action_input,result): | |
if "COMPLETE" in action_name: | |
print("Complete - Exiting") | |
#exit(0) | |
return "COMPLETE", None, history, task, result | |
# 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) | |
if action_name in NAME_TO_FUNC: | |
assert action_name in NAME_TO_FUNC | |
print(f"RUN: {action_name} ACTION_INPUT: {action_input}") | |
return NAME_TO_FUNC[action_name](purpose, task, history, action_input, result) | |
else: | |
history += "observation: The TOOL I tried to use returned an error, I need to select a tool from: (UPDATE-TASK, SEARCH_ENGINE, SCRAPE_WEBSITE, COMPLETE)\n" | |
return "MAIN", None, history, task, result | |
def run(purpose,history): | |
yield "Searching..." | |
task=None | |
result="" | |
#history = "" | |
if not history: | |
history = "" | |
else: | |
history=str(history) | |
action_name = "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, result = run_action( | |
purpose, | |
task, | |
history, | |
action_name, | |
action_input, | |
result | |
) | |
if not result: | |
yield "More Searching..." | |
else: | |
yield result | |
if action_name == "COMPLETE": | |
break | |
return result | |
examples =[ | |
"What is the current weather in Florida?", | |
"Find breaking news about Texas", | |
"Find the best deals on flippers for scuba diving", | |
"Teach me to fly a helicopter" | |
] | |
gr.ChatInterface( | |
fn=run, | |
chatbot=gr.Chatbot(show_label=False, show_share_button=True, show_copy_button=True, likeable=True, layout="panel", height="800px"), | |
title="Mixtral 46.7B Powered <br> Search", | |
examples=examples, | |
concurrency_limit=20, | |
).launch() | |
''' | |
with gr.Blocks() as app: | |
with gr.Row(): | |
with gr.Column(scale=1): | |
inp = gr.Textbox() | |
with gr.Column(scale=2): | |
q = gr.Textbox(value="p") | |
with gr.Column(scale=2): | |
num = gr.Textbox() | |
with gr.Row(): | |
all_btn = gr.Button("Load") | |
find_btn = gr.Button("Find") | |
with gr.Row(): | |
rawp = gr.JSON() | |
outp = gr.JSON() | |
outl = gr.Textbox() | |
all_btn.click(find_all,[inp,q,num],[rawp]) | |
find_btn.click(find_it,[inp,q,num],[outp,outl]) | |
app.launch() | |
''' |