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

antioch/session/objects/pir_sensor.py

@@ -1,98 +0,0 @@
-from antioch.session.session import Session, SessionContainer
-from common.message import PirStatus, Pose
-from common.session.config import PirSensorConfig
-
-
-class PirSensor(SessionContainer):
-    """
-    PIR (Passive Infrared) sensor object for motion detection.
-
-    PIR sensors detect infrared radiation changes caused by moving warm objects.
-    The sensor uses a 3-sensor design (center, left, right) with dual elements per sensor.
-
-    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 object.
-
-        :param path: USD path for the PIR sensor.
-        :param config: Optional PIR sensor config.
-        """
-
-        super().__init__()
-        self._config = config
-        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":
-        """
-        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="pir_sensor/add",
-            payload={"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, and per-sensor details.
-        """
-
-        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:
-        - 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="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:
-    """
-    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="pir_material/set",
-        payload={"path": path, "emissivity": emissivity, "temperature_c": temperature_c},
-    )

antioch/session/objects/radar.py

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

@@ -1,197 +0,0 @@
-from antioch.session.session import Session, SessionContainer
-from common.message import Pose, Twist, Vector3
-from common.session.config import RigidBodyConfig
-
-
-class RigidBody(SessionContainer):
-    """
-    Ergonomic wrapper for rigid body operations.
-
-    Rigid bodies should be added using scene.add_rigid_body() or retrieved using scene.get_rigid_body().
-
-    Example:
-        scene = Scene()
-
-        # Add rigid body
-        body = scene.add_rigid_body(
-            path="/World/cube",
-            mass=1.0,
-            linear_velocity=[1.0, 0.0, 0.0]
-        )
-
-        # Set velocity with tuples/lists
-        body.set_velocity(
-            linear=(1.0, 0.0, 0.0),
-            angular=[0.0, 0.0, 1.0]
-        )
-        pose = body.get_world_pose()
-    """
-
-    def __init__(self, path: str):
-        """
-        Initialize rigid body by resolving path and validating existence.
-
-        :param path: USD path for the rigid body.
-        """
-
-        super().__init__()
-        self._session.query_sim_rpc(endpoint="rigid_body/get", payload={"path": path})
-        self._path = path
-
-    @classmethod
-    def add(
-        cls,
-        path: str,
-        config: RigidBodyConfig,
-        world_pose: Pose | None,
-        local_pose: Pose | None,
-        scale: Vector3 | None,
-    ) -> "RigidBody":
-        """
-        Add a rigid body to the scene.
-
-        :param path: USD path for the rigid body.
-        :param config: Rigid body configuration.
-        :param world_pose: Optional world pose.
-        :param local_pose: Optional local pose.
-        :param scale: Optional scale.
-        :return: The rigid body instance.
-        """
-
-        Session.get_current().query_sim_rpc(
-            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) -> Twist:
-        """
-        Get the velocity of the rigid body.
-
-        :return: Linear and angular velocities.
-        """
-
-        return self._session.query_sim_rpc(endpoint="rigid_body/get_velocity", payload={"path": self._path}, response_type=Twist)
-
-    def set_velocity(
-        self,
-        linear: Vector3 | list[float] | tuple[float, float, float],
-        angular: Vector3 | list[float] | tuple[float, float, float],
-    ) -> None:
-        """
-        Set the velocity of the rigid body.
-
-        :param linear: Linear velocity as Vector3 (or list/tuple of 3 floats).
-        :param angular: Angular velocity as Vector3 (or list/tuple of 3 floats).
-        """
-
-        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,
-        force: Vector3 | list[float] | tuple[float, float, float],
-        is_global: bool = True,
-    ) -> None:
-        """
-        Apply force to the rigid body.
-
-        :param force: Force vector as Vector3 (or list/tuple of 3 floats).
-        :param is_global: Whether force is in global frame.
-        """
-
-        self._session.query_sim_rpc(
-            endpoint="rigid_body/apply_force",
-            payload={"path": self._path, "force": Vector3.from_any(force), "is_global": is_global},
-        )
-
-    def get_mass(self) -> float:
-        """
-        Get the mass of the rigid body.
-
-        :return: Mass in kg.
-        """
-
-        return self._session.query_sim_rpc(endpoint="rigid_body/get_mass", payload={"path": self._path}, response_type=float)
-
-    def get_inertia(self) -> list[float]:
-        """
-        Get the inertia tensor of the rigid body.
-
-        :return: Inertia tensor as 9 values (3x3 matrix flattened).
-        """
-
-        return self._session.query_sim_rpc(endpoint="rigid_body/get_inertia", payload={"path": self._path}, response_type=list)
-
-    def get_center_of_mass(self) -> Pose:
-        """
-        Get the center of mass position and orientation.
-
-        :return: Center of mass as Pose.
-        """
-
-        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="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="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="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="rigid_body/disable_physics", payload={"path": self._path})
-
-    def get_world_pose(self) -> Pose:
-        """
-        Get the world pose of the rigid body.
-
-        :return: World 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:
-        """
-        Get the local pose of the rigid body.
-
-        :return: Local 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:
-        """
-        Set the world pose of the rigid body.
-
-        :param pose: World pose as Pose (or dict with position/orientation lists).
-        """
-
-        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:
-        """
-        Set the local pose of the rigid body.
-
-        :param pose: Local pose as Pose (or dict with position/orientation lists).
-        """
-
-        self._session.query_sim_rpc(endpoint="rigid_body/set_local_pose", payload={"path": self._path, "pose": pose})

antioch/session/objects/xform.py

@@ -1,119 +0,0 @@
-from antioch.session.session import Session, SessionContainer
-from common.message import Pose, Vector3
-
-
-class XForm(SessionContainer):
-    """
-    Ergonomic wrapper for xform operations.
-
-    XForms should be added using scene.add_xform() or retrieved using scene.get_xform().
-
-    Example:
-        scene = Scene()
-
-        # Add xform
-        xform = scene.add_xform(
-            path="/World/container",
-            world_pose={"position": [1.0, 2.0, 3.0], "orientation": [1.0, 0.0, 0.0, 0.0]},
-            scale=[2.0, 2.0, 2.0]
-        )
-
-        pose = xform.get_world_pose()
-    """
-
-    def __init__(self, path: str):
-        """
-        Initialize xform by resolving path and validating existence.
-
-        :param path: USD path for the xform.
-        """
-
-        super().__init__()
-        self._session.query_sim_rpc(endpoint="xform/get", payload={"path": path})
-        self._path = path
-
-    @classmethod
-    def add(
-        cls,
-        path: str,
-        world_pose: Pose | None,
-        local_pose: Pose | None,
-        scale: Vector3 | None,
-    ) -> "XForm":
-        """
-        Add an xform to the scene.
-
-        :param path: USD path for the xform.
-        :param world_pose: Optional world pose.
-        :param local_pose: Optional local pose.
-        :param scale: Optional scale.
-        :return: The xform instance.
-        """
-
-        Session.get_current().query_sim_rpc(
-            endpoint="xform/add",
-            payload={"path": path, "world_pose": world_pose, "local_pose": local_pose, "scale": scale},
-        )
-        return cls(path)
-
-    def get_world_pose(self) -> Pose:
-        """
-        Get the world pose of the xform.
-
-        :return: World pose.
-        """
-
-        return self._session.query_sim_rpc(
-            endpoint="xform/get_world_pose",
-            payload={"path": self._path},
-            response_type=Pose,
-        )
-
-    def get_local_pose(self) -> Pose:
-        """
-        Get the local pose of the xform.
-
-        :return: Local pose.
-        """
-
-        return self._session.query_sim_rpc(
-            endpoint="xform/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 xform.
-
-        :param pose: World pose as Pose (or dict with position/orientation lists).
-        """
-
-        self._session.query_sim_rpc(
-            endpoint="xform/set_world_pose",
-            payload={"path": self._path, "pose": pose},
-        )
-
-    def set_local_pose(self, pose: Pose | dict) -> None:
-        """
-        Set the local pose of the xform.
-
-        :param pose: Local pose as Pose (or dict with position/orientation lists).
-        """
-
-        self._session.query_sim_rpc(
-            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},
-        )

antioch/session/record.py

@@ -1,158 +0,0 @@
-from collections import deque
-from threading import Lock
-from typing import TypeVar, overload
-
-from antioch.module.node import TOKEN_OUTPUT_PATH
-from antioch.module.token import Token, TokenType
-from antioch.session.error import SessionRecordError
-from common.ark.ark import Ark as ArkDefinition
-from common.message import Message
-from common.utils.comms import CommsSession
-
-T = TypeVar("T", bound=Message)
-
-
-class NodeOutputRecorder:
-    """
-    Records node outputs by subscribing to token stream with filtering and buffering.
-
-    Maintains a circular buffer of recent tokens using async callback for efficient updates.
-    Validates that module/node/output exists in the Ark definition.
-    """
-
-    def __init__(
-        self,
-        comms: CommsSession,
-        ark_def: ArkDefinition,
-        module_name: str,
-        node_name: str,
-        output_name: str,
-        token_type: TokenType | None = TokenType.DATA,
-        last_n: int = 10,
-    ):
-        """
-        Initialize node output recorder with validation and subscription.
-
-        :param comms: Communication session for subscribing to token stream.
-        :param ark_def: Ark definition used to validate module/node/output exists.
-        :param module_name: Name of module containing the node.
-        :param node_name: Name of node containing the output.
-        :param output_name: Name of output to record tokens from.
-        :param token_type: Token type to filter (None records all types).
-        :param last_n: Maximum number of recent tokens to buffer.
-        :raises SessionRecordError: If module, node, or output doesn't exist in Ark.
-        """
-
-        # Validate module exists
-        module = next((m for m in ark_def.modules if m.name == module_name), None)
-        if module is None:
-            raise SessionRecordError(f"Module '{module_name}' not found in Ark")
-
-        # Validate node exists
-        node = module.nodes.get(node_name)
-        if node is None:
-            raise SessionRecordError(f"Node '{node_name}' not found in module '{module_name}'")
-
-        # Validate output exists
-        output = node.outputs.get(output_name)
-        if output is None:
-            raise SessionRecordError(f"Output '{output_name}' not found in node '{module_name}/{node_name}'")
-
-        self._token_type = token_type
-        self._buffer: deque[Token] = deque(maxlen=last_n)
-        self._buffer_lock = Lock()
-        self._subscriber = comms.declare_callback_subscriber(TOKEN_OUTPUT_PATH.format(path=output.path), self._on_token)
-
-    @overload
-    def next(self, message_cls: type[T]) -> T | None: ...
-
-    @overload
-    def next(self, message_cls: None = None) -> dict | None: ...
-
-    def next(self, message_cls: type[T] | None = None) -> T | dict | None:
-        """
-        Return next deserialized payload in order and remove from buffer.
-
-        :param message_cls: Message class to deserialize payload (None for generic JSON dict).
-        :return: Deserialized payload, or None if buffer empty.
-        """
-
-        token = self.next_token()
-        if token is None:
-            return None
-        return self._deserialize_payload(token, message_cls)
-
-    @overload
-    def latest(self, message_cls: type[T]) -> T | None: ...
-
-    @overload
-    def latest(self, message_cls: None = None) -> dict | None: ...
-
-    def latest(self, message_cls: type[T] | None = None) -> T | dict | None:
-        """
-        Return latest deserialized payload and clear entire buffer.
-
-        :param message_cls: Message class to deserialize payload (None for generic JSON dict).
-        :return: Deserialized payload, or None if buffer empty.
-        """
-
-        token = self.latest_token()
-        if token is None:
-            return None
-        return self._deserialize_payload(token, message_cls)
-
-    def next_token(self) -> Token | None:
-        """
-        Return next token in order and remove from buffer.
-
-        :return: Token, or None if buffer empty.
-        """
-
-        with self._buffer_lock:
-            if not self._buffer:
-                return None
-            return self._buffer.popleft()
-
-    def latest_token(self) -> Token | None:
-        """
-        Return latest buffered token and clear entire buffer.
-
-        :return: Token, or None if buffer empty.
-        """
-
-        with self._buffer_lock:
-            if not self._buffer:
-                return None
-            token = self._buffer[-1]
-            self._buffer.clear()
-            return token
-
-    def _on_token(self, sample) -> None:
-        """
-        Callback invoked when token arrives, filters by type and adds to buffer.
-
-        :param sample: Zenoh sample containing token payload.
-        """
-
-        token = Token.unpack(sample.payload.to_bytes())
-        if self._token_type is not None and token.status != self._token_type:
-            return
-
-        with self._buffer_lock:
-            self._buffer.append(token)
-
-    def _deserialize_payload(self, token: Token, message_cls: type[T] | None) -> T | dict | None:
-        """
-        Deserialize token payload as specific message type or generic JSON dict.
-
-        :param token: Token containing payload to deserialize.
-        :param message_cls: Message class to deserialize as (None for generic JSON).
-        :return: Deserialized payload.
-        """
-
-        if token.payload is None:
-            return None
-        elif message_cls is None:
-            return Message.extract_data_as_json(token.payload)
-        else:
-            return message_cls.unpack(token.payload)