|
from abc import abstractmethod |
|
import uuid |
|
from text2vec import semantic_search |
|
from utils import ( |
|
get_relevant_history, |
|
load_knowledge_base_qa, |
|
load_knowledge_base_UnstructuredFile, |
|
get_embedding, |
|
extract, |
|
) |
|
import json |
|
from typing import Dict, List |
|
import os |
|
from googleapiclient.discovery import build |
|
import requests |
|
from selenium import webdriver |
|
from selenium.webdriver.common.by import By |
|
from selenium.webdriver.support.ui import WebDriverWait |
|
from selenium.webdriver.support import expected_conditions as EC |
|
from bs4 import BeautifulSoup |
|
import base64 |
|
import re |
|
from datetime import datetime, timedelta |
|
from typing import Tuple, List, Any, Dict |
|
from email.mime.text import MIMEText |
|
from email.mime.multipart import MIMEMultipart |
|
from google.auth.transport.requests import Request |
|
from google.oauth2.credentials import Credentials |
|
from google_auth_oauthlib.flow import InstalledAppFlow |
|
from googleapiclient.discovery import build |
|
from googleapiclient.errors import HttpError |
|
from tqdm import tqdm |
|
|
|
class ToolComponent: |
|
def __init__(self): |
|
pass |
|
|
|
@abstractmethod |
|
def func(self): |
|
pass |
|
|
|
class KnowledgeBaseComponent(ToolComponent): |
|
""" |
|
Inject knowledge base |
|
top_k : Top_k with the highest matching degree |
|
type : "QA" or others |
|
knowledge_base(json_path) : knowledge_base_path |
|
""" |
|
def __init__(self, top_k, type, knowledge_base): |
|
super().__init__() |
|
self.top_k = top_k |
|
self.type = type |
|
self.knowledge_base = knowledge_base |
|
|
|
if self.type == "QA": |
|
( |
|
self.kb_embeddings, |
|
self.kb_questions, |
|
self.kb_answers, |
|
self.kb_chunks, |
|
) = load_knowledge_base_qa(self.knowledge_base) |
|
else: |
|
self.kb_embeddings, self.kb_chunks = load_knowledge_base_UnstructuredFile( |
|
self.knowledge_base |
|
) |
|
|
|
def func(self, agent): |
|
query = ( |
|
agent.long_term_memory[-1]["content"] |
|
if len(agent.long_term_memory) > 0 |
|
else "" |
|
) |
|
knowledge = "" |
|
query = extract(query, "query") |
|
query_embedding = get_embedding(query) |
|
hits = semantic_search(query_embedding, self.kb_embeddings, top_k=50) |
|
hits = hits[0] |
|
temp = [] |
|
if self.type == "QA": |
|
for hit in hits: |
|
matching_idx = hit["corpus_id"] |
|
if self.kb_chunks[matching_idx] in temp: |
|
pass |
|
else: |
|
knowledge = ( |
|
knowledge |
|
+ f"question:{self.kb_questions[matching_idx]},answer:{self.kb_answers[matching_idx]}\n\n" |
|
) |
|
temp.append(self.kb_answers[matching_idx]) |
|
if len(temp) == 1: |
|
break |
|
print(hits[0]["score"]) |
|
score = hits[0]["score"] |
|
if score < 0.5: |
|
return {"prompt": "No matching knowledge base"} |
|
else: |
|
return {"prompt": "The relevant content is: " + knowledge + "\n"} |
|
else: |
|
for hit in hits: |
|
matching_idx = hit["corpus_id"] |
|
if self.kb_chunks[matching_idx] in temp: |
|
pass |
|
else: |
|
knowledge = knowledge + f"{self.kb_answers[matching_idx]}\n\n" |
|
temp.append(self.kb_answers[matching_idx]) |
|
if len(temp) == self.top_k: |
|
break |
|
print(hits[0]["score"]) |
|
score = hits[0]["score"] |
|
if score < 0.5: |
|
return {"prompt": "No matching knowledge base"} |
|
else: |
|
print(knowledge) |
|
return {"prompt": "The relevant content is: " + knowledge + "\n"} |
|
|
|
|
|
class StaticComponent(ToolComponent): |
|
"Return static response" |
|
def __init__(self, output): |
|
super().__init__() |
|
self.output = output |
|
|
|
def func(self, agent): |
|
outputdict = {"response": self.output} |
|
return outputdict |
|
|
|
|
|
class ExtractComponent(ToolComponent): |
|
""" |
|
Extract keywords based on the current scene and store them in the environment |
|
extract_words(list) : Keywords to be extracted |
|
system_prompt & last_prompt : Prompt to extract keywords |
|
""" |
|
def __init__( |
|
self, |
|
extract_words, |
|
system_prompt, |
|
last_prompt=None, |
|
): |
|
super().__init__() |
|
self.extract_words = extract_words |
|
self.system_prompt = system_prompt |
|
self.default_prompt = ( |
|
"Please strictly adhere to the following format for outputting:\n" |
|
) |
|
for extract_word in extract_words: |
|
self.default_prompt += ( |
|
f"<{extract_word}> the content you need to extract </{extract_word}>" |
|
) |
|
self.last_prompt = last_prompt if last_prompt else self.default_prompt |
|
|
|
def func(self, agent): |
|
response = agent.LLM.get_response( |
|
agent.long_term_memory, |
|
self.system_prompt, |
|
self.last_prompt, |
|
stream=False, |
|
) |
|
for extract_word in self.extract_words: |
|
key = extract(response, extract_word) |
|
key = key if key else response |
|
agent.environment.shared_memory[extract_word] = key |
|
|
|
return {} |
|
|
|
|
|
"""Search sources: chatgpt/search engines/specific search sources/can even be multimodal (if it comes to clothing)""" |
|
|
|
|
|
class WebSearchComponent(ToolComponent): |
|
"""search engines""" |
|
|
|
__ENGINE_NAME__: List = ["google", "bing"] |
|
|
|
def __init__(self, engine_name: str, api: Dict): |
|
""" |
|
:param engine_name: The name of the search engine used |
|
:param api: Pass in a dictionary, such as {"bing":"key1", "google":"key2", ...}, of course each value can also be a list, or more complicated |
|
""" |
|
super(WebSearchComponent, self).__init__() |
|
"""Determine whether the key and engine_name of the api are legal""" |
|
|
|
assert engine_name in WebSearchComponent.__ENGINE_NAME__ |
|
for api_name in api: |
|
assert api_name in WebSearchComponent.__ENGINE_NAME__ |
|
|
|
self.api = api |
|
self.engine_name = engine_name |
|
|
|
self.search: Dict = {"bing": self._bing_search, "google": self._google_search} |
|
|
|
def _bing_search(self, query: str, **kwargs): |
|
"""Initialize search hyperparameters""" |
|
subscription_key = self.api["bing"] |
|
search_url = "https://api.bing.microsoft.com/v7.0/search" |
|
headers = {"Ocp-Apim-Subscription-Key": subscription_key} |
|
params = { |
|
"q": query, |
|
"textDecorations": True, |
|
"textFormat": "HTML", |
|
"count": 10, |
|
} |
|
"""start searching""" |
|
response = requests.get(search_url, headers=headers, params=params) |
|
response.raise_for_status() |
|
results = response.json()["webPages"]["value"] |
|
"""execute""" |
|
metadata_results = [] |
|
for result in results: |
|
metadata_result = { |
|
"snippet": result["snippet"], |
|
"title": result["name"], |
|
"link": result["url"], |
|
} |
|
metadata_results.append(metadata_result) |
|
return {"meta data": metadata_results} |
|
|
|
def _google_search(self, query: str, **kwargs): |
|
"""Initialize search hyperparameters""" |
|
api_key = self.api[self.engine_name]["api_key"] |
|
cse_id = self.api[self.engine_name]["cse_id"] |
|
service = build("customsearch", "v1", developerKey=api_key) |
|
"""start searching""" |
|
results = ( |
|
service.cse().list(q=query, cx=cse_id, num=10, **kwargs).execute()["items"] |
|
) |
|
"""execute""" |
|
metadata_results = [] |
|
for result in results: |
|
metadata_result = { |
|
"snippet": result["snippet"], |
|
"title": result["title"], |
|
"link": result["link"], |
|
} |
|
metadata_results.append(metadata_result) |
|
return {"meta data": metadata_results} |
|
|
|
def func(self, agent, **kwargs) -> Dict: |
|
query = ( |
|
agent.long_term_memory[-1]["content"] |
|
if len(agent.long_term_memory) > 0 |
|
else " " |
|
) |
|
response = agent.LLM.get_response( |
|
None, |
|
system_prompt=f"Please analyze the provided conversation and identify keywords that can be used for a search engine query. Format the output as <keywords>extracted keywords</keywords>:\nConversation:\n{query}", |
|
stream=False, |
|
) |
|
response = extract(response, "keywords") |
|
query = response if response else query |
|
|
|
search_results = self.search[self.engine_name](query=query, **kwargs) |
|
information = "" |
|
for i in search_results["meta data"][:5]: |
|
information += i["snippet"] |
|
return { |
|
"prompt": "You can refer to the following information to reply:\n" |
|
+ information |
|
} |
|
|
|
def convert_search_engine_to(self, engine_name): |
|
assert engine_name in WebSearchComponent.__ENGINE_NAME__ |
|
self.engine_name = engine_name |
|
|
|
|
|
class WebCrawlComponent(ToolComponent): |
|
"""Open a single web page for crawling""" |
|
|
|
def __init__(self): |
|
super(WebCrawlComponent, self).__init__() |
|
|
|
def func(self, agent_dict) -> Dict: |
|
url = agent_dict["url"] |
|
print(f"crawling {url} ......") |
|
content = "" |
|
"""Crawling content from url may need to be carried out according to different websites, such as wiki, baidu, zhihu, etc.""" |
|
driver = webdriver.Chrome() |
|
try: |
|
"""open url""" |
|
driver.get(url) |
|
|
|
"""wait 20 second""" |
|
wait = WebDriverWait(driver, 20) |
|
wait.until(EC.presence_of_element_located((By.TAG_NAME, "body"))) |
|
|
|
"""crawl code""" |
|
page_source = driver.page_source |
|
|
|
"""parse""" |
|
soup = BeautifulSoup(page_source, "html.parser") |
|
|
|
"""concatenate""" |
|
for paragraph in soup.find_all("p"): |
|
content = f"{content}\n{paragraph.get_text()}" |
|
except Exception as e: |
|
print("Error:", e) |
|
finally: |
|
"""quit""" |
|
driver.quit() |
|
return {"content": content.strip()} |
|
|
|
|
|
class MailComponent(ToolComponent): |
|
__VALID_ACTION__ = ["read", "send"] |
|
|
|
def __init__( |
|
self, cfg_file: str, default_action: str = "read", name: str = "e-mail" |
|
): |
|
"""'../config/google_mail.json'""" |
|
super(MailComponent, self).__init__(name) |
|
self.name = name |
|
assert ( |
|
default_action.lower() in self.__VALID_ACTION__ |
|
), f"Action `{default_action}` is not allowed! The valid action is in `{self.__VALID_ACTION__}`" |
|
self.action = default_action.lower() |
|
self.credential = self._login(cfg_file) |
|
|
|
def _login(self, cfg_file: str): |
|
SCOPES = [ |
|
"https://www.googleapis.com/auth/gmail.readonly", |
|
"https://www.googleapis.com/auth/gmail.send", |
|
] |
|
creds = None |
|
if os.path.exists("token.json"): |
|
print("Login Successfully!") |
|
creds = Credentials.from_authorized_user_file("token.json", SCOPES) |
|
if not creds or not creds.valid: |
|
print("Please authorize in an open browser.") |
|
if creds and creds.expired and creds.refresh_token: |
|
creds.refresh(Request()) |
|
else: |
|
flow = InstalledAppFlow.from_client_secrets_file(cfg_file, SCOPES) |
|
creds = flow.run_local_server(port=0) |
|
|
|
with open("token.json", "w") as token: |
|
token.write(creds.to_json()) |
|
return creds |
|
|
|
def _read(self, mail_dict: dict): |
|
credential = self.credential |
|
state = mail_dict["state"] if "state" in mail_dict else None |
|
time_between = ( |
|
mail_dict["time_between"] if "time_between" in mail_dict else None |
|
) |
|
sender_mail = mail_dict["sender_mail"] if "sender_mail" in mail_dict else None |
|
only_both = mail_dict["only_both"] if "only_both" in mail_dict else False |
|
order_by_time = ( |
|
mail_dict["order_by_time"] if "order_by_time" in mail_dict else "descend" |
|
) |
|
include_word = ( |
|
mail_dict["include_word"] if "include_word" in mail_dict else None |
|
) |
|
exclude_word = ( |
|
mail_dict["exclude_word"] if "exclude_word" in mail_dict else None |
|
) |
|
MAX_SEARCH_CNT = ( |
|
mail_dict["MAX_SEARCH_CNT"] if "MAX_SEARCH_CNT" in mail_dict else 50 |
|
) |
|
number = mail_dict["number"] if "number" in mail_dict else 10 |
|
if state is None: |
|
state = "all" |
|
if time_between is not None: |
|
assert isinstance(time_between, tuple) |
|
assert len(time_between) == 2 |
|
assert state in ["all", "unread", "read", "sent"] |
|
if only_both: |
|
assert sender_mail is not None |
|
if sender_mail is not None: |
|
assert isinstance(sender_mail, str) |
|
assert credential |
|
assert order_by_time in ["descend", "ascend"] |
|
|
|
def generate_query(): |
|
query = "" |
|
if state in ["unread", "read"]: |
|
query = f"is:{state}" |
|
if state in ["sent"]: |
|
query = f"in:{state}" |
|
if only_both: |
|
query = f"{query} from:{sender_mail} OR to:{sender_mail}" |
|
if sender_mail is not None and not only_both: |
|
query = f"{query} from:({sender_mail})" |
|
if include_word is not None: |
|
query = f"{query} {include_word}" |
|
if exclude_word is not None: |
|
query = f"{query} -{exclude_word}" |
|
if time_between is not None: |
|
TIME_FORMAT = "%Y/%m/%d" |
|
t1, t2 = time_between |
|
if t1 == "now": |
|
t1 = datetime.now().strftime(TIME_FORMAT) |
|
if t2 == "now": |
|
t2 = datetime.now().strftime(TIME_FORMAT) |
|
if isinstance(t1, str) and isinstance(t2, str): |
|
t1 = datetime.strptime(t1, TIME_FORMAT) |
|
t2 = datetime.strptime(t2, TIME_FORMAT) |
|
elif isinstance(t1, str) and isinstance(t2, int): |
|
t1 = datetime.strptime(t1, TIME_FORMAT) |
|
t2 = t1 + timedelta(days=t2) |
|
elif isinstance(t1, int) and isinstance(t2, str): |
|
t2 = datetime.strptime(t2, TIME_FORMAT) |
|
t1 = t2 + timedelta(days=t1) |
|
else: |
|
assert False, "invalid time" |
|
if t1 > t2: |
|
t1, t2 = t2, t1 |
|
query = f"{query} after:{t1.strftime(TIME_FORMAT)} before:{t2.strftime(TIME_FORMAT)}" |
|
return query.strip() |
|
|
|
def sort_by_time(data: List[Dict]): |
|
if order_by_time == "descend": |
|
reverse = True |
|
else: |
|
reverse = False |
|
sorted_data = sorted( |
|
data, |
|
key=lambda x: datetime.strptime(x["time"], "%Y-%m-%d %H:%M:%S"), |
|
reverse=reverse, |
|
) |
|
return sorted_data |
|
|
|
try: |
|
service = build("gmail", "v1", credentials=credential) |
|
results = ( |
|
service.users() |
|
.messages() |
|
.list(userId="me", labelIds=["INBOX"], q=generate_query()) |
|
.execute() |
|
) |
|
|
|
messages = results.get("messages", []) |
|
email_data = list() |
|
|
|
if not messages: |
|
print("No eligible emails.") |
|
return None |
|
else: |
|
pbar = tqdm(total=min(MAX_SEARCH_CNT, len(messages))) |
|
for cnt, message in enumerate(messages): |
|
pbar.update(1) |
|
if cnt >= MAX_SEARCH_CNT: |
|
break |
|
msg = ( |
|
service.users() |
|
.messages() |
|
.get( |
|
userId="me", |
|
id=message["id"], |
|
format="full", |
|
metadataHeaders=None, |
|
) |
|
.execute() |
|
) |
|
|
|
subject = "" |
|
for header in msg["payload"]["headers"]: |
|
if header["name"] == "Subject": |
|
subject = header["value"] |
|
break |
|
|
|
sender = "" |
|
for header in msg["payload"]["headers"]: |
|
if header["name"] == "From": |
|
sender = re.findall( |
|
r"\b[\w\.-]+@[\w\.-]+\.\w+\b", header["value"] |
|
)[0] |
|
break |
|
body = "" |
|
if "parts" in msg["payload"]: |
|
for part in msg["payload"]["parts"]: |
|
if part["mimeType"] == "text/plain": |
|
data = part["body"]["data"] |
|
body = base64.urlsafe_b64decode(data).decode("utf-8") |
|
break |
|
|
|
email_info = { |
|
"sender": sender, |
|
"time": datetime.fromtimestamp( |
|
int(msg["internalDate"]) / 1000 |
|
).strftime("%Y-%m-%d %H:%M:%S"), |
|
"subject": subject, |
|
"body": body, |
|
} |
|
email_data.append(email_info) |
|
pbar.close() |
|
email_data = sort_by_time(email_data)[0:number] |
|
return {"results": email_data} |
|
except Exception as e: |
|
print(e) |
|
return None |
|
|
|
def _send(self, mail_dict: dict): |
|
recipient_mail = mail_dict["recipient_mail"] |
|
subject = mail_dict["subject"] |
|
body = mail_dict["body"] |
|
credential = self.credential |
|
service = build("gmail", "v1", credentials=credential) |
|
|
|
message = MIMEMultipart() |
|
message["to"] = recipient_mail |
|
message["subject"] = subject |
|
|
|
message.attach(MIMEText(body, "plain")) |
|
|
|
raw_message = base64.urlsafe_b64encode(message.as_bytes()).decode("utf-8") |
|
try: |
|
message = ( |
|
service.users() |
|
.messages() |
|
.send(userId="me", body={"raw": raw_message}) |
|
.execute() |
|
) |
|
return {"state": True} |
|
except HttpError as error: |
|
print(error) |
|
return {"state": False} |
|
|
|
def func(self, mail_dict: dict): |
|
if "action" in mail_dict: |
|
assert mail_dict["action"].lower() in self.__VALID_ACTION__ |
|
self.action = mail_dict["action"] |
|
functions = {"read": self._read, "send": self._send} |
|
return functions[self.action](mail_dict) |
|
|
|
def convert_action_to(self, action_name: str): |
|
assert ( |
|
action_name.lower() in self.__VALID_ACTION__ |
|
), f"Action `{action_name}` is not allowed! The valid action is in `{self.__VALID_ACTION__}`" |
|
self.action = action_name.lower() |
|
|
|
|
|
class WeatherComponet(ToolComponent): |
|
def __init__(self, api_key, name="weather", TIME_FORMAT="%Y-%m-%d"): |
|
super(WeatherComponet, self).__init__(name) |
|
self.name = name |
|
self.TIME_FORMAT = TIME_FORMAT |
|
self.api_key = api_key |
|
|
|
def _parse(self, data): |
|
dict_data: dict = {} |
|
for item in data["data"]: |
|
date = item["datetime"] |
|
dict_data[date] = {} |
|
if "weather" in item: |
|
dict_data[date]["description"] = item["weather"]["description"] |
|
mapping = { |
|
"temp": "temperature", |
|
"max_temp": "max_temperature", |
|
"min_temp": "min_temperature", |
|
"precip": "accumulated_precipitation", |
|
} |
|
for key in ["temp", "max_temp", "min_temp", "precip"]: |
|
if key in item: |
|
dict_data[date][mapping[key]] = item[key] |
|
return dict_data |
|
|
|
def _query(self, city_name, country_code, start_date, end_date): |
|
"""https://www.weatherbit.io/api/historical-weather-daily""" |
|
|
|
if start_date == datetime.strftime( |
|
datetime.now(), self.TIME_FORMAT |
|
) and end_date == datetime.strftime( |
|
datetime.now() + timedelta(days=1), self.TIME_FORMAT |
|
): |
|
"""today""" |
|
url = f"https://api.weatherbit.io/v2.0/current?city={city_name}&country={country_code}&key={self.api_key}" |
|
else: |
|
url = f"https://api.weatherbit.io/v2.0/history/daily?&city={city_name}&country={country_code}&start_date={start_date}&end_date={end_date}&key={self.api_key}" |
|
response = requests.get(url) |
|
data = response.json() |
|
return self._parse(data) |
|
|
|
def func(self, weather_dict: Dict) -> Dict: |
|
TIME_FORMAT = self.TIME_FORMAT |
|
|
|
city_name = weather_dict["city_name"] |
|
|
|
country_code = weather_dict["country_code"] |
|
|
|
start_date = datetime.strftime( |
|
datetime.strptime(weather_dict["start_date"], self.TIME_FORMAT), |
|
self.TIME_FORMAT, |
|
) |
|
end_date = weather_dict["end_date"] if "end_date" in weather_dict else None |
|
if end_date is None: |
|
end_date = datetime.strftime( |
|
datetime.strptime(start_date, TIME_FORMAT) + timedelta(days=-1), |
|
TIME_FORMAT, |
|
) |
|
else: |
|
end_date = datetime.strftime( |
|
datetime.strptime(weather_dict["end_date"], self.TIME_FORMAT), |
|
self.TIME_FORMAT, |
|
) |
|
if datetime.strptime(start_date, TIME_FORMAT) > datetime.strptime( |
|
end_date, TIME_FORMAT |
|
): |
|
start_date, end_date = end_date, start_date |
|
assert start_date != end_date |
|
return self._query(city_name, country_code, start_date, end_date) |
|
|
|
|
|
class TranslateComponent(ToolComponent): |
|
__SUPPORT_LANGUAGE__ = [ |
|
"af", |
|
"am", |
|
"ar", |
|
"as", |
|
"az", |
|
"ba", |
|
"bg", |
|
"bn", |
|
"bo", |
|
"bs", |
|
"ca", |
|
"cs", |
|
"cy", |
|
"da", |
|
"de", |
|
"dsb", |
|
"dv", |
|
"el", |
|
"en", |
|
"es", |
|
"et", |
|
"eu", |
|
"fa", |
|
"fi", |
|
"fil", |
|
"fj", |
|
"fo", |
|
"fr", |
|
"fr-CA", |
|
"ga", |
|
"gl", |
|
"gom", |
|
"gu", |
|
"ha", |
|
"he", |
|
"hi", |
|
"hr", |
|
"hsb", |
|
"ht", |
|
"hu", |
|
"hy", |
|
"id", |
|
"ig", |
|
"ikt", |
|
"is", |
|
"it", |
|
"iu", |
|
"iu-Latn", |
|
"ja", |
|
"ka", |
|
"kk", |
|
"km", |
|
"kmr", |
|
"kn", |
|
"ko", |
|
"ku", |
|
"ky", |
|
"ln", |
|
"lo", |
|
"lt", |
|
"lug", |
|
"lv", |
|
"lzh", |
|
"mai", |
|
"mg", |
|
"mi", |
|
"mk", |
|
"ml", |
|
"mn-Cyrl", |
|
"mn-Mong", |
|
"mr", |
|
"ms", |
|
"mt", |
|
"mww", |
|
"my", |
|
"nb", |
|
"ne", |
|
"nl", |
|
"nso", |
|
"nya", |
|
"or", |
|
"otq", |
|
"pa", |
|
"pl", |
|
"prs", |
|
"ps", |
|
"pt", |
|
"pt-PT", |
|
"ro", |
|
"ru", |
|
"run", |
|
"rw", |
|
"sd", |
|
"si", |
|
"sk", |
|
"sl", |
|
"sm", |
|
"sn", |
|
"so", |
|
"sq", |
|
"sr-Cyrl", |
|
"sr-Latn", |
|
"st", |
|
"sv", |
|
"sw", |
|
"ta", |
|
"te", |
|
"th", |
|
"ti", |
|
"tk", |
|
"tlh-Latn", |
|
"tlh-Piqd", |
|
"tn", |
|
"to", |
|
"tr", |
|
"tt", |
|
"ty", |
|
"ug", |
|
"uk", |
|
"ur", |
|
"uz", |
|
"vi", |
|
"xh", |
|
"yo", |
|
"yua", |
|
"yue", |
|
"zh-Hans", |
|
"zh-Hant", |
|
"zu", |
|
] |
|
|
|
def __init__( |
|
self, api_key, location, default_target_language="zh-cn", name="translate" |
|
): |
|
super(TranslateComponent, self).__init__(name) |
|
self.name = name |
|
self.api_key = api_key |
|
self.location = location |
|
self.default_target_language = default_target_language |
|
|
|
def func(self, translate_dict: Dict) -> Dict: |
|
content = translate_dict["content"] |
|
target_language = self.default_target_language |
|
if "target_language" in translate_dict: |
|
target_language = translate_dict["target_language"] |
|
assert ( |
|
target_language in self.__SUPPORT_LANGUAGE__ |
|
), f"language `{target_language}` is not supported." |
|
|
|
endpoint = "https://api.cognitive.microsofttranslator.com" |
|
|
|
path = "/translate" |
|
constructed_url = endpoint + path |
|
|
|
params = {"api-version": "3.0", "to": target_language} |
|
|
|
headers = { |
|
"Ocp-Apim-Subscription-Key": self.api_key, |
|
"Ocp-Apim-Subscription-Region": self.location, |
|
"Content-type": "application/json", |
|
"X-ClientTraceId": str(uuid.uuid4()), |
|
} |
|
|
|
body = [{"text": content}] |
|
|
|
request = requests.post( |
|
constructed_url, params=params, headers=headers, json=body |
|
) |
|
response = request.json() |
|
response = json.dumps( |
|
response, |
|
sort_keys=True, |
|
ensure_ascii=False, |
|
indent=4, |
|
separators=(",", ": "), |
|
) |
|
response = eval(response) |
|
return {"result": response[0]["translations"][0]["text"]} |
|
|
|
|
|
class APIComponent(ToolComponent): |
|
def __init__(self): |
|
super(APIComponent, self).__init__() |
|
|
|
def func(self, agent) -> Dict: |
|
pass |
|
|
|
|
|
class FunctionComponent(ToolComponent): |
|
def __init__( |
|
self, |
|
functions, |
|
function_call="auto", |
|
response_type="response", |
|
your_function=None, |
|
): |
|
super().__init__() |
|
self.functions = functions |
|
self.function_call = function_call |
|
self.parameters = {} |
|
self.available_functions = {} |
|
self.response_type = response_type |
|
if your_function: |
|
function_name = your_function["name"] |
|
function_content = your_function["content"] |
|
exec(function_content) |
|
self.available_functions[function_name] = eval(function_name) |
|
|
|
for function in self.functions: |
|
self.parameters[function["name"]] = list( |
|
function["parameters"]["properties"].keys() |
|
) |
|
self.available_functions[function["name"]] = eval(function["name"]) |
|
|
|
def func(self, agent): |
|
messages = agent.long_term_memory |
|
outputdict = {} |
|
query = agent.long_term_memory[-1].content if len(agent.long_term_memory) > 0 else " " |
|
relevant_history = get_relevant_history( |
|
query, |
|
agent.long_term_memory[:-1], |
|
agent.chat_embeddings[:-1], |
|
) |
|
response = agent.LLM.get_response( |
|
messages, |
|
None, |
|
functions=self.functions, |
|
stream=False, |
|
function_call=self.function_call, |
|
relevant_history=relevant_history, |
|
) |
|
response_message = response |
|
if response_message.get("function_call"): |
|
function_name = response_message["function_call"]["name"] |
|
fuction_to_call = self.available_functions[function_name] |
|
function_args = json.loads(response_message["function_call"]["arguments"]) |
|
input_args = {} |
|
for args_name in self.parameters[function_name]: |
|
input_args[args_name] = function_args.get(args_name) |
|
function_response = fuction_to_call(**input_args) |
|
if self.response_type == "response": |
|
outputdict["response"] = function_response |
|
elif self.response_type == "prompt": |
|
outputdict["prompt"] = function_response |
|
|
|
return outputdict |
|
|
|
|
|
class CodeComponent(ToolComponent): |
|
def __init__(self, file_name, keyword) -> None: |
|
super().__init__() |
|
self.file_name = file_name |
|
self.keyword = keyword |
|
self.system_prompt = ( |
|
"you need to extract the modified code as completely as possible." |
|
) |
|
self.last_prompt = ( |
|
f"Please strictly adhere to the following format for outputting: \n" |
|
) |
|
self.last_prompt += ( |
|
f"<{self.keyword}> the content you need to extract </{self.keyword}>" |
|
) |
|
|
|
def func(self, agent): |
|
response = agent.LLM.get_response( |
|
agent.long_term_memory, |
|
self.system_prompt, |
|
self.last_prompt, |
|
stream=False, |
|
) |
|
code = extract(response, self.keyword) |
|
code = code if code else response |
|
os.makedirs("output_code", exist_ok=True) |
|
file_name = "output_code/" + self.file_name |
|
codes = code.split("\n") |
|
if codes[0] == "```python": |
|
codes.remove(codes[0]) |
|
if codes[-1] == "```": |
|
codes.remove(codes[-1]) |
|
code = "\n".join(codes) |
|
with open(file_name, "w", encoding="utf-8") as f: |
|
f.write(code) |
|
return {} |
|
|
