下次请把要修改的文件的位置，名称告诉我 然后我把文件发给你，你改好了（要完整的），再还给我,这是E:\AI_System\agent里的environment_interface.py：“import os
import psutil
import platform
import json
import sqlite3
import sys
import subprocess
import requests
import logging
from datetime import datetime
from pathlib import Path
logger = logging.getLogger('EnvironmentInterface')
class EnvironmentInterface:
def __init__(self, base_dir: str):
# 配置日志
self.logger = logging.getLogger('EnvironmentInterface')
self.logger.setLevel(logging.INFO)
console_handler = logging.StreamHandler()
console_handler.setFormatter(logging.Formatter('%(asctime)s - %(name)s - %(levelname)s - %(message)s'))
self.logger.addHandler(console_handler)
self.logger.propagate = False
# 工作区路径设置（使用绝对路径）
self.workspace_root = self._resolve_workspace_path(base_dir)
# 解析路径并确保目录存在
self.models_dir = self._resolve_and_create_dir(os.path.join(self.workspace_root, "01_模型存储"))
self.cache_dir = self._resolve_and_create_dir(os.path.join(self.workspace_root, "01_模型存储", "下载缓存"))
self.system_dir = self._resolve_and_create_dir(os.path.join(self.workspace_root, "02_核心代码"))
self.temp_dir = self._resolve_and_create_dir(os.path.join(self.workspace_root, "04_环境工具", "临时补丁"))
self.python_dir = self._resolve_and_create_dir(os.path.join(self.workspace_root, "04_环境工具", "Python环境"))
# 环境配置
os.environ['PATH'] = f"{self.python_dir};{self.python_dir}\\Scripts;{os.environ['PATH']}"
os.environ['HF_HOME'] = self.cache_dir
# 安全策略
self.authorized_actions = {
"file_access": True,
"web_search": True,
"command_exec": True,
"software_install": False,
"hardware_control": False
}
self.action_log = []
# 初始化数据库（使用绝对路径）
self.environment_db = os.path.join(self.system_dir, 'environment.db')
self._init_db()
self.logger.info("✅ 环境接口初始化完成")
def _resolve_workspace_path(self, base_dir: str) -> str:
"""解析工作区路径为绝对路径"""
try:
# 使用Path对象确保跨平台兼容性
base_path = Path(base_dir).resolve()
workspace_path = base_path / "AI_Workspace"
if not workspace_path.exists():
workspace_path.mkdir(parents=True, exist_ok=True)
self.logger.info(f"创建工作区目录: {workspace_path}")
return str(workspace_path)
except Exception as e:
self.logger.error(f"工作区路径解析失败: {str(e)}")
# 回退到默认路径
fallback_path = os.path.join(os.path.expanduser("~"), "AI_Workspace")
os.makedirs(fallback_path, exist_ok=True)
return fallback_path
def _resolve_and_create_dir(self, path):
"""解析路径并确保目录存在"""
try:
# 转换为绝对路径
abs_path = os.path.abspath(path)
# 创建目录（如果不存在）
if not os.path.exists(abs_path):
os.makedirs(abs_path, exist_ok=True)
self.logger.info(f"创建目录: {abs_path}")
return abs_path
except Exception as e:
self.logger.error(f"目录解析失败: {path} - {str(e)}")
# 创建临时目录作为回退
temp_path = os.path.join(self.workspace_root, "temp")
os.makedirs(temp_path, exist_ok=True)
return temp_path
def _init_db(self):
"""初始化环境数据库"""
try:
conn = sqlite3.connect(self.environment_db)
c = conn.cursor()
# 系统信息表
c.execute('''CREATE TABLE IF NOT EXISTS system_info (
id INTEGER PRIMARY KEY,
timestamp DATETIME DEFAULT CURRENT_TIMESTAMP,
os TEXT,
cpu TEXT,
memory REAL,
disk_usage REAL
)''')
# 文件探索历史表
c.execute('''CREATE TABLE IF NOT EXISTS file_exploration (
id INTEGER PRIMARY KEY,
path TEXT UNIQUE,
last_visited DATETIME,
visit_count INTEGER DEFAULT 0
)''')
# 资源管理表
c.execute('''CREATE TABLE IF NOT EXISTS resources (
id INTEGER PRIMARY KEY,
name TEXT,
type TEXT CHECK(type IN ('skin', 'furniture', 'tool')),
path TEXT,
is_active BOOLEAN DEFAULT 0
)''')
conn.commit()
conn.close()
self.logger.info(f"✅ 数据库初始化完成: {self.environment_db}")
except Exception as e:
self.logger.error(f"❌ 数据库初始化失败: {str(e)}")
# 系统监控功能
def get_system_info(self):
"""获取并记录系统信息"""
try:
# 获取内存使用情况
mem = psutil.virtual_memory()
mem_used = round(mem.used / (1024 ** 3), 1)
mem_total = round(mem.total / (1024 ** 3), 1)
# 获取磁盘使用情况
disk_usage = psutil.disk_usage('/').percent
info = {
"os": f"{platform.system()} {platform.release()}",
"cpu": f"{platform.processor()} ({psutil.cpu_count(logical=False)} cores)",
"memory": f"{mem_used}GB/{mem_total}GB",
"disk_usage": f"{disk_usage}%"
}
# 保存到数据库
conn = sqlite3.connect(self.environment_db)
c = conn.cursor()
c.execute('''INSERT INTO system_info
(os, cpu, memory, disk_usage)
VALUES (?, ?, ?, ?)''',
(info['os'], info['cpu'], mem_used, disk_usage))
conn.commit()
conn.close()
self.log_action("system_monitor", "采集系统信息")
return info
except Exception as e:
self.logger.error(f"❌ 获取系统信息失败: {str(e)}")
return {
"os": f"Error: {str(e)}",
"cpu": "0%",
"memory": "0GB/0GB",
"disk_usage": "0%"
}
# 文件探索功能
def explore_directory(self, path=None):
"""探索目录内容"""
try:
target_path = path or self.workspace_root
target_path = os.path.abspath(target_path)
# 安全路径检查
if not target_path.startswith(os.path.abspath(self.workspace_root)):
return {"error": "访问路径超出工作区范围"}
if not os.path.exists(target_path):
return {"error": "路径不存在"}
# 记录探索历史
self._record_exploration(target_path)
contents = []
for item in os.listdir(target_path):
full_path = os.path.join(target_path, item)
try:
is_dir = os.path.isdir(full_path)
size = os.path.getsize(full_path) if not is_dir else 0
modified_time = os.path.getmtime(full_path)
contents.append({
"name": item,
"type": "directory" if is_dir else "file",
"path": full_path,
"size": f"{size / 1024:.1f}KB" if size < 1024 ** 2 else f"{size / (1024 ** 2):.1f}MB",
"modified": datetime.fromtimestamp(modified_time).strftime("%Y-%m-%d %H:%M")
})
except PermissionError:
contents.append({
"name": item,
"type": "unknown",
"error": "权限不足"
})
except Exception as e:
contents.append({
"name": item,
"type": "unknown",
"error": str(e)
})
self.log_action("file_explore", f"探索路径: {target_path}")
return {
"current_path": target_path,
"contents": sorted(contents, key=lambda x: (x['type'] == 'directory', x['name']), reverse=True)
}
except Exception as e:
self.logger.error(f"❌ 探索目录失败: {str(e)}")
return {"error": str(e)}
def _record_exploration(self, path):
"""记录探索历史到数据库"""
try:
conn = sqlite3.connect(self.environment_db)
c = conn.cursor()
c.execute("SELECT id FROM file_exploration WHERE path = ?", (path,))
if c.fetchone():
c.execute('''UPDATE file_exploration
SET last_visited = CURRENT_TIMESTAMP,
visit_count = visit_count + 1
WHERE path = ?''', (path,))
else:
c.execute('''INSERT INTO file_exploration
(path, last_visited, visit_count)
VALUES (?, CURRENT_TIMESTAMP, 1)''', (path,))
conn.commit()
except Exception as e:
self.logger.error(f"❌ 记录探索历史失败: {str(e)}")
finally:
conn.close()
# 资源管理功能
def get_resource(self, resource_type):
"""获取特定类型资源"""
try:
conn = sqlite3.connect(self.environment_db)
c = conn.cursor()
c.execute('''SELECT name, path, is_active
FROM resources
WHERE type = ?''', (resource_type,))
resources = [
{"name": item[0], "path": item[1], "is_active": bool(item[2])}
for item in c.fetchall()
]
return resources
except Exception as e:
self.logger.error(f"❌ 获取资源失败: {str(e)}")
return []
finally:
conn.close()
def activate_resource(self, resource_name):
"""激活特定资源"""
try:
conn = sqlite3.connect(self.environment_db)
c = conn.cursor()
c.execute('''UPDATE resources
SET is_active = 0
WHERE type = (SELECT type FROM resources WHERE name = ?)''',
(resource_name,))
c.execute('''UPDATE resources
SET is_active = 1
WHERE name = ?''', (resource_name,))
conn.commit()
self.log_action("resource_activate", f"激活资源: {resource_name}")
return True
except Exception as e:
self.logger.error(f"❌ 激活资源失败: {str(e)}")
return False
finally:
conn.close()
# 工作区管理功能
def get_workspace_info(self):
"""获取工作区信息"""
return {
"workspace": self.workspace_root,
"models": self.models_dir,
"system": self.system_dir,
"cache": self.cache_dir,
"temp": self.temp_dir,
"python": self.python_dir
}
# 辅助功能
def _is_authorized(self, action):
"""检查操作授权状态"""
return self.authorized_actions.get(action, False)
def log_action(self, action, details):
"""记录环境操作日志"""
log_entry = {
"timestamp": datetime.now().isoformat(),
"action": action,
"details": details
}
self.action_log.append(log_entry)
# 保存到文件
log_file = os.path.join(self.workspace_root, "environment_actions.log")
try:
with open(log_file, 'a', encoding='utf-8') as f:
f.write(json.dumps(log_entry, ensure_ascii=False) + "\n")
except Exception as e:
self.logger.error(f"❌ 记录日志失败: {str(e)}")
# 同时记录到logger
self.logger.info(f"{action}: {details}")
return True
# 使用示例
if __name__ == "__main__":
# 配置日志
logging.basicConfig(level=logging.INFO)
# 创建环境接口实例
env = EnvironmentInterface(os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
# 获取工作区信息
print("工作区信息:", json.dumps(env.get_workspace_info(), indent=2, ensure_ascii=False))
# 获取系统信息
print("系统信息:", json.dumps(env.get_system_info(), indent=2, ensure_ascii=False))
# 探索目录
print("工作区内容:", json.dumps(env.explore_directory(), indent=2, ensure_ascii=False))
”E:\AI_System\agent里的autonomous_agent.py：“import os
import time
import logging
from dotenv import load_dotenv
# 使用绝对导入
from core.config import system_config
from core.environment import DefaultEnvironment, AIHome, ActionExecutor
from .environment_interface import EnvironmentInterface # 导入修复后的环境接口
class AutonomousAgent:
def __init__(self):
self.logger = self._setup_logger()
self.logger.info("🔁 初始化自主智能体核心模块...")
try:
# 加载环境变量
load_dotenv()
# 初始化环境感知系统
self._initialize_environment_systems()
# 初始化各子系统
self._initialize_subsystems()
self.logger.info("✅ 自主智能体初始化完成")
except Exception as e:
self.logger.error(f"❌ 智能体初始化失败: {str(e)}")
raise
def _setup_logger(self):
"""配置日志记录器"""
logger = logging.getLogger('AutonomousAgent')
logger.setLevel(system_config.LOG_LEVEL)
# 创建控制台处理器
console_handler = logging.StreamHandler()
console_handler.setLevel(system_config.LOG_LEVEL)
# 创建格式化器
formatter = logging.Formatter('%(asctime)s - %(name)s - %(levelname)s - %(message)s')
console_handler.setFormatter(formatter)
# 添加处理器
logger.addHandler(console_handler)
logger.propagate = False
return logger
def _initialize_environment_systems(self):
"""初始化环境感知系统 - 修复后"""
# 获取项目根目录
base_dir = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
# 修复：使用具体实现类 DefaultEnvironment
self.environment = DefaultEnvironment(base_dir)
self.logger.info("✅ 环境接口初始化完成")
# 初始化智能家居环境
self.home = AIHome(base_dir)
self.logger.info("✅ 智能家居环境初始化完成")
# 修复：ActionExecutor 不需要参数
self.executor = ActionExecutor()
self.logger.info("✅ 动作执行器初始化完成")
# 新增：初始化环境接口（用于数据库和资源管理）
self.env_interface = EnvironmentInterface(base_dir)
self.logger.info("✅ 环境接口（数据库）初始化完成")
# 记录环境状态
env_status = self.environment.get_system_info()
self.logger.info(f"📊 系统状态: OS={env_status['os']}, CPU={env_status['cpu']}, "
f"内存={env_status['memory']}GB, 磁盘={env_status['disk_usage']}%")
def _initialize_subsystems(self):
"""初始化所有子系统"""
# 1. 初始化模型管理器
from .model_manager import ModelManager
self.model_manager = ModelManager(
model_dir=system_config.MODEL_DIR,
device=system_config.DEVICE,
default_model=system_config.DEFAULT_MODEL
)
self.logger.info("✅ 模型管理器初始化完成")
# 2. 初始化健康系统
from .health_system import HealthSystem
self.health_system = HealthSystem(self)
self.logger.info("✅ 健康系统初始化完成")
# 3. 初始化记忆系统
from .memory_system import MemorySystem
self.memory_system = MemorySystem(self)
self.logger.info("✅ 记忆系统初始化完成")
# 4. 初始化情感系统
from .affective_system import AffectiveSystem
self.affective_system = AffectiveSystem(agent=self)
self.logger.info("✅ 情感系统初始化完成")
# 5. 初始化认知架构
from .cognitive_architecture import CognitiveArchitecture
self.cognitive_architecture = CognitiveArchitecture(agent=self)
self.logger.info("✅ 认知架构初始化完成")
# 6. 初始化通信系统
from .communication_system import CommunicationSystem
self.communication_system = CommunicationSystem(
cognitive_system=self.cognitive_architecture,
agent=self # 传递智能体实例
)
self.logger.info("✅ 通信系统初始化完成")
def process_input(self, user_input, user_id="default"):
"""处理用户输入（通过通信系统）"""
return self.communication_system.process_input(user_input, user_id)
def run_periodic_tasks(self):
"""运行周期性任务"""
# 更新健康状态
self.health_system.update()
# 情感系统更新
self.affective_system.grow()
# 记忆系统维护
self.memory_system.consolidate_memories()
# 修复：环境状态监控 - 使用时间戳
current_time = time.time()
if not hasattr(self, "_last_env_check"):
self._last_env_check = current_time
# 每5分钟检查一次
if current_time - self._last_env_check > 300:
self._last_env_check = current_time
self._monitor_environment()
def _monitor_environment(self):
"""监控环境状态 - 修复后"""
try:
# 获取当前系统状态
env_status = self.environment.get_system_info()
# 安全解析磁盘使用率
disk_str = env_status.get('disk_usage', '0%').strip()
if disk_str.endswith('%'):
try:
disk_usage = float(disk_str[:-1])
except ValueError:
disk_usage = 0.0
else:
disk_usage = 0.0
if disk_usage > 90:
self.logger.warning(f"⚠️ 磁盘空间不足！当前使用率: {disk_usage}%")
# 安全解析内存使用
memory_str = env_status.get('memory', '0GB/0GB')
try:
# 支持多种格式: "3.2GB/16GB" 或 "3.2/16.0 GB"
parts = memory_str.replace('GB', '').replace(' ', '').split('/')
if len(parts) >= 2:
memory_used = float(parts[0])
memory_total = float(parts[1])
memory_ratio = memory_used / memory_total
if memory_ratio > 0.85:
self.logger.warning(
f"⚠️ 内存使用过高！已用: {memory_used:.1f}GB, "
f"总共: {memory_total:.1f}GB, "
f"使用率: {memory_ratio * 100:.1f}%"
)
except (ValueError, TypeError, ZeroDivisionError) as e:
self.logger.error(f"内存数据解析失败: {memory_str} - {str(e)}")
# 记录到健康系统
self.health_system.record_environment_status(env_status)
except Exception as e:
self.logger.error(f"环境监控失败: {str(e)}", exc_info=True)
def get_status(self):
"""获取智能体状态报告"""
# 获取基础状态
status = {
"health": self.health_system.get_status(),
"affective": self.affective_system.get_state(),
"memory_stats": self.memory_system.get_stats(),
"model": self.model_manager.get_current_model_info()
}
# 添加环境信息
try:
env_status = self.environment.get_system_info()
status["environment"] = {
"os": env_status.get("os", "未知"),
"cpu": env_status.get("cpu", "0%"),
"memory": env_status.get("memory", "0GB/0GB"),
"disk": env_status.get("disk_usage", "0%")
}
except Exception as e:
status["environment"] = {"error": str(e)}
return status
# 环境交互方法
def explore_environment(self, path=None):
"""探索环境目录"""
try:
return self.environment.explore_directory(path)
except Exception as e:
self.logger.error(f"环境探索失败: {str(e)}")
return {"error": str(e)}
def execute_action(self, action, parameters):
"""通过执行器执行动作"""
try:
result = self.executor.execute(action, parameters)
self.logger.info(f"执行动作: {action} {parameters} → {result.get('status', '未知')}")
return result
except Exception as e:
self.logger.error(f"动作执行失败: {action} {parameters} - {str(e)}")
return {"status": "error", "message": str(e)}
”没找到你说的agent_controller.py，只看见agent_core.py：“from agent.cognitive_architecture import CognitiveArchitecture
from .model_manager import ModelManager
from .memory_system import MemorySystem
from .knowledge_manager import KnowledgeManager
from .decision_system import DecisionSystem
from .affective_system import AffectiveSystem
from .health_system import HealthSystem
from .environment_interface import EnvironmentInterface
from .communication_system import CommunicationSystem
class AgentCore:
def __init__(self, config):
self.config = config
self.model_manager = ModelManager(config)
self.memory = MemorySystem(config)
self.knowledge = KnowledgeManager(config, self.memory)
self.cognition = CognitiveArchitecture(config, self.model_manager)
self.affect = AffectiveSystem(config)
self.decision = DecisionSystem(config, self.cognition, self.affect)
self.environment = EnvironmentInterface(config)
self.communication = CommunicationSystem(config)
self.health = HealthSystem(config)
self.initialized = False
def initialize(self):
"""初始化所有核心组件"""
if self.initialized:
return True
try:
# 加载默认模型
self.model_manager.load_model(self.config.DEFAULT_MODEL)
# 初始化认知架构
self.cognition.initialize()
# 加载环境接口
self.environment.load_environment()
# 启动健康监测
self.health.start_monitoring()
self.initialized = True
return True
except Exception as e:
print(f"❌ 智能体初始化失败: {str(e)}")
return False
def process_input(self, input_data):
"""处理输入数据"""
if not self.initialized:
return {"error": "Agent not initialized"}
# 认知处理
processed = self.cognition.process_input(input_data)
# 情感评估
affective_response = self.affect.evaluate(processed)
# 决策生成
decision = self.decision.make_decision(processed, affective_response)
# 执行行动
result = self.environment.execute_action(decision)
# 更新记忆
self.memory.store_experience({
"input": input_data,
"processed": processed,
"decision": decision,
"result": result
})
return result”
最新发布
扫一扫
2908
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
