pycityagent 1.0.0__py3-none-any.whl → 2.0.0a2__py3-none-any.whl

pycityagent/__init__.py

@@ -1,4 +1,8 @@
-from .simulator import Simulator
-from .agent import Agent
+"""
+Pycityagent: 城市智能体构建框架
+"""
 
-__all__ = [Simulator, Agent]
+from .agent import Agent, CitizenAgent, InstitutionAgent
+from .environment import Simulator
+
+__all__ = ["Agent", "Simulator", "CitizenAgent", "InstitutionAgent"]

pycityagent/agent.py

@@ -1,318 +1,214 @@
+"""智能体模板类及其定义"""
+
 from abc import ABC, abstractmethod
-from typing import Optional, Union
-import PIL.Image as Image
-from PIL.Image import Image
-import asyncio
-import time
-from pycitysim.sim import CityClient
-
-from pycityagent.urbanllm import UrbanLLM
-from .urbanllm import UrbanLLM
-from .brain.brain import Brain
-from .hubconnector.hubconnector import HubConnector
-from .image.image import AgentImage
-from .ac.ac import ActionController
-from .cc.cc import CommondController
-from .st.st import StateTransformer
-
-
-class Template:
-    """
-    The basic template of Agent
-    """
-    def __init__(self, name, server, soul:UrbanLLM=None, simulator=None, id:int=None) -> None:
-        self.agent_name = name
-        self._client = CityClient(server)
-        self._soul = soul
-        self._simulator = simulator
-        self._id = id
+from datetime import datetime
+from enum import Enum
+from typing import Dict, List, Optional
 
-    def add_soul(self, llm_engine:UrbanLLM):
-        """
-        为Agent添加soul(UrbanLLM)
-        Add soul for Agent
+from .economy import EconomyClient
+from .environment import Simulator
+from .llm import LLM
+from .memory import Memory
 
-        Args:
-        - llm_engine (UrbanLLM): the soul
-        """
-        self._soul = llm_engine
 
-    def add_simulator(self, simulator):
-        """
-        添加关联模拟器
-        Add related simulator
+class AgentType(Enum):
+    """
+    Agent类型
 
-        Args:
-        - simulator (Simulator): the Simulator object
-        """
-        self._simulator = simulator
+    - Citizen, Citizen type agent
+    - Institution, Orgnization or institution type agent
+    """
 
-    @abstractmethod
-    def Step(self):
-        """模拟器执行接口"""
+    Unspecified = "Unspecified"
+    Citizen = "Citizen"
+    Institution = "Institution"
 
-class Agent(Template):
+
+class Agent(ABC):
     """
-    Agent
+    Agent base class
     """
+
     def __init__(
-            self, 
-            name:str, 
-            server:str, 
-            soul:UrbanLLM=None, 
-            simulator=None, 
-            id:int=None, 
-            base=None,
-            motion=None,
-            scratch_file:str=None,
-            selfie:bool = False,
-            connect_to_hub:bool=False,
-            hub_url:str=None,
-            app_id:int=None,
-            app_secret:str=None,
-            profile_img:str=None
-        ) -> None:
-        super().__init__(name, server, soul, simulator, id)
-        self.base = base
-        """
-        Agent/Person的基本属性, Agent指被代理的Person, Person指模拟器中的背景人
-        The base attributes of Agent/Person. Agent is the Person being represented. Persons are background persons in simulator
-        - https://cityproto.sim.fiblab.net/#city.agent.v2.Agent
-        """
-        self.motion = motion
-        """
-        Agent/Person的运动信息
-        The motion information of Agent/Person
-        - https://cityproto.sim.fiblab.net/#city.agent.v2.AgentMotion
-        """
-        if connect_to_hub:
-            self._hub_connector = HubConnector(
-                hub_url=hub_url,
-                app_id=app_id,
-                app_secret=app_secret,
-                agent=self,
-                profile_img=profile_img
-            )
-        else:
-            self._hub_connector = None
-        self._image = AgentImage(self, scratch_file, selfie)
-        """
-        Agent画像
-        The Agent's Image
+        self,
+        name: str,
+        type: AgentType = AgentType.Unspecified,
+        llm_client: Optional[LLM] = None,
+        economy_client: Optional[EconomyClient] = None,
+        simulator: Optional[Simulator] = None,
+        memory: Optional[Memory] = None,
+    ) -> None:
         """
-        self._brain = Brain(self)
-        """
-        Agent的大脑
-        The Agent's Brain
-        """
-        self._ac = ActionController(self)
-        """
-        Agent的行为控制器
-        The Agent's ActionController
-        """
-        self._cc = CommondController(self)
-        """
-        Agent的命令控制器
-        The Agent's CommondController
-        """
-        self._st = StateTransformer()
-        """
-        与Agent关联的状态转移器
-        The related StateTransformer
-        """
-        # * 默认trip构建
-        self.Scheduler.schedule_init()
-    
-    def ConnectToHub(self, config:dict):
-        """
-        与AppHub构建连接
-        Connect to AppHub
+        Initialize the Agent.
 
         Args:
-        - config (dict): the config dict of AppHub
-        """
-        profile_img = None
-        if 'profile_image' in config.keys():
-            profile_img = config['profile_image']
-        self._hub_connector = HubConnector(
-            hub_url=config['hub_url'],
-            app_id=config['app_id'],
-            app_secret=config['app_secret'],
-            agent=self,
-            profile_img=profile_img
-        )
-    
-    def enable_streetview(self):
-        """
-        开启街景相关功能
-        Enable Streetview function
-        """
-        self._brain.Sence.enable_streeview = True
+            name (str): The name of the agent.
+            type (AgentType): The type of the agent. Defaults to `AgentType.Unspecified`
+            llm_client (LLM): The language model client. Defaults to None.
+            economy_client (EconomyClient): The `EconomySim` client. Defaults to None.
+            simulator (Simulator, optional): The simulator object. Defaults to None.
+            memory (Memory, optional): The memory of the agent. Defaults to None.
+        """
+        self._name = name
+        self._type = type
+        self._llm_client = llm_client
+        self._economy_client = economy_client
+        self._simulator = simulator
+        self._memory = memory
+        self._has_bound_to_simulator = False
+        self._interview_history: List[Dict] = []  # 存储采访历史
 
-    def disable_streetview(self):
+    def set_memory(self, memory: Memory):
         """
-        关闭街景相关功能
-        Disable Streetview function
+        Set the memory of the agent.
         """
-        self._brain.Sence.enable_streeview = False
+        self._memory = memory
 
-    def enable_user_interaction(self):
+    def set_simulator(self, simulator: Simulator):
         """
-        开启用户交互功能(即在OpenCity控制台中与Agent进行交互)
-        Enable User Interaction function. The User Interaction function is the ability to interact with the related agent in OpenCity website console.
+        Set the simulator of the agent.
         """
-        self._brain.Memory.Working.enable_user_interaction = True
+        self._simulator = simulator
 
-    def disable_user_interaction(self):
+    def set_economy_client(self, economy_client: EconomyClient):
         """
-        关闭用户交互功能
-        Disable User Interaction function
+        Set the economy_client of the agent.
         """
-        self._brain.Memory.Working.enable_user_interaction = False
+        self._economy_client = economy_client
 
-    def enable_economy_behavior(self):
-        """
-        开启经济模拟相关功能(例如购物)
-        Enable Economy function. Shopping for instance.
-        """
-        self.Brain.Memory.Working.enable_economy = True
+    @property
+    def LLM(self):
+        """The Agent's LLM"""
+        if self._llm_client is None:
+            raise RuntimeError(
+                f"LLM access before assignment, please `set_llm_client` first!"
+            )
+        return self._llm_client
 
-    def disable_economy_behavior(self):
-        """
-        关闭经济模拟相关功能
-        Disable Economy function
-        """
-        self.Brain.Memory.Working.enable_economy = False
+    @property
+    def economy_client(self):
+        """The Agent's EconomyClient"""
+        if self._economy_client is None:
+            raise RuntimeError(
+                f"EconomyClient access before assignment, please `set_economy_client` first!"
+            )
+        return self._economy_client
 
-    def enable_social_behavior(self):
-        """
-        开启社交相关功能
-        Enable Social function
-        """
-        self.Brain.Memory.Working.enable_social = True
+    @property
+    def memory(self):
+        """The Agent's Memory"""
+        if self._memory is None:
+            raise RuntimeError(
+                f"Memory access before assignment, please `set_memory` first!"
+            )
+        return self._memory
 
-    def diable_social_behavior(self):
-        """
-        关闭社交相关功能
-        Disable Social function
-        """
-        self.Brain.Memory.Working.enable_social = False
+    @property
+    def simulator(self):
+        """The Simulator"""
+        if self._simulator is None:
+            raise RuntimeError(
+                f"Simulator access before assignment, please `set_simulator` first!"
+            )
+        return self._simulator
 
-    async def Pause(self):
-        """
-        暂停Agent行为使Agent进入'pause'状态
-        Pause the Agent, making the agent 'pause'
+    async def generate_response(self, question: str) -> str:
+        """生成回答
 
-        """
-        req = {'person_id': self.base['id'], 'schedules': []}
-        await self._client.person_service.SetSchedule(req)
-        self.Scheduler.unset_schedule()
-        self._st.trigger('pause')
+        基于智能体的记忆和当前状态，生成对问题的回答。
 
-    async def Active(self):
-        """
-        恢复Agent行为
-        Recover from 'pause'
-        """
-        self._st.pause_back()
+        Args:
+            question: 需要回答的问题
+
+        Returns:
+            str: 智能体的回答
+        """
+        dialog = []
+
+        # 添加系统提示
+        system_prompt = f"请以第一人称的方式回答问题,保持回答简洁明了。"
+        dialog.append({"role": "system", "content": system_prompt})
+
+        # 添加记忆上下文
+        if self._memory:
+            relevant_memories = await self._memory.search(question)
+            if relevant_memories:
+                dialog.append(
+                    {
+                        "role": "system",
+                        "content": f"基于以下记忆回答问题:\n{relevant_memories}",
+                    }
+                )
+
+        # 添加用户问题
+        dialog.append({"role": "user", "content": question})
+
+        # 使用LLM生成回答
+        if not self._llm_client:
+            return "抱歉，我现在无法回答问题。"
+
+        response = await self._llm_client.atext_request(dialog)  # type:ignore
+
+        # 记录采访历史
+        self._interview_history.append(
+            {
+                "timestamp": datetime.now().isoformat(),
+                "question": question,
+                "response": response,
+            }
+        )
 
-    async def Run(self, round:int=1, interval:int=1, log:bool=True):
-        """
-        Agent执行入口
-        The Agent Run entrance
+        return response  # type:ignore
 
-        Args:
-        - round (int): 执行步数. The steps to run.
-        - interval (int): 步与步之间的执行间隔, 单位秒. The interval between steps, second.
-        - log (bool): 是否输出log信息, 默认为True. Whether console log message, default: True
-        """
-        if self._soul == None:
-            print("Do not add soul yet. Try add_soul(UrbanLLM)")
-        await self.Step(log)
-        for i in range(0, round-1):
-            time.sleep(interval)
-            await self.Step(log)
-
-    async def Step(self, log:bool):
-        """
-        单步Agent执行流
-        Single step entrance
-        (Not recommended, use Run() method)
+    def get_interview_history(self) -> List[Dict]:
+        """获取采访历史记录"""
+        return self._interview_history
 
-        Args:
-        - log (bool): 是否输出log信息. Whether console log message
-        """
-        if self.state != 'paused':
-            # * 1. 模拟器时间更新
-            await self._simulator.GetTime()
-            # * 2. 拉取Agent最新状态
-            resp = await self._client.person_service.GetPerson({'person_id':self._id})
-            self.base = resp['base']
-            self.motion = resp['motion']
-            # * 3. Brain工作流
-            await self._brain.Run()
-            # * 4. Commond Controller工作流
-            commond = await self._cc.Run()
-            # * 5. State Transformer工作流
-            self._st.trigger(commond)
-            # * 6. Action Controller工作流
-            await self._ac.Run()
-        if log:
-            print(f"---------------------- SIM TIME: {self._simulator.time} ----------------------")
-            self.show_yourself()
-    
-    def show_yourself(self):
-        """
-        Log信息输出
-        Pring log message
-        """
-        print(f"【State Message】: {self.state}")
-        motion_message = ''''''
-        motion_message += f'''行为状态: {self.motion['status']}, '''
-        if 'lane_position' in self.motion['position'].keys():
-            motion_message += f'''位置信息: lane-{self.motion['position']['lane_position']['lane_id']}'''
-        else:
-            motion_message += f'''位置信息: aoi-{self.motion['position']['aoi_position']['aoi_id']}'''
-        motion_message += f'''-[x: {self.motion['position']['xy_position']['x']}, y: {self.motion['position']['xy_position']['y']}]'''
-        print(f'【Simulator Motion Message】: \n{motion_message}')
-        print(self.Scheduler)
-    
-    @property
-    def Image(self):
-        """The Agent's Image"""
-        return self._image
-    
-    @property
-    def Soul(self):
-        """The Agent's Soul(UrbanLLM)"""
-        return self._soul
-    
-    @property
-    def Brain(self):
-        """The Agent's Brain"""
-        return self._brain
-    
-    @property
-    def ActionController(self):
-        """The Agents's ActionController"""
-        return self._ac
+    @abstractmethod
+    async def forward(self) -> None:
+        """智能体行为逻辑"""
+        raise NotImplementedError
 
-    @property
-    def Scheduler(self):
-        """The Agent's Scheduler"""
-        return self._brain.Memory.Working.scheduler
-    
-    @property
-    def state(self):
-        """The state of the Agent"""
-        return self._st.state
-    
-    @property
-    def StateTransformer(self):
-        """The StateTransformer of the Agent"""
-        return self._st
 
-    @property
-    def Hub(self):
-        """The connected AppHub"""
-        return self._hub_connector
+class CitizenAgent(Agent):
+    """
+    CitizenAgent: 城市居民智能体类及其定义
+    """
+
+    def __init__(
+        self,
+        name: str,
+        llm_client: Optional[LLM] = None,
+        simulator: Optional[Simulator] = None,
+        memory: Optional[Memory] = None,
+    ) -> None:
+        super().__init__(
+            name,
+            AgentType.Citizen,
+            llm_client,
+            None,
+            simulator,
+            memory,
+        )
+
+
+class InstitutionAgent(Agent):
+    """
+    InstitutionAgent: 机构智能体类及其定义
+    """
+
+    def __init__(
+        self,
+        name: str,
+        llm_client: Optional[LLM] = None,
+        simulator: Optional[Simulator] = None,
+        memory: Optional[Memory] = None,
+    ) -> None:
+        super().__init__(
+            name,
+            AgentType.Institution,
+            llm_client,
+            None,
+            simulator,
+            memory,
+        )

pycityagent/economy/__init__.py

@@ -0,0 +1,5 @@
+from .econ_client import EconomyClient
+
+__all__ = [
+    "EconomyClient",
+]