你有卡住了 我只看到“# ====================== 增强命令处理器 ======================
def chat_model_generate(model, message: str) -> str:
"""使用模型生成聊天回复"""
try:
# 准备模型输入
inputs = model.tokenizer(
message,
return_tensors="pt"
).to(model.device)
# 生成回复
outputs = model.generate(
**inputs,
max_new_tokens=200,
do_sample=True,
temperature=0.7
)
# 解码回复
return model.tokenizer.decode(outputs[0], skip_special_tokens=True)
except Exception as e:
raise RuntimeError(f"生成回复失败: {str(e)}")
def handle_chat_command(message: str) -> dict:
"""处理聊天命令"""
global orchestrator, model_manager
logger = logging.getLogger("Main.Command.Chat")
# 检查模型是否可用
if orchestrator is None or orchestrator.default_model is None:
return {"status": "error", "message": "聊天模型未初始化"}
try:
# 生成回复
response = chat_model_generate(orchestrator.default_model, message)
logger.info(f"🤖 生成回复: {response}")
return {"status": "success", "response": response}
except Exception as e:
logger.error(f"❌ 生成回复失败: {str(e)}", exc_info=True)
return {"status": "error", "message": f"生成回复失败: {str(e)}"}
def handle_vision_command(message: str) -> dict:
"""处理多模态命令"""
global”就卡住了，前面我都覆盖好了“# E:\AI_System\main.py (完整增强版)
import os
import sys
import time
import logging
import logging.handlers
import signal
import json
import traceback
import atexit
import threading
import queue
import torch
from pathlib import Path
from tqdm import tqdm
from concurrent.futures import ThreadPoolExecutor, as_completed
from transformers import AutoConfig, AutoModelForCausalLM, VisionEncoderDecoderModel, AutoModelForVision2Seq
from diffusers import StableDiffusionPipeline, DiffusionPipeline
# 修复导入问题 - 确保根目录在路径中
sys.path.insert(0, str(Path(__file__).parent.resolve()))
try:
from core.config_system import CoreConfig
from core.command_listener import start_command_listener
from agent.model_manager import ModelManager
from core.cognitive_orchestrator import CognitiveOrchestrator
from agent.environment_interface import EnvironmentInterface
from agent.diagnostic_system import DiagnosticSystem
from utils.path_utils import normalize_path, clean_path_cache
except ImportError as e:
print(f"❌ 关键模块导入失败: {e}")
traceback.print_exc()
sys.exit(1)
# ====================== 基础路径配置 ======================
# 确保所有操作都在E盘
BASE_DRIVE = "E:"
PROJECT_ROOT = Path(__file__).parent.resolve()
WORKSPACE_PATH = Path(BASE_DRIVE) / "AI_Workspace"
# 创建必要目录
WORKSPACE_PATH.mkdir(parents=True, exist_ok=True)
# 全局变量
orchestrator = None
model_manager = None
environment_interface = None
diagnostic_system = None
command_listener = None
shutdown_initiated = False
progress_bar = None
log_listener = None # 日志监听器全局引用
start_time = None # 系统启动时间
# ====================== 线程安全的日志处理器 ======================
class ConcurrentFileHandler(logging.FileHandler):
"""线程安全的文件日志处理器"""
def __init__(self, filename, mode='a', encoding=None, delay=False):
super().__init__(filename, mode, encoding, delay)
self.lock = threading.RLock()
self.last_rotate = time.time()
self.max_bytes = 10 * 1024 * 1024 # 10MB
self.backup_count = 5
def emit(self, record):
"""线程安全地记录日志并处理滚动"""
with self.lock:
# 检查是否需要滚动日志
if self.should_rotate():
self.do_rotate()
super().emit(record)
def should_rotate(self):
"""检查是否需要滚动日志"""
if self.stream is None:
self.stream = self._open()
# 检查文件大小
if os.path.exists(self.baseFilename):
if os.stat(self.baseFilename).st_size > self.max_bytes:
return True
# 检查时间（每天滚动一次）
if time.time() - self.last_rotate > 86400: # 24小时
return True
return False
def do_rotate(self):
"""执行日志滚动"""
if self.stream:
self.stream.close()
self.stream = None
# 重命名现有日志文件
base, ext = os.path.splitext(self.baseFilename)
for i in range(self.backup_count - 1, 0, -1):
sfn = f"{base}.{i}{ext}"
dfn = f"{base}.{i+1}{ext}"
if os.path.exists(sfn):
if os.path.exists(dfn):
os.remove(dfn)
os.rename(sfn, dfn)
dfn = f"{base}.1{ext}"
if os.path.exists(dfn):
os.remove(dfn)
os.rename(self.baseFilename, dfn)
self.last_rotate = time.time()
self.stream = self._open()
# ====================== 日志配置 ======================
def setup_logging() -> (logging.Logger, logging.handlers.QueueListener):
"""配置线程安全的日志系统"""
logs_dir = WORKSPACE_PATH / "logs"
logs_dir.mkdir(parents=True, exist_ok=True)
# 配置日志级别
log_level_name = CoreConfig.get("log_level", "INFO").upper()
log_level = getattr(logging, log_level_name, logging.INFO)
# 创建唯一的日志文件名
log_file = logs_dir / f"system_{time.strftime('%Y%m%d_%H%M%S')}.log"
# 配置根日志记录器
root_logger = logging.getLogger()
root_logger.setLevel(log_level)
# 移除所有现有处理器
for handler in root_logger.handlers[:]:
root_logger.removeHandler(handler)
handler.close()
# 创建线程安全的文件处理器
file_handler = ConcurrentFileHandler(log_file, encoding='utf-8')
file_handler.setLevel(log_level)
# 控制台处理器
console_handler = logging.StreamHandler()
console_handler.setLevel(log_level)
# 日志格式
log_format = "%(asctime)s - [%(levelname)s] - %(name)s - %(message)s"
formatter = logging.Formatter(log_format)
file_handler.setFormatter(formatter)
console_handler.setFormatter(formatter)
# 创建队列处理器
log_queue = queue.Queue(-1) # 无限队列
queue_handler = logging.handlers.QueueHandler(log_queue)
queue_handler.setLevel(log_level)
# 创建队列监听器
queue_listener = logging.handlers.QueueListener(
log_queue, file_handler, console_handler
)
queue_listener.start()
# 添加队列处理器
root_logger.addHandler(queue_handler)
# 创建主日志记录器
main_logger = root_logger.getChild("Main")
main_logger.info(f"⚙️ 日志系统初始化完成 (级别: {log_level_name})")
main_logger.info(f"📝 日志文件位置: {log_file}")
return main_logger, queue_listener
# ====================== 模型路径处理 ======================
def get_model_paths(model_name: str) -> list:
"""返回所有可能的模型路径（仅限E盘）"""
return [
WORKSPACE_PATH / "AI_Models" / model_name,
Path(BASE_DRIVE) / "AI_Models" / model_name,
Path(BASE_DRIVE) / "Models" / model_name,
WORKSPACE_PATH / "models" / model_name
]
def find_valid_model_path(model_name: str, logger: logging.Logger) -> Path:
"""在E盘查找有效的模型路径"""
possible_paths = get_model_paths(model_name)
for path in possible_paths:
normalized_path = normalize_path(str(path))
if os.path.exists(normalized_path):
logger.info(f"✅ 找到模型路径: {normalized_path}")
return Path(normalized_path)
# 没有找到有效路径
logger.critical(f"🛑 在E盘找不到模型: {model_name}")
logger.critical("检查位置:")
for path in possible_paths:
logger.critical(f" - {path}")
raise FileNotFoundError(f"在E盘找不到模型: {model_name}")
# ====================== 模型注册函数 ======================
def register_models(model_manager, logger: logging.Logger) -> list:
"""异步注册所有模型并显示进度"""
model_configs = {
"TEXT_BASE": {"path": r"E:\AI_Models\Qwen2-7B", "type": "text", "priority": 1},
"TEXT_CHAT": {"path": r"E:\AI_Models\deepseek-7b-chat", "type": "text", "priority": 2},
"MULTIMODAL": {"path": r"E:\AI_Models\deepseek-vl2", "type": "multimodal", "priority": 3},
"IMAGE_MODEL": {"path": r"E:\AI_Models\sdxl", "type": "image", "priority": 4},
"YI_VL": {"path": r"E:\AI_Models\yi-vl", "type": "multimodal", "priority": 5}
}
# 按优先级排序模型
sorted_models = sorted(model_configs.items(), key=lambda x: x[1]["priority"])
registered_models = []
futures = {}
# ✅ 关键修改1：添加路径存在性检查
with tqdm(total=len(model_configs), desc="🚀 注册模型") as pbar:
with ThreadPoolExecutor(max_workers=3) as executor:
for model_name, config in sorted_models:
# 检查模型路径是否存在
if not Path(config["path"]).exists():
logger.warning(f"⚠️ 模型路径不存在: {model_name} -> {config['path']}")
pbar.update(1)
continue # 跳过不存在的路径
future = executor.submit(
model_manager.register_model,
model_name,
config["path"],
config["type"]
)
futures[future] = model_name
# ✅ 关键修改2：确保进度条正确更新
for future in as_completed(futures):
model_name = futures[future]
try:
success = future.result()
if success:
registered_models.append(model_name)
logger.info(f"✅ 注册成功: {model_name}")
else:
logger.error(f"❌ 注册失败: {model_name}")
except Exception as e:
logger.error(f"❌ 模型注册异常: {model_name} - {str(e)}", exc_info=True)
finally:
pbar.update(1)
pbar.set_postfix_str(f"当前: {model_name}")
return registered_models
# ====================== 安全关闭处理 ======================
def shutdown_handler(signum=None, frame=None):
"""安全关闭系统（避免重复关闭）"""
global shutdown_initiated, progress_bar, log_listener
if shutdown_initiated:
return
shutdown_initiated = True
logger = logging.getLogger("Main.Shutdown")
if signum:
signal_name = {signal.SIGINT: "Ctrl+C", signal.SIGTERM: "终止信号"}.get(signum, signum)
logger.warning(f"⚠️ 接收到关闭信号: {signal_name}")
else:
logger.warning(f"⚠️ 接收到关闭请求")
# 关闭顺序优化
shutdown_sequence = [
("命令监听器", command_listener.stop if command_listener else None),
("协调器", orchestrator.shutdown if orchestrator else None),
("模型管理器", model_manager.shutdown if model_manager else None),
("环境接口", environment_interface.shutdown if environment_interface else None),
("诊断系统", diagnostic_system.shutdown if diagnostic_system else None)
]
for name, shutdown_func in shutdown_sequence:
if shutdown_func:
try:
logger.info(f"🛑 正在关闭{name}...")
shutdown_func()
logger.info(f"✅ {name}已关闭")
except Exception as e:
logger.error(f"❌ 关闭{name}失败: {str(e)}", exc_info=True)
# 确保关闭进度条
if progress_bar:
try:
progress_bar.close()
except:
pass
# 停止日志监听器
if log_listener:
logger.info("🛑 正在停止日志监听器...")
log_listener.stop()
logger.info("✅ 日志监听器已停止")
# 确保日志系统最后关闭
logging.shutdown()
sys.exit(0)
# ====================== 设置默认模型 ======================
def setup_default_model():
"""
设置默认模型
"""
global model_manager, orchestrator
logger = logging.getLogger("Main.DefaultModel")
try:
# 尝试加载 TEXT_BASE 作为默认模型
model_name = "TEXT_BASE"
logger.info(f"⏳ 开始加载默认模型: {model_name}")
# 同步加载模型
success, model = model_manager.load_model(model_name)
if success and model is not None:
# 使用协调器的 set_model 方法而不是 set_default_model
if hasattr(orchestrator, 'set_model'):
orchestrator.set_model(model_name, model)
logger.info(f"✅ 默认模型已设置: {model_name}")
else:
# 如果协调器没有 set_model 方法，直接赋值
orchestrator.default_model = model
logger.info(f"✅ 默认模型已设置 (直接赋值): {model_name}")
return True
else:
raise RuntimeError("模型加载返回失败状态")
except Exception as e:
logger.error(f"❌ 默认模型设置异常: {str(e)}", exc_info=True)
return False
# ====================== 全局异常处理 ======================
def global_exception_handler(exc_type, exc_value, exc_traceback):
"""
增强版全局异常处理器
关键改进：
1. 添加内存状态转储
2. 优化崩溃报告格式
3. 添加关键变量记录
4. 增强错误分析信息
"""
if issubclass(exc_type, KeyboardInterrupt):
sys.excepthook(exc_type, exc_value, exc_traceback)
return
# 获取日志记录器
logger = logging.getLogger("Main.Critical")
# 记录原始异常
logger.critical("💥 未捕获的全局异常", exc_info=(exc_type, exc_value, exc_traceback))
try:
# 创建崩溃报告
crash_report = {
"timestamp": time.strftime("%Y-%m-%d %H:%M:%S"),
"system": {
"python_version": sys.version,
"platform": sys.platform,
"executable": sys.executable
},
"exception": {
"type": str(exc_type),
"message": str(exc_value),
"traceback": traceback.format_tb(exc_traceback)
},
"environment": {
"workspace": str(WORKSPACE_PATH),
"project_root": str(PROJECT_ROOT),
"shutdown_initiated": shutdown_initiated
},
"modules": {
"orchestrator": "initialized" if orchestrator else "not initialized",
"model_manager": "initialized" if model_manager else "not initialized",
"diagnostic_system": "initialized" if diagnostic_system else "not initialized"
}
}
# 添加内存分析（如果可用）
try:
import psutil
process = psutil.Process()
crash_report["memory"] = {
"rss": process.memory_info().rss,
"vms": process.memory_info().vms,
"percent": process.memory_percent()
}
except ImportError:
crash_report["memory"] = "psutil not available"
# 保存崩溃报告
crash_dir = WORKSPACE_PATH / "crash_reports"
crash_dir.mkdir(exist_ok=True)
timestamp = time.strftime("%Y%m%d_%H%M%S")
crash_file = crash_dir / f"crash_{timestamp}.json"
with open(crash_file, "w", encoding="utf-8") as f:
json.dump(crash_report, f, indent=2, ensure_ascii=False)
logger.error(f"📝 崩溃报告已保存: {crash_file}")
# 额外保存完整堆栈跟踪
stack_file = crash_dir / f"stacktrace_{timestamp}.log"
with open(stack_file, "w", encoding="utf-8") as f:
traceback.print_exception(exc_type, exc_value, exc_traceback, file=f)
logger.error(f"📝 堆栈跟踪已保存: {stack_file}")
except Exception as e:
logger.error(f"❌ 保存崩溃报告失败: {str(e)}")
# 回退到简单记录
traceback.print_exception(exc_type, exc_value, exc_traceback)
# 尝试安全关闭
logger.critical("🛑 尝试安全关闭系统...")
try:
shutdown_handler()
except Exception as e:
logger.error(f"❌ 安全关闭失败: {str(e)}")
sys.exit(1)
# ====================== 命令处理器 ======================
def command_handler(command: str):
"""处理用户命令"""
global orchestrator, model_manager, environment_interface, diagnostic_system
logger = logging.getLogger("Main.Command")
logger.info(f"📝 收到命令: {command}")
# 转换为小写以便处理
cmd = command.strip().lower()
if cmd == "help":
return {
"status": "success",
"commands": {
"help": "显示此帮助信息",
"status": "显示系统状态",
"models": "列出所有可用模型",
"load [model]": "加载指定模型",
"unload [model]": "卸载指定模型",
"shutdown": "安全关闭系统"
}
}
elif cmd == "status":
# 获取系统状态
status = {
"system": {
"uptime": time.time() - start_time if 'start_time' in globals() else 0,
"shutdown_initiated": shutdown_initiated
}
}
# 添加模型管理器状态
if model_manager:
status["model_manager"] = model_manager.get_status()
# 添加协调器状态
if orchestrator:
status["orchestrator"] = orchestrator.get_status()
return status
elif cmd == "models":
# 列出所有已注册模型
if model_manager:
return {
"registered_models": model_manager.registered_models,
"loaded_models": list(model_manager.loaded_models.keys())
}
return {"error": "模型管理器未初始化"}
elif cmd.startswith("load "):
# 加载指定模型
model_name = cmd[5:].upper()
if model_manager:
try:
# 异步加载模型
future = model_manager.load_model(model_name)
return {"status": "loading", "model": model_name, "message": "模型正在异步加载"}
except Exception as e:
return {"error": f"加载模型失败: {str(e)}"}
return {"error": "模型管理器未初始化"}
elif cmd.startswith("unload "):
# 卸载指定模型
model_name = cmd[7:].upper()
if model_manager:
try:
model_manager.unload_model(model_name)
return {"status": "success", "model": model_name, "message": "模型已卸载"}
except Exception as e:
return {"error": "卸载模型失败: {str(e)}"}
return {"error": "模型管理器未初始化"}
elif cmd == "shutdown":
# 安全关闭系统
return {"action": "shutdown", "message": "系统将在5秒内关闭"}
else:
return {"error": "未知命令", "available_commands": ["help", "status", "models", "load", "unload", "shutdown"]}
# ====================== 主函数 ======================
def main():
"""主函数（完全E盘操作）"""
global orchestrator, model_manager, environment_interface, diagnostic_system
global command_listener, progress_bar, log_listener, start_time
# 记录启动时间
start_time = time.time()
# 设置全局异常处理器
sys.excepthook = global_exception_handler
# 清理路径缓存
clean_path_cache()
# 初始化配置系统
CoreConfig.initialize()
# 设置日志 - 修复返回值问题
logger, log_listener = setup_logging()
# 注册退出处理
atexit.register(shutdown_handler)
# 设置信号处理
signal.signal(signal.SIGINT, shutdown_handler)
signal.signal(signal.SIGTERM, shutdown_handler)
# 记录启动信息
logger.info("=" * 70)
logger.info(f"🌟 {'AI系统 - 弹性星型架构':^60} 🌟")
logger.info("=" * 70)
logger.info(f"🚀 工作空间: {WORKSPACE_PATH}")
logger.info(f"📂 项目目录: {PROJECT_ROOT}")
logger.info(f"🐍 Python版本: {sys.version}")
logger.info(f"🖥️ 操作系统: {sys.platform}")
logger.info("-" * 70)
# 创建启动进度条
progress_bar = tqdm(
total=100,
desc="🚀 系统启动中",
bar_format="{l_bar}{bar}| {n_fmt}/{total_fmt} [{elapsed}<{remaining}]",
dynamic_ncols=True
)
try:
# 初始化模型管理器
model_manager_config = CoreConfig.get("model_manager", {})
cache_dir = WORKSPACE_PATH / "model_cache"
cache_dir.mkdir(parents=True, exist_ok=True)
model_manager = ModelManager(
config=model_manager_config,
cache_dir=str(cache_dir),
use_gpu=model_manager_config.get("use_gpu", True),
max_models_in_memory=model_manager_config.get("max_models_in_memory", 3)
)
logger.info("✅ 模型管理器初始化完成")
progress_bar.update(10) # 更新进度条
# 注册所有模型
progress_bar.set_description("📦 注册模型中")
progress_bar.refresh()
registered_models = register_models(model_manager, logger)
# 验证已注册模型
logger.info("🔍 验证已注册模型...")
valid_models = model_manager.validate_registered_models(logger)
logger.info(f"✅ 有效模型: {len(valid_models)}/{len(registered_models)}")
# 检查是否有有效模型
if not valid_models:
logger.critical("🛑 没有有效模型，系统无法启动")
shutdown_handler()
return
logger.info(f"✅ 已注册模型: {registered_models}")
progress_bar.update(30) # 更新进度条
progress_bar.set_description("🚀 系统启动中") # 重置描述
# 初始化星型协调器
progress_bar.set_description("🧠 初始化协调器")
progress_bar.refresh()
cognitive_config = CoreConfig.get("cognitive_config", {})
state_dir = WORKSPACE_PATH / "system_state"
state_dir.mkdir(parents=True, exist_ok=True)
cognitive_config["state_dir"] = str(state_dir)
orchestrator = CognitiveOrchestrator(config=cognitive_config)
logger.info("✅ 星型协调器初始化完成")
progress_bar.update(15) # 更新进度条
progress_bar.set_description("🚀 系统启动中") # 重置描述
# 设置默认模型
setup_default_model()
# 初始化卫星模块
progress_bar.set_description("🛰️ 初始化卫星模块")
progress_bar.refresh()
ei_config = CoreConfig.get("environment_interface", {})
ds_config = CoreConfig.get("diagnostic_system", {})
environment_interface = EnvironmentInterface(
name="环境接口",
coordinator=orchestrator,
config=ei_config
)
diagnostic_system = DiagnosticSystem(
name="诊断系统",
coordinator=orchestrator,
config=ds_config
)
# 动态注册模块
register_method = None
if hasattr(orchestrator, 'register_module'):
register_method = orchestrator.register_module
elif hasattr(orchestrator, 'add_module'):
register_method = orchestrator.add_module
else:
logger.warning("⚠️ 协调器没有标准注册方法，使用直接赋值")
orchestrator.modules = {}
# 注册模块
module_mapping = {
"environment": environment_interface,
"diagnostic": diagnostic_system
}
for name, module in module_mapping.items():
if register_method:
register_method(name, module)
else:
orchestrator.modules[name] = module
logger.info("✅ 卫星模块初始化完成")
progress_bar.update(15) # 更新进度条
progress_bar.set_description("🚀 系统启动中") # 重置描述
except Exception as e:
logger.error(f"❌ 系统初始化失败: {e}", exc_info=True)
if progress_bar:
progress_bar.close()
sys.exit(1)
# 连接模块
try:
progress_bar.set_description("🔗 连接模块中")
progress_bar.refresh()
if hasattr(orchestrator, 'connect_modules'):
if orchestrator.connect_modules():
logger.info("✅ 星型架构模块连接成功")
else:
logger.warning("⚠️ 模块连接存在问题，系统进入降级模式")
else:
logger.info("ℹ️ 协调器没有 connect_modules 方法，跳过模块连接")
progress_bar.update(10) # 更新进度条
progress_bar.set_description("🚀 系统启动中") # 重置描述
except Exception as e:
logger.error(f"❌ 模块连接失败: {e}", exc_info=True)
if progress_bar:
progress_bar.close()
sys.exit(1)
# 加载基础模型
base_model_key = "TEXT_BASE"
base_model_info = CoreConfig.get("model_settings.TEXT_BASE", {})
model_name = base_model_info.get("name", "Qwen2-7B")
try:
progress_bar.set_description(f"🤖 加载 {model_name}")
progress_bar.refresh()
# 同步加载基础模型
success, model = model_manager.load_model(base_model_key)
if success:
logger.info(f"✅ 基础模型加载成功: {base_model_key}")
# 使用协调器的 set_model 方法而不是 set_default_model
if hasattr(orchestrator, 'set_model'):
orchestrator.set_model(base_model_key, model)
else:
# 如果协调器没有 set_model 方法，直接赋值
orchestrator.default_model = model
else:
raise RuntimeError(f"模型加载返回失败状态: {base_model_key}")
progress_bar.update(10)
progress_bar.set_description("🚀 系统启动中")
except Exception as e:
logger.error(f"❌ 基础模型加载失败: {e}", exc_info=True)
# 检查是否有其他可用模型
fallback_model = None
for model_name in registered_models:
if model_name != base_model_key:
try:
success, model = model_manager.load_model(model_name)
if success:
fallback_model = model_name
logger.warning(f"⚠️ 使用备用模型: {fallback_model}")
# 使用协调器的 set_model 方法而不是 set_default_model
if hasattr(orchestrator, 'set_model'):
orchestrator.set_model(fallback_model, model)
else:
# 如果协调器没有 set_model 方法，直接赋值
orchestrator.default_model = model
break
except:
continue
if not fallback_model:
logger.critical("🛑 没有可用模型，系统无法启动")
shutdown_handler()
return
# 启动命令监听器
try:
progress_bar.set_description("📡 启动命令监听")
progress_bar.refresh()
command_listener = start_command_listener(
command_handler=command_handler,
shutdown_handler=shutdown_handler
)
logger.info("✅ 命令监听器已启动")
progress_bar.update(10) # 更新进度条
except Exception as e:
logger.error(f"❌ 命令监听器启动失败: {e}", exc_info=True)
if progress_bar:
progress_bar.close()
shutdown_handler()
return
# 完成启动进度
progress_bar.set_description("🎉 系统准备就绪")
progress_bar.update(10) # 最后10%
time.sleep(0.5) # 让用户看到完成状态
progress_bar.close()
logger.info("🌟 系统准备就绪! 输入命令开始交互 ('help' 查看命令列表)")
logger.info("-" * 70)
# 主循环
try:
while True:
time.sleep(0.1) # 降低CPU占用
# 检查命令队列
if command_listener and hasattr(command_listener, 'command_queue'):
while not command_listener.command_queue.empty():
command = command_listener.command_queue.get()
response = command_handler(command)
# 处理关闭指令
if isinstance(response, dict) and response.get("action") == "shutdown":
shutdown_handler()
return
# 打印响应
if response:
print("\n" + ("-" * 50))
if isinstance(response, dict):
response_str = json.dumps(response, indent=2, ensure_ascii=False)
print(f"系统响应:\n{response_str}")
else:
print(f"系统响应: {str(response)}")
print("-" * 50 + "\n")
except Exception as e:
logger.critical(f"🔥 主循环错误: {e}", exc_info=True)
shutdown_handler()
if __name__ == "__main__":
try:
main()
except Exception as e:
print(f"🔥 主函数异常: {e}")
traceback.print_exc()
sys.exit(1)”，你从“# ====================== 增强命令处理器 ======================”开始写吧
本文介绍了如何使用Python的concurrent.futures库并行检测一组大质数，同时处理`atexit`模块在进程池执行器关闭时可能出现的错误。
扫一扫
7298
到【灌水乐园】发言
