Find-it-Auto / app.py
Omnibus's picture
Update app.py
ec90841 verified
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()
'''