E
:\AI_System\web_ui>
python server.py
Traceback (most recent call last)
:
File "E
:\AI_System\web_ui\server.py", line 16, in <
module>
from flask_socketio import SocketIO, emit
ModuleNotFoundError: No module named &#
39;flask_socketio&#
39;
# E
:\AI_System\web_ui\server.py
import sys
import os
import time
import logging
import json
import traceback
import threading
import platform
import psutil
import importlib
import datetime
from pathlib import Path
from flask import Flask, jsonify, request, render_template, send_from_directory
from logging.handlers import TimedRotatingFileHandler
from flask_socketio import SocketIO, emit
from core.config import system_config as config
# 导入必要的模块（假设这些模块存在）
try
:
from environment.hardware_manager import create_hardware_manager
from cognitive_arch.life_scheduler import LifeScheduler
from agent.auto
nomous_agent import Auto
nomousAgent
from environment.environment_manager import EnvironmentManager
from environment.environment_state import EnvironmentState
from environment.spatial_simulator import SpatialSimulator
from environment.db_manager import DatabaseManager
except ImportError as e
:
logging.warning(f"部分模块导入失败
: {str(e)} - 使用模拟实现")
# ========== 全局协调器 ==========
coordinator =
None
def register_coordinator(coord)
:
"""注册意识系统协调器"""
global coordinator
coordinator = coord
if coordinator and hasattr(coordinator, &#
39;connect_to_ui&#
39;)
:
coordinator.connect_to_ui(update_ui)
def update_ui(event)
:
"""更新UI事件处理"""
if &#
39;socketio&#
39; in globals()
:
socketio.emit(&#
39;system_event&#
39;, event)
# ========== 初始化日志系统 ==========
def setup_logger()
:
"""配置全局日志系统"""
# 确保日志目录存在
config.LOG_DIR.mkdir(parents=True, exist_ok=True)
# 创建主日志记录器
logger = logging.getLogger(&#
39;WebServer&#
39;)
logger.setLevel(getattr(logging, config.LOG_LEVEL.upper(), logging.INFO))
# 日志格式
log_formatter = logging.Formatter(
&#
39;%(asctime)s - %(name)s - %(levelname)s - %(message)s&#
39;,
datefmt=&#
39;%Y-%m-%d %H
:%M
:%S&#
39;
)
# 文件日志处理器 (每天轮换，保留
30天)
file_handler = TimedRotatingFileHandler(
config.LOG_DIR / &#
39;web_server.log&#
39;,
when=&#
39;midnight&#
39;,
backupCount=
30,
encoding=&#
39;utf-8&#
39;
)
file_handler.setFormatter(log_formatter)
logger.addHandler(file_handler)
# 控制台日志处理器
console_handler = logging.StreamHandler()
console_handler.setFormatter(log_formatter)
logger.addHandler(console_handler)
# 安全日志处理装饰器
def safe_logger(func)
:
def wrapper(*args, **kwargs)
:
try
:
return func(*args, **kwargs)
except UnicodeEncodeError
:
new_args = []
for arg in args
:
if isinstance(arg, str)
:
new_args.append(arg.encode(&#
39;ascii&#
39;, &#
39;ig
nore&#
39;).decode(&#
39;ascii&#
39;))
else
:
new_args.append(arg)
return func(*new_args, **kwargs)
return wrapper
# 应用安全日志处理
for level in [&#
39;debug&#
39;, &#
39;info&#
39;, &#
39;warning&#
39;, &#
39;error&#
39;, &#
39;critical&#
39;]
:
setattr(logger, level, safe_logger(getattr(logger, level)))
return logger
# 初始化日志
logger = setup_logger()
# ========== 系统初始化 ==========
class SystemInitializer
:
"""负责初始化系统核心组件"""
def __init__(self)
:
self.base_dir = Path(__file__).resolve().parent.parent
self.ai_core =
None
self.hardware_manager =
None
self.life_scheduler =
None
self.ai_agent =
None
self.start_time = time.time()
self.environment_manager =
None
def initialize_system_paths(self)
:
"""初始化系统路径"""
sys.path.insert(0, str(self.base_dir))
logger.info(f"项目根目录
: {self.base_dir}")
sub_dirs = [&#
39;agent&#
39;, &#
39;core&#
39;, &#
39;utils&#
39;, &#
39;config&#
39;, &#
39;cognitive_arch&#
39;, &#
39;environment&#
39;]
for sub_dir in sub_dirs
:
full_path = self.base_dir / sub_dir
if full_path.exists()
:
sys.path.insert(0, str(full_path))
logger.info(f"添加路径
: {full_path}")
else
:
logger.warning(f"目录不存在
: {full_path}")
def initialize_environment_manager(self)
:
"""初始化环境管理器"""
try
:
env_config = {
&#
39;update_interval&#
39;
: 1.0,
&#
39;spatial&#
39;
: {&#
39;grid_size&#
39;
: 1.0}
}
self.environment_manager = EnvironmentManager(env_config)
self.environment_manager.start()
logger.info("✅ 环境管理器初始化成功")
return self.environment_manager
except Exception as e
:
logger.error(f"❌ 环境管理器初始化失败
: {str(e)}")
logger.warning("⚠️ 环境交互功能将不可用")
return
None
def initialize_ai_core(self)
:
"""初始化AI核心系统"""
class AICore
:
def __init__(self, base_dir)
:
self.base_dir = Path(base_dir)
self.genetic_code = self.load_genetic_code()
self.physical_state = {
"health"
: 100,
"energy"
: 100,
"mood"
: "calm"
}
self.dependencies = self.scan_dependencies()
def load_genetic_code(self)
:
code_path = self.base_dir / "core" / "genetic_code.py"
try
:
with open(code_path, "r", encoding="utf-8") as f
:
return f.read()
except File
NotFoundError
:
return "# 默认遗传代码\nclass AICore
:\n pass"
def scan_dependencies(self)
:
return {
"nervous_system"
: "flask",
"memory"
: "
sqlite",
"perception"
: "opencv",
"reasoning"
: "transformers"
}
def mutate(self, new_code)
:
try
:
code_path = self.base_dir / "core" / "genetic_code.py"
with open(code_path, "w", encoding="utf-8") as f
:
f.write(new_code)
importlib.reload(sys.
modules[&#
39;core.genetic_code&#
39;])
self.genetic_code = new_code
return True, "核心代码更新成功，系统已进化"
except Exception as e
:
return False, f"进化失败
: {str(e)}"
def wear_dependency(self, dependency_name, version)
:
self.dependencies[dependency_name] = version
return f"已穿戴 {dependency_name}@{version}"
def get_state(self)
:
return {
"genetic_code_hash"
: hash(self.genetic_code),
"dependencies"
: self.dependencies,
"physical_state"
: self.physical_state,
"hardware_environment"
: self.get_hardware_info()
}
def get_hardware_info(self)
:
return {
"cpu"
: platform.processor(),
"gpu"
: "NVIDIA RTX
3090" if psutil.virtual_memory().total > 16 * 1024 **
3 else "Integrated",
"memory_gb"
: round(psutil.virtual_memory().total / (1024 **
3), 1),
"storage_gb"
: round(psutil.disk_usage(&#
39;/&#
39;).total / (1024 **
3), 1)
}
self.ai_core = AICore(self.base_dir)
logger.info("✅ AI核心系统初始化完成")
return self.ai_core
def initialize_hardware_manager(self)
:
"""初始化硬件管理器"""
try
:
config_path = config.CONFIG_DIR / "hardware_config.json"
self.hardware_manager = create_hardware_manager(config_path)
logger.info("✅ 硬件管理器初始化成功")
return self.hardware_manager
except Exception as e
:
logger.error(f"❌ 硬件管理器初始化失败
: {str(e)}")
logger.warning("⚠️ 使用内置简单硬件管理器")
class SimpleHardwareManager
:
def __init__(self)
:
self.available_hardware = {
"cpu"
: ["Intel i9-1
3900K", "AMD Ryzen 9 7950X", "Apple M2 Max"],
"gpu"
: ["NVIDIA RTX 4090", "AMD Radeon RX 7900 XTX", "Apple M2 GPU"],
"memory"
: [16,
32, 64, 128],
"storage"
: ["1TB SSD", "2TB SSD", "4TB SSD", "8TB HDD"],
"peripherals"
: ["4K Camera", "
3D Scanner", "High-Fidelity Microphone"]
}
self.current_setup = {
"cpu"
: platform.processor(),
"gpu"
: "Integrated Graphics",
"memory"
: round(psutil.virtual_memory().total / (1024 **
3), 1),
"storage"
: round(psutil.disk_usage(&#
39;/&#
39;).total / (1024 **
3), 1)
}
def request_hardware(self, hardware_type, specification)
:
if hardware_type
not in self.available_hardware
:
return False, f"不支持硬件类型
: {hardware_type}"
if specification
not in self.available_hardware[hardware_type]
:
return False, f"不支持的规格
: {specification}"
self.current_setup[hardware_type] = specification
return True, f"已请求 {hardware_type}
: {specification}。请管理员完成安装。"
def get_current_setup(self)
:
return self.current_setup
def get_performance_metrics(self)
:
return {
"cpu_usage"
: psutil.cpu_percent(),
"memory_usage"
: psutil.virtual_memory().percent,
"disk_usage"
: psutil.disk_usage(&#
39;/&#
39;).percent,
"cpu_temp"
: 45.0,
"gpu_temp"
: 55.0,
"network_io"
: {
"sent"
: psutil.net_io_counters().bytes_sent,
"received"
: psutil.net_io_counters().bytes_recv
},
"last_updated"
: datetime.datetime.
now().isoformat()
}
self.hardware_manager = SimpleHardwareManager()
return self.hardware_manager
def initialize_life_scheduler(self)
:
"""初始化生活调度器"""
try
:
config.MODEL_CACHE_DIR.mkdir(parents=True, exist_ok=True)
self.life_scheduler = LifeScheduler()
logger.info("✅ 生活调度器初始化成功")
life_thread = threading.Thread(
target=self._update_life_status,
daemon=True,
name="LifeSystemThread"
)
life_thread.start()
logger.info("✅ 生活系统后台线程已启动")
return self.life_scheduler
except Exception as e
:
logger.error(f"❌ 生活调度器初始化失败
: {str(e)}")
return
None
def _update_life_status(self)
:
logger.info("🚦 生活系统后台线程启动")
while True
:
try
:
now = datetime.datetime.
now()
current_hour =
now.hour
if 8 <= current_hour < 9
:
self.life_scheduler.wake_up()
elif 12 <= current_hour < 1
3:
self.life_scheduler.have_meal("lunch")
elif 19 <= current_hour < 20
:
self.life_scheduler.have_meal("dinner")
elif 2
3 <= current_hour or current_hour < 6
:
self.life_scheduler.go_to_sleep()
self.life_scheduler.log_activity("系统状态更新")
time.sleep(60)
except Exception as e
:
logger.error(f"生活系统更新失败
: {str(e)}", exc_info=True)
time.sleep(
300)
def initialize_ai_agent(self)
:
"""初始化AI智能体"""
try
:
config.MODEL_CACHE_DIR.mkdir(parents=True, exist_ok=True)
self.ai_agent = Auto
nomousAgent(
model_path=config.AGENT_PATH,
cache_dir=config.MODEL_CACHE_DIR,
use_gpu=config.USE_GPU,
default_model=config.DEFAULT_MODEL
)
logger.info("✅ AI智能体初始化成功")
return self.ai_agent
except Exception as e
:
logger.error(f"❌ AI智能体初始化失败
: {str(e)}")
return
None
def start_evolution_monitor(self)
:
def monitor()
:
while True
:
try
:
cpu_usage = psutil.cpu_percent()
mem_usage = psutil.virtual_memory().percent
if cpu_usage > 80
:
self.ai_core.physical_state["energy"] = max(20, self.ai_core.physical_state["energy"] - 5)
self.ai_core.physical_state["mood"] = "strained"
elif cpu_usage <
30
:
self.ai_core.physical_state["energy"] = min(100, self.ai_core.physical_state["energy"] + 2)
if self.hardware_manager
:
current_hw = self.ai_core.get_hardware_info()
requested_hw = self.hardware_manager.get_current_setup()
for hw_type, spec in requested_hw.items()
:
if current_hw.get(hw_type) != spec
:
if hw_type == "cpu"
:
self.ai_core.physical_state["health"] = min(100, self.ai_core.physical_state[
"health"] + 10)
elif hw_type == "gpu"
:
self.ai_core.physical_state["energy"] = min(100, self.ai_core.physical_state[
"energy"] + 20)
time.sleep(60)
except Exception as e
:
logging.error(f"进化监控错误
: {str(e)}")
time.sleep(
300)
monitor_thread = threading.Thread(target=monitor, daemon=True)
monitor_thread.start()
logger.info("✅ 进化监控线程已启动")
def initialize_all(self)
:
logger.info("=" * 50)
logger.info("🚀 开始初始化AI系统")
logger.info("=" * 50)
self.initialize_system_paths()
self.initialize_ai_core()
self.initialize_hardware_manager()
self.initialize_life_scheduler()
self.initialize_ai_agent()
self.initialize_environment_manager()
self.start_evolution_monitor()
logger.info("✅ 所有系统组件初始化完成")
return {
"ai_core"
: self.ai_core,
"hardware_manager"
: self.hardware_manager,
"life_scheduler"
: self.life_scheduler,
"ai_agent"
: self.ai_agent,
"environment_manager"
: self.environment_manager
}
# ========== Flask应用工厂 ==========
def create_app()
:
app = Flask(
__name__,
template_folder=&#
39;templates&#
39;,
static_folder=&#
39;static&#
39;,
static_url_path=&#
39;/static&#
39;
)
app.secret_key = config.SECRET_KEY
system_initializer = SystemInitializer()
components = system_initializer.initialize_all()
app.config[&#
39;SYSTEM_COMPONENTS&#
39;] = components
app.config[&#
39;START_TIME&#
39;] = system_initializer.start_time
app.config[&#
39;BASE_DIR&#
39;] = system_initializer.base_dir
# 初始化SocketIO
app.config[&#
39;SOCKETIO&#
39;] = SocketIO(app, cors_allowed_origins="*", async_mode=&#
39;threading&#
39;)
# 注册路由
register_routes(app)
register_error_handlers(app)
return app
# ========== 环境交互路由 ==========
def register_environment_routes(app)
:
@app.route(&#
39;/environment&#
39;)
def environment_view()
:
return render_template(&#
39;environment_view.html&#
39;)
@app.route(&#
39;/api/environment/state&#
39;, methods=[&#
39;GET&#
39;])
def get_environment_state()
:
env_manager = app.config[&#
39;SYSTEM_COMPONENTS&#
39;].get(&#
39;environment_manager&#
39;)
if
not env_manager
:
return jsonify({"success"
: False, "error"
: "环境管理器未初始化"}), 50
3
try
:
state = env_manager.get_state()
return jsonify(state.to_dict())
except Exception as e
:
app.logger.error(f"获取环境状态失败
: {traceback.format_exc()}")
return jsonify({"success"
: False, "error"
: str(e)}), 500
@app.route(&#
39;/api/environment/action&#
39;, methods=[&#
39;POST&#
39;])
def execute_environment_action()
:
env_manager = app.config[&#
39;SYSTEM_COMPONENTS&#
39;].get(&#
39;environment_manager&#
39;)
if
not env_manager
:
return jsonify({"success"
: False, "error"
: "环境管理器未初始化"}), 50
3
try
:
data = request.json
action = data.get(&#
39;action&#
39;)
params = data.get(&#
39;params&#
39;, {})
if
not action
:
return jsonify({"success"
: False, "error"
: "缺少动作参数"}), 400
success = env_manager.execute_action(action, params)
return jsonify({"success"
: success, "action"
: action})
except Exception as e
:
app.logger.error(f"执行环境动作失败
: {traceback.format_exc()}")
return jsonify({"success"
: False, "error"
: str(e)}), 500
# ========== 环境状态广播 ==========
def setup_environment_broadcast(app)
:
socketio = app.config[&#
39;SOCKETIO&#
39;]
@socketio.on(&#
39;connect&#
39;, namespace=&#
39;/environment&#
39;)
def handle_environment_connect()
:
app.logger.info(&#
39;客户端已连接环境WebSocket&#
39;)
@socketio.on(&#
39;disconnect&#
39;, namespace=&#
39;/environment&#
39;)
def handle_environment_disconnect()
:
app.logger.info(&#
39;客户端已断开环境WebSocket&#
39;)
def broadcast_environment_state()
:
env_manager = app.config[&#
39;SYSTEM_COMPONENTS&#
39;].get(&#
39;environment_manager&#
39;)
if
not env_manager
:
return
while True
:
try
:
state = env_manager.get_state()
socketio.emit(&#
39;environment_update&#
39;, state.to_dict(), namespace=&#
39;/environment&#
39;)
time.sleep(1)
except Exception as e
:
app.logger.error(f"环境状态广播失败
: {str(e)}")
time.sleep(5)
broadcast_thread = threading.Thread(
target=broadcast_environment_state,
daemon=True,
name="EnvironmentBroadcastThread"
)
broadcast_thread.start()
app.logger.info("✅ 环境状态广播线程已启动")
# ========== 路由注册 ==========
def register_routes(app)
:
register_environment_routes(app)
setup_environment_broadcast(app)
@app.route(&#
39;/&#
39;)
def index()
:
return render_template(&#
39;agent_interface.html&#
39;)
@app.route(&#
39;/static/<path
:filename>&#
39;)
def static_files(filename)
:
try
:
return send_from_directory(app.static_folder, filename)
except Exception as e
:
app.logger.error(f"静态文件服务失败
: {filename} - {str(e)}")
return jsonify({"error"
: "文件未找到"}), 404
@app.route(&#
39;/status&#
39;)
def status()
:
try
:
components = app.config[&#
39;SYSTEM_COMPONENTS&#
39;]
status_data = {
"server"
: {
"status"
: "running",
"uptime"
: time.time() - app.config[&#
39;START_TIME&#
39;],
"version"
: "1.0.0",
"config"
: {
"host"
: config.HOST,
"port"
: config.PORT,
"log_level"
: config.LOG_LEVEL,
"default_model"
: config.DEFAULT_MODEL
}
},
"core"
: components[&#
39;ai_core&#
39;].get_state(),
"hardware"
: components[&#
39;hardware_manager&#
39;].get_current_setup()
}
if components[&#
39;environment_manager&#
39;]
:
try
:
status_data["environment"] = components[&#
39;environment_manager&#
39;].get_state().to_dict()
except Exception as e
:
status_data["environment"] = {"error"
: str(e)}
if components[&#
39;life_scheduler&#
39;]
:
try
:
status_data["life_system"] = components[&#
39;life_scheduler&#
39;].get_current_state()
except Exception as e
:
status_data["life_system"] = {"error"
: str(e)}
if components[&#
39;ai_agent&#
39;]
:
try
:
status_data["agent"] = components[&#
39;ai_agent&#
39;].get_status()
except Exception as e
:
status_data["agent"] = {"error"
: str(e)}
return jsonify(status_data)
except Exception as e
:
app.logger.error(f"获取状态失败
: {traceback.format_exc()}")
return jsonify({"error"
: "内部错误", "details"
: str(e)}), 500
# 核心系统路由
@app.route(&#
39;/api/core/state&#
39;)
def get_core_state()
:
return jsonify(app.config[&#
39;SYSTEM_COMPONENTS&#
39;][&#
39;ai_core&#
39;].get_state())
@app.route(&#
39;/api/core/mutate&#
39;, methods=[&#
39;POST&#
39;])
def mutate_core()
:
data = request.get_json()
new_code = data.get(&#
39;genetic_code&#
39;)
if
not new_code
:
return jsonify({"success"
: False, "error"
: "缺少遗传代码"}), 400
success, message = app.config[&#
39;SYSTEM_COMPONENTS&#
39;][&#
39;ai_core&#
39;].mutate(new_code)
return jsonify({"success"
: success, "message"
: message})
@app.route(&#
39;/api/core/wear&#
39;, methods=[&#
39;POST&#
39;])
def wear_dependency()
:
data = request.get_json()
dep_name = data.get(&#
39;dependency&#
39;)
version = data.get(&#
39;version&#
39;, &#
39;latest&#
39;)
if
not dep_name
:
return jsonify({"success"
: False, "error"
: "缺少依赖名称"}), 400
result = app.config[&#
39;SYSTEM_COMPONENTS&#
39;][&#
39;ai_core&#
39;].wear_dependency(dep_name, version)
return jsonify({"success"
: True, "message"
: result})
# 硬件管理路由
@app.route(&#
39;/api/hardware/catalog&#
39;)
def get_hardware_catalog()
:
return jsonify(app.config[&#
39;SYSTEM_COMPONENTS&#
39;][&#
39;hardware_manager&#
39;].available_hardware)
@app.route(&#
39;/api/hardware/request&#
39;, methods=[&#
39;POST&#
39;])
def request_hardware()
:
data = request.get_json()
hw_type = data.get(&#
39;type&#
39;)
spec = data.get(&#
39;specification&#
39;)
if
not hw_type or
not spec
:
return jsonify({"success"
: False, "error"
: "缺少硬件类型或规格"}), 400
success, message = app.config[&#
39;SYSTEM_COMPONENTS&#
39;][&#
39;hardware_manager&#
39;].request_hardware(hw_type, spec)
return jsonify({"success"
: success, "message"
: message})
@app.route(&#
39;/api/hardware/current&#
39;)
def get_current_hardware()
:
return jsonify(app.config[&#
39;SYSTEM_COMPONENTS&#
39;][&#
39;hardware_manager&#
39;].get_current_setup())
# 生活系统路由
@app.route(&#
39;/life&#
39;)
def life_dashboard()
:
return render_template(&#
39;life_dashboard.html&#
39;)
@app.route(&#
39;/api/life/status&#
39;)
def get_life_status()
:
components = app.config[&#
39;SYSTEM_COMPONENTS&#
39;]
if
not components[&#
39;life_scheduler&#
39;]
:
return jsonify({"success"
: False, "error"
: "生活系统未初始化"}), 50
3
try
:
current_state = components[&#
39;life_scheduler&#
39;].get_current_state()
recent_activities = components[&#
39;life_scheduler&#
39;].get_recent_activities(10)
return jsonify({
"success"
: True,
"current_activity"
: current_state.get("current_activity", "未知"),
"next_scheduled"
: current_state.get("next_scheduled", "未知"),
"schedule"
: components[&#
39;life_scheduler&#
39;].daily_schedule,
"recent_activities"
: recent_activities,
"energy_level"
: current_state.get("energy_level", 100),
"mood"
: current_state.get("mood", "平静")
})
except Exception as e
:
app.logger.error(f"获取生活状态失败
: {traceback.format_exc()}")
return jsonify({"success"
: False, "error"
: str(e)}), 500
@app.route(&#
39;/adjust_schedule&#
39;, methods=[&#
39;POST&#
39;])
def adjust_schedule()
:
components = app.config[&#
39;SYSTEM_COMPONENTS&#
39;]
if
not components[&#
39;life_scheduler&#
39;]
:
return jsonify({"success"
: False, "error"
: "生活系统未初始化"}), 50
3
try
:
data = request.json
adjustments = data.get("adjustments", {})
valid_activities = ["wake_up", "breakfast", "lunch", "dinner", "sleep"]
for activity, new_time in adjustments.items()
:
if activity
not in valid_activities
:
return jsonify({"success"
: False, "error"
: f"无效的活动类型
: {activity}"}), 400
if
not isinstance(new_time, str) or len(new_time) != 5 or new_time[2] != &#
39;
:&#
39;
:
return jsonify({"success"
: False, "error"
: f"无效的时间格式
: {new_time}"}), 400
components[&#
39;life_scheduler&#
39;].adjust_schedule(adjustments)
return jsonify({
"success"
: True,
"message"
: "计划表已更新",
"new_schedule"
: components[&#
39;life_scheduler&#
39;].daily_schedule
})
except Exception as e
:
app.logger.error(f"调整作息时间失败
: {traceback.format_exc()}")
return jsonify({"success"
: False, "error"
: str(e)}), 400
# 聊天路由
@app.route(&#
39;/chat&#
39;, methods=[&#
39;POST&#
39;])
def chat()
:
components = app.config[&#
39;SYSTEM_COMPONENTS&#
39;]
if
not components[&#
39;ai_agent&#
39;]
:
return jsonify({"error"
: "Agent未初始化"}), 50
3
try
:
data = request.get_json()
user_input = data.get(&#
39;message&#
39;, &#
39;&#
39;)
user_id = data.get(&#
39;user_id&#
39;, &#
39;default&#
39;)
if
not user_input
:
return jsonify({"error"
: "消息内容不能为空"}), 400
app.logger.info(f"聊天请求
: 用户={user_id}, 内容长度={len(user_input)}")
response = components[&#
39;ai_agent&#
39;].process_input(user_input, user_id)
return jsonify({"response"
: response})
except Exception as e
:
app.logger.error(f"聊天处理失败
: {traceback.format_exc()}")
return jsonify({"error"
: "聊天处理失败", "details"
: str(e)}), 500
# 家具管理路由
furniture_cache = {}
CACHE_DURATION =
3600 # 1小时
@app.route(&#
39;/api/furniture&#
39;)
def get_furniture()
:
try
:
room = request.args.get(&#
39;room&#
39;, &#
39;workshop&#
39;)
app.logger.info(f"获取家具数据
: 房间={room}")
current_time = time.time()
if room in furniture_cache and current_time - furniture_cache[room][&#
39;timestamp&#
39;] < CACHE_DURATION
:
return jsonify(furniture_cache[room][&#
39;data&#
39;])
furniture_data = {
"workshop"
: [
{"type"
: "desk", "position"
: {"x"
: 0, "y"
: -1.5, "z"
: -
3}, "rotation"
: {"x"
: 0, "y"
: 0, "z"
: 0}},
{"type"
: "chair", "position"
: {"x"
: 0, "y"
: -1.5, "z"
: -1}, "rotation"
: {"x"
: 0, "y"
: 0, "z"
: 0}},
{"type"
: "bookshelf", "position"
: {"x"
: 3, "y"
: 0, "z"
: -
3}, "rotation"
: {"x"
: 0, "y"
: 0, "z"
: 0}},
{"type"
: "computer", "position"
: {"x"
: 0.5, "y"
: -0.5, "z"
: -
3.2},
"rotation"
: {"x"
: 0, "y"
: 0, "z"
: 0}}
],
"living_room"
: [
{"type"
: "sofa", "position"
: {"x"
: 0, "y"
: 0, "z"
: -2}, "rotation"
: {"x"
: 0, "y"
: 0, "z"
: 0}},
{"type"
: "tv", "position"
: {"x"
: 0, "y"
: 1.5, "z"
: -
3}, "rotation"
: {"x"
: 0, "y"
: 0, "z"
: 0}}
],
"bedroom"
: [
{"type"
: "bed", "position"
: {"x"
: 0, "y"
: 0, "z"
: -
3}, "rotation"
: {"x"
: 0, "y"
: 0, "z"
: 0}},
{"type"
: "nightstand", "position"
: {"x"
: 1.5, "y"
: 0, "z"
: -2.5},
"rotation"
: {"x"
: 0, "y"
: 0, "z"
: 0}}
]
}
furniture_cache[room] = {
&#
39;timestamp&#
39;
: current_time,
&#
39;data&#
39;
: furniture_data.get(room, [])
}
return jsonify(furniture_cache[room][&#
39;data&#
39;])
except Exception as e
:
app.logger.error(f"获取家具数据失败
: {traceback.format_exc()}")
return jsonify({"error"
: "内部错误", "details"
: str(e)}), 500
# ========== 错误处理器 ==========
def register_error_handlers(app)
:
@app.errorhandler(404)
def page_
not_found(error)
:
app.logger.warning(f"404错误
: {request.path}")
return jsonify({
"error"
: "资源未找到",
"path"
: request.path,
"method"
: request.method
}), 404
@app.errorhandler(500)
def internal_server_error(error)
:
app.logger.error(f"500错误
: {str(error)}")
return jsonify({
"error"
: "服务器内部错误",
"message"
: "系统遇到意外错误，请稍后重试"
}), 500
@app.errorhandler(Exception)
def handle_general_exception(error)
:
app.logger.error(f"未处理异常
: {traceback.format_exc()}")
return jsonify({
"error"
: "未处理的异常",
"type"
: type(error).__name__,
"message"
: str(error)
}), 500
# ========== WebSocket处理 ==========
def setup_websocket_handlers(socketio)
:
@socketio.on(&#
39;connect&#
39;)
def handle_connect()
:
logger.info(&#
39;客户端已连接&#
39;)
socketio.emit(&#
39;system_status&#
39;, {&#
39;status&#
39;
: &#
39;ready&#
39;})
@socketio.on(&#
39;disconnect&#
39;)
def handle_disconnect()
:
logger.info(&#
39;客户端已断开连接&#
39;)
@socketio.on(&#
39;user_message&#
39;)
def handle_user_message(data)
:
user_id = data.get(&#
39;user_id&#
39;, &#
39;guest&#
39;)
message = data.get(&#
39;message&#
39;, &#
39;&#
39;)
logger.info(f"收到来自 {user_id} 的消息
: {message}")
# 处理消息逻辑
response = f"已收到您的消息
: {message}"
# 如果有协调器，使用协调器处理
global coordinator
if coordinator
:
try
:
response = coordinator.process_message(message)
except Exception as e
:
logger.error(f"协调器处理消息失败
: {str(e)}")
socketio.emit(&#
39;agent_response&#
39;, {
&#
39;user_id&#
39;
: user_id,
&#
39;response&#
39;
: response
})
# ========== 主程序入口 ==========
if __name__ == &#
39;__main__&#
39;
:
try
:
app = create_app()
socketio = app.config[&#
39;SOCKETIO&#
39;]
# 设置WebSocket处理器
setup_websocket_handlers(socketio)
# 启动服务器
socketio.run(
app,
host=config.HOST,
port=config.PORT,
debug=config.DEBUG,
use_reloader=False
)
logger.info(f"服务器运行在 http
://{config.HOST}
:{config.PORT}")
except KeyboardInterrupt
:
logger.info("服务器关闭")
except Exception as e
:
logger.critical(f"服务器启动失败
: {str(e)}")
logger.error(traceback.format_exc())
扫一扫
8万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
