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

pycityagent/environment/sim/client.py

@@ -0,0 +1,126 @@
+import warnings
+import grpc
+
+from ..sidecar import OnlyClientSidecar
+from .clock_service import ClockService
+from .person_service import PersonService
+from .aoi_service import AoiService
+from .lane_service import LaneService
+from .road_service import RoadService
+from .social_service import SocialService
+from .economy_services import EconomyPersonService, EconomyOrgService
+from .light_service import LightService
+
+from ..utils.grpc import create_aio_channel
+
+__all__ = ["CityClient"]
+
+
+class CityClient:
+    """
+    模拟器接口
+    Simulator interface
+    """
+
+    NAME = "city"
+
+    def __init__(
+        self,
+        url: str,
+        secure: bool = False,
+    ):
+        """
+        Args:
+        - url (str): 模拟器server的地址。The address of the emulator server.
+        - secure (bool, optional): 是否使用安全连接. Defaults to False. Whether to use a secure connection. Defaults to False.
+        """
+        aio_channel = create_aio_channel(url, secure)
+        self._clock_service = ClockService(aio_channel)
+        self._lane_service = LaneService(aio_channel)
+        self._person_service = PersonService(aio_channel)
+        self._aoi_service = AoiService(aio_channel)
+        self._road_service = RoadService(aio_channel)
+        self._social_service = SocialService(aio_channel)
+        self._economy_person_service = EconomyPersonService(aio_channel)
+        self._economy_org_service = EconomyOrgService(aio_channel)
+        self._light_service = LightService(aio_channel)
+
+    @staticmethod
+    def from_sidecar(sidecar: OnlyClientSidecar, name: str = NAME):
+        """
+        从sidecar中创建CityClient
+        Create CityClient from sidecar
+        """
+        return CityClient(sidecar.wait_url(name))
+
+    @property
+    def clock_service(self):
+        """
+        模拟器时间服务子模块
+        Simulator time service submodule
+        """
+        return self._clock_service
+
+    @property
+    def lane_service(self):
+        """
+        模拟器lane服务子模块
+        Simulator lane service submodule
+        """
+        return self._lane_service
+
+    @property
+    def person_service(self):
+        """
+        模拟器智能体服务子模块
+        Simulator agent service submodule
+        """
+        return self._person_service
+
+    @property
+    def aoi_service(self):
+        """
+        模拟器AOI服务子模块
+        Simulator AOI service submodule
+        """
+        return self._aoi_service
+
+    @property
+    def road_service(self):
+        """
+        模拟器road服务子模块
+        Simulator road service submodule
+        """
+        return self._road_service
+
+    @property
+    def social_service(self):
+        """
+        模拟器social服务子模块
+        Simulator social service submodule
+        """
+        return self._social_service
+
+    @property
+    def economy_person_service(self):
+        """
+        模拟器经济服务（个人）子模块
+        Simulator economic service (personal) submodule
+        """
+        return self._economy_person_service
+
+    @property
+    def economy_org_service(self):
+        """
+        模拟器经济服务（组织）子模块
+        Simulator economic service (organizational) submodule
+        """
+        return self._economy_org_service
+
+    @property
+    def light_service(self):
+        """
+        模拟器红绿灯服务子模块
+        Simulator traffic light service submodule
+        """
+        return self._light_service

pycityagent/environment/sim/clock_service.py

@@ -0,0 +1,43 @@
+from typing import Any, Awaitable, Coroutine, cast, Union, Dict
+
+import grpc
+from google.protobuf.json_format import ParseDict
+from pycityproto.city.clock.v1 import clock_service_pb2 as clock_service
+from pycityproto.city.clock.v1 import clock_service_pb2_grpc as clock_grpc
+
+from ..utils.protobuf import async_parse
+
+__all__ = ["ClockService"]
+
+
+class ClockService:
+    """
+    城市模拟时间服务
+    City simulation clock service
+    """
+
+    def __init__(self, aio_channel: grpc.aio.Channel):
+        self._aio_stub = clock_grpc.ClockServiceStub(aio_channel)
+
+    def Now(
+        self,
+        req: Union[clock_service.NowRequest, dict],
+        dict_return: bool = True,
+    ) -> Coroutine[Any, Any, Union[Dict[str, Any], clock_service.NowResponse]]:
+        """
+        获取当前的模拟时间请求
+        Getting current simulation clock
+
+        Args:
+        - req (dict): https://cityproto.sim.fiblab.net/#city.clock.v1.NowRequest
+
+        Returns:
+        - https://cityproto.sim.fiblab.net/#city.clock.v1.NowResponse
+        """
+        if type(req) != clock_service.NowRequest:
+            req = ParseDict(req, clock_service.NowRequest())
+        res = cast(
+            Awaitable[clock_service.NowResponse],
+            self._aio_stub.Now(req),
+        )
+        return async_parse(res, dict_return)

pycityagent/environment/sim/economy_services.py

@@ -0,0 +1,191 @@
+from typing import Any, Awaitable, Coroutine, cast, Union, Dict
+
+import grpc
+from google.protobuf.json_format import ParseDict
+from pycityproto.city.economy.v1 import org_service_pb2 as org_service
+from pycityproto.city.economy.v1 import org_service_pb2_grpc as org_grpc
+from pycityproto.city.economy.v1 import person_service_pb2 as person_service
+from pycityproto.city.economy.v1 import person_service_pb2_grpc as person_grpc
+
+from ..utils.protobuf import async_parse
+
+__all__ = ["EconomyPersonService", "EconomyOrgService"]
+
+
+class EconomyPersonService:
+    """
+    城市模拟经济服务（个人）
+    City simulation economic service (personal)
+    """
+
+    def __init__(self, aio_channel: grpc.aio.Channel):
+        self._aio_stub = person_grpc.PersonServiceStub(aio_channel)
+
+    def GetPerson(
+        self,
+        req: Union[person_service.GetPersonRequest, dict],
+        dict_return: bool = True,
+    ) -> Coroutine[Any, Any, Union[Dict[str, Any], person_service.GetPersonResponse]]:
+        """
+        批量查询人的经济情况（资金、雇佣关系）
+        Query person’s economic situation (funds, employment relationship) in batches
+        
+        Args:
+        - req (dict): https://cityproto.sim.fiblab.net/#city.economy.v1.GetPersonRequest
+
+        Returns:
+        - https://cityproto.sim.fiblab.net/#city.economy.v1.GetPersonResponse
+        """
+        if type(req) != person_service.GetPersonRequest:
+            req = ParseDict(req, person_service.GetPersonRequest())
+        res = cast(
+            Awaitable[person_service.GetPersonResponse], self._aio_stub.GetPerson(req)
+        )
+        return async_parse(res, dict_return)
+
+    def UpdatePersonMoney(
+        self,
+        req: Union[person_service.UpdatePersonMoneyRequest, dict],
+        dict_return: bool = True,
+    ) -> Coroutine[
+        Any, Any, Union[Dict[str, Any], person_service.UpdatePersonMoneyResponse]
+    ]:
+        """
+        批量修改人的资金
+        Modify person’s money in batches
+
+        Args:
+        - req (dict): https://cityproto.sim.fiblab.net/#city.economy.v1.UpdatePersonMoneyRequest
+
+        Returns:
+        - https://cityproto.sim.fiblab.net/#city.economy.v1.UpdatePersonMoneyResponse
+        """
+        if type(req) != person_service.UpdatePersonMoneyRequest:
+            req = ParseDict(req, person_service.UpdatePersonMoneyRequest())
+        res = cast(
+            Awaitable[person_service.UpdatePersonMoneyResponse],
+            self._aio_stub.UpdatePersonMoney(req),
+        )
+        return async_parse(res, dict_return)
+
+
+class EconomyOrgService:
+    """
+    城市模拟经济服务（组织）
+    City simulation economic service (organizational)
+    """
+
+    def __init__(self, aio_channel: grpc.aio.Channel):
+        self._aio_stub = org_grpc.OrgServiceStub(aio_channel)
+
+    def GetOrg(
+        self, req: Union[org_service.GetOrgRequest, dict], dict_return: bool = True
+    ) -> Coroutine[Any, Any, Union[Dict[str, Any], org_service.GetOrgResponse]]:
+        """
+        批量查询组织的经济情况（员工、岗位、资金、货物）
+        Query the economic status of the organization (employees, positions, funds, goods) in batches
+
+        Args:
+        - req (dict): https://cityproto.sim.fiblab.net/#city.economy.v1.GetOrgRequest
+
+        Returns:
+        - https://cityproto.sim.fiblab.net/#city.economy.v1.GetOrgResponse
+        """
+        if type(req) != org_service.GetOrgRequest:
+            req = ParseDict(req, org_service.GetOrgRequest())
+        res = cast(Awaitable[org_service.GetOrgResponse], self._aio_stub.GetOrg(req))
+        return async_parse(res, dict_return)
+
+    def UpdateOrgMoney(
+        self,
+        req: Union[org_service.UpdateOrgMoneyRequest, dict],
+        dict_return: bool = True,
+    ) -> Coroutine[Any, Any, Union[Dict[str, Any], org_service.UpdateOrgMoneyResponse]]:
+        """
+        批量修改组织的资金
+        Modify organization’s money in batches
+
+        Args:
+        - req (dict): https://cityproto.sim.fiblab.net/#city.economy.v1.UpdateOrgMoneyRequest
+
+        Returns:
+        - https://cityproto.sim.fiblab.net/#city.economy.v1.UpdateOrgMoneyResponse
+        """
+        if type(req) != org_service.UpdateOrgMoneyRequest:
+            req = ParseDict(req, org_service.UpdateOrgMoneyRequest())
+        res = cast(
+            Awaitable[org_service.UpdateOrgMoneyResponse],
+            self._aio_stub.UpdateOrgMoney(req),
+        )
+        return async_parse(res, dict_return)
+
+    def UpdateOrgGoods(
+        self,
+        req: Union[org_service.UpdateOrgGoodsRequest, dict],
+        dict_return: bool = True,
+    ) -> Coroutine[Any, Any, Union[Dict[str, Any], org_service.UpdateOrgGoodsResponse]]:
+        """
+        批量修改组织的货物
+        Modify organization’s goods in batches
+
+        Args:
+        - req (dict): https://cityproto.sim.fiblab.net/#city.economy.v1.UpdateOrgGoodsRequest
+
+        Returns:
+        - https://cityproto.sim.fiblab.net/#city.economy.v1.UpdateOrgGoodsResponse
+        """
+        if type(req) != org_service.UpdateOrgGoodsRequest:
+            req = ParseDict(req, org_service.UpdateOrgGoodsRequest())
+        res = cast(
+            Awaitable[org_service.UpdateOrgGoodsResponse],
+            self._aio_stub.UpdateOrgGoods(req),
+        )
+        return async_parse(res, dict_return)
+
+    def UpdateOrgEmployee(
+        self,
+        req: Union[org_service.UpdateOrgEmployeeRequest, dict],
+        dict_return: bool = True,
+    ) -> Coroutine[
+        Any, Any, Union[Dict[str, Any], org_service.UpdateOrgEmployeeResponse]
+    ]:
+        """
+        批量修改组织的员工
+        Modify organization’s emplpyees in batches
+
+        Args:
+        - req (dict): https://cityproto.sim.fiblab.net/#city.economy.v1.UpdateOrgEmployeeRequest
+
+        Returns:
+        - https://cityproto.sim.fiblab.net/#city.economy.v1.UpdateOrgEmployeeResponse
+        """
+        if type(req) != org_service.UpdateOrgEmployeeRequest:
+            req = ParseDict(req, org_service.UpdateOrgEmployeeRequest())
+        res = cast(
+            Awaitable[org_service.UpdateOrgEmployeeResponse],
+            self._aio_stub.UpdateOrgEmployee(req),
+        )
+        return async_parse(res, dict_return)
+
+    def UpdateOrgJob(
+        self,
+        req: Union[org_service.UpdateOrgJobRequest, dict],
+        dict_return: bool = True,
+    ) -> Coroutine[Any, Any, Union[Dict[str, Any], org_service.UpdateOrgJobResponse]]:
+        """
+        批量修改组织的岗位
+        Modify organization’s jobs in batches
+
+        Args:
+        - req (dict): https://cityproto.sim.fiblab.net/#city.economy.v1.UpdateOrgJobRequest
+
+        Returns:
+        - https://cityproto.sim.fiblab.net/#city.economy.v1.UpdateOrgJobResponse
+        """
+        if type(req) != org_service.UpdateOrgJobRequest:
+            req = ParseDict(req, org_service.UpdateOrgJobRequest())
+        res = cast(
+            Awaitable[org_service.UpdateOrgJobResponse],
+            self._aio_stub.UpdateOrgJob(req),
+        )
+        return async_parse(res, dict_return)

pycityagent/environment/sim/lane_service.py

@@ -0,0 +1,110 @@
+from typing import Any, Awaitable, Coroutine, cast, Union, Dict
+
+import grpc
+from google.protobuf.json_format import ParseDict
+from pycityproto.city.map.v2 import lane_service_pb2 as lane_service
+from pycityproto.city.map.v2 import lane_service_pb2_grpc as lane_grpc
+
+from ..utils.protobuf import async_parse
+
+__all__ = ["LaneService"]
+
+
+class LaneService:
+    """
+    交通模拟lane服务
+    Traffic simulation lane service
+    """
+
+    def __init__(self, aio_channel: grpc.aio.Channel):
+        self._aio_stub = lane_grpc.LaneServiceStub(aio_channel)
+
+    def GetLane(
+        self, req: Union[lane_service.GetLaneRequest, dict], dict_return: bool = True
+    ) -> Coroutine[Any, Any, Union[Dict[str, Any], lane_service.GetLaneResponse]]:
+        """
+        获取Lane的信息
+        Get Lane's information
+
+        Args:
+        - req (dict): https://cityproto.sim.fiblab.net/#city.map.v2.GetLaneRequest
+
+        Returns:
+        - https://cityproto.sim.fiblab.net/#city.map.v2.GetLaneResponse
+        """
+        if type(req) != lane_service.GetLaneRequest:
+            req = ParseDict(req, lane_service.GetLaneRequest())
+        res = cast(Awaitable[lane_service.GetLaneResponse], self._aio_stub.GetLane(req))
+        return async_parse(res, dict_return)
+
+    def SetLaneMaxV(
+        self,
+        req: Union[lane_service.SetLaneMaxVRequest, dict],
+        dict_return: bool = True,
+    ) -> Coroutine[Any, Any, Union[Dict[str, Any], lane_service.SetLaneMaxVResponse]]:
+        """
+        设置Lane的最大速度（限速）
+        Set the maximum speed of Lane (speed limit)
+
+        Args:
+        - req (dict): https://cityproto.sim.fiblab.net/#city.map.v2.SetLaneMaxVRequest
+
+        Returns:
+        - https://cityproto.sim.fiblab.net/#city.map.v2.SetLaneMaxVResponse
+        """
+        if type(req) != lane_service.SetLaneMaxVRequest:
+            req = ParseDict(req, lane_service.SetLaneMaxVRequest())
+        res = cast(
+            Awaitable[lane_service.SetLaneMaxVResponse], self._aio_stub.SetLaneMaxV(req)
+        )
+        return async_parse(res, dict_return)
+
+    def SetLaneRestriction(
+        self,
+        req: Union[lane_service.SetLaneRestrictionRequest, dict],
+        dict_return: bool = True,
+    ) -> Coroutine[
+        Any, Any, Union[Dict[str, Any], lane_service.SetLaneRestrictionResponse]
+    ]:
+        """
+        设置Lane的限制
+        Set the restriction of Lane
+
+        Args:
+        - req (dict): https://cityproto.sim.fiblab.net/#city.map.v2.SetLaneRestrictionRequest
+
+        Returns:
+        - https://cityproto.sim.fiblab.net/#city.map.v2.SetLaneRestrictionResponse
+        """
+        if type(req) != lane_service.SetLaneRestrictionRequest:
+            req = ParseDict(req, lane_service.SetLaneRestrictionRequest())
+        res = cast(
+            Awaitable[lane_service.SetLaneRestrictionResponse],
+            self._aio_stub.SetLaneRestriction(req),
+        )
+        return async_parse(res, dict_return)
+
+    def GetLaneByLongLatBBox(
+        self,
+        req: Union[lane_service.GetLaneByLongLatBBoxRequest, dict],
+        dict_return: bool = True,
+    ) -> Coroutine[
+        Any, Any, Union[Dict[str, Any], lane_service.GetLaneByLongLatBBoxResponse]
+    ]:
+        """
+        获取特定区域内的Lane的信息
+        Get lane information in a specific region
+
+        Args:
+        - req (dict): https://cityproto.sim.fiblab.net/#city.map.v2.GetLaneByLongLatBBoxRequest
+
+        Returns:
+        - https://cityproto.sim.fiblab.net/#city.map.v2.GetLaneByLongLatBBoxResponse
+        """
+        if type(req) != lane_service.GetLaneByLongLatBBoxRequest:
+            req = ParseDict(req, lane_service.GetLaneByLongLatBBoxRequest())
+        res = cast(
+            Awaitable[lane_service.GetLaneByLongLatBBoxResponse],
+            self._aio_stub.GetLaneByLongLatBBox(req),
+        )
+        return async_parse(res, dict_return)

pycityagent/environment/sim/light_service.py

@@ -0,0 +1,120 @@
+from typing import Any, Awaitable, Coroutine, cast, Union, Dict
+
+import grpc
+from google.protobuf.json_format import ParseDict
+from pycityproto.city.map.v2 import traffic_light_service_pb2 as light_service
+from pycityproto.city.map.v2 import traffic_light_service_pb2_grpc as light_grpc
+
+from ..utils.protobuf import async_parse
+
+__all__ = ["LightService"]
+
+
+class LightService:
+    """
+    城市模拟信控服务
+    City simulation traffic light service
+    """
+
+    def __init__(self, aio_channel: grpc.aio.Channel):
+        self._aio_stub = light_grpc.TrafficLightServiceStub(aio_channel)
+
+    def GetTrafficLight(
+        self,
+        req: Union[light_service.GetTrafficLightRequest, Dict[str, Any]],
+        dict_return: bool = True,
+    ) -> Coroutine[
+        Any, Any, Union[Dict[str, Any], light_service.GetTrafficLightResponse]
+    ]:
+        """
+        获取路口的红绿灯信息
+        Get traffic light information
+
+        Args:
+        - req (dict): https://cityproto.sim.fiblab.net/#city.traffic.v1.GetTrafficLightRequest
+
+        Returns:
+        - https://cityproto.sim.fiblab.net/#city.traffic.v1.GetTrafficLightResponse
+        """
+        if type(req) != light_service.GetTrafficLightRequest:
+            req = ParseDict(req, light_service.GetTrafficLightRequest())
+        res = cast(
+            Awaitable[light_service.GetTrafficLightResponse],
+            self._aio_stub.GetTrafficLight(req),
+        )
+        return async_parse(res, dict_return)
+
+    def SetTrafficLight(
+        self,
+        req: Union[light_service.SetTrafficLightRequest, Dict[str, Any]],
+        dict_return: bool = True,
+    ) -> Coroutine[
+        Any, Any, Union[Dict[str, Any], light_service.SetTrafficLightResponse]
+    ]:
+        """
+        设置路口的红绿灯信息
+        Set traffic light information
+
+        Args:
+        - req (dict): https://cityproto.sim.fiblab.net/#city.traffic.v1.SetTrafficLightRequest
+
+        Returns:
+        - https://cityproto.sim.fiblab.net/#city.traffic.v1.SetTrafficLightResponse
+        """
+        if type(req) != light_service.SetTrafficLightRequest:
+            req = ParseDict(req, light_service.SetTrafficLightRequest())
+        res = cast(
+            Awaitable[light_service.SetTrafficLightResponse],
+            self._aio_stub.SetTrafficLight(req),
+        )
+        return async_parse(res, dict_return)
+
+    def SetTrafficLightPhase(
+        self,
+        req: Union[light_service.SetTrafficLightPhaseRequest, dict],
+        dict_return: bool = True,
+    ) -> Coroutine[
+        Any, Any, Union[Dict[str, Any], light_service.SetTrafficLightPhaseResponse]
+    ]:
+        """
+        设置路口的红绿灯相位
+        Set traffic light phase
+
+        Args:
+        - req (dict): https://cityproto.sim.fiblab.net/#city.traffic.v1.SetTrafficLightPhaseRequest
+
+        Returns:
+        - https://cityproto.sim.fiblab.net/#city.traffic.v1.SetTrafficLightPhaseResponse
+        """
+        if type(req) != light_service.SetTrafficLightPhaseRequest:
+            req = ParseDict(req, light_service.SetTrafficLightPhaseRequest())
+        res = cast(
+            Awaitable[light_service.SetTrafficLightPhaseResponse],
+            self._aio_stub.SetTrafficLightPhase(req),
+        )
+        return async_parse(res, dict_return)
+
+    def SetTrafficLightStatus(
+        self,
+        req: Union[light_service.SetTrafficLightStatusRequest, dict],
+        dict_return: bool = True,
+    ) -> Coroutine[
+        Any, Any, Union[Dict[str, Any], light_service.SetTrafficLightStatusResponse]
+    ]:
+        """
+        设置路口的红绿灯状态
+        Set traffic light status
+
+        Args:
+        - req (dict): https://cityproto.sim.fiblab.net/#city.traffic.v1.SetTrafficLightStatusRequest
+
+        Returns:
+        - https://cityproto.sim.fiblab.net/#city.traffic.v1.SetTrafficLightStatusResponse
+        """
+        if type(req) != light_service.SetTrafficLightStatusRequest:
+            req = ParseDict(req, light_service.SetTrafficLightStatusRequest())
+        res = cast(
+            Awaitable[light_service.SetTrafficLightStatusResponse],
+            self._aio_stub.SetTrafficLightStatus(req),
+        )
+        return async_parse(res, dict_return)