environment = environ[‘wsgi.websocket‘] KeyError: ‘wsgi.websocket‘

最新推荐文章于 2025-11-24 15:49:46 发布
原创 最新推荐文章于 2025-11-24 15:49:46 发布 · 663 阅读 · 0 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#websocket #网络协议 #网络

本文详细描述了如何在Nginx配置中设置代理，包括转发请求头和连接升级，同时提到了`wsgi.websocket`引发的KeyError问题，暗示可能是在处理WebSocket时遇到的问题。 
   location / {
                   proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;

                   proxy_set_header Host $http_host;

                   proxy_redirect off;

                   proxy_pass http://127.0.0.1:8082/;
                   proxy_http_version 1.1;
                   proxy_set_header Upgrade $http_upgrade;
                   proxy_set_header Connection "upgrade";
                    }

在这里插入图片描述
Key error: wsgi.websocket

Django3框架-（2）-[使用websocket]：使用channels实现websocket，配置和项目实际使用
weixin_46371752的博客
07-25 5384
Django3如何实现websocket,django3怎么在项目使用websocket，django使用websocket，django配置websocket，django应用websocket，django怎么写websocket
websocket小案例，和遇到的坑，希望对你有帮助
weixin_43494908的博客
02-15 3523
websocket小案例 开发环境 jdk8+tomcat8 遇到的大坑： @ServerEndpoint 对bean的不支持（如果出来初始化bean对象一直未空指针） 修改为@ServerEndpoint(value = “/websocket”, configurator = SpringConfigurator.class) 客户端：sendxxx()…发送请求到服务端 前段： `(1)ws...
HTTPS站点使用WebSocket的常见错误及解决方案
派煌篇的博客
12-26 3万+
因为HTTPS是基于SSL依靠证书来验证服务器的身份，并为浏览器和服务器之间的通信加密，所以在HTTPS站点调用某些非SSL验证的资源时浏览器可能会阻止。比如使用ws://***调用websocket服务器或者引入类似http://***.js的js文件等都会报错。这里简述一下连接websocket服务器时的错误及解决方案。当使用ws://连接websocket服务器时会出现类似如下错误： Mi...
python使用websocket的几种方式
ronon77的专栏
06-29 5530
      websocket 是一种html5新的接口，以前服务器推送需要进行ajax等方式进行轮训，对服务器压力较高，随着新标准的推进，使用websocket在推送等方面已经是比较成熟了，并且各个浏览器对websocket的支持情况已经比较好了，只要不是太老古古董，对这些暂时不考虑。 使用websocket的时候，前端使用是比较规范的，js支持ws协议，感觉上类似于一个轻度封装的...
request.environ.get('wsgi.websocket')
weixin_30477293的博客
09-21 1138
　　前言 　　websocket是一种html5新的接口，以前服务器推送需要进行ajax等方式进行轮训，对服务器压力较高，随着新标准的推进，使用websocket在推送等方面已经是比较成熟了，并且各个浏览器对websocket的支持情况已经比较好了，只要不是太老古古董，对这些暂时不考虑。 　　使用websocket的时候，前端使用是比较规范的，js支持ws协议，感觉上类似于一...
Python字典查找报Keyerror解决方法
热门推荐
幸运的Alina的博客
07-18 29万+
Python的字典一般都直接查找key ，比如 dict={'a':1,'b':2,'c':3} print(dict['a']) 但是如果在查找的key不存在的时候就会报：KeyError: 比如你要查看print(dict['d']) 由于这个时候dict里面并没有这个key ,所以就会直接报错，那么这个时候其实python给我们提供了一种很棒的解决方法，那就是用 setdefa...
【Django一站式教程 · 第34章】WebSocket 实时通信：在线聊天与通知
feizuiku0116的博客
09-02 958
传统 HTTP 是无状态请求响应模式，不适合实时双向通信。WebSocket 协议支持持久连接，适合聊天、通知等场景。本章介绍 Django Channels，教你搭建基于 WebSocket 的实时通信系统。
# E:\AI_System\web_ui\server.py (修复KeyError完整版) import sys import os import time import logging import json import traceback import threading import platform import psutil import datetime from pathlib import Path from functools import wraps from concurrent.futures import ThreadPoolExecutor import logging.handlers # ========== 关键修复1: 最先执行eventlet猴子补丁 ========== try: import eventlet eventlet.monkey_patch() # 必须在所有导入之前执行 print("✅ Eventlet monkey patch applied at startup") except ImportError: print("⚠️ Eventlet not installed, using threading mode") pass # 修复1：更新依赖包列表 REQUIRED_PACKAGES = [ 'flask', 'flask_socketio', 'flask_limiter', 'psutil', 'eventlet', 'waitress' ] def check_dependencies(): """增强依赖检查功能""" missing = [] for package in REQUIRED_PACKAGES: try: __import__(package) except ImportError: missing.append(package) if missing: print(f"❌ 缺少必要的依赖包: {', '.join(missing)}") print("请运行以下命令安装依赖:") print(f"pip install {' '.join(missing)}") sys.exit(1) if __name__ == '__main__': check_dependencies() # 在启动前检查依赖 # 现在导入其他模块 from flask import Flask, jsonify, request, render_template from flask_socketio import SocketIO, emit from flask_limiter import Limiter from flask_limiter.util import get_remote_address # ========== 配置系统 ========== class SystemConfig: def __init__(self): self.BASE_DIR = Path(__file__).resolve().parent.parent self.HOST = '0.0.0.0' self.PORT = 5000 self.LOG_LEVEL = 'DEBUG' self.SECRET_KEY = os.getenv('SECRET_KEY', 'your_secret_key_here') self.DEBUG = True self.USE_GPU = False self.DEFAULT_MODEL = 'gpt-3.5-turbo' self.MAX_WORKERS = 4 # 目录配置 self.LOG_DIR = self.BASE_DIR / 'logs' self.LOG_DIR.mkdir(parents=True, exist_ok=True) self.CONFIG_DIR = self.BASE_DIR / 'config' self.CONFIG_DIR.mkdir(parents=True, exist_ok=True) self.AGENT_PATH = self.BASE_DIR / 'agent' self.MODEL_CACHE_DIR = self.BASE_DIR / 'model_cache' self.MODEL_CACHE_DIR.mkdir(parents=True, exist_ok=True) self.TEMPLATE_DIR = self.BASE_DIR / 'web_ui' / 'templates' def __str__(self): return f"SystemConfig(HOST={self.HOST}, PORT={self.PORT})" config = SystemConfig() # ========== 全局协调器 ========== coordinator = None executor = ThreadPoolExecutor(max_workers=config.MAX_WORKERS) def register_coordinator(coord): global coordinator coordinator = coord if coordinator and hasattr(coordinator, 'connect_to_ui'): coordinator.connect_to_ui(update_ui) def update_ui(event): if 'socketio' in globals(): socketio.emit('system_event', event) # ========== 线程安全装饰器 ========== def synchronized(lock): def decorator(func): @wraps(func) def wrapper(*args, **kwargs): with lock: return func(*args, **kwargs) return wrapper return decorator # ========== 日志系统 ========== def setup_logger(): """优化日志配置""" logger = logging.getLogger('WebServer') logger.setLevel(getattr(logging, config.LOG_LEVEL.upper(), logging.DEBUG)) # 清除所有现有处理器 for handler in logger.handlers[:]: logger.removeHandler(handler) # 日志格式 log_formatter = logging.Formatter( '%(asctime)s [%(levelname)s] %(name)s: %(message)s', datefmt='%Y-%m-%d %H:%M:%S' ) # 文件日志处理器 (每天轮换，保留30天) file_handler = logging.handlers.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) # 设置Flask和SocketIO日志 flask_logger = logging.getLogger('werkzeug') flask_logger.setLevel(logging.WARNING) socketio_logger = logging.getLogger('engineio') socketio_logger.setLevel(logging.WARNING) return logger logger = setup_logger() # ========== 环境管理器 ========== class EnvironmentManager: """独立的环境管理器类""" def __init__(self, config): self.config = config self.state = { 'temperature': 22.5, 'humidity': 45.0, 'light_level': 75, 'objects': [], 'last_updated': datetime.datetime.now().isoformat() } self.healthy = True self.lock = threading.Lock() @synchronized(threading.Lock()) def start(self): logger.info("环境管理器已启动") @synchronized(threading.Lock()) def get_state(self): # 更新模拟数据 self.state['temperature'] = round(20 + 5 * (time.time() % 10) / 10, 1) self.state['humidity'] = round(40 + 10 * (time.time() % 10) / 10, 1) self.state['light_level'] = round(70 + 10 * (time.time() % 10) / 10, 1) self.state['last_updated'] = datetime.datetime.now().isoformat() return self.state @synchronized(threading.Lock()) def execute_action(self, action, params): logger.info(f"执行环境动作: {action} 参数: {params}") if action == "adjust_temperature": self.state['temperature'] = params.get('value', 22.0) return True elif action == "adjust_light": self.state['light_level'] = params.get('level', 70) return True return False def is_healthy(self): return self.healthy # ========== 系统初始化 ========== class SystemInitializer: def __init__(self): self.base_dir = Path(__file__).resolve().parent.parent self.ai_c极 = None self.hardware_manager = None self.life_scheduler = None self.ai_agent = None self.start_time = time.time() self.environment_manager = None self.life_lock = threading.Lock() 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): logger.info("✅ 模拟AI核心初始化") self.ai_core = type('AICore', (), { 'status': 'running', 'get_state': lambda: {"status": "running", "model": "gpt-3.5-turbo"} })() def initialize_hardware_manager(self): logger.info("✅ 模拟硬件管理器初始化") self.hardware_manager = type('HardwareManager', (), { 'get_status': lambda: { "cpu_usage": psutil.cpu_percent(), "memory_usage": psutil.virtual_memory().percent, "gpu_usage": 0 } })() @synchronized(lock=threading.Lock()) def initialize_life_scheduler(self): logger.info("✅ 模拟生活调度器初始化") self.life_scheduler = type('LifeScheduler', (), { 'get_status': lambda: { "current_activity": "thinking", "next_activity": "learning", "energy": 85 } })() @synchronized(lock=threading.Lock()) def initialize_ai_agent(self): logger.info("✅ 模拟AI智能体初始化") self.ai_agent = type('AIAgent', (), { 'process_input': lambda self, input, user_id: f"你好{user_id}，我收到了你的消息: '{input}'" })() def start_evolution_monitor(self): 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 } # ========== 环境交互路由 ========== def register_environment_routes(app): @app.route('/environment') def environment_view(): return render_template('environment_view.html') @app.route('/api/environment/state', methods=['GET']) @app.config['LIMITER'].limit("10 per minute") 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) 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']) @app.config['极IMITER'].limit("5 per minute") 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 register_routes(app): # 添加根路由 - 关键修复 @app.route('/') def home(): """根路由显示欢迎页面""" # 使用f-string避免format()方法的问题 current_time = datetime.datetime.now().strftime("%Y-%m-%d %H:%M:%S") return f""" <!DOCTYPE html> <html> <head> <title>AI系统控制中心</title> <style> body {{ font-family: Arial, sans-serif; margin: 40px; background-color: #f5f8fa; }} .container {{ max-width: 800px; margin: 0 auto; padding: 20px; background: white; border-radius: 8px; box-shadow: 0 2px 10px rgba(0,0,0,0.1); }} h1 {{ color: #2c3e50; text-align: center; margin-bottom: 30px; }} .status {{ background: #f8f9fa; padding: 20px; border-radius: 8px; margin-top: 30px; border-left: 4px solid #3498db; }} .links {{ margin-top: 20px; display: flex; justify-content: center; flex-wrap: wrap; gap: 15px; }} .links a {{ display: inline-block; padding: 12px 25px; background: #3498db; color: white; text-decoration: none; border-radius: 4px; transition: all 0.3s ease; text-align: center; min-width: 150px; }} .links a:hover {{ background: #2980b9; transform: translateY(-2px); box-shadow: 0 4px 8px rgba(0,0,0,0.1); }} .footer {{ text-align: center; margin-top: 30px; color: #7f8c8d; font-size: 0.9em; }} </style> </head> <body> <div class="container"> <h1>🤖 AI系统控制中心</h1> <p>欢迎访问AI系统控制面板，请选择以下功能：</p> <div class="links"> <a href="/environment">🌍 环境监控</a> <a href="/life/dashboard">📅 生活调度</a> <a href="/status">📊 系统状态</a> <a href="/health">🩺 健康检查</a> <a href="/chat">💬 聊天交互</a> </div> <div class="status"> <h3>系统状态</h3> <p>✅ 服务器已启动，运行正常</p> <p>🕒 启动时间: {current_time}</p> <p>📍 服务器地址: http://{request.host}</p> </div> <div class="footer"> <p>AI系统控制中心 v1.0 | 技术支持: support@ai-system.com</p> </div> </div> </body> </html> """ register_environment_routes(app) # 健康检查路由 @app.route('/health') def health_check(): return jsonify({"status": "healthy", "timestamp": datetime.datetime.now().isoformat()}) # 系统状态路由 @app.route('/status') @app.config['LIMITER'].exempt def status(): components = app.config['SYSTEM_COMPONENTS'] system_info = { "uptime": time.time() - app.config['START_TIME'], "ai_core_status": components['ai_core'].status if components['ai_core'] else "uninitialized", "hardware_status": components['hardware_manager'].get_status() if components[ 'hardware_manager'] else "uninitialized", "life_scheduler_status": components['life_scheduler'].get_status() if components[ 'life_scheduler'] else "uninitialized", "environment_status": components['environment_manager'].is_healthy() if components[ 'environment_manager'] else "uninitialized", "platform": platform.platform(), "python_version": sys.version, "memory_usage": psutil.virtual_memory().percent, "cpu_usage": psutil.cpu_percent(), "thread_count": threading.active_count(), "process_id": os.getpid() } return jsonify(system_info) # 核心系统路由 @app.route('/api/core/state') @app.config['LIMITER'].limit("10 per minute") def get_core_state(): ai_core = app.config['SYSTEM_COMPONENTS'].get('ai_core') if not ai_core: return jsonify({"error": "AI核心未初始化"}), 503 return jsonify(ai_core.get_state()) # 生活系统路由 @app.route('/life/dashboard') def life_dashboard(): return render_template('life_dashboard.html') @app.route('/api/life/status') @app.config['LIMITER'].limit("10 per minute") def get_life_status(): life_scheduler = app.config['SYSTEM_COMPONENTS'].get('life_scheduler') if not life_scheduler: return jsonify({"error": "生活调度器未初始化"}), 503 status = life_scheduler.get_status() return jsonify(status) # 聊天路由 - 添加GET方法支持 @app.route('/chat', methods=['GET']) def chat_interface(): """聊天界面""" return render_template('chat.html') @app.route('/api/chat', methods=['POST']) @app.config['LIMITER'].limit("30 per minute") def chat_handler(): """处理聊天请求的API端点""" components = app.config['SYSTEM_COMPONENTS'] if not components['ai_agent']: return jsonify({"error": "Agent未初始化"}), 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)}") # 使用线程池异步处理 future = executor.submit(components['ai_agent'].process_input, user_input, user_id) response = future.result(timeout=10) # 10秒超时 return jsonify({"response": response}) except TimeoutError: return jsonify({"error": "处理超时"}), 504 except Exception as e: app.logger.error(f"聊天处理失败: {traceback.format_exc()}") return jsonify({"error": "聊天处理失败", "details": str(e)}), 500 # 404处理 @app.route('/<path:path>') def catch_all(path): return jsonify({"error": "路由不存在", "path": path}), 404 def register_error_handlers(app): @app.errorhandler(404) def not_found_error(error): return jsonify({"error": "资源未找到", "message": str(error)}), 404 @app.errorhandler(500) def internal_error(error): app.logger.error(f"服务器内部错误: {str(error)}") return jsonify({"error": "服务器内部错误", "message": "请查看日志获取详细信息"}), 500 # ========== WebSocket处理 ========== def setup_websocket_handlers(socketio): @socketio.on('connect') def handle_connect(): logger.info('客户端已连接') socketio.emit('system_status', {'status': 'ready'}) @socketio.on('disconnect') def handle_disconnect(): logger.info('客户端已断开连接') @socketio.on('user_message') def handle_user_message(data): user_id = data.get('user_id', 'guest') message = data.get('message', '') logger.info(f"收到来自 {user_id} 的消息: {message}") # 使用线程池处理消息 def process_message(): try: global coordinator if coordinator: return coordinator.process_message(message) else: return f"已收到您的消息: {message}" except Exception as e: logger.error(f"消息处理失败: {str(e)}") return "处理消息时出错" future = executor.submit(process_message) try: response = future.result(timeout=10) socketio.emit('agent_response', { 'user_id': user_id, 'response': response }) except TimeoutError: socketio.emit('agent_response', { 'user_id': user_id, 'response': "处理超时，请重试" }) # ========== 生产环境启动器 ========== def run_production_server(app): try: from waitress import serve logger.info(f"🚀 生产服务器启动: http://{config.HOST}:{config.PORT}") logger.warning("⚠️ 当前运行在生产模式 (Waitress WSGI服务器)") serve(app, host=config.HOST, port=config.PORT, threads=8) except ImportError: logger.error("❌ 缺少生产环境依赖: waitress") logger.info("请运行: pip install waitress") sys.exit(1) # ========== Flask应用工厂 ========== def create_app(): app = Flask( __name__, template_folder=str(config.TEMPLATE_DIR), static_folder='static', static_url_path='/static' ) app.secret_key = config.SECRET_KEY # 初始化限流器 limiter = Limiter( get_remote_address, app=app, default_limits=["200 per day", "50 per hour"], storage_uri="memory://" ) app.config['LIMITER'] = limiter 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 async_mode = 'threading' try: import eventlet async_mode = 'eventlet' logger.info("✅ 使用eventlet异步模式") except ImportError: logger.warning("⚠️ eventlet未安装，使用threadi 哥 你给我发完整版吧 改来改去我会烦 也改不明白
08-12
1. 在WebSocket处理部分，有一个未完成的字符串（logger.warning("⚠️ eventlet未安装，使用threadi ...） 2. 在环境交互路由中，有一个路由装饰器使用了错误的变量名（@app.config['极IMITER'] -> 应该是'LIMITER'...
# 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 datetime from pathlib import Path from functools import wraps from concurrent.futures import ThreadPoolExecutor import logging.handlers # ========== 关键修复1: 最先执行eventlet猴子补丁 ========== try: import eventlet eventlet.monkey_patch() # 必须在所有导入之前执行 print("✅ Eventlet monkey patch applied at startup") except ImportError: print("⚠️ Eventlet not installed, using threading mode") pass # 修复1：更新依赖包列表 REQUIRED_PACKAGES = [ 'flask', 'flask_socketio', 'flask_limiter', 'psutil', 'waitress' ] def check_dependencies(): """增强依赖检查功能""" missing = [] for package in REQUIRED_PACKAGES: try: __import__(package) except ImportError: missing.append(package) if missing: print(f"❌ 缺少必要的依赖包: {', '.join(missing)}") print("请运行以下命令安装依赖:") print(f"pip install {' '.join(missing)}") sys.exit(1) if __name__ == '__main__': check_dependencies() # 在启动前检查依赖 # 现在导入其他模块 from flask import Flask, jsonify, request, render_template, send_from_directory from flask_socketio import SocketIO, emit from flask_limiter import Limiter from flask_limiter.util import get_remote_address # ========== 配置系统 ========== class SystemConfig: def __init__(self): self.BASE_DIR = Path(__file__).resolve().parent.parent self.HOST = '0.0.0.0' self.PORT = 5000 self.LOG_LEVEL = 'DEBUG' self.SECRET_KEY = os.getenv('SECRET_KEY', 'your_secret_key_here') self.DEBUG = True self.USE_GPU = False self.DEFAULT_MODEL = 'gpt-3.5-turbo' self.MAX_WORKERS = 4 # 目录配置 self.LOG_DIR = self.BASE_DIR / 'logs' self.LOG_DIR.mkdir(parents=True, exist_ok=True) self.CONFIG_DIR = self.BASE_DIR / 'config' self.CONFIG_DIR.mkdir(parents=True, exist_ok=True) self.AGENT_PATH = self.BASE_DIR / 'agent' self.MODEL_CACHE_DIR = self.BASE_DIR / 'model_cache' self.MODEL_CACHE_DIR.mkdir(parents=True, exist_ok=True) self.TEMPLATE_DIR = self.BASE_DIR / 'web_ui' / 'templates' self.STATIC_DIR = self.BASE_DIR / 'web_ui' / 'static' def __str__(self): return f"SystemConfig(HOST={self.HOST}, PORT={self.PORT})" config = SystemConfig() # ========== 全局协调器 ========== coordinator = None executor = ThreadPoolExecutor(max_workers=config.MAX_WORKERS) def register_coordinator(coord): global coordinator coordinator = coord if coordinator and hasattr(coordinator, 'connect_to_ui'): coordinator.connect_to_ui(update_ui) def update_ui(event): if 'socketio' in globals(): socketio.emit('system_event', event) # ========== 线程安全装饰器 ========== def synchronized(lock): def decorator(func): @wraps(func) def wrapper(*args, **kwargs): with lock: return func(*args, **kwargs) return wrapper return decorator # ========== 日志系统 ========== def setup_logger(): """优化日志配置""" logger = logging.getLogger('WebServer') logger.setLevel(getattr(logging, config.LOG_LEVEL.upper(), logging.DEBUG)) # 清除所有现有处理器 for handler in logger.handlers[:]: logger.removeHandler(handler) # 日志格式 log_formatter = logging.Formatter( '%(asctime)s [%(levelname)s] %(name)s: %(message)s', datefmt='%Y-%m-%d %H:%M:%S' ) # 文件日志处理器 (每天轮换，保留30天) file_handler = logging.handlers.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) # 设置Flask和SocketIO日志 flask_logger = logging.getLogger('werkzeug') flask_logger.setLevel(logging.WARNING) socketio_logger = logging.getLogger('engineio') socketio_logger.setLevel(logging.WARNING) return logger logger = setup_logger() # ========== 环境管理器 ========== class EnvironmentManager: """独立的环境管理器类""" def __init__(self, config): self.config = config self.state = { 'temperature': 22.5, 'humidity': 45.0, 'light_level': 75, 'objects': [], 'last_updated': datetime.datetime.now().isoformat() } self.healthy = True self.lock = threading.Lock() @synchronized(threading.Lock()) def start(self): logger.info("环境管理器已启动") @synchronized(threading.Lock()) def get_state(self): # 更新模拟数据 self.state['temperature'] = round(20 + 5 * (time.time() % 10) / 10, 1) self.state['humidity'] = round(40 + 10 * (time.time() % 10) / 10, 1) self.state['light_level'] = round(70 + 10 * (time.time() % 10) / 10, 1) self.state['last_updated'] = datetime.datetime.now().isoformat() return self.state @synchronized(threading.Lock()) def execute_action(self, action, params): logger.info(f"执行环境动作: {action} 参数: {params}") if action == "adjust_temperature": self.state['temperature'] = params.get('value', 22.0) return True elif action == "adjust_light": self.state['light_level'] = params.get('level', 70) return True return False def is_healthy(self): return self.healthy # ========== 系统初始化 ========== 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 self.life_lock = threading.Lock() 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): logger.info("✅ 模拟AI核心初始化") self.ai_core = type('AICore', (), { 'status': 'running', 'get_state': lambda: {"status": "running", "model": "gpt-3.5-turbo"} })() def initialize_hardware_manager(self): logger.info("✅ 模拟硬件管理器初始化") self.hardware_manager = type('HardwareManager', (), { 'get_status': lambda: { "cpu_usage": psutil.cpu_percent(), "memory_usage": psutil.virtual_memory().percent, "gpu_usage": 0 } })() @synchronized(lock=threading.Lock()) def initialize_life_scheduler(self): logger.info("✅ 模拟生活调度器初始化") self.life_scheduler = type('LifeScheduler', (), { 'get_status': lambda: { "current_activity": "thinking", "next_activity": "learning", "energy": 85 } })() @synchronized(lock=threading.Lock()) def initialize_ai_agent(self): logger.info("✅ 模拟AI智能体初始化") self.ai_agent = type('AIAgent', (), { 'process_input': lambda self, input, user_id: f"你好{user_id}，我收到了你的消息: '{input}'" })() def start_evolution_monitor(self): 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 } # ========== 环境交互路由 ========== def register_environment_routes(app): @app.route('/environment') def environment_view(): return render_template('environment_view.html') @app.route('/api/environment/state', methods=['GET']) @app.config['LIMITER'].limit("10 per minute") 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) 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']) @app.config['LIMITER'].limit("5 per minute") 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 register_routes(app): # 添加根路由 - 关键修复 @app.route('/') def home(): """根路由显示欢迎页面""" current_time = datetime.datetime.now().strftime("%Y-%m-%d %H:%M:%S") return f""" <!DOCTYPE html> <html> <head> <title>AI系统控制中心</title> <style> body {{ font-family: Arial, sans-serif; margin: 40px; background-color: #f5f8fa; }} .container {{ max-width: 800px; margin: 0 auto; padding: 20px; background: white; border-radius: 8px; box-shadow: 0 2px 10px rgba(0,0,0,0.1); }} h1 {{ color: #2c3e50; text-align: center; margin-bottom: 30px; }} .status {{ background: #f8f9fa; padding: 20px; border-radius: 8px; margin-top: 30px; border-left: 4px solid #3498db; }} .links {{ margin-top: 20px; display: flex; justify-content: center; flex-wrap: wrap; gap: 15px; }} .links a {{ display: inline-block; padding: 12px 25px; background: #3498db; color: white; text-decoration: none; border-radius: 4px; transition: all 0.3s ease; text-align: center; min-width: 150px; }} .links a:hover {{ background: #2980b9; transform: translateY(-2px); box-shadow: 0 4px 8px rgba(0,0,0,0.1); }} .footer {{ text-align: center; margin-top: 30px; color: #7f8c8d; font-size: 0.9em; }} </style> </head> <body> <div class="container"> <h1>🤖 AI系统控制中心</h1> <p>欢迎访问AI系统控制面板，请选择以下功能：</p> <div class="links"> <a href="/environment">🌍 环境监控</a> <a href="/life/dashboard">📅 生活调度</a> <a href="/status">📊 系统状态</a> <a href="/health">🩺 健康检查</a> <a href="/chat">💬 聊天交互</a> </div> <div class="status"> <h3>系统状态</h3> <p>✅ 服务器已启动，运行正常</p> <p>🕒 启动时间: {current_time}</p> <p>📍 服务器地址: http://{request.host}</p> </div> <div class="footer"> <p>AI系统控制中心 v1.0 | 技术支持: support@ai-system.com</p> </div> </div> </body> </html> """ register_environment_routes(app) # 静态文件路由 @app.route('/static/<path:filename>') def static_files(filename): return send_from_directory(app.static_folder, filename) # 健康检查路由 @app.route('/health') def health_check(): return jsonify({"status": "healthy", "timestamp": datetime.datetime.now().isoformat()}) # 系统状态路由 @app.route('/status') @app.config['LIMITER'].exempt def status(): components = app.config['SYSTEM_COMPONENTS'] system_info = { "uptime": time.time() - app.config['START_TIME'], "ai_core_status": components['ai_core'].status if components['ai_core'] else "uninitialized", "hardware_status": components['hardware_manager'].get_status() if components[ 'hardware_manager'] else "uninitialized", "life_scheduler_status": components['life_scheduler'].get_status() if components[ 'life_scheduler'] else "uninitialized", "environment_status": components['environment_manager'].is_healthy() if components[ 'environment_manager'] else "uninitialized", "platform": platform.platform(), "python_version": sys.version, "memory_usage": psutil.virtual_memory().percent, "cpu_usage": psutil.cpu_percent(), "thread_count": threading.active_count(), "process_id": os.getpid() } return jsonify(system_info) # 核心系统路由 @app.route('/api/core/state') @app.config['LIMITER'].limit("10 per minute") def get_core_state(): ai_core = app.config['SYSTEM_COMPONENTS'].get('ai_core') if not ai_core: return jsonify({"error": "AI核心未初始化"}), 503 return jsonify(ai_core.get_state()) # 生活系统路由 @app.route('/life/dashboard') def life_dashboard(): return render_template('life_dashboard.html') @app.route('/api/life/status') @app.config['LIMITER'].limit("10 per minute") def get_life_status(): life_scheduler = app.config['SYSTEM_COMPONENTS'].get('life_scheduler') if not life_scheduler: return jsonify({"error": "生活调度器未初始化"}), 503 status = life_scheduler.get_status() return jsonify(status) # 聊天路由 @app.route('/chat', methods=['GET']) def chat_interface(): """聊天界面""" return render_template('chat.html') @app.route('/api/chat', methods=['POST']) @app.config['LIMITER'].limit("30 per minute") def chat_handler(): """处理聊天请求的API端点""" components = app.config['SYSTEM_COMPONENTS'] if not components['ai_agent']: return jsonify({"error": "Agent未初始化"}), 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)}") # 使用线程池异步处理 future = executor.submit(components['ai_agent'].process_input, user_input, user_id) response = future.result(timeout=10) # 10秒超时 return jsonify({"response": response}) except TimeoutError: return jsonify({"error": "处理超时"}), 504 except Exception as e: app.logger.error(f"聊天处理失败: {traceback.format_exc()}") return jsonify({"error": "聊天处理失败", "details": str(e)}), 500 # 404处理 @app.route('/<path:path>') def catch_all(path): return jsonify({"error": "路由不存在", "path": path}), 404 def register_error_handlers(app): @app.errorhandler(404) def not_found_error(error): return jsonify({"error": "资源未找到", "message": str(error)}), 404 @app.errorhandler(500) def internal_error(error): app.logger.error(f"服务器内部错误: {str(error)}") return jsonify({"error": "服务器内部错误", "message": "请查看日志获取详细信息"}), 500 # ========== WebSocket处理 ========== def setup_websocket_handlers(socketio): @socketio.on('connect') def handle_connect(): logger.info('客户端已连接') socketio.emit('system_status', {'status': 'ready'}) @socketio.on('disconnect') def handle_disconnect(): logger.info('客户端已断开连接') @socketio.on('user_message') def handle_user_message(data): user_id = data.get('user_id', 'guest') message = data.get('message', '') logger.info(f"收到来自 {user_id} 的消息: {message}") # 使用线程池处理消息 def process_message(): try: global coordinator if coordinator: return coordinator.process_message(message) else: return f"已收到您的消息: {message}" except Exception as e: logger.error(f"消息处理失败: {str(e)}") return "处理消息时出错" future = executor.submit(process_message) try: response = future.result(timeout=10) socketio.emit('agent_response', { 'user_id': user_id, 'response': response }) except TimeoutError: socketio.emit('agent_response', { 'user_id': user_id, 'response': "处理超时，请重试" }) # ========== 生产环境启动器 ========== def run_production_server(app): try: from waitress import serve logger.info(f"🚀 生产服务器启动: http://{config.HOST}:{config.PORT}") logger.warning("⚠️ 当前运行在生产模式 (Waitress WSGI服务器)") serve(app, host=config.HOST, port=config.PORT, threads=8) except ImportError: logger.error("❌ 缺少生产环境依赖: waitress") logger.info("请运行: pip install waitress") sys.exit(1) # ========== Flask应用工厂 ========== def create_app(): app = Flask( __name__, template_folder=str(config.TEMPLATE_DIR), static_folder=str(config.STATIC_DIR), static_url_path='/static' ) app.secret_key = config.SECRET_KEY # 初始化限流器 limiter = Limiter( get_remote_address, app=app, default_limits=["200 per day", "50 per hour"], storage_uri="memory://" ) app.config['LIMITER'] = limiter 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 async_mode = 'threading' try: import eventlet async_mode = 'eventlet' logger.info("✅ 使用eventlet异步模式") except ImportError: logger.warning("⚠️ eventlet未安装，使用threading模式") pass # 注册路由和错误处理 register_routes(app) register_error_handlers(app) # 创建SocketIO实例 socketio = SocketIO(app, async_mode=async_mode, logger=False, engineio_logger=False) setup_websocket_handlers(socketio) app.config['SOCKETIO'] = socketio return app, socketio # ========== 主程序入口 ========== if __name__ == '__main__': app, socketio = create_app() # 启动服务器 if os.environ.get('ENV') == 'production': run_production_server(app) else: logger.info(f"🚀 开发服务器启动: http://{config.HOST}:{config.PORT}") socketio.run( app, host=config.HOST, port=config.PORT, debug=config.DEBUG, use_reloader=False ) # E:\AI_System\agent\autonomous_agent.py import os import sys import time import logging import importlib import traceback import psutil import platform import threading import json from pathlib import Path from dotenv import load_dotenv from typing import Dict, Any, Optional, List, Callable from concurrent.futures import ThreadPoolExecutor from ..core.config import system_config # 使用绝对导入 - 确保路径正确 sys.path.insert(0, str(Path(__file__).resolve().parent.parent)) from core.config import system_config from core.exceptions import DependencyError, SubsystemFailure from core.dependency_manager import DependencyManager from core.metrics import PerformanceMetrics, MetricsCollector # 全局线程池 executor = ThreadPoolExecutor(max_workers=4) class AutonomousAgent: def __init__(self): """自主智能体核心类，负责协调所有子系统""" self.logger = self._setup_logger() self.logger.info("🔁 初始化自主智能体核心模块...") self._running = False # 运行状态标志 self._background_thread = None # 后台线程 # 初始化状态跟踪 self.initialization_steps = [] self._last_env_check = 0 self._initialization_time = time.time() self.subsystem_status = {} # 子系统熔断状态 self.metrics = MetricsCollector() # 性能监控 self._status_lock = threading.Lock() # 状态锁 # 依赖管理器 self.dependency_manager = DependencyManager() try: # 记录初始化步骤 self._record_step("加载环境变量") load_dotenv() self._record_step("验证环境") self.verify_environment() self._record_step("初始化核心组件") self._initialize_core_components() self._record_step("初始化子系统") self._initialize_subsystems() self.logger.info(f"✅ 自主智能体初始化完成 (耗时: {time.time() - self._initialization_time:.2f}秒)") self.logger.info(f"初始化步骤: {', '.join(self.initialization_steps)}") # 启动后台任务线程 self._start_background_tasks() except Exception as e: self.logger.exception(f"❌ 智能体初始化失败: {str(e)}") self.logger.error(f"堆栈跟踪:\n{traceback.format_exc()}") raise RuntimeError(f"智能体初始化失败: {str(e)}") from e def _start_background_tasks(self): """启动后台任务线程""" if self._running: self.logger.warning("后台任务已在运行") return self._running = True self._background_thread = threading.Thread( target=self._background_task_loop, daemon=True, name="AutonomousAgentBackgroundTasks" ) self._background_thread.start() self.logger.info("✅ 后台任务线程已启动") def _background_task_loop(self): """后台任务循环""" while self._running: try: start_time = time.time() self.run_periodic_tasks() # 动态调整睡眠时间 task_time = time.time() - start_time sleep_time = max(0.1, 10 - task_time) # 确保至少10秒间隔 time.sleep(sleep_time) except Exception as e: self.logger.error(f"后台任务错误: {str(e)}") self.metrics.record_error('background_task') time.sleep(30) def _record_step(self, step_name: str): """记录初始化步骤""" self.initialization_steps.append(step_name) self.logger.info(f"⏳ 步骤 {len(self.initialization_steps)}: {step_name}") def verify_environment(self): """验证运行环境是否满足要求""" missing = [] warnings = [] # 检查必需模块 required_modules = [ 'os', 'sys', 'logging', 'dotenv', 'flask', 'werkzeug', 'numpy', 'transformers', 'torch', 'psutil' ] for mod in required_modules: try: importlib.import_module(mod) except ImportError: missing.append(mod) # 检查配置文件 if not hasattr(system_config, 'CONFIG_PATH') or not os.path.exists(system_config.CONFIG_PATH): self.logger.error(f"❌ 配置文件缺失: {system_config.CONFIG_PATH}") warnings.append(f"配置文件缺失: {system_config.CONFIG_PATH}") # 检查模型目录 - 如果不存在则创建 model_dir = Path(system_config.MODEL_CACHE_DIR) if not model_dir.exists(): model_dir.mkdir(parents=True, exist_ok=True) self.logger.warning(f"⚠️ 创建模型缓存目录: {model_dir}") # 检查日志目录 - 如果不存在则创建 log_dir = Path(system_config.LOG_DIR) if not log_dir.exists(): log_dir.mkdir(parents=True, exist_ok=True) self.logger.warning(f"⚠️ 创建日志目录: {log_dir}") # 处理警告 for warning in warnings: self.logger.warning(warning) # 处理缺失项 if missing: error_msg = f"环境验证失败，缺失: {', '.join(missing)}" self.logger.error(error_msg) self.dependency_manager.record_missing_dependencies(missing) raise DependencyError(error_msg) self.logger.info("✅ 环境验证通过") def _setup_logger(self) -> logging.Logger: """配置日志记录器""" logger = logging.getLogger('AutonomousAgent') logger.setLevel(system_config.LOG_LEVEL) # 创建控制台处理器 console_handler = logging.StreamHandler() console_handler.setLevel(system_config.LOG_LEVEL) # 创建文件处理器 log_file = Path(system_config.LOG_DIR) / 'autonomous_agent.log' file_handler = logging.FileHandler(log_file, encoding='utf-8') file_handler.setLevel(system_config.LOG_LEVEL) # 创建格式化器 formatter = logging.Formatter( '%(asctime)s - %(name)s - %(levelname)s - %(message)s', datefmt='%Y-%m-%d %H:%M:%S' ) console_handler.setFormatter(formatter) file_handler.setFormatter(formatter) # 添加处理器 logger.addHandler(console_handler) logger.addHandler(file_handler) logger.propagate = False return logger def _initialize_core_components(self): """初始化不依赖其他组件的核心组件""" # 获取项目根目录 base_dir = Path(__file__).resolve().parent.parent # 环境相关组件 - 使用回退实现 self.environment = self._create_fallback_environment(base_dir) self.logger.info("✅ 环境接口初始化完成") # 记录环境状态 self._log_environment_status() # 初始化状态持久化 self._load_subsystem_status() def _create_fallback_environment(self, base_dir: Path): """创建回退的环境实现""" class FallbackEnvironment: def __init__(self, base_dir): self.base_dir = base_dir self.status_file = base_dir / 'environment_status.json' def get_system_info(self): try: # 尝试从文件加载状态 if self.status_file.exists(): with open(self.status_file, 'r') as f: return json.load(f) except: pass # 创建新状态 status = { "os": platform.system(), "os_version": platform.version(), "cpu": platform.processor(), "cpu_cores": psutil.cpu_count(logical=False), "memory_total": round(psutil.virtual_memory().total / (1024 ** 3), 1), "memory_used": round(psutil.virtual_memory().used / (1024 ** 3), 1), "disk_total": round(psutil.disk_usage('/').total / (1024 ** 3), 1), "disk_used": round(psutil.disk_usage('/').used / (1024 ** 3), 1), "timestamp": time.time() } # 保存状态 try: with open(self.status_file, 'w') as f: json.dump(status, f) except: pass return status return FallbackEnvironment(base_dir) def _log_environment_status(self): """记录环境状态信息""" try: env_status = self.environment.get_system_info() or {} self.logger.info( f"📊 系统状态: OS={env_status.get('os', '未知')} {env_status.get('os_version', '')}, " f"CPU={env_status.get('cpu', '未知')} ({env_status.get('cpu_cores', 0)}核), " f"内存={env_status.get('memory_used', 0)}/{env_status.get('memory_total', 0)}GB, " f"磁盘={env_status.get('disk_used', 0)}/{env_status.get('disk_total', 0)}GB" ) except Exception as e: self.logger.error(f"环境状态获取失败: {str(e)}") self.metrics.record_error('environment_status') def _initialize_subsystems(self): """初始化所有子系统 - 使用动态导入并添加详细错误处理""" # 定义子系统初始化顺序 - 使用更简单的回退实现 subsystems = [ ('健康系统', self._create_fallback_health_system, {}), ('模型管理器', self._create_fallback_model_manager, {}), ('记忆系统', self._create_fallback_memory_system, {}), ('情感系统', self._create_fallback_affective_system, {}), ('认知架构', self._create_fallback_cognitive_architecture, {}), ('通信系统', self._create_fallback_communication_system, {}) ] # 注册子系统依赖关系 self.dependency_manager.register_dependency('通信系统', ['认知架构']) self.dependency_manager.register_dependency('情感系统', ['健康系统', '记忆系统']) self.dependency_manager.register_dependency('认知架构', ['记忆系统']) # 初始化子系统 for name, creator_func, kwargs in subsystems: try: # 检查依赖是否满足 missing_deps = self.dependency_manager.check_dependencies(name) if missing_deps: self.logger.warning(f"⚠️ 子系统 {name} 缺少依赖: {', '.join(missing_deps)}") # 尝试自动安装缺失依赖 self.dependency_manager.install_missing_dependencies(missing_deps) # 创建实例 instance = creator_func(**kwargs) setattr(self, name.lower().replace(' ', '_'), instance) self.logger.info(f"✅ {name}初始化完成") # 标记子系统为活跃状态 with self._status_lock: self.subsystem_status[name] = { 'active': True, 'error_count': 0, 'last_active': time.time(), 'last_recovery_attempt': 0 } except Exception as e: self.logger.error(f"❌ {name}初始化失败: {str(e)}") with self._status_lock: self.subsystem_status[name] = { 'active': False, 'error': str(e), 'error_count': 1, 'last_error': time.time() } # 记录指标 self.metrics.record_error(f'subsystem_init_{name.lower()}') # 保存子系统状态 self._save_subsystem_status() # 各子系统回退实现保持不变... def process_input(self, user_input: str, user_id: str = "default") -> Dict[str, Any]: """处理用户输入（通过通信系统）""" # 检查通信系统是否活跃 with self._status_lock: comm_status = self.subsystem_status.get('通信系统', {}) active = comm_status.get('active', False) if not active: self.logger.error("通信系统未激活，使用回退处理") self.metrics.record_error('communication_system_inactive') return {"response": "系统正在维护中，请稍后再试"} try: # 使用性能监控 with PerformanceMetrics() as pm: # 使用线程池异步处理 future = executor.submit( self.communication_system.process_input, user_input, user_id ) response = future.result(timeout=10) # 10秒超时 # 记录性能指标 self.metrics.record_latency('process_input', pm.duration) self.metrics.record_success('process_input') self.logger.info(f"📥 处理输入: '{user_input[:30]}...' → 耗时: {pm.duration:.2f}秒") return response except TimeoutError: self.logger.warning("处理输入超时") self.metrics.record_timeout('process_input') return {"error": "处理超时，请重试"} except Exception as e: # 更新错误计数 with self._status_lock: comm_status = self.subsystem_status.get('通信系统', {}) comm_status['error_count'] = comm_status.get('error_count', 0) + 1 comm_status['last_error'] = time.time() # 检查熔断条件 if comm_status['error_count'] >= 5: # 临时阈值 comm_status['active'] = False self.logger.critical(f"🚨 通信系统因连续错误被熔断！") self.metrics.record_event('circuit_breaker', '通信系统') self.logger.error(f"处理输入失败: {str(e)}") self.metrics.record_error('process_input') return {"error": "处理失败，请稍后再试"} def run_periodic_tasks(self): """运行周期性任务""" task_start = time.time() tasks_executed = 0 tasks_failed = 0 # 定义任务列表 tasks = [ ('健康系统更新', lambda: self.health_system.update()), ('情感系统更新', lambda: self.affective_system.grow()), ('记忆系统维护', lambda: self.memory_system.consolidate_memories()), ('环境监控', self._monitor_environment), ('子系统心跳检查', self._check_subsystem_heartbeats), ('子系统恢复', self._recover_failed_subsystems) ] # 执行任务 for name, task_func in tasks: try: if name == '环境监控' or self._is_subsystem_active(name.split()[0]): task_func() tasks_executed += 1 except Exception as e: tasks_failed += 1 subsystem_name = name.split()[0] self.logger.error(f"{name}失败: {str(e)}", exc_info=True) self._handle_subsystem_error(subsystem_name, e) self.metrics.record_error(f'periodic_{subsystem_name.lower()}') # 记录任务执行情况 if tasks_executed > 0: task_time = time.time() - task_start self.logger.debug(f"⏱️ 执行 {tasks_executed} 项周期性任务 ({tasks_failed}失败), 耗时: {task_time:.3f}秒") self.metrics.record_latency('periodic_tasks', task_time) self.metrics.record_value('periodic_tasks_count', tasks_executed) self.metrics.record_value('periodic_tasks_failed', tasks_failed) def _is_subsystem_active(self, name: str) -> bool: """检查子系统是否活跃""" with self._status_lock: status = self.subsystem_status.get(name, {}) return status.get('active', False) def _handle_subsystem_error(self, name: str, error: Exception): """处理子系统错误""" with self._status_lock: status = self.subsystem_status.get(name, {}) status['error_count'] = status.get('error_count', 0) + 1 status['last_error'] = time.time() # 检查熔断条件 if status['error_count'] >= 5: # 临时阈值 status['active'] = False self.logger.critical(f"🚨 子系统 {name} 因连续错误被熔断！") self.metrics.record_event('circuit_breaker', name) def _check_subsystem_heartbeats(self): """检查子系统心跳""" for name in list(self.subsystem_status.keys()): with self._status_lock: status = self.subsystem_status.get(name, {}) if not status.get('active', False): continue # 跳过已熔断的 subsystem = getattr(self, name.lower().replace(' ', '_'), None) if subsystem and hasattr(subsystem, 'check_heartbeat'): try: if not subsystem.check_heartbeat(): self.logger.warning(f"⚠️ 子系统 {name} 心跳检测失败") self._handle_subsystem_error(name, RuntimeError("心跳检测失败")) else: # 更新最后活跃时间 with self._status_lock: status['last_active'] = time.time() except Exception as e: self.logger.error(f"子系统 {name} 心跳检查异常: {str(e)}") self._handle_subsystem_error(name, e) self.metrics.record_error(f'heartbeat_{name.lower()}') def _recover_failed_subsystems(self): """尝试恢复失败的子系统""" for name in list(self.subsystem_status.keys()): with self._status_lock: status = self.subsystem_status.get(name, {}) if status.get('active', False): continue # 跳过活跃的 # 检查恢复条件：错误后至少等待5分钟 last_error = status.get('last_error', 0) if time.time() - last_error < 300: continue # 检查上次恢复尝试时间 last_attempt = status.get('last_recovery_attempt', 0) if time.time() - last_attempt < 600: # 每10分钟尝试一次 continue self.logger.info(f"🔄 尝试恢复子系统: {name}") status['last_recovery_attempt'] = time.time() try: # 尝试重新初始化子系统 # 这里需要根据子系统名称调用相应的初始化方法 # 简化实现：直接重置状态 subsystem = self._reinitialize_subsystem(name) setattr(self, name.lower().replace(' ', '_'), subsystem) with self._status_lock: status['active'] = True status['error_count'] = 0 status['last_error'] = 0 self.logger.info(f"✅ 子系统 {name} 恢复成功") self.metrics.record_event('subsystem_recovered', name) except Exception as e: with self._status_lock: status['active'] = False status['error_count'] += 1 status['last_error'] = time.time() self.logger.error(f"子系统 {name} 恢复失败: {str(e)}") self.metrics.record_error(f'recovery_{name.lower()}') def _reinitialize_subsystem(self, name: str) -> Any: """重新初始化子系统""" # 根据名称选择初始化方法 creators = { '健康系统': self._create_fallback_health_system, '模型管理器': self._create_fallback_model_manager, '记忆系统': self._create_fallback_memory_system, '情感系统': self._create_fallback_affective_system, '认知架构': self._create_fallback_cognitive_architecture, '通信系统': self._create_fallback_communication_system } if name in creators: return creators[name]() else: raise SubsystemFailure(f"未知子系统: {name}") def _monitor_environment(self): """监控环境状态""" try: self.logger.info("🔍 开始环境监控...") env_status = self.environment.get_system_info() or {} # 获取CPU和内存使用情况 env_status['cpu_usage'] = psutil.cpu_percent() env_status['memory_usage'] = psutil.virtual_memory().percent env_status['disk_usage'] = psutil.disk_usage('/').percent # 记录到日志 self.logger.info( f"📊 环境监控: CPU={env_status['cpu_usage']}%, " f"内存={env_status['memory_usage']}%, " f"磁盘={env_status['disk_usage']}%" ) # 记录到健康系统 if hasattr(self, 'health_system'): self.health_system.record_environment_status(env_status) # 记录指标 self.metrics.record_value('cpu_usage', env_status['cpu_usage']) self.metrics.record_value('memory_usage', env_status['memory_usage']) self.metrics.record_value('disk_usage', env_status['disk_usage']) except Exception as e: self.logger.error(f"环境监控失败: {str(e)}", exc_info=True) self.metrics.record_error('environment_monitoring') def _save_subsystem_status(self): """保存子系统状态到文件""" status_file = Path(system_config.CONFIG_DIR) / 'subsystem_status.json' try: with self._status_lock: data = { 'timestamp': time.time(), 'status': self.subsystem_status } with open(status_file, 'w') as f: json.dump(data, f, indent=2) except Exception as e: self.logger.error(f"保存子系统状态失败: {str(e)}") def _load_subsystem_status(self): """从文件加载子系统状态""" status_file = Path(system_config.CONFIG_DIR) / 'subsystem_status.json' if status_file.exists(): try: with open(status_file, 'r') as f: data = json.load(f) # 只加载24小时内的状态 if time.time() - data.get('timestamp', 0) < 86400: with self._status_lock: self.subsystem_status = data.get('status', {}) self.logger.info("加载子系统状态缓存") except Exception as e: self.logger.error(f"加载子系统状态失败: {str(e)}") def get_status(self) -> Dict[str, Any]: """获取智能体状态报告""" with self._status_lock: status_data = { "uptime": time.time() - self._initialization_time, "subsystems": { name: info.get('active', False) for name, info in self.subsystem_status.items() }, "circuit_breaker": { name: { "active": info.get('active', False), "error_count": info.get('error_count', 0), "last_error": info.get('last_error', 0) } for name, info in self.subsystem_status.items() }, "metrics": self.metrics.get_metrics(), "environment": self.environment.get_system_info() if hasattr(self, 'environment') else {} } # 添加子系统状态 for name in ['健康系统', '情感系统', '记忆系统', '模型管理器', '认知架构', '通信系统']: attr_name = name.lower().replace(' ', '_') if hasattr(self, attr_name) and hasattr(getattr(self, attr_name), 'get_status'): status_data[name] = getattr(self, attr_name).get_status() return status_data def shutdown(self): """关闭智能体""" self.logger.info("🛑 正在关闭智能体...") self._running = False # 停止线程池 executor.shutdown(wait=False) # 保存状态 self._save_subsystem_status() # 等待后台线程 if self._background_thread and self._background_thread.is_alive(): self._background_thread.join(timeout=5.0) if self._background_thread.is_alive(): self.logger.warning("后台线程未正常退出") self.logger.info("✅ 智能体已关闭") 你看看怎么修改 主要是哪个模块没启动 哪里有问题 我需要知道 你理解吗？
08-13
logger.error(f"❌ AI智能体初始化失败: {str(e)}") logger.error(traceback.format_exc()) # 创建回退的模拟智能体 self.ai_agent = type('AIAgent', (), { 'process_input': lambda self, input, user_id: f...
================================================ AI系统正在启动 [周一 2025/08/11 22:52:48.99] ================================================ [1/3] 启动模型API服务... 2025-08-11 22:52:49,235 - APIServer - INFO - 开始初始化模型... 2025-08-11 22:52:52,366 - APIServer - CRITICAL - 模型初始化异常: cannot import name 'cached_download' from 'huggingface_hub' (E:\Python310\lib\site-packages\huggingface_hub\__init__.py) ================================================== Starting DeepSeek-7B Model API Server Start Time: 2025-08-11T14:52:52.367935Z Model Status: Not Loaded ================================================== API Endpoints: - Generate: POST http://127.0.0.1:6000/generate - Status: GET http://127.0.0.1:6000/status - Health: GET http://127.0.0.1:6000/health ================================================== * Serving Flask app 'api_server' * Debug mode: off WARNING: This is a development server. Do not use it in a production deployment. Use a production WSGI server instead. * Running on http://127.0.0.1:6000 Press CTRL+C to quit [2/3] 启动AI核心服务... Traceback (most recent call last): File "E:\AI_System\agent\agent_core.py", line 24, in <module> from agent.cognitive_architecture import CognitiveArchitecture File "E:\AI_System\agent\__init__.py", line 5, in <module> from .autonomous_agent import AutonomousAgent # 修改此处 File "E:\AI_System\agent\autonomous_agent.py", line 19, in <module> from core.config import system_config ImportError: cannot import name 'system_config' from 'core.config' (E:\AI_System\core\config.py) [3/3] 启动用户界面... 系统启动完成！自动打开监控页面... ✅ Eventlet monkey patch applied at startup 2025-08-11 22:52:57 [INFO] WebServer: ================================================== 2025-08-11 22:52:57 [INFO] WebServer: 🚀 开始初始化AI系统 2025-08-11 22:52:57 [INFO] WebServer: ================================================== 2025-08-11 22:52:57 [INFO] WebServer: 项目根目录: E:\AI_System 2025-08-11 22:52:57 [INFO] WebServer: 添加路径: E:\AI_System\agent 2025-08-11 22:52:57 [INFO] WebServer: 添加路径: E:\AI_System\core 2025-08-11 22:52:57 [INFO] WebServer: 添加路径: E:\AI_System\utils 2025-08-11 22:52:57 [INFO] WebServer: 添加路径: E:\AI_System\config 2025-08-11 22:52:57 [INFO] WebServer: 添加路径: E:\AI_System\cognitive_arch 2025-08-11 22:52:57 [INFO] WebServer: 添加路径: E:\AI_System\environment 2025-08-11 22:52:57 [INFO] WebServer: ✅ 模拟AI核心初始化 2025-08-11 22:52:57 [INFO] WebServer: ✅ 模拟硬件管理器初始化 2025-08-11 22:52:57 [INFO] WebServer: ✅ 模拟生活调度器初始化 2025-08-11 22:52:57 [INFO] WebServer: ✅ 模拟AI智能体初始化 2025-08-11 22:52:57 [INFO] WebServer: 环境管理器已启动 2025-08-11 22:52:57 [INFO] WebServer: ✅ 环境管理器初始化成功 2025-08-11 22:52:57 [INFO] WebServer: ✅ 模拟进化监视器启动 2025-08-11 22:52:57 [INFO] WebServer: ✅ 所有系统组件初始化完成 2025-08-11 22:52:57 [INFO] WebServer: ✅ 使用eventlet异步模式 2025-08-11 22:52:57 [INFO] WebServer: 🚀 开发服务器启动: http://0.0.0.0:5000 (17256) wsgi starting up on http://0.0.0.0:5000 ================================================ 运行中进程： python.exe 16140 Console 1 210,852 K python.exe 17256 Console 1 50,544 K ================================================ 按任意键退出此窗口（服务将继续在后台运行）... (17256) accepted ('127.0.0.1', 50016) (17256) accepted ('127.0.0.1', 50032) 127.0.0.1 - - [11/Aug/2025 22:53:21] "GET / HTTP/1.1" 200 3308 0.001000 127.0.0.1 - - [11/Aug/2025 22:53:21] "GET /favicon.ico HTTP/1.1" 404 212 0.000000 127.0.0.1 - - [11/Aug/2025 22:53:29] "GET /life/dashboard HTTP/1.1" 200 32013 0.003999 Traceback (most recent call last): File "E:\Python310\lib\site-packages\flask\app.py", line 2193, in wsgi_app response = self.handle_exception(e) File "E:\Python310\lib\site-packages\flask\app.py", line 2190, in wsgi_app response = self.full_dispatch_request() File "E:\Python310\lib\site-packages\flask\app.py", line 1486, in full_dispatch_request rv = self.handle_user_exception(e) File "E:\Python310\lib\site-packages\flask\app.py", line 1484, in full_dispatch_request rv = self.dispatch_request() File "E:\Python310\lib\site-packages\flask\app.py", line 1469, in dispatch_request return self.ensure_sync(self.view_functions[rule.endpoint])(**view_args) File "E:\AI_System\web_ui\server.py", line 467, in status "hardware_status": components['hardware_manager'].get_status() if components[ TypeError: SystemInitializer.initialize_hardware_manager.<locals>.<lambda>() takes 0 positional arguments but 1 was given 127.0.0.1 - - [11/Aug/2025 22:53:42] "GET /status HTTP/1.1" 500 12795 0.012914 127.0.0.1 - - [11/Aug/2025 22:53:42] "GET /status?__debugger__=yes&cmd=resource&f=style.css HTTP/1.1" 304 183 0.016000 127.0.0.1 - - [11/Aug/2025 22:53:42] "GET /status?__debugger__=yes&cmd=resource&f=debugger.js HTTP/1.1" 304 184 0.000000 127.0.0.1 - - [11/Aug/2025 22:53:42] "GET /status?__debugger__=yes&cmd=resource&f=console.png&s=cy8AirLRNcqty2WTg3dx HTTP/1.1" 200 729 0.001000 127.0.0.1 - - [11/Aug/2025 22:53:54] "GET /health HTTP/1.1" 200 203 0.001001 127.0.0.1 - - [11/Aug/2025 22:53:57] "GET /chat HTTP/1.1" 200 2844 0.009460 127.0.0.1 - - [11/Aug/2025 22:53:59] "GET /socket.io/?EIO=4&transport=polling&t=PYPdxlY HTTP/1.1" 200 300 0.000000 2025-08-11 22:53:59 [INFO] WebServer: 客户端已连接 127.0.0.1 - - [11/Aug/2025 22:53:59] "POST /socket.io/?EIO=4&transport=polling&t=PYPdxla&sid=y_bOfyPWaorXA7sEAAAA HTTP/1.1" 200 219 0.001000 (17256) accepted ('127.0.0.1', 50075) 127.0.0.1 - - [11/Aug/2025 22:53:59] "GET /socket.io/?EIO=4&transport=polling&t=PYPdxlb&sid=y_bOfyPWaorXA7sEAAAA HTTP/1.1" 200 252 0.000000 127.0.0.1 - - [11/Aug/2025 22:53:59] "GET /socket.io/?EIO=4&transport=polling&t=PYPdxlc&sid=y_bOfyPWaorXA7sEAAAA HTTP/1.1" 200 181 0.000000 127.0.0.1 - - [11/Aug/2025 22:53:59] "GET /socket.io/?EIO=4&transport=polling&t=PYPdxle&sid=y_bOfyPWaorXA7sEAAAA HTTP/1.1" 200 181 0.000000 2025-08-11 22:54:01 [INFO] WebServer: 收到来自 user_1754924041725 的消息: hi 2025-08-11 22:54:08 [INFO] WebServer: 收到来自 user_1754924048779 的消息: 能听见吗 2025-08-11 22:54:13 [INFO] WebServer: 客户端已断开连接 127.0.0.1 - - [11/Aug/2025 22:54:13] "GET /socket.io/?EIO=4&transport=websocket&sid=y_bOfyPWaorXA7sEAAAA HTTP/1.1" 200 0 14.650252 127.0.0.1 - - [11/Aug/2025 22:54:14] "GET /environment HTTP/1.1" 200 47268 0.014014 #E:\AI_System\core\config.py # import os import json import logging import configparser from pathlib import Path from typing import Dict, Any, Optional, Union from dotenv import load_dotenv class CoreConfig: """ 核心配置管理类 - 提供统一的配置管理接口 支持多来源配置加载：环境变量 > 配置文件 > 默认值 """ def __init__(self, config_path: Optional[Union[str, Path]] = None, env_prefix: str = "APP_", default_config: Optional[Dict[str, Any]] = None): """ 初始化配置管理器 :param config_path: 配置文件路径(支持.json, .ini, .env) :param env_prefix: 环境变量前缀 :param default_config: 默认配置字典 """ self.logger = logging.getLogger('CoreConfig') self._setup_logger() self.env_prefix = env_prefix self.config_path = Path(config_path) if config_path else None self.config_data = default_config or {} self.config_modified = False self.log(f"📋 初始化配置管理器 | 环境前缀: {env_prefix}") # 加载配置 self.load_configuration() def _setup_logger(self): """配置日志记录器""" if not self.logger.handlers: handler = logging.StreamHandler() formatter = logging.Formatter('%(asctime)s - %(name)s - %(levelname)s - %(message)s') handler.setFormatter(formatter) self.logger.addHandler(handler) self.logger.setLevel(logging.INFO) self.logger.propagate = False def log(self, message: str, level: str = "info"): """记录日志""" log_levels = { "debug": self.logger.debug, "info": self.logger.info, "warning": self.logger.warning, "error": self.logger.error } log_func = log_levels.get(level.lower(), self.logger.info) log_func(message) def load_configuration(self): """加载所有配置源""" # 1. 加载环境变量 self._load_environment_vars() # 2. 加载配置文件（如果存在） if self.config_path and self.config_path.exists(): self._load_config_file() elif self.config_path: self.log(f"⚠️ 配置文件不存在: {self.config_path}", "warning") self.log(f"✅ 配置加载完成 | 条目数: {len(self.config_data)}") def _load_environment_vars(self): """加载环境变量""" self.log("🔍 加载环境变量...") load_dotenv() # 加载.env文件（如果存在） # 获取所有以指定前缀开头的环境变量 for key, value in os.environ.items(): if key.startswith(self.env_prefix): config_key = key[len(self.env_prefix):].lower() self.config_data[config_key] = self._parse_value(value) self.log(f" - 加载环境变量: {config_key} = {self._mask_secret(config_key, value)}") def _load_config_file(self): """根据文件扩展名加载配置文件""" suffix = self.config_path.suffix.lower() self.log(f"📄 加载配置文件: {self.config_path} (类型: {suffix[1:]})") try: if suffix == '.json': self._load_json_config() elif suffix in ('.ini', '.cfg'): self._load_ini_config() elif suffix == '.env': self._load_dotenv_config() else: self.log(f"❌ 不支持的配置文件类型: {suffix}", "error") except Exception as e: self.log(f"❌ 配置文件加载失败: {str(e)}", "error") def _load_json_config(self): """加载JSON配置文件""" with open(self.config_path, 'r', encoding='utf-8') as f: json_data = json.load(f) self._merge_config(json_data) def _load_ini_config(self): """加载INI配置文件""" parser = configparser.ConfigParser() parser.read(self.config_path) config_dict = {} for section in parser.sections(): section_dict = {} for key, value in parser.items(section): section_dict[key] = self._parse_value(value) config_dict[section] = section_dict self._merge_config(config_dict) def _load_dotenv_config(self): """加载.env配置文件""" # 已由load_dotenv()处理，这里只需记录 self.log(" - .env文件已加载") def _merge_config(self, new_config: Dict[str, Any]): """合并新配置到现有配置""" for key, value in new_config.items(): # 处理嵌套配置 if isinstance(value, dict) and key in self.config_data and isinstance(self.config_data[key], dict): self.config_data[key].update(value) else: self.config_data[key] = value self.log(f" - 加载配置项: {key} = {self._mask_secret(key, value)}") def _parse_value(self, value: str) -> Any: """智能解析字符串值为合适的Python类型""" # 尝试解析为布尔值 if value.lower() in ('true', 'yes', 'on'): return True if value.lower() in ('false', 'no', 'off'): return False # 尝试解析为数字 try: return int(value) except ValueError: try: return float(value) except ValueError: pass # 尝试解析为列表 if ',' in value: return [self._parse_value(item.strip()) for item in value.split(',')] # 返回原始字符串 return value def _mask_secret(self, key: str, value: Any) -> str: """对敏感信息进行掩码处理""" if 'secret' in key or 'password' in key or 'key' in key: return '******' if value else '空' if isinstance(value, list): return f"[列表, 长度: {len(value)}]" if isinstance(value, dict): return f"{{字典, 键数: {len(value)}}}" return str(value) def get(self, key: str, default: Any = None) -> Any: """ 获取配置值，支持点分路径 (如: 'database.host') :param key: 配置键名 :param default: 默认值（如果键不存在） :return: 配置值 """ keys = key.split('.') current = self.config_data for k in keys: if isinstance(current, dict) and k in current: current = current[k] else: return default return current def set(self, key: str, value: Any, persist: bool = False): """ 设置配置值 :param key: 配置键名 :param value: 配置值 :param persist: 是否持久化到配置文件 """ keys = key.split('.') current = self.config_data # 遍历创建嵌套字典 for i, k in enumerate(keys[:-1]): if k not in current or not isinstance(current[k], dict): current[k] = {} current = current[k] # 设置最终值 last_key = keys[-1] current[last_key] = value self.config_modified = True self.log(f"⚙️ 设置配置: {key} = {self._mask_secret(last_key, value)}") # 持久化到文件 if persist and self.config_path: self.save_config() def save_config(self, path: Optional[Union[str, Path]] = None): """ 保存配置到文件 :param path: 可选的自定义保存路径 """ save_path = Path(path) if path else self.config_path if not save_path: self.log("❌ 保存失败: 未指定配置文件路径", "error") return False suffix = save_path.suffix.lower() try: if suffix == '.json': with open(save_path, 'w', encoding='utf-8') as f: json.dump(self.config_data, f, indent=2, ensure_ascii=False) elif suffix in ('.ini', '.cfg'): self._save_ini_config(save_path) else: self.log(f"❌ 不支持的文件格式: {suffix}", "error") return False self.log(f"💾 配置已保存到: {save_path}") self.config_modified = False return True except Exception as e: self.log(f"❌ 配置保存失败: {str(e)}", "error") return False def _save_ini_config(self, path: Path): """保存为INI格式配置文件""" parser = configparser.ConfigParser() # 递归处理嵌套字典 def add_section(data, section_name=None): if section_name: parser.add_section(section_name) for key, value in data.items(): if isinstance(value, dict): add_section(value, f"{section_name}.{key}" if section_name else key) else: if not section_name: parser.set('DEFAULT', key, str(value)) else: parser.set(section_name, key, str(value)) add_section(self.config_data) with open(path, 'w', encoding='utf-8') as f: parser.write(f) def reload(self): """重新加载所有配置源""" self.log("🔄 重新加载配置...") self.config_data = {} self.load_configuration() def to_dict(self) -> Dict[str, Any]: """返回当前配置的完整字典""" return self.config_data.copy() def __getitem__(self, key: str) -> Any: """支持字典式访问""" return self.get(key) def __setitem__(self, key: str, value: Any): """支持字典式设置""" self.set(key, value) def __contains__(self, key: str) -> bool: """检查配置项是否存在""" return self.get(key) is not None # 测试代码 if __name__ == "__main__": logging.basicConfig( level=logging.INFO, format='%(asctime)s - %(name)s - %(levelname)s - %(message)s' ) print("=" * 50) print("核心配置管理器测试") print("=" * 50) # 创建临时配置文件 config_json = """ { "database": { "host": "localhost", "port": 5432, "username": "admin", "password": "db_secret" }, "logging": { "level": "INFO", "path": "/var/log/app.log" }, "features": ["auth", "caching", "analytics"] } """ with open("test_config.json", "w") as f: f.write(config_json) # 设置环境变量 os.environ["APP_API_KEY"] = "env_secret_key" os.environ["APP_DATABASE_PORT"] = "6432" # 覆盖配置文件中的端口 # 创建配置管理器实例 config = CoreConfig( config_path="test_config.json", env_prefix="APP_", default_config={ "app_name": "MyApp", "version": "1.0.0" } ) # 测试配置获取 print("\n测试配置获取:") print(f"数据库主机: {config.get('database.host')}") print(f"数据库端口: {config.get('database.port')} (应被环境变量覆盖)") print(f"API密钥: {config.get('api_key')} (来自环境变量)") print(f"应用名称: {config.get('app_name')} (来自默认配置)") print(f"日志级别: {config.get('logging.level')}") print(f"功能列表: {config.get('features')}") # 测试配置设置 print("\n测试配置设置:") config.set("new_feature.enabled", True) config.set("database.password", "new_secret", persist=True) print(f"新功能状态: {config.get('new_feature.enabled')}") # 测试配置保存 print("\n测试配置保存:") config.save_config("test_config_saved.json") # 测试配置包含检查 print("\n测试配置包含检查:") print(f"数据库用户名存在: {'database.username' in config}") print(f"不存在的键: {'nonexistent.key' in config}") # 测试配置转字典 print("\n完整配置字典:") print(json.dumps(config.to_dict(), indent=2, ensure_ascii=False))
08-12
我们遇到了几个问题： 1. 在启动模型API服务时，出现了导入错误：`cannot import name 'cached_download' from 'huggingface_hub'` 2. 在启动AI核心服务时，出现了导入错误：`ImportError: cannot import name '...
# 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 datetime from pathlib import Path from flask import Flask, jsonify, request, render_template from logging.handlers import TimedRotatingFileHandler from flask_socketio import SocketIO, emit # ========== 配置系统 ========== class SystemConfig: def __init__(self): self.BASE_DIR = Path(__file__).resolve().parent.parent self.HOST = '127.0.0.1' self.PORT = 5000 self.LOG_LEVEL = 'INFO' self.SECRET_KEY = 'your_secret_key_here' self.DEBUG = True self.USE_GPU = False self.DEFAULT_MODEL = 'gpt-3.5-turbo' # 目录配置 self.LOG_DIR = self.BASE_DIR / 'logs' self.LOG_DIR.mkdir(parents=True, exist_ok=True) self.CONFIG_DIR = self.BASE_DIR / 'config' self.CONFIG_DIR.mkdir(parents=True, exist_ok=True) self.AGENT_PATH = self.BASE_DIR / 'agent' self.MODEL_CACHE_DIR = self.BASE_DIR / 'model_cache' self.MODEL_CACHE_DIR.mkdir(parents=True, exist_ok=True) def __str__(self): return f"SystemConfig(HOST={self.HOST}, PORT={self.PORT})" config = SystemConfig() # ========== 全局协调器 ========== coordinator = None def register_coordinator(coord): """注册意识系统协调器""" global coordinator coordinator = coord if coordinator and hasattr(coordinator, 'connect_to_ui'): coordinator.connect_to_ui(update_ui) def update_ui(event): """更新UI事件处理""" if 'socketio' in globals(): socketio.emit('system_event', event) # ========== 初始化日志系统 ========== def setup_logger(): """配置全局日志系统""" 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 # 应用安全日志处理 for level in ['debug', 'info', 'warning', 'error', 'critical']: 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 = ['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: # 环境管理器模拟实现 class EnvironmentManager: def __init__(self, config): self.config = config self.state = { 'temperature': 22.5, 'humidity': 45.0, 'light_level': 75, 'objects': [], 'last_updated': datetime.datetime.now().isoformat() } def start(self): logger.info("环境管理器已启动") def get_state(self): # 更新模拟数据 self.state['temperature'] = 20 + 5 * (time.time() % 10) / 10 self.state['humidity'] = 40 + 10 * (time.time() % 10) / 10 self.state['light_level'] = 70 + 10 * (time.time() % 10) / 10 self.state['last_updated'] = datetime.datetime.now().isoformat() return self.state def execute_action(self, action, params): logger.info(f"执行环境动作: {action} 参数: {params}") if action == "adjust_temperature": self.state['temperature'] = params.get('value', 22.0) return True elif action == "adjust_light": self.state['light_level'] = params.get('level', 70) return True return False 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: 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: if not code_path.exists(): # 创建默认遗传代码文件 default_code = """# 默认遗传代码 class AICore: def __init__(self): self.version = "1.0.0" self.capabilities = ["learning", "reasoning", "problem_solving"] def evolve(self): print("系统正在进化...") """ with open(code_path, "w", encoding="utf-8") as f: f.write(default_code) with open(code_path, "r", encoding="utf-8") as f: return f.read() except Exception as e: logger.error(f"加载遗传代码失败: {str(e)}") 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) 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(), "cpu_cores": psutil.cpu_count(logical=False), "cpu_threads": psutil.cpu_count(logical=True), "memory_gb": round(psutil.virtual_memory().total / (1024 ** 3), 1), "storage_gb": round(psutil.disk_usage('/').total / (1024 ** 3), 1), "os": f"{platform.system()} {platform.release()}" } self.ai_core = AICore(self.base_dir) logger.info("✅ AI核心系统初始化完成") return self.ai_core def initialize_hardware_manager(self): """初始化硬件管理器""" try: # 硬件管理器模拟实现 class HardwareManager: def __init__(self): self.available_hardware = { "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.cpu_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 = HardwareManager() logger.info("✅ 硬件管理器初始化成功") return self.hardware_manager except Exception as e: logger.error(f"❌ 硬件管理器初始化失败: {str(e)}") logger.warning("⚠️ 使用内置简单硬件管理器") return None def initialize_life_scheduler(self): """初始化生活调度器""" try: # 生活调度器模拟实现 class LifeScheduler: def __init__(self): self.daily_schedule = { "wake_up": "07:00", "breakfast": "08:00", "lunch": "12:30", "dinner": "19:00", "sleep": "23:00" } self.current_activity = "awake" self.energy_level = 100 self.mood = "calm" self.activity_log = [] def wake_up(self): self.current_activity = "awake" self.log_activity("醒来") def have_meal(self, meal_type): self.current_activity = f"eating_{meal_type}" self.energy_level = min(100, self.energy_level + 20) self.log_activity(f"用餐: {meal_type}") def go_to_sleep(self): self.current_activity = "sleeping" self.log_activity("睡觉") def log_activity(self, activity): timestamp = datetime.datetime.now().strftime("%Y-%m-%d %H:%M:%S") self.activity_log.append(f"{timestamp} - {activity}") # 保留最近的100条记录 if len(self.activity_log) > 100: self.activity_log.pop(0) def adjust_schedule(self, adjustments): for activity, new_time in adjustments.items(): if activity in self.daily_schedule: self.daily_schedule[activity] = new_time def get_current_state(self): return { "current_activity": self.current_activity, "next_scheduled": self._get_next_scheduled(), "energy_level": self.energy_level, "mood": self.mood } def get_recent_activities(self, count=10): return self.activity_log[-count:] def _get_next_scheduled(self): now = datetime.datetime.now() current_time = now.strftime("%H:%M") # 找到下一个计划活动 schedule_times = sorted( [(k, v) for k, v in self.daily_schedule.items()], key=lambda x: x[1] ) for activity, time_str in schedule_times: if time_str > current_time: return f"{activity} at {time_str}" # 如果没有找到，返回第二天的第一个活动 return f"{schedule_times[0][0]} at {schedule_times[0][1]} tomorrow" 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 current_minute = now.minute current_time = f"{current_hour:02d}:{current_minute:02d}" # 根据时间更新活动状态 if 7 <= current_hour < 8 and self.life_scheduler.current_activity != "awake": self.life_scheduler.wake_up() elif 12 <= current_hour < 13 and self.life_scheduler.current_activity != "eating_lunch": self.life_scheduler.have_meal("lunch") elif 19 <= current_hour < 20 and self.life_scheduler.current_activity != "eating_dinner": self.life_scheduler.have_meal("dinner") elif (23 <= current_hour or current_hour < 6) and self.life_scheduler.current_activity != "sleeping": self.life_scheduler.go_to_sleep() # 自然能量消耗 if self.life_scheduler.current_activity != "sleeping": self.life_scheduler.energy_level = max(0, self.life_scheduler.energy_level - 0.1) 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: # AI智能体模拟实现 class AutonomousAgent: def __init__(self, model_path, cache_dir, use_gpu, default_model): self.model_name = default_model self.cache_dir = cache_dir self.use_gpu = use_gpu self.conversation_history = {} def process_input(self, user_input, user_id): # 初始化用户对话历史 if user_id not in self.conversation_history: self.conversation_history[user_id] = [] # 添加用户输入到历史 self.conversation_history[user_id].append({"role": "user", "content": user_input}) # 生成AI响应（模拟） if "你好" in user_input or "hello" in user_input: response = "你好！我是AI助手，有什么可以帮您的吗？" elif "时间" in user_input: response = f"现在是 {datetime.datetime.now().strftime('%Y-%m-%d %H:%M:%S')}" elif "状态" in user_input: response = "系统运行正常，所有组件都在线。" else: response = f"我已收到您的消息: '{user_input}'。这是一个模拟响应，实际系统中我会分析您的问题并提供专业解答。" # 添加AI响应到历史 self.conversation_history[user_id].append({"role": "assistant", "content": response}) return response def get_status(self): return { "model": self.model_name, "cache_dir": str(self.cache_dir), "use_gpu": self.use_gpu, "active_conversations": len(self.conversation_history) } 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智能体初始化成功") 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 # 根据系统负载调整AI状态 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) 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='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 socketio = SocketIO(app, cors_allowed_origins="*", async_mode='threading') app.config['SOCKETIO'] = socketio # 注册路由 register_routes(app) register_error_handlers(app) return app, socketio # ========== 环境交互路由 ========== def register_environment_routes(app): @app.route('/environment') def environment_view(): 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) 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, 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('/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() 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(): 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", "未知"), "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未初始化"}), 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: 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": 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] = { 'timestamp': current_time, 'data': furniture_data.get(room, []) } return jsonify(furniture_cache[room]['data']) 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('connect') def handle_connect(): logger.info('客户端已连接') socketio.emit('system_status', {'status': 'ready'}) @socketio.on('disconnect') def handle_disconnect(): logger.info('客户端已断开连接') @socketio.on('user_message') def handle_user_message(data): user_id = data.get('user_id', 'guest') message = data.get('message', '') 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('agent_response', { 'user_id': user_id, 'response': response }) # ========== 主程序入口 ========== if __name__ == '__main__': try: app, socketio = create_app() # 设置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())
08-11
app.config['SECRET_KEY'] = os.environ['APP_SECRET'] ``` 3. **日志安全** 需注意日志中控制字符的过滤，防止终端注入攻击[^1]： ```python import re safe_log = re.sub(r'[\x00-\x1F\x7F-\x9F]', '', ...
websocket
jincm的专栏
12-16 2905
著作权归作者所有。 商业转载请联系作者获得授权，非商业转载请注明出处。 作者：Ovear 链接：http://www.zhihu.com/question/20215561/answer/40316953 来源：知乎 一、WebSocket是HTML5出的东西（协议），也就是说HTTP协议没有变化，或者说没关系，但HTTP是不支持持久连接的（长连接，循环连接的不算） 首先HTTP有
一起写个 WSGI Web Framework
weixin_34221036的博客
02-25 191
作者简介 旺旺，switch狂热爱好者（掌游瘾少年），但是写代码的功力还是可以的，负责骑手相关的开发工作，常年充当老张、老赵、老方...等人的backup，同时常年把老张、老赵、老方...等人列为自己的backup 写在前面 本文中所列举的代码仅在 Python 2.7.15 和 Python 3.7.0 版本下进行编写测试。 什么是 WSGI 使用 Python 进行 Web 项目开发时，...
使用dwebsocket 报错AttributeError: 'WSGIRequest' object has no attribute 'is_websocket'
秋楓的博客
09-07 4044
本人用的django(2.0.8)，dwebsocket版本是最后版本(0.5.10)，因为dwebsocket已不再更新 django setting文件相关配置： # 为所有的URL提供websocket，如果只是单独的视图需要可以不选 MIDDLEWARE_CLASSES=['dwebsocket.middleware.WebSocketMiddleware'] # 可以允许每一个单...
【Linux 网络基础】libwebsockets 技术文档
love131452098的博客
11-24 557
libwebsockets (LWS) 是一个轻量级C语言网络库，专注于现代网络协议(HTTP/1.x/2、WebSocket等)的非阻塞实现。核心特性包括：多角色支持(HTTP/WebSocket/MQTT等)、可插拔TLS后端(OpenSSL/mbedTLS)、虚拟主机管理及跨平台事件循环适配(poll/libuv等)。采用事件驱动架构，通过协议回调处理连接生命周期。提供统一API实现服务器/客户端功能，支持高分辨率定时器和内存优化设计。适用于嵌入式与高性能场景，典型使用模式为单线程事件循环，开发者通过
《计算机网络》(B)复习
2509_94007310的博客
11-23 974
解： UDP总长度为：8000+8=8008B，MTU=1500B，IP头部=20B，数据部分为：1500 20=1480B（1）按上述过程进行分片，8008=1480*5+608，能分为6个分片；（2）最后一个分片长度为：608+20=628B，片偏移量分别为：0，185（1480/8），370， 555，740，925。
计算机网络13
最新发布
2301_80828873的博客
11-24 244
无类别域间路由与网络地址转换
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
红包 添加红包
表情包 插入表情
表情包 代码片
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

Cocktail_py

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值