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

pycityagent/memory/profile.py

@@ -0,0 +1,165 @@
+"""
+Agent Profile
+"""
+
+from copy import deepcopy
+from typing import (Any, Callable, Dict, List, Optional, Sequence, Tuple,
+                    Union, cast)
+
+from ..utils.decorators import lock_decorator
+from .const import *
+from .memory_base import MemoryBase, MemoryUnit
+from .utils import convert_msg_to_sequence
+
+
+class ProfileMemoryUnit(MemoryUnit):
+    def __init__(
+        self,
+        content: Optional[Dict] = None,
+        activate_timestamp: bool = False,
+    ) -> None:
+        super().__init__(
+            content=content,
+            required_attributes=PROFILE_ATTRIBUTES,
+            activate_timestamp=activate_timestamp,
+        )
+
+
+class ProfileMemory(MemoryBase):
+    def __init__(
+        self,
+        msg: Optional[
+            Union[ProfileMemoryUnit, Sequence[ProfileMemoryUnit], Dict, Sequence[Dict]]
+        ] = None,
+        activate_timestamp: bool = False,
+    ) -> None:
+        super().__init__()
+        if msg is None:
+            msg = deepcopy(PROFILE_ATTRIBUTES)
+        self.activate_timestamp = activate_timestamp
+        msg = convert_msg_to_sequence(
+            msg,
+            sequence_type=ProfileMemoryUnit,
+            activate_timestamp=self.activate_timestamp,
+        )
+        for unit in msg:
+            self._memories[unit] = {}
+
+    @lock_decorator
+    async def add(
+        self, msg: Union[ProfileMemoryUnit, Sequence[ProfileMemoryUnit]]
+    ) -> None:
+        _memories = self._memories
+        msg = convert_msg_to_sequence(
+            msg,
+            sequence_type=ProfileMemoryUnit,
+            activate_timestamp=self.activate_timestamp,
+        )
+        for unit in msg:
+            if unit not in _memories:
+                _memories[unit] = {}
+
+    @lock_decorator
+    async def pop(self, index: int) -> ProfileMemoryUnit:
+
+        _memories = self._memories
+        try:
+            pop_unit = list(_memories.keys())[index]
+            _memories.pop(pop_unit)
+
+            return pop_unit
+        except IndexError as e:
+
+            raise ValueError(f"Index {index} not in memory!")
+
+    @lock_decorator
+    async def load(
+        self,
+        snapshots: Union[Dict, Sequence[Dict]],
+        reset_memory: bool = False,
+    ) -> None:
+        if reset_memory:
+            self._memories = {}
+        msg = convert_msg_to_sequence(
+            snapshots,
+            sequence_type=ProfileMemoryUnit,
+            activate_timestamp=self.activate_timestamp,
+        )
+        for unit in msg:
+            if unit not in self._memories:
+                self._memories[unit] = {}
+
+    @lock_decorator
+    async def export(
+        self,
+    ) -> Sequence[Dict]:
+        _res = []
+        for m in self._memories.keys():
+            m = cast(ProfileMemoryUnit, m)
+            _dict_values = await m.dict_values()
+            _res.append(_dict_values)
+
+        return _res
+
+    async def reset(self) -> None:
+        self._memories = {}
+
+    # interact
+    @lock_decorator
+    async def get(self, key: Any):
+        _latest_memories = self._fetch_recent_memory()
+        _latest_memory: ProfileMemoryUnit = _latest_memories[-1]
+        return _latest_memory[key]
+
+    @lock_decorator
+    async def get_top_k(
+        self,
+        key: Any,
+        metric: Callable[[Any], Any],
+        top_k: Optional[int] = None,
+        preserve_order: bool = True,
+    ) -> Union[Sequence[Any], Any]:
+        _latest_memories = self._fetch_recent_memory()
+        _latest_memory: ProfileMemoryUnit = _latest_memories[-1]
+        _top_k = await _latest_memory.top_k_values(key, metric, top_k, preserve_order)
+
+        return _top_k
+
+    @lock_decorator
+    async def update(self, key: Any, value: Any, store_snapshot: bool = False):
+        _latest_memories = self._fetch_recent_memory()
+        _latest_memory: ProfileMemoryUnit = _latest_memories[-1]
+        if not store_snapshot:
+            # write in place
+            await _latest_memory.update({key: value})
+
+        else:
+            # insert new unit
+            _dict_values = await _latest_memory.dict_values()
+            _content = deepcopy(
+                {k: v for k, v in _dict_values.items() if k not in {TIME_STAMP_KEY}}
+            )
+            _content.update({key: value})
+            msg = ProfileMemoryUnit(_content, self.activate_timestamp)
+            for unit in [msg]:
+                if unit not in self._memories:
+                    self._memories[unit] = {}
+
+    @lock_decorator
+    async def update_dict(self, to_update_dict: Dict, store_snapshot: bool = False):
+        _latest_memories = self._fetch_recent_memory()
+        _latest_memory: ProfileMemoryUnit = _latest_memories[-1]
+        if not store_snapshot:
+            # write in place
+            await _latest_memory.update(to_update_dict)
+        else:
+            # insert new unit
+            _dict_values = await _latest_memory.dict_values()
+            _content = deepcopy(
+                {k: v for k, v in _dict_values.items() if k not in {TIME_STAMP_KEY}}
+            )
+            _content.update(to_update_dict)
+            msg = ProfileMemoryUnit(_content, self.activate_timestamp)
+            for unit in [msg]:
+                if unit not in self._memories:
+                    self._memories[unit] = {}

pycityagent/memory/self_define.py

@@ -0,0 +1,165 @@
+"""
+Self Define Data
+"""
+
+from copy import deepcopy
+from typing import (Any, Callable, Dict, List, Optional, Sequence, Tuple,
+                    Union, cast)
+
+from ..utils.decorators import lock_decorator
+from .const import *
+from .memory_base import MemoryBase, MemoryUnit
+from .utils import convert_msg_to_sequence
+
+
+class DynamicMemoryUnit(MemoryUnit):
+    def __init__(
+        self,
+        content: Optional[Dict] = None,
+        required_attributes: Optional[Dict] = None,
+        activate_timestamp: bool = False,
+    ) -> None:
+        super().__init__(
+            content=content,
+            required_attributes=required_attributes,
+            activate_timestamp=activate_timestamp,
+        )
+
+
+class DynamicMemory(MemoryBase):
+
+    def __init__(
+        self,
+        required_attributes: Dict[Any, Any],
+        activate_timestamp: bool = False,
+    ) -> None:
+        super().__init__()
+        self._required_attributes = deepcopy(required_attributes)
+        self.activate_timestamp = activate_timestamp
+        msg = DynamicMemoryUnit(
+            self._required_attributes, None, self.activate_timestamp
+        )
+        self._memories[msg] = {}
+
+    @lock_decorator
+    async def add(
+        self, msg: Union[DynamicMemoryUnit, Sequence[DynamicMemoryUnit]]
+    ) -> None:
+        _memories = self._memories
+        msg = convert_msg_to_sequence(
+            msg,
+            sequence_type=DynamicMemoryUnit,
+            activate_timestamp=self.activate_timestamp,
+        )
+        for unit in msg:
+            if unit not in _memories:
+                _memories[unit] = {}
+
+    @lock_decorator
+    async def pop(self, index: int) -> DynamicMemoryUnit:
+        _memories = self._memories
+        try:
+            pop_unit = list(_memories.keys())[index]
+            _memories.pop(pop_unit)
+
+            return pop_unit
+        except IndexError as e:
+
+            raise ValueError(f"Index {index} not in memory!")
+
+    @lock_decorator
+    async def load(
+        self,
+        snapshots: Union[Dict, Sequence[Dict]],
+        reset_memory: bool = False,
+    ) -> None:
+        if reset_memory:
+            self._memories = {}
+        msg = convert_msg_to_sequence(
+            snapshots,
+            sequence_type=DynamicMemoryUnit,
+            activate_timestamp=self.activate_timestamp,
+        )
+        for unit in msg:
+            if unit not in self._memories:
+                self._memories[unit] = {}
+
+    @lock_decorator
+    async def export(
+        self,
+    ) -> Sequence[Dict]:
+        _res = []
+        for m in self._memories.keys():
+            m = cast(DynamicMemoryUnit, m)
+            _dict_values = await m.dict_values()
+            _res.append(_dict_values)
+
+        return _res
+
+    async def reset(self) -> None:
+        self._memories = {}
+
+    # interact
+    @lock_decorator
+    async def get(self, key: Any):
+        _latest_memories = self._fetch_recent_memory()
+        _latest_memory: DynamicMemoryUnit = _latest_memories[-1]
+
+        return _latest_memory[key]
+
+    @lock_decorator
+    async def get_top_k(
+        self,
+        key: Any,
+        metric: Callable[[Any], Any],
+        top_k: Optional[int] = None,
+        preserve_order: bool = True,
+    ) -> Union[Sequence[Any], Any]:
+        _latest_memories = self._fetch_recent_memory()
+        _latest_memory: DynamicMemoryUnit = _latest_memories[-1]
+        _top_k = await _latest_memory.top_k_values(key, metric, top_k, preserve_order)
+
+        return _top_k
+
+    @lock_decorator
+    async def update(self, key: Any, value: Any, store_snapshot: bool = False):
+        _latest_memories = self._fetch_recent_memory()
+        _latest_memory: DynamicMemoryUnit = _latest_memories[-1]
+        if not store_snapshot:
+            # write in place
+            await _latest_memory.update({key: value})
+
+        else:
+            # insert new unit
+            _dict_values = await _latest_memory.dict_values()
+            _content = deepcopy(
+                {k: v for k, v in _dict_values.items() if k not in {TIME_STAMP_KEY}}
+            )
+            _content.update({key: value})
+            msg = DynamicMemoryUnit(
+                _content, self._required_attributes, self.activate_timestamp
+            )
+            for unit in [msg]:
+                if unit not in self._memories:
+                    self._memories[unit] = {}
+
+    @lock_decorator
+    async def update_dict(self, to_update_dict: Dict, store_snapshot: bool = False):
+        _latest_memories = self._fetch_recent_memory()
+        _latest_memory: DynamicMemoryUnit = _latest_memories[-1]
+        if not store_snapshot:
+            # write in place
+            await _latest_memory.update(to_update_dict)
+        else:
+            # insert new unit
+            _dict_values = await _latest_memory.dict_values()
+            _content = deepcopy(
+                {k: v for k, v in _dict_values.items() if k not in {TIME_STAMP_KEY}}
+            )
+            _content.update(to_update_dict)
+            msg = DynamicMemoryUnit(
+                _content, self._required_attributes, self.activate_timestamp
+            )
+            for unit in [msg]:
+                if unit not in self._memories:
+                    self._memories[unit] = {}

pycityagent/memory/state.py

@@ -0,0 +1,173 @@
+"""
+Agent State
+"""
+
+from copy import deepcopy
+from typing import (Any, Callable, Dict, List, Optional, Sequence, Tuple,
+                    Union, cast)
+
+from ..utils.decorators import lock_decorator
+from .const import *
+from .memory_base import MemoryBase, MemoryUnit
+from .utils import convert_msg_to_sequence
+
+
+class StateMemoryUnit(MemoryUnit):
+    def __init__(
+        self,
+        content: Optional[Dict] = None,
+        activate_timestamp: bool = False,
+    ) -> None:
+        super().__init__(
+            content=content,
+            required_attributes=STATE_ATTRIBUTES,
+            activate_timestamp=activate_timestamp,
+        )
+
+
+class StateMemory(MemoryBase):
+    def __init__(
+        self,
+        msg: Optional[
+            Union[MemoryUnit, Sequence[MemoryUnit], Dict, Sequence[Dict]]
+        ] = None,
+        activate_timestamp: bool = False,
+    ) -> None:
+        super().__init__()
+        if msg is None:
+            msg = deepcopy(STATE_ATTRIBUTES)
+        self.activate_timestamp = activate_timestamp
+        msg = convert_msg_to_sequence(
+            msg,
+            sequence_type=StateMemoryUnit,
+            activate_timestamp=self.activate_timestamp,
+        )
+        for unit in msg:
+            self._memories[unit] = {}
+
+    @lock_decorator
+    async def add(self, msg: Union[MemoryUnit, Sequence[MemoryUnit]]) -> None:
+
+        _memories = self._memories
+        msg = convert_msg_to_sequence(
+            msg,
+            sequence_type=StateMemoryUnit,
+            activate_timestamp=self.activate_timestamp,
+        )
+        for unit in msg:
+            if unit not in _memories:
+                _memories[unit] = {}
+
+    @lock_decorator
+    async def pop(self, index: int) -> MemoryUnit:
+
+        _memories = self._memories
+        try:
+            pop_unit = list(_memories.keys())[index]
+            _memories.pop(pop_unit)
+
+            return pop_unit
+        except IndexError as e:
+
+            raise ValueError(f"Index {index} not in memory!")
+
+    @lock_decorator
+    async def load(
+        self,
+        snapshots: Union[Dict, Sequence[Dict]],
+        reset_memory: bool = False,
+    ) -> None:
+
+        if reset_memory:
+            self._memories = {}
+        msg = convert_msg_to_sequence(
+            snapshots,
+            sequence_type=StateMemoryUnit,
+            activate_timestamp=self.activate_timestamp,
+        )
+        for unit in msg:
+            if unit not in self._memories:
+                self._memories[unit] = {}
+
+    @lock_decorator
+    async def export(
+        self,
+    ) -> Sequence[Dict]:
+
+        _res = []
+        for m in self._memories.keys():
+            m = cast(StateMemoryUnit, m)
+            _dict_values = await m.dict_values()
+            _res.append(_dict_values)
+
+        return _res
+
+    async def reset(self) -> None:
+
+        self._memories = {}
+
+    # interact
+    @lock_decorator
+    async def get(self, key: Any):
+
+        _latest_memories = self._fetch_recent_memory()
+        _latest_memory: StateMemoryUnit = _latest_memories[-1]
+
+        return _latest_memory[key]
+
+    @lock_decorator
+    async def get_top_k(
+        self,
+        key: Any,
+        metric: Callable[[Any], Any],
+        top_k: Optional[int] = None,
+        preserve_order: bool = True,
+    ) -> Union[Sequence[Any], Any]:
+
+        _latest_memories = self._fetch_recent_memory()
+        _latest_memory: StateMemoryUnit = _latest_memories[-1]
+        _top_k = await _latest_memory.top_k_values(key, metric, top_k, preserve_order)
+
+        return _top_k
+
+    @lock_decorator
+    async def update(self, key: Any, value: Any, store_snapshot: bool = False):
+
+        _latest_memories = self._fetch_recent_memory()
+        _latest_memory: StateMemoryUnit = _latest_memories[-1]
+        if not store_snapshot:
+            # write in place
+            await _latest_memory.update({key: value})
+
+        else:
+            # insert new unit
+            _dict_values = await _latest_memory.dict_values()
+            _content = deepcopy(
+                {k: v for k, v in _dict_values.items() if k not in {TIME_STAMP_KEY}}
+            )
+            _content.update({key: value})
+            msg = StateMemoryUnit(_content, self.activate_timestamp)
+            for unit in [msg]:
+                if unit not in self._memories:
+                    self._memories[unit] = {}
+
+    @lock_decorator
+    async def update_dict(self, to_update_dict: Dict, store_snapshot: bool = False):
+
+        _latest_memories = self._fetch_recent_memory()
+        _latest_memory: StateMemoryUnit = _latest_memories[-1]
+        if not store_snapshot:
+            # write in place
+            await _latest_memory.update(to_update_dict)
+
+        else:
+            # insert new unit
+            _dict_values = await _latest_memory.dict_values()
+            _content = deepcopy(
+                {k: v for k, v in _dict_values.items() if k not in {TIME_STAMP_KEY}}
+            )
+            _content.update(to_update_dict)
+            msg = StateMemoryUnit(_content, self.activate_timestamp)
+            for unit in [msg]:
+                if unit not in self._memories:
+                    self._memories[unit] = {}

pycityagent/memory/utils.py

@@ -0,0 +1,27 @@
+from typing import Any, Dict, List, Optional, Sequence, Tuple, Union
+
+from .memory_base import MemoryUnit
+
+
+def convert_msg_to_sequence(
+    msg: Union[Any, Sequence[Any]],
+    sequence_type=MemoryUnit,
+    activate_timestamp: bool = False,
+) -> Sequence[Any]:
+    # Convert the input message to a sequence if it is not already one
+    if not isinstance(msg, Sequence):
+        _sequence_msg = [msg]
+    else:
+        _sequence_msg = msg
+
+    # Initialize an empty list to store the converted MemoryUnit objects
+    _sequence_unit = []
+
+    # Iterate over each unit in the sequence
+    for unit in _sequence_msg:
+        # If the unit is not already a MemoryUnit, convert it to one
+        if not isinstance(unit, sequence_type):
+            unit = sequence_type(content=unit, activate_timestamp=activate_timestamp)
+        _sequence_unit.append(unit)
+
+    return _sequence_unit

pycityagent/simulation/__init__.py

@@ -0,0 +1,7 @@
+"""
+城市智能体模拟器模块
+"""
+
+from .simulation import AgentSimulation
+
+__all__ = ["AgentSimulation"] 

pycityagent/simulation/interview.py

@@ -0,0 +1,36 @@
+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]