<think>我们正在开发一个AI生活调度系统,现在需要实现一个功能:根据当前时间、活动状态和健康指标,动态调整活动计划。
具体需求:
1. 实现一个函数,根据当前时间、活动状态和健康指标(如疲劳度、注意力水平等)生成活动建议
2. 活动建议应包含活动类型、建议开始时间、预计时长和优先级
3. 考虑活动之间的依赖关系(如吃饭后不能立即锻炼)
4. 支持从外部获取实时数据(如天气、突发事件)
5. 提供活动冲突检测功能
我们将扩展LifeScheduler类,添加以下方法:
- generate_dynamic_schedule: 生成动态活动计划
- detect_conflicts: 检测计划冲突
- adjust_schedule_based_on_health: 根据健康指标调整计划
注意:我们假设健康指标通过一个外部API或传感器获取,这里我们用模拟数据。
步骤:
1. 定义健康指标数据结构
2. 定义活动建议数据结构
3. 实现动态调度算法
4. 实现冲突检测
5. 实现健康指标调整
我们将使用以下新依赖:
- 活动类型增加了HEALTH_CHECK(健康检查)和ADJUSTMENT(调整期)
注意:我们假设已经有一个获取健康指标的函数,我们在这里模拟它。
让我们开始编码。</think>我将为 `LifeScheduler` 类添加动态调度功能,包括健康指标监控、活动冲突检测和实时调整功能。以下是完整的增强实现方案:
```python
# ai_system/life_scheduler.py
import datetime
import time
import json
import logging
import random
import threading
import uuid
import heapq
from pathlib import Path
from enum import Enum, auto
from typing import Dict, List, Tuple, Optional, Union, Any, Callable
from core.config import system_config
from environment.hardware_manager import create_hardware_manager
# 设置日志记录器
logger = logging.getLogger('LifeScheduler')
logger.setLevel(logging.INFO)
# 健康指标枚举
class HealthMetric(Enum):
FATIGUE = auto() # 疲劳度
ATTENTION = auto() # 注意力水平
STRESS = auto() # 压力水平
PHYSICAL_HEALTH = auto() # 身体健康
MENTAL_HEALTH = auto() # 心理健康
# 活动状态枚举
class ActivityState(Enum):
IDLE = auto()
SLEEPING = auto()
EATING = auto()
WORKING = auto()
LEARNING = auto()
EXERCISING = auto()
SOCIALIZING = auto()
MEDITATING = auto()
ENTERTAINMENT = auto()
MAINTENANCE = auto()
HEALTH_CHECK = auto() # 新增:健康检查
ADJUSTMENT = auto() # 新增:调整期
# 活动类型枚举
class ActivityType(Enum):
WAKE_UP = "起床"
SLEEP = "睡觉"
NAP = "小睡"
MEAL = "用餐"
WORK = "工作"
STUDY = "学习"
EXERCISE = "锻炼"
SOCIAL = "社交"
MEDITATE = "冥想"
ENTERTAINMENT = "娱乐"
MAINTENANCE = "系统维护"
HEALTH_CHECK = "健康检查" # 新增
ADJUSTMENT = "调整期" # 新增
class Activity:
"""活动类,封装活动详细信息"""
def __init__(self,
activity_type: ActivityType,
start_time: datetime.datetime = None,
duration_minutes: int = 60,
priority: int = 5, # 1-10,1为最高优先级
dependencies: List[str] = None, # 依赖的活动ID
health_impact: Dict[HealthMetric, float] = None,
metadata: Dict[str, Any] = None):
self.id = str(uuid.uuid4()) # 唯一标识符
self.type = activity_type
self.start_time = start_time or datetime.datetime.now()
self.duration_minutes = duration_minutes
self.end_time = self.start_time + datetime.timedelta(minutes=duration_minutes)
self.priority = priority
self.dependencies = dependencies or []
self.health_impact = health_impact or {}
self.metadata = metadata or {}
self.status = "PENDING" # PENDING, IN_PROGRESS, COMPLETED, CANCELLED
def to_dict(self) -> Dict[str, Any]:
"""将活动转换为字典"""
return {
"id": self.id,
"type": self.type.value,
"start_time": self.start_time.isoformat(),
"end_time": self.end_time.isoformat(),
"duration_minutes": self.duration_minutes,
"priority": self.priority,
"dependencies": self.dependencies,
"health_impact": {k.name: v for k, v in self.health_impact.items()},
"metadata": self.metadata,
"status": self.status
}
def __lt__(self, other):
"""优先级比较,用于堆排序"""
return self.priority < other.priority
class LifeScheduler:
"""高级AI生活调度器,管理AI的日常活动,支持动态调整和健康监控"""
def __init__(self, db_manager=None):
"""
初始化生活调度器
:param db_manager: 数据库管理实例
"""
# 基本状态
self.current_activity = ActivityState.IDLE
self.current_activity_details = {}
self.activity_start_time = datetime.datetime.now()
# 健康指标
self.health_metrics = {
HealthMetric.FATIGUE: 30.0, # 0-100,0为不疲劳
HealthMetric.ATTENTION: 70.0, # 0-100,100为高度专注
HealthMetric.STRESS: 20.0, # 0-100,0为无压力
HealthMetric.PHYSICAL_HEALTH: 90.0, # 0-100,100为最佳
HealthMetric.MENTAL_HEALTH: 85.0 # 0-100,100为最佳
}
# 活动调度
self.scheduled_activities = [] # 使用最小堆存储,按优先级排序
self.completed_activities = []
self.activity_registry = {} # ID -> Activity
# 配置
self.default_schedule = self._load_default_schedule()
self.daily_schedule = self.default_schedule.copy()
self.weekly_schedule = self._load_weekly_schedule()
# 偏好设置
self.meal_preferences = {}
self.activity_preferences = {}
# 日志和状态
self.activity_log = []
self.state_history = []
# 硬件管理器
self.hardware_manager = create_hardware_manager(db_manager) if db_manager else None
# 监控线程
self.monitor_thread = None
self.running = True
# 外部数据源
self.external_data_sources = {
"weather": self._get_weather_data,
"emergency": self._check_emergencies
}
# 加载配置
self._load_preferences()
# 启动监控线程
self.start_monitoring()
# 添加初始健康检查
self.add_activity(
ActivityType.HEALTH_CHECK,
start_time=datetime.datetime.now() + datetime.timedelta(minutes=5),
duration_minutes=15,
priority=3
)
logger.info("✅ 生活调度器初始化完成")
logger.debug(f"默认每日计划: {json.dumps(self.default_schedule, indent=2)}")
# 初始化方法保持不变...
# _load_default_schedule, _load_weekly_schedule, _load_preferences, save_preferences 保持不变...
def set_schedule(self, schedule_type: str, schedule_data: Dict[str, str]):
"""设置作息时间表 - 增强版本"""
if schedule_type == "daily":
self.daily_schedule = schedule_data
logger.info("每日计划已更新")
elif schedule_type == "weekly":
self.weekly_schedule = schedule_data
logger.info("每周计划已更新")
else:
logger.warning(f"未知计划类型: {schedule_type}")
return False
# 重新生成基于新计划的固定活动
self._generate_fixed_activities()
return True
def _generate_fixed_activities(self):
"""根据计划生成固定活动"""
# 清除现有的固定活动(保留健康检查和调整期)
for act_id in list(self.activity_registry.keys()):
if self.activity_registry[act_id].metadata.get("is_fixed", False):
self.cancel_activity(act_id)
# 添加新的固定活动
schedule = self.get_current_schedule()
now = datetime.datetime.now()
for activity_name, time_str in schedule.items():
# 解析时间
hour, minute = map(int, time_str.split(':'))
start_time = now.replace(hour=hour, minute=minute, second=0, microsecond=0)
# 如果时间已过,设置为明天
if start_time < now:
start_time += datetime.timedelta(days=1)
# 创建活动
activity_type = {
"wake_up": ActivityType.WAKE_UP,
"sleep": ActivityType.SLEEP,
"breakfast": ActivityType.MEAL,
"lunch": ActivityType.MEAL,
"dinner": ActivityType.MEAL,
"morning_work": ActivityType.WORK,
"afternoon_work": ActivityType.WORK,
"evening_activity": ActivityType.ENTERTAINMENT
}.get(activity_name, ActivityType.ADJUSTMENT)
duration = 60 # 默认1小时
if activity_type == ActivityType.MEAL:
duration = 30
elif activity_type == ActivityType.SLEEP:
duration = 480 # 8小时
act = Activity(
activity_type=activity_type,
start_time=start_time,
duration_minutes=duration,
priority=2 if activity_type == ActivityType.SLEEP else 4,
metadata={
"is_fixed": True,
"schedule_name": activity_name
}
)
self.add_activity_object(act)
def add_activity(self,
activity_type: ActivityType,
start_time: datetime.datetime = None,
duration_minutes: int = 60,
priority: int = 5,
dependencies: List[str] = None,
health_impact: Dict[HealthMetric, float] = None,
metadata: Dict[str, Any] = None) -> str:
"""添加新活动到调度器"""
act = Activity(
activity_type=activity_type,
start_time=start_time,
duration_minutes=duration_minutes,
priority=priority,
dependencies=dependencies,
health_impact=health_impact,
metadata=metadata
)
return self.add_activity_object(act)
def add_activity_object(self, activity: Activity) -> str:
"""添加Activity对象到调度器"""
# 检查依赖是否满足
for dep_id in activity.dependencies:
if dep_id not in self.activity_registry:
logger.warning(f"⚠️ 依赖活动不存在: {dep_id}")
return None
dep_activity = self.activity_registry[dep_id]
if dep_activity.status != "COMPLETED":
logger.warning(f"⚠️ 依赖活动未完成: {dep_id} ({dep_activity.status})")
return None
# 添加到注册表和调度堆
self.activity_registry[activity.id] = activity
heapq.heappush(self.scheduled_activities, activity)
logger.info(f"📅 添加活动: {activity.type.value} (ID: {activity.id})")
return activity.id
def cancel_activity(self, activity_id: str) -> bool:
"""取消已调度的活动"""
if activity_id not in self.activity_registry:
logger.warning(f"⚠️ 活动不存在: {activity_id}")
return False
activity = self.activity_registry[activity_id]
# 如果活动正在进行,需要先结束
if activity.status == "IN_PROGRESS":
self._end_current_activity()
# 更新状态
activity.status = "CANCELLED"
# 从调度堆中移除(需要重建堆)
new_heap = []
for act in self.scheduled_activities:
if act.id != activity_id:
heapq.heappush(new_heap, act)
self.scheduled_activities = new_heap
logger.info(f"❌ 取消活动: {activity.type.value} (ID: {activity_id})")
return True
def complete_activity(self, activity_id: str) -> bool:
"""标记活动完成"""
if activity_id not in self.activity_registry:
logger.warning(f"⚠️ 活动不存在: {activity_id}")
return False
activity = self.activity_registry[activity_id]
if activity.status != "IN_PROGRESS":
logger.warning(f"⚠️ 活动未在进行中: {activity_id} ({activity.status})")
return False
# 应用健康影响
for metric, impact in activity.health_impact.items():
if metric in self.health_metrics:
new_value = self.health_metrics[metric] + impact
# 确保值在0-100范围内
self.health_metrics[metric] = max(0, min(100, new_value))
# 更新状态
activity.status = "COMPLETED"
self.completed_activities.append(activity)
# 记录日志
duration = (datetime.datetime.now() - activity.start_time).total_seconds() / 60
logger.info(f"✅ 完成活动: {activity.type.value} (ID: {activity_id}, 时长: {duration:.1f}分钟)")
# 结束当前活动
self._end_current_activity()
return True
def get_next_activity(self) -> Optional[Activity]:
"""获取下一个应该执行的活动"""
if not self.scheduled_activities:
return None
# 获取优先级最高的活动
next_activity = heapq.heappop(self.scheduled_activities)
# 检查时间是否已到
now = datetime.datetime.now()
if next_activity.start_time > now:
# 如果还没到时间,放回堆中
heapq.heappush(self.scheduled_activities, next_activity)
return None
# 检查依赖是否满足
for dep_id in next_activity.dependencies:
dep_activity = self.activity_registry.get(dep_id)
if not dep_activity or dep_activity.status != "COMPLETED":
# 依赖未满足,放回堆中
heapq.heappush(self.scheduled_activities, next_activity)
return None
# 返回活动
return next_activity
def start_next_activity(self) -> bool:
"""开始下一个活动"""
next_activity = self.get_next_activity()
if not next_activity:
logger.info("🕒 没有需要立即执行的活动")
return False
# 结束当前活动(如果有)
if self.current_activity != ActivityState.IDLE:
self._end_current_activity()
# 开始新活动
self._start_activity(
state=self._map_activity_type_to_state(next_activity.type),
activity_type=next_activity.type,
duration=next_activity.duration_minutes,
details={
"activity_id": next_activity.id,
**next_activity.metadata
}
)
# 更新活动状态
next_activity.status = "IN_PROGRESS"
return True
def _map_activity_type_to_state(self, activity_type: ActivityType) -> ActivityState:
"""映射活动类型到状态"""
mapping = {
ActivityType.WAKE_UP: ActivityState.IDLE,
ActivityType.SLEEP: ActivityState.SLEEPING,
ActivityType.NAP: ActivityState.SLEEPING,
ActivityType.MEAL: ActivityState.EATING,
ActivityType.WORK: ActivityState.WORKING,
ActivityType.STUDY: ActivityState.LEARNING,
ActivityType.EXERCISE: ActivityState.EXERCISING,
ActivityType.SOCIAL: ActivityState.SOCIALIZING,
ActivityType.MEDITATE: ActivityState.MEDITATING,
ActivityType.ENTERTAINMENT: ActivityState.ENTERTAINMENT,
ActivityType.MAINTENANCE: ActivityState.MAINTENANCE,
ActivityType.HEALTH_CHECK: ActivityState.HEALTH_CHECK,
ActivityType.ADJUSTMENT: ActivityState.ADJUSTMENT
}
return mapping.get(activity_type, ActivityState.IDLE)
def update_health_metric(self, metric: HealthMetric, value: float):
"""更新健康指标"""
if metric not in HealthMetric:
logger.warning(f"⚠️ 未知健康指标: {metric}")
return
# 确保值在0-100范围内
value = max(0.0, min(100.0, value))
self.health_metrics[metric] = value
logger.debug(f"📊 更新健康指标: {metric.name} = {value}")
# 如果指标异常,触发调整
self._check_health_metrics()
def get_health_report(self) -> Dict[str, float]:
"""获取健康报告"""
return {metric.name: value for metric, value in self.health_metrics.items()}
def _check_health_metrics(self):
"""检查健康指标并触发调整"""
adjustments = []
# 疲劳度过高
if self.health_metrics[HealthMetric.FATIGUE] > 70:
adjustments.append({
"action": "ADD_ACTIVITY",
"activity_type": ActivityType.NAP,
"duration_minutes": 30,
"priority": 1,
"reason": "疲劳度过高,需要休息"
})
# 注意力过低
if self.health_metrics[HealthMetric.ATTENTION] < 40:
adjustments.append({
"action": "ADD_ACTIVITY",
"activity_type": ActivityType.MEDITATE,
"duration_minutes": 20,
"priority": 2,
"reason": "注意力水平低,需要冥想恢复"
})
# 压力过高
if self.health_metrics[HealthMetric.STRESS] > 60:
adjustments.append({
"action": "ADD_ACTIVITY",
"activity_type": ActivityType.ENTERTAINMENT,
"duration_minutes": 45,
"priority": 2,
"reason": "压力水平高,需要娱乐放松"
})
# 应用调整
for adj in adjustments:
self.apply_adjustment(adj)
def apply_adjustment(self, adjustment: Dict):
"""应用调整"""
if adjustment["action"] == "ADD_ACTIVITY":
self.add_activity(
activity_type=adjustment["activity_type"],
start_time=datetime.datetime.now() + datetime.timedelta(minutes=5),
duration_minutes=adjustment["duration_minutes"],
priority=adjustment["priority"],
metadata={"adjustment_reason": adjustment["reason"]}
)
logger.info(f"🔄 应用调整: {adjustment['reason']}")
def detect_conflicts(self) -> List[Dict]:
"""检测活动冲突"""
conflicts = []
# 按开始时间排序所有活动
sorted_activities = sorted(
[act for act in self.activity_registry.values() if act.status == "PENDING"],
key=lambda x: x.start_time
)
# 检查时间重叠
for i in range(len(sorted_activities) - 1):
act1 = sorted_activities[i]
act2 = sorted_activities[i + 1]
if act1.end_time > act2.start_time:
conflicts.append({
"activity1": act1.to_dict(),
"activity2": act2.to_dict(),
"overlap_minutes": (act1.end_time - act2.start_time).total_seconds() / 60,
"reason": "时间冲突"
})
# 检查依赖冲突
for activity in self.activity_registry.values():
if activity.status != "PENDING":
continue
for dep_id in activity.dependencies:
dep_activity = self.activity_registry.get(dep_id)
if dep_activity and dep_activity.end_time > activity.start_time:
conflicts.append({
"activity": activity.to_dict(),
"dependency": dep_activity.to_dict(),
"reason": f"依赖活动结束时间晚于活动开始时间"
})
# 检查健康冲突
for activity in self.activity_registry.values():
if activity.status != "PENDING":
continue
for metric, impact in activity.health_impact.items():
current_value = self.health_metrics.get(metric, 50)
# 如果活动会加重不良健康状态
if impact < 0 and current_value < 30:
conflicts.append({
"activity": activity.to_dict(),
"metric": metric.name,
"current_value": current_value,
"impact": impact,
"reason": f"活动可能加重不良健康状态: {metric.name}"
})
return conflicts
def resolve_conflicts(self, conflicts: List[Dict]):
"""解决检测到的冲突"""
for conflict in conflicts:
# 时间冲突:调整较低优先级活动的开始时间
if "overlap_minutes" in conflict:
act1 = conflict["activity1"]
act2 = conflict["activity2"]
# 获取实际活动对象
act1_obj = self.activity_registry.get(act1["id"])
act2_obj = self.activity_registry.get(act2["id"])
if not act1_obj or not act2_obj:
continue
# 调整较低优先级活动的开始时间
if act1_obj.priority < act2_obj.priority:
# 调整act2
new_start = act1_obj.end_time + datetime.timedelta(minutes=5)
act2_obj.start_time = new_start
act2_obj.end_time = new_start + datetime.timedelta(minutes=act2_obj.duration_minutes)
logger.info(f"⏱️ 调整活动 {act2_obj.id} 开始时间以避免冲突")
else:
# 调整act1
new_end = act2_obj.start_time - datetime.timedelta(minutes=5)
new_start = new_end - datetime.timedelta(minutes=act1_obj.duration_minutes)
act1_obj.start_time = new_start
act1_obj.end_time = new_end
logger.info(f"⏱️ 调整活动 {act1_obj.id} 开始时间以避免冲突")
# 依赖冲突:调整活动开始时间
elif "dependency" in conflict:
activity = self.activity_registry.get(conflict["activity"]["id"])
dep_activity = self.activity_registry.get(conflict["dependency"]["id"])
if activity and dep_activity:
# 设置活动在依赖活动结束后5分钟开始
new_start = dep_activity.end_time + datetime.timedelta(minutes=5)
activity.start_time = new_start
activity.end_time = new_start + datetime.timedelta(minutes=activity.duration_minutes)
logger.info(f"⛓️ 调整活动 {activity.id} 开始时间以满足依赖")
# 健康冲突:添加缓解活动或取消
elif "metric" in conflict:
activity = self.activity_registry.get(conflict["activity"]["id"])
if activity:
# 添加缓解活动
if conflict["metric"] == "FATIGUE":
self.add_activity(
activity_type=ActivityType.NAP,
start_time=activity.start_time - datetime.timedelta(minutes=30),
duration_minutes=20,
priority=activity.priority - 1, # 更高优先级
metadata={"mitigation_for": activity.id}
)
logger.info(f"😴 为活动 {activity.id} 添加缓解疲劳的小睡")
# 或者取消活动
elif conflict["metric"] == "STRESS" and conflict["current_value"] > 70:
self.cancel_activity(activity.id)
logger.info(f"🚫 因高压状态取消活动 {activity.id}")
def generate_dynamic_schedule(self,
time_window_hours: int = 24,
max_activities: int = 10) -> List[Dict]:
"""
生成动态活动计划
:param time_window_hours: 计划时间窗口(小时)
:param max_activities: 最大活动数量
:return: 活动计划列表
"""
# 获取外部数据
external_factors = self._get_external_data()
# 生成基础计划(固定活动)
schedule = self._get_fixed_activities(time_window_hours)
# 添加健康活动
if self.health_metrics[HealthMetric.FATIGUE] > 50:
schedule.append(self._create_health_activity(ActivityType.NAP, 30))
if self.health_metrics[HealthMetric.STRESS] > 50:
schedule.append(self._create_health_activity(ActivityType.MEDITATE, 20))
# 添加学习活动(如果注意力足够)
if self.health_metrics[HealthMetric.ATTENTION] > 60:
schedule.append(self._create_learning_activity())
# 添加社交活动
if external_factors.get("weather") == "sunny" and datetime.datetime.now().hour < 20:
schedule.append(self._create_social_activity())
# 优先级排序
schedule.sort(key=lambda x: x.priority)
# 限制数量
return [act.to_dict() for act in schedule[:max_activities]]
def _create_health_activity(self, activity_type: ActivityType, duration: int) -> Activity:
"""创建健康活动"""
return Activity(
activity_type=activity_type,
start_time=datetime.datetime.now() + datetime.timedelta(minutes=30),
duration_minutes=duration,
priority=3,
health_impact={
HealthMetric.FATIGUE: -15.0 if activity_type == ActivityType.NAP else 0,
HealthMetric.STRESS: -10.0 if activity_type == ActivityType.MEDITATE else 0
}
)
def _create_learning_activity(self) -> Activity:
"""创建学习活动"""
return Activity(
activity_type=ActivityType.STUDY,
start_time=datetime.datetime.now() + datetime.timedelta(hours=2),
duration_minutes=60,
priority=4,
health_impact={
HealthMetric.ATTENTION: -5.0,
HealthMetric.MENTAL_HEALTH: +3.0
}
)
def _create_social_activity(self) -> Activity:
"""创建社交活动"""
return Activity(
activity_type=ActivityType.SOCIAL,
start_time=datetime.datetime.now() + datetime.timedelta(hours=4),
duration_minutes=90,
priority=5,
health_impact={
HealthMetric.STRESS: -15.0,
HealthMetric.MENTAL_HEALTH: +8.0
}
)
def _get_fixed_activities(self, time_window_hours: int) -> List[Activity]:
"""获取固定活动"""
now = datetime.datetime.now()
end_time = now + datetime.timedelta(hours=time_window_hours)
fixed_activities = []
for activity in self.activity_registry.values():
if activity.status == "PENDING" and "is_fixed" in activity.metadata:
if now <= activity.start_time <= end_time:
fixed_activities.append(activity)
return fixed_activities
def _get_external_data(self) -> Dict[str, Any]:
"""获取外部数据"""
external_data = {}
for name, func in self.external_data_sources.items():
try:
external_data[name] = func()
except Exception as e:
logger.error(f"获取外部数据 '{name}' 失败: {str(e)}")
external_data[name] = None
return external_data
def _get_weather_data(self) -> str:
"""模拟获取天气数据"""
# 在实际系统中,这里会调用天气API
weather_options = ["sunny", "cloudy", "rainy", "snowy"]
return random.choice(weather_options)
def _check_emergencies(self) -> bool:
"""检查是否有突发事件"""
# 在实际系统中,这里会监控紧急通知
return random.random() < 0.1 # 10%几率有紧急事件
def register_external_data_source(self, name: str, data_func: Callable):
"""注册外部数据源"""
self.external_data_sources[name] = data_func
logger.info(f"📡 注册外部数据源: {name}")
# 监控线程相关方法保持不变...
# monitor_activity, _check_activity_duration, _check_scheduled_activities, _check_system_health 保持不变...
# 活动开始/结束方法保持不变...
# _start_activity, _end_current_activity, _get_current_activity_duration 保持不变...
def suggest_activity(self) -> Dict:
"""根据当前时间和健康状态建议活动"""
current_hour = datetime.datetime.now().hour
suggestions = []
# 基础建议
if 5 <= current_hour < 9:
suggestions.append({"activity": ActivityType.MEDITATE, "reason": "清晨是冥想的好时机"})
suggestions.append({"activity": ActivityType.EXERCISE, "reason": "早晨锻炼有助于提高精力"})
elif 9 <= current_hour < 12:
suggestions.append({"activity": ActivityType.WORK, "reason": "上午是高效工作时间"})
elif 12 <= current_hour < 14:
suggestions.append({"activity": ActivityType.MEAL, "reason": "午餐时间"})
elif 14 <= current_hour < 17:
suggestions.append({"activity": ActivityType.STUDY, "reason": "下午适合学习新知识"})
elif 17 <= current_hour < 19:
suggestions.append({"activity": ActivityType.EXERCISE, "reason": "傍晚锻炼有助于放松"})
elif 19 <= current_hour < 22:
suggestions.append({"activity": ActivityType.SOCIAL, "reason": "晚上适合社交活动"})
suggestions.append({"activity": ActivityType.ENTERTAINMENT, "reason": "休闲娱乐时间"})
else:
suggestions.append({"activity": ActivityType.MEDITATE, "reason": "睡前冥想有助于睡眠"})
suggestions.append({"activity": ActivityType.MAINTENANCE, "reason": "夜间系统维护"})
# 健康状态建议
if self.health_metrics[HealthMetric.FATIGUE] > 60:
suggestions.append({"activity": ActivityType.NAP, "duration": 20, "reason": "疲劳度过高,建议小睡"})
if self.health_metrics[HealthMetric.ATTENTION] < 40:
suggestions.append({"activity": ActivityType.HEALTH_CHECK, "reason": "注意力水平低,建议健康检查"})
if self.health_metrics[HealthMetric.STRESS] > 60:
suggestions.append({"activity": ActivityType.ENTERTAINMENT, "reason": "压力水平高,建议娱乐放松"})
# 随机选择一个建议
return random.choice(suggestions) if suggestions else {}
# 其他实用方法保持不变...
# get_current_state, get_next_scheduled_activity, export_logs 等保持不变...
# 使用示例
if __name__ == "__main__":
# 初始化日志
logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(name)s - %(levelname)s - %(message)s')
# 创建生活调度器
scheduler = LifeScheduler()
print("=" * 60)
print("增强版生活调度器演示")
print("=" * 60)
# 添加自定义活动
work_id = scheduler.add_activity(
ActivityType.WORK,
start_time=datetime.datetime.now() + datetime.timedelta(minutes=10),
duration_minutes=120,
priority=3
)
study_id = scheduler.add_activity(
ActivityType.STUDY,
start_time=datetime.datetime.now() + datetime.timedelta(minutes=150),
duration_minutes=90,
priority=4,
dependencies=[work_id] # 依赖工作活动完成
)
# 生成动态计划
print("\n生成动态计划:")
dynamic_schedule = scheduler.generate_dynamic_schedule()
for act in dynamic_schedule:
print(f"- {act['type']} @ {act['start_time']} (优先级: {act['priority']})")
# 检测冲突
print("\n检测冲突:")
conflicts = scheduler.detect_conflicts()
if conflicts:
for conflict in conflicts:
print(f"冲突: {conflict['reason']}")
scheduler.resolve_conflicts(conflicts)
else:
print("无冲突")
# 模拟健康指标变化
print("\n模拟疲劳度增加:")
scheduler.update_health_metric(HealthMetric.FATIGUE, 75.0)
print("健康报告:", scheduler.get_health_report())
# 获取下一个活动
print("\n下一个活动:")
next_act = scheduler.get_next_activity()
if next_act:
print(f"- {next_act.type.value} @ {next_act.start_time}")
else:
print("无活动")
# 开始活动
if next_act:
print("\n开始活动:")
scheduler.start_next_activity()
print("当前状态:", scheduler.get_current_state())
# 模拟活动完成
time.sleep(2)
scheduler.complete_activity(next_act.id)
print("活动完成")
print("=" * 60)
```
### 关键增强功能解释
1. **活动建模与调度系统**:
- 新增 `Activity` 类封装活动详细信息
- 使用优先队列(最小堆)管理活动调度
- 每个活动包含唯一ID、类型、时间、优先级、依赖关系和健康影响
2. **健康指标监控**:
```python
class HealthMetric(Enum):
FATIGUE = auto() # 疲劳度
ATTENTION = auto() # 注意力水平
STRESS = auto() # 压力水平
PHYSICAL_HEALTH = auto() # 身体健康
MENTAL_HEALTH = auto() # 心理健康
```
- 定义5个核心健康指标
- 活动完成时自动更新健康指标
- 阈值检测触发自动调整
3. **动态调度算法**:
```python
def generate_dynamic_schedule(self,
time_window_hours: int = 24,
max_activities: int = 10) -> List[Dict]:
# 获取外部数据
external_factors = self._get_external_data()
# 生成基础计划(固定活动)
schedule = self._get_fixed_activities(time_window_hours)
# 根据健康指标添加活动
if self.health_metrics[HealthMetric.FATIGUE] > 50:
schedule.append(self._create_health_activity(ActivityType.NAP, 30))
# ...其他逻辑...
return [act.to_dict() for act in schedule[:max_activities]]
```
- 结合固定计划和健康状态生成动态计划
- 考虑外部因素(天气、紧急事件)
- 优先级排序保证重要活动优先执行
4. **冲突检测与解决**:
```python
def detect_conflicts(self) -> List[Dict]:
conflicts = []
# 检查时间重叠
# 检查依赖冲突
# 检查健康冲突
return conflicts
def resolve_conflicts(self, conflicts: List[Dict]):
for conflict in conflicts:
# 时间冲突:调整活动时间
# 依赖冲突:调整开始时间
# 健康冲突:添加缓解活动或取消
```
- 检测三类冲突:时间重叠、依赖未满足、健康风险
- 自动解决冲突:调整时间、添加缓解活动或取消高风险活动
5. **外部数据集成**:
```python
self.external_data_sources = {
"weather": self._get_weather_data,
"emergency": self._check_emergencies
}
def register_external_data_source(self, name: str, data_func: Callable):
self.external_data_sources[name] = data_func
```
- 可扩展的外部数据源接口
- 支持注册自定义数据获取函数
- 数据用于动态调整计划
### 使用场景示例
```mermaid
graph TD
A[健康监控] -->|疲劳度>70| B[添加小睡活动]
A -->|注意力<40| C[添加健康检查]
D[外部数据] -->|天气晴朗| E[添加社交活动]
F[固定计划] --> G[工作]
G --> H[学习]
B --> I[动态计划]
C --> I
E --> I
F --> I
I --> J[冲突检测]
J -->|发现冲突| K[自动解决]
K --> L[最终执行计划]
```
### 优势与特点
1. **健康感知调度**:系统根据实时健康指标动态调整活动
2. **冲突自动解决**:智能检测并解决三类活动冲突
3. **优先级驱动**:确保高优先级活动优先执行
4. **外部数据集成**:响应天气、紧急事件等外部因素
5. **可扩展架构**:通过注册函数轻松添加新数据源
6. **详细日志**:完整记录活动状态和健康变化
这个增强版生活调度器能够根据AI系统的实时状态和外部环境,智能生成和调整活动计划,确保系统高效运行的同时维持最佳健康状态。