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

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

@@ -2,18 +2,6 @@ from typing import Literal
 
 from antioch.session.session import Session, SessionContainer
 from common.message import Vector3
-from common.session.views.basis_curve import (
-    AddBasisCurveLine,
-    AddBasisCurveSemiCircle,
-    GetBasisCurve,
-    GetBasisCurveExtents,
-    GetBasisCurveExtentsResponse,
-    GetBasisCurvePoints,
-    GetBasisCurvePointsResponse,
-    GetBasisCurveResponse,
-    RemoveBasisCurve,
-    SetBasisCurveVisibility,
-)
 
 
 class BasisCurve(SessionContainer):
@@ -45,13 +33,8 @@ class BasisCurve(SessionContainer):
         """
 
         super().__init__()
-
-        # Validate path
-        self._path = self._session.query_sim_rpc(
-            endpoint="get_basis_curve",
-            payload=GetBasisCurve(path=path),
-            response_type=GetBasisCurveResponse,
-        ).path
+        self._session.query_sim_rpc(endpoint="basis_curve/get", payload={"path": path})
+        self._path = path
 
     @property
     def path(self) -> str:
@@ -71,6 +54,9 @@ class BasisCurve(SessionContainer):
         radius: float = 1.0,
         min_angle_deg: float = 0.0,
         max_angle_deg: float = 180.0,
+        guide: bool = False,
+        color: Vector3 | None = None,
+        width: float = 0.005,
     ) -> "BasisCurve":
         """
         Add a semi-circle basis curve to the scene.
@@ -80,18 +66,24 @@ class BasisCurve(SessionContainer):
         :param radius: Radius of the basis curve.
         :param min_angle_deg: Minimum angle of the basis curve in degrees.
         :param max_angle_deg: Maximum angle of the basis curve in degrees.
+        :param guide: If True, mark as guide purpose (invisible to cameras). If False, default purpose.
+        :param color: Optional RGB color [0-1].
+        :param width: Width of the curve.
         :return: The basis curve instance.
         """
 
         Session.get_current().query_sim_rpc(
-            endpoint="add_basis_curve_semi_circle",
-            payload=AddBasisCurveSemiCircle(
-                path=path,
-                center=center,
-                radius=radius,
-                min_angle_deg=min_angle_deg,
-                max_angle_deg=max_angle_deg,
-            ),
+            endpoint="basis_curve/add_semi_circle",
+            payload={
+                "path": path,
+                "center": center,
+                "radius": radius,
+                "min_angle_deg": min_angle_deg,
+                "max_angle_deg": max_angle_deg,
+                "guide": guide,
+                "color": color,
+                "width": width,
+            },
         )
         return cls(path)
 
@@ -103,6 +95,9 @@ class BasisCurve(SessionContainer):
         end: Vector3 | None = None,
         angle_deg: float | None = None,
         length: float | None = None,
+        guide: bool = False,
+        color: Vector3 | None = None,
+        width: float = 0.005,
     ) -> "BasisCurve":
         """
         Add a line basis curve to the scene.
@@ -116,19 +111,25 @@ class BasisCurve(SessionContainer):
         :param end: End point of the line (Cartesian mode).
         :param angle_deg: Angle in degrees from +X axis in XY plane (polar mode).
         :param length: Length of the line (polar mode).
+        :param guide: If True, mark as guide purpose (invisible to cameras). If False, default purpose.
+        :param color: Optional RGB color [0-1].
+        :param width: Width of the curve.
         :return: The basis curve instance.
         :raises ValueError: If both modes are specified or neither mode is complete.
         """
 
         Session.get_current().query_sim_rpc(
-            endpoint="add_basis_curve_line",
-            payload=AddBasisCurveLine(
-                path=path,
-                start=start,
-                end=end,
-                angle_deg=angle_deg,
-                length=length,
-            ),
+            endpoint="basis_curve/add_line",
+            payload={
+                "path": path,
+                "start": start,
+                "end": end,
+                "angle_deg": angle_deg,
+                "length": length,
+                "guide": guide,
+                "color": color,
+                "width": width,
+            },
         )
         return cls(path)
 
@@ -139,12 +140,10 @@ class BasisCurve(SessionContainer):
         :return: Extents as tuple of start and end points.
         """
 
-        extents = self._session.query_sim_rpc(
-            endpoint="get_basis_curve_extents",
-            payload=GetBasisCurveExtents(path=self._path),
-            response_type=GetBasisCurveExtentsResponse,
-        )
-        return extents.start, extents.end
+        result = self._session.query_sim_rpc(endpoint="basis_curve/get_extents", payload={"path": self._path})
+        if result is None:
+            raise RuntimeError("Failed to get extents")
+        return Vector3(**result[0]), Vector3(**result[1])
 
     def get_points(
         self, samples_per_segment: int = 10, sort_by: Literal["X", "Y", "Z"] | None = None, ascending: bool = True
@@ -157,11 +156,12 @@ class BasisCurve(SessionContainer):
         :param ascending: Whether to sort the points in ascending order.
         :return: The points of the basis curve.
         """
-        return self._session.query_sim_rpc(
-            endpoint="get_basis_curve_points",
-            payload=GetBasisCurvePoints(path=self._path, samples_per_segment=samples_per_segment, sort_by=sort_by, ascending=ascending),
-            response_type=GetBasisCurvePointsResponse,
-        ).points
+
+        response = self._session.query_sim_rpc(
+            endpoint="basis_curve/get_points",
+            payload={"path": self._path, "samples_per_segment": samples_per_segment, "sort_by": sort_by, "ascending": ascending},
+        )
+        return [Vector3(**pt) for pt in response] if response else []
 
     def set_visibility(self, visible: bool) -> None:
         """
@@ -170,17 +170,11 @@ class BasisCurve(SessionContainer):
         :param visible: True to make visible, False to hide.
         """
 
-        self._session.query_sim_rpc(
-            endpoint="set_basis_curve_visibility",
-            payload=SetBasisCurveVisibility(path=self._path, visible=visible),
-        )
+        self._session.query_sim_rpc(endpoint="basis_curve/set_visibility", payload={"path": self._path, "visible": visible})
 
     def remove(self) -> None:
         """
         Remove the basis curve from the scene.
         """
 
-        self._session.query_sim_rpc(
-            endpoint="remove_basis_curve",
-            payload=RemoveBasisCurve(path=self._path),
-        )
+        self._session.query_sim_rpc(endpoint="basis_curve/remove", payload={"path": self._path})

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