Spaces:
Build error
Build error
File size: 3,951 Bytes
01523b5 |
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 |
import asyncio
import logging
from typing import Any, Dict, List
from datetime import datetime as dt
import datetime
from pydantic import Field
from agentverse.agents.simulation_agent.conversation import BaseAgent
# from agentverse.environments.simulation_env.rules.base import Rule
from agentverse.environments.simulation_env.rules.base import SimulationRule as Rule
from agentverse.message import Message
from . import env_registry as EnvironmentRegistry
from ..base import BaseEnvironment
from pydantic import validator
@EnvironmentRegistry.register("reflection")
class ReflectionEnvironment(BaseEnvironment):
"""
Environment used in Observation-Planning-Reflection agent architecture.
Args:
agents: List of agents
rule: Rule for the environment
max_turns: Maximum number of turns
cnt_turn: Current turn number
last_messages: Messages from last turn
rule_params: Variables set by the rule
current_time
time_delta: time difference between steps
"""
agents: List[BaseAgent]
rule: Rule
max_turns: int = 10
cnt_turn: int = 0
last_messages: List[Message] = []
rule_params: Dict = {}
current_time: dt = dt.now()
time_delta: int = 120
#
# @validator("time_delta")
# def convert_str_to_timedelta(cls, string):
#
# return datetime.timedelta(seconds=int(string))
def __init__(self, rule, **kwargs):
rule_config = rule
order_config = rule_config.get("order", {"type": "sequential"})
visibility_config = rule_config.get("visibility", {"type": "all"})
selector_config = rule_config.get("selector", {"type": "basic"})
updater_config = rule_config.get("updater", {"type": "basic"})
describer_config = rule_config.get("describer", {"type": "basic"})
rule = Rule(
order_config,
visibility_config,
selector_config,
updater_config,
describer_config,
)
super().__init__(rule=rule, **kwargs)
async def step(self) -> List[Message]:
"""Run one step of the environment"""
logging.log(logging.INFO, f"Tick tock. Current time: {self.current_time}")
# Get the next agent index
agent_ids = self.rule.get_next_agent_idx(self)
# Generate current environment description
env_descriptions = self.rule.get_env_description(self)
# Generate the next message
messages = await asyncio.gather(
*[
self.agents[i].astep(self.current_time, env_descriptions[i])
for i in agent_ids
]
)
# Some rules will select certain messages from all the messages
selected_messages = self.rule.select_message(self, messages)
self.last_messages = selected_messages
self.print_messages(selected_messages)
# Update the memory of the agents
self.rule.update_memory(self)
# Update the set of visible agents for each agent
self.rule.update_visible_agents(self)
self.cnt_turn += 1
# update current_time
self.tick_tock()
return selected_messages
def print_messages(self, messages: List[Message]) -> None:
for message in messages:
if message is not None:
logging.info(f"{message.sender}: {message.content}")
def reset(self) -> None:
"""Reset the environment"""
self.cnt_turn = 0
self.rule.reset()
BaseAgent.update_forward_refs()
for agent in self.agents:
agent.reset(environment=self)
def is_done(self) -> bool:
"""Check if the environment is done"""
return self.cnt_turn >= self.max_turns
def tick_tock(self) -> None:
"""Increment the time"""
self.current_time = self.current_time + datetime.timedelta(
seconds=self.time_delta
)
|