pycityagent 1.1.9__py3-none-any.whl → 1.1.11__py3-none-any.whl

pycityagent/__init__.py

@@ -6,5 +6,6 @@ from .simulator import Simulator
 from .agent import Agent
 from .agent_citizen import CitizenAgent
 from .agent_func import FuncAgent
+from .agent_group import GroupAgent
 
-__all__ = [Simulator, Agent, CitizenAgent, FuncAgent]
+__all__ = [Simulator, Agent, CitizenAgent, FuncAgent, GroupAgent]

pycityagent/ac/__init__.py

@@ -5,4 +5,4 @@ from .action import *
 from .hub_actions import *
 from .sim_actions import *
 
-__all__ = [ActionController, Action, HubAction, SimAction, SendUserMessage, SendStreetview, SendPop, PositionUpdate, ShowPath, ShowPosition, SetSchedule, SendAgentMessage]
+__all__ = [ActionController, Action, HubAction, SimAction, SendUserMessage, SendStreetview, SendPop, ShowPath, ShowPosition, SetSchedule, SendAgentMessage]

pycityagent/ac/citizen_actions/trip.py

@@ -13,10 +13,9 @@ class TripAction(Action):
     async def Forward(self):
         now = self._agent.Scheduler.now
         if now.is_set:
-            # TODO: 目前仅支持传输一张图片至前端
             '''之前已经将schedule同步至模拟器了'''
-            if self._agent.Hub != None:
-                self._agent.Hub.Update(streetview=self._agent.Brain.Sence.sence_buffer['streetview'][0])
+            if self._agent.Hub != None and self._agent.Brain.Sence.sence_buffer['streetview'] != None:
+                self._agent.Hub.Update(streetview=self._agent.Brain.Sence.sence_buffer['streetview'])
         else:
             '''同步schedule至模拟器'''
             self._agent.Scheduler.now.is_set = True

pycityagent/ac/hub_actions.py

@@ -1,9 +1,12 @@
 """AppHub关联Action定义"""
 
-from typing import Callable, Optional, Any
+from typing import Callable, Optional, Any, Union
+from geojson import Feature, FeatureCollection, Point, LineString
+from shapely.geometry import mapping
 from pycitysim.apphub import AgentMessage
 from .action import HubAction
 from PIL.Image import Image
+from ..utils import *
 
 class SendUserMessage(HubAction):
     """
@@ -20,6 +23,8 @@ class SendUserMessage(HubAction):
             messages = self.get_source()
             if messages != None:
                 self._agent.Hub.Update(messages = messages)
+        else:
+            print("Error: without input data")
 
 class SendStreetview(HubAction):
     """
@@ -30,13 +35,14 @@ class SendStreetview(HubAction):
         super().__init__(agent, source, before)
 
     async def Forward(self, images: Optional[list[Image]] = None):
-        # TODO: 目前只支持发送一张图片
         if not images == None:
-            self._agent.Hub.Update(streetview = images[0])
+            self._agent.Hub.Update(streetview = images)
         elif self._source != None:
             images = self.get_source()
             if images != None:
-                self._agent.Hub.Update(streetview = images[0])
+                self._agent.Hub.Update(streetview = images)
+        else:
+            print("Error: without input data")
 
 class SendPop(HubAction):
     """
@@ -53,6 +59,8 @@ class SendPop(HubAction):
             pop = self.get_source()
             if pop != None:
                 self._agent.Hub.Update(pop = pop)
+        else:
+            print("Error: without input data")
 
 class PositionUpdate(HubAction):
     """
@@ -69,27 +77,219 @@ class PositionUpdate(HubAction):
             longlat = self.get_source()
             if longlat != None:
                 self._agent.Hub.Update(longlat = longlat)
+        else:
+            print("Error: without input data")
 
-class ShowPath(HubAction):
+class ShowPosition(HubAction):
     """
-    在地图上展示路径信息
-    Show a path in frontend map
+    在地图上展示特定地点
+    Show a position in frontend map
     """
     def __init__(self, agent, source: str = None, before: Callable[[list], Any] = None) -> None:
         super().__init__(agent, source, before)
 
-    async def Forward(self):
-        # TODO: 相关功能完善
-        pass
+    async def Forward(self, position: Union[int, list[float]], properties: Optional[dict]=None):
+        """
+        Args:
+        - position (Union[int, list[float]])
+            - int: 表示poi id
+            - list[float]: 具体的position经纬度坐标
+        - properties (Optional[dict]): 支持用户添加自定义属性, 默认为None
+            - 例如: {'description': "莲花超市"}
+        """
+        if isinstance(position, int):
+            # poi
+            if position in self._agent._simulator.map.pois:
+                poi = self._agent._simulator.map.pois[position]
+                lnglat_p = poi['shapely_lnglat']
+                position_feature = Feature(geometry=lnglat_p, properties=properties)
+                self._agent.Hub.ShowGeo(FeatureCollection([position_feature]))
+            else:
+                print("Error: wrong position (wrong poi id)")
+        else:
+            # longitude latitude
+            position_feature = Feature(geometry=Point(position), properties=properties)
+            self._agent.Hub.ShowGeo(FeatureCollection([position_feature]))
 
-class ShowPosition(HubAction):
+class ShowAoi(HubAction):
     """
-    在地图上展示特定地点
-    Show a position in frontend map
+    在地图上显示Aoi
+    Show aoi in map
     """
     def __init__(self, agent, source: str = None, before: Callable[[list], Any] = None) -> None:
         super().__init__(agent, source, before)
 
-    async def Forward(self):
-        # TODO: 相关功能完善
-        pass
+    async def Forward(self, aoi_id:int, properties: Optional[dict]=None):
+        """
+        Args:
+        - aoi_id (int): Aoi id
+        - properties (Optional[dict]): 支持用户添加自定义属性, 默认为None
+            - 例如: {'description': "我居住的小区"}
+        """
+        properties_default = {
+            "stroke-width": 2,
+            "stroke-opacity": 1,
+            "fill": "#ff2600",
+            "fill-opacity": 0.5
+        }
+        if properties != None:
+            properties_default.update(properties)
+        if aoi_id in self._agent._simulator.map.aois:
+            aoi = self._agent._simulator.map.aois[aoi_id]
+            lnglat_poly = aoi['shapely_lnglat']
+            aoi_feature = Feature(geometry=lnglat_poly, properties=properties_default)
+            self._agent.Hub.ShowGeo(FeatureCollection([aoi_feature]))
+        else:
+            print("Error: wrong aoi id")
+
+class ShowPath(HubAction):
+    """
+    在地图上展示路径信息
+    Show a path in frontend map
+    """
+    def __init__(self, agent, source: str = None, before: Callable[[list], Any] = None) -> None:
+        super().__init__(agent, source, before)
+
+    async def Forward(self, 
+                      path: Optional[Union[int, list[list[float]]]]=None, 
+                      start_end: Optional[Union[float, tuple[float, float]]]=None, 
+                      direction: Optional[str]='front', 
+                      properties: Optional[dict]=None):
+        """
+        Args:
+        - path (Optional[Union[int, list[list[float]]]]): 如果为None, 从Reason池中基于source拿取数据
+            - int: lane id
+            - list[list[float]]: path node
+        - start_end: (Optional[Union[float, tuple[float, float]]]): 指定显示范围, 如path是list[list[float]]形式则无效
+            - float: 如果仅包含一个float, 则展示从指定位置开始到path结尾的位置
+            - tuple[float, end]: 分别表示起点与终点
+        - direction (str): 指定前进方向, 支持['front', 'back'], 默认为'front'
+        - properties (Optional[dict]): 支持用户添加自定义属性, 默认为None
+        """
+        properties_default = {'stroke-width': 10, 'stroke-opacity': 0.5}
+        if properties != None:
+            properties_default.update(properties)
+        if path != None:
+            if isinstance(path, int):
+                # lane id
+                if path in self._agent._simulator.map.lanes:
+                    lane = self._agent._simulator.map.lanes[path]
+                    nodes = lane['center_line']['nodes']
+                    path_ls = mapping(lane['shapely_lnglat'])
+                    path_ls['coordinates'] = list(path_ls['coordinates'])
+                    for i in range(len(path_ls['coordinates'])):
+                        path_ls['coordinates'][i] = list(path_ls['coordinates'][i])
+                    # start-end与direction处理
+                    if isinstance(start_end, float):
+                        # start
+                        if direction == 'back':
+                            key_index = get_keyindex_in_lane(nodes, start_end, 'back')
+                            path_ls['coordinates'] = path_ls['coordinates'][:key_index+1]
+                            path_ls['coordinates'].reverse()
+                        else:
+                            key_index = get_keyindex_in_lane(nodes, start_end)
+                            path_ls['coordinates'] = path_ls['coordinates'][key_index:]
+
+                        path_ls['coordinates'][0] = [
+                                self._agent.motion['position']['longlat_position']['longitude'],
+                                self._agent.motion['position']['longlat_position']['latitude']
+                            ]
+                    elif isinstance(start_end, tuple) and len(start_end) == 2:
+                        # start - end
+                        start = start_end[0]
+                        end = start_end[1]
+                        if direction == 'back':
+                            keyIndex_s = get_keyindex_in_lane(nodes, start, 'back')
+                            keyIndex_e = get_keyindex_in_lane(nodes, end, 'back')
+                            path_ls['coordinates'] = path_ls['coordinates'][keyIndex_e:keyIndex_s+1]
+                            path_ls['coordinates'].reverse()
+                            xy = get_xy_in_lane(nodes, end, 'back')
+                            longlat = self._agent._simulator.map.xy2lnglat(x=xy[0], y=xy[1])
+                            path_ls['coordinates'].append([longlat[0], longlat[1]])
+                        else:
+                            keyIndex_s = get_keyindex_in_lane(nodes, start)
+                            keyIndex_e = get_keyindex_in_lane(nodes, end)
+                            path_ls['coordinates'] = path_ls['coordinates'][keyIndex_s:keyIndex_e+1]
+                            xy = get_xy_in_lane(nodes, end)
+                            longlat = self._agent._simulator.map.xy2lnglat(x=xy[0], y=xy[1])
+                            path_ls['coordinates'].append([longlat[0], longlat[1]])
+                        path_ls['coordinates'][0] = [
+                                    self._agent.motion['position']['longlat_position']['longitude'],
+                                    self._agent.motion['position']['longlat_position']['latitude']
+                                ]
+                    path_feature = Feature(geometry=path_ls, properties=properties_default)
+                    self._agent.Hub.ShowGeo(FeatureCollection([path_feature]))
+                else:
+                    print("Error: wrong path (wrong lane id)")
+            else:
+                # list point
+                path_ls = LineString(path)
+                path_feature = Feature(geometry=path_ls, properties=properties_default)
+                self._agent.Hub.ShowGeo(FeatureCollection([path_feature]))
+        elif self._source != None:
+            path_coll = self.get_source()
+            if path_coll != None:
+                path = path_coll['path']
+                start_end = path_coll['start_end']
+                direction = path_coll['direction']
+                properties = path_coll['properties']
+                if properties != None:
+                    properties_default.update(properties)
+                if isinstance(path, int):
+                    # lane id
+                    if path in self._agent._simulator.map.lanes:
+                        lane = self._agent._simulator.map.lanes[path]
+                        nodes = lane['center_line']['nodes']
+                        path_ls = mapping(lane['shapely_lnglat'])
+                        path_ls['coordinates'] = list(path_ls['coordinates'])
+                        for i in range(len(path_ls['coordinates'])):
+                            path_ls['coordinates'][i] = list(path_ls['coordinates'][i])
+                        # start-end与direction处理
+                        if isinstance(start_end, float):
+                            # start
+                            if direction == 'back':
+                                key_index = get_keyindex_in_lane(nodes, start_end, 'back')
+                                path_ls['coordinates'] = path_ls['coordinates'][:key_index+1]
+                                path_ls['coordinates'].reverse()
+                            else:
+                                key_index = get_keyindex_in_lane(nodes, start_end)
+                                path_ls['coordinates'] = path_ls['coordinates'][key_index:]
+
+                            path_ls['coordinates'][0] = [
+                                    self._agent.motion['position']['longlat_position']['longitude'],
+                                    self._agent.motion['position']['longlat_position']['latitude']
+                                ]
+                        elif isinstance(start_end, tuple) and len(start_end) == 2:
+                            # start - end
+                            start = start_end[0]
+                            end = start_end[1]
+                            if direction == 'back':
+                                keyIndex_s = get_keyindex_in_lane(nodes, start, 'back')
+                                keyIndex_e = get_keyindex_in_lane(nodes, end, 'back')
+                                path_ls['coordinates'] = path_ls['coordinates'][keyIndex_e:keyIndex_s+1]
+                                path_ls['coordinates'].reverse()
+                                xy = get_xy_in_lane(nodes, end, 'back')
+                                longlat = self._agent._simulator.map.xy2lnglat(x=xy[0], y=xy[1])
+                                path_ls['coordinates'].append([longlat[0], longlat[1]])
+                            else:
+                                keyIndex_s = get_keyindex_in_lane(nodes, start)
+                                keyIndex_e = get_keyindex_in_lane(nodes, end)
+                                path_ls['coordinates'] = path_ls['coordinates'][keyIndex_s:keyIndex_e+1]
+                                xy = get_xy_in_lane(nodes, end)
+                                longlat = self._agent._simulator.map.xy2lnglat(x=xy[0], y=xy[1])
+                                path_ls['coordinates'].append([longlat[0], longlat[1]])
+                            path_ls['coordinates'][0] = [
+                                        self._agent.motion['position']['longlat_position']['longitude'],
+                                        self._agent.motion['position']['longlat_position']['latitude']
+                                    ]
+                        path_feature = Feature(geometry=path_ls, properties=properties_default)
+                        self._agent.Hub.ShowGeo(FeatureCollection([path_feature]))
+                    else:
+                        print("Error: wrong path (wrong lane id)")
+                else:
+                    # list point
+                    path_ls = LineString(path)
+                    path_feature = Feature(geometry=path_ls, properties=properties_default)
+                    self._agent.Hub.ShowGeo(FeatureCollection([path_feature]))
+        else:
+            print("Error: without input")

pycityagent/agent.py

@@ -22,9 +22,11 @@ class AgentType:
 
     - Citizen = 1, 指城市居民类型agent——行动受城市规则限制
     - Func = 2, 功能型agent——行动规则宽松——本质上模拟器无法感知到Func类型的agent
+    - Group = 3, 群体智能体
     """
     Citizen = 1
     Func = 2
+    Group = 3
 
 class Template:
     """

pycityagent/agent_citizen.py

@@ -4,6 +4,8 @@ from pycityagent.urbanllm import UrbanLLM
 from .urbanllm import UrbanLLM
 from .agent import Agent, AgentType
 from .image.image import CitizenImage
+from .hubconnector import Waypoint
+import time
 
 class CitizenAgent(Agent):
     """
@@ -54,6 +56,8 @@ class CitizenAgent(Agent):
         - Schedule Init
         """
 
+        self._history_trajectory: list[Waypoint] = []
+
     def Bind(self):
         """
         - 将智能体绑定到AppHub
@@ -124,8 +128,12 @@ class CitizenAgent(Agent):
             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']
+            self.base = resp['person']['base']
+            self.motion = resp['person']['motion']
+            longitude = self.motion['position']['longlat_position']['longitude']
+            latitude = self.motion['position']['longlat_position']['latitude']
+            if self.state == 'trip':
+                self._history_trajectory.append(Waypoint([longitude, latitude], int(time.time())))
             # * 3. Brain工作流
             await self._brain.Run()
             # * 4. Commond Controller工作流

pycityagent/agent_func.py

@@ -1,10 +1,13 @@
 """FuncAgent: 功能性智能体及其定义"""
 
+from typing import Union
 from pycityagent.urbanllm import UrbanLLM
 from .urbanllm import UrbanLLM
 from .agent import Agent, AgentType
 from .image.image import Image
 from .ac.hub_actions import PositionUpdate
+from .utils import *
+from .hubconnector import Waypoint
 
 class FuncAgent(Agent):
     """
@@ -15,7 +18,6 @@ class FuncAgent(Agent):
     def __init__(
             self, 
             name:str, 
-            id: int,
             server:str, 
             soul:UrbanLLM=None, 
             simulator=None, 
@@ -32,12 +34,6 @@ class FuncAgent(Agent):
         """
 
         super().__init__(name, server, AgentType.Func, soul, simulator)
-        self._id = id
-        """
-        - 智能体Id
-        - Agent's id
-        """
-
         self._image = Image(self)
         """
         - Func Agent画像——支持自定义内容
@@ -63,23 +59,107 @@ class FuncAgent(Agent):
                 - x (double)
                 - y (double)
                 - z (double)
-        - direction (double): 方向角
+        - direction (double): 朝向-方向角
         """
 
-    async def init_position_aoi(self, aoi_id:int):
+        self._posUpdate = PositionUpdate(self)
+        self._history_trajectory:list[Waypoint] = []
+
+    async def set_position_aoi(self, aoi_id:int):
         """
-        - 将agent的位置初始化到指定aoi
-        - 根据指定aoi设置aoi_position, longlat_position以及xy_position
+        - 将agent的位置设定到指定aoi
+
+        Args:
+        - aoi_id (int): AOI id
         """
         if aoi_id in self._simulator.map.aois:
+            if 'aoi_position' in self.motion['position'].keys() and aoi_id == self.motion['position']['aoi_position']['aoi_id']:
+                return
             aoi = self._simulator.map.aois[aoi_id]
+            self.motion['position'] = {}
             self.motion['position']['aoi_position'] = {'aoi_id': aoi_id}
             self.motion['position']['longlat_position'] = {'longitude': aoi['shapely_lnglat'].centroid.coords[0][0], 'latitude': aoi['shapely_lnglat'].centroid.coords[0][1]}
+            # self._history_trajectory.append([self.motion['position']['longlat_position']['longitude'], self.motion['position']['longlat_position']['latitude']])
             x, y = self._simulator.map.lnglat2xy(lng=self.motion['position']['longlat_position']['longitude'], 
                                                  lat=self.motion['position']['longlat_position']['latitude'])
             self.motion['position']['xy_position'] = {'x': x, 'y': y}
-        pos = PositionUpdate(self)
-        await pos.Forward(longlat=[self.motion['position']['longlat_position']['longitude'], self.motion['position']['longlat_position']['latitude']])
+            await self._posUpdate.Forward(longlat=[self.motion['position']['longlat_position']['longitude'], self.motion['position']['longlat_position']['latitude']])
+        else:
+            print("Error: wrong aoi id")
+
+    async def set_position_lane(self, lane_id:int, s:float=0.0, direction:Union[float, str]='front'):
+        """
+        - 将agent的位置设定到指定lane
+        
+        Args:
+        - lane_id (int): Lane id
+        - s (float): distance from the start point of the lane, default None, if None, then set to the start point
+        - direction (Union[float, str]): agent方向角, 默认值为'front'
+            - float: 直接设置为给定方向角(atan2计算得到)
+            - str: 可选项['front', 'back'], 指定agent的行走方向
+                - 对于driving lane而言, 只能朝一个方向通行, 只能是'front'
+                - 对于walking lane而言, 可以朝两个方向通行, 可以是'front'或'back'
+        """
+        if lane_id in self._simulator.map.lanes:
+            if 'lane_position' in self.motion['position'].keys() and lane_id == self.motion['position']['lane_position']['lane_id']:
+                return
+            lane = self._simulator.map.lanes[lane_id]
+            if s > lane['length']:
+                print("Error: 's' too large")
+            self.motion['position'] = {}
+            self.motion['position']['lane_position'] = {'lane_id': lane_id, 's': s}
+            nodes = lane['center_line']['nodes']
+            x, y = get_xy_in_lane(nodes, s)
+            longlat = self._simulator.map.xy2lnglat(x=x, y=y)
+            self.motion['position']['longlat_position'] = {
+                'longitude': longlat[0],
+                'latitude': longlat[1]
+            }
+            self.motion['position']['xy_position'] = {
+                'x': x,
+                'y': y
+            }
+            if isinstance(direction, float):
+                self.motion['direction'] = direction
+            else:
+                # 计算方向角
+                direction_ = get_direction_by_s(nodes, s, direction)
+                self.motion['direction'] = direction_      
+            # self._history_trajectory.append([self.motion['position']['longlat_position']['longitude'], self.motion['position']['longlat_position']['latitude']])              
+            await self._posUpdate.Forward(longlat=[self.motion['position']['longlat_position']['longitude'], self.motion['position']['longlat_position']['latitude']])
+        else:
+            print("Error: wrong lane id")
+
+    async def set_position_poi(self, poi_id:int, hub:bool=True):
+        """
+        - 将agent的位置设定到指定poi
+
+        Args:
+        - poi_id (int): Poi id
+        """
+        if poi_id in self._simulator.map.pois:
+            poi = self._simulator.map.pois[poi_id]
+            aoi_id = poi['aoi_id']
+            if 'aoi_position' in self.motion['position'].keys() and aoi_id == self.motion['position']['aoi_position']['aoi_id']:
+                return
+            x = poi['position']['x']
+            y = poi['position']['y']
+            longlat = self._simulator.map.xy2lnglat(x=x, y=y)
+            self.motion['position'] = {}
+            self.motion['position']['aoi_position'] = {'aoi_id': aoi_id}
+            self.motion['position']['longlat_position'] = {
+                'longitude': longlat[0],
+                'latitude': longlat[1]
+            }
+            self.motion['position']['xy_position'] = {
+                'x': x,
+                'y': y
+            }
+            # self._history_trajectory.append([self.motion['position']['longlat_position']['longitude'], self.motion['position']['longlat_position']['latitude']])
+            if hub:
+                await self._posUpdate.Forward(longlat=[self.motion['position']['longlat_position']['longitude'], self.motion['position']['longlat_position']['latitude']])
+        else:
+            print("Error: wrong poi id")
 
     def Bind(self):
         """

pycityagent/agent_group.py

@@ -0,0 +1,84 @@
+"""GroupAgent群体智能体"""
+
+from typing import Union, Optional
+from pycityagent.urbanllm import UrbanLLM
+from .urbanllm import UrbanLLM
+from .agent import Agent, AgentType
+from .image.image import Image
+from .ac.hub_actions import PositionUpdate
+from .agent_func import FuncAgent
+from .utils import *
+
+class GroupAgent(Agent):
+    """
+    GroupAgent
+    群体智能体
+    """
+
+    def __init__(
+            self, 
+            name: str, 
+            soul: UrbanLLM = None, 
+            simulator=None
+        ) -> None:
+        super().__init__(name, simulator.config['simulator']['server'], AgentType.Group, soul, simulator)
+        self.agents:list[FuncAgent] = []
+        """
+        Agent列表
+        """
+
+    def add_agents(self, agents:Optional[list[FuncAgent]]=None, ids: Optional[Union[int, list[int], tuple]]=None, number:Optional[int]=1):
+        """
+        添加一个或多个智能体
+
+        Args:
+        - agents: FuncAgent列表
+        - ids: 智能体id
+            - int: 添加单个智能体
+            - list[int]: 添加多个智能体
+            - tuple(int, int): 根据范围确定添加智能体个数
+        - number: 智能体个数
+            - 与int类型ids参数配合使用
+        """
+        if agents != None:
+            self.agents = agents
+        elif isinstance(ids, int):
+            for i in range(number):
+                agent = FuncAgent(
+                    f"{self._name}_{ids+i}",
+                    ids+i,
+                    self._simulator.config['simulator']['server'],
+                    simulator=self._simulator
+                )
+                self.agents.append(agent)
+        elif isinstance(ids, list):
+            for id in ids:
+                agent = FuncAgent(
+                    f"{self._name}_{id}",
+                    id,
+                    self._simulator.config['simulator']['server'],
+                    simulator=self._simulator
+                )
+                self.agents.append(agent)
+        elif isinstance(ids, tuple):
+            if len(ids) == 2 and ids[0] <= ids[0]:
+                for i in range(ids[0], ids[1]+1):
+                    agent = FuncAgent(
+                        f"{self._name}_{i}",
+                        i,
+                        self._simulator.config['simulator']['server'],
+                        simulator=self._simulator
+                    )
+                    self.agents.append(agent)
+            else:
+                raise Exception(f"Error: wrong id tuple: {ids}")
+        else:
+            raise Exception("Wrong parameter")
+        
+    def ConnectToHub(self, config: dict):
+        for agent in self.agents:
+            agent.ConnectToHub(config)
+
+    def Bind(self):
+        for agent in self.agents:
+            agent.Bind()

pycityagent/brain/brain.py

@@ -18,6 +18,7 @@ class Brain:
         感知模块
         Sence module
         """
+        
         self._memory = MemoryController(agent)
         """
         记忆模块

pycityagent/brain/memory.py

@@ -440,21 +440,21 @@ class WorkingMemory(WMemory):
         """
         self.sence = sence
         # * social message
-        social_message = sence['social_messages']
-        for message in social_message:
-            print(message)
-            from_id = message['from']
-            content = message['message']
-            if from_id in self.msg_agent_unhandle.keys():
-                self.msg_agent_unhandle[from_id] += [{
-                    'role': 'user',
-                    'content': content
-                }]
-            else:
-                self.msg_agent_unhandle[from_id] = [{
-                    'role': 'user',
-                    'content': content
-                }]
+        # social_message = sence['social_messages']
+        # for message in social_message:
+        #     print(message)
+        #     from_id = message['from']
+        #     content = message['message']
+        #     if from_id in self.msg_agent_unhandle.keys():
+        #         self.msg_agent_unhandle[from_id] += [{
+        #             'role': 'user',
+        #             'content': content
+        #         }]
+        #     else:
+        #         self.msg_agent_unhandle[from_id] = [{
+        #             'role': 'user',
+        #             'content': content
+        #         }]
         # * user message
         self.msg_user_unhandle = sence['user_messages']
 

pycityagent/brain/scheduler.py

@@ -329,7 +329,7 @@ class Scheduler(BrainFunction):
                             self.schedule_set(True)
                 else:
                     # * 基本行程注册
-                    if self.base_schedule_index >=0 and self.base_schedule[self.base_schedule_index].time <= self._agent._simulator.time:
+                    if self.base_schedule_index >=0 and len(self.base_schedule) > 0 and self.base_schedule[self.base_schedule_index].time <= self._agent._simulator.time:
                         self.now = self.base_schedule[self.base_schedule_index]
                         if 'aoi_position' in self._agent.motion['position'].keys() and self._agent.motion['position']['aoi_position']['aoi_id'] == self.now.target_id_aoi:
                             # 直接跳过该行程