antioch-py 2.2.4__py3-none-any.whl → 3.0.0__py3-none-any.whl

antioch/session/objects/basis_curve.py

@@ -1,180 +0,0 @@
-from typing import Literal
-
-from antioch.session.session import Session, SessionContainer
-from common.message import Vector3
-
-
-class BasisCurve(SessionContainer):
-    """
-    Ergonomic wrapper for basis curve operations.
-
-    BasisCurves should be added using scene.add_basis_curve() or retrieved using scene.get_basis_curve().
-
-    Example:
-        scene = Scene()
-
-        # Add basis curve
-        basis_curve = scene.add_basis_curve(
-            path="/World/curve",
-            center=[1.0, 2.0, 3.0],
-            radius=2.0,
-            min_angle_deg=0.0,
-            max_angle_deg=180.0,
-        )
-
-        extents = basis_curve.get_extents()
-    """
-
-    def __init__(self, path: str):
-        """
-        Initialize basis curve by resolving path and validating existence.
-
-        :param path: USD path for the basis curve.
-        """
-
-        super().__init__()
-        self._session.query_sim_rpc(endpoint="basis_curve/get", payload={"path": path})
-        self._path = path
-
-    @property
-    def path(self) -> str:
-        """
-        Get the path of the basis curve.
-
-        :return: The path of the basis curve.
-        """
-
-        return self._path
-
-    @classmethod
-    def add(
-        cls,
-        path: str,
-        center: Vector3 = Vector3.zeros(),
-        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.
-
-        :param path: USD path for the basis curve.
-        :param center: Center of the basis curve.
-        :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="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)
-
-    @classmethod
-    def add_line(
-        cls,
-        path: str,
-        start: Vector3,
-        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.
-
-        Supports two modes:
-        - Cartesian: Provide start and end points directly
-        - Polar: Provide start point, angle (degrees from +X axis in XY plane), and length
-
-        :param path: USD path for the basis curve.
-        :param start: Start point of the line.
-        :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="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)
-
-    def get_extents(self) -> tuple[Vector3, Vector3]:
-        """
-        Get the extents of the basis curve.
-
-        :return: Extents as tuple of start and end points.
-        """
-
-        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
-    ) -> list[Vector3]:
-        """
-        Get the points of the basis curve.
-
-        :param samples_per_segment: The number of samples per segment.
-        :param sort_by: The axis to sort the points by.
-        :param ascending: Whether to sort the points in ascending order.
-        :return: The points of the basis curve.
-        """
-
-        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:
-        """
-        Set the visibility of the basis curve.
-
-        :param visible: True to make visible, False to hide.
-        """
-
-        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="basis_curve/remove", payload={"path": self._path})

antioch/session/objects/camera.py

@@ -1,65 +0,0 @@
-from antioch.session.session import Session, SessionContainer
-from common.message import CameraInfo, Image, Pose
-from common.session.config import CameraConfig
-
-
-class Camera(SessionContainer):
-    """
-    Camera object for time-synchronized image capture.
-
-    Example:
-        scene = Scene()
-        camera = scene.get_camera(name="my_ark/my_module/my_camera")
-        frame = camera.get_frame()
-    """
-
-    def __init__(self, path: str, config: CameraConfig | None = None):
-        """
-        Initialize camera object.
-
-        :param path: USD path for the camera.
-        :param config: Optional camera config for intrinsics.
-        """
-
-        super().__init__()
-        self._config = config
-        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":
-        """
-        Add camera to the scene.
-
-        :param path: USD path for the camera.
-        :param config: Camera configuration.
-        :param world_pose: Optional world pose.
-        :param local_pose: Optional local pose.
-        :return: The camera instance.
-        """
-
-        Session.get_current().query_sim_rpc(
-            endpoint="camera/add",
-            payload={"path": path, "config": config, "world_pose": world_pose, "local_pose": local_pose},
-        )
-        return cls(path, config)
-
-    def get_frame(self) -> Image | None:
-        """
-        Get camera frame with image data.
-
-        :return: Image (RGB or depth based on camera mode), or None if image data is not ready.
-        """
-
-        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:
-        """
-        Get camera info with calculated intrinsics.
-
-        :param frame_id: The coordinate frame ID for the camera.
-        :return: CameraInfo with full intrinsics and distortion parameters, or None if no config.
-        """
-
-        return self._config.to_camera_info(frame_id=frame_id) if self._config else None

antioch/session/objects/collision.py

@@ -1,46 +0,0 @@
-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/objects/geometry.py

@@ -1,58 +0,0 @@
-from antioch.session.session import Session, SessionContainer
-from common.message import Pose
-from common.session.config import GeometryConfig
-
-
-class Geometry(SessionContainer):
-    """
-    Ergonomic wrapper for geometry operations.
-
-    Geometry provides basic shapes (sphere, cube, cylinder, cone, capsule) with
-    collision, material, and visual properties. Geometries should be added using
-    scene.add_geometry() or retrieved using scene.get_geometry().
-
-    Example:
-        scene = Scene()
-
-        # Add geometry with flexible types (lists/tuples auto-convert)
-        geom = scene.add_geometry(
-            path="/World/cube",
-            geometry_type=GeometryType.CUBE,
-            size=[1.0, 1.0, 1.0],
-            color=(1.0, 0.0, 0.0),
-            world_pose={"position": [0, 0, 1], "orientation": [1, 0, 0, 0]}
-        )
-
-        # For dynamic pose control, use XForm
-        xform = scene.get_xform(path="/World/cube")
-        pose = xform.get_world_pose()
-    """
-
-    def __init__(self, path: str):
-        """
-        Initialize geometry by resolving path and validating existence.
-
-        :param path: USD path for the geometry.
-        """
-
-        super().__init__()
-        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":
-        """
-        Add geometry to the scene.
-
-        :param path: USD path for the geometry.
-        :param config: Geometry configuration.
-        :param world_pose: Optional world pose.
-        :param local_pose: Optional local pose.
-        :return: The geometry instance.
-        """
-
-        Session.get_current().query_sim_rpc(
-            endpoint="geometry/add",
-            payload={"path": path, "config": config, "world_pose": world_pose, "local_pose": local_pose},
-        )
-        return cls(path)

antioch/session/objects/ground_plane.py

@@ -1,48 +0,0 @@
-from antioch.session.session import Session, SessionContainer
-from common.session.config import GroundPlaneConfig
-
-
-class GroundPlane(SessionContainer):
-    """
-    Ergonomic wrapper for ground plane operations.
-
-    Ground planes should be added using scene.add_ground_plane() or retrieved using scene.get_ground_plane().
-
-    Note: Ground planes do not support pose modification after creation.
-    Set the z_position during creation.
-
-    Example:
-        scene = Scene()
-
-        # Add ground plane
-        ground = scene.add_ground_plane(
-            path="/World/Ground",
-            size=5000.0,
-            z_position=0.0,
-            color=[0.5, 0.5, 0.5]
-        )
-    """
-
-    def __init__(self, path: str):
-        """
-        Initialize ground plane by resolving path and validating existence.
-
-        :param path: USD path for the ground plane.
-        """
-
-        super().__init__()
-        self._session.query_sim_rpc(endpoint="ground_plane/get", payload={"path": path})
-        self._path = path
-
-    @classmethod
-    def add(cls, path: str, config: GroundPlaneConfig) -> "GroundPlane":
-        """
-        Add a ground plane to the scene.
-
-        :param path: USD path for the ground plane.
-        :param config: Ground plane configuration.
-        :return: The ground plane instance.
-        """
-
-        Session.get_current().query_sim_rpc(endpoint="ground_plane/add", payload={"path": path, "config": config})
-        return cls(path)

antioch/session/objects/imu.py

@@ -1,53 +0,0 @@
-from antioch.session.session import Session, SessionContainer
-from common.message import ImuSample, Pose
-from common.session.config import ImuConfig
-
-
-class Imu(SessionContainer):
-    """
-    IMU object for time-synchronized sensor data.
-
-    Example:
-        scene = Scene()
-        imu = scene.get_imu(name="my_ark/my_module/my_imu")
-        sample = imu.get_sample()
-    """
-
-    def __init__(self, path: str):
-        """
-        Initialize IMU object.
-
-        :param path: USD path for the IMU.
-        """
-
-        super().__init__()
-        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":
-        """
-        Add IMU to the scene.
-
-        :param path: USD path for the IMU.
-        :param config: IMU configuration.
-        :param world_pose: Optional world pose.
-        :param local_pose: Optional local pose.
-        :return: The IMU instance.
-        """
-
-        Session.get_current().query_sim_rpc(
-            endpoint="imu/add",
-            payload={"path": path, "config": config, "world_pose": world_pose, "local_pose": local_pose},
-        )
-        return cls(path)
-
-    def get_sample(self) -> ImuSample | None:
-        """
-        Get IMU sensor sample.
-
-        :return: IMU sensor measurements, or None if sensor data is not ready.
-        """
-
-        sample = self._session.query_sim_rpc(endpoint="imu/get_sample", payload={"path": self._path})
-        return ImuSample(**sample) if sample else None

antioch/session/objects/joint.py

@@ -1,49 +0,0 @@
-from antioch.session.session import Session, SessionContainer
-from common.session.config import JointConfig
-
-
-class Joint(SessionContainer):
-    """
-    Ergonomic wrapper for joint operations.
-
-    Joints connect two bodies and define kinematic constraints between them.
-    Joints should be added using scene.add_joint() or retrieved using scene.get_joint().
-
-    Example:
-        scene = Scene()
-
-        # Add a revolute joint between two bodies
-        joint = scene.add_joint(
-            path="/World/robot/joint1",
-            parent_path="/World/robot/link1",
-            child_path="/World/robot/link2",
-            joint_type=JointType.REVOLUTE,
-            axis=JointAxis.Z,
-            lower_limit=-180.0,
-            upper_limit=180.0,
-        )
-    """
-
-    def __init__(self, path: str):
-        """
-        Initialize joint by resolving path and validating existence.
-
-        :param path: USD path for the joint.
-        """
-
-        super().__init__()
-        self._session.query_sim_rpc(endpoint="joint/get", payload={"path": path})
-        self._path = path
-
-    @classmethod
-    def add(cls, path: str, config: JointConfig) -> "Joint":
-        """
-        Add a joint to the scene.
-
-        :param path: USD path for the joint.
-        :param config: Joint configuration.
-        :return: The joint instance.
-        """
-
-        Session.get_current().query_sim_rpc(endpoint="joint/add", payload={"path": path, "config": config})
-        return cls(path)

antioch/session/objects/light.py

@@ -1,123 +0,0 @@
-from antioch.session.session import Session, SessionContainer
-from common.message import Pose, Vector3
-from common.session.config import LightConfig
-
-
-class Light(SessionContainer):
-    """
-    Ergonomic wrapper for light operations.
-
-    Lights should be added using scene.add_light() or retrieved using scene.get_light().
-
-    Example:
-        scene = Scene()
-
-        # Add light
-        light = scene.add_light(
-            path="/World/Sun",
-            light_type=LightType.DISTANT,
-            intensity=30000.0,
-            color=[1.0, 0.9, 0.8]
-        )
-
-        # Set color with a tuple
-        light.set_color((0.5, 0.7, 1.0))
-        pose = light.get_world_pose()
-    """
-
-    def __init__(self, path: str):
-        """
-        Initialize light by resolving path and validating existence.
-
-        :param path: USD path for the light.
-        """
-
-        super().__init__()
-        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":
-        """
-        Add a light to the scene.
-
-        :param path: USD path for the light.
-        :param config: Light configuration.
-        :param world_pose: Optional world pose.
-        :param local_pose: Optional local pose.
-        :return: The light instance.
-        """
-
-        Session.get_current().query_sim_rpc(
-            endpoint="light/add",
-            payload={"path": path, "config": config, "world_pose": world_pose, "local_pose": local_pose},
-        )
-        return cls(path)
-
-    def get_world_pose(self) -> Pose:
-        """
-        Get the world pose of the light.
-
-        :return: World 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:
-        """
-        Get the local pose of the light.
-
-        :return: Local 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:
-        """
-        Set the world pose of the light.
-
-        :param pose: World pose as Pose (or dict with position/orientation lists).
-        """
-
-        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:
-        """
-        Set the local pose of the light.
-
-        :param pose: Local pose as Pose (or dict with position/orientation lists).
-        """
-
-        self._session.query_sim_rpc(endpoint="light/set_local_pose", payload={"path": self._path, "pose": pose})
-
-    def set_intensity(self, intensity: float) -> None:
-        """
-        Set the intensity of the light.
-
-        :param intensity: Light intensity value.
-        """
-
-        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:
-        """
-        Set the color of the light.
-
-        :param color: RGB color as Vector3 (or list/tuple of 3 floats) with values 0-1.
-        """
-
-        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="light/enable", payload={"path": self._path})
-
-    def disable(self) -> None:
-        """
-        Disable the light (turn it off).
-        """
-
-        self._session.query_sim_rpc(endpoint="light/disable", payload={"path": self._path})