pycityagent 2.0.0a66__cp312-cp312-macosx_11_0_arm64.whl → 2.0.0a67__cp312-cp312-macosx_11_0_arm64.whl

pycityagent/cityagent/blocks/social_block.py

@@ -1,19 +1,22 @@
-# 由于目前模拟器支持的限制，现在只有Dispatcher中只有NoneBlock,MessageBlock和FindPersonBlock。 
+# 由于目前模拟器支持的限制，现在只有Dispatcher中只有NoneBlock,MessageBlock和FindPersonBlock。
 
-import random
 import json
-from typing import Dict, Any, List, Optional
+import logging
+import random
+from typing import Any, Dict, List, Optional
+
+from pycityagent.environment.simulator import Simulator
 from pycityagent.llm.llm import LLM
-from pycityagent.workflow.block import Block
 from pycityagent.memory import Memory
-from pycityagent.environment.simulator import Simulator
+from pycityagent.workflow.block import Block
 from pycityagent.workflow.prompt import FormatPrompt
+
 from .dispatcher import BlockDispatcher
-from .utils import clean_json_response, TIME_ESTIMATE_PROMPT
-import logging
+from .utils import TIME_ESTIMATE_PROMPT, clean_json_response
 
 logger = logging.getLogger("pycityagent")
 
+
 class MessagePromptManager:
     def __init__(self, template: str, to_discuss: List[str]):
         self.template = template
@@ -30,8 +33,10 @@ class MessagePromptManager:
         discussion_constraint = ""
         if self.to_discuss:
             topics = ", ".join(f'"{topic}"' for topic in self.to_discuss)
-            discussion_constraint = f"Limit your discussion to the following topics: {topics}."
-        
+            discussion_constraint = (
+                f"Limit your discussion to the following topics: {topics}."
+            )
+
         # 格式化提示
         self.format_prompt.format(
             gender=await memory.status.get("gender") or "",
@@ -42,49 +47,63 @@ class MessagePromptManager:
             intention=step.get("intention", ""),
             emotion_types=await memory.status.get("emotion_types"),
             thought=await memory.status.get("thought"),
-            chat_history=chat_histories.get(target, "") if isinstance(chat_histories, dict) else "",
-            discussion_constraint=discussion_constraint
+            chat_history=(
+                chat_histories.get(target, "")
+                if isinstance(chat_histories, dict)
+                else ""
+            ),
+            discussion_constraint=discussion_constraint,
         )
-        
+
         return self.format_prompt.to_dialog()
 
+
 class SocialNoneBlock(Block):
     """
     空操作
     NoneBlock
     """
+
     def __init__(self, llm: LLM, memory: Memory):
         super().__init__("NoneBlock", llm=llm, memory=memory)
         self.description = "Handle all other cases"
         self.guidance_prompt = FormatPrompt(template=TIME_ESTIMATE_PROMPT)
 
     async def forward(self, step, context):
-        self.guidance_prompt.format(plan=context['plan'],
-                                    intention=step['intention'],
-                                    emotion_types=await self.memory.status.get("emotion_types"))
+        self.guidance_prompt.format(
+            plan=context["plan"],
+            intention=step["intention"],
+            emotion_types=await self.memory.status.get("emotion_types"),
+        )
         result = await self.llm.atext_request(self.guidance_prompt.to_dialog())
         result = clean_json_response(result)
         try:
             result = json.loads(result)
-            node_id = await self.memory.stream.add_social(description=f"I {step['intention']}")
+            node_id = await self.memory.stream.add_social(
+                description=f"I {step['intention']}"
+            )
             return {
-                'success': True,
-                'evaluation': f'Finished {step["intention"]}',
-                'consumed_time': result['time'],
-                'node_id': node_id
+                "success": True,
+                "evaluation": f'Finished {step["intention"]}',
+                "consumed_time": result["time"],
+                "node_id": node_id,
             }
         except Exception as e:
             logger.warning(f"解析时间评估响应时发生错误: {str(e)}, 原始结果: {result}")
-            node_id = await self.memory.stream.add_social(description=f"I failed to execute {step['intention']}")
+            node_id = await self.memory.stream.add_social(
+                description=f"I failed to execute {step['intention']}"
+            )
             return {
-                'success': False,
-                'evaluation': f'Failed to execute {step["intention"]}',
-                'consumed_time': 5,
-                'node_id': node_id
+                "success": False,
+                "evaluation": f'Failed to execute {step["intention"]}',
+                "consumed_time": 5,
+                "node_id": node_id,
             }
 
+
 class FindPersonBlock(Block):
     """寻找社交对象"""
+
     def __init__(self, llm: LLM, memory: Memory, simulator: Simulator):
         super().__init__("FindPersonBlock", llm=llm, memory=memory, simulator=simulator)
         self.description = "Find a suitable person to socialize with"
@@ -122,39 +141,42 @@ class FindPersonBlock(Block):
         ['offline', 2] - means meet the third friend offline
         """
 
-    async def forward(self, step: Dict[str, Any], context: Optional[Dict] = None) -> Dict[str, Any]:
+    async def forward(
+        self, step: Dict[str, Any], context: Optional[Dict] = None
+    ) -> Dict[str, Any]:
         try:
             # Get friends list and relationship strength
             friends = await self.memory.status.get("friends") or []
             relationships = await self.memory.status.get("relationships") or {}
-            
+
             if not friends:
-                node_id = await self.memory.stream.add_social(description=f"I can't find any friends to socialize with.")
+                node_id = await self.memory.stream.add_social(
+                    description=f"I can't find any friends to socialize with."
+                )
                 return {
-                    'success': False,
-                    'evaluation': 'No friends found in social network',
-                    'consumed_time': 5,
-                    'node_id': node_id
+                    "success": False,
+                    "evaluation": "No friends found in social network",
+                    "consumed_time": 5,
+                    "node_id": node_id,
                 }
-            
+
             # Create a list of friends with all information
             friend_info = []
             index_to_uuid = {}
-            
+
             for i, friend_id in enumerate(friends):
                 relationship_strength = relationships.get(friend_id, 0)
-                friend_info.append({
-                    'index': i,
-                    'relationship_strength': relationship_strength
-                })
+                friend_info.append(
+                    {"index": i, "relationship_strength": relationship_strength}
+                )
                 index_to_uuid[i] = friend_id
-            
+
             # Format friend information for easier reading
             formatted_friend_info = {
-                i: {'relationship_strength': info['relationship_strength']}
+                i: {"relationship_strength": info["relationship_strength"]}
                 for i, info in enumerate(friend_info)
             }
-            
+
             # Format the prompt
             formatted_prompt = FormatPrompt(self.prompt)
             formatted_prompt.format(
@@ -165,51 +187,66 @@ class FindPersonBlock(Block):
                 intention=str(step.get("intention", "socialize")),
                 emotion_types=str(await self.memory.status.get("emotion_types")),
                 thought=str(await self.memory.status.get("thought")),
-                friend_info=str(formatted_friend_info)
+                friend_info=str(formatted_friend_info),
             )
-            
+
             # Get LLM response
-            response = await self.llm.atext_request(formatted_prompt.to_dialog(), timeout=300)
-            
+            response = await self.llm.atext_request(
+                formatted_prompt.to_dialog(), timeout=300
+            )
+
             try:
                 # Parse the response
                 mode, friend_index = eval(response)
-                
+
                 # Validate the response format
-                if not isinstance(mode, str) or mode not in ['online', 'offline']:
+                if not isinstance(mode, str) or mode not in ["online", "offline"]:
                     raise ValueError("Invalid mode")
-                if not isinstance(friend_index, int) or friend_index not in index_to_uuid:
+                if (
+                    not isinstance(friend_index, int)
+                    or friend_index not in index_to_uuid
+                ):
                     raise ValueError("Invalid friend index")
-                
+
                 # Convert index to UUID
                 target = index_to_uuid[friend_index]
-                context['target']=target
+                context["target"] = target
             except Exception as e:
                 # If parsing fails, select the friend with the strongest relationship as the default option
-                target = max(relationships.items(), key=lambda x: x[1])[0] if relationships else friends[0]
-                mode = 'online'
-            
-            node_id = await self.memory.stream.add_social(description=f"I selected the friend {target} for {mode} interaction")
+                target = (
+                    max(relationships.items(), key=lambda x: x[1])[0]
+                    if relationships
+                    else friends[0]
+                )
+                mode = "online"
+
+            node_id = await self.memory.stream.add_social(
+                description=f"I selected the friend {target} for {mode} interaction"
+            )
             return {
-                'success': True,
-                'evaluation': f'Selected friend {target} for {mode} interaction',
-                'consumed_time': 15,
-                'mode': mode,
-                'target': target,
-                'node_id': node_id
+                "success": True,
+                "evaluation": f"Selected friend {target} for {mode} interaction",
+                "consumed_time": 15,
+                "mode": mode,
+                "target": target,
+                "node_id": node_id,
             }
-        
+
         except Exception as e:
-            node_id = await self.memory.stream.add_social(description=f"I can't find any friends to socialize with.")
+            node_id = await self.memory.stream.add_social(
+                description=f"I can't find any friends to socialize with."
+            )
             return {
-                'success': False,
-                'evaluation': f'Error in finding person: {str(e)}',
-                'consumed_time': 5,
-                'node_id': node_id
+                "success": False,
+                "evaluation": f"Error in finding person: {str(e)}",
+                "consumed_time": 5,
+                "node_id": node_id,
             }
 
+
 class MessageBlock(Block):
     """生成并发送消息"""
+
     def __init__(self, agent, llm: LLM, memory: Memory, simulator: Simulator):
         super().__init__("MessageBlock", llm=llm, memory=memory, simulator=simulator)
         self.agent = agent
@@ -235,44 +272,46 @@ class MessageBlock(Block):
         """
         self.to_discuss = []
 
-        self.prompt_manager = MessagePromptManager(self.default_message_template, self.to_discuss)
+        self.prompt_manager = MessagePromptManager(
+            self.default_message_template, self.to_discuss
+        )
 
     def _serialize_message(self, message: str, propagation_count: int) -> str:
         try:
-            return json.dumps({
-                "content": message,
-                "propagation_count": propagation_count
-            }, ensure_ascii=False)
+            return json.dumps(
+                {"content": message, "propagation_count": propagation_count},
+                ensure_ascii=False,
+            )
         except Exception as e:
             logger.warning(f"Error serializing message: {e}")
             return message
 
-    async def forward(self, step: Dict[str, Any], context: Optional[Dict] = None) -> Dict[str, Any]:
+    async def forward(
+        self, step: Dict[str, Any], context: Optional[Dict] = None
+    ) -> Dict[str, Any]:
         try:
             # Get target from context or find one
-            target = context.get('target') if context else None
+            target = context.get("target") if context else None
             if not target:
                 result = await self.find_person_block.forward(step, context)
-                if not result['success']:
+                if not result["success"]:
                     return {
-                        'success': False,
-                        'evaluation': 'Could not find target for message',
-                        'consumed_time': 5
+                        "success": False,
+                        "evaluation": "Could not find target for message",
+                        "consumed_time": 5,
                     }
-                target = result['target']
-            
+                target = result["target"]
+
             # Get formatted prompt using prompt manager
             formatted_prompt = await self.prompt_manager.get_prompt(
-                self.memory,
-                step,
-                target
+                self.memory, step, target
             )
-            
+
             # Generate message
             message = await self.llm.atext_request(formatted_prompt, timeout=300)
             if not message:
                 message = "Hello! How are you?"
-                
+
             # Update chat history with proper format
             chat_histories = await self.memory.status.get("chat_histories") or {}
             if not isinstance(chat_histories, dict):
@@ -282,32 +321,38 @@ class MessageBlock(Block):
             if chat_histories[target]:
                 chat_histories[target] += "，"
             chat_histories[target] += f"me: {message}"
-            
+
             await self.memory.status.update("chat_histories", chat_histories)
-            
+
             # Send message
             serialized_message = self._serialize_message(message, 1)
-            node_id = await self.memory.stream.add_social(description=f"I sent a message to {target}: {message}")
+            node_id = await self.memory.stream.add_social(
+                description=f"I sent a message to {target}: {message}"
+            )
             return {
-                'success': True,
-                'evaluation': f'Sent message to {target}: {message}',
-                'consumed_time': 10,
-                'message': message,
-                'target': target,
-                'node_id': node_id
+                "success": True,
+                "evaluation": f"Sent message to {target}: {message}",
+                "consumed_time": 10,
+                "message": message,
+                "target": target,
+                "node_id": node_id,
             }
-            
+
         except Exception as e:
-            node_id = await self.memory.stream.add_social(description=f"I can't send a message to {target}")
+            node_id = await self.memory.stream.add_social(
+                description=f"I can't send a message to {target}"
+            )
             return {
-                'success': False,
-                'evaluation': f'Error in sending message: {str(e)}',
-                'consumed_time': 5,
-                'node_id': node_id
+                "success": False,
+                "evaluation": f"Error in sending message: {str(e)}",
+                "consumed_time": 5,
+                "node_id": node_id,
             }
-        
+
+
 class SocialBlock(Block):
     """主社交模块"""
+
     find_person_block: FindPersonBlock
     message_block: MessageBlock
     noneblock: SocialNoneBlock
@@ -316,39 +361,45 @@ class SocialBlock(Block):
         super().__init__("SocialBlock", llm=llm, memory=memory, simulator=simulator)
         self.find_person_block = FindPersonBlock(llm, memory, simulator)
         self.message_block = MessageBlock(agent, llm, memory, simulator)
-        self.noneblock=SocialNoneBlock(llm, memory)
+        self.noneblock = SocialNoneBlock(llm, memory)
         self.dispatcher = BlockDispatcher(llm)
 
         self.trigger_time = 0
         self.token_consumption = 0
-        
-        self.dispatcher.register_blocks([
-            self.find_person_block,
-            self.message_block,
-            self.noneblock
-        ])
 
-    async def forward(self, step: Dict[str, Any], context: Optional[Dict] = None) -> Dict[str, Any]:
+        self.dispatcher.register_blocks(
+            [self.find_person_block, self.message_block, self.noneblock]
+        )
+
+    async def forward(
+        self, step: Dict[str, Any], context: Optional[Dict] = None
+    ) -> Dict[str, Any]:
         try:
             self.trigger_time += 1
-            consumption_start = self.llm.prompt_tokens_used + self.llm.completion_tokens_used
+            consumption_start = (
+                self.llm.prompt_tokens_used + self.llm.completion_tokens_used
+            )
 
             # Select the appropriate sub-block using dispatcher
             selected_block = await self.dispatcher.dispatch(step)
-            
+
             # Execute the selected sub-block and get the result
             result = await selected_block.forward(step, context)
-            
-            consumption_end = self.llm.prompt_tokens_used + self.llm.completion_tokens_used
+
+            consumption_end = (
+                self.llm.prompt_tokens_used + self.llm.completion_tokens_used
+            )
             self.token_consumption += consumption_end - consumption_start
 
             return result
 
         except:
-            consumption_end = self.llm.prompt_tokens_used + self.llm.completion_tokens_used
+            consumption_end = (
+                self.llm.prompt_tokens_used + self.llm.completion_tokens_used
+            )
             self.token_consumption += consumption_end - consumption_start
             return {
-                'success': True,
-                'evaluation': 'Completed social interaction with default behavior',
-                'consumed_time': 15
+                "success": True,
+                "evaluation": "Completed social interaction with default behavior",
+                "consumed_time": 15,
             }

pycityagent/cityagent/blocks/utils.py

@@ -1,5 +1,5 @@
-import re
 import ast
+import re
 
 TIME_ESTIMATE_PROMPT = """As an intelligent agent's time estimation system, please estimate the time needed to complete the current action based on the overall plan and current intention.
 
@@ -36,18 +36,24 @@ tao = 1
 period = 3
 UBI = 0
 
+
 def prettify_document(document: str) -> str:
     # Remove sequences of whitespace characters (including newlines)
-    cleaned = re.sub(r'\s+', ' ', document).strip()
+    cleaned = re.sub(r"\s+", " ", document).strip()
     return cleaned
 
+
 def extract_dict_from_string(input_string):
     """
     提取输入字符串中的字典。支持跨行字典和嵌套字典。
     """
     # 正则表达式查找所有可能的字典部分，允许多行
-    dict_pattern = r'\{(?:[^{}]|\{(?:[^{}]|\{[^{}]*\})*\})*\}'  # 匹配字典的正则表达式，支持嵌套
-    matches = re.findall(dict_pattern, input_string, re.DOTALL)  # re.DOTALL允许匹配换行符
+    dict_pattern = (
+        r"\{(?:[^{}]|\{(?:[^{}]|\{[^{}]*\})*\})*\}"  # 匹配字典的正则表达式，支持嵌套
+    )
+    matches = re.findall(
+        dict_pattern, input_string, re.DOTALL
+    )  # re.DOTALL允许匹配换行符
 
     dicts = []
 
@@ -62,7 +68,8 @@ def extract_dict_from_string(input_string):
 
     return dicts
 
+
 def clean_json_response(response: str) -> str:
     """清理LLM响应中的特殊字符"""
-    response = response.replace('```json', '').replace('```', '')
-    return response.strip() 
+    response = response.replace("```json", "").replace("```", "")
+    return response.strip()

pycityagent/cityagent/firmagent.py

@@ -1,9 +1,8 @@
-import asyncio
 from typing import Optional
 
 import numpy as np
 from pycityagent import Simulator, InstitutionAgent
-from pycityagent.llm.llm import LLM
+from pycityagent.llm import LLM
 from pycityagent.economy import EconomyClient
 from pycityagent.message import Messager
 from pycityagent.memory import Memory
@@ -19,6 +18,11 @@ class FirmAgent(InstitutionAgent):
         "max_price_inflation": 0.05,
         "max_wage_inflation": 0.05,
     }
+    fields_description = {
+        "time_diff": "Time difference between each forward, day * hour * minute * second",
+        "max_price_inflation": "Maximum price inflation rate",
+        "max_wage_inflation": "Maximum wage inflation rate",
+    }
 
     def __init__(
         self,
@@ -62,34 +66,14 @@ class FirmAgent(InstitutionAgent):
 
     async def forward(self):
         if await self.month_trigger():
-            employees = await self.memory.status.get("employees")
-            agents_forward = []
-            if not np.all(np.array(agents_forward) > self.forward_times):
-                return
-            goods_demand = await self.gather_messages(employees, "goods_demand")
-            goods_consumption = await self.gather_messages(
-                employees, "goods_consumption"
-            )
-            print(
-                f"goods_demand: {goods_demand}, goods_consumption: {goods_consumption}"
-            )
-            total_demand = sum(goods_demand)
-            last_inventory = sum(goods_consumption) + await self.economy_client.get(
-                self._agent_id, "inventory"
-            )
-            print(
-                f"total_demand: {total_demand}, last_inventory: {last_inventory}, goods_contumption: {sum(goods_consumption)}"
-            )
-            max_change_rate = (total_demand - last_inventory) / (
-                max(total_demand, last_inventory) + 1e-8
-            )
-            skills = await self.gather_messages(employees, "work_skill")
-            for skill, uuid in zip(skills, employees):
-                await self.send_message_to_agent(
-                    uuid,
-                    f"work_skill@{max(skill*(1 + np.random.uniform(0, max_change_rate*self.max_wage_inflation)), 1)}",
-                    "economy",
-                )
+            employees = await self.economy_client.get(self._agent_id, "employees")
+            total_demand = await self.economy_client.get(self._agent_id, "demand")
+            goods_consumption = await self.economy_client.get(self._agent_id, "sales")
+            last_inventory = goods_consumption + await self.economy_client.get(self._agent_id, "inventory")
+            max_change_rate = (total_demand - last_inventory) / (max(total_demand, last_inventory) + 1e-8)
+            skills = np.array(await self.economy_client.get(employees, "skill"))
+            skill_change_ratio = np.random.uniform(0, max_change_rate*self.max_wage_inflation)
+            await self.economy_client.update(employees, "skill", list(np.maximum(skills*(1 + skill_change_ratio), 1)))
             price = await self.economy_client.get(self._agent_id, "price")
             await self.economy_client.update(
                 self._agent_id,
@@ -105,8 +89,6 @@ class FirmAgent(InstitutionAgent):
                     1,
                 ),
             )
-            self.forward_times += 1
-            for uuid in employees:
-                await self.send_message_to_agent(
-                    uuid, f"firm_forward@{self.forward_times}", "economy"
-                )
+                
+            await self.economy_client.update(self._agent_id, 'demand', 0)
+            await self.economy_client.update(self._agent_id, 'sales', 0)

pycityagent/cityagent/governmentagent.py

@@ -20,7 +20,7 @@ class GovernmentAgent(InstitutionAgent):
         simulator: Optional[Simulator] = None,
         memory: Optional[Memory] = None,
         economy_client: Optional[EconomyClient] = None,
-        messager: Optional[Messager] = None,
+        messager: Optional[Messager] = None,# type:ignore
         avro_file: Optional[dict] = None,
     ) -> None:
         super().__init__(
@@ -42,12 +42,12 @@ class GovernmentAgent(InstitutionAgent):
         if self.last_time_trigger is None:
             self.last_time_trigger = now_time
             return False
-        if now_time - self.last_time_trigger >= self.time_diff:
+        if now_time - self.last_time_trigger >= self.time_diff:# type:ignore
             self.last_time_trigger = now_time
             return True
         return False
 
-    async def gather_messages(self, agent_ids, content):
+    async def gather_messages(self, agent_ids, content):# type:ignore
         infos = await super().gather_messages(agent_ids, content)
         return [info["content"] for info in infos]