pycityagent 2.0.0a12__py3-none-any.whl → 2.0.0a14__py3-none-any.whl

pycityagent/simulation/simulation.py

@@ -1,18 +1,21 @@
 import asyncio
 import json
 import logging
+import os
+from pathlib import Path
 import uuid
 from datetime import datetime
 import random
 from typing import Dict, List, Optional, Callable, Union,Any
+import fastavro
 from mosstool.map._map_util.const import AOI_START_ID
 import pycityproto.city.economy.v2.economy_pb2 as economyv2
 from pycityagent.memory.memory import Memory
+from pycityagent.message.messager import Messager
+from pycityagent.survey import Survey
+from pycityagent.utils.avro_schema import PROFILE_SCHEMA, DIALOG_SCHEMA, STATUS_SCHEMA, SURVEY_SCHEMA
 
 from ..agent import Agent, InstitutionAgent
-from .interview import InterviewManager
-from .survey import QuestionType, SurveyManager
-from .ui import InterviewUI
 from .agentgroup import AgentGroup
 
 logger = logging.getLogger(__name__)
@@ -44,10 +47,34 @@ class AgentSimulation:
         self._groups: Dict[str, AgentGroup] = {}
         self._agent_uuid2group: Dict[uuid.UUID, AgentGroup] = {}
         self._agent_uuids: List[uuid.UUID] = []
-
+        self._user_chat_topics: Dict[uuid.UUID, str] = {}
+        self._user_survey_topics: Dict[uuid.UUID, str] = {}
+        self._user_interview_topics: Dict[uuid.UUID, str] = {}
         self._loop = asyncio.get_event_loop()
-        self._interview_manager = InterviewManager()
-        self._survey_manager = SurveyManager()
+
+        self._messager = Messager(
+            hostname=config["simulator_request"]["mqtt"]["server"],
+            port=config["simulator_request"]["mqtt"]["port"],
+            username=config["simulator_request"]["mqtt"].get("username", None),
+            password=config["simulator_request"]["mqtt"].get("password", None),
+        )
+        asyncio.create_task(self._messager.connect())
+
+        self._enable_avro = config["storage"]["avro"]["enabled"]
+        self._avro_path = Path(config["storage"]["avro"]["path"])
+        self._avro_file = {
+            "profile": self._avro_path / f"{self.exp_id}_profile.avro",
+            "dialog": self._avro_path / f"{self.exp_id}_dialog.avro",
+            "status": self._avro_path / f"{self.exp_id}_status.avro",
+            "survey": self._avro_path / f"{self.exp_id}_survey.avro",
+        }
+
+        self._enable_pgsql = config["storage"]["pgsql"]["enabled"]
+        self._pgsql_host = config["storage"]["pgsql"]["host"]
+        self._pgsql_port = config["storage"]["pgsql"]["port"]
+        self._pgsql_database = config["storage"]["pgsql"]["database"]
+        self._pgsql_user = config["storage"]["pgsql"]["user"]
+        self._pgsql_password = config["storage"]["pgsql"]["password"]
 
     @property
     def agents(self):
@@ -126,6 +153,7 @@ class AgentSimulation:
                 agent = agent_class(
                     name=agent_name,
                     memory=memory,
+                    avro_file=self._avro_file,
                 )
 
                 self._agents[agent._uuid] = agent
@@ -145,7 +173,7 @@ class AgentSimulation:
                 # 获取当前组的agents
                 agents = list(self._agents.values())[start_idx:end_idx]
                 group_name = f"AgentType_{i}_Group_{k}"
-                group = AgentGroup.remote(agents, self.config, self.exp_id)
+                group = AgentGroup.remote(agents, self.config, self.exp_id, self._avro_file)
                 self._groups[group_name] = group
                 for agent in agents:
                     self._agent_uuid2group[agent._uuid] = group
@@ -156,6 +184,42 @@ class AgentSimulation:
         for group in self._groups.values():
             init_tasks.append(group.init_agents.remote())
         await asyncio.gather(*init_tasks)
+        for uuid, agent in self._agents.items():
+            self._user_chat_topics[uuid] = f"exps/{self.exp_id}/agents/{uuid}/user-chat"
+            self._user_survey_topics[uuid] = f"exps/{self.exp_id}/agents/{uuid}/user-survey"
+
+        # save profile
+        if self._enable_avro:
+            self._avro_path.mkdir(parents=True, exist_ok=True)
+            # profile
+            filename = self._avro_file["profile"]
+            with open(filename, "wb") as f:
+                profiles = []
+                for agent in self._agents.values():
+                    profile = await agent.memory._profile.export()
+                    profile = profile[0]
+                    profile['id'] = str(agent._uuid)
+                    profiles.append(profile)
+                fastavro.writer(f, PROFILE_SCHEMA, profiles)
+
+            # dialog
+            filename = self._avro_file["dialog"]
+            with open(filename, "wb") as f:
+                dialogs = []
+                fastavro.writer(f, DIALOG_SCHEMA, dialogs)
+
+            # status
+            filename = self._avro_file["status"]
+            with open(filename, "wb") as f:
+                statuses = []
+                fastavro.writer(f, STATUS_SCHEMA, statuses)
+
+            # survey
+            filename = self._avro_file["survey"]
+            with open(filename, "wb") as f:
+                surveys = []
+                fastavro.writer(f, SURVEY_SCHEMA, surveys)
+
 
     async def gather(self, content: str):
         """收集智能体的特定信息"""
@@ -219,6 +283,7 @@ class AgentSimulation:
         }
 
         PROFILE = {
+            "name": "unknown",
             "gender": random.choice(["male", "female"]),
             "education": random.choice(
                 ["Doctor", "Master", "Bachelor", "College", "High School"]
@@ -251,7 +316,7 @@ class AgentSimulation:
             "personality": random.choice(
                 ["outgoint", "introvert", "ambivert", "extrovert"]
             ),
-            "income": random.randint(1000, 10000),
+            "income": str(random.randint(1000, 10000)),
             "currency": random.randint(10000, 100000),
             "residence": random.choice(["city", "suburb", "rural"]),
             "race": random.choice(
@@ -285,6 +350,32 @@ class AgentSimulation:
         }
 
         return EXTRA_ATTRIBUTES, PROFILE, BASE
+    
+    async def send_survey(self, survey: Survey, agent_uuids: Optional[List[uuid.UUID]] = None):
+        """发送问卷"""
+        survey = survey.to_dict()
+        if agent_uuids is None:
+            agent_uuids = self._agent_uuids
+        payload = {
+            "from": "none",
+            "survey_id": survey["id"],
+            "timestamp": int(datetime.now().timestamp() * 1000),
+            "data": survey,
+        }
+        for uuid in agent_uuids:
+            topic = self._user_survey_topics[uuid]
+            await self._messager.send_message(topic, payload)
+
+    async def send_interview_message(self, content: str, agent_uuids: Union[uuid.UUID, List[uuid.UUID]]):
+        """发送面试消息"""
+        payload = {
+            "from": "none",
+            "content": content,
+            "timestamp": int(datetime.now().timestamp() * 1000),
+        }
+        for uuid in agent_uuids:
+            topic = self._user_chat_topics[uuid]
+            await self._messager.send_message(topic, payload)
 
     async def step(self):
         """运行一步, 即每个智能体执行一次forward"""

pycityagent/survey/manager.py

@@ -0,0 +1,58 @@
+from typing import List, Dict, Optional
+from datetime import datetime
+import uuid
+import json
+from .models import Survey, Question, QuestionType, Page
+
+
+class SurveyManager:
+    def __init__(self):
+        self._surveys: Dict[str, Survey] = {}
+
+    def create_survey(
+        self, title: str, description: str, pages: List[dict]
+    ) -> Survey:
+        """创建新问卷"""
+        survey_id = uuid.uuid4()
+
+        # 转换页面和问题数据
+        survey_pages = []
+        for page_data in pages:
+            questions = []
+            for q in page_data["elements"]:
+                question = Question(
+                    name=q["name"],
+                    title=q["title"],
+                    type=QuestionType(q["type"]),
+                    required=q.get("required", True),
+                    choices=q.get("choices", []),
+                    columns=q.get("columns", []),
+                    rows=q.get("rows", []),
+                    min_rating=q.get("min_rating", 1),
+                    max_rating=q.get("max_rating", 5),
+                )
+                questions.append(question)
+            
+            page = Page(
+                name=page_data["name"],
+                elements=questions
+            )
+            survey_pages.append(page)
+
+        survey = Survey(
+            id=survey_id,
+            title=title,
+            description=description,
+            pages=survey_pages,
+        )
+
+        self._surveys[str(survey_id)] = survey
+        return survey
+
+    def get_survey(self, survey_id: str) -> Optional[Survey]:
+        """获取指定问卷"""
+        return self._surveys.get(survey_id)
+
+    def get_all_surveys(self) -> List[Survey]:
+        """获取所有问卷"""
+        return list(self._surveys.values())

pycityagent/survey/models.py

@@ -0,0 +1,120 @@
+from dataclasses import dataclass, field
+from typing import List, Dict, Optional
+from datetime import datetime
+from enum import Enum
+import uuid
+import json
+
+
+class QuestionType(Enum):
+    TEXT = "text"
+    RADIO = "radiogroup"
+    CHECKBOX = "checkbox"
+    BOOLEAN = "boolean"
+    RATING = "rating"
+    MATRIX = "matrix"
+
+
+@dataclass
+class Question:
+    name: str
+    title: str
+    type: QuestionType
+    choices: List[str] = field(default_factory=list)
+    columns: List[str] = field(default_factory=list)
+    rows: List[str] = field(default_factory=list)
+    min_rating: int = 1
+    max_rating: int = 5
+
+    def to_dict(self) -> dict:
+        base_dict = {
+            "type": self.type.value,
+            "name": self.name,
+            "title": self.title,
+        }
+        
+        if self.type in [QuestionType.RADIO, QuestionType.CHECKBOX]:
+            base_dict["choices"] = self.choices
+        elif self.type == QuestionType.MATRIX:
+            base_dict["columns"] = self.columns
+            base_dict["rows"] = self.rows
+        elif self.type == QuestionType.RATING:
+            base_dict["min_rating"] = self.min_rating
+            base_dict["max_rating"] = self.max_rating
+            
+        return base_dict
+
+
+@dataclass
+class Page:
+    name: str
+    elements: List[Question]
+
+    def to_dict(self) -> dict:
+        return {
+            "name": self.name,
+            "elements": [q.to_dict() for q in self.elements]
+        }
+
+
+@dataclass
+class Survey:
+    id: uuid.UUID
+    title: str
+    description: str
+    pages: List[Page]
+    responses: Dict[str, dict] = field(default_factory=dict)
+    created_at: datetime = field(default_factory=datetime.now)
+
+    def to_dict(self) -> dict:
+        return {
+            "id": str(self.id),
+            "title": self.title,
+            "description": self.description,
+            "pages": [p.to_dict() for p in self.pages],
+            "response_count": len(self.responses),
+        }
+
+    def to_json(self) -> str:
+        """Convert the survey to a JSON string for MQTT transmission"""
+        survey_dict = {
+            "id": str(self.id),
+            "title": self.title,
+            "description": self.description,
+            "pages": [p.to_dict() for p in self.pages],
+            "responses": self.responses,
+            "created_at": self.created_at.isoformat()
+        }
+        return json.dumps(survey_dict)
+
+    @classmethod
+    def from_json(cls, json_str: str) -> 'Survey':
+        """Create a Survey instance from a JSON string"""
+        data = json.loads(json_str)
+        pages = [
+            Page(
+                name=p["name"],
+                elements=[
+                    Question(
+                        name=q["name"],
+                        title=q["title"],
+                        type=QuestionType(q["type"]),
+                        required=q.get("required", True),
+                        choices=q.get("choices", []),
+                        columns=q.get("columns", []),
+                        rows=q.get("rows", []),
+                        min_rating=q.get("min_rating", 1),
+                        max_rating=q.get("max_rating", 5)
+                    ) for q in p["elements"]
+                ]
+            ) for p in data["pages"]
+        ]
+        
+        return cls(
+            id=uuid.UUID(data["id"]),
+            title=data["title"],
+            description=data["description"],
+            pages=pages,
+            responses=data.get("responses", {}),
+            created_at=datetime.fromisoformat(data["created_at"])
+        )

pycityagent/utils/__init__.py

@@ -0,0 +1,7 @@
+from .avro_schema import PROFILE_SCHEMA, DIALOG_SCHEMA, STATUS_SCHEMA, SURVEY_SCHEMA
+from .survey_util import process_survey_for_llm
+
+__all__ = [
+    "PROFILE_SCHEMA", "DIALOG_SCHEMA", "STATUS_SCHEMA", "SURVEY_SCHEMA",
+    "process_survey_for_llm"
+]

pycityagent/utils/avro_schema.py

@@ -0,0 +1,85 @@
+PROFILE_SCHEMA = {
+    "doc": "Agent属性",
+    "name": "AgentProfile",
+    "namespace": "com.socialcity",
+    "type": "record",
+    "fields": [
+        {"name": "id", "type": "string"},  # uuid as string
+        {"name": "name", "type": "string"},
+        {"name": "gender", "type": "string"},
+        {"name": "age", "type": "float"},
+        {"name": "education", "type": "string"},
+        {"name": "skill", "type": "string"},
+        {"name": "occupation", "type": "string"},
+        {"name": "family_consumption", "type": "string"},
+        {"name": "consumption", "type": "string"},
+        {"name": "personality", "type": "string"},
+        {"name": "income", "type": "string"},
+        {"name": "currency", "type": "float"},
+        {"name": "residence", "type": "string"},
+        {"name": "race", "type": "string"},
+        {"name": "religion", "type": "string"},
+        {"name": "marital_status", "type": "string"},
+    ],
+}
+
+DIALOG_SCHEMA = {
+    "doc": "Agent对话",
+    "name": "AgentDialog",
+    "namespace": "com.socialcity",
+    "type": "record",
+    "fields": [
+        {"name": "id", "type": "string"},  # uuid as string
+        {"name": "day", "type": "int"},
+        {"name": "t", "type": "float"},
+        {"name": "type", "type": "int"},
+        {"name": "speaker", "type": "string"},
+        {"name": "content", "type": "string"},
+        {
+            "name": "created_at",
+            "type": {"type": "long", "logicalType": "timestamp-millis"},
+        },
+    ],
+}
+
+STATUS_SCHEMA = {
+    "doc": "Agent状态",
+    "name": "AgentStatus",
+    "namespace": "com.socialcity",
+    "type": "record",
+    "fields": [
+        {"name": "id", "type": "string"},  # uuid as string
+        {"name": "day", "type": "int"},
+        {"name": "t", "type": "float"},
+        {"name": "lng", "type": "double"},
+        {"name": "lat", "type": "double"},
+        {"name": "parent_id", "type": "int"},
+        {"name": "action", "type": "string"},
+        {"name": "hungry", "type": "float"},
+        {"name": "tired", "type": "float"},
+        {"name": "safe", "type": "float"},
+        {"name": "social", "type": "float"},
+        {
+            "name": "created_at",
+            "type": {"type": "long", "logicalType": "timestamp-millis"},
+        },
+    ],
+}
+
+SURVEY_SCHEMA = {
+    "doc": "Agent问卷",
+    "name": "AgentSurvey",
+    "namespace": "com.socialcity",
+    "type": "record",
+    "fields": [
+        {"name": "id", "type": "string"},  # uuid as string
+        {"name": "day", "type": "int"},
+        {"name": "t", "type": "float"},
+        {"name": "survey_id", "type": "string"},
+        {"name": "result", "type": "string"},
+        {
+            "name": "created_at",
+            "type": {"type": "long", "logicalType": "timestamp-millis"},
+        },
+    ],
+}

pycityagent/utils/survey_util.py

@@ -0,0 +1,53 @@
+def process_survey_for_llm(survey_dict: dict) -> str:
+    """
+    将问卷字典转换为LLM可以逐题处理的格式，使用英文提示
+    """
+    prompt = f"""Survey Title: {survey_dict['title']}
+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']:
+            prompt += f"Question {question_count}: {question['title']}\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"
+                prompt += "You can select MULTIPLE options\n"
+                
+            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"
+                prompt += "Please select ONE column option for EACH row\n"
+                
+            elif question['type'] == 'text':
+                prompt += "Please provide a text response\n"
+                
+            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
+2. Responses match the question type requirements
+3. Answers are clear and specific
+
+Format your responses exactly as requested above."""
+    
+    return prompt

{pycityagent-2.0.0a12.dist-info → pycityagent-2.0.0a14.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: pycityagent
-Version: 2.0.0a12
+Version: 2.0.0a14
 Summary: LLM-based城市环境agent构建库
 License: MIT
 Author: Yuwei Yan
@@ -20,6 +20,7 @@ Requires-Dist: aiohttp (==3.10.10)
 Requires-Dist: aiomqtt (>=2.3.0,<3.0.0)
 Requires-Dist: citystreetview (==1.2.4)
 Requires-Dist: dashscope (==1.14.1)
+Requires-Dist: fastavro (>=1.10.0,<2.0.0)
 Requires-Dist: geojson (==3.1.0)
 Requires-Dist: gradio (>=5.7.1,<6.0.0)
 Requires-Dist: grpcio (==1.67.1)
@@ -28,6 +29,7 @@ Requires-Dist: mosstool (==1.0.24)
 Requires-Dist: networkx (==3.2.1)
 Requires-Dist: numpy (>=1.20.0,<2.0.0)
 Requires-Dist: openai (>=1.58.1,<2.0.0)
+Requires-Dist: pandavro (>=1.8.0,<2.0.0)
 Requires-Dist: poetry (>=1.2.2)
 Requires-Dist: protobuf (<=4.24.0)
 Requires-Dist: pycitydata (==1.0.0)

{pycityagent-2.0.0a12.dist-info → pycityagent-2.0.0a14.dist-info}/RECORD

@@ -1,7 +1,7 @@
 pycityagent/__init__.py,sha256=n56bWkAUEcvjDsb7LcJpaGjlrriSKPnR0yBhwRfEYBA,212
-pycityagent/agent.py,sha256=h0p9G5bLlfiv4yB8bkc9l2Z4jpa7s4uYVwAT4IrxusY,17396
+pycityagent/agent.py,sha256=0ZqHXImR05ETA0vt9t5GDS4AgYzza3-Zwuua2OckwTw,22788
 pycityagent/economy/__init__.py,sha256=aonY4WHnx-6EGJ4WKrx4S-2jAkYNLtqUA04jp6q8B7w,75
-pycityagent/economy/econ_client.py,sha256=qQb_kZneEXGBRaS_y5Jdoi95I8GyjKEsDSC4s6V6R7w,10829
+pycityagent/economy/econ_client.py,sha256=wcuNtcpkSijJwNkt2mXw3SshYy4SBy6qbvJ0VQ7Aovo,10854
 pycityagent/environment/__init__.py,sha256=awHxlOud-btWbk0FCS4RmGJ13W84oVCkbGfcrhKqihA,240
 pycityagent/environment/interact/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 pycityagent/environment/interact/interact.py,sha256=ifxPPzuHeqLHIZ_6zvfXMoBOnBsXNIP4bYp7OJ7pnEQ,6588
@@ -36,7 +36,7 @@ pycityagent/llm/llm.py,sha256=BtxBvPK4tb8QlZIfxO5XJ73lKXwF8L31LqVbejWB8eo,15121
 pycityagent/llm/llmconfig.py,sha256=4Ylf4OFSBEFy8jrOneeX0HvPhWEaF5jGvy1HkXK08Ro,436
 pycityagent/llm/utils.py,sha256=hoNPhvomb1u6lhFX0GctFipw74hVKb7bvUBDqwBzBYw,160
 pycityagent/memory/__init__.py,sha256=Hs2NhYpIG-lvpwPWwj4DydB1sxtjz7cuA4iDAzCXnjI,243
-pycityagent/memory/const.py,sha256=m9AidLs7Zu28StpvYetclqx-1qQcy3bYvwagcXB3a04,913
+pycityagent/memory/const.py,sha256=6zpJPJXWoH9-yf4RARYYff586agCoud9BRn7sPERB1g,932
 pycityagent/memory/memory.py,sha256=sDbaqr1Koqf_9joMtG9PmmVxJZ6Rq7nAZO6EO0OdVgo,18148
 pycityagent/memory/memory_base.py,sha256=bd2q0qNu5hCRd2u4cPxE3bBA2OaoAD1oR4-vbRdbd_s,5594
 pycityagent/memory/profile.py,sha256=s4LnxSPGSjIGZXHXkkd8mMa6uYYZrytgyQdWjcaqGf4,5182
@@ -46,25 +46,24 @@ pycityagent/memory/utils.py,sha256=wLNlNlZ-AY9VB8kbUIy0UQSYh26FOQABbhmKQkit5o8,8
 pycityagent/message/__init__.py,sha256=TCjazxqb5DVwbTu1fF0sNvaH_EPXVuj2XQ0p6W-QCLU,55
 pycityagent/message/messager.py,sha256=Iv4pK83JvHAQSZyGNACryPBey2wRoiok3Hb1eIwHbww,2506
 pycityagent/simulation/__init__.py,sha256=jYaqaNpzM5M_e_ykISS_M-mIyYdzJXJWhgpfBpA6l5k,111
-pycityagent/simulation/agentgroup.py,sha256=DzZooUZstnhObO3X7NjB9-8zBofEu_1NevaIhspuGME,6113
-pycityagent/simulation/interview.py,sha256=S2uv8MFCB4-u_4Q202VFoPJOIleqpKK9Piju0BDSb_0,1158
-pycityagent/simulation/simulation.py,sha256=4BHavfSHPM81Y5Su-MzzBYM0sR9cHRk4YOv-VkRkzrA,11595
-pycityagent/simulation/survey/__init__.py,sha256=rxwou8U9KeFSP7rMzXtmtp2fVFZxK4Trzi-psx9LPIs,153
-pycityagent/simulation/survey/manager.py,sha256=Tqini-4-uBZDsChVVL4ezlgXatnrxAfvceAZZRP8E48,2062
-pycityagent/simulation/survey/models.py,sha256=sY4OrrG1h9iBnjBsyDage4T3mUFPBHHZQe-ORtwSjKc,1305
-pycityagent/simulation/ui/__init__.py,sha256=4aevYl09KSku2NEpFZhyFNxI1qlswbrAFwhF_YhxFTo,62
-pycityagent/simulation/ui/interface.py,sha256=cSQRQhuA5Gj-X7anuN9tmRpG6-I8QYOuswjIWUeSvio,21636
-pycityagent/utils/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+pycityagent/simulation/agentgroup.py,sha256=ZJIeQbFmFwK3iUiwUpa4TG-k1Eb4vOTgy5ybv-CE1Rc,7797
+pycityagent/simulation/simulation.py,sha256=rDQRgKmJkjfeQtvXyW9LeqBVVX0iFh6snBEsdg1bCag,15574
+pycityagent/survey/__init__.py,sha256=rxwou8U9KeFSP7rMzXtmtp2fVFZxK4Trzi-psx9LPIs,153
+pycityagent/survey/manager.py,sha256=N4-Q8vve4L-PLaFikAgVB4Z8BNyFDEd6WjEk3AyMTgs,1764
+pycityagent/survey/models.py,sha256=Z2gHEazQRj0TkTz5qbh4Uy_JrU_FZGWpOLwjN0RoUrY,3547
+pycityagent/utils/__init__.py,sha256=_0AV01UAHp4pTj2mlJ4m8LTH0toWL9j3DouNC6sDuUQ,249
+pycityagent/utils/avro_schema.py,sha256=MsRG0CsYAn2UjSlSXgCF8-3076VywpALEmz1mW-UJB0,2789
 pycityagent/utils/decorators.py,sha256=Gk3r41hfk6awui40tbwpq3C7wC7jHaRmLRlcJFlLQCE,3160
 pycityagent/utils/parsers/__init__.py,sha256=AN2xgiPxszWK4rpX7zrqRsqNwfGF3WnCA5-PFTvbaKk,281
 pycityagent/utils/parsers/code_block_parser.py,sha256=Cs2Z_hm9VfNCpPPll1TwteaJF-HAQPs-3RApsOekFm4,1173
 pycityagent/utils/parsers/json_parser.py,sha256=FZ3XN1g8z4Dr2TFraUOoah1oQcze4fPd2m01hHoX0Mo,2917
 pycityagent/utils/parsers/parser_base.py,sha256=k6DVqwAMK3jJdOP4IeLE-aFPm3V2F-St5qRBuRdx4aU,1742
+pycityagent/utils/survey_util.py,sha256=Be9nptmu2JtesFNemPgORh_2GsN7rcDYGQS9Zfvc5OI,2169
 pycityagent/workflow/__init__.py,sha256=EyCcjB6LyBim-5iAOPe4m2qfvghEPqu1ZdGfy4KPeZ8,551
 pycityagent/workflow/block.py,sha256=6EmiRMLdOZC1wMlmLMIjfrp9TuiI7Gw4s3nnXVMbrnw,6031
 pycityagent/workflow/prompt.py,sha256=tY69nDO8fgYfF_dOA-iceR8pAhkYmCqoox8uRPqEuGY,2956
 pycityagent/workflow/tool.py,sha256=wD9WZ5rma6HCKugtHTwbShNE0f-Rjlwvn_1be3fCAsk,6682
 pycityagent/workflow/trigger.py,sha256=t5X_i0WtL32bipZSsq_E3UUyYYudYLxQUpvxbgClp2s,5683
-pycityagent-2.0.0a12.dist-info/METADATA,sha256=DNsYXJBF2nVXYdiNJrhDty3AwVMkqmPbnm_Ld-Vtt8k,7622
-pycityagent-2.0.0a12.dist-info/WHEEL,sha256=Nq82e9rUAnEjt98J6MlVmMCZb-t9cYE2Ir1kpBmnWfs,88
-pycityagent-2.0.0a12.dist-info/RECORD,,
+pycityagent-2.0.0a14.dist-info/METADATA,sha256=O6cGdAHKuG6W0Ya_Du_wEP8_xfM4xmOetYWb6rPj-WM,7705
+pycityagent-2.0.0a14.dist-info/WHEEL,sha256=Nq82e9rUAnEjt98J6MlVmMCZb-t9cYE2Ir1kpBmnWfs,88
+pycityagent-2.0.0a14.dist-info/RECORD,,

pycityagent/simulation/interview.py

@@ -1,40 +0,0 @@
-from dataclasses import dataclass
-from datetime import datetime
-from typing import List, Optional
-
-
-@dataclass
-class InterviewRecord:
-    """采访记录"""
-
-    timestamp: datetime
-    agent_name: str
-    question: str
-    response: str
-    blocking: bool
-
-
-class InterviewManager:
-    """采访管理器"""
-
-    def __init__(self):
-        self._history: List[InterviewRecord] = []
-
-    def add_record(self, agent_name: str, question: str, response: str, blocking: bool):
-        """添加采访记录"""
-        record = InterviewRecord(
-            timestamp=datetime.now(),
-            agent_name=agent_name,
-            question=question,
-            response=response,
-            blocking=blocking,
-        )
-        self._history.append(record)
-
-    def get_agent_history(self, agent_name: str) -> List[InterviewRecord]:
-        """获取指定智能体的采访历史"""
-        return [r for r in self._history if r.agent_name == agent_name]
-
-    def get_recent_history(self, limit: int = 10) -> List[InterviewRecord]:
-        """获取最近的采访记录"""
-        return sorted(self._history, key=lambda x: x.timestamp, reverse=True)[:limit]