没看懂 是改这个文件吗：“# 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
import subprocess
from pathlib import Path
from functools import wraps
from concurrent
.futures import ThreadPool
Executor
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 = ThreadPool
Executor(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):
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)
# 聊天路由
@app
.route('/chat', methods=['POST'])
@app
.config['LIMITER']
.limit("30 per minute")
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)}")
# 使用线程池异步处理
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 = Limiter(
get_remote_address,
app=app,
default_limits=["200 per day", "50 per hour"],
storage_uri="memory://"
)
app
.config['LIMITER'] = 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模式，性能可能受影响")
socketio = SocketIO(
app,
cors_allowed_origins="*",
async_mode=async_mode,
logger=True,
engineio_logger=True
)
app
.config['SOCKETIO'] = socketio
# 注册路由和错误处理
register_routes(app)
register_error_handlers(app)
return app, socketio
# ========== 主程序入口 ==========
if __name__ == '__main__':
try:
app, socketio = create_app()
setup_websocket_handlers(socketio)
if config
.DEBUG:
logger
.info(f"开发服务器运行在 http://{config
.HOST}:{config
.PORT}")
socketio
.run(
app,
host=config
.HOST,
port=config
.PORT,
debug=True,
use_reloader=False,
log_output=True
)
else:
run_production_server(app)
except KeyboardInterrupt:
logger
.info("服务器关闭")
executor.shutdown(wait=False)
except Exception as e:
logger
.critical(f"服务器启动失败: {str(e)}")
logger
.error(traceback
.format_exc())
executor.shutdown(wait=False)
sys
.exit(1)
”如果是 请把改好的完整版发给我 注意不要随便删减我原来的主要内容哦
本文介绍了如何使用pip来管理Python项目的依赖，通过创建requirements.txt文件并利用pip install -r命令来批量安装所需的软件包。此外，还探讨了Flask框架的一些基本用法，包括开启调试模式以便实时查看代码更改的效果。
扫一扫
297
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
