509 lines
20 KiB
Python
509 lines
20 KiB
Python
# myapp/sockets/namespaces.py
|
|
import json
|
|
import time
|
|
import requests
|
|
from flask import current_app, request, session, url_for
|
|
from flask_socketio import Namespace, join_room, leave_room, emit
|
|
from ..config import Config
|
|
|
|
from ..function_tools import judge
|
|
from ..function_tools import next_chapter
|
|
from ..services.backboard_service import realtime_response
|
|
from ..services.markdown_service import load_full_markdown_file
|
|
from ..services.course_service import save_learning_progress, upload_learning_progress_to_cloud
|
|
from ..extension_ase.ase_client import HSAEngineClient
|
|
from ..services.user_service import get_or_load_current_user
|
|
from ..services.course_service import load_learning_progress
|
|
from ..services.asectrl_service import (
|
|
on_connect_to_ase,
|
|
receive_ase_paste_detected,
|
|
receive_ase_dialog,
|
|
receive_ase_message_hint,
|
|
receive_ase_voice_out,
|
|
receive_ase_process,
|
|
receive_ase_judge,
|
|
receive_ase_next_chapter,
|
|
receive_ase_chapter_score
|
|
)
|
|
|
|
|
|
|
|
class VSCodeNamespace(Namespace):
|
|
def on_login(self,data):
|
|
self.app = current_app
|
|
ex = current_app.extensions
|
|
print("VSCode client connected")
|
|
dataconfig = data['config']
|
|
user_uuid = dataconfig.get('user_uuid')
|
|
path = dataconfig.get('path')
|
|
course_id = dataconfig.get('course_id')
|
|
lesson_id = dataconfig.get('chapter_id')
|
|
print(f"User {user_uuid} connected with path: {path}")
|
|
join_room(user_uuid, namespace='/vscode')
|
|
chatmanager = ex['user_uuid2chatmanager'][user_uuid]
|
|
chatmanager.set_vscode_ws(self)
|
|
|
|
|
|
def on_load_chapter(self, data):
|
|
dataconfig = data['config']
|
|
user_uuid = dataconfig.get('user_uuid')
|
|
ex = current_app.extensions
|
|
chatmanager = ex['user_uuid2chatmanager'][user_uuid]
|
|
chatmanager.load_code_in_markdown()
|
|
|
|
def on_message(self, data):
|
|
# print(f"Received from VSCode client: {data}")
|
|
dataconfig = data['config']
|
|
realtime_response(dataconfig, data)
|
|
# emit('response', {'message': 'Config data received and connection established'})
|
|
def on_disconnect(self, data):
|
|
print("VSCode client disconnected")
|
|
print("Disconnect reason:"+str(data))
|
|
|
|
|
|
class AgentNamespace(Namespace):
|
|
def _setup_initial_state(self, data):
|
|
"""Set up initial state, parse data, and join user to room."""
|
|
self.app = current_app
|
|
ex = current_app.extensions
|
|
data = json.loads(data)
|
|
|
|
# Extract required fields
|
|
user_uuid = data['user_uuid']
|
|
course_id = data['course_id']
|
|
lesson_name = data['lesson_name']
|
|
chapter_name = data['chapter_name']
|
|
|
|
# Get user_id and set session
|
|
uuid2username = ex["uuid2username"]
|
|
user_id = uuid2username[user_uuid]
|
|
session['user_uuid'] = user_uuid
|
|
|
|
# Join user to room
|
|
join_room(user_uuid, namespace='/agent')
|
|
print(f'User connected with session user_uuid: {user_uuid}')
|
|
|
|
return {
|
|
'ex': ex,
|
|
'user_uuid': user_uuid,
|
|
'user_id': user_id,
|
|
'course_id': course_id,
|
|
'lesson_name': lesson_name,
|
|
'chapter_name': chapter_name
|
|
}
|
|
|
|
def _manage_ase_client(self, ex, user_uuid):
|
|
"""Manage ASE client: disconnect existing if connected and return chatmanager."""
|
|
user_uuid2chatmanager = ex["user_uuid2chatmanager"]
|
|
user_uuid2ase_client = ex["user_uuid2ase_client"]
|
|
|
|
# Disconnect existing ASE client if connected
|
|
if user_uuid2ase_client.get(user_uuid) is not None and user_uuid2ase_client[user_uuid].connected:
|
|
user_uuid2ase_client[user_uuid].disconnect()
|
|
|
|
# Get chatmanager
|
|
chatmanager = user_uuid2chatmanager[user_uuid]
|
|
|
|
return {
|
|
'chatmanager': chatmanager,
|
|
'user_uuid2ase_client': user_uuid2ase_client
|
|
}
|
|
|
|
def on_login(self, data):
|
|
initial_state = self._setup_initial_state(data)
|
|
ex = initial_state['ex']
|
|
user_uuid = initial_state['user_uuid']
|
|
user_id = initial_state['user_id']
|
|
course_id = initial_state['course_id']
|
|
lesson_name = initial_state['lesson_name']
|
|
chapter_name = initial_state['chapter_name']
|
|
backboard_manager = ex["backboard_manager"]
|
|
|
|
def _register_chatmanager_functions(self, chatmanager, course_id, user_id, chapter_name, lesson_name, user_uuid):
|
|
"""Register required functions to chatmanager's function manager."""
|
|
# Add judge function
|
|
chatmanager.function_manager.add_function(
|
|
judge,
|
|
{'course_id': course_id, 'root_path': f'/home/{user_id}/{course_id}/{chapter_name}/{lesson_name}'}
|
|
)
|
|
|
|
# Add next_chapter function
|
|
chatmanager.function_manager.add_function(
|
|
next_chapter,
|
|
{'user_uuid': user_uuid}
|
|
)
|
|
|
|
return not chatmanager.restart
|
|
|
|
def on_login(self, data):
|
|
initial_state = self._setup_initial_state(data)
|
|
ex = initial_state['ex']
|
|
user_uuid = initial_state['user_uuid']
|
|
user_id = initial_state['user_id']
|
|
course_id = initial_state['course_id']
|
|
lesson_name = initial_state['lesson_name']
|
|
chapter_name = initial_state['chapter_name']
|
|
backboard_manager = ex["backboard_manager"]
|
|
|
|
ase_management = self._manage_ase_client(ex, user_uuid)
|
|
chatmanager = ase_management['chatmanager']
|
|
user_uuid2ase_client = ase_management['user_uuid2ase_client']
|
|
|
|
def _load_and_restore_progress(self, chatmanager, user_id, course_id, chapter_name, lesson_name):
|
|
"""Load and restore user learning progress if available."""
|
|
need_skip_chapters = 0
|
|
|
|
# Load learning progress
|
|
progress_result = load_learning_progress(user_id, course_id, chapter_name, lesson_name)
|
|
|
|
if progress_result['exists']:
|
|
progress = progress_result['data']
|
|
|
|
# Restore scores and calculate chapters to skip
|
|
if 'scores' in progress:
|
|
need_skip_chapters = len(progress['scores'])
|
|
chatmanager.scores = progress['scores']
|
|
|
|
# Restore chat history
|
|
chatmanager.chat_historys = progress.get('chat_historys', [])
|
|
|
|
# Restore chapter chain
|
|
if 'chapter_chain_now' in progress:
|
|
chatmanager.chapter_chain_now = progress['chapter_chain_now']
|
|
|
|
# Upload progress to cloud
|
|
upload_learning_progress_to_cloud(progress)
|
|
else:
|
|
# Use default values from progress_result
|
|
chatmanager.chat_historys = progress_result['data']['chat_historys']
|
|
chatmanager.scores = progress_result['data']['scores']
|
|
|
|
return need_skip_chapters
|
|
|
|
def on_login(self, data):
|
|
initial_state = self._setup_initial_state(data)
|
|
ex = initial_state['ex']
|
|
user_uuid = initial_state['user_uuid']
|
|
user_id = initial_state['user_id']
|
|
course_id = initial_state['course_id']
|
|
lesson_name = initial_state['lesson_name']
|
|
chapter_name = initial_state['chapter_name']
|
|
backboard_manager = ex["backboard_manager"]
|
|
|
|
ase_management = self._manage_ase_client(ex, user_uuid)
|
|
chatmanager = ase_management['chatmanager']
|
|
user_uuid2ase_client = ase_management['user_uuid2ase_client']
|
|
|
|
continue_learn = self._register_chatmanager_functions(
|
|
chatmanager, course_id, user_id, chapter_name, lesson_name, user_uuid
|
|
)
|
|
|
|
need_skip_chapters = 0
|
|
if continue_learn:
|
|
need_skip_chapters = self._load_and_restore_progress(
|
|
chatmanager, user_id, course_id, chapter_name, lesson_name
|
|
)
|
|
|
|
def _initialize_ase_client_and_chatmanager(self, user_uuid, user_id, course_id, chapter_name, lesson_name, chatmanager, user_uuid2ase_client):
|
|
"""Initialize ASE client and chatmanager with required parameters."""
|
|
# Load full markdown file
|
|
fmd, fmdp, fsp = load_full_markdown_file(course_id, chapter_name, lesson_name)
|
|
|
|
# Create and initialize ASE client
|
|
ase_client = HSAEngineClient(
|
|
current_app.config["ASE_ENGINE_URL"],
|
|
current_app.config["ASE_ENGINE_NAMESPACE"],
|
|
id=user_id,
|
|
chatmanager=chatmanager
|
|
)
|
|
user_uuid2ase_client[user_uuid] = ase_client
|
|
|
|
# Initialize chatmanager
|
|
chatmanager.init(
|
|
user_uuid,
|
|
ase_client,
|
|
fmd,
|
|
fmdp,
|
|
fsp,
|
|
course_id,
|
|
chapter_name,
|
|
lesson_name,
|
|
max_iter=5,
|
|
app=current_app,
|
|
socketio=self
|
|
)
|
|
|
|
return ase_client
|
|
|
|
def _setup_backboard(self, backboard_manager, user_uuid, user_id, course_id, lesson_name, chapter_name, chatmanager):
|
|
"""Set up backboard for the user and associate with chatmanager."""
|
|
# Add backboard
|
|
root_path = f'/home/{user_id}/{course_id}/{chapter_name}/{lesson_name}'
|
|
backboard_manager.add_backboard(user_uuid, user_id, course_id, lesson_name, root_path=root_path)
|
|
|
|
# Associate backboard with chatmanager
|
|
chatmanager.bb = backboard_manager.get_backboard(user_uuid)
|
|
|
|
def on_login(self, data):
|
|
initial_state = self._setup_initial_state(data)
|
|
ex = initial_state['ex']
|
|
user_uuid = initial_state['user_uuid']
|
|
user_id = initial_state['user_id']
|
|
course_id = initial_state['course_id']
|
|
lesson_name = initial_state['lesson_name']
|
|
chapter_name = initial_state['chapter_name']
|
|
backboard_manager = ex["backboard_manager"]
|
|
|
|
ase_management = self._manage_ase_client(ex, user_uuid)
|
|
chatmanager = ase_management['chatmanager']
|
|
user_uuid2ase_client = ase_management['user_uuid2ase_client']
|
|
|
|
continue_learn = self._register_chatmanager_functions(
|
|
chatmanager, course_id, user_id, chapter_name, lesson_name, user_uuid
|
|
)
|
|
|
|
need_skip_chapters = 0
|
|
if continue_learn:
|
|
need_skip_chapters = self._load_and_restore_progress(
|
|
chatmanager, user_id, course_id, chapter_name, lesson_name
|
|
)
|
|
|
|
# Initialize ASE client and chatmanager
|
|
ase_client = self._initialize_ase_client_and_chatmanager(
|
|
user_uuid, user_id, course_id, chapter_name, lesson_name, chatmanager, user_uuid2ase_client
|
|
)
|
|
|
|
def _skip_completed_chapters(self, chatmanager, need_skip_chapters):
|
|
"""Skip chapters that have already been completed based on learning progress."""
|
|
for _ in range(need_skip_chapters):
|
|
chatmanager.next_chapter()
|
|
|
|
def on_login(self, data):
|
|
initial_state = self._setup_initial_state(data)
|
|
ex = initial_state['ex']
|
|
user_uuid = initial_state['user_uuid']
|
|
user_id = initial_state['user_id']
|
|
course_id = initial_state['course_id']
|
|
lesson_name = initial_state['lesson_name']
|
|
chapter_name = initial_state['chapter_name']
|
|
backboard_manager = ex["backboard_manager"]
|
|
|
|
ase_management = self._manage_ase_client(ex, user_uuid)
|
|
chatmanager = ase_management['chatmanager']
|
|
user_uuid2ase_client = ase_management['user_uuid2ase_client']
|
|
|
|
continue_learn = self._register_chatmanager_functions(
|
|
chatmanager, course_id, user_id, chapter_name, lesson_name, user_uuid
|
|
)
|
|
|
|
need_skip_chapters = 0
|
|
if continue_learn:
|
|
need_skip_chapters = self._load_and_restore_progress(
|
|
chatmanager, user_id, course_id, chapter_name, lesson_name
|
|
)
|
|
|
|
# Initialize ASE client and chatmanager
|
|
ase_client = self._initialize_ase_client_and_chatmanager(
|
|
user_uuid, user_id, course_id, chapter_name, lesson_name, chatmanager, user_uuid2ase_client
|
|
)
|
|
|
|
# Set up backboard
|
|
self._setup_backboard(backboard_manager, user_uuid, user_id, course_id, lesson_name, chapter_name, chatmanager)
|
|
|
|
# Skip completed chapters if continuing learning
|
|
if continue_learn:
|
|
self._skip_completed_chapters(chatmanager, need_skip_chapters)
|
|
|
|
def _register_ase_routes(self, ase_client, user_uuid, chatmanager):
|
|
"""Register all required routes with ASE client."""
|
|
# Register on_connect entry
|
|
ase_client.register_on_connect_entry(
|
|
callback=on_connect_to_ase,
|
|
entry=(self, ase_client),
|
|
init_data={'room': user_uuid, 'restart': chatmanager.restart}
|
|
)
|
|
|
|
# Register dialog route
|
|
ase_client.register_route_with_entry(
|
|
route='dialog',
|
|
callback=receive_ase_dialog,
|
|
entry=self,
|
|
init_data={'room': user_uuid}
|
|
)
|
|
|
|
# Register dialog-hint route
|
|
ase_client.register_route_with_entry(
|
|
route='dialog-hint',
|
|
callback=receive_ase_message_hint,
|
|
entry=self,
|
|
init_data={'room': user_uuid}
|
|
)
|
|
|
|
# Register voice_out route
|
|
ase_client.register_route_with_entry(
|
|
route='voice_out',
|
|
callback=receive_ase_voice_out,
|
|
entry=self,
|
|
init_data={'room': user_uuid}
|
|
)
|
|
|
|
# Register judge route
|
|
ase_client.register_route_with_entry(
|
|
route='judge',
|
|
callback=receive_ase_judge,
|
|
entry=self,
|
|
init_data={'room': user_uuid}
|
|
)
|
|
|
|
# Register next_chapter route
|
|
ase_client.register_route_with_entry(
|
|
route='next_chapter',
|
|
callback=receive_ase_next_chapter,
|
|
entry=self,
|
|
init_data={'room': user_uuid}
|
|
)
|
|
|
|
# Register chapter_score route
|
|
ase_client.register_route_with_entry(
|
|
route='chapter_score',
|
|
callback=receive_ase_chapter_score,
|
|
entry=(get_or_load_current_user(), chatmanager),
|
|
init_data={'room': user_uuid}
|
|
)
|
|
|
|
# Register process route
|
|
ase_client.register_route_with_entry(
|
|
route='process',
|
|
callback=receive_ase_process,
|
|
entry=self,
|
|
init_data={'room': user_uuid}
|
|
)
|
|
|
|
# Register paste_detected route
|
|
ase_client.register_route_with_entry(
|
|
route='paste_detected',
|
|
callback=receive_ase_paste_detected,
|
|
entry=self,
|
|
init_data={'room': user_uuid}
|
|
)
|
|
|
|
# Connect the ASE client
|
|
ase_client.connect()
|
|
|
|
def on_login(self, data):
|
|
initial_state = self._setup_initial_state(data)
|
|
ex = initial_state['ex']
|
|
user_uuid = initial_state['user_uuid']
|
|
user_id = initial_state['user_id']
|
|
course_id = initial_state['course_id']
|
|
lesson_name = initial_state['lesson_name']
|
|
chapter_name = initial_state['chapter_name']
|
|
backboard_manager = ex["backboard_manager"]
|
|
|
|
ase_management = self._manage_ase_client(ex, user_uuid)
|
|
chatmanager = ase_management['chatmanager']
|
|
user_uuid2ase_client = ase_management['user_uuid2ase_client']
|
|
|
|
continue_learn = self._register_chatmanager_functions(
|
|
chatmanager, course_id, user_id, chapter_name, lesson_name, user_uuid
|
|
)
|
|
|
|
need_skip_chapters = 0
|
|
if continue_learn:
|
|
need_skip_chapters = self._load_and_restore_progress(
|
|
chatmanager, user_id, course_id, chapter_name, lesson_name
|
|
)
|
|
|
|
# Initialize ASE client and chatmanager
|
|
ase_client = self._initialize_ase_client_and_chatmanager(
|
|
user_uuid, user_id, course_id, chapter_name, lesson_name, chatmanager, user_uuid2ase_client
|
|
)
|
|
|
|
# Set up backboard
|
|
self._setup_backboard(backboard_manager, user_uuid, user_id, course_id, lesson_name, chapter_name, chatmanager)
|
|
|
|
# Skip completed chapters if continuing learning
|
|
if continue_learn:
|
|
self._skip_completed_chapters(chatmanager, need_skip_chapters)
|
|
|
|
# Set instance variables
|
|
self.chatmanager = chatmanager
|
|
self.ase_client = ase_client
|
|
|
|
# Register all ASE routes and connect
|
|
self._register_ase_routes(ase_client, user_uuid, chatmanager)
|
|
|
|
|
|
def on_language(self, language):
|
|
ex = current_app.extensions
|
|
|
|
def on_message(self, data):
|
|
ex = current_app.extensions
|
|
chatmanager = ex["user_uuid2chatmanager"]
|
|
uuid = session.get('user_uuid')
|
|
user_uuid2ase_client = ex["user_uuid2ase_client"]
|
|
if (type(data)==str):
|
|
data = json.loads(data)
|
|
if data['type'] == 'text':
|
|
res = user_uuid2ase_client[uuid].send_text('dialog', data['data'])
|
|
chatmanager[uuid].chat_historys.append({'role': 'user', 'content': data['data']})
|
|
|
|
if data['type'] == 'function': # 在这里 前端会发送允许执行的function与参数
|
|
d = data['data']
|
|
res = chatmanager[uuid].function_call(d['data']['name'], d['data'].get('args', {}))
|
|
d['data'] = res.to_dict()
|
|
emit(d['route'], d, room=uuid, namespace='/agent')
|
|
chatmanager[uuid].chat_historys.append({'role': 'user', 'content': data['data']})
|
|
user_uuid2ase_client[uuid].send_text(d['route'], data['data'])
|
|
|
|
def on_voice(self, voice_data):
|
|
ex = current_app.extensions
|
|
chatmanager = ex["user_uuid2chatmanager"]
|
|
uuid = session.get('user_uuid')
|
|
user_uuid2ase_client = ex["user_uuid2ase_client"]
|
|
res = user_uuid2ase_client[uuid].send_voice('voice_in', voice_data['data'])
|
|
|
|
|
|
def on_initiative(self,data): # 主动call
|
|
ex = current_app.extensions
|
|
uuid = session.get('user_uuid')
|
|
manager = ex["user_uuid2chatmanager"][uuid]
|
|
backboard_manager = ex["backboard_manager"]
|
|
if data['name'] == 'sample_judge':
|
|
manager.sample_judge(uuid, backboard_manager.get_backboard(uuid))
|
|
if data['name'] == 'judge':
|
|
res = manager.judge(uuid, backboard_manager.get_backboard(uuid))
|
|
emit('message', res.message, room=uuid, namespace='/agent')
|
|
|
|
|
|
def on_disconnect(self,data):
|
|
self.app.logger.info(f'AgentNamespace client disconnected, session user_uuid: {session.get("user_uuid", "unknown")}')
|
|
ex = current_app.extensions
|
|
uuid = session.get('user_uuid')
|
|
user_uuid2chatmanager = ex.get("user_uuid2chatmanager", {})
|
|
|
|
# 保存学习进度到MongoDB
|
|
try:
|
|
# 获取用户ID
|
|
uuid2username = ex.get("uuid2username", {})
|
|
user_id = uuid2username.get(uuid, "unknown")
|
|
self.app.logger.debug(f"get user's dialog his user_id={user_id}")
|
|
# 调用保存学习进度功能
|
|
chatmanager = user_uuid2chatmanager.get(uuid)
|
|
if chatmanager:
|
|
save_result = save_learning_progress(chatmanager, user_id)
|
|
|
|
except Exception as e:
|
|
self.app.logger.error(f"保存学习进度时发生异常: {str(e)}")
|
|
|
|
# 执行原有的断开连接逻辑
|
|
if uuid in user_uuid2chatmanager:
|
|
user_uuid2chatmanager[uuid].disconnect(uuid)
|
|
|
|
# 离开房间
|
|
if uuid:
|
|
leave_room(uuid, namespace='/agent')
|
|
|
|
self.app.logger.info("VSCode client disconnected")
|
|
self.app.logger.info(f"Disconnect reason: {str(data)}")
|