antioch-py 2.0.7__py3-none-any.whl → 2.2.1__py3-none-any.whl

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},
     )

antioch/session/objects/radar.py

@@ -0,0 +1,62 @@
+from antioch.session.session import Session, SessionContainer
+from common.message import Pose, RadarScan
+from common.session.config import RadarConfig
+
+
+class Radar(SessionContainer):
+    """
+    Radar object for time-synchronized scan data.
+
+    Example:
+        scene = Scene()
+        radar = scene.get_radar(name="my_ark/my_module/my_radar")
+        scan = radar.get_scan()
+    """
+
+    def __init__(self, path: str):
+        """
+        Initialize Radar object.
+
+        :param path: USD path for the radar.
+        """
+
+        super().__init__()
+        self._session.query_sim_rpc(endpoint="radar/get", payload={"path": path})
+        self._path = path
+
+    @classmethod
+    def add(cls, path: str, config: RadarConfig, world_pose: Pose | None, local_pose: Pose | None) -> "Radar":
+        """
+        Add radar to the scene.
+
+        :param path: USD path for the radar.
+        :param config: Radar configuration.
+        :param world_pose: Optional world pose.
+        :param local_pose: Optional local pose.
+        :return: The radar instance.
+        """
+
+        Session.get_current().query_sim_rpc(
+            endpoint="radar/add",
+            payload={"path": path, "config": config, "world_pose": world_pose, "local_pose": local_pose},
+        )
+        return cls(path)
+
+    def get_scan(self) -> RadarScan | None:
+        """
+        Get radar scan data.
+
+        :return: Radar scan with detections, or None if scan data is not ready.
+        """
+
+        scan = self._session.query_sim_rpc(endpoint="radar/get_scan", payload={"path": self._path})
+        return RadarScan(**scan) if scan else None
+
+    def set_debug_mode(self, enabled: bool) -> None:
+        """
+        Enable or disable debug visualization.
+
+        :param enabled: Whether to enable debug visualization.
+        """
+
+        self._session.query_sim_rpc(endpoint="radar/set_debug_mode", payload={"path": self._path, "enabled": enabled})

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

@@ -1,26 +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.rigid_body import (
-    AddRigidBody,
-    ApplyForce,
-    BodyCenterOfMass,
-    BodyInertia,
-    BodyMass,
-    BodyVelocity,
-    DisableGravity,
-    DisablePhysics,
-    EnableGravity,
-    EnablePhysics,
-    GetBodyCenterOfMass,
-    GetBodyInertia,
-    GetBodyMass,
-    GetBodyVelocity,
-    GetRigidBody,
-    GetRigidBodyResponse,
-    RigidBodyConfig,
-    SetBodyVelocity,
-)
+from common.message import Pose, Twist, Vector3
+from common.session.config import RigidBodyConfig
 
 
 class RigidBody(SessionContainer):
@@ -55,13 +35,8 @@ class RigidBody(SessionContainer):
         """
 
         super().__init__()
-
-        # Validate path
-        self._path = self._session.query_sim_rpc(
-            endpoint="get_rigid_body",
-            payload=GetRigidBody(path=path),
-            response_type=GetRigidBodyResponse,
-        ).path
+        self._session.query_sim_rpc(endpoint="rigid_body/get", payload={"path": path})
+        self._path = path
 
     @classmethod
     def add(
@@ -84,29 +59,19 @@ class RigidBody(SessionContainer):
         """
 
         Session.get_current().query_sim_rpc(
-            endpoint="add_rigid_body",
-            payload=AddRigidBody(
-                path=path,
-                config=config,
-                world_pose=world_pose,
-                local_pose=local_pose,
-                scale=scale,
-            ),
+            endpoint="rigid_body/add",
+            payload={"path": path, "config": config, "world_pose": world_pose, "local_pose": local_pose, "scale": scale},
         )
         return cls(path)
 
-    def get_velocity(self) -> BodyVelocity:
+    def get_velocity(self) -> Twist:
         """
         Get the velocity of the rigid body.
 
         :return: Linear and angular velocities.
         """
 
-        return self._session.query_sim_rpc(
-            endpoint="get_body_velocity",
-            payload=GetBodyVelocity(path=self._path),
-            response_type=BodyVelocity,
-        )
+        return self._session.query_sim_rpc(endpoint="rigid_body/get_velocity", payload={"path": self._path}, response_type=Twist)
 
     def set_velocity(
         self,
@@ -120,16 +85,8 @@ class RigidBody(SessionContainer):
         :param angular: Angular velocity as Vector3 (or list/tuple of 3 floats).
         """
 
-        self._session.query_sim_rpc(
-            endpoint="set_body_velocity",
-            payload=SetBodyVelocity(
-                path=self._path,
-                velocity=BodyVelocity(
-                    linear=Vector3.from_any(linear),
-                    angular=Vector3.from_any(angular),
-                ),
-            ),
-        )
+        twist = Twist(linear=Vector3.from_any(linear), angular=Vector3.from_any(angular))
+        self._session.query_sim_rpc(endpoint="rigid_body/set_velocity", payload={"path": self._path, "twist": twist})
 
     def apply_force(
         self,
@@ -144,12 +101,8 @@ class RigidBody(SessionContainer):
         """
 
         self._session.query_sim_rpc(
-            endpoint="apply_force",
-            payload=ApplyForce(
-                path=self._path,
-                force=Vector3.from_any(force),
-                is_global=is_global,
-            ),
+            endpoint="rigid_body/apply_force",
+            payload={"path": self._path, "force": Vector3.from_any(force), "is_global": is_global},
         )
 
     def get_mass(self) -> float:
@@ -159,11 +112,7 @@ class RigidBody(SessionContainer):
         :return: Mass in kg.
         """
 
-        return self._session.query_sim_rpc(
-            endpoint="get_body_mass",
-            payload=GetBodyMass(path=self._path),
-            response_type=BodyMass,
-        ).mass
+        return self._session.query_sim_rpc(endpoint="rigid_body/get_mass", payload={"path": self._path}, response_type=float)
 
     def get_inertia(self) -> list[float]:
         """
@@ -172,64 +121,44 @@ class RigidBody(SessionContainer):
         :return: Inertia tensor as 9 values (3x3 matrix flattened).
         """
 
-        return self._session.query_sim_rpc(
-            endpoint="get_body_inertia",
-            payload=GetBodyInertia(path=self._path),
-            response_type=BodyInertia,
-        ).inertia
+        return self._session.query_sim_rpc(endpoint="rigid_body/get_inertia", payload={"path": self._path}, response_type=list)
 
-    def get_center_of_mass(self) -> BodyCenterOfMass:
+    def get_center_of_mass(self) -> Pose:
         """
         Get the center of mass position and orientation.
 
-        :return: Center of mass position and orientation.
+        :return: Center of mass as Pose.
         """
 
-        return self._session.query_sim_rpc(
-            endpoint="get_body_center_of_mass",
-            payload=GetBodyCenterOfMass(path=self._path),
-            response_type=BodyCenterOfMass,
-        )
+        return self._session.query_sim_rpc(endpoint="rigid_body/get_center_of_mass", payload={"path": self._path}, response_type=Pose)
 
     def enable_gravity(self) -> None:
         """
         Enable gravity on the rigid body.
         """
 
-        self._session.query_sim_rpc(
-            endpoint="enable_gravity",
-            payload=EnableGravity(path=self._path),
-        )
+        self._session.query_sim_rpc(endpoint="rigid_body/enable_gravity", payload={"path": self._path})
 
     def disable_gravity(self) -> None:
         """
         Disable gravity on the rigid body.
         """
 
-        self._session.query_sim_rpc(
-            endpoint="disable_gravity",
-            payload=DisableGravity(path=self._path),
-        )
+        self._session.query_sim_rpc(endpoint="rigid_body/disable_gravity", payload={"path": self._path})
 
     def enable_physics(self) -> None:
         """
         Enable rigid body physics (make body dynamic).
         """
 
-        self._session.query_sim_rpc(
-            endpoint="enable_physics",
-            payload=EnablePhysics(path=self._path),
-        )
+        self._session.query_sim_rpc(endpoint="rigid_body/enable_physics", payload={"path": self._path})
 
     def disable_physics(self) -> None:
         """
         Disable rigid body physics (make body kinematic).
         """
 
-        self._session.query_sim_rpc(
-            endpoint="disable_physics",
-            payload=DisablePhysics(path=self._path),
-        )
+        self._session.query_sim_rpc(endpoint="rigid_body/disable_physics", payload={"path": self._path})
 
     def get_world_pose(self) -> Pose:
         """
@@ -238,11 +167,7 @@ class RigidBody(SessionContainer):
         :return: World pose.
         """
 
-        return self._session.query_sim_rpc(
-            endpoint="get_rigid_body_world_pose",
-            payload=GetWorldPose(path=self._path),
-            response_type=Pose,
-        )
+        return self._session.query_sim_rpc(endpoint="rigid_body/get_world_pose", payload={"path": self._path}, response_type=Pose)
 
     def get_local_pose(self) -> Pose:
         """
@@ -251,11 +176,7 @@ class RigidBody(SessionContainer):
         :return: Local pose.
         """
 
-        return self._session.query_sim_rpc(
-            endpoint="get_rigid_body_local_pose",
-            payload=GetLocalPose(path=self._path),
-            response_type=Pose,
-        )
+        return self._session.query_sim_rpc(endpoint="rigid_body/get_local_pose", payload={"path": self._path}, response_type=Pose)
 
     def set_world_pose(self, pose: Pose | dict) -> None:
         """
@@ -264,10 +185,7 @@ class RigidBody(SessionContainer):
         :param pose: World pose as Pose (or dict with position/orientation lists).
         """
 
-        self._session.query_sim_rpc(
-            endpoint="set_rigid_body_world_pose",
-            payload=SetWorldPose(path=self._path, pose=Pose.from_any(pose)),
-        )
+        self._session.query_sim_rpc(endpoint="rigid_body/set_world_pose", payload={"path": self._path, "pose": pose})
 
     def set_local_pose(self, pose: Pose | dict) -> None:
         """
@@ -276,7 +194,4 @@ class RigidBody(SessionContainer):
         :param pose: Local pose as Pose (or dict with position/orientation lists).
         """
 
-        self._session.query_sim_rpc(
-            endpoint="set_rigid_body_local_pose",
-            payload=SetLocalPose(path=self._path, pose=Pose.from_any(pose)),
-        )
+        self._session.query_sim_rpc(endpoint="rigid_body/set_local_pose", payload={"path": self._path, "pose": pose})

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

@@ -1,7 +1,5 @@
 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.xform import AddXForm, GetXForm, GetXFormResponse
 
 
 class XForm(SessionContainer):
@@ -31,13 +29,8 @@ class XForm(SessionContainer):
         """
 
         super().__init__()
-
-        # Validate path
-        self._path = self._session.query_sim_rpc(
-            endpoint="get_xform",
-            payload=GetXForm(path=path),
-            response_type=GetXFormResponse,
-        ).path
+        self._session.query_sim_rpc(endpoint="xform/get", payload={"path": path})
+        self._path = path
 
     @classmethod
     def add(
@@ -58,13 +51,8 @@ class XForm(SessionContainer):
         """
 
         Session.get_current().query_sim_rpc(
-            endpoint="add_xform",
-            payload=AddXForm(
-                path=path,
-                world_pose=world_pose,
-                local_pose=local_pose,
-                scale=scale,
-            ),
+            endpoint="xform/add",
+            payload={"path": path, "world_pose": world_pose, "local_pose": local_pose, "scale": scale},
         )
         return cls(path)
 
@@ -76,8 +64,8 @@ class XForm(SessionContainer):
         """
 
         return self._session.query_sim_rpc(
-            endpoint="get_xform_world_pose",
-            payload=GetWorldPose(path=self._path),
+            endpoint="xform/get_world_pose",
+            payload={"path": self._path},
             response_type=Pose,
         )
 
@@ -89,8 +77,8 @@ class XForm(SessionContainer):
         """
 
         return self._session.query_sim_rpc(
-            endpoint="get_xform_local_pose",
-            payload=GetLocalPose(path=self._path),
+            endpoint="xform/get_local_pose",
+            payload={"path": self._path},
             response_type=Pose,
         )
 
@@ -102,8 +90,8 @@ class XForm(SessionContainer):
         """
 
         self._session.query_sim_rpc(
-            endpoint="set_xform_world_pose",
-            payload=SetWorldPose(path=self._path, pose=Pose.from_any(pose)),
+            endpoint="xform/set_world_pose",
+            payload={"path": self._path, "pose": pose},
         )
 
     def set_local_pose(self, pose: Pose | dict) -> None:
@@ -114,6 +102,18 @@ class XForm(SessionContainer):
         """
 
         self._session.query_sim_rpc(
-            endpoint="set_xform_local_pose",
-            payload=SetLocalPose(path=self._path, pose=Pose.from_any(pose)),
+            endpoint="xform/set_local_pose",
+            payload={"path": self._path, "pose": pose},
+        )
+
+    def set_visibility(self, visible: bool) -> None:
+        """
+        Set the visibility of the xform.
+
+        :param visible: True to make visible, False to hide.
+        """
+
+        self._session.query_sim_rpc(
+            endpoint="xform/set_visibility",
+            payload={"path": self._path, "visible": visible},
         )