sys.modules[__name__]的一个实例

本文介绍了一种使用Python的sys模块和getattr函数动态调用模块的方法。通过从JSON文件中读取指定键的值,并将该值作为模块名,通过getattr从当前模块中获取相应的对象并执行其方法。

摘要生成于 C知道 ,由 DeepSeek-R1 满血版支持, 前往体验 >

  关于sys.modules[__name__]的用法,百度上阅读量比较多得一个帖子是:https://www.cnblogs.com/robinunix/p/8523601.html

  对于里面提到的基础性的知识点这里就不再重复了,大家看原贴就好。这里为大家提供一个详细的例子,帮助大家更进一步的理解。

  有这样一个需求:我们需要在whw.json文件中读取出name键对应的value,然后用这个value通过getattr方法取到相应模块的对象名,实现该对象中的方法。

  whw.json文件中的内容如下: 

{"name": "whw", "password": "wanghwhwhw", "email": "1122@qq.com"}

  具体代码如下:

import sys
import json

f = open('whw.json','r')
data = f.read()
name = json.loads(data)['name']

def whw():
    print('HelloWorld!')

class Wanghw:
    def __init__(self):
        pass #构造函数略

    def run(self):
        whw_obj = getattr(sys.modules[__name__],name)
        whw_obj()

if __name__ == '__main__':
    wanghw = Wanghw()
    wanghw.run()

  程序的实现效果如下:

 

转载于:https://www.cnblogs.com/paulwhw/p/9000529.html

把这段代码写入进去,修改后的导入部分 - 使用绝对导入 from dlt_analyzer.core.app_context import app from dlt_analyzer.core.number_pool import NumberPool from dlt_analyzer.core.event_center import EventCenter from dlt_analyzer.ui.main_interface import MainWindow from dlt_analyzer.core.global_config import GlobalConfig 业务模块导入 from dlt_analyzer.modules.input_analysis import InputAnalyzer from dlt_analyzer.modules.combination_analysis import CombinationAnalysisModule from dlt_analyzer.modules.trend_analysis import TrendAnalysisModule from dlt_analyzer.modules.follow_analysis import FollowAnalysisModule from dlt_analyzer.modules.number_generation import NumberGenerationModule其它问题:在 ‘init.py’ 中找不到引用 'main_window’未解析的引用 'root’找不到模块 'MainWindow’从外部作用域隐藏名称 'GlobalConfig’函数中的变量应小写从外部作用域隐藏名称 'pool’代码# main.py !/usr/bin/env python3 -- coding: utf-8 -- import sys from pathlib import Path from typing import Optional 所有模块级导入移到顶部(E402) from core import InputAnalyzer, DialogManager from core.app_context import app from core.number_pool import NumberPool from ui.main_interface import MainWindow from tkinter import Tk import tkinter as tk 移除重复的导入语句 sys.path.insert(0, str(Path(file).parent)) 全局配置延迟导入 def get_global_config(): from core.global_config import GlobalConfig return GlobalConfig() def main(): “”“主程序入口函数”“” # 初始化全局配置 GlobalConfig = get_global_config() GlobalConfig.init() # 创建主窗口 root = Tk() root.title(GlobalConfig.VERSION) root.geometry("800x600") # 初始化号码池 pool = NumberPool() app.number_pool = pool # 创建主界面 main_ui = MainWindow(root, pool) app.main_ui = main_ui # 启动事件循环 root.mainloop() if name == “main”: # 执行时延迟导入GUI模块 from ui.main_window import MainWindow window = MainWindow() window.run() # 初始化配置 GlobalConfig = get_global_config() GlobalConfig.init() # 获取事件中心(延迟导入)from core.event_center import event_center # 初始化UI from ui.main_interface import MainInterface pool = NumberPool() app = MainInterface(root, pool) root.mainloop()
08-06
# agent/autonomous_agent.py import os import sys import time import json import logging import traceback import threading import platform import psutil from pathlib import Path from typing import Any, Dict, Optional, List, Callable, Tuple from concurrent.futures import ThreadPoolExecutor, Future, TimeoutError # 原错误导入 from core.config import system_config # 修改为正确导入 from core.config import CoreConfig system_config = CoreConfig() # 创建配置实例 # 确保项目根目录在 sys.path 中 BASE_DIR = Path(__file__).resolve().parent.parent.parent # 指向 E:\AI_System if str(BASE_DIR) not in sys.path: sys.path.insert(0, str(BASE_DIR)) # 导入核心模块 from core.config import system_config from core.exceptions import DependencyError, SubsystemFailure, ConfigurationError from core.metrics import MetricsCollector from core.circuit_breaker import CircuitBreaker from core.subsystem_registry import SubsystemRegistry # 全局线程池 executor = ThreadPoolExecutor(max_workers=system_config.MAX_WORKERS) 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.metrics = MetricsCollector() # 熔断器管理器 self.circuit_breakers: Dict[str, CircuitBreaker] = {} # 子系统注册表 self.subsystem_registry = SubsystemRegistry() # 环境管理器(外部设置) self.environment = None # 确保必要目录存在 self._ensure_directories_exist() try: # 初始化步骤 self._record_step("验证配置") self._validate_configuration() self._record_step("加载环境变量") self._load_environment() 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)}") 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 _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' log_file.parent.mkdir(parents=True, exist_ok=True) file_handler = logging.FileHandler(log_file, encoding='utf-8') file_handler.setLevel(system_config.LOG_LEVEL) # 创建格式化器 formatter = logging.Formatter( '%(asctime)s [%(levelname)s] %(name)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 _ensure_directories_exist(self): """确保所需目录存在""" required_dirs = [ system_config.LOG_DIR, system_config.CONFIG_DIR, system_config.MODEL_CACHE_DIR ] for dir_path in required_dirs: try: if not isinstance(dir_path, Path): dir_path = Path(dir_path) if not dir_path.exists(): dir_path.mkdir(parents=True, exist_ok=True) self.logger.info(f"创建目录: {dir_path}") except Exception as e: self.logger.error(f"创建目录失败 {dir_path}: {str(e)}") def _validate_configuration(self): """验证关键配置项""" required_configs = [ 'LOG_DIR', 'CONFIG_DIR', 'MODEL_CACHE_DIR', 'MAX_WORKERS', 'AGENT_RESPONSE_TIMEOUT' ] missing = [] for config_key in required_configs: if not hasattr(system_config, config_key): missing.append(config_key) if missing: raise ConfigurationError(f"缺失关键配置项: {', '.join(missing)}") # 检查配置值有效性 if system_config.MAX_WORKERS <= 0: raise ConfigurationError(f"无效的MAX_WORKERS值: {system_config.MAX_WORKERS}") def _record_step(self, step_name: str): """记录初始化步骤""" self.initialization_steps.append(step_name) self.logger.info(f"⏳ 步骤 {len(self.initialization_steps)}: {step_name}") def _load_environment(self): """加载环境变量""" env_path = system_config.CONFIG_DIR / ".env" if not env_path.exists(): self.logger.warning(f"⚠️ 环境变量文件不存在: {env_path}") return try: from dotenv import load_dotenv load_dotenv(env_path) self.logger.info(f"✅ 已加载环境变量文件: {env_path}") except ImportError: self.logger.warning("dotenv包未安装,跳过环境变量加载。请安装: pip install python-dotenv") except Exception as e: self.logger.error(f"加载环境变量失败: {str(e)}") def set_environment(self, env_manager): """设置环境管理器引用""" self.environment = env_manager self.logger.info("✅ 已连接环境管理器") # 注册环境监控任务 if self.environment: self.subsystem_registry.register_task( "环境监控", self._monitor_environment, interval=system_config.get('ENVIRONMENT_MONITOR_INTERVAL', 5.0) ) def start(self): """启动智能体后台任务""" if not self._running: self._start_background_tasks() self.logger.info("🏁 智能体后台任务已启动") else: self.logger.warning("智能体已在运行中") def _start_background_tasks(self): """启动后台任务线程""" if self._running: 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): """后台任务循环""" self.logger.info("🔄 后台任务循环启动") while self._running: try: start_time = time.time() # 执行注册的周期性任务 self.subsystem_registry.run_periodic_tasks() # 动态调整睡眠时间 task_time = time.time() - start_time sleep_time = max(0.1, system_config.AGENT_TASK_INTERVAL - task_time) time.sleep(sleep_time) except Exception as e: self.logger.error(f"后台任务错误: {str(e)}") self.metrics.record_error('background_task') time.sleep(30) # 错误后等待更长时间 def verify_environment(self): """验证运行环境是否满足要求""" # 检查必需模块 required_modules = [ 'os', 'sys', 'logging', 'flask', 'werkzeug', 'numpy', 'transformers', 'torch', 'psutil' ] # 检查必需包 required_packages = [ ('dotenv', 'python-dotenv'), ('flask_socketio', 'flask-socketio') ] missing_modules = [] for mod in required_modules: try: __import__(mod) except ImportError: missing_modules.append(mod) missing_packages = [] for import_name, pkg_name in required_packages: try: __import__(import_name) except ImportError: missing_packages.append(pkg_name) # 处理缺失项 errors = [] if missing_modules: errors.append(f"缺失Python模块: {', '.join(missing_modules)}") if missing_packages: errors.append(f"缺失Python包: {', '.join(missing_packages)}") if errors: error_msg = "环境验证失败:\n" + "\n".join(errors) self.logger.error(error_msg) raise DependencyError(error_msg) self.logger.info("✅ 环境验证通过") def _log_environment_status(self): """记录环境状态信息""" try: # 获取系统信息 sys_info = { "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), } self.logger.info( f"📊 系统状态: OS={sys_info['os']} {sys_info['os_version']}, " f"CPU={sys_info['cpu']} ({sys_info['cpu_cores']}核), " f"内存={sys_info['memory_used']}/{sys_info['memory_total']}GB, " f"磁盘={sys_info['disk_used']}/{sys_info['disk_total']}GB" ) except Exception as e: self.logger.error(f"环境状态获取失败: {str(e)}") self.metrics.record_error('environment_status') def _initialize_core_components(self): """初始化不依赖其他组件的核心组件""" self._log_environment_status() # 初始化熔断器 self._initialize_circuit_breakers() # 注册核心任务 self.subsystem_registry.register_task( "子系统心跳检查", self._check_subsystem_heartbeats, interval=system_config.get('HEARTBEAT_INTERVAL', 60.0) ) self.subsystem_registry.register_task( "子系统恢复", self._recover_failed_subsystems, interval=system_config.get('RECOVERY_INTERVAL', 300.0) ) def _initialize_circuit_breakers(self): """为所有子系统初始化熔断器""" subsystems = [ '健康系统', '模型管理器', '记忆系统', '情感系统', '认知架构', '通信系统' ] for subsystem in subsystems: breaker = CircuitBreaker( failure_threshold=system_config.get('CIRCUIT_BREAKER_THRESHOLD', 5), recovery_timeout=system_config.get('CIRCUIT_BREAKER_TIMEOUT', 300) ) self.circuit_breakers[subsystem] = breaker self.logger.info(f"⚡ 为 {subsystem} 初始化熔断器") def _initialize_subsystems(self): """初始化所有子系统""" # 定义子系统初始化顺序 subsystems = [ ('健康系统', self._create_health_system, {}), ('模型管理器', self._create_model_manager, {}), ('记忆系统', self._create_memory_system, {}), ('情感系统', self._create_affective_system, {}), ('认知架构', self._create_cognitive_architecture, {}), ('通信系统', self._create_communication_system, {}) ] # 注册子系统依赖关系 dependencies = { '通信系统': ['认知架构'], '情感系统': ['健康系统', '记忆系统'], '认知架构': ['记忆系统'] } for name, creator_func, kwargs in subsystems: try: # 检查依赖是否满足 if name in dependencies: missing_deps = [dep for dep in dependencies[name] if not self.subsystem_registry.get_subsystem(dep)] if missing_deps: self.logger.warning(f"⚠️ 子系统 {name} 缺少依赖: {', '.join(missing_deps)}") # 尝试自动初始化缺失依赖 for dep in missing_deps: self._initialize_dependency(dep) # 创建实例 instance = creator_func(**kwargs) self.subsystem_registry.register_subsystem(name, instance) # 注册子系统任务 if hasattr(instance, 'periodic_task'): self.subsystem_registry.register_task( f"{name}更新", instance.periodic_task, interval=system_config.get(f'{name}_INTERVAL', 60.0) ) self.logger.info(f"✅ {name}初始化完成") except Exception as e: self.logger.error(f"❌ {name}初始化失败: {str(e)}") self.metrics.record_error(f'subsystem_init_{name.lower()}') def _initialize_dependency(self, subsystem_name: str): """初始化依赖子系统""" creators = { '健康系统': self._create_health_system, '模型管理器': self._create_model_manager, '记忆系统': self._create_memory_system, '情感系统': self._create_affective_system, '认知架构': self._create_cognitive_architecture, '通信系统': self._create_communication_system } if subsystem_name in creators: try: instance = creators[subsystem_name]() self.subsystem_registry.register_subsystem(subsystem_name, instance) self.logger.info(f"✅ 依赖子系统 {subsystem_name} 初始化完成") except Exception as e: self.logger.error(f"❌ 依赖子系统 {subsystem_name} 初始化失败: {str(e)}") raise # 各子系统实现(增强功能) def _create_health_system(self): class HealthSystem: def __init__(self): self.status = "healthy" self.metrics: Dict[str, Any] = {} self.logger = logging.getLogger('HealthSystem') def periodic_task(self): """更新健康状态""" try: # 获取系统状态 cpu_usage = psutil.cpu_percent() mem_usage = psutil.virtual_memory().percent disk_usage = psutil.disk_usage('/').percent # 更新状态 self.status = "healthy" if cpu_usage < 90 and mem_usage < 90 else "warning" self.metrics = { "cpu_usage": cpu_usage, "mem_usage": mem_usage, "disk_usage": disk_usage, "timestamp": time.time() } self.logger.debug(f"健康状态更新: {self.status}") except Exception as e: self.logger.error(f"健康系统更新失败: {str(e)}") def record_environment_status(self, env_data: Dict[str, Any]): """记录环境状态""" self.metrics['environment'] = env_data def get_status(self) -> Dict[str, Any]: return { "status": self.status, "metrics": self.metrics } return HealthSystem() def _create_model_manager(self): class ModelManager: def __init__(self): self.loaded_models: Dict[str, Dict[str, Any]] = {} self.logger = logging.getLogger('ModelManager') def load_model(self, model_name: str) -> bool: """加载模型""" if model_name not in self.loaded_models: # 模拟模型加载 self.logger.info(f"加载模型: {model_name}") self.loaded_models[model_name] = { "status": "loaded", "load_time": time.time() } return True return False def periodic_task(self): """模型管理器周期性任务""" # 检查模型状态 for model_name, model_info in list(self.loaded_models.items()): # 模拟模型验证 if time.time() - model_info['load_time'] > 86400: # 24小时 self.logger.info(f"重新加载模型: {model_name}") model_info['load_time'] = time.time() def get_status(self) -> Dict[str, Any]: return { "loaded_models": list(self.loaded_models.keys()), "count": len(self.loaded_models) } return ModelManager() def _create_memory_system(self): class MemorySystem: def __init__(self): self.memories: List[Dict[str, Any]] = [] self.last_consolidation = time.time() self.logger = logging.getLogger('MemorySystem') def periodic_task(self): """巩固记忆""" try: # 保留最近100条记忆 if len(self.memories) > 100: self.memories = self.memories[-100:] self.last_consolidation = time.time() self.logger.debug(f"记忆巩固完成,当前记忆数: {len(self.memories)}") except Exception as e: self.logger.error(f"记忆巩固失败: {str(e)}") def add_memory(self, memory: str): """添加记忆""" self.memories.append({ "content": memory, "timestamp": time.time() }) def get_status(self) -> Dict[str, Any]: return { "memory_count": len(self.memories), "last_consolidation": self.last_consolidation } return MemorySystem() def _create_affective_system(self): class AffectiveSystem: def __init__(self): self.mood = "neutral" self.energy = 100 self.logger = logging.getLogger('AffectiveSystem') def periodic_task(self): """情感成长""" try: # 根据时间恢复能量 self.energy = min(100, self.energy + 1) self.logger.debug(f"情感更新: 能量={self.energy}, 情绪={self.mood}") except Exception as e: self.logger.error(f"情感系统更新失败: {str(e)}") def update_mood(self, interaction: str): """根据交互更新情绪""" if "positive" in interaction: self.mood = "happy" elif "negative" in interaction: self.mood = "sad" def get_status(self) -> Dict[str, Any]: return { "mood": self.mood, "energy": self.energy } return AffectiveSystem() def _create_cognitive_architecture(self): class CognitiveArchitecture: def __init__(self): self.current_task: Optional[str] = None self.task_history: List[Dict[str, Any]] = [] self.logger = logging.getLogger('CognitiveArchitecture') def start_task(self, task: str): """开始新任务""" self.logger.info(f"开始任务: {task}") self.current_task = task self.task_history.append({ "task": task, "start_time": time.time(), "status": "in_progress" }) def complete_task(self, result: Any): """完成任务""" if self.current_task: for task in reversed(self.task_history): if task["task"] == self.current_task and task["status"] == "in_progress": task["status"] = "completed" task["result"] = result task["end_time"] = time.time() self.logger.info(f"完成任务: {task['task']}") break self.current_task = None def periodic_task(self): """认知架构周期性任务""" # 清理过时任务 now = time.time() self.task_history = [t for t in self.task_history if t['status'] == 'completed' or (now - t['start_time']) < 3600] # 保留1小时内进行中的任务 def get_status(self) -> Dict[str, Any]: return { "current_task": self.current_task, "task_count": len(self.task_history), "completed_tasks": sum(1 for t in self.task_history if t["status"] == "completed") } return CognitiveArchitecture() def _create_communication_system(self): class CommunicationSystem: def __init__(self): self.message_queue: List[Dict[str, Any]] = [] self.processed_count = 0 self.logger = logging.getLogger('CommunicationSystem') def process_input(self, user_input: str, user_id: str = "default") -> str: """处理用户输入""" try: # 模拟处理逻辑 response = f"已处理您的消息: '{user_input}' (用户: {user_id})" # 记录处理 self.processed_count += 1 self.logger.info(f"处理消息: '{user_input[:30]}...' (用户: {user_id})") return response except Exception as e: self.logger.error(f"消息处理失败: {str(e)}") return "处理消息时出错" def periodic_task(self): """通信系统周期性任务""" # 清理消息队列 if len(self.message_queue) > 100: self.message_queue = self.message_queue[-100:] self.logger.debug("清理消息队列") def check_heartbeat(self) -> bool: """心跳检查""" return True def get_status(self) -> Dict[str, Any]: return { "queue_size": len(self.message_queue), "processed_count": self.processed_count } return CommunicationSystem() def process_input(self, user_input: str, user_id: str = "default") -> Dict[str, Any]: """处理用户输入(通过通信系统)""" # 获取通信系统 comm_system = self.subsystem_registry.get_subsystem('通信系统') if not comm_system: self.logger.error("通信系统未初始化,使用回退处理") self.metrics.record_error('communication_system_inactive') return {"response": "系统正在维护中,请稍后再试"} # 检查熔断器状态 breaker = self.circuit_breakers.get('通信系统') if breaker and breaker.is_open(): self.logger.warning("通信系统熔断器已打开") self.metrics.record_error('communication_circuit_open') return {"response": "系统繁忙,请稍后再试"} try: # 使用熔断器包装调用 def process_wrapper(): return comm_system.process_input(user_input, user_id) if breaker: response = breaker.call(process_wrapper) else: response = process_wrapper() # 使用线程池异步处理 future = executor.submit(lambda: response) result = future.result(timeout=system_config.AGENT_RESPONSE_TIMEOUT) # 记录成功 self.metrics.record_success('process_input') return {"response": result} except TimeoutError: self.logger.warning("处理输入超时") self.metrics.record_timeout('process_input') if breaker: breaker.record_failure() return {"error": "处理超时,请重试"} except Exception as e: self.logger.error(f"处理输入失败: {str(e)}") self.metrics.record_error('process_input') if breaker: breaker.record_failure() return {"error": "处理失败,请稍后再试"} def _monitor_environment(self): """监控环境状态""" try: if self.environment and hasattr(self.environment, 'get_state'): # 使用真实环境管理器获取状态 env_state = self.environment.get_state() self.logger.info( f"🌡️ 环境监控: 温度={env_state.get('temperature', '未知')}℃, " f"湿度={env_state.get('humidity', '未知')}%, " f"光照={env_state.get('light_level', '未知')}%" ) # 记录到健康系统(如果可用) health_system = self.subsystem_registry.get_subsystem('健康系统') if health_system and hasattr(health_system, 'record_environment_status'): health_system.record_environment_status(env_state) else: # 使用内置监控 cpu_usage = psutil.cpu_percent() mem_usage = psutil.virtual_memory().percent disk_usage = psutil.disk_usage('/').percent self.logger.info( f"📊 系统监控: CPU={cpu_usage}%, " f"内存={mem_usage}%, " f"磁盘={disk_usage}%" ) # 记录到健康系统 health_system = self.subsystem_registry.get_subsystem('健康系统') if health_system and hasattr(health_system, 'record_environment_status'): health_system.record_environment_status({ "cpu_usage": cpu_usage, "mem_usage": mem_usage, "disk_usage": disk_usage }) except Exception as e: self.logger.error(f"环境监控失败: {str(e)}") self.metrics.record_error('environment_monitoring') def _check_subsystem_heartbeats(self): """检查子系统心跳""" for name, subsystem in self.subsystem_registry.subsystems.items(): if hasattr(subsystem, 'check_heartbeat'): try: if not subsystem.check_heartbeat(): self.logger.warning(f"⚠️ 子系统 {name} 心跳检测失败") self._handle_subsystem_error(name) else: self.logger.debug(f"✅ 子系统 {name} 心跳正常") except Exception as e: self.logger.error(f"子系统 {name} 心跳检查异常: {str(e)}") self._handle_subsystem_error(name) self.metrics.record_error(f'heartbeat_{name.lower()}') def _handle_subsystem_error(self, name: str): """处理子系统错误""" breaker = self.circuit_breakers.get(name) if breaker: breaker.record_failure() if breaker.is_open(): self.logger.critical(f"🚨 子系统 {name} 因连续错误被熔断!") self.metrics.record_event('circuit_breaker', name) def _recover_failed_subsystems(self): """尝试恢复失败的子系统""" for name, breaker in self.circuit_breakers.items(): if breaker.is_open() and breaker.should_try_recovery(): self.logger.info(f"🔄 尝试恢复子系统: {name}") try: # 尝试重新初始化子系统 self._reinitialize_subsystem(name) breaker.record_success() self.logger.info(f"✅ 子系统 {name} 恢复成功") self.metrics.record_event('subsystem_recovered', name) except Exception as e: self.logger.error(f"子系统 {name} 恢复失败: {str(e)}") breaker.record_failure() self.metrics.record_error(f'recovery_{name.lower()}') def _reinitialize_subsystem(self, name: str): """重新初始化子系统""" creators = { '健康系统': self._create_health_system, '模型管理器': self._create_model_manager, '记忆系统': self._create_memory_system, '情感系统': self._create_affective_system, '认知架构': self._create_cognitive_architecture, '通信系统': self._create_communication_system } if name in creators: # 先尝试关闭现有实例 old_instance = self.subsystem_registry.get_subsystem(name) if old_instance and hasattr(old_instance, 'shutdown'): try: old_instance.shutdown() self.logger.info(f"已关闭旧实例: {name}") except Exception as e: self.logger.warning(f"关闭旧实例失败: {str(e)}") # 创建新实例 instance = creators[name]() self.subsystem_registry.register_subsystem(name, instance) else: raise SubsystemFailure(f"未知子系统: {name}") def get_status(self) -> Dict[str, Any]: """获取智能体状态报告""" status_data = { "uptime": time.time() - self._initialization_time, "running": self._running, "metrics": self.metrics.get_metrics(), "subsystems": {} } # 添加子系统状态 for name, subsystem in self.subsystem_registry.subsystems.items(): if hasattr(subsystem, 'get_status'): status_data['subsystems'][name] = subsystem.get_status() # 添加熔断器状态 status_data['circuit_breakers'] = {} for name, breaker in self.circuit_breakers.items(): status_data['circuit_breakers'][name] = breaker.get_status() return status_data def shutdown(self): """关闭智能体""" self.logger.info("🛑 正在关闭智能体...") self._running = False # 停止线程池 executor.shutdown(wait=False) # 等待后台线程 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("后台线程未正常退出") # 关闭所有子系统 for name, subsystem in self.subsystem_registry.subsystems.items(): if hasattr(subsystem, 'shutdown'): try: subsystem.shutdown() self.logger.info(f"已关闭子系统: {name}") except Exception as e: self.logger.error(f"关闭子系统 {name} 失败: {str(e)}") self.logger.info("✅ 智能体已关闭")
最新发布
08-13
import tkinter as tk import ttkbootstrap as ttk from ttkbootstrap.constants import * import math import random import time class CornerMarkModule: def __init__(self, parent, width, height, module_id, label_text): self.parent = parent self.width = width self.height = height self.module_id = module_id self.label_text = label_text self.line_ids = [] self.animation_id = None self.data_flow_points = [] self.data_flow_animations = [] # 创建画布 self.canvas = tk.Canvas( parent, width=width, height=height, bg="#121212", highlightthickness=0, bd=0, relief="flat" ) self.canvas.pack(fill=tk.BOTH, expand=True) # 计算中心位置 self.square_size = 80 self.start_x = width // 2 - self.square_size // 2 self.start_y = height // 2 - self.square_size // 2 - 10 # 创建蓝色圆角矩形 self.square = self.create_round_rect( self.start_x, self.start_y, self.start_x + self.square_size, self.start_y + self.square_size, radius=15, fill="#325b74", outline="#5a9bc0", width=2 ) # 添加标签文本 self.label_id = self.canvas.create_text( width // 2, height // 2 - 10, text=label_text, fill="#e0e0e0", font=("Microsoft YaHei", 11, "bold"), width=self.square_size - 10, justify="center" ) # 添加模块编号标签 self.canvas.create_text( width // 2, height - 30, text=f"模块 {module_id}", fill="#7a7a7a", font=("Microsoft YaHei", 9) ) # 添加装饰线条 self.decor_line = self.canvas.create_line( width//2 - 40, height - 25, width//2 + 40, height - 25, fill="#3a6b8c", width=1, dash=(4, 2) ) # 初始参数 self.base_gap = 12 self.base_length = 30 self.create_all_lines() # 动画计数器 self.counter = 0 # 绑定悬停效果 self.canvas.bind("<Enter>", self.on_enter) self.canvas.bind("<Leave>", self.on_leave) def on_enter(self, event): """鼠标悬停效果""" self.canvas.itemconfig(self.square, fill="#5a9bc0") for line_id in self.line_ids: self.canvas.itemconfig(line_id, fill="#5a9bc0") self.canvas.itemconfig(self.decor_line, fill="#5a9bc0") def on_leave(self, event): """鼠标离开效果""" self.canvas.itemconfig(self.square, fill="#325b74") for line_id in self.line_ids: self.canvas.itemconfig(line_id, fill="#3a6b8c") self.canvas.itemconfig(self.decor_line, fill="#3a6b8c") def create_round_rect(self, x1, y1, x2, y2, radius=25, **kwargs): """创建圆角矩形""" points = [ x1 + radius, y1, # 左上角 x2 - radius, y1, x2, y1, x2, y1 + radius, # 右上角 x2, y2 - radius, x2, y2, x2 - radius, y2, # 右下角 x1 + radius, y2, x1, y2, x1, y2 - radius, # 左下角 x1, y1 + radius, x1, y1, x1 + radius, y1 ] return self.canvas.create_polygon(points, **kwargs, smooth=True) def create_all_lines(self): line_color = "#3a6b8c" # 左上角标记 self.line_ids.append(self.canvas.create_line( self.start_x - self.base_gap, self.start_y - self.base_gap, self.start_x - self.base_gap + self.base_length, self.start_y - self.base_gap, width=2, fill=line_color )) self.line_ids.append(self.canvas.create_line( self.start_x - self.base_gap, self.start_y - self.base_gap, self.start_x - self.base_gap, self.start_y - self.base_gap + self.base_length, width=2, fill=line_color )) # 右上角标记 self.line_ids.append(self.canvas.create_line( self.start_x + self.square_size + self.base_gap, self.start_y - self.base_gap, self.start_x + self.square_size + self.base_gap - self.base_length, self.start_y - self.base_gap, width=2, fill=line_color )) self.line_ids.append(self.canvas.create_line( self.start_x + self.square_size + self.base_gap, self.start_y - self.base_gap, self.start_x + self.square_size + self.base_gap, self.start_y - self.base_gap + self.base_length, width=2, fill=line_color )) # 左下角标记 self.line_ids.append(self.canvas.create_line( self.start_x - self.base_gap, self.start_y + self.square_size + self.base_gap, self.start_x - self.base_gap + self.base_length, self.start_y + self.square_size + self.base_gap, width=2, fill=line_color )) self.line_ids.append(self.canvas.create_line( self.start_x - self.base_gap, self.start_y + self.square_size + self.base_gap, self.start_x - self.base_gap, self.start_y + self.square_size + self.base_gap - self.base_length, width=2, fill=line_color )) # 右下角标记 self.line_ids.append(self.canvas.create_line( self.start_x + self.square_size + self.base_gap, self.start_y + self.square_size + self.base_gap, self.start_x + self.square_size + self.base_gap - self.base_length, self.start_y + self.square_size + self.base_gap, width=2, fill=line_color )) self.line_ids.append(self.canvas.create_line( self.start_x + self.square_size + self.base_gap, self.start_y + self.square_size + self.base_gap, self.start_x + self.square_size + self.base_gap, self.start_y + self.square_size + self.base_gap - self.base_length, width=2, fill=line_color )) def update_animation(self): """更新角标动画""" phase = self.counter * 0.08 self.counter += 1 phase_offset = self.module_id * 0.5 distance_factor = 0.5 * math.sin(phase + phase_offset) + 0.5 current_gap = 5 + distance_factor * 20 current_length = 25 + distance_factor * 15 self.update_lines(current_gap, current_length) self.animation_id = self.parent.after(50, self.update_animation) def pause_animation(self): """暂停动画""" if self.animation_id: self.parent.after_cancel(self.animation_id) self.animation_id = None def resume_animation(self): """恢复动画""" if not self.animation_id: self.update_animation() def update_lines(self, gap, length): """更新角标线条位置""" # 左上角 self.canvas.coords(self.line_ids[0], self.start_x - gap, self.start_y - gap, self.start_x - gap + length, self.start_y - gap) self.canvas.coords(self.line_ids[1], self.start_x - gap, self.start_y - gap, self.start_x - gap, self.start_y - gap + length) # 右上角 self.canvas.coords(self.line_ids[2], self.start_x + self.square_size + gap, self.start_y - gap, self.start_x + self.square_size + gap - length, self.start_y - gap) self.canvas.coords(self.line_ids[3], self.start_x + self.square_size + gap, self.start_y - gap, self.start_x + self.square_size + gap, self.start_y - gap + length) # 左下角 self.canvas.coords(self.line_ids[4], self.start_x - gap, self.start_y + self.square_size + gap, self.start_x - gap + length, self.start_y + self.square_size + gap) self.canvas.coords(self.line_ids[5], self.start_x - gap, self.start_y + self.square_size + gap, self.start_x - gap, self.start_y + self.square_size + gap - length) # 右下角 self.canvas.coords(self.line_ids[6], self.start_x + self.square_size + gap, self.start_y + self.square_size + gap, self.start_x + self.square_size + gap - length, self.start_y + self.square_size + gap) self.canvas.coords(self.line_ids[7], self.start_x + self.square_size + gap, self.start_y + self.square_size + gap, self.start_x + self.square_size + gap, self.start_y + self.square_size + gap - length) def get_center(self): """获取模块中心位置""" return (self.width // 2, self.height // 2 - 10) class DataFlowVisualizer: def __init__(self, parent, modules): self.parent = parent self.modules = modules self.connections = [] self.flow_lines = [] self.flow_points = [] self.animations = [] # 创建画布用于绘制连接线 self.canvas = tk.Canvas( parent, bg="#121212", highlightthickness=0, bd=0 ) self.canvas.place(relx=0, rely=0, relwidth=1, relheight=1) self.canvas.lower() # 定义模块连接关系 self.define_connections() def define_connections(self): """定义模块之间的连接关系""" # 干扰(1) -> 威胁分析(2) self.add_connection(1, 2, "#ff6b6b") # 威胁分析(2) -> 知识库(4) self.add_connection(2, 4, "#4ecdc4") # 威胁分析(2) -> 推理引擎(5) self.add_connection(2, 5, "#ffd166") # 推理引擎(5) -> 决策输出(6) self.add_connection(5, 6, "#1a936f") # 决策输出(6) -> 知识库(4) self.add_connection(6, 4, "#9b5de5") # 抗干扰中(3) -> 干扰(1) self.add_connection(3, 1, "#5a9bc0") def add_connection(self, from_id, to_id, color): """添加连接关系""" self.connections.append({ 'from': from_id, 'to': to_id, 'color': color }) def draw_connections(self): """绘制所有连接线""" for conn in self.connections: from_module = self.get_module_by_id(conn['from']) to_module = self.get_module_by_id(conn['to']) if from_module and to_module: # 获取模块在父容器中的位置 from_x = from_module.winfo_x() + from_module.get_center()[0] from_y = from_module.winfo_y() + from_module.get_center()[1] to_x = to_module.winfo_x() + to_module.get_center()[0] to_y = to_module.winfo_y() + to_module.get_center()[1] # 绘制连接线 line_id = self.canvas.create_line( from_x, from_y, to_x, to_y, fill=conn['color'], width=2, dash=(6, 4), arrow=tk.LAST, arrowshape=(12, 15, 5) ) self.flow_lines.append(line_id) # 创建流动数据点 self.create_flow_point(from_x, from_y, to_x, to_y, conn['color']) def get_module_by_id(self, module_id): """根据ID获取模块实例""" for module in self.modules: if module.module_id == module_id: return module return None def create_flow_point(self, from_x, from_y, to_x, to_y, color): """创建流动的数据点""" points = self.generate_path_points(from_x, from_y, to_x, to_y) point = self.canvas.create_oval(0, 0, 0, 0, fill=color, outline="") self.flow_points.append(point) self.animate_point(point, points) def generate_path_points(self, from_x, from_y, to_x, to_y, num_points=30): """生成路径点""" points = [] for i in range(num_points): t = i / (num_points - 1) x = from_x + (to_x - from_x) * t y = from_y + (to_y - from_y) * t points.append((x, y)) return points def animate_point(self, point, points, index=0): """动画点沿路径移动""" if index >= len(points): index = 0 x, y = points[index] r = 5 self.canvas.coords(point, x-r, y-r, x+r, y+r) speed = random.randint(1, 3) anim_id = self.parent.after(50, lambda: self.animate_point(point, points, index + speed)) self.animations.append(anim_id) def stop_animations(self): """停止所有动画""" for anim_id in self.animations: self.parent.after_cancel(anim_id) self.animations = [] class SystemStatusBar(ttk.Frame): """系统状态栏组件""" def __init__(self, parent): super().__init__(parent, padding=(10, 5)) self.pack(fill=tk.X, pady=(15, 5)) # 系统状态 self.status_label = ttk.Label( self, text="系统状态: 运行中", font=("Microsoft YaHei", 10), bootstyle="success" ) self.status_label.pack(side=tk.LEFT, padx=10) # 数据流状态 self.flow_label = ttk.Label( self, text="数据流: 正常", font=("Microsoft YaHei", 10), bootstyle="info" ) self.flow_label.pack(side=tk.LEFT, padx=10) # 威胁级别 self.threat_label = ttk.Label( self, text="威胁级别: 低", font=("Microsoft YaHei", 10), bootstyle="warning" ) self.threat_label.pack(side=tk.LEFT, padx=10) # 更新时间 self.time_label = ttk.Label( self, text="", font=("Microsoft YaHei", 10), bootstyle="secondary" ) self.time_label.pack(side=tk.RIGHT, padx=10) self.update_time() def update_time(self): """更新时间显示""" current_time = time.strftime("%Y-%m-%d %H:%M:%S") self.time_label.config(text=f"更新时间: {current_time}") self.after(1000, self.update_time) def create_dynamic_flow_visualization(): """创建动态数据流可视化系统""" # 创建主窗口 root = ttk.Window(title="动态数据流可视化系统", themename="superhero") root.configure(bg="#121212") # 设置窗口大小并居中 window_width = 1400 window_height = 800 screen_width = root.winfo_screenwidth() screen_height = root.winfo_screenheight() center_x = int(screen_width/2 - window_width/2) center_y = int(screen_height/2 - window_height/2) root.geometry(f"{window_width}x{window_height}+{center_x}+{center_y}") # 创建主容器框架 main_container = ttk.Frame(root, padding=(30, 20, 30, 10)) main_container.pack(fill=tk.BOTH, expand=True) # 创建标题栏 header_frame = ttk.Frame(main_container) header_frame.pack(fill=tk.X, pady=(0, 20)) title_label = ttk.Label( header_frame, text="动态数据流可视化系统", font=("Microsoft YaHei", 18, "bold"), bootstyle="inverse-primary" ) title_label.pack(side=tk.LEFT) subtitle = ttk.Label( header_frame, text="实时监控与响应系统", font=("Microsoft YaHei", 12), bootstyle="secondary" ) subtitle.pack(side=tk.LEFT, padx=(15, 0), pady=(5, 0)) # 添加控制按钮 control_frame = ttk.Frame(header_frame) control_frame.pack(side=tk.RIGHT) # 创建网格容器 grid_container = ttk.Frame(main_container) grid_container.pack(fill=tk.BOTH, expand=True) # 配置网格布局 grid_container.grid_rowconfigure(0, weight=1) grid_container.grid_rowconfigure(1, weight=1) grid_container.grid_rowconfigure(2, weight=1) grid_container.grid_columnconfigure(0, weight=1) grid_container.grid_columnconfigure(1, weight=1) grid_container.grid_columnconfigure(2, weight=1) grid_container.grid_columnconfigure(3, weight=1) # 定义模块标签文本 labels = ["干扰", "威胁分析", "抗干扰中", "知识库", "推理引擎", "决策输出"] # 创建模块容器 modules = [] # 抗干扰中 - 第1行第2列 cell0 = ttk.Frame(grid_container) cell0.grid(row=0, column=1, padx=15, pady=15, sticky="nsew") module0 = CornerMarkModule(cell0, 220, 280, 3, labels[2]) modules.append(module0) # 知识库 - 第3行第2列 cell1 = ttk.Frame(grid_container) cell1.grid(row=2, column=1, padx=15, pady=15, sticky="nsew") module1 = CornerMarkModule(cell1, 220, 280, 4, labels[3]) modules.append(module1) # 干扰 - 第2行第1列 cell2 = ttk.Frame(grid_container) cell2.grid(row=1, column=0, padx=15, pady=15, sticky="nsew") module2 = CornerMarkModule(cell2, 220, 280, 1, labels[0]) modules.append(module2) # 威胁分析 - 第2行第2列 cell3 = ttk.Frame(grid_container) cell3.grid(row=1, column=1, padx=15, pady=15, sticky="nsew") module3 = CornerMarkModule(cell3, 220, 280, 2, labels[1]) modules.append(module3) # 推理引擎 - 第2行第3列 cell4 = ttk.Frame(grid_container) cell4.grid(row=1, column=2, padx=15, pady=15, sticky="nsew") module4 = CornerMarkModule(cell4, 220, 280, 5, labels[4]) modules.append(module4) # 决策输出 - 第2行第4列 cell5 = ttk.Frame(grid_container) cell5.grid(row=1, column=3, padx=15, pady=15, sticky="nsew") module5 = CornerMarkModule(cell5, 220, 280, 6, labels[5]) modules.append(module5) # 启动所有模块的动画 for module in modules: module.update_animation() # 更新UI以确保位置信息正确 root.update() # 创建数据流可视化 flow_visualizer = DataFlowVisualizer(grid_container, modules) flow_visualizer.draw_connections() # 添加系统状态栏 status_bar = SystemStatusBar(main_container) # 添加控制按钮 exit_button = ttk.Button( control_frame, text="安全退出", command=lambda: safe_exit(root, modules, flow_visualizer), bootstyle="danger-outline", width=12 ) exit_button.pack(side=tk.RIGHT, padx=5) pause_button = ttk.Button( control_frame, text="暂停动画", command=lambda: toggle_animation(modules, pause_button), bootstyle="warning-outline", width=12 ) pause_button.pack(side=tk.RIGHT, padx=5) # 添加性能优化按钮 optimize_button = ttk.Button( control_frame, text="性能优化", command=lambda: optimize_performance(modules, flow_visualizer), bootstyle="info-outline", width=12 ) optimize_button.pack(side=tk.RIGHT, padx=5) root.mainloop() def safe_exit(root, modules, flow_visualizer): """安全退出程序""" for module in modules: module.pause_animation() flow_visualizer.stop_animations() root.after(500, root.destroy) def toggle_animation(modules, button): """切换动画状态""" if button.cget("text") == "暂停动画": for module in modules: module.pause_animation() button.configure(text="继续动画") else: for module in modules: module.resume_animation() button.configure(text="暂停动画") def optimize_performance(modules, flow_visualizer): """优化系统性能""" # 简化动画效果 for module in modules: module.pause_animation() module.resume_animation() # 减少数据流动画数量 flow_visualizer.stop_animations() for conn in flow_visualizer.connections: from_module = flow_visualizer.get_module_by_id(conn['from']) to_module = flow_visualizer.get_module_by_id(conn['to']) if from_module and to_module: from_x = from_module.winfo_x() + from_module.get_center()[0] from_y = from_module.winfo_y() + from_module.get_center()[1] to_x = to_module.winfo_x() + to_module.get_center()[0] to_y = to_module.winfo_y() + to_module.get_center()[1] flow_visualizer.create_flow_point(from_x, from_y, to_x, to_y, conn['color']) if __name__ == "__main__": create_dynamic_flow_visualization() 生成的代码运行时闪退并且出现了这些报错,帮我修改代码中的错误并写出完整代码Traceback (most recent call last): File "/home/ljc/Python/test/direction.py", line 561, in <module> create_dynamic_flow_visualization() File "/home/ljc/Python/test/direction.py", line 486, in create_dynamic_flow_visualization flow_visualizer = DataFlowVisualizer(grid_container, modules) File "/home/ljc/Python/test/direction.py", line 228, in __init__ self.canvas.lower() File "/usr/lib/python3.8/tkinter/__init__.py", line 2914, in tag_lower self.tk.call((self._w, 'lower') + args) _tkinter.TclError: wrong # args: should be ".!frame.!frame2.!canvas lower tagOrId ?belowThis?"
07-09
# agent/autonomous_agent.py from concurrent.futures import ThreadPoolExecutor from core.config import get_config from core.subsystem_registry import SubsystemRegistry from core.circuit_breaker import CircuitBreakerRegistry # 获取配置 system_config = get_config() class AutonomousAgent: def __init__(self): # 使用配置系统获取 MAX_WORKERS max_workers = system_config.get("MAX_WORKERS", max(1, os.cpu_count() * 2)) self.executor = ThreadPoolExecutor(max_workers=max_workers) # 获取子系统注册表 self.registry = SubsystemRegistry() # 初始化熔断器 self.circuit_breaker = CircuitBreakerRegistry.get_breaker( "autonomous_agent", failure_threshold=system_config.get("AGENT_FAILURE_THRESHOLD", 5), recovery_timeout=system_config.get("AGENT_RECOVERY_TIMEOUT", 60) ) def initialize(self): """初始化智能体""" # 确保所有子系统已初始化 if not self.registry.initialized: self.registry.initialize_all() # 获取关键子系统 self.hardware = self.registry.get("hardware_manager") self.scheduler = self.registry.get("life_scheduler") self.memory = self.registry.get("memory_manager") # 初始化完成 print("AutonomousAgent 初始化完成") def run(self): """运行智能体主循环""" try: while True: # 使用熔断器保护关键操作 self.circuit_breaker.call(self._run_cycle) except KeyboardInterrupt: print("智能体运行终止") except Exception as e: print(f"智能体运行错误: {str(e)}") # 错误处理逻辑... def _run_cycle(self): """执行单个运行周期""" # 获取下一个任务 task = self.scheduler.get_next_task() # 在线程池中执行任务 future = self.executor.submit(self.hardware.execute, task) future.add_done_callback(self._task_completed) def _task_completed(self, future): """任务完成回调""" try: result = future.result() # 处理任务结果... except Exception as e: print(f"任务执行失败: {str(e)}") # 错误处理逻辑... # 子系统注册 @SubsystemRegistry.subsystem("autonomous_agent", dependencies=["hardware_manager", "life_scheduler"]) class RegisteredAutonomousAgent(AutonomousAgent): """注册为子系统的智能体""" import os import sys import time import json import logging import traceback import threading import platform import psutil from pathlib import Path from typing import Any, Dict, Optional, Callable from concurrent.futures import ThreadPoolExecutor, Future # 确保项目根目录在 sys.path 中 BASE_DIR = Path(__file__).resolve().parent.parent.parent # 指向 E:\AI_System if str(BASE_DIR) not in sys.path: sys.path.insert(0, str(BASE_DIR)) # 导入核心模块 from core.config import system_config from core.exceptions import DependencyError, SubsystemFailure, ConfigurationError from core.metrics import MetricsCollector from core.circuit_breaker import CircuitBreaker from core.subsystem_registry import SubsystemRegistry # 全局线程池 executor = ThreadPoolExecutor(max_workers=system_config.MAX_WORKERS) 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.metrics = MetricsCollector() # 熔断器管理器 self.circuit_breakers = {} # 子系统注册表 self.subsystem_registry = SubsystemRegistry() # 环境管理器(外部设置) self.environment = None # 确保必要目录存在 self._ensure_directories_exist() try: # 初始化步骤 self._record_step("验证配置") self._validate_configuration() self._record_step("加载环境变量") self._load_environment() 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)}") 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 _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' log_file.parent.mkdir(parents=True, exist_ok=True) file_handler = logging.FileHandler(log_file, encoding='utf-8') file_handler.setLevel(system_config.LOG_LEVEL) # 创建格式化器 formatter = logging.Formatter( '%(asctime)s [%(levelname)s] %(name)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 _ensure_directories_exist(self): """确保所需目录存在""" required_dirs = [ system_config.LOG_DIR, system_config.CONFIG_DIR, system_config.MODEL_CACHE_DIR ] for dir_path in required_dirs: try: if not isinstance(dir_path, Path): dir_path = Path(dir_path) if not dir_path.exists(): dir_path.mkdir(parents=True, exist_ok=True) self.logger.info(f"创建目录: {dir_path}") except Exception as e: self.logger.error(f"创建目录失败 {dir_path}: {str(e)}") def _validate_configuration(self): """验证关键配置项""" required_configs = [ 'LOG_DIR', 'CONFIG_DIR', 'MODEL_CACHE_DIR', 'MAX_WORKERS', 'AGENT_RESPONSE_TIMEOUT' ] missing = [] for config_key in required_configs: if not hasattr(system_config, config_key): missing.append(config_key) if missing: raise ConfigurationError(f"缺失关键配置项: {', '.join(missing)}") # 检查配置值有效性 if system_config.MAX_WORKERS <= 0: raise ConfigurationError(f"无效的MAX_WORKERS值: {system_config.MAX_WORKERS}") def _record_step(self, step_name: str): """记录初始化步骤""" self.initialization_steps.append(step_name) self.logger.info(f"⏳ 步骤 {len(self.initialization_steps)}: {step_name}") def _load_environment(self): """加载环境变量""" env_path = system_config.CONFIG_DIR / ".env" if not env_path.exists(): self.logger.warning(f"⚠️ 环境变量文件不存在: {env_path}") return try: from dotenv import load_dotenv load_dotenv(env_path) self.logger.info(f"✅ 已加载环境变量文件: {env_path}") except ImportError: self.logger.warning("dotenv包未安装,跳过环境变量加载。请安装: pip install python-dotenv") except Exception as e: self.logger.error(f"加载环境变量失败: {str(e)}") def set_environment(self, env_manager): """设置环境管理器引用""" self.environment = env_manager self.logger.info("✅ 已连接环境管理器") # 注册环境监控任务 if self.environment: self.subsystem_registry.register_task( "环境监控", self._monitor_environment, interval=system_config.get('ENVIRONMENT_MONITOR_INTERVAL', 5.0) ) def start(self): """启动智能体后台任务""" if not self._running: self._start_background_tasks() self.logger.info("🏁 智能体后台任务已启动") else: self.logger.warning("智能体已在运行中") def _start_background_tasks(self): """启动后台任务线程""" if self._running: 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): """后台任务循环""" self.logger.info("🔄 后台任务循环启动") while self._running: try: start_time = time.time() # 执行注册的周期性任务 self.subsystem_registry.run_periodic_tasks() # 动态调整睡眠时间 task_time = time.time() - start_time sleep_time = max(0.1, system_config.AGENT_TASK_INTERVAL - task_time) time.sleep(sleep_time) except Exception as e: self.logger.error(f"后台任务错误: {str(e)}") self.metrics.record_error('background_task') time.sleep(30) # 错误后等待更长时间 def verify_environment(self): """验证运行环境是否满足要求""" # 检查必需模块 required_modules = [ 'os', 'sys', 'logging', 'flask', 'werkzeug', 'numpy', 'transformers', 'torch', 'psutil' ] # 检查必需包 required_packages = [ ('dotenv', 'python-dotenv'), ('flask_socketio', 'flask-socketio') ] missing_modules = [] for mod in required_modules: try: __import__(mod) except ImportError: missing_modules.append(mod) missing_packages = [] for import_name, pkg_name in required_packages: try: __import__(import_name) except ImportError: missing_packages.append(pkg_name) # 处理缺失项 errors = [] if missing_modules: errors.append(f"缺失Python模块: {', '.join(missing_modules)}") if missing_packages: errors.append(f"缺失Python包: {', '.join(missing_packages)}") if errors: error_msg = "环境验证失败:\n" + "\n".join(errors) self.logger.error(error_msg) raise DependencyError(error_msg) self.logger.info("✅ 环境验证通过") def _log_environment_status(self): """记录环境状态信息""" try: # 获取系统信息 sys_info = { "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), } self.logger.info( f"📊 系统状态: OS={sys_info['os']} {sys_info['os_version']}, " f"CPU={sys_info['cpu']} ({sys_info['cpu_cores']}核), " f"内存={sys_info['memory_used']}/{sys_info['memory_total']}GB, " f"磁盘={sys_info['disk_used']}/{sys_info['disk_total']}GB" ) except Exception as e: self.logger.error(f"环境状态获取失败: {str(e)}") self.metrics.record_error('environment_status') def _initialize_core_components(self): """初始化不依赖其他组件的核心组件""" self._log_environment_status() # 初始化熔断器 self._initialize_circuit_breakers() # 注册核心任务 self.subsystem_registry.register_task( "子系统心跳检查", self._check_subsystem_heartbeats, interval=system_config.get('HEARTBEAT_INTERVAL', 60.0) ) self.subsystem_registry.register_task( "子系统恢复", self._recover_failed_subsystems, interval=system_config.get('RECOVERY_INTERVAL', 300.0) ) def _initialize_circuit_breakers(self): """为所有子系统初始化熔断器""" subsystems = [ '健康系统', '模型管理器', '记忆系统', '情感系统', '认知架构', '通信系统' ] for subsystem in subsystems: breaker = CircuitBreaker( failure_threshold=system_config.get('CIRCUIT_BREAKER_THRESHOLD', 5), recovery_timeout=system_config.get('CIRCUIT_BREAKER_TIMEOUT', 300) ) self.circuit_breakers[subsystem] = breaker self.logger.info(f"⚡ 为 {subsystem} 初始化熔断器") def _initialize_subsystems(self): """初始化所有子系统""" # 定义子系统初始化顺序 subsystems = [ ('健康系统', self._create_health_system, {}), ('模型管理器', self._create_model_manager, {}), ('记忆系统', self._create_memory_system, {}), ('情感系统', self._create_affective_system, {}), ('认知架构', self._create_cognitive_architecture, {}), ('通信系统', self._create_communication_system, {}) ] # 注册子系统依赖关系 dependencies = { '通信系统': ['认知架构'], '情感系统': ['健康系统', '记忆系统'], '认知架构': ['记忆系统'] } for name, creator_func, kwargs in subsystems: try: # 检查依赖是否满足 if name in dependencies: missing_deps = [dep for dep in dependencies[name] if not self.subsystem_registry.get_subsystem(dep)] if missing_deps: self.logger.warning(f"⚠️ 子系统 {name} 缺少依赖: {', '.join(missing_deps)}") # 尝试自动初始化缺失依赖 for dep in missing_deps: self._initialize_dependency(dep) # 创建实例 instance = creator_func(**kwargs) self.subsystem_registry.register_subsystem(name, instance) # 注册子系统任务 if hasattr(instance, 'periodic_task'): self.subsystem_registry.register_task( f"{name}更新", instance.periodic_task, interval=system_config.get(f'{name}_INTERVAL', 60.0) ) self.logger.info(f"✅ {name}初始化完成") except Exception as e: self.logger.error(f"❌ {name}初始化失败: {str(e)}") self.metrics.record_error(f'subsystem_init_{name.lower()}') def _initialize_dependency(self, subsystem_name: str): """初始化依赖子系统""" creators = { '健康系统': self._create_health_system, '模型管理器': self._create_model_manager, '记忆系统': self._create_memory_system, '情感系统': self._create_affective_system, '认知架构': self._create_cognitive_architecture, '通信系统': self._create_communication_system } if subsystem_name in creators: try: instance = creators[subsystem_name]() self.subsystem_registry.register_subsystem(subsystem_name, instance) self.logger.info(f"✅ 依赖子系统 {subsystem_name} 初始化完成") except Exception as e: self.logger.error(f"❌ 依赖子系统 {subsystem_name} 初始化失败: {str(e)}") raise # 各子系统实现(增强功能) def _create_health_system(self): class HealthSystem: def __init__(self): self.status = "healthy" self.metrics = {} self.logger = logging.getLogger('HealthSystem') def periodic_task(self): """更新健康状态""" try: # 获取系统状态 cpu_usage = psutil.cpu_percent() mem_usage = psutil.virtual_memory().percent disk_usage = psutil.disk_usage('/').percent # 更新状态 self.status = "healthy" if cpu_usage < 90 and mem_usage < 90 else "warning" self.metrics = { "cpu_usage": cpu_usage, "mem_usage": mem_usage, "disk_usage": disk_usage, "timestamp": time.time() } self.logger.debug(f"健康状态更新: {self.status}") except Exception as e: self.logger.error(f"健康系统更新失败: {str(e)}") def record_environment_status(self, env_data): """记录环境状态""" self.metrics['environment'] = env_data def get_status(self): return { "status": self.status, "metrics": self.metrics } return HealthSystem() def _create_model_manager(self): class ModelManager: def __init__(self): self.loaded_models = {} self.logger = logging.getLogger('ModelManager') def load_model(self, model_name): """加载模型""" if model_name not in self.loaded_models: # 模拟模型加载 self.logger.info(f"加载模型: {model_name}") self.loaded_models[model_name] = { "status": "loaded", "load_time": time.time() } return True return False def periodic_task(self): """模型管理器周期性任务""" # 检查模型状态 for model_name, model_info in list(self.loaded_models.items()): # 模拟模型验证 if time.time() - model_info['load_time'] > 86400: # 24小时 self.logger.info(f"重新加载模型: {model_name}") model_info['load_time'] = time.time() def get_status(self): return { "loaded_models": list(self.loaded_models.keys()), "count": len(self.loaded_models) } return ModelManager() def _create_memory_system(self): class MemorySystem: def __极忆__init__(self): self.memories = [] self.last_consolidation = time.time() self.logger = logging.getLogger('MemorySystem') def periodic_task(self): """巩固记忆""" try: # 保留最近100条记忆 if len(self.memories) > 100: self.memories = self.memories[-100:] self.last_consolidation = time.time() self.logger.debug(f"记忆巩固完成,当前记忆数: {极忆len(self.memories)}") except Exception as e: self.logger.error(f"记忆巩固失败: {str(e)}") def add_memory(self, memory): """添加记忆""" self.memories.append({ "content": memory, "timestamp": time.time() }) def get_status(self): return { "memory_count": len(self.memories), "last_consolidation": self.last_consolidation } return MemorySystem() def _create_affective_system(self): class AffectiveSystem: def __init__(self): self.mood = "neutral" self.energy = 100 self.logger = logging.getLogger('AffectiveSystem') def periodic_task(self): """情感成长""" try: # 根据时间恢复能量 self.energy = min(100, self.energy + 1) self.logger.debug(f"情感更新: 能量={self.energy}, 情绪={self.mood}") except Exception as e: self.logger.error(f"情感系统更新失败: {str(e)}") def update_mood(self, interaction): """根据交互更新情绪""" if "positive" in interaction: self.mood = "happy" elif "negative" in interaction: self.mood = "sad" def get_status(self): return { "mood": self.mood, "energy": self.energy } return AffectiveSystem() def _create_cognitive_architecture(self): class CognitiveArchitecture: def __init__(self): self.current_task = None self.task_history = [] self.logger = logging.getLogger('CognitiveArchitecture') def start_task(self, task): """开始新任务""" self.logger.info(f"开始任务: {task}") self.current_task = task self.task_history.append({ "task": task, "start_time": time.time(), "status": "in_progress" }) def complete_task(self, result): """完成任务""" if self.current_task: for task in reversed(self.task_history): if task["task"] == self.current_task and task["status"] == "in_progress": task["status"] = "completed" task["result"] = result task["end_time"] = time.time() self.log极忆.info(f"完成任务: {task['task']}") break self.current_task = None def periodic_task(self): """认知架构周期性任务""" # 清理过时任务 now = time.time() self.task_history = [t for t in self.task_history if t['status'] == 'completed' or (now - t['start_time']) < 3600] # 保留1小时内进行中的任务 def get_status(self): return { "current_task": self.current_task, "task_count": len(self.task_history), "completed_tasks": sum(1 for t in self.task_history if t["status"] == "completed") } return CognitiveArchitecture() def _create_communication_system(self): class CommunicationSystem: def __init__(self): self.message_queue = [] self.processed_count = 0 self.logger = logging.getLogger('CommunicationSystem') def process_input(self, user_input: str, user_id: str = "default") -> str: """处理用户输入""" try: # 模拟处理逻辑 response = f"已处理您的消息: '{user_input}' (用户: {user_id})" # 记录处理 self.processed_count += 1 self.logger.info(f"处理消息: '{user_input[:30]}...' (用户: {user_id})") return response except Exception as e: self.logger.error(f"消息处理失败: {str(e)}") return "处理消息时出错" def periodic_task(self): """通信系统周期性任务""" # 清理消息队列 if len(self.message_queue) > 100: self.message_queue = self.message_queue[-100:] self.logger.debug("清理消息队列") def check_heartbeat(self): """心跳检查""" return True def get_status(self): return { "queue_size": len(self.message_queue), "processed_count": self.processed_count } return CommunicationSystem() def process_input(self, user_input: str, user_id: str = "default") -> Dict[str, Any]: """处理用户输入(通过通信系统)""" # 获取通信系统 comm_system = self.subsystem_registry.get_subsystem('通信系统') if not comm_system: self.logger.error("通信系统未初始化,使用回退处理") self.metrics.record_error('communication_system_inactive') return {"response": "系统正在维护中,请稍后再试"} # 检查熔断器状态 breaker = self.circuit_breakers.get('通信系统') if breaker and breaker.is_open(): self.logger.warning("通信系统熔断器已打开") self.metrics.record_error('communication_circuit_open') return {"response": "系统繁忙,请稍后再试"} try: # 使用熔断器包装调用 def process_wrapper(): return comm_system.process_input(user_input, user_id) if breaker: response = breaker.call(process_wrapper) else: response = process_wrapper() # 使用线程池异步处理 future = executor.submit(lambda: response) result = future.result(timeout=system_config.AGENT_RESPONSE_TIMEOUT) # 记录成功 self.metrics.record_success('process_input') return {"response": result} except TimeoutError: self.logger.warning("处理输入超时") self.metrics.record_timeout('process_input') if breaker: breaker.record_failure() return {"error": "处理超时,请重试"} except Exception as e: self.logger.error(f"处理输入失败: {str(e)}") self.metrics.record_error('process_input') if breaker: breaker.record极忆failure() return {"error": "处理失败,请稍后再试"} def _monitor_environment(self): """监控环境状态""" try: if self.environment and hasattr(self.environment, 'get_state'): # 使用真实环境管理器获取状态 env_state = self.environment.get_state() self.logger.info( f"🌡️ 环境监控: 温度={env_state.get('temperature', '未知')}℃, " f"湿度={env_state.get('humidity', '未知')}%, " f"光照={env_state.get('light_level', '未知')}%" ) # 记录到健康系统(如果可用) health_system = self.subsystem_registry.get_subsystem('健康系统') if health_system and hasattr(health_system, 'record_environment_status'): health_system.record_environment_status(env_state) else: # 使用内置监控 cpu_usage = psutil.cpu_percent() mem_usage = psutil.virtual_memory().percent disk_usage = psutil.disk_usage('/').percent self.logger.info( f"📊 系统监控: CPU={cpu_usage}%, " f"内存={mem_usage}%, " f"磁盘={disk_usage}%" ) # 记录到健康系统 health_system = self.subsystem_registry.get_subsystem('健康系统') if health_system and hasattr(health_system, 'record_environment_status'): health_system.record_environment_status({ "cpu_usage": cpu_usage, "mem_usage": mem_usage, "disk_usage": disk_usage }) except Exception as e: self.logger.error(f"环境监控失败: {str(e)}") self.metrics.record_error('environment_monitoring') def _check_subsystem_heartbeats(self): """检查子系统心跳""" for name, subsystem in self.subsystem_registry.subsystems.items(): if hasattr(subsystem, 'check_heartbeat'): try: if not subsystem.check_heartbeat(): self.logger.warning(f"⚠️ 子系统 {name} 心跳检测失败") self._handle_subsystem_error(name) else: self.logger.debug(f"✅ 子系统 {name} 心跳正常") except Exception as e: self.logger.error(f"子系统 {name} 心跳检查异常: {str(e)}") self._handle_subsystem_error(name) self.metrics.record_error(f'heartbeat_{name.lower()}') def _handle_subsystem_error(self, name: str): """处理子系统错误""" breaker = self.circuit_breakers.get(name) if breaker: breaker.record_failure() if breaker.is_open(): self.logger.critical(f"🚨 子系统 {name} 因连续错误被熔断!") self.metrics.record_event('circuit_breaker', name) def _recover_failed_subsystems(self): """尝试恢复失败的子系统""" for name, breaker in self.circuit_breakers.items(): if breaker.is_open() and breaker.should_try_recovery(): self.logger.info(f"🔄 尝试恢复子系统: {name}") try: # 尝试重新初始化子系统 self._reinitialize_subsystem(name) breaker.record_success() self.logger.info(f"✅ 子系统 {name} 恢复成功") self.metrics.record_event('subsystem_recovered', name) except Exception as e: self.logger.error(f"子系统 {name} 恢复失败: {str(e)}") breaker.record_failure() self.metrics.record_error(f'recovery_{name.lower()}') def _reinitialize_subsystem(self, name: str): """重新初始化子系统""" creators = { '健康系统': self._create_health_system, '模型管理器': self._create_model_manager, '记忆系统': self._create_memory_system, '情感系统': self._create_affective_system, '认知架构': self._create_cognitive_architecture, '通信系统': self._create_communication_system } if name in creators: instance = creators[name]() self.subsystem_registry.register_subsystem(name, instance) else: raise SubsystemFailure(f"未知子系统: {name}") def get_status(self) -> Dict[str, Any]: """获取智能体状态报告""" status_data = { "uptime": time.time() - self._initialization_time, "running": self._running, "metrics": self.metrics.get_metrics(), "subsystems": {} } # 添加子系统状态 for name, subsystem in self.subsystem_registry.subsystems.items(): if hasattr(subsystem, 'get_status'): status_data['subsystems'][name] = subsystem.get_status() # 添加熔断器状态 status_data['circuit_breakers'] = {} for name, breaker in self.circuit_breakers.items(): status_data['circuit_breakers'][name] = breaker.get_status() return status_data def shutdown(self): """关闭智能体""" self.logger.info("🛑 正在关闭智能体...") self._running = False # 停止线程池 executor.shutdown(wait=False) # 等待后台线程 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
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

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

余额充值