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

common/session/sim.py

@@ -1,10 +1,10 @@
-import time
 from enum import Enum
-from typing import Any
+from typing import Any, TypeVar, cast
 
-from pydantic import Field
+from common.message import Message
 
-from common.message import Message, Pose, Vector3
+T = TypeVar("T")
+_MISSING = object()
 
 
 class SimulationState(str, Enum):
@@ -17,14 +17,6 @@ class SimulationState(str, Enum):
     STOPPED = "stopped"
 
 
-class Step(Message):
-    """
-    Step the simulation forward by a specified amount of time in microseconds.
-    """
-
-    dt_us: int = 10000  # Default 10ms
-
-
 class SimulationInfo(Message):
     """
     Full simulation info.
@@ -42,77 +34,9 @@ class SimulationTime(Message):
     time_us: int
 
 
-class ToggleUi(Message):
-    """
-    Toggle the UI visibility.
-    """
-
-    show_ui: bool
-
-
-class GetObject(Message):
-    """
-    Get information about a specific object.
-    """
-
-    path: str
-
-
-class ObjectInfo(Message):
-    """
-    Information about a simulation object.
-    """
-
-    path: str
-    type: str
-    config: dict[str, Any]
-
-
-class AllObjectInfo(Message):
-    """
-    All objects in the scene.
-    """
-
-    objects: list[ObjectInfo]
-
-
-class GetWorldPose(Message):
-    """
-    Get the world pose of an object.
-    """
-
-    path: str = Field(description="USD path of the object")
-
-
-class GetLocalPose(Message):
-    """
-    Get the local pose of an object.
-    """
-
-    path: str = Field(description="USD path of the object")
-
-
-class SetWorldPose(Message):
-    """
-    Set the world pose of an object.
-    """
-
-    path: str = Field(description="USD path of the object")
-    pose: Pose
-
-
-class SetLocalPose(Message):
-    """
-    Set the local pose of an object.
-    """
-
-    path: str = Field(description="USD path of the object")
-    pose: Pose
-
-
 class RpcError(Message):
     """
-    RPC error.
+    RPC error details.
     """
 
     message: str
@@ -122,69 +46,44 @@ class RpcError(Message):
 
 class RpcCall(Message):
     """
-    RPC call with optional payload.
-    """
-
-    ts: int = Field(default_factory=lambda: int(time.time_ns() // 1000))
-    payload: bytes | None = None
-
-
-class RpcResponse(Message):
-    """
-    RPC response with optional payload and error.
+    RPC request with dict payload.
     """
 
-    ts: int = Field(default_factory=lambda: int(time.time_ns() // 1000))
-    payload: bytes | None = None
-    error: RpcError | None = None
-
+    data: dict[str, Any] | None = None
 
-class AddAsset(Message):
-    """
-    Add an asset to the simulation.
-    """
+    def get(self, key: str, *, type: type[T] | None = None, default: T | object = _MISSING) -> T:
+        """
+        Get a value from the call data with optional type conversion.
 
-    path: str = Field(description="USD path where asset will be added")
-    asset_file_path: str = Field(description="Path to asset file (USD, FBX, OBJ, etc.)")
-    asset_prim_path: str | None = Field(default=None, description="Full path to prim in the Usd file to reference")
-    remove_articulation: bool = Field(default=True, description="Whether to remove articulation APIs")
-    remove_rigid_body: bool = Field(default=False, description="Whether to remove rigid body APIs")
-    remove_sensors: bool = Field(default=False, description="Whether to remove sensor and graph prims")
-    world_pose: Pose | None = Field(default=None, description="Optional world pose")
-    local_pose: Pose | None = Field(default=None, description="Optional local pose")
-    scale: Vector3 | None = Field(default=None, description="Optional scale")
+        If type is a Message subclass, auto-converts via model_validate.
+        Raises KeyError if key missing and no default provided.
 
+        :param key: The key to lookup in data.
+        :param type: The expected type class (optional).
+        :param default: Default value to return if key is missing (can be None).
+        :return: The value (converted if type provided).
+        :raises KeyError: If key is missing and no default provided.
+        """
 
-class GetPrimAttribute(Message):
-    """
-    Get an attribute value from a prim.
+        if self.data is None or key not in self.data:
+            if default is not _MISSING:
+                return cast(T, default)
+            raise KeyError(f"Missing required field '{key}'")
 
-    Supports primitive and vector types (float, int, bool, string, Vec2/3/4, Quat).
-    """
+        value = self.data[key]
+        if type is not None and isinstance(value, dict) and issubclass(type, Message):
+            return cast(T, type.model_validate(value))
 
-    path: str = Field(description="USD path to the prim")
-    attribute_name: str = Field(description="Name of the attribute to get")
+        return cast(T, value)
 
 
-class SetPrimAttribute(Message):
-    """
-    Set an attribute value on a prim.
-
-    Supports primitive and vector types (float, int, bool, string, Vec2/3/4, Quat).
-    The attribute must already exist on the prim.
-    """
-
-    path: str = Field(description="USD path to the prim")
-    attribute_name: str = Field(description="Name of the attribute to set")
-    value: float | int | str | bool | list[float] = Field(description="Value to set (must match attribute type)")
-
-
-class PrimAttributeValue(Message):
+class RpcResponse(Message):
     """
-    Response containing an attribute value.
+    RPC response with arbitrary payload or error.
     """
 
-    value: float | int | str | bool | list[float]
+    data: Any = None
+    error: RpcError | None = None
 
 
 class SceneTarget(str, Enum):
@@ -210,17 +109,8 @@ class PrimInfo(Message):
     Information about a prim in the scene with its applicable view types.
     """
 
-    path: str = Field(description="USD path to the prim")
-    targets: list[SceneTarget] = Field(description="List of applicable scene targets/view types for this prim")
-
-
-class QueryScene(Message):
-    """
-    Query the scene hierarchy for prims matching specific criteria.
-    """
-
-    root_path: str = Field(default="/World", description="Root path to start the query from")
-    target: SceneTarget | None = Field(default=None, description="Specific target type to filter for (None returns all)")
+    path: str
+    targets: list[SceneTarget]
 
 
 class SceneQueryResponse(Message):
@@ -228,13 +118,12 @@ class SceneQueryResponse(Message):
     Response containing the results of a scene query.
     """
 
-    prims: list[PrimInfo] = Field(description="List of matching prims with their applicable targets")
+    prims: list[PrimInfo]
 
 
-class SetSimulationControls(Message):
+class PrimAttributeValue(Message):
     """
-    Set simulation control parameters.
+    Response containing an attribute value.
     """
 
-    max_physics_dt_us: int | None = Field(default=None, description="Maximum physics timestep in microseconds")
-    render_interval_us: int | None = Field(default=None, description="Render interval in microseconds")
+    value: float | int | str | bool | list[float]

antioch/session/views/__init__.py

@@ -1,42 +0,0 @@
-from antioch.session.views.animation import Animation
-from antioch.session.views.articulation import Articulation
-from antioch.session.views.basis_curve import BasisCurve
-from antioch.session.views.camera import Camera
-from antioch.session.views.collision import (
-    get_mesh_approximation,
-    has_collision,
-    remove_collision,
-    set_collision,
-)
-from antioch.session.views.geometry import Geometry
-from antioch.session.views.ground_plane import GroundPlane
-from antioch.session.views.imu import Imu
-from antioch.session.views.joint import Joint
-from antioch.session.views.light import Light
-from antioch.session.views.material import set_nonvisual_material
-from antioch.session.views.pir_sensor import PirSensor, set_pir_material
-from antioch.session.views.radar import Radar
-from antioch.session.views.rigid_body import RigidBody
-from antioch.session.views.xform import XForm
-
-__all__ = [
-    "Animation",
-    "Articulation",
-    "BasisCurve",
-    "Camera",
-    "Geometry",
-    "GroundPlane",
-    "Imu",
-    "Joint",
-    "Light",
-    "PirSensor",
-    "Radar",
-    "RigidBody",
-    "XForm",
-    "get_mesh_approximation",
-    "has_collision",
-    "remove_collision",
-    "set_collision",
-    "set_nonvisual_material",
-    "set_pir_material",
-]

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/material.py

@@ -1,54 +0,0 @@
-from antioch.session.session import Session
-from common.session.views.material import SetNonVisualMaterial, SetNonVisualMaterialResponse
-
-
-def set_nonvisual_material(
-    path: str,
-    base: str,
-    coating: str = "none",
-    attribute: str = "none",
-) -> int:
-    """
-    Set non-visual material properties on all Material prims in a subtree.
-
-    These properties define how objects appear to RTX sensors (LiDAR and Radar).
-
-    Valid base materials:
-        Metals: aluminum, steel, oxidized_steel, iron, oxidized_iron, silver, brass,
-                bronze, oxidized_bronze_patina, tin
-        Polymers: plastic, fiberglass, carbon_fiber, vinyl, plexiglass, pvc, nylon, polyester
-        Glass: clear_glass, frosted_glass, one_way_mirror, mirror, ceramic_glass
-        Other: asphalt, concrete, leaf_grass, dead_leaf_grass, rubber, wood, bark,
-               cardboard, paper, fabric, skin, fur_hair, leather, marble, brick,
-               stone, gravel, dirt, mud, water, salt_water, snow, ice, calibration_lambertion
-        Default: none
-
-    Valid coatings: none, paint, clearcoat, paint_clearcoat
-
-    Valid attributes: none, emissive, retroreflective, single_sided, visually_transparent
-
-    Example:
-        # Make a person visible to radar/lidar with skin material
-        count = set_nonvisual_material("/World/person", base="skin")
-
-        # Make a car with aluminum body and paint coating
-        count = set_nonvisual_material("/World/car", base="aluminum", coating="paint")
-
-    :param path: USD path of the root prim to configure.
-    :param base: Base material type.
-    :param coating: Coating type.
-    :param attribute: Material attribute.
-    :return: Number of Material prims modified.
-    """
-
-    response = Session.get_current().query_sim_rpc(
-        endpoint="set_nonvisual_material",
-        payload=SetNonVisualMaterial(
-            path=path,
-            base=base,
-            coating=coating,
-            attribute=attribute,
-        ),
-        response_type=SetNonVisualMaterialResponse,
-    )
-    return response.materials_modified

antioch/session/views/radar.py

@@ -1,131 +0,0 @@
-from antioch.session.session import Session, SessionContainer
-from common.message import Pose, RadarScan
-from common.session.views.radar import (
-    AddRadar,
-    GetRadar,
-    GetRadarResponse,
-    GetRadarScan,
-    RadarConfig,
-    SetRadarDebugMode,
-    SetRadarMaterial,
-)
-
-
-class Radar(SessionContainer):
-    """
-    Radar view 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 view.
-
-        :param path: USD path for the radar.
-        """
-
-        super().__init__()
-
-        self._path = self._session.query_sim_rpc(
-            endpoint="get_radar",
-            payload=GetRadar(path=path),
-            response_type=GetRadarResponse,
-        ).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="add_radar",
-            payload=AddRadar(
-                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="get_radar_scan",
-            payload=GetRadarScan(path=self._path),
-            response_type=RadarScan,
-        )
-
-        return scan
-
-    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="set_radar_debug_mode",
-            payload=SetRadarDebugMode(path=self._path, enabled=enabled),
-        )
-
-
-def set_radar_material(
-    path: str,
-    reflectivity: float | None = None,
-    metallic: float | None = None,
-    roughness: float | None = None,
-    backscattering: float | None = None,
-    cross_section: float | None = None,
-) -> None:
-    """
-    Set radar-specific material properties on a prim and all prims in its subtree.
-
-    These properties define how the prim appears to radar sensors.
-
-    Example:
-        # Make a target highly reflective to radar
-        set_radar_material("/World/car", reflectivity=0.9, metallic=1.0)
-
-    :param path: USD path of the prim to configure.
-    :param reflectivity: Radar reflectivity (0-1).
-    :param metallic: Metallic property (0-1).
-    :param roughness: Surface roughness (0-1).
-    :param backscattering: Backscattering coefficient.
-    :param cross_section: Radar cross section in dBsm.
-    """
-
-    Session.get_current().query_sim_rpc(
-        endpoint="set_radar_material",
-        payload=SetRadarMaterial(
-            path=path,
-            reflectivity=reflectivity,
-            metallic=metallic,
-            roughness=roughness,
-            backscattering=backscattering,
-            cross_section=cross_section,
-        ),
-    )