pycityagent 2.0.0a43__cp39-cp39-macosx_11_0_arm64.whl

pycityagent/utils/parsers/json_parser.py

@@ -0,0 +1,86 @@
+import json
+import logging
+from typing import Any
+
+from .parser_base import ParserBase
+
+
+class JsonObjectParser(ParserBase):
+    """A parser that extracts and parses JSON objects from a response string enclosed within specific tags.
+
+    Attributes:
+        tag_start (str): The start tag used to identify the beginning of the JSON object.
+        tag_end (str): The end tag used to identify the end of the JSON object.
+    """
+
+    tag_start = "```json"
+    tag_end = "```"
+
+    def __init__(self) -> None:
+        """Initialize the JsonObjectParser with default tags."""
+        super().__init__()
+
+    def parse(self, response: str) -> Any:
+        """Parse the response string to extract and return a JSON object.
+
+        Parameters:
+            response (str): The response string containing the JSON object.
+
+        Returns:
+            Any: The parsed JSON object.
+        """
+        extract_text = self._extract_text_within_tags(
+            response=response,
+            tag_start=self.tag_start,
+            tag_end=self.tag_end,
+        )
+        try:
+            eval_parsed_json = eval(extract_text)
+            return eval_parsed_json
+        except Exception as e:
+            # logging.warning(f"Error when handling text {extract_text} with `eval`")
+            pass
+        try:
+            parsed_json = json.loads(extract_text)
+            return parsed_json
+        except json.decoder.JSONDecodeError as e:
+            raw_response = f"{self.tag_start}{extract_text}{self.tag_end}"
+            raise ValueError(
+                f"The content between {self.tag_start} and {self.tag_end} "
+                f"MUST be a JSON object."
+                f'When parsing "{raw_response}", an error occurred: {e}',
+            ) from None
+
+
+class JsonDictParser(JsonObjectParser):
+    """A parser that extends JsonObjectParser to ensure the parsed JSON is returned as a dictionary.
+
+    Attributes:
+        tag_start (str): The start tag used to identify the beginning of the JSON object.
+        tag_end (str): The end tag used to identify the end of the JSON object.
+    """
+
+    tag_start = "```json"
+    tag_end = "```"
+
+    def __init__(self) -> None:
+        """Initialize the JsonDictParser with default tags."""
+        super().__init__()
+
+    def parse(self, response: str) -> dict:
+        """Parse the response string to extract and return a JSON object as a dictionary.
+
+        Parameters:
+            response (str): The response string containing the JSON object.
+
+        Returns:
+            dict: The parsed JSON object as a dictionary.
+        """
+        parsed_json = super().parse(response)
+        if not isinstance(parsed_json, dict):
+            # If not a dictionary, raise an error
+            raise ValueError(
+                "A JSON dictionary object is wanted, "
+                f"but got {type(parsed_json)} instead."
+            )
+        return dict(parsed_json)

pycityagent/utils/parsers/parser_base.py

@@ -0,0 +1,60 @@
+"""
+Base class of parser
+"""
+
+import re
+from abc import ABC, abstractmethod
+from typing import Any, Union
+
+
+class ParserBase(ABC):
+    def __init__(
+        self,
+    ) -> None:
+        pass
+
+    @abstractmethod
+    def parse(self, response: str) -> Any:
+        """
+        Parse the string response returned by the model and convert it into a more manageable form.
+
+        Parameters:
+            response (str): The raw string returned by the model.
+
+        Returns:
+            Any: The converted data, the specific type depends on the parsing result.
+        """
+        pass
+
+    def _extract_text_within_tags(
+        self, response: str, tag_start: str, tag_end: str
+    ) -> str:
+        """
+        Return the string between the first occurrence of the start tag and the end tag in the response string.
+
+        Parameters:
+            response (str): The response string.
+            tag_start (str): The start tag.
+            tag_end (str): The end tag.
+
+        Returns:
+            str: The string between the start and end tags.
+        """
+
+        def _extract_substring(
+            text: str, tag_start: str, tag_end: str
+        ) -> Union[str, None]:
+            pattern = re.escape(tag_start) + r"(.*?)" + re.escape(tag_end)
+            match = re.search(pattern, text, re.DOTALL)
+            if match:
+                return match.group(1).strip()
+            else:
+                return None
+
+        sub_response = _extract_substring(response, tag_start, tag_end)
+        if sub_response is not None:
+            return sub_response
+        else:
+            raise ValueError(
+                f"No text between tag {tag_start} and tag {tag_end} in response {response}!"
+            )

pycityagent/utils/pg_query.py

@@ -0,0 +1,92 @@
+from typing import Any
+
+PGSQL_DICT: dict[str, list[Any]] = {
+    # Experiment
+    "experiment": [
+        """
+    CREATE TABLE IF NOT EXISTS {table_name} (
+        id UUID PRIMARY KEY,
+        name TEXT,
+        num_day INT4,
+        status INT4, 
+        cur_day INT4,
+        cur_t FLOAT,
+        config TEXT,
+        error TEXT,
+        created_at TIMESTAMPTZ NOT NULL DEFAULT CURRENT_TIMESTAMP,
+        updated_at TIMESTAMPTZ NOT NULL DEFAULT CURRENT_TIMESTAMP
+    )
+""",
+    ],
+    # Agent Profile
+    "agent_profile": [
+        """
+    CREATE TABLE IF NOT EXISTS {table_name} (
+        id UUID PRIMARY KEY,
+        name TEXT,
+        profile JSONB
+    )
+""",
+    ],
+    # Agent Dialog
+    "agent_dialog": [
+        """
+    CREATE TABLE IF NOT EXISTS {table_name} (
+        id UUID,
+        day INT4,
+        t FLOAT,
+        type INT4,
+        speaker TEXT,
+        content TEXT,
+        created_at TIMESTAMPTZ
+    )
+""",
+        "CREATE INDEX {table_name}_id_idx ON {table_name} (id)",
+        "CREATE INDEX {table_name}_day_t_idx ON {table_name} (day,t)",
+    ],
+    # Agent Status
+    "agent_status": [
+        """
+    CREATE TABLE IF NOT EXISTS {table_name} (
+        id UUID,
+        day INT4,
+        t FLOAT,
+        lng DOUBLE PRECISION,
+        lat DOUBLE PRECISION,
+        parent_id INT4,
+        action TEXT,
+        status JSONB,
+        created_at TIMESTAMPTZ
+    )
+""",
+        "CREATE INDEX {table_name}_id_idx ON {table_name} (id)",
+        "CREATE INDEX {table_name}_day_t_idx ON {table_name} (day,t)",
+    ],
+    # Agent Survey
+    "agent_survey": [
+        """
+    CREATE TABLE IF NOT EXISTS {table_name} (
+        id UUID,
+        day INT4,
+        t FLOAT,
+        survey_id UUID,
+        result JSONB,
+        created_at TIMESTAMPTZ
+    )
+""",
+        "CREATE INDEX {table_name}_id_idx ON {table_name} (id)",
+        "CREATE INDEX {table_name}_day_t_idx ON {table_name} (day,t)",
+    ],
+}
+TO_UPDATE_EXP_INFO_KEYS_AND_TYPES: list[tuple[str, Any]] = [
+    ("id", None),
+    ("name", str),
+    ("num_day", int),
+    ("status", int),
+    ("cur_day", int),
+    ("cur_t", float),
+    ("config", str),
+    ("error", str),
+    ("created_at", None),
+    ("updated_at", None),
+]

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/workflow/__init__.py

@@ -0,0 +1,26 @@
+# __init__.py
+
+"""
+This module contains classes for creating blocks and running workflows.
+"""
+
+from .block import (Block, log_and_check, log_and_check_with_memory,
+                    trigger_class)
+from .prompt import FormatPrompt
+from .tool import ExportMlflowMetrics, GetMap, SencePOI, Tool
+from .trigger import EventTrigger, MemoryChangeTrigger, TimeTrigger
+
+__all__ = [
+    "SencePOI",
+    "Tool",
+    "ExportMlflowMetrics",
+    "GetMap",
+    "MemoryChangeTrigger",
+    "TimeTrigger",
+    "EventTrigger",
+    "Block",
+    "log_and_check",
+    "log_and_check_with_memory",
+    "FormatPrompt",
+    "trigger_class",
+]

pycityagent/workflow/block.py

@@ -0,0 +1,211 @@
+import asyncio
+import functools
+import inspect
+from collections.abc import Awaitable, Callable, Coroutine
+from typing import Any, Optional, Union
+
+from ..environment.simulator import Simulator
+from ..llm import LLM
+from ..memory import Memory
+from ..utils.decorators import record_call_aio
+from ..workflow.trigger import EventTrigger
+
+TRIGGER_INTERVAL = 1
+
+
+def log_and_check_with_memory(
+    condition: Union[
+        Callable[[Memory], Coroutine[Any, Any, bool]],
+        Callable[[], Coroutine[Any, Any, bool]],
+        Callable[[Memory], bool],
+        Callable[[], bool],
+    ] = lambda: True,
+    trigger_interval: float = TRIGGER_INTERVAL,
+    record_function_calling: bool = False,
+):
+    """
+    A decorator that logs function calls and optionally checks a condition before executing the function.
+
+    This decorator is specifically designed to be used with the `block` method. A 'Memory' object is required in method input.
+
+    Args:
+        condition (Callable): A condition function that must be satisfied before the decorated function is executed.
+                             Can be synchronous or asynchronous.
+        trigger_interval (float): The interval (in seconds) to wait between condition checks.
+        record_function_calling (bool): Whether to log the function call information.
+    """
+
+    def decorator(func):
+        @record_call_aio(record_function_calling)
+        @functools.wraps(func)
+        async def wrapper(self, *args, **kwargs):
+            memory = None
+            for arg in list(args) + list(kwargs.values()):
+                if memory is not None:
+                    break
+                if isinstance(arg, Memory):
+                    memory = arg
+            assert isinstance(memory, Memory), "Input arguments has no `Memory` object!"
+            # Wait until the condition is met
+            sig = inspect.signature(condition)
+            params = list(sig.parameters.values())
+            if len(params) == 1 and params[0].annotation is Memory:
+                if inspect.iscoroutinefunction(condition):
+                    while not await condition(memory):  # type:ignore
+                        await asyncio.sleep(trigger_interval)
+                else:
+                    while not condition(memory):  # type:ignore
+                        await asyncio.sleep(trigger_interval)
+            elif len(params) == 0:
+                if inspect.iscoroutinefunction(condition):
+                    while not await condition():  # type:ignore
+                        await asyncio.sleep(trigger_interval)
+                else:
+                    while not condition():  # type:ignore
+                        await asyncio.sleep(trigger_interval)
+            else:
+                raise RuntimeError(
+                    f"Invalid parameter format in condition function {condition}"
+                )
+            result = await func(self, *args, **kwargs)
+            return result
+
+        return wrapper
+
+    return decorator
+
+
+def log_and_check(
+    condition: Union[
+        Callable[[], Coroutine[Any, Any, bool]],
+        Callable[[], bool],
+    ] = lambda: True,
+    trigger_interval: float = TRIGGER_INTERVAL,
+    record_function_calling: bool = False,
+):
+    """
+    A decorator that logs function calls and optionally checks a condition before executing the function.
+
+    This decorator is specifically designed to be used with the `block` method.
+
+    Args:
+        condition (Callable): A condition function that must be satisfied before the decorated function is executed.
+                             Can be synchronous or asynchronous.
+        trigger_interval (float): The interval (in seconds) to wait between condition checks.
+        record_function_calling (bool): Whether to log the function call information.
+    """
+
+    def decorator(func):
+        @record_call_aio(record_function_calling)
+        @functools.wraps(func)
+        async def wrapper(self, *args, **kwargs):
+            # Wait until the condition is met
+            sig = inspect.signature(condition)
+            params = list(sig.parameters.values())
+            if len(params) == 0:
+                if inspect.iscoroutinefunction(condition):
+                    while not await condition():  # type:ignore
+                        await asyncio.sleep(trigger_interval)
+                else:
+                    while not condition():  # type:ignore
+                        await asyncio.sleep(trigger_interval)
+            else:
+                raise RuntimeError(
+                    f"Invalid parameter format in condition function {condition}"
+                )
+            result = await func(self, *args, **kwargs)
+            return result
+
+        return wrapper
+
+    return decorator
+
+
+def trigger_class():
+    def decorator(cls):
+        original_forward = cls.forward
+
+        @functools.wraps(original_forward)
+        async def wrapped_forward(self, *args, **kwargs):
+            if self.trigger is not None:
+                await self.trigger.wait_for_trigger()
+            return await original_forward(self, *args, **kwargs)
+
+        cls.forward = wrapped_forward
+        return cls
+
+    return decorator
+
+
+# Define a Block, similar to a layer in PyTorch
+class Block:
+    def __init__(
+        self,
+        name: str,
+        llm: Optional[LLM] = None,
+        memory: Optional[Memory] = None,
+        simulator: Optional[Simulator] = None,
+        trigger: Optional[EventTrigger] = None,
+    ):
+        self.name = name
+        self._llm = llm
+        self._memory = memory
+        self._simulator = simulator
+        # 如果传入trigger，将block注入到trigger中并立即初始化
+        if trigger is not None:
+            trigger.block = self
+            trigger.initialize()  # 立即初始化trigger
+        self.trigger = trigger
+
+    async def forward(self):
+        """
+        Each block performs a specific reasoning task.
+        To be overridden by specific block implementations.
+        """
+        raise NotImplementedError("Subclasses should implement this method")
+
+    @property
+    def llm(
+        self,
+    ) -> LLM:
+        if self._llm is None:
+            raise RuntimeError(f"LLM access before assignment, please `set_llm` first!")
+        return self._llm
+
+    @property
+    def memory(
+        self,
+    ) -> Memory:
+        if self._memory is None:
+            raise RuntimeError(
+                f"Memory access before assignment, please `set_memory` first!"
+            )
+        return self._memory
+
+    @property
+    def simulator(
+        self,
+    ) -> Simulator:
+        if self._simulator is None:
+            raise RuntimeError(
+                f"Simulator access before assignment, please `set_simulator` first!"
+            )
+        return self._simulator
+
+    def set_llm_client(self, llm: LLM):
+        """
+        Set the llm_client of the block.
+        """
+        self._llm = llm
+
+    def set_simulator(self, simulator: Simulator):
+        """
+        Set the simulator of the block.
+        """
+        self._simulator = simulator
+
+    def set_memory(self, memory: Memory):
+        """
+        Set the memory of the block.
+        """
+        self._memory = memory

pycityagent/workflow/prompt.py

@@ -0,0 +1,79 @@
+from typing import Optional, Union
+import re
+
+
+class FormatPrompt:
+    """
+    A class to handle the formatting of prompts based on a template,
+    with support for system prompts and variable extraction.
+
+    Attributes:
+        template (str): The template string containing placeholders.
+        system_prompt (Optional[str]): An optional system prompt to add to the dialog.
+        variables (list[str]): A list of variable names extracted from the template.
+        formatted_string (str): The formatted string derived from the template and provided variables.
+    """
+
+    def __init__(self, template: str, system_prompt: Optional[str] = None) -> None:
+        """
+        Initializes the FormatPrompt with a template and an optional system prompt.
+
+        Args:
+            template (str): The string template with variable placeholders.
+            system_prompt (Optional[str]): An optional system prompt.
+        """
+        self.template = template
+        self.system_prompt = system_prompt  # Store the system prompt
+        self.variables = self._extract_variables()
+        self.formatted_string = ""  # To store the formatted string
+
+    def _extract_variables(self) -> list[str]:
+        """
+        Extracts variable names from the template string.
+
+        Returns:
+            list[str]: A list of variable names found within the template.
+        """
+        return re.findall(r"\{(\w+)\}", self.template)
+
+    def format(self, **kwargs) -> str:
+        """
+        Formats the template string using the provided keyword arguments.
+
+        Args:
+            **kwargs: Variable names and their corresponding values to format the template.
+
+        Returns:
+            str: The formatted string.
+        """
+        self.formatted_string = self.template.format(
+            **kwargs
+        )  # Store the formatted string
+        return self.formatted_string
+
+    def to_dialog(self) -> list[dict[str, str]]:
+        """
+        Converts the formatted prompt and optional system prompt into a dialog format.
+
+        Returns:
+            list[dict[str, str]]: A list representing the dialog with roles and content.
+        """
+        dialog = []
+        if self.system_prompt:
+            dialog.append(
+                {"role": "system", "content": self.system_prompt}
+            )  # Add system prompt if it exists
+        dialog.append(
+            {"role": "user", "content": self.formatted_string}
+        )  # Add user content
+        return dialog
+
+    def log(self) -> None:
+        """
+        Logs the details of the FormatPrompt, including the template,
+        system prompt, extracted variables, and formatted string.
+        """
+        print(f"FormatPrompt: {self.template}")
+        print(f"System Prompt: {self.system_prompt}")  # Log the system prompt
+        print(f"Variables: {self.variables}")
+        print(f"Formatted String: {self.formatted_string}")  # Log the formatted string