antioch-py 2.0.6__py3-none-any.whl → 2.1.0__py3-none-any.whl

antioch/session/{views → objects}/camera.py

@@ -1,11 +1,11 @@
 from antioch.session.session import Session, SessionContainer
 from common.message import CameraInfo, Image, Pose
-from common.session.views.camera import AddCamera, CameraConfig, GetCamera, GetCameraFrame, GetCameraResponse
+from common.session.config import CameraConfig
 
 
 class Camera(SessionContainer):
     """
-    Camera view for time-synchronized image capture.
+    Camera object for time-synchronized image capture.
 
     Example:
         scene = Scene()
@@ -13,35 +13,21 @@ class Camera(SessionContainer):
         frame = camera.get_frame()
     """
 
-    def __init__(
-        self,
-        path: str,
-        config: CameraConfig | None = None,
-    ):
+    def __init__(self, path: str, config: CameraConfig | None = None):
         """
-        Initialize camera view.
+        Initialize camera object.
 
         :param path: USD path for the camera.
         :param config: Optional camera config for intrinsics.
         """
 
         super().__init__()
-
         self._config = config
-        self._path = self._session.query_sim_rpc(
-            endpoint="get_camera",
-            payload=GetCamera(path=path),
-            response_type=GetCameraResponse,
-        ).path
+        self._session.query_sim_rpc(endpoint="camera/get", payload={"path": path})
+        self._path = path
 
     @classmethod
-    def add(
-        cls,
-        path: str,
-        config: CameraConfig,
-        world_pose: Pose | None,
-        local_pose: Pose | None,
-    ) -> "Camera":
+    def add(cls, path: str, config: CameraConfig, world_pose: Pose | None, local_pose: Pose | None) -> "Camera":
         """
         Add camera to the scene.
 
@@ -53,13 +39,8 @@ class Camera(SessionContainer):
         """
 
         Session.get_current().query_sim_rpc(
-            endpoint="add_camera",
-            payload=AddCamera(
-                path=path,
-                config=config,
-                world_pose=world_pose,
-                local_pose=local_pose,
-            ),
+            endpoint="camera/add",
+            payload={"path": path, "config": config, "world_pose": world_pose, "local_pose": local_pose},
         )
         return cls(path, config)
 
@@ -70,13 +51,8 @@ class Camera(SessionContainer):
         :return: Image (RGB or depth based on camera mode), or None if image data is not ready.
         """
 
-        image = self._session.query_sim_rpc(
-            endpoint="get_camera_frame",
-            payload=GetCameraFrame(path=self._path),
-            response_type=Image,
-        )
-
-        return image
+        image_dict = self._session.query_sim_rpc(endpoint="camera/get_frame", payload={"path": self._path})
+        return Image(**image_dict) if image_dict else None
 
     def get_camera_info(self, frame_id: str = "camera_optical_frame") -> CameraInfo | None:
         """
@@ -86,7 +62,4 @@ class Camera(SessionContainer):
         :return: CameraInfo with full intrinsics and distortion parameters, or None if no config.
         """
 
-        if self._config is None:
-            return None
-
-        return self._config.to_camera_info(frame_id=frame_id)
+        return self._config.to_camera_info(frame_id=frame_id) if self._config else None

antioch/session/objects/collision.py

@@ -0,0 +1,46 @@
+from antioch.session.session import Session
+from common.session.config import MeshApproximation
+
+
+def set_collision(path: str, mesh_approximation: MeshApproximation | None = None) -> None:
+    """
+    Apply collision API to a prim, optionally with mesh approximation.
+
+    :param path: USD path to the prim.
+    :param mesh_approximation: Optional mesh approximation method for collision geometry.
+    """
+
+    Session.get_current().query_sim_rpc(endpoint="set_collision", payload={"path": path, "mesh_approximation": mesh_approximation})
+
+
+def remove_collision(path: str) -> None:
+    """
+    Remove collision API from a prim.
+
+    :param path: USD path to the prim.
+    """
+
+    Session.get_current().query_sim_rpc(endpoint="remove_collision", payload={"path": path})
+
+
+def has_collision(path: str) -> bool:
+    """
+    Check if a prim has collision API applied.
+
+    :param path: USD path to the prim.
+    :return: True if collision API is applied.
+    """
+
+    return Session.get_current().query_sim_rpc(endpoint="has_collision", payload={"path": path}, response_type=bool)
+
+
+def get_mesh_approximation(path: str) -> MeshApproximation | None:
+    """
+    Get mesh collision approximation from a prim.
+
+    :param path: USD path to the prim.
+    :return: Mesh approximation method, or None if not set.
+    """
+
+    result = Session.get_current().query_sim_rpc(endpoint="get_mesh_approximation", payload={"path": path})
+    return MeshApproximation(result) if result else None

antioch/session/{views → objects}/geometry.py

@@ -1,6 +1,6 @@
 from antioch.session.session import Session, SessionContainer
 from common.message import Pose
-from common.session.views.geometry import AddGeometry, GeometryConfig, GetGeometry, GetGeometryResponse
+from common.session.config import GeometryConfig
 
 
 class Geometry(SessionContainer):
@@ -36,22 +36,11 @@ class Geometry(SessionContainer):
         """
 
         super().__init__()
-
-        # Validate path
-        self._path = self._session.query_sim_rpc(
-            endpoint="get_geometry",
-            payload=GetGeometry(path=path),
-            response_type=GetGeometryResponse,
-        ).path
+        self._session.query_sim_rpc(endpoint="geometry/get", payload={"path": path})
+        self._path = path
 
     @classmethod
-    def add(
-        cls,
-        path: str,
-        config: GeometryConfig,
-        world_pose: Pose | None,
-        local_pose: Pose | None,
-    ) -> "Geometry":
+    def add(cls, path: str, config: GeometryConfig, world_pose: Pose | None, local_pose: Pose | None) -> "Geometry":
         """
         Add geometry to the scene.
 
@@ -63,12 +52,7 @@ class Geometry(SessionContainer):
         """
 
         Session.get_current().query_sim_rpc(
-            endpoint="add_geometry",
-            payload=AddGeometry(
-                path=path,
-                config=config,
-                world_pose=world_pose,
-                local_pose=local_pose,
-            ),
+            endpoint="geometry/add",
+            payload={"path": path, "config": config, "world_pose": world_pose, "local_pose": local_pose},
         )
         return cls(path)

antioch/session/{views → objects}/ground_plane.py

@@ -1,5 +1,5 @@
 from antioch.session.session import Session, SessionContainer
-from common.session.views.ground_plane import AddGroundPlane, GetGroundPlane, GetGroundPlaneResponse, GroundPlaneConfig
+from common.session.config import GroundPlaneConfig
 
 
 class GroundPlane(SessionContainer):
@@ -31,20 +31,11 @@ class GroundPlane(SessionContainer):
         """
 
         super().__init__()
-
-        # Validate path
-        self._path = self._session.query_sim_rpc(
-            endpoint="get_ground_plane",
-            payload=GetGroundPlane(path=path),
-            response_type=GetGroundPlaneResponse,
-        ).path
+        self._session.query_sim_rpc(endpoint="ground_plane/get", payload={"path": path})
+        self._path = path
 
     @classmethod
-    def add(
-        cls,
-        path: str,
-        config: GroundPlaneConfig,
-    ) -> "GroundPlane":
+    def add(cls, path: str, config: GroundPlaneConfig) -> "GroundPlane":
         """
         Add a ground plane to the scene.
 
@@ -53,11 +44,5 @@ class GroundPlane(SessionContainer):
         :return: The ground plane instance.
         """
 
-        Session.get_current().query_sim_rpc(
-            endpoint="add_ground_plane",
-            payload=AddGroundPlane(
-                path=path,
-                config=config,
-            ),
-        )
+        Session.get_current().query_sim_rpc(endpoint="ground_plane/add", payload={"path": path, "config": config})
         return cls(path)

antioch/session/{views → objects}/imu.py

@@ -1,11 +1,11 @@
 from antioch.session.session import Session, SessionContainer
 from common.message import ImuSample, Pose
-from common.session.views.imu import AddImu, GetImu, GetImuResponse, GetImuSample, ImuConfig
+from common.session.config import ImuConfig
 
 
 class Imu(SessionContainer):
     """
-    IMU view for time-synchronized sensor data.
+    IMU object for time-synchronized sensor data.
 
     Example:
         scene = Scene()
@@ -15,27 +15,17 @@ class Imu(SessionContainer):
 
     def __init__(self, path: str):
         """
-        Initialize IMU view.
+        Initialize IMU object.
 
         :param path: USD path for the IMU.
         """
 
         super().__init__()
-
-        self._path = self._session.query_sim_rpc(
-            endpoint="get_imu",
-            payload=GetImu(path=path),
-            response_type=GetImuResponse,
-        ).path
+        self._session.query_sim_rpc(endpoint="imu/get", payload={"path": path})
+        self._path = path
 
     @classmethod
-    def add(
-        cls,
-        path: str,
-        config: ImuConfig,
-        world_pose: Pose | None,
-        local_pose: Pose | None,
-    ) -> "Imu":
+    def add(cls, path: str, config: ImuConfig, world_pose: Pose | None, local_pose: Pose | None) -> "Imu":
         """
         Add IMU to the scene.
 
@@ -47,13 +37,8 @@ class Imu(SessionContainer):
         """
 
         Session.get_current().query_sim_rpc(
-            endpoint="add_imu",
-            payload=AddImu(
-                path=path,
-                config=config,
-                world_pose=world_pose,
-                local_pose=local_pose,
-            ),
+            endpoint="imu/add",
+            payload={"path": path, "config": config, "world_pose": world_pose, "local_pose": local_pose},
         )
         return cls(path)
 
@@ -64,10 +49,5 @@ class Imu(SessionContainer):
         :return: IMU sensor measurements, or None if sensor data is not ready.
         """
 
-        sample = self._session.query_sim_rpc(
-            endpoint="get_imu_sample",
-            payload=GetImuSample(path=self._path),
-            response_type=ImuSample,
-        )
-
-        return sample
+        sample = self._session.query_sim_rpc(endpoint="imu/get_sample", payload={"path": self._path})
+        return ImuSample(**sample) if sample else None

antioch/session/{views → objects}/joint.py

@@ -1,5 +1,5 @@
 from antioch.session.session import Session, SessionContainer
-from common.session.views.joint import AddJoint, GetJoint, GetJointResponse, JointConfig
+from common.session.config import JointConfig
 
 
 class Joint(SessionContainer):
@@ -32,20 +32,11 @@ class Joint(SessionContainer):
         """
 
         super().__init__()
-
-        # Validate path
-        self._path = self._session.query_sim_rpc(
-            endpoint="get_joint",
-            payload=GetJoint(path=path),
-            response_type=GetJointResponse,
-        ).path
+        self._session.query_sim_rpc(endpoint="joint/get", payload={"path": path})
+        self._path = path
 
     @classmethod
-    def add(
-        cls,
-        path: str,
-        config: JointConfig,
-    ) -> "Joint":
+    def add(cls, path: str, config: JointConfig) -> "Joint":
         """
         Add a joint to the scene.
 
@@ -54,11 +45,5 @@ class Joint(SessionContainer):
         :return: The joint instance.
         """
 
-        Session.get_current().query_sim_rpc(
-            endpoint="add_joint",
-            payload=AddJoint(
-                path=path,
-                config=config,
-            ),
-        )
+        Session.get_current().query_sim_rpc(endpoint="joint/add", payload={"path": path, "config": config})
         return cls(path)

antioch/session/{views → objects}/light.py

@@ -1,16 +1,6 @@
 from antioch.session.session import Session, SessionContainer
 from common.message import Pose, Vector3
-from common.session.sim import GetLocalPose, GetWorldPose, SetLocalPose, SetWorldPose
-from common.session.views.light import (
-    AddLight,
-    DisableLight,
-    EnableLight,
-    GetLight,
-    GetLightResponse,
-    LightConfig,
-    SetLightColor,
-    SetLightIntensity,
-)
+from common.session.config import LightConfig
 
 
 class Light(SessionContainer):
@@ -43,22 +33,11 @@ class Light(SessionContainer):
         """
 
         super().__init__()
-
-        # Validate path
-        self._path = self._session.query_sim_rpc(
-            endpoint="get_light",
-            payload=GetLight(path=path),
-            response_type=GetLightResponse,
-        ).path
+        self._session.query_sim_rpc(endpoint="light/get", payload={"path": path})
+        self._path = path
 
     @classmethod
-    def add(
-        cls,
-        path: str,
-        config: LightConfig,
-        world_pose: Pose | None,
-        local_pose: Pose | None,
-    ) -> "Light":
+    def add(cls, path: str, config: LightConfig, world_pose: Pose | None, local_pose: Pose | None) -> "Light":
         """
         Add a light to the scene.
 
@@ -70,13 +49,8 @@ class Light(SessionContainer):
         """
 
         Session.get_current().query_sim_rpc(
-            endpoint="add_light",
-            payload=AddLight(
-                path=path,
-                config=config,
-                world_pose=world_pose,
-                local_pose=local_pose,
-            ),
+            endpoint="light/add",
+            payload={"path": path, "config": config, "world_pose": world_pose, "local_pose": local_pose},
         )
         return cls(path)
 
@@ -87,11 +61,7 @@ class Light(SessionContainer):
         :return: World pose.
         """
 
-        return self._session.query_sim_rpc(
-            endpoint="get_light_world_pose",
-            payload=GetWorldPose(path=self._path),
-            response_type=Pose,
-        )
+        return self._session.query_sim_rpc(endpoint="light/get_world_pose", payload={"path": self._path}, response_type=Pose)
 
     def get_local_pose(self) -> Pose:
         """
@@ -100,11 +70,7 @@ class Light(SessionContainer):
         :return: Local pose.
         """
 
-        return self._session.query_sim_rpc(
-            endpoint="get_light_local_pose",
-            payload=GetLocalPose(path=self._path),
-            response_type=Pose,
-        )
+        return self._session.query_sim_rpc(endpoint="light/get_local_pose", payload={"path": self._path}, response_type=Pose)
 
     def set_world_pose(self, pose: Pose | dict) -> None:
         """
@@ -113,10 +79,7 @@ class Light(SessionContainer):
         :param pose: World pose as Pose (or dict with position/orientation lists).
         """
 
-        self._session.query_sim_rpc(
-            endpoint="set_light_world_pose",
-            payload=SetWorldPose(path=self._path, pose=Pose.from_any(pose)),
-        )
+        self._session.query_sim_rpc(endpoint="light/set_world_pose", payload={"path": self._path, "pose": pose})
 
     def set_local_pose(self, pose: Pose | dict) -> None:
         """
@@ -125,10 +88,7 @@ class Light(SessionContainer):
         :param pose: Local pose as Pose (or dict with position/orientation lists).
         """
 
-        self._session.query_sim_rpc(
-            endpoint="set_light_local_pose",
-            payload=SetLocalPose(path=self._path, pose=Pose.from_any(pose)),
-        )
+        self._session.query_sim_rpc(endpoint="light/set_local_pose", payload={"path": self._path, "pose": pose})
 
     def set_intensity(self, intensity: float) -> None:
         """
@@ -137,10 +97,7 @@ class Light(SessionContainer):
         :param intensity: Light intensity value.
         """
 
-        self._session.query_sim_rpc(
-            endpoint="set_light_intensity",
-            payload=SetLightIntensity(path=self._path, intensity=intensity),
-        )
+        self._session.query_sim_rpc(endpoint="light/set_intensity", payload={"path": self._path, "intensity": intensity})
 
     def set_color(self, color: Vector3 | list[float] | tuple[float, float, float]) -> None:
         """
@@ -149,27 +106,18 @@ class Light(SessionContainer):
         :param color: RGB color as Vector3 (or list/tuple of 3 floats) with values 0-1.
         """
 
-        self._session.query_sim_rpc(
-            endpoint="set_light_color",
-            payload=SetLightColor(path=self._path, color=Vector3.from_any(color)),
-        )
+        self._session.query_sim_rpc(endpoint="light/set_color", payload={"path": self._path, "color": color})
 
     def enable(self) -> None:
         """
         Enable the light (make it illuminate the scene).
         """
 
-        self._session.query_sim_rpc(
-            endpoint="enable_light",
-            payload=EnableLight(path=self._path),
-        )
+        self._session.query_sim_rpc(endpoint="light/enable", payload={"path": self._path})
 
     def disable(self) -> None:
         """
         Disable the light (turn it off).
         """
 
-        self._session.query_sim_rpc(
-            endpoint="disable_light",
-            payload=DisableLight(path=self._path),
-        )
+        self._session.query_sim_rpc(endpoint="light/disable", payload={"path": self._path})

antioch/session/{views → objects}/pir_sensor.py

@@ -1,22 +1,14 @@
 from antioch.session.session import Session, SessionContainer
 from common.message import PirStatus, Pose
-from common.session.views.pir_sensor import (
-    AddPirSensor,
-    GetPirDetectionStatus,
-    GetPirSensor,
-    GetPirSensorResponse,
-    PirSensorConfig,
-    SetPirDebugMode,
-    SetPirMaterial,
-)
+from common.session.config import PirSensorConfig
 
 
 class PirSensor(SessionContainer):
     """
-    PIR (Passive Infrared) sensor view for motion detection.
+    PIR (Passive Infrared) sensor object for motion detection.
 
     PIR sensors detect infrared radiation changes caused by moving warm objects.
-    The sensor uses a dual-element design with interleaved zones for motion detection.
+    The sensor uses a 3-sensor design (center, left, right) with dual elements per sensor.
 
     Example:
         scene = Scene()
@@ -27,35 +19,21 @@ class PirSensor(SessionContainer):
         print(f"Detected: {status.is_detected}")
     """
 
-    def __init__(
-        self,
-        path: str,
-        config: PirSensorConfig | None = None,
-    ):
+    def __init__(self, path: str, config: PirSensorConfig | None = None):
         """
-        Initialize PIR sensor view.
+        Initialize PIR sensor object.
 
         :param path: USD path for the PIR sensor.
         :param config: Optional PIR sensor config.
         """
 
         super().__init__()
-
         self._config = config
-        self._path = self._session.query_sim_rpc(
-            endpoint="get_pir_sensor",
-            payload=GetPirSensor(path=path),
-            response_type=GetPirSensorResponse,
-        ).path
+        self._session.query_sim_rpc(endpoint="pir_sensor/get", payload={"path": path})
+        self._path = path
 
     @classmethod
-    def add(
-        cls,
-        path: str,
-        config: PirSensorConfig,
-        world_pose: Pose | None,
-        local_pose: Pose | None,
-    ) -> "PirSensor":
+    def add(cls, path: str, config: PirSensorConfig, world_pose: Pose | None, local_pose: Pose | None) -> "PirSensor":
         """
         Add PIR sensor to the scene.
 
@@ -67,13 +45,8 @@ class PirSensor(SessionContainer):
         """
 
         Session.get_current().query_sim_rpc(
-            endpoint="add_pir_sensor",
-            payload=AddPirSensor(
-                path=path,
-                config=config,
-                world_pose=world_pose,
-                local_pose=local_pose,
-            ),
+            endpoint="pir_sensor/add",
+            payload={"path": path, "config": config, "world_pose": world_pose, "local_pose": local_pose},
         )
         return cls(path, config)
 
@@ -81,39 +54,28 @@ class PirSensor(SessionContainer):
         """
         Get current detection status.
 
-        :return: Detection status with is_detected, signal_strength, threshold, element_flux, and element_signal.
+        :return: Detection status with is_detected, signal_strength, and per-sensor details.
         """
 
-        status = self._session.query_sim_rpc(
-            endpoint="get_pir_detection_status",
-            payload=GetPirDetectionStatus(path=self._path),
-            response_type=PirStatus,
-        )
-        return status
+        return PirStatus(**self._session.query_sim_rpc(endpoint="pir_sensor/get_status", payload={"path": self._path}))
 
     def set_debug_mode(self, enabled: bool) -> None:
         """
         Enable or disable debug ray visualization.
 
         When enabled, rays are drawn each update:
-        - Red rays for element 0
-        - Blue rays for element 1
-        - Green points at hit locations
+        - Green: Center sensor
+        - Blue: Left sensor
+        - Red: Right sensor
+        - Cyan points at hit locations
 
         :param enabled: Whether to enable debug visualization.
         """
 
-        self._session.query_sim_rpc(
-            endpoint="set_pir_debug_mode",
-            payload=SetPirDebugMode(path=self._path, enabled=enabled),
-        )
+        self._session.query_sim_rpc(endpoint="pir_sensor/set_debug_mode", payload={"path": self._path, "enabled": enabled})
 
 
-def set_pir_material(
-    path: str,
-    emissivity: float = 0.9,
-    temperature_c: float | None = None,
-) -> None:
+def set_pir_material(path: str, emissivity: float = 0.9, temperature_c: float | None = None) -> None:
     """
     Set PIR-specific thermal properties on a prim.
 
@@ -131,10 +93,6 @@ def set_pir_material(
     """
 
     Session.get_current().query_sim_rpc(
-        endpoint="set_pir_material",
-        payload=SetPirMaterial(
-            path=path,
-            emissivity=emissivity,
-            temperature_c=temperature_c,
-        ),
+        endpoint="pir_material/set",
+        payload={"path": path, "emissivity": emissivity, "temperature_c": temperature_c},
     )