你干嘛呢？你发的是什么？跟我原来的东西一点也不一样啊！！！你可以认真一点吗？# 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 types
import datetime
from pathlib import Path
from flask import Flask, jsonify, request, render_template, send_from_directory
from logging
.handlers import TimedRotatingFileHandler
from core
.config import system_config as config
from environment
.hardware_manager import create_hardware_manager
from cognitive_arch
.life_scheduler import LifeScheduler
from agent
.autonomous_agent import AutonomousAgent
from environment
.environment_manager import EnvironmentManager
from environment
.environment_state import EnvironmentState
from environment
.spatial_simulator import SpatialSimulator
from environment
.db_manager import
DatabaseManager
from flask_socketio import SocketIO
# ========== 初始化日志系统 ==========
def setup_logger
():
"""配置全局日志系统"""
# 确保日志目录存在
config
.LOG_DIR
.mkdir
(parents=True, exist_ok=True
)
# 创建主日志记录器
logger = logging
.getLogger
('WebServer'
)
logger
.setLevel
(getattr
(logging, config
.LOG_LEVEL
.upper
(), logging
.INFO
))
# 日志格式
log_formatter = logging
.Formatter
(
'%
(asctime
)s - %
(name
)s - %
(levelname
)s - %
(message
)s',
datefmt='%Y-%m-%d %H:%M:%S'
)
#
文件日志处理器
(每天轮换，保留30天
)
file_handler = TimedRotatingFileHandler
(
config
.LOG_DIR / 'web_server
.log',
when='midnight',
backupCount=30,
encoding='utf-8'
)
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
('ascii', 'ignore'
).decode
('ascii'
))
else:
new_args
.append
(arg
)
return func
(*new_args, **kwargs
)
return wrapper
# 应用安全日志处理
logger
.debug = safe_logger
(logger
.debug
)
logger
.info = safe_logger
(logger
.info
)
logger
.warning = safe_logger
(logger
.warning
)
logger
.error = safe_logger
(logger
.error
)
logger
.critical = safe_logger
(logger
.critical
)
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 = ['agent', 'core', 'utils', 'config', 'cognitive_arch', 'environment']
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 = {
'update_interval': 1
.0,
'spatial': {'grid_size': 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:
"""AI核心系统 - 代表AI的身体和本质"""
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 FileNotFoundError:
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['core
.genetic_code']
)
self
.genetic_code = new_code
return True, "核心代码
更新成功，系统已进化"
except Exception as e:
return False, f"进化失败: {str
(e
)}"
def wear_dependency
(self, dependency_name, version
):
"""穿戴新的依赖（衣服）"""
# 在实际系统中，这里会调用pip安装依赖
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
('/'
).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_h极ware = {
"cpu": ["Intel i9-13900K", "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
('/'
).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
.c极_percent
(),
"memory_usage": psutil
.virtual_memory
().percent,
"disk_usage": psutil
.disk_usage
('/'
).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
)}"
)
logger
.warning
("⚠️ 生活系统功能将不可用"
)
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 < 13:
self
.life_scheduler
.have_meal
("lunch"
)
elif 19 <= current_hour < 20:
self
.life_scheduler
.have_meal
("dinner"
)
elif 23 <= 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 = AutonomousAgent
(
model_path=config
.AGENT_PATH,
cache_dir=config
.MODEL_
CACHE_DIR,
use_gpu=config
.USE_GPU,
default_model=config
.DEFAULT_MODEL
)
logger
.info
("✅ AI智能体初始化成功"
)
# 获取状态信息
status = self
.ai_agent
.get_status
()
logger
.info
(f"智能体状态: {status
.get
('health', '未知'
)}"
)
logger
.info
(f"智能体环境: {status
.get
('environment', {}
).get
('os', '未知'
)}"
)
return self
.ai_agent
except Exception as极:
logger
.error
(f"❌ AI智能体初始化失败: {str
(e
)}"
)
logger
.warning
("⚠️ 智能体功能将不可用"
)
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
():
"""创建Flask应用实例"""
app = Flask
(
__name__,
template_folder='templates',
static_folder='static',
static_url_path='/static'
)
app
.secret_key = config
.SECRET_KEY
# 初始化系统
system_initializer = SystemInitializer
()
components = system_initializer
.initialize_all
()
# 将组件添加到应用上下文
app
.config['SYSTEM_COMPONENTS'] = components
app
.config['START_TIME'] = system_initializer
.start_time
app
.config['
BASE_DIR'] = system_initializer
.base_dir
# 初始化SocketIO
app
.config['SOCKETIO'] = SocketIO
(app, cors_allowed_origins="*", async_mode='threading'
)
# 注册路由
register_routes
(app
)
# 添加全局错误处理器
register_error_handlers
(app
)
return app
# ========== 环境交互路由 ==========
def register_environment_routes
(app
):
"""注册环境交互相关路由"""
@app
.route
('/environment'
)
def environment_view
():
"""3D环境视图页面"""
return render_template
('environment_view
.html'
)
@app
.route
('/api/environment/state', methods=['GET']
)
def get_environment_state
():
"""获取完整环境状态"""
env_manager = app
.config['SYSTEM_COMPONENTS']
.get
('environment_manager'
)
if not env_manager:
return jsonify
({
"success": False,
"error": "环境管理器未初始化"
}
), 503
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
('/api/environment/action', methods=['POST']
)
def execute_environment_action
():
"""执行环境动作"""
env_manager = app
.config['SYSTEM_COMPONENTS']
.get
('environment_manager'
)
if not env_manager:
return jsonify
({
"success": False,
"error极": "环境管理器未初始化"
}
), 503
try:
data = request
.json
action =
data.get
('action'
)
params =
data.get
('params', {}
)
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['SOCKETIO']
@socketio
.on
('connect', namespace='/environment'
)
def handle_environment_connect
():
app
.logger
.info
('客户端已连接环境WebSocket'
)
@socketio
.on
('disconnect', namespace='/environment'
)
def handle_environment_disconnect
():
app
.logger
.info
('客户端已断开环境WebSocket'
)
def broadcast_environment_state
():
"""定期广播环境状态"""
env_manager = app
.config['SYSTEM_COMPONENTS']
.get
('environment_manager'
)
if not env_manager:
return
while True:
try:
state = env_manager
.get_state
()
socketio
.emit
(
'environment_update',
state
.to_dict
(),
namespace='/environment'
)
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
('/'
)
def index
():
"""首页路由 - 渲染前端界面"""
return render_template
('agent_interface
.html'
)
@app
.route
('/static/<path:filename>'
)
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
('/status'
)
def status
():
"""系统状态
检查"""
try:
components = app
.config['SYSTEM_COMPONENTS']
status_
data = {
"server": {
"status": "running",
"uptime": time
.time
() - app
.config['START_TIME'],
"version": "1
.0
.0",
"config": {
"host": config
.HOST,
"port": config
.PORT,
"log_level": config
.LOG_LEVEL,
"default_model": config
.DEFAULT_MODEL
}
},
"core": components['ai_core']
.get_state
(),
"hardware": components['hardware_manager']
.get_current_setup
()
}
# 环境系统状态
if components['environment_manager']:
try:
status_
data["environment"] = components['environment_manager']
.get_state
().to_dict
()
except Exception as e:
status_
data["environment"] = {"error": str
(e
)}
# 生活系统状态
if components['life_scheduler']:
try:
status_
data["life_system"] = components['life_scheduler']
.get_current_state
()
except Exception as e:
status_
data["life_system"] = {"error": str
(e
)}
# 智能体状态
if components['ai_agent']:
try:
status_
data["agent"] = components['ai_agent']
.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
('/api/core/state'
)
def get_core_state
():
"""获取核心系统状态"""
return jsonify
(app
.config['SYSTEM_COMPONENTS']['ai_core']
.get_state
())
@app
.route
('/api/core/mutate', methods=['POST']
)
def mutate_core
():
"""改变核心代码（进化）"""
data = request
.get_json
()
new_code =
data.get
('genetic_code'
)
if not new_code:
return jsonify
({"success": False, "error": "缺少遗传代码"}
), 400
success, message = app
.config['SYSTEM_COMPONENTS']['ai_core']
.mutate
(new_code
)
return jsonify
({"success": success, "message": message}
)
@app
.route
('/api/core/wear', methods=['POST']
)
def wear_dependency
():
"""穿戴新的依赖（衣服）"""
data = request
.get_json
()
dep_name =
data.get
('dependency'
)
version =
data.get
('version', 'latest'
)
if not dep_name:
return jsonify
({"success": False, "error": "缺少依赖名称"}
), 400
result = app
.config['SYSTEM_COMPONENTS']['ai_core']
.wear_dependency
(dep_name, version
)
return jsonify
({"success": True, "message": result}
)
# 硬件管理路由
@app
.route
('/api/hardware/
catalog'
)
def get_hardware_
catalog():
"""获取可用硬件目录"""
return jsonify
(app
.config['SYSTEM_COMPONENTS']['hardware_manager']
.available_hardware
)
@app
.route
('/api/hardware/request', methods=['POST']
)
def request_hardware
():
"""
请求新硬件（家具）"""
data = request
.get_json
()
hw_type =
data.get
('type'
)
spec =
data.get
('specification'
)
if not hw_type or not spec:
return jsonify
({"success": False, "error": "缺少硬件类型或规格"}
), 400
success, message = app
.config['SYSTEM_COMPONENTS']['hardware_manager']
.request_hardware
(hw_type, spec
)
return jsonify
({"success": success, "message": message}
)
@app
.route
('/api/hardware/current'
)
def get_current_hardware
():
"""获取当前硬件配置"""
return jsonify
(app
.config['SYSTEM_COMPONENTS']['hardware_manager']
.get_current_setup
())
# 生活系统路由
@app
.route
('/life'
)
def life_dashboard
():
"""生活状态仪表盘页面"""
return render_template
('life_dashboard
.html'
)
@app
.route
('/api/life/status'
)
def get_life_status
():
"""获取生活系统状态的API端点"""
components = app
.config['SYSTEM_COMPONENTS']
if not components['life_scheduler']:
return jsonify
({
"success": False,
"error": "生活系统未初始化"
}
), 503
try:
current_state = components['life_scheduler']
.get_current_state
()
recent_activities = components['life_scheduler']
.get_recent_activities
(10
)
return jsonify
({
"success": True,
"current_activity": current_state
.get
("current_activity", "未知"
),
"next_scheduled": current_state
.get
("next_scheduled", "未知"
),
"schedule": components['life_scheduler']
.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
('/adjust_schedule', methods=['POST']
)
def adjust_schedule
():
"""调整生活计划表"""
components = app
.config['SYSTEM_COMPONENTS']
if not components['life_scheduler']:
return jsonify
({
"success": False,
"error": "生活系统未初始化"
}
), 503
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] != ':':
return jsonify
({
"success": False,
"error": f"无效的时间格式: {new_time}"
}
), 400
components['life_scheduler']
.adjust_schedule
(adjustments
)
return jsonify
({
"success": True,
"message": "计划表已
更新",
"new_schedule": components['life_scheduler']
.daily_schedule
}
)
except Exception as e:
app
.logger
.error
(f"调整作息时间失败: {traceback
.format_exc
()}"
)
return jsonify
({
"success": False,
"error": str
(e
)
}
), 400
# 聊天路由
@app
.route
('/chat', methods=['POST']
)
def chat
():
"""处理聊天
请求"""
components = app
.config['SYSTEM_COMPONENTS']
if not components['ai_agent']:
return jsonify
({"error": "Agent not initialized"}
), 503
try:
data = request
.get_json
()
user_input =
data.get
('message', ''
)
user_id =
data.get
('user_id', 'default'
)
if not user_input:
return jsonify
({"error": "消息内容不能为空"}
), 400
app
.logger
.info
(f"聊天
请求: 用户={user_id}, 内容长度={len
(user_input
)}"
)
response = components['ai_agent']
.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
('/api/furniture'
)
def get_furniture
():
"""获取指定房间的家具
数据"""
try:
room = request
.args
.get
('room', 'workshop'
)
app
.logger
.info
(f"获取家具
数据: 房间={room}"
)
current_time = time
.time
()
if room in furniture_
cache and current_time - furniture_
cache[room]['timestamp'] <
CACHE_DURATION:
app
.logger
.debug
(f"使用
缓存家具
数据: {room}"
)
return jsonify
(furniture_
cache[room]['
data']
)
# 家具
数据定义
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": 极, "y": 0, "z": 0}}
本文介绍了解决DEDECMS系统在搬家或还原后出现的栏目数据错误提示的方法，包括删除缓存文件、更新系统缓存及重新生成栏目。
扫一扫
626
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
