pycityagent 2.0.0a52__cp312-cp312-macosx_11_0_arm64.whl → 2.0.0a54__cp312-cp312-macosx_11_0_arm64.whl

pycityagent/environment/sim/client.py

@@ -10,7 +10,7 @@ from .road_service import RoadService
 from .social_service import SocialService
 from .economy_services import EconomyPersonService, EconomyOrgService
 from .light_service import LightService
-
+from .pause_service import PauseService
 from ..utils.grpc import create_aio_channel
 
 __all__ = ["CityClient"]
@@ -44,6 +44,7 @@ class CityClient:
         self._economy_person_service = EconomyPersonService(aio_channel)
         self._economy_org_service = EconomyOrgService(aio_channel)
         self._light_service = LightService(aio_channel)
+        self._pause_service = PauseService(aio_channel)
 
     @staticmethod
     def from_sidecar(sidecar: OnlyClientSidecar, name: str = NAME):
@@ -61,6 +62,14 @@ class CityClient:
         """
         return self._clock_service
 
+    @property
+    def pause_service(self):
+        """
+        模拟器暂停服务子模块
+        Simulator pause service submodule
+        """
+        return self._pause_service
+
     @property
     def lane_service(self):
         """

pycityagent/environment/sim/clock_service.py

@@ -30,10 +30,10 @@ class ClockService:
         Getting current simulation clock
 
         Args:
-        - req (dict): https://cityproto.sim.fiblab.net/#city.clock.v1.NowRequest
+        - req (dict): https://cityproto.readthedocs.io/en/latest/docs.html#nowrequest
 
         Returns:
-        - https://cityproto.sim.fiblab.net/#city.clock.v1.NowResponse
+        - https://cityproto.readthedocs.io/en/latest/docs.html#nowresponse
         """
         if type(req) != clock_service.NowRequest:
             req = ParseDict(req, clock_service.NowRequest())

pycityagent/environment/sim/pause_service.py

@@ -0,0 +1,61 @@
+from collections.abc import Awaitable, Coroutine
+from typing import Any, Dict, Union, cast
+
+import grpc
+from google.protobuf.json_format import ParseDict
+from pycityproto.city.pause.v1 import pause_service_pb2 as pause_service
+from pycityproto.city.pause.v1 import pause_service_pb2_grpc as pause_grpc
+
+from ..utils.protobuf import async_parse
+
+__all__ = ["PauseService"]
+
+
+class PauseService:
+    """
+    城市模拟暂停服务
+    City simulation pause service
+    """
+
+    def __init__(self, aio_channel: grpc.aio.Channel):
+        self._aio_stub = pause_grpc.PauseServiceStub(aio_channel)
+
+    async def pause(
+        self,
+    ) -> Coroutine[Any, Any, Union[Dict[str, Any], pause_service.PauseResponse]]:
+        """
+        暂停模拟
+        Pause the simulation
+
+        Args:
+        - req (dict): https://cityproto.readthedocs.io/en/latest/docs.html#pauserequest
+
+        Returns:
+        - https://cityproto.readthedocs.io/en/latest/docs.html#pauseresponse
+        """
+        req = pause_service.PauseRequest()
+        res = cast(
+            Awaitable[pause_service.PauseResponse],
+            self._aio_stub.Pause(req),
+        )
+        return
+    
+    async def resume(
+        self,
+    ) -> Coroutine[Any, Any, Union[Dict[str, Any], pause_service.ResumeResponse]]:
+        """
+        恢复模拟
+        Resume the simulation
+
+        Args:
+        - req (dict): https://cityproto.readthedocs.io/en/latest/docs.html#resumerequest
+
+        Returns:
+        - https://cityproto.readthedocs.io/en/latest/docs.html#resumeresponse
+        """
+        req = pause_service.ResumeRequest()
+        res = cast(
+            Awaitable[pause_service.ResumeResponse],
+            self._aio_stub.Resume(req),
+        )
+        return

pycityagent/environment/sim/sim_env.py

@@ -1,7 +1,8 @@
+import atexit
 import logging
 import os
 import time
-import atexit
+import warnings
 from subprocess import DEVNULL, Popen
 from typing import Optional
 
@@ -51,7 +52,7 @@ class ControlSimEnv:
         log_dir: str,
         min_step_time: int = 1000,
         timeout: int = 5,
-        simuletgo_addr: Optional[str] = None,
+        sim_addr: Optional[str] = None,
     ):
         self._task_name = task_name
         self._map_file = map_file
@@ -66,47 +67,38 @@ class ControlSimEnv:
         地图数据
         """
 
-        # 检查二进制文件是否存在
-        # simulet-go: ~/.local/bin/simulet-go
-        self._simuletgo_path = os.path.expanduser("~/.local/bin/simulet-go")
-        if not os.path.exists(os.path.expanduser(self._simuletgo_path)):
-            raise FileNotFoundError("simulet-go not found, please install it first")
-
-        self._simuletgo_config = _generate_yaml_config(map_file, start_step, total_step)
-        self.simuletgo_port = None
-        self._simuletgo_proc = None
-        self._traffic_client = None
-
+        self._sim_config = _generate_yaml_config(map_file, start_step, total_step)
+        # sim
+        self.sim_port = None
+        self._sim_proc = None
         os.makedirs(log_dir, exist_ok=True)
 
-        self.simuletgo_addr = self.reset(simuletgo_addr)
+        self.sim_addr = self.reset(sim_addr)
 
     def reset(
         self,
-        simuletgo_addr: Optional[str] = None,
+        sim_addr: Optional[str] = None,
     ):
         """
         Args:
-        - simuletgo_addr: str, simulet-go的地址。如果为None，则启动一个新的simulet-go
+        - sim_addr: str, pycityagent-sim的地址。如果为None，则启动一个新的pycityagent-sim
         """
-
-        # 三个地址必须同时为None或者同时不为None
-        if simuletgo_addr is None:
-            # 1. 启动simulet-go
-            # ./simulet-go -config-data configbase64 -job test -syncer http://localhost:53001 -listen :51102
-            assert self.simuletgo_port is None
-            assert self._simuletgo_proc is None
-            self.simuletgo_port = find_free_port()
-            config_base64 = encode_to_base64(self._simuletgo_config)
-            self._simuletgo_proc = Popen(
+        if sim_addr is None:
+            # 启动pycityagent-sim
+            # pycityagent-sim -config-data configbase64 -job test -listen :51102
+            assert self.sim_port is None
+            assert self._sim_proc is None
+            self.sim_port = find_free_port()
+            config_base64 = encode_to_base64(self._sim_config)
+            self._sim_proc = Popen(
                 [
-                    self._simuletgo_path,
+                    "pycityagent-sim",
                     "-config-data",
                     config_base64,
                     "-job",
                     self._task_name,
                     "-listen",
-                    f":{self.simuletgo_port}",
+                    f":{self.sim_port}",
                     "-run.min_step_time",
                     f"{self._min_step_time}",
                     "-output",
@@ -120,26 +112,22 @@ class ControlSimEnv:
                 # stdout=DEVNULL,
             )
             logging.info(
-                f"start simulet-go at localhost:{self.simuletgo_port}, PID={self._simuletgo_proc.pid}"
+                f"start pycityagent-sim at localhost:{self.sim_port}, PID={self._sim_proc.pid}"
             )
-            simuletgo_addr = f"http://localhost:{self.simuletgo_port}"
+            sim_addr = f"http://localhost:{self.sim_port}"
             atexit.register(self.close)
-            time.sleep(1)
-        elif simuletgo_addr is not None:
-            pass
+            time.sleep(0.3)
         else:
-            # raise ValueError(
-            #     "simuletgo_addr, syncer_addr, routing_addr must be all None or all not None"
-            # )
-            pass
-        return simuletgo_addr
+            warnings.warn("单独启动模拟器模拟将被弃用", DeprecationWarning)
 
-    def close(self):
-        if self._simuletgo_proc is not None:
-            self._simuletgo_proc.terminate()
-            simuletgo_code = self._simuletgo_proc.wait()
-            logging.info(f"simulet-go exit with code {simuletgo_code}")
+        return sim_addr
 
-        self.simuletgo_port = None
-        self._simuletgo_proc = None
-        self._traffic_client = None
+    def close(self):
+        if self._sim_proc is not None:
+            self._sim_proc.terminate()
+            sim_code = self._sim_proc.wait()
+            logging.info(f"pycityagent-sim exit with code {sim_code}")
+
+        # sim
+        self.sim_port = None
+        self._sim_proc = None

pycityagent/environment/simulator.py

@@ -60,11 +60,11 @@ class Simulator:
                     total_step=2147000000,
                     log_dir=config["simulator"].get("log_dir", "./log"),
                     min_step_time=config["simulator"].get("min_step_time", 1000),
-                    simuletgo_addr=config["simulator"].get("server", None),
+                    sim_addr=config["simulator"].get("server", None),
                 )
 
                 # using local client
-                self._client = CityClient(sim_env.simuletgo_addr, secure=False)
+                self._client = CityClient(sim_env.sim_addr, secure=False)
                 """
                 - 模拟器grpc客户端
                 - grpc client of simulator
@@ -162,35 +162,39 @@ class Simulator:
         Returns:
         - time Union[int, str]: 时间 time in second(int) or formatted time(str)
         """
-        t_sec = await self._client.clock_service.Now({})
-        t_sec = cast(dict[str, int], t_sec)
-        self.time = t_sec["t"]
+        now = await self._client.clock_service.Now({})
+        now = cast(dict[str, int], now)
+        self.time = now["t"]
         if format_time:
             current_date = datetime.now().date()
             start_of_day = datetime.combine(current_date, datetime.min.time())
-            current_time = start_of_day + timedelta(seconds=t_sec["t"])
+            current_time = start_of_day + timedelta(seconds=now["t"])
             formatted_time = current_time.strftime(format)
             return formatted_time
         else:
-            # BUG: 返回的time是float类型
-            return t_sec["t"]
+            return int(now["t"])
+    async def pause(self):
+        await self._client.pause_service.pause()
+
+    async def resume(self):
+        await self._client.pause_service.resume()
 
     async def get_simulator_day(self) -> int:
         """
         获取模拟器到第几日
         """
-        t_sec = await self._client.clock_service.Now({})
-        t_sec = cast(dict[str, int], t_sec)
-        day = t_sec["t"] // 86400
+        now = await self._client.clock_service.Now({})
+        now = cast(dict[str, int], now)
+        day = now["day"]
         return day
 
     async def get_simulator_second_from_start_of_day(self) -> int:
         """
         获取模拟器从00:00:00到当前的秒数
         """
-        t_sec = await self._client.clock_service.Now({})
-        t_sec = cast(dict[str, int], t_sec)
-        return t_sec["t"] % 86400
+        now = await self._client.clock_service.Now({})
+        now = cast(dict[str, int], now)
+        return now["t"] % 86400
 
     async def get_person(self, person_id: int) -> dict:
         return await self._client.person_service.GetPerson(

pycityagent/llm/embeddings.py

@@ -196,30 +196,6 @@ class SimpleEmbedding(Embeddings):
         """Embed query text."""
         return self._embed(text)
 
-    # def save(self, file_path: str):
-    #     """保存模型"""
-    #     state = {
-    #         "vector_dim": self.vector_dim,
-    #         "cache_size": self.cache_size,
-    #         "vocab": self._vocab,
-    #         "idf": self._idf,
-    #         "doc_count": self._doc_count,
-    #     }
-    #     with open(file_path, "w") as f:
-    #         json.dump(state, f)
-
-    # def load(self, file_path: str):
-    #     """加载模型"""
-    #     with open(file_path, "r") as f:
-    #         state = json.load(f)
-    #     self.vector_dim = state["vector_dim"]
-    #     self.cache_size = state["cache_size"]
-    #     self._vocab = state["vocab"]
-    #     self._idf = state["idf"]
-    #     self._doc_count = state["doc_count"]
-    #     self._cache = {}  # 清空缓存
-
-
 if __name__ == "__main__":
     # se = SentenceEmbedding(
     #     pretrained_model_name_or_path="ignore/BAAI--bge-m3", cache_dir="ignore"

pycityagent/llm/llm.py

@@ -1,25 +1,27 @@
 """UrbanLLM: 智能能力类及其定义"""
 
 import json
-from openai import OpenAI, AsyncOpenAI, APIConnectionError, OpenAIError
-from zhipuai import ZhipuAI
 import logging
 
+from openai import APIConnectionError, AsyncOpenAI, OpenAI, OpenAIError
+from zhipuai import ZhipuAI
+
 logging.getLogger("zhipuai").setLevel(logging.WARNING)
 
 import asyncio
+import os
 from http import HTTPStatus
+from io import BytesIO
+from typing import Any, Optional, Union
+
 import dashscope
 import requests
 from dashscope import ImageSynthesis
 from PIL import Image
-from io import BytesIO
-from typing import Any, Optional, Union
+
 from .llmconfig import *
 from .utils import *
 
-import os
-
 os.environ["GRPC_VERBOSITY"] = "ERROR"
 
 
@@ -38,13 +40,13 @@ class LLM:
         self.request_number = 0
         self.semaphore = None
         self._current_client_index = 0
-        
+
         api_keys = self.config.text["api_key"]
         if not isinstance(api_keys, list):
             api_keys = [api_keys]
-            
+
         self._aclients = []
-        
+
         for api_key in api_keys:
             if self.config.text["request_type"] == "openai":
                 client = AsyncOpenAI(api_key=api_key, timeout=300)
@@ -62,6 +64,10 @@ class LLM:
                 )
             elif self.config.text["request_type"] == "zhipuai":
                 client = ZhipuAI(api_key=api_key, timeout=300)
+            else:
+                raise ValueError(
+                    f"Unsupported `request_type` {self.config.text['request_type']}!"
+                )
             self._aclients.append(client)
 
     def set_semaphore(self, number_of_coroutine: int):
@@ -118,7 +124,9 @@ Token Usage:
     def _get_next_client(self):
         """获取下一个要使用的客户端"""
         client = self._aclients[self._current_client_index]
-        self._current_client_index = (self._current_client_index + 1) % len(self._aclients)
+        self._current_client_index = (self._current_client_index + 1) % len(
+            self._aclients
+        )
         return client
 
     async def atext_request(

pycityagent/memory/faiss_query.py

@@ -1,4 +1,5 @@
 import asyncio
+import warnings
 from collections.abc import Sequence
 from typing import Any, Literal, Optional, Union
 
@@ -116,32 +117,34 @@ class FaissQuery:
         }
         if filter is not None:
             _filter.update(filter)
-        if return_score_type == "L2-distance":
-            _result = await self.vectors_store.asimilarity_search_with_score(
-                query=query,
-                k=k,
-                filter=_filter,
-                fetch_k=fetch_k,
-            )
-            return [(r.page_content, s, r.metadata) for r, s in _result]
-        elif return_score_type == "none":
-            _result = await self.vectors_store.asimilarity_search(
-                query=query,
-                k=k,
-                filter=_filter,
-                fetch_k=fetch_k,
-            )
-            return [(r.page_content, r.metadata) for r in _result]
-        elif return_score_type == "similarity_score":
-            _result = await self.vectors_store.asimilarity_search_with_relevance_scores(
-                query=query,
-                k=k,
-                filter=_filter,
-                fetch_k=fetch_k,
-            )
-            return [(r.page_content, s, r.metadata) for r, s in _result]
-        else:
-            raise ValueError(f"Invalid `return_score_type` {return_score_type}!")
+        with warnings.catch_warnings():
+            warnings.simplefilter("ignore")
+            if return_score_type == "L2-distance":
+                _result = await self.vectors_store.asimilarity_search_with_score(
+                    query=query,
+                    k=k,
+                    filter=_filter,
+                    fetch_k=fetch_k,
+                )
+                return [(r.page_content, s, r.metadata) for r, s in _result]
+            elif return_score_type == "none":
+                _result = await self.vectors_store.asimilarity_search(
+                    query=query,
+                    k=k,
+                    filter=_filter,
+                    fetch_k=fetch_k,
+                )
+                return [(r.page_content, r.metadata) for r in _result]
+            elif return_score_type == "similarity_score":
+                _result = await self.vectors_store.asimilarity_search_with_relevance_scores(
+                    query=query,
+                    k=k,
+                    filter=_filter,
+                    fetch_k=fetch_k,
+                )
+                return [(r.page_content, s, r.metadata) for r, s in _result]
+            else:
+                raise ValueError(f"Invalid `return_score_type` {return_score_type}!")
 
     @lock_decorator
     async def similarity_search_by_embedding(