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

antioch/session/views/collision.py

@@ -1,75 +0,0 @@
-from antioch.session.session import Session
-from common.session.views.collision import (
-    GetMeshApproximation,
-    GetMeshApproximationResponse,
-    HasCollision,
-    HasCollisionResponse,
-    RemoveCollision,
-    SetCollision,
-)
-from common.session.views.geometry 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=SetCollision(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=RemoveCollision(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=HasCollision(path=path),
-            response_type=HasCollisionResponse,
-        )
-        .has_collision
-    )
-
-
-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.
-    """
-
-    return (
-        Session.get_current()
-        .query_sim_rpc(
-            endpoint="get_mesh_approximation_rpc",
-            payload=GetMeshApproximation(path=path),
-            response_type=GetMeshApproximationResponse,
-        )
-        .approximation
-    )

antioch/session/views/geometry.py

@@ -1,74 +0,0 @@
-from antioch.session.session import Session, SessionContainer
-from common.message import Pose
-from common.session.views.geometry import AddGeometry, GeometryConfig, GetGeometry, GetGeometryResponse
-
-
-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__()
-
-        # Validate path
-        self._path = self._session.query_sim_rpc(
-            endpoint="get_geometry",
-            payload=GetGeometry(path=path),
-            response_type=GetGeometryResponse,
-        ).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="add_geometry",
-            payload=AddGeometry(
-                path=path,
-                config=config,
-                world_pose=world_pose,
-                local_pose=local_pose,
-            ),
-        )
-        return cls(path)

antioch/session/views/ground_plane.py

@@ -1,63 +0,0 @@
-from antioch.session.session import Session, SessionContainer
-from common.session.views.ground_plane import AddGroundPlane, GetGroundPlane, GetGroundPlaneResponse, 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__()
-
-        # Validate path
-        self._path = self._session.query_sim_rpc(
-            endpoint="get_ground_plane",
-            payload=GetGroundPlane(path=path),
-            response_type=GetGroundPlaneResponse,
-        ).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="add_ground_plane",
-            payload=AddGroundPlane(
-                path=path,
-                config=config,
-            ),
-        )
-        return cls(path)

antioch/session/views/imu.py

@@ -1,73 +0,0 @@
-from antioch.session.session import Session, SessionContainer
-from common.message import ImuSample, Pose
-from common.session.views.imu import AddImu, GetImu, GetImuResponse, GetImuSample, ImuConfig
-
-
-class Imu(SessionContainer):
-    """
-    IMU view 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 view.
-
-        :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
-
-    @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="add_imu",
-            payload=AddImu(
-                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="get_imu_sample",
-            payload=GetImuSample(path=self._path),
-            response_type=ImuSample,
-        )
-
-        return sample

antioch/session/views/joint.py

@@ -1,64 +0,0 @@
-from antioch.session.session import Session, SessionContainer
-from common.session.views.joint import AddJoint, GetJoint, GetJointResponse, 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__()
-
-        # Validate path
-        self._path = self._session.query_sim_rpc(
-            endpoint="get_joint",
-            payload=GetJoint(path=path),
-            response_type=GetJointResponse,
-        ).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="add_joint",
-            payload=AddJoint(
-                path=path,
-                config=config,
-            ),
-        )
-        return cls(path)

antioch/session/views/light.py

@@ -1,175 +0,0 @@
-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,
-)
-
-
-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__()
-
-        # Validate path
-        self._path = self._session.query_sim_rpc(
-            endpoint="get_light",
-            payload=GetLight(path=path),
-            response_type=GetLightResponse,
-        ).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="add_light",
-            payload=AddLight(
-                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="get_light_world_pose",
-            payload=GetWorldPose(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="get_light_local_pose",
-            payload=GetLocalPose(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="set_light_world_pose",
-            payload=SetWorldPose(path=self._path, pose=Pose.from_any(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="set_light_local_pose",
-            payload=SetLocalPose(path=self._path, pose=Pose.from_any(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="set_light_intensity",
-            payload=SetLightIntensity(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="set_light_color",
-            payload=SetLightColor(path=self._path, color=Vector3.from_any(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),
-        )
-
-    def disable(self) -> None:
-        """
-        Disable the light (turn it off).
-        """
-
-        self._session.query_sim_rpc(
-            endpoint="disable_light",
-            payload=DisableLight(path=self._path),
-        )

antioch/session/views/pir_sensor.py

@@ -1,140 +0,0 @@
-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,
-)
-
-
-class PirSensor(SessionContainer):
-    """
-    PIR (Passive Infrared) sensor view 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.
-
-    Example:
-        scene = Scene()
-        pir = scene.add_pir_sensor(path="/World/pir_sensor")
-        scene.play()
-        scene.step(dt_us=100_000)
-        status = pir.get_detection_status()
-        print(f"Detected: {status.is_detected}")
-    """
-
-    def __init__(
-        self,
-        path: str,
-        config: PirSensorConfig | None = None,
-    ):
-        """
-        Initialize PIR sensor view.
-
-        :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
-
-    @classmethod
-    def add(
-        cls,
-        path: str,
-        config: PirSensorConfig,
-        world_pose: Pose | None,
-        local_pose: Pose | None,
-    ) -> "PirSensor":
-        """
-        Add PIR sensor to the scene.
-
-        :param path: USD path for the PIR sensor.
-        :param config: PIR sensor configuration.
-        :param world_pose: Optional world pose.
-        :param local_pose: Optional local pose.
-        :return: The PIR sensor instance.
-        """
-
-        Session.get_current().query_sim_rpc(
-            endpoint="add_pir_sensor",
-            payload=AddPirSensor(
-                path=path,
-                config=config,
-                world_pose=world_pose,
-                local_pose=local_pose,
-            ),
-        )
-        return cls(path, config)
-
-    def get_detection_status(self) -> PirStatus:
-        """
-        Get current detection status.
-
-        :return: Detection status with is_detected, signal_strength, threshold, element_flux, and element_signal.
-        """
-
-        status = self._session.query_sim_rpc(
-            endpoint="get_pir_detection_status",
-            payload=GetPirDetectionStatus(path=self._path),
-            response_type=PirStatus,
-        )
-        return status
-
-    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
-
-        :param enabled: Whether to enable debug visualization.
-        """
-
-        self._session.query_sim_rpc(
-            endpoint="set_pir_debug_mode",
-            payload=SetPirDebugMode(path=self._path, enabled=enabled),
-        )
-
-
-def set_pir_material(
-    path: str,
-    emissivity: float = 0.9,
-    temperature_c: float | None = None,
-) -> None:
-    """
-    Set PIR-specific thermal properties on a prim.
-
-    These properties define how the prim appears to PIR sensors:
-    - emissivity: How well the surface emits infrared radiation (0-1)
-    - temperature_c: Surface temperature in Celsius
-
-    Example:
-        # Make a target detectable by PIR sensors
-        set_pir_material("/World/person", emissivity=0.98, temperature_c=37.0)
-
-    :param path: USD path of the prim to configure.
-    :param emissivity: Material emissivity (0-1, default 0.9).
-    :param temperature_c: Surface temperature in Celsius (optional).
-    """
-
-    Session.get_current().query_sim_rpc(
-        endpoint="set_pir_material",
-        payload=SetPirMaterial(
-            path=path,
-            emissivity=emissivity,
-            temperature_c=temperature_c,
-        ),
-    )