pycityagent 2.0.0a52__cp311-cp311-macosx_11_0_arm64.whl → 2.0.0a54__cp311-cp311-macosx_11_0_arm64.whl

pycityagent/simulation/simulation.py

@@ -18,13 +18,15 @@ from ..cityagent import (BankAgent, FirmAgent, GovernmentAgent, NBSAgent,
                          memory_config_government, memory_config_nbs,
                          memory_config_societyagent)
 from ..cityagent.initial import bind_agent_info, initialize_social_network
-from ..environment.simulator import Simulator
-from ..llm import SimpleEmbedding
+from ..environment import Simulator
+from ..llm import LLM, LLMConfig, SimpleEmbedding
 from ..memory import Memory
-from ..message.messager import Messager
+from ..message import (MessageBlockBase, MessageBlockListenerBase,
+                       MessageInterceptor, Messager)
 from ..metrics import init_mlflow_connection
+from ..metrics.mlflow_client import MlflowClient
 from ..survey import Survey
-from ..utils import TO_UPDATE_EXP_INFO_KEYS_AND_TYPES
+from ..utils import SURVEY_SENDER_UUID, TO_UPDATE_EXP_INFO_KEYS_AND_TYPES
 from .agentgroup import AgentGroup
 from .storage.pg import PgWriter, create_pg_tables
 
@@ -39,6 +41,7 @@ class AgentSimulation:
         config: dict,
         agent_class: Union[None, type[Agent], list[type[Agent]]] = None,
         agent_config_file: Optional[dict] = None,
+        metric_extractor: Optional[list[tuple[int, Callable]]] = None,
         enable_economy: bool = True,
         agent_prefix: str = "agent_",
         exp_name: str = "default_experiment",
@@ -80,6 +83,15 @@ class AgentSimulation:
         self.config = config
         self.exp_name = exp_name
         self._simulator = Simulator(config["simulator_request"])
+        if enable_economy:
+            self._economy_env = self._simulator._sim_env
+            _req_dict = self.config["simulator_request"]
+            if "economy" in _req_dict:
+                _req_dict["economy"]["server"] = self._economy_env.sim_addr
+            else:
+                _req_dict["economy"] = {
+                    "server": self._economy_env.sim_addr,
+                }
         self.agent_prefix = agent_prefix
         self._groups: dict[str, AgentGroup] = {}  # type:ignore
         self._agent_uuid2group: dict[str, AgentGroup] = {}  # type:ignore
@@ -89,6 +101,8 @@ class AgentSimulation:
         self._user_survey_topics: dict[str, str] = {}
         self._user_interview_topics: dict[str, str] = {}
         self._loop = asyncio.get_event_loop()
+        self._total_steps = 0
+        self._simulator_day = 0
         # self._last_asyncio_pg_task = None  # 将SQL写入的IO隐藏到计算任务后
 
         self._messager = Messager.remote(
@@ -102,6 +116,7 @@ class AgentSimulation:
         _storage_config: dict[str, Any] = config.get("storage", {})
         if _storage_config is None:
             _storage_config = {}
+
         # avro
         _avro_config: dict[str, Any] = _storage_config.get("avro", {})
         self._enable_avro = _avro_config.get("enabled", False)
@@ -112,6 +127,27 @@ class AgentSimulation:
             self._avro_path = Path(_avro_config["path"]) / f"{self.exp_id}"
             self._avro_path.mkdir(parents=True, exist_ok=True)
 
+        # mlflow
+        _mlflow_config: dict[str, Any] = config.get("metric_request", {}).get("mlflow")
+        mlflow_run_id, _ = init_mlflow_connection(
+            config=_mlflow_config,
+            mlflow_run_name=f"EXP_{self.exp_name}_{1000*int(time.time())}",
+            experiment_name=self.exp_name,
+        )
+        if _mlflow_config:
+            logger.info(f"-----Creating Mlflow client...")
+            self.mlflow_client = MlflowClient(
+                config=_mlflow_config,
+                mlflow_run_name=f"EXP_{exp_name}_{1000*int(time.time())}",
+                experiment_name=exp_name,
+                run_id=mlflow_run_id,
+            )
+            self.metric_extractor = metric_extractor
+        else:
+            logger.warning("Mlflow is not enabled, NO MLFLOW STORAGE")
+            self.mlflow_client = None
+            self.metric_extractor = None
+
         # pg
         _pgsql_config: dict[str, Any] = _storage_config.get("pgsql", {})
         self._enable_pgsql = _pgsql_config.get("enabled", False)
@@ -167,11 +203,11 @@ class AgentSimulation:
         - workflow:
             - list[Step]
             - Step:
-                - type: str, "step", "run", "interview", "survey", "intervene"
+                - type: str, "step", "run", "interview", "survey", "intervene", "pause", "resume"
                 - day: int if type is "run", else None
-                - time: int if type is "step", else None
+                - times: int if type is "step", else None
                 - description: Optional[str], description of the step
-                - step_func: Optional[Callable[AgentSimulation, None]], only used when type is "interview", "survey" and "intervene"
+                - func: Optional[Callable[AgentSimulation, None]], only used when type is "interview", "survey" and "intervene"
         - logging_level: Optional[int]
         - exp_name: Optional[str]
         """
@@ -201,6 +237,7 @@ class AgentSimulation:
         agent_count.append(config["agent_config"]["number_of_government"])
         agent_count.append(config["agent_config"]["number_of_bank"])
         agent_count.append(config["agent_config"]["number_of_nbs"])
+        # TODO(yanjunbo): support MessageInterceptor
         await simulation.init_agents(
             agent_count=agent_count,
             group_size=config["agent_config"].get("group_size", 10000),
@@ -224,10 +261,15 @@ class AgentSimulation:
             if step["type"] == "run":
                 await simulation.run(step.get("day", 1))
             elif step["type"] == "step":
-                # await simulation.step(step.get("time", 1))
-                await simulation.step()
+                times = step.get("times", 1)
+                for _ in range(times):
+                    await simulation.step()
+            elif step["type"] == "pause":
+                await simulation.pause_simulator()
+            elif step["type"] == "resume":
+                await simulation.resume_simulator()
             else:
-                await step["step_func"](simulation)
+                await step["func"](simulation)
         logger.info("Simulation finished")
 
     @property
@@ -261,9 +303,13 @@ class AgentSimulation:
         return self._agent_uuid2group
 
     @property
-    def messager(self):
+    def messager(self) -> ray.ObjectRef:
         return self._messager
 
+    @property
+    def message_interceptor(self) -> ray.ObjectRef:
+        return self._message_interceptors[0]  # type:ignore
+
     async def _save_exp_info(self) -> None:
         """异步保存实验信息到YAML文件"""
         try:
@@ -331,11 +377,21 @@ class AgentSimulation:
             # 如果没有发生异常且状态不是错误，则更新为完成
             await self._update_exp_status(2)
 
+    async def pause_simulator(self):
+        await self._simulator.pause()
+
+    async def resume_simulator(self):
+        await self._simulator.resume()
+
     async def init_agents(
         self,
         agent_count: Union[int, list[int]],
         group_size: int = 10000,
         pg_sql_writers: int = 32,
+        message_interceptors: int = 1,
+        message_interceptor_blocks: Optional[list[MessageBlockBase]] = None,
+        social_black_list: Optional[list[tuple[str, str]]] = None,
+        message_listener: Optional[MessageBlockListenerBase] = None,
         embedding_model: Embeddings = SimpleEmbedding(),
         memory_config_func: Optional[Union[Callable, list[Callable]]] = None,
     ) -> None:
@@ -344,6 +400,8 @@ class AgentSimulation:
         Args:
             agent_count: 要创建的总智能体数量, 如果为列表，则每个元素表示一个智能体类创建的智能体数量
             group_size: 每个组的智能体数量，每一个组为一个独立的ray actor
+            pg_sql_writers: 独立的PgSQL writer数量
+            message_interceptors: message拦截器数量
             memory_config_func: 返回Memory配置的函数，需要返回(EXTRA_ATTRIBUTES, PROFILE, BASE)元组, 如果为列表，则每个元素表示一个智能体类创建的Memory配置函数
         """
         if not isinstance(agent_count, list):
@@ -353,12 +411,12 @@ class AgentSimulation:
             raise ValueError("agent_class和agent_count的长度不一致")
 
         if memory_config_func is None:
-            logger.warning(
-                "memory_config_func is None, using default memory config function"
-            )
             memory_config_func = self.default_memory_config_func
 
         elif not isinstance(memory_config_func, list):
+            logger.warning(
+                "memory_config_func is not a list, using specific memory config function"
+            )
             memory_config_func = [memory_config_func]
 
         if len(memory_config_func) != len(agent_count):
@@ -464,13 +522,12 @@ class AgentSimulation:
                         config_files,
                     )
                 )
-
         # 初始化mlflow连接
         _mlflow_config = self.config.get("metric_request", {}).get("mlflow")
         if _mlflow_config:
             mlflow_run_id, _ = init_mlflow_connection(
                 config=_mlflow_config,
-                mlflow_run_name=f"EXP_{self.exp_name}_{1000*int(time.time())}",
+                mlflow_run_name=f"{self.exp_name}_{1000*int(time.time())}",
                 experiment_name=self.exp_name,
             )
         else:
@@ -489,7 +546,31 @@ class AgentSimulation:
         else:
             _num_workers = 1
             self._pgsql_writers = _workers = [None for _ in range(_num_workers)]
-
+        # message interceptor
+        if message_listener is not None:
+            self._message_abort_listening_queue = _queue = ray.util.queue.Queue()  # type: ignore
+            await message_listener.set_queue(_queue)
+        else:
+            self._message_abort_listening_queue = _queue = None
+        _interceptor_blocks = message_interceptor_blocks
+        _black_list = [] if social_black_list is None else social_black_list
+        _llm_config = self.config.get("llm_request", {})
+        if message_interceptor_blocks is not None:
+            _num_interceptors = min(1, message_interceptors)
+            self._message_interceptors = _interceptors = [
+                MessageInterceptor.remote(
+                    _interceptor_blocks,  # type:ignore
+                    _black_list,
+                    _llm_config,
+                    _queue,
+                )
+                for _ in range(_num_interceptors)
+            ]
+        else:
+            _num_interceptors = 1
+            self._message_interceptors = _interceptors = [
+                None for _ in range(_num_interceptors)
+            ]
         creation_tasks = []
         for i, (
             agent_class,
@@ -504,13 +585,14 @@ class AgentSimulation:
                 number_of_agents,
                 memory_config_function_group,
                 self.config,
-                self.exp_id,
                 self.exp_name,
+                self.exp_id,
                 self.enable_avro,
                 self.avro_path,
                 self.enable_pgsql,
                 _workers[i % _num_workers],  # type:ignore
-                mlflow_run_id,  # type:ignore
+                self.message_interceptor,
+                mlflow_run_id,
                 embedding_model,
                 self.logging_level,
                 config_file,
@@ -536,16 +618,24 @@ class AgentSimulation:
                 self._type2group[agent_type].append(group)
 
         # 并行初始化所有组的agents
+        await self.resume_simulator()
         init_tasks = []
         for group in self._groups.values():
             init_tasks.append(group.init_agents.remote())
         ray.get(init_tasks)
+        await self.messager.connect.remote()  # type:ignore
+        await self.messager.subscribe.remote(  # type:ignore
+            [(f"exps/{self.exp_id}/user_payback", 1)], [self.exp_id]
+        )
+        await self.messager.start_listening.remote()  # type:ignore
 
-    async def gather(self, content: str):
+    async def gather(
+        self, content: str, target_agent_uuids: Optional[list[str]] = None
+    ):
         """收集智能体的特定信息"""
         gather_tasks = []
         for group in self._groups.values():
-            gather_tasks.append(group.gather.remote(content))
+            gather_tasks.append(group.gather.remote(content, target_agent_uuids))
         return await asyncio.gather(*gather_tasks)
 
     async def filter(
@@ -585,13 +675,13 @@ class AgentSimulation:
         self, survey: Survey, agent_uuids: Optional[list[str]] = None
     ):
         """发送问卷"""
-        await self.messager.connect()
+        await self.messager.connect.remote()  # type:ignore
         survey_dict = survey.to_dict()
         if agent_uuids is None:
             agent_uuids = self._agent_uuids
         _date_time = datetime.now(timezone.utc)
         payload = {
-            "from": "none",
+            "from": SURVEY_SENDER_UUID,
             "survey_id": survey_dict["id"],
             "timestamp": int(_date_time.timestamp() * 1000),
             "data": survey_dict,
@@ -599,16 +689,23 @@ class AgentSimulation:
         }
         for uuid in agent_uuids:
             topic = self._user_survey_topics[uuid]
-            await self.messager.send_message(topic, payload)
+            await self.messager.send_message.remote(topic, payload)  # type:ignore
+        remain_payback = len(agent_uuids)
+        while True:
+            messages = await self.messager.fetch_messages.remote()  # type:ignore
+            logger.info(f"Received {len(messages)} payback messages [survey]")
+            remain_payback -= len(messages)
+            if remain_payback <= 0:
+                break
+            await asyncio.sleep(3)
 
     async def send_interview_message(
         self, content: str, agent_uuids: Union[str, list[str]]
     ):
         """发送采访消息"""
-        await self.messager.connect()
         _date_time = datetime.now(timezone.utc)
         payload = {
-            "from": "none",
+            "from": SURVEY_SENDER_UUID,
             "content": content,
             "timestamp": int(_date_time.timestamp() * 1000),
             "_date_time": _date_time,
@@ -617,24 +714,72 @@ class AgentSimulation:
             agent_uuids = [agent_uuids]
         for uuid in agent_uuids:
             topic = self._user_chat_topics[uuid]
-            await self.messager.send_message(topic, payload)
+            await self.messager.send_message.remote(topic, payload)  # type:ignore
+        remain_payback = len(agent_uuids)
+        while True:
+            messages = await self.messager.fetch_messages.remote()  # type:ignore
+            logger.info(f"Received {len(messages)} payback messages [interview]")
+            remain_payback -= len(messages)
+            if remain_payback <= 0:
+                break
+            await asyncio.sleep(3)
+
+    async def extract_metric(self, metric_extractors: list[Callable]):
+        """提取指标"""
+        for metric_extractor in metric_extractors:
+            await metric_extractor(self)
 
     async def step(self):
-        """运行一步, 即每个智能体执行一次forward"""
+        """Run one step, each agent execute one forward"""
         try:
+            # check whether insert agents
+            simulator_day = await self._simulator.get_simulator_day()
+            print(
+                f"simulator_day: {simulator_day}, self._simulator_day: {self._simulator_day}"
+            )
+            need_insert_agents = False
+            if simulator_day > self._simulator_day:
+                need_insert_agents = True
+                self._simulator_day = simulator_day
+            if need_insert_agents:
+                await self.resume_simulator()
+                insert_tasks = []
+                for group in self._groups.values():
+                    insert_tasks.append(group.insert_agents.remote())
+                await asyncio.gather(*insert_tasks)
+
+            # step
             tasks = []
             for group in self._groups.values():
                 tasks.append(group.step.remote())
             await asyncio.gather(*tasks)
+            # save
+            simulator_day = await self._simulator.get_simulator_day()
+            simulator_time = int(await self._simulator.get_time())
+            save_tasks = []
+            for group in self._groups.values():
+                save_tasks.append(group.save.remote(simulator_day, simulator_time))
+            await asyncio.gather(*save_tasks)
+            self._total_steps += 1
+            if self.metric_extractor is not None:
+                print(f"total_steps: {self._total_steps}, excute metric")
+                to_excute_metric = [
+                    metric[1]
+                    for metric in self.metric_extractor
+                    if self._total_steps % metric[0] == 0
+                ]
+                await self.extract_metric(to_excute_metric)
         except Exception as e:
-            logger.error(f"运行错误: {str(e)}")
-            raise
+            import traceback
+
+            logger.error(f"模拟器运行错误: {str(e)}\n{traceback.format_exc()}")
+            raise RuntimeError(str(e)) from e
 
     async def run(
         self,
         day: int = 1,
     ):
-        """运行模拟器"""
+        """Run the simulation by days"""
         try:
             self._exp_info["num_day"] += day
             await self._update_exp_status(1)  # 更新状态为运行中
@@ -645,13 +790,14 @@ class AgentSimulation:
             monitor_task = asyncio.create_task(self._monitor_exp_status(stop_event))
 
             try:
-                for _ in range(day):
-                    tasks = []
-                    for group in self._groups.values():
-                        tasks.append(group.run.remote())
-                    # 等待所有group运行完成
-                    await asyncio.gather(*tasks)
-
+                end_time = (
+                    await self._simulator.get_time() + day * 24 * 3600
+                )  # type:ignore
+                while True:
+                    current_time = await self._simulator.get_time()
+                    if current_time >= end_time:  # type:ignore
+                        break
+                    await self.step()
             finally:
                 # 设置停止事件
                 stop_event.set()

pycityagent/simulation/storage/pg.py

@@ -71,11 +71,11 @@ class PgWriter:
 
     @lock_decorator
     async def async_write_status(self, rows: list[tuple]):
-        _tuple_types = [str, int, float, float, float, int, str, str, None]
+        _tuple_types = [str, int, float, float, float, int, list, str, str, None]
         table_name = f"socialcity_{self.exp_id.replace('-', '_')}_agent_status"
         async with await psycopg.AsyncConnection.connect(self._dsn) as aconn:
             copy_sql = psycopg.sql.SQL(
-                "COPY {} (id, day, t, lng, lat, parent_id, action, status, created_at) FROM STDIN"
+                "COPY {} (id, day, t, lng, lat, parent_id, friend_ids, action, status, created_at) FROM STDIN"
             ).format(psycopg.sql.Identifier(table_name))
             _rows: list[Any] = []
             async with aconn.cursor() as cur:

pycityagent/tools/tool.py

@@ -119,7 +119,7 @@ class SencePOI(Tool):
         if agent.memory is None or agent.simulator is None:
             raise ValueError("Memory or Simulator is not set.")
         if radius is None and category_prefix is None:
-            position = await agent.memory.get("position")
+            position = await agent.status.get("position")
             resp = []
             for prefix in self.category_prefix:
                 resp += agent.simulator.map.query_pois(
@@ -146,17 +146,15 @@ class UpdateWithSimulator(Tool):
         agent = self.agent
         if agent._simulator is None:
             return
-        if not agent._has_bound_to_simulator:
-            await agent._bind_to_simulator()  # type: ignore
         simulator = agent.simulator
-        memory = agent.memory
-        person_id = await memory.get("id")
+        status = agent.status
+        person_id = await status.get("id")
         resp = await simulator.get_person(person_id)
         resp_dict = resp["person"]
         for k, v in resp_dict.get("motion", {}).items():
             try:
-                await memory.get(k)
-                await memory.update(
+                await status.get(k)
+                await status.update(
                     k, v, mode="replace", protect_llm_read_only_fields=False
                 )
             except KeyError as e:
@@ -183,9 +181,9 @@ class ResetAgentPosition(Tool):
         s: Optional[float] = None,
     ):
         agent = self.agent
-        memory = agent.memory
+        status = agent.status
         await agent.simulator.reset_person_position(
-            person_id=await memory.get("id"),
+            person_id=await status.get("id"),
             aoi_id=aoi_id,
             poi_id=poi_id,
             lane_id=lane_id,

pycityagent/utils/__init__.py

@@ -1,11 +1,16 @@
 from .avro_schema import (DIALOG_SCHEMA, INSTITUTION_STATUS_SCHEMA,
                           PROFILE_SCHEMA, STATUS_SCHEMA, SURVEY_SCHEMA)
 from .pg_query import PGSQL_DICT, TO_UPDATE_EXP_INFO_KEYS_AND_TYPES
-from .survey_util import process_survey_for_llm
+from .survey_util import SURVEY_SENDER_UUID, process_survey_for_llm
 
 __all__ = [
-    "PROFILE_SCHEMA", "DIALOG_SCHEMA", "STATUS_SCHEMA", "SURVEY_SCHEMA", "INSTITUTION_STATUS_SCHEMA",
+    "PROFILE_SCHEMA",
+    "DIALOG_SCHEMA",
+    "STATUS_SCHEMA",
+    "SURVEY_SCHEMA",
+    "INSTITUTION_STATUS_SCHEMA",
     "process_survey_for_llm",
     "TO_UPDATE_EXP_INFO_KEYS_AND_TYPES",
     "PGSQL_DICT",
+    "SURVEY_SENDER_UUID",
 ]

pycityagent/utils/pg_query.py

@@ -54,6 +54,7 @@ PGSQL_DICT: dict[str, list[Any]] = {
         lng DOUBLE PRECISION,
         lat DOUBLE PRECISION,
         parent_id INT4,
+        friend_ids UUID[],
         action TEXT,
         status JSONB,
         created_at TIMESTAMPTZ

pycityagent/utils/survey_util.py

@@ -8,40 +8,40 @@ Survey Description: {survey_dict['description']}
 Please answer each question in the following format:
 
 """
-    
+
     question_count = 1
-    for page in survey_dict['pages']:
-        for question in page['elements']:
+    for page in survey_dict["pages"]:
+        for question in page["elements"]:
             prompt += f"Question {question_count}: {question['title']}\n"
-            
+
             # 根据不同类型的问题生成不同的提示
-            if question['type'] == 'radiogroup':
-                prompt += "Options: " + ", ".join(question['choices']) + "\n"
+            if question["type"] == "radiogroup":
+                prompt += "Options: " + ", ".join(question["choices"]) + "\n"
                 prompt += "Please select ONE option\n"
-            
-            elif question['type'] == 'checkbox':
-                prompt += "Options: " + ", ".join(question['choices']) + "\n"
+
+            elif question["type"] == "checkbox":
+                prompt += "Options: " + ", ".join(question["choices"]) + "\n"
                 prompt += "You can select MULTIPLE options\n"
-                
-            elif question['type'] == 'rating':
+
+            elif question["type"] == "rating":
                 prompt += f"Rating range: {question.get('min_rating', 1)} - {question.get('max_rating', 5)}\n"
                 prompt += "Please provide a rating within the range\n"
-                
-            elif question['type'] == 'matrix':
-                prompt += "Rows: " + ", ".join(question['rows']) + "\n"
-                prompt += "Columns: " + ", ".join(question['columns']) + "\n"
+
+            elif question["type"] == "matrix":
+                prompt += "Rows: " + ", ".join(question["rows"]) + "\n"
+                prompt += "Columns: " + ", ".join(question["columns"]) + "\n"
                 prompt += "Please select ONE column option for EACH row\n"
-                
-            elif question['type'] == 'text':
+
+            elif question["type"] == "text":
                 prompt += "Please provide a text response\n"
-                
-            elif question['type'] == 'boolean':
+
+            elif question["type"] == "boolean":
                 prompt += "Options: Yes, No\n"
                 prompt += "Please select either Yes or No\n"
-                
+
             prompt += "\nAnswer: [Your response here]\n\n---\n\n"
             question_count += 1
-            
+
     # 添加总结提示
     prompt += """Please ensure:
 1. All required questions are answered
@@ -49,5 +49,8 @@ Please answer each question in the following format:
 3. Answers are clear and specific
 
 Format your responses exactly as requested above."""
-    
-    return prompt
+
+    return prompt
+
+
+SURVEY_SENDER_UUID = "none"

pycityagent/workflow/block.py

@@ -146,6 +146,7 @@ def trigger_class():
 class Block:
     configurable_fields: list[str] = []
     default_values: dict[str, Any] = {}
+    fields_description: dict[str, str] = {}
 
     def __init__(
         self,
@@ -173,14 +174,20 @@ class Block:
 
     @classmethod
     def export_class_config(cls) -> dict[str, str]:
-        return {
-            field: cls.default_values.get(field, "default_value")
-            for field in cls.configurable_fields
-        }
+        return (
+            {
+                field: cls.default_values.get(field, "default_value")
+                for field in cls.configurable_fields
+            },
+            {
+                field: cls.fields_description.get(field, "")
+                for field in cls.configurable_fields
+            }
+        )
 
     @classmethod
     def import_config(cls, config: dict[str, Union[str, dict]]) -> Block:
-        instance = cls(name=config["name"])
+        instance = cls(name=config["name"])  # type: ignore
         assert isinstance(config["config"], dict)
         for field, value in config["config"].items():
             if field in cls.configurable_fields:
@@ -188,12 +195,12 @@ class Block:
 
         # 递归创建子Block
         for child_config in config.get("children", []):
-            child_block = Block.import_config(child_config)
+            child_block = Block.import_config(child_config)  # type: ignore
             setattr(instance, child_block.name.lower(), child_block)
 
         return instance
 
-    def load_from_config(self, config: dict[str, list[Dict]]) -> None:
+    def load_from_config(self, config: dict[str, list[dict]]) -> None:
         """
         使用配置更新当前Block实例的参数，并递归更新子Block。
         """

{pycityagent-2.0.0a52.dist-info → pycityagent-2.0.0a54.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: pycityagent
-Version: 2.0.0a52
+Version: 2.0.0a54
 Summary: LLM-based city environment agent building library
 Author-email: Yuwei Yan <pinkgranite86@gmail.com>, Junbo Yan <yanjb20thu@gmali.com>, Jun Zhang <zhangjun990222@gmali.com>
 License: MIT License
@@ -45,7 +45,7 @@ Requires-Dist: openai>=1.58.1
 Requires-Dist: Pillow<12.0.0,>=11.0.0
 Requires-Dist: protobuf<5.0.0,<=4.24.0
 Requires-Dist: pycitydata>=1.0.3
-Requires-Dist: pycityproto>=2.1.5
+Requires-Dist: pycityproto>=2.2.0
 Requires-Dist: requests>=2.32.3
 Requires-Dist: Shapely>=2.0.6
 Requires-Dist: PyYAML>=6.0.2