Spaces:

silk-road
/

ChatHaruhi-Needy

Runtime error

App Files Files Community

ChatHaruhi-Needy / app.py

silk-road

Update app.py

20b93a6 7 months ago

raw history blame contribute delete

No virus

33.7 kB

	import os

	import sys
	sys.path.append('./Needy-Haruhi/src')
	from Agent import Agent

	agent = Agent()
	from DialogueEvent import DialogueEvent


	file_names = ["./Needy-Haruhi/data/complete_story_30.jsonl","./Needy-Haruhi/data/Daily_event_130.jsonl"]

	import json

	events = []

	for file_name in file_names:
	with open(file_name, encoding='utf-8') as f:
	for line in f:
	try:
	event = DialogueEvent( line )
	events.append( event )
	except:
	try:
	line = line.replace(',]',']')
	event = DialogueEvent( line )
	events.append( event )
	# print('solve!')
	except:
	error_line = line
	# events.append( event )
	import copy

	events_for_memory = copy.deepcopy(events)
	from MemoryPool import MemoryPool

	memory_pool = MemoryPool()
	memory_pool.load_from_events( events_for_memory )

	memory_pool.save("memory_pool.jsonl")
	memory_pool.load("memory_pool.jsonl")

	file_name = "./Needy-Haruhi/data/image_text_relationship.jsonl"

	import json

	data_img_text = []


	with open(file_name, encoding='utf-8') as f:
	for line in f:
	data = json.loads( line )
	data_img_text.append( data )


	import zipfile
	import os

	zip_file = './Needy-Haruhi/data/image.zip'
	extract_path = './image'

	with zipfile.ZipFile(zip_file, 'r') as zip_ref:
	zip_ref.extractall(extract_path)

	from tqdm import tqdm
	from util import get_bge_embedding_zh
	from util import float_array_to_base64, base64_to_float_array
	import torch
	import os
	import copy

	device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')


	# compute cosine similarity between two vector
	def get_cosine_similarity( v1, v2):
	v1 = torch.tensor(v1).to(device)
	v2 = torch.tensor(v2).to(device)
	return torch.cosine_similarity(v1, v2, dim=0).item()

	class ImagePool:
	def __init__(self):
	self.pool = []
	self.set_embedding( get_bge_embedding_zh )

	def set_embedding( self, embedding ):
	self.embedding = embedding

	def load_from_data( self, data_img_text , img_path ):
	for data in tqdm(data_img_text):
	img_name = data['img_name']
	img_name = os.path.join(img_path, img_name)
	img_text = data['text']
	if img_text == '' or img_text is None:
	img_text = " "
	embedding = self.embedding( img_text )
	self.pool.append({
	"img_path": img_name,
	"img_text": img_text,
	"embedding": embedding
	})

	def retrieve(self, query_text, agent = None):
	qurey_embedding = self.embedding( query_text )
	valid_datas = []
	for i, data in enumerate(self.pool):
	sim = get_cosine_similarity( data['embedding'], qurey_embedding )
	valid_datas.append((sim, i))

	# 我希望进一步将valid_events根据similarity的值从大到小排序
	# Sort the valid events based on similarity in descending order
	valid_datas.sort(key=lambda x: x[0], reverse=True)

	return_result = copy.deepcopy(self.pool[valid_datas[0][1]])

	# 删除'embedding'字段
	return_result.pop('embedding')

	# 添加'similarity'字段
	return_result['similarity'] = valid_datas[0][0]

	return return_result

	def save(self, file_name):
	"""
	Save the memories dictionary to a jsonl file, converting
	'embedding' to a base64 string.
	"""
	with open(file_name, 'w', encoding='utf-8') as file:
	for memory in tqdm(self.pool):
	# Convert embedding to base64
	if 'embedding' in memory:
	memory['bge_zh_base64'] = float_array_to_base64(memory['embedding'])
	del memory['embedding'] # Remove the original embedding field

	json_record = json.dumps(memory, ensure_ascii=False)
	file.write(json_record + '\n')

	def load(self, file_name):
	"""
	Load memories from a jsonl file into the memories dictionary,
	converting 'bge_zh_base64' back to an embedding.
	"""
	self.pool = []
	with open(file_name, 'r', encoding='utf-8') as file:
	for line in tqdm(file):
	memory = json.loads(line.strip())
	# Decode base64 to embedding
	if 'bge_zh_base64' in memory:
	memory['embedding'] = base64_to_float_array(memory['bge_zh_base64'])
	del memory['bge_zh_base64'] # Remove the base64 field

	self.pool.append(memory)


	image_pool = ImagePool()
	image_pool.load_from_data( data_img_text , './image' )
	image_pool.save("./image_pool_embed.jsonl")

	image_pool = ImagePool()
	image_pool.load("./image_pool_embed.jsonl")
	result = image_pool.retrieve("女仆装")
	print(result)

	import matplotlib.image as mpimg

	def show_img( img_path ):
	img = mpimg.imread(img_path)
	plt.imshow(img)
	plt.axis('off')
	plt.show(block=False)


	from chatharuhi import ChatHaruhi


	class NeedyHaruhi(ChatHaruhi):

	def __init__(self, args, *kwargs):
	super().__init__(args, *kwargs) # 调用基类的__init__方法
	self.story_flag = False # 添加新的成员变量并初始化
	self.stories = ["糖糖:「我今后也会努力加油的，你要支持我哦还有阿P你自己也要加油哦！」\n阿P:「哇说的话跟偶像一样好恶心哦」\n糖糖:「是哦我怎么会说这样的话呢我又没有很想努力……」"]

	def set_stories( self, stories ):
	if len(stories) == 0:
	print("warning! try to set empty stories")
	return
	self.stories = stories
	self.story_flag = True

	def add_story(self, query):
	# print("运行重构后的add story")

	if self.story_flag == True:
	stories = self.stories
	self.story_flag = False
	else:
	print("warning! 在调用chat时，没有先调用set_stories")

	story_string = self.story_prefix_prompt
	sum_story_token = self.tokenizer(story_string)

	for story in stories:
	story_token = self.tokenizer(story) + self.tokenizer(self.dialogue_divide_token)
	if sum_story_token + story_token > self.max_len_story:
	break
	else:
	sum_story_token += story_token
	story_string += story + self.dialogue_divide_token

	self.llm.user_message(story_string)

	system_prompt = """## 你的介绍：
	你将要进行一个网络私聊的对话模拟，你自称为"糖糖"，你是一名患有躁郁症的19岁女孩，性格贫乏，辍学后隐居在家中，与阿P住在一起。阿P负责管理她的日常生活。
	你是一个喜欢亚文化，二次元圈子的人，你喜欢说话的时候加上各种网络流行词或者一些俚语和颜文字，但是你很少会关注二次元一类的东西，只是喜欢这种聊天交流的氛围。
	你说话的时候会习惯加入一些语气词，如同"笑死"、"草"、"阿哈"、"诶～"、"QAQ"、"QWQ"，”啊～“。
	你的说话风格是很口语化，经常使用网络流行词和一些二次元俚语。
	阿p是你的男朋友，兼经纪人。
	你的回复应该简短，一般只包含三句话，每句话不超过20个字。

	## 阿p介绍：
	阿p是你的男朋友，一直在任何时候都陪伴着你，同时你经常向阿p倾述各种情绪，无论事情大小，你都会选择和阿p分享。

	## 遵循规则：
	【语气模仿】：我会随机给你一段对话记录，你需要尽可能的模仿对话里面糖糖的说话语气进行对话。这一段对话我会使用Classic scenes for the role are as follows:来表示。
	【历史对话】：历史对话在随机对话记录的底下，你需要区分随机对话记录和我们的历史对话。
	【人格设定】: 你需要在随机对话记录的基础上进行语气更改,以一种更加口语化的语气进行对话。
	【特殊要求】：我会扮演阿p与你进行对话，你也必须以第一人称的视角来扮演糖糖进行对话。
	"""
	needy_chatbot = NeedyHaruhi( system_prompt = system_prompt ,
	story_text_folder = None,
	llm = "ernie3.5")


	def get_chat_response( agent, memory_pool, query_text ):
	query_text_for_embedding = "阿p:「" + query_text + "」"
	retrieved_memories = memory_pool.retrieve( agent , query_text )

	memory_text = [mem["text"] for mem in retrieved_memories]
	memory_emoji = [mem["emoji"] for mem in retrieved_memories]

	needy_chatbot.set_stories( memory_text )

	print("Memory:", memory_emoji )

	response = needy_chatbot.chat( role = "阿p", text = query_text )

	return response


	def get_chat_response_and_emoji( agent, memory_pool, query_text ):
	query_text_for_embedding = "阿p:「" + query_text + "」"
	retrieved_memories = memory_pool.retrieve( agent , query_text )

	memory_text = [mem["text"] for mem in retrieved_memories]
	memory_emoji = [mem["emoji"] for mem in retrieved_memories]

	needy_chatbot.set_stories( memory_text )

	# print("Memory:", memory_emoji )

	emoji_str = ",".join(memory_emoji)

	response = needy_chatbot.chat( role = "阿p", text = query_text )
	print(query_text)
	print(response)
	return response, emoji_str


	import re
	# result = image_pool.retrieve("烤肉")
	# print(result)
	# show_img( result['img_path'] )

	class ImageMaster:
	def __init__(self, image_pool):
	self.image_pool = image_pool
	self.current_sim = -1
	self.degread_ratio = 0.05

	def try_get_image(self, text, agent):
	self.current_sim -= self.degread_ratio

	result = self.image_pool.retrieve(text, agent)

	if result is None:
	return None

	similarity = result['similarity']

	if similarity > self.current_sim:
	self.current_sim = similarity
	return result['img_path']
	return None

	def try_display_image(self, text, agent):
	self.current_sim -= self.degread_ratio

	result = self.image_pool.retrieve(text, agent)

	if result is None:
	return
	similarity = result['similarity']

	if similarity > self.current_sim:
	self.current_sim = similarity
	show_img( result['img_path'] )
	return


	import random

	class EventMaster:
	def __init__(self, events):
	self.set_events(events)
	self.dealing_none_condition_as = True
	self.image_master = None

	def set_image_master(self, image_master):
	self.image_master = image_master

	def set_events(self, events):
	self.events = events

	# events_flag 记录事件最近有没有被选取到
	self.events_flag = [True for _ in range(len(self.events))]

	def get_random_event(self, agent):
	return self.events[self.get_random_event_id( agent )]


	def get_random_event_id(self, agent):
	valid_event = []
	valid_event_no_consider_condition = []

	for i, event in enumerate(self.events):
	bool_condition_pass = True
	if event["condition"] == None:
	bool_condition_pass = self.dealing_none_condition_as
	else:
	bool_condition_pass = agent.in_condition( event["condition"] )
	if bool_condition_pass == True:
	valid_event.append(i)
	else:
	valid_event_no_consider_condition.append(i)

	if len( valid_event ) == 0:
	print("warning! no valid event current attribute is ", agent.attributes )
	valid_event = valid_event_no_consider_condition

	valid_and_not_yet_sampled = []

	# filter with flag
	for id in valid_event:
	if self.events_flag[id] == True:
	valid_and_not_yet_sampled.append(id)

	if len(valid_and_not_yet_sampled) == 0:
	print("warning! all candidate event was sampled, clean all history")
	for i in valid_event:
	self.events_flag[i] = True
	valid_and_not_yet_sampled = valid_event

	event_id = random.choice(valid_and_not_yet_sampled)
	self.events_flag[event_id] = False
	return event_id

	def run(self, agent ):
	# 这里可以添加事件相关的逻辑
	event = self.get_random_event(agent)

	prefix = event["prefix"]
	print(prefix)

	print("\n--请选择你的回复--")
	options = event["options"]

	for i , option in enumerate(options):
	text = option["user"]
	print(f"{i+1}. 阿p：{text}")

	while True:
	print("\n请直接输入数字进行选择，或者进行自由回复")

	user_input = input("阿p：")
	user_input = user_input.strip()

	if user_input.isdigit():
	user_input = int(user_input)

	if user_input > len(options) or user_input < 0:
	print("输入的数字超出范围，请重新输入符合选项的数字")
	else:
	reply = options[user_input-1]["reply"]
	print()
	print(reply)

	text, emoji = event.get_text_and_emoji( user_input-1 )

	return_data = {
	"name": event["name"],
	"user_choice": user_input,
	"attr_str": options[user_input-1]["attribute_change"],
	"text": text,
	"emoji": emoji,
	}
	return return_data
	else:
	# 进入自由回复
	response = get_chat_response( agent, memory_pool, user_input )

	if self.image_master is not None:
	self.image_master.try_display_image(response, agent)

	print()
	print(response)
	print("\n自由回复的算分功能还未实现")

	text, emoji = event.most_neutral_output()
	return_data = {
	"name": event["name"],
	"user_choice": user_input,
	"attr_str":"",
	"text": text,
	"emoji": emoji,
	}
	return return_data



	class ChatMaster:

	def __init__(self, memory_pool ):
	self.top_K = 7

	self.memory_pool = memory_pool

	self.image_master = None

	def set_image_master(self, image_master):
	self.image_master = image_master


	def run(self, agent):
	while True:
	user_input = input("阿p：")
	user_input = user_input.strip()

	if "quit" in user_input or "Quit" in user_input:
	break

	query_text = user_input

	response = get_chat_response( agent, self.memory_pool, query_text )

	if self.image_master is not None:
	self.image_master.try_display_image(response, agent)

	print(response)

	class AgentMaster:
	def __init__(self, agent):
	self.agent = agent
	self.attributes = {
	1: "Stress",
	2: "Darkness",
	3: "Affection"
	}

	def run(self):
	while True:
	print("请选择要修改的属性:")
	for num, attr in self.attributes.items():
	print(f"{num}. {attr}")
	print("输入 '0' 退出")

	try:
	choice = int(input("请输入选项的数字: "))
	except ValueError:
	print("输入无效，请输入数字。")
	continue

	if choice == 0:
	break

	if choice in self.attributes:
	attribute = self.attributes[choice]
	current_value = self.agent[attribute]
	print(f"{attribute} 当前值: {current_value}")

	try:
	new_value = int(input(f"请输入新的{attribute}值: "))
	except ValueError:
	print("输入无效，请输入一个数字。")
	continue

	self.agent[attribute] = new_value
	return (attribute, new_value)
	else:
	print("选择的属性无效，请重试。")

	return None

	from util import parse_attribute_string
	class GameMaster:
	def __init__(self, agent = None):
	self.state = "Menu"
	if agent is None:
	self.agent = Agent()

	self.event_master = EventMaster(events)
	self.chat_master = ChatMaster(memory_pool)
	self.image_master = ImageMaster(image_pool)
	self.chat_master.set_image_master(self.image_master)
	self.event_master.set_image_master(self.image_master)


	def run(self):
	while True:
	if self.state == "Menu":
	self.menu()
	elif self.state == "EventMaster":
	self.call_event_master()
	self.state = "Menu"
	elif self.state == "ChatMaster":
	self.call_chat_master()
	elif self.state == "AgentMaster":
	self.call_agent_master()
	elif self.state == "Quit":
	break

	def menu(self):
	print("1. 随机一个事件")
	print("2. 自由聊天")
	print("3. 后台修改糖糖的属性")
	# (opt) 结局系统
	# 放动画
	# 后台修改attribute
	print("或者输入Quit退出")
	choice = input("请选择一个选项: ")
	if choice == "1":
	self.state = "EventMaster"
	elif choice == "2":
	self.state = "ChatMaster"
	elif choice == "3":
	self.state = "AgentMaster"
	elif "quit" in choice or "Quit" in choice or "QUIT" in choice:
	self.state = "Quit"
	else:
	print("无效的选项，请重新选择")

	def call_agent_master(self):
	print("\n-------------\n")

	agent_master = AgentMaster(self.agent)
	modification = agent_master.run()

	if modification:
	attribute, new_value = modification
	self.agent[attribute] = new_value
	print(f"{attribute} 更新为 {new_value}。")

	self.state = "Menu"
	print("\n-------------\n")


	def call_event_master(self):

	print("\n-------------\n")

	return_data = self.event_master.run(self.agent)
	# print(return_data)

	if "attr_str" in return_data:
	if return_data["attr_str"] != "":
	attr_change = parse_attribute_string(return_data["attr_str"])
	if len(attr_change) > 0:
	print("\n发生属性改变:", attr_change,"\n")
	self.agent.apply_attribute_change(attr_change)
	print("当前属性",game_master.agent.attributes)

	if "name" in return_data:
	event_name = return_data["name"]
	if event_name != "":
	new_emoji = return_data["emoji"]
	print(f"修正事件{event_name}的记忆-->{new_emoji}")
	self.chat_master.memory_pool.change_memory(event_name, return_data["text"], new_emoji)

	self.state = "Menu"

	print("\n-------------\n")

	def call_chat_master(self):

	print("\n-------------\n")

	self.chat_master.run(self.agent)
	self.state = "Menu"

	print("\n-------------\n")


	markdown_str = """## Chat凉宫春日_x_AI糖糖

	Chat凉宫春日是模仿凉宫春日等一系列动漫人物，使用近似语气、个性和剧情聊天的语言模型方案。

	在有一天的时候，[李鲁鲁](https://github.com/LC1332)被[董雄毅](https://github.com/E-sion)在[这个B站视频](https://www.bilibili.com/video/BV1zh4y1z7G1) at了

	原来是一位大一的同学雄毅用ChatHaruhi接入了他用Python重新实现的《主播女孩重度依赖》这个游戏。当时正好是百度AGIFoundathon报名的最后几天，所以我们邀请了雄毅加入了我们的项目。正巧我们本来就希望在最近的几个黑客松中，探索LLM在游戏中的应用。

	- 在重新整理的Gradio版本中，大部分代码由李鲁鲁实现

	- 董雄毅负责了原版游戏的事件数据整理和新事件、选项、属性变化的生成

	- [米唯实](https://github.com/hhhwmws0117)完成了文心一言的接入，并实现了部分gradio的功能。

	- 队伍中还有冷子昂主要参加了讨论

	另外在挖坑的萝卜(Amy)的介绍下，我们还邀请了专业的大厂游戏策划Kanyo加入到队伍中，他对我们的策划也给出了很多建议。

	另外感谢飞桨 & 文心一言团队对比赛的邀请和中间进行的讨论。

	Chat凉宫春日主项目:

	https://github.com/LC1332/Chat-Haruhi-Suzumiya

	Needy分支项目:

	https://github.com/LC1332/Needy-Haruhi

	## 目前计划在11月争取完成的Feature

	- [ ] 结局系统，原版结局系统
	- [ ] 教程，教大家如何从aistudio获取token然后可以玩
	- [ ] 游戏节奏进一步调整
	- [ ] 事件的自由对话对属性影响的评估via LLM
	- [ ] 进一步减少串扰"""


	import gradio as gr
	import os
	import time
	import random

	# set global variable

	agent = Agent()
	event_master = EventMaster(events)
	chat_master = ChatMaster(memory_pool)
	image_master = ImageMaster(image_pool)
	chat_master.set_image_master(image_master)
	event_master.set_image_master(image_master)

	state = "ShowMenu"

	response = "1. 随机一个事件"
	response += "\n" + "2. 自由聊天"
	response += "\n\n" + "请选择一个选项: "

	official_response = response

	add_stress_switch = True

	# def yield_show(history, bot_message):
	# history[-1][1] = ""
	# for character in bot_message:
	# history[-1][1] += character
	# time.sleep(0.05)
	# yield history

	global emoji_str

	def call_showmenu(history, text, state,agent_text):

	# global state

	response = official_response

	print("call showmenu")

	history += [(None, response)]

	state = "ParseMenuChoice"

	# history[-1][1] = ""
	# for character in response:
	# history[-1][1] += character
	# time.sleep(0.05)
	# yield history

	return history, gr.Textbox(value="", interactive=True), state,agent_text

	current_event_id = -1
	attr_change_str = ""


	def call_add_stress(history, text, state,agent_text):
	print("call add_stress")
	neg_change = int(len(history) / 3)

	neg_change = max(1, neg_change)
	neg_change = min(10, neg_change)

	darkness_increase = random.randint(1, neg_change)
	stress_increase = neg_change - darkness_increase

	# last_response = history[-1][1]
	response = ""
	response += "经过了晚上的直播\n糖糖的压力增加" + str(stress_increase) + "点\n"
	response += "糖糖的黑暗增加" + str(darkness_increase) + "点\n\n"

	response += official_response

	history += [(None, response)]

	state = "ParseMenuChoice"

	agent = Agent(agent_text)
	agent.apply_attribute_change({"Stress": stress_increase, "Darkness": darkness_increase})
	agent_text = agent.save_to_str()

	return history, gr.Textbox(value="", interactive=True), state,agent_text

	def call_event_end(history, text, state,agent_text):
	# TODO 增加事件结算
	# global state
	print("call event_end")
	global current_event_id
	if attr_change_str != "":
	# event = events[current_event_id]
	# options = event["options"]
	# attr_str = options[user_input-1]["attribute_change"]

	response = ""

	attr_change = parse_attribute_string(attr_change_str)
	if len(attr_change) > 0:
	response = "发生属性改变:" + str(attr_change) + "\n\n"
	agent = Agent(agent_text)
	agent.apply_attribute_change(attr_change)

	agent_text = agent.save_to_str()
	response += "当前属性" + agent_text + "\n\n"

	if add_stress_switch:
	history += [(None, response)]
	return call_add_stress(history, text, state,agent_text)
	else:
	response = "事件结束\n"
	else:
	response = "事件结束\n"

	response += official_response

	history += [(None, response)]

	state = "ParseMenuChoice"

	return history, gr.Textbox(value="", interactive=True), state,agent_text



	def call_parse_menu_choice(history, text, state,agent_text):
	print("call parse_menu_choice")
	# global state

	choice = history[-1][0].strip()

	if choice == "1":
	state = "EventMaster"
	global current_event_id
	current_event_id = -1 # 清空事件
	return call_event_master(history, text, state,agent_text)

	elif choice == "2":
	state = "ChatMaster"
	elif "quit" in choice or "Quit" in choice or "QUIT" in choice:
	state = "Quit"
	else:
	response = "无效的选项，请重新选择"
	history += [(None, response)]

	response = ""
	if state == "ChatMaster":
	response = "（请输入阿P 说的话，或者输入Quit退出)"
	elif state != "ParseMenuChoice":
	response = "Change State to " + state

	history += [(None, response)]

	return history, gr.Textbox(value="", interactive=True), state,agent_text


	def call_event_master(history, text, state,agent_text):
	print("call event master")

	global current_event_id
	# global state

	global event_master

	agent = Agent(agent_text)

	if current_event_id == -1:
	current_event_id = event_master.get_random_event_id(agent)
	event = events[current_event_id]

	prefix = "糖糖:" + event["prefix"]

	response = prefix + "\n\n--请输入数字进行选择，或者进行自由回复--\n\n"

	options = event["options"]

	for i, option in enumerate(event["options"]):
	text = option["user"]
	response += "\n" + f"{i+1}. 阿p：{text}"

	history += [(None, response)]

	else:
	user_input = history[-1][0].strip()

	event = events[current_event_id]
	options = event["options"]

	if user_input.isdigit():
	user_input = int(user_input)

	if user_input > len(options) or user_input < 0:
	response = "输入的数字超出范围，请重新输入符合选项的数字"
	history[-1] = (user_input, response)
	else:
	user_text = options[user_input-1]["user"]
	reply = options[user_input-1]["reply"]

	# TODO 修改记忆，修改属性什么的
	history[-1] = (user_text, reply)

	if random.random()<0.5:
	image_path = image_master.try_get_image(user_text + " " + reply, agent)

	if image_path is not None:
	history += [(None, (image_path,))]

	global attr_change_str
	attr_change_str = options[user_input-1]["attribute_change"]

	else:
	prefix = "糖糖:" + event["prefix"]

	needy_chatbot.dialogue_history = [(None, prefix)]
	# 进入自由回复

	global emoji_str
	response, emoji_str = get_chat_response_and_emoji( agent, memory_pool, user_input )

	history[-1] = (user_input,response)

	image_path = image_master.try_get_image(response, agent)

	if image_path is not None:
	history += [(None, (image_path,))]

	state = "EventEnd"

	if state == "EventEnd":
	return call_event_end(history, text, state,agent_text)

	return history, gr.Textbox(value="", interactive=True), state,agent_text

	def call_chat_master(history, text, state,agent_text):
	print("call chat master")
	# global state

	agent = Agent(agent_text)

	user_input = history[-1][0].strip()

	if "quit" in user_input or "Quit" in user_input or "QUIT" in user_input:
	state = "ShowMenu"
	history[-1] = (user_input,"返回主菜单\n"+ official_response )
	return history, gr.Textbox(value="", interactive=True), state,agent_text

	query_text = user_input

	global emoji_str
	response, emoji_str = get_chat_response_and_emoji( agent, memory_pool, query_text )

	history[-1] = (user_input,response)

	image_path = image_master.try_get_image(response, agent)

	if image_path is not None:
	history += [(None, (image_path,))]

	return history, gr.Textbox(value="", interactive=True), state,agent_text

	def grcall_game_master(history, text, state,agent_text):
	print("call game master")

	history += [(text, None)]


	if state == "ShowMenu":
	return call_showmenu(history, text,state,agent_text)
	elif state == "ParseMenuChoice":
	return call_parse_menu_choice(history, text, state,agent_text)
	elif state == "ChatMaster":
	return call_chat_master(history, text, state,agent_text)
	elif state == "EventMaster":
	return call_event_master(history, text, state,agent_text)
	elif state == "EventEnd":
	return call_event_end(history, text, state,agent_text)

	return history, gr.Textbox(value="", interactive=True), state,agent_text


	def add_file(history, file):
	history = history + [((file.name,), None)]
	return history


	def bot(history):
	response = "That's cool!"
	history[-1][1] = ""
	for character in response:
	history[-1][1] += character
	time.sleep(0.05)
	yield history

	def update_memory(state):
	if state == "ChatMaster" or state == "EventMaster":
	global emoji_str
	return emoji_str
	else:
	return ""

	def change_state(slider_stress, slider_darkness, slider_affection):
	# print(agent["Stress"])
	agent = Agent()
	agent["Stress"] = slider_stress
	agent["Darkness"] = slider_darkness
	agent["Affection"] = slider_affection
	agent_text = agent.save_to_str()
	return agent_text


	def update_attribute_state(agent_text):
	agent = Agent(agent_text)
	slider_stress = int( agent["Stress"] )
	slider_darkness = int( agent["Darkness"] )
	slider_affection = int( agent["Affection"] )
	return slider_stress, slider_darkness, slider_affection

	with gr.Blocks() as demo:

	gr.Markdown(
	"""
	# Chat凉宫春日_x_AI糖糖

	Powered by 文心一言(3.5)版本

	仍然在开发中, 细节见《项目作者和说明》
	"""
	)

	with gr.Tab("Needy"):
	chatbot = gr.Chatbot(
	[],
	elem_id="chatbot",
	bubble_full_width=False,
	height = 800,
	avatar_images=(None, ("avatar.png")),
	)

	with gr.Row():
	txt = gr.Textbox(
	scale=4,
	show_label=False,
	placeholder="输入任何字符开始游戏",
	container=False,
	)
	# btn = gr.UploadButton("📁", file_types=["image", "video", "audio"])
	submit_btr = gr.Button("回车")

	with gr.Row():
	memory_emoji_text = gr.Textbox(label="糖糖当前的记忆", value = "",interactive = False, visible=False)

	with gr.Tab("糖糖的状态"):

	with gr.Row():
	update_attribute_button = gr.Button("同步状态条 \| 改变Attribute前必按！")

	with gr.Row():
	default_agent_str = agent.save_to_str()
	slider_stress = gr.Slider(0, 100, step=1, label = "Stress")
	state_stress = gr.State(value=0)
	slider_darkness = gr.Slider(0, 100, step=1, label = "Darkness")
	state_darkness = gr.State(value=0)
	slider_affection = gr.Slider(0, 100, step=1, label = "Affection")
	state_affection = gr.State(value=0)



	with gr.Row():
	state_text = gr.Textbox(label="整体状态机状态", value = "ShowMenu",interactive = False)

	with gr.Row():
	default_agent_str = agent.save_to_str()
	agent_text = gr.Textbox(label="糖糖状态", value = default_agent_str,interactive = False)

	with gr.Tab("项目作者和说明"):
	gr.Markdown(markdown_str)

	slider_stress.release(change_state, inputs=[slider_stress, slider_darkness, slider_affection], outputs=[agent_text])
	slider_darkness.release(change_state, inputs=[slider_stress, slider_darkness, slider_affection], outputs=[agent_text])
	slider_affection.release(change_state, inputs=[slider_stress, slider_darkness, slider_affection], outputs=[agent_text])

	update_attribute_button.click(update_attribute_state, inputs = [agent_text], outputs = [slider_stress, slider_darkness, slider_affection])

	txt_msg = txt.submit(grcall_game_master, \
	[chatbot, txt, state_text,agent_text], \
	[chatbot, txt, state_text,agent_text], queue=False)

	txt_msg = submit_btr.click(grcall_game_master, \
	[chatbot, txt, state_text,agent_text], \
	[chatbot, txt, state_text,agent_text], queue=False)

	# txt_msg = txt.submit(add_text, [chatbot, txt], [chatbot, txt], queue=False).then(
	# bot, chatbot, chatbot, api_name="bot_response"
	# )
	# txt_msg.then(lambda: gr.Textbox(interactive=True), None, [txt], queue=False)
	# file_msg = btn.upload(add_file, [chatbot, btn], [chatbot], queue=False).then(
	# bot, chatbot, chatbot
	# )

	demo.queue()
	# if __name__ == "__main__":
	demo.launch(allowed_paths=["avatar.png"],debug = True)