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

antioch/session/asset.py

@@ -1,65 +0,0 @@
-from pathlib import Path
-
-from antioch.session.session import SessionContainer
-from common.ark import AssetReference
-from common.core import list_local_assets, list_remote_assets, pull_remote_asset
-
-
-class Asset(SessionContainer):
-    """
-    Provides methods for interacting with the asset registry.
-
-    All methods handle authentication automatically using the current session's auth context.
-    This is a lightweight wrapper around registry functions that manages auth token complexity.
-
-    Example:
-        # List local assets
-        local_assets = Asset.list_local()
-
-        # List remote assets (requires auth)
-        remote_assets = Asset.list_remote()
-
-        # Pull an asset from remote registry
-        asset_path = Asset.pull(name="my_asset", version="1.0.0")
-    """
-
-    @staticmethod
-    def list_local() -> list[AssetReference]:
-        """
-        List all locally available assets.
-
-        :return: List of AssetReference objects from local storage.
-        """
-
-        return list_local_assets()
-
-    @staticmethod
-    def list_remote() -> list[AssetReference]:
-        """
-        List all assets from remote registry.
-
-        Requires authentication. Call session.login() first if not authenticated.
-
-        :return: List of AssetReference objects from remote registry.
-        :raises SessionAuthError: If not authenticated.
-        """
-
-        return list_remote_assets()
-
-    @staticmethod
-    def pull(name: str, version: str, overwrite: bool = False, show_progress: bool = True) -> Path:
-        """
-        Pull an asset from remote registry to local storage.
-
-        Requires authentication. Call session.login() first if not authenticated.
-        If the asset already exists locally, returns the existing path unless overwrite=True.
-
-        :param name: Name of the asset.
-        :param version: Version of the asset.
-        :param overwrite: Overwrite local asset if it already exists.
-        :param show_progress: Show download progress bar.
-        :return: Path to the downloaded asset file.
-        :raises SessionAuthError: If not authenticated.
-        """
-
-        return pull_remote_asset(name=name, version=version, overwrite=overwrite, show_progress=show_progress)

antioch/session/error.py

@@ -1,80 +0,0 @@
-class SessionError(Exception):
-    """
-    Base exception for all session-related errors.
-    """
-
-
-class SessionSimRpcNotConnectedError(SessionError):
-    """
-    Raised when the Sim RPC server is not reachable.
-    """
-
-
-class SessionSimRpcInterruptedError(SessionError):
-    """
-    Raised when the Sim RPC is interrupted.
-    """
-
-
-class SessionSimRpcClientError(SessionError):
-    """
-    Raised when the Sim RPC server returns a client error (user error).
-    """
-
-
-class SessionSimRpcInternalError(SessionError):
-    """
-    Raised when the Sim RPC server returns an internal error with traceback.
-    """
-
-    def __init__(self, message: str, traceback: str | None = None):
-        super().__init__(message)
-        self.traceback = traceback
-
-
-class SessionAuthError(SessionError):
-    """
-    Raised when authentication fails.
-    """
-
-
-class SessionAgentError(SessionError):
-    """
-    Raised when an agent operation fails (start/stop ark, telemetry, etc).
-    """
-
-
-class SessionTaskError(SessionError):
-    """
-    Raised when a task operation fails (invalid lifecycle, etc).
-    """
-
-
-class SessionArkError(SessionError):
-    """
-    Raised when an Ark operation fails (loading, stepping, hardware access, etc).
-    """
-
-
-class SessionHardwareError(SessionError):
-    """
-    Raised when a hardware operation fails.
-    """
-
-
-class SessionAssetError(SessionError):
-    """
-    Raised when an asset operation fails.
-    """
-
-
-class SessionRecordError(SessionError):
-    """
-    Raised when a recording operation fails (node output recording, etc).
-    """
-
-
-class SessionValidationError(SessionError):
-    """
-    Raised when input validation fails (user error).
-    """

antioch/session/objects/__init__.py

@@ -1,40 +0,0 @@
-from antioch.session.objects.animation import Animation
-from antioch.session.objects.articulation import Articulation
-from antioch.session.objects.basis_curve import BasisCurve
-from antioch.session.objects.camera import Camera
-from antioch.session.objects.collision import (
-    get_mesh_approximation,
-    has_collision,
-    remove_collision,
-    set_collision,
-)
-from antioch.session.objects.geometry import Geometry
-from antioch.session.objects.ground_plane import GroundPlane
-from antioch.session.objects.imu import Imu
-from antioch.session.objects.joint import Joint
-from antioch.session.objects.light import Light
-from antioch.session.objects.pir_sensor import PirSensor, set_pir_material
-from antioch.session.objects.radar import Radar
-from antioch.session.objects.rigid_body import RigidBody
-from antioch.session.objects.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_pir_material",
-]

antioch/session/objects/animation.py

@@ -1,162 +0,0 @@
-from typing import Literal, overload
-
-from antioch.session.session import Session, SessionContainer
-from common.message import Vector3
-
-
-class Animation(SessionContainer):
-    """
-    Ergonomic wrapper for animation operations.
-
-    Animations should be added using scene.add_animation() or retrieved using scene.get_animation().
-    Animations wrap around an existing skeleton UsdSkel.Root and provide a way to play and control the animation.
-
-    Example:
-        scene = Scene()
-
-        # Add xform
-        animation = scene.add_animation(
-            path="/World/skeleton",
-            waypoints=[Vector3(1.0, 0.0, 0.0), Vector3(0.0, 1.0, 0.0), Vector3(0.0, 0.0, 1.0)],
-            loop=True,
-        )
-    """
-
-    def __init__(self, path: str):
-        """
-        Initialize animation by resolving path and validating existence.
-
-        :param path: USD path for the animation.
-        """
-
-        super().__init__()
-        self._path = path
-
-    @overload
-    @classmethod
-    def add(cls, path: str, *, waypoints: list[Vector3], loop: bool = True) -> "Animation": ...
-
-    @overload
-    @classmethod
-    def add(
-        cls,
-        path: str,
-        *,
-        basis_curve: str,
-        samples_per_segment: int = 10,
-        sort_by: Literal["X", "Y", "Z"] | None = None,
-        ascending: bool = True,
-    ) -> "Animation": ...
-
-    @classmethod
-    def add(
-        cls,
-        path: str,
-        *,
-        waypoints: list[Vector3] | None = None,
-        basis_curve: str | None = None,
-        samples_per_segment: int = 10,
-        sort_by: Literal["X", "Y", "Z"] | None = None,
-        ascending: bool = True,
-        loop: bool = True,
-    ) -> "Animation":
-        """
-        Add an animation to the scene.
-
-        :param path: USD path for the animation.
-        :param waypoints: List of waypoints.
-        :param basis_curve: Path to the basis curve to use for the animation.
-        :param samples_per_segment: The number of samples per segment to use from the basis curve.
-        :param sort_by: The axis to sort the points by.
-        :param ascending: Whether to sort the points in ascending order.
-        :param loop: Whether to loop the animation (waypoints only).
-        :return: The animation instance.
-        """
-
-        if waypoints is not None:
-            Session.get_current().query_sim_rpc(
-                endpoint="animation/add_from_waypoints",
-                payload={"path": path, "waypoints": waypoints, "loop": loop},
-            )
-        elif basis_curve is not None:
-            Session.get_current().query_sim_rpc(
-                endpoint="animation/add_from_basis_curve",
-                payload={
-                    "path": path,
-                    "basis_curve": basis_curve,
-                    "samples_per_segment": samples_per_segment,
-                    "sort_by": sort_by,
-                    "ascending": ascending,
-                },
-            )
-        else:
-            raise ValueError("Must provide either waypoints or basis_curve")
-
-        return cls(path)
-
-    @overload
-    def update(self, *, waypoints: list[Vector3], loop: bool = True) -> "Animation": ...
-
-    @overload
-    def update(
-        self,
-        *,
-        basis_curve: str,
-        samples_per_segment: int = 10,
-        sort_by: Literal["X", "Y", "Z"] | None = None,
-        ascending: bool = True,
-    ) -> "Animation": ...
-
-    def update(
-        self,
-        *,
-        waypoints: list[Vector3] | None = None,
-        basis_curve: str | None = None,
-        samples_per_segment: int = 10,
-        sort_by: Literal["X", "Y", "Z"] | None = None,
-        ascending: bool = True,
-        loop: bool = True,
-    ) -> "Animation":
-        """
-        Update the animation.
-
-        :param waypoints: List of waypoints.
-        :param basis_curve: Path to the basis curve to use for the animation.
-        :param samples_per_segment: The number of samples per segment to use from the basis curve.
-        :param sort_by: The axis to sort the points by.
-        :param ascending: Whether to sort the points in ascending order.
-        :param loop: Whether to loop the animation (waypoints only).
-        :raises ValueError: If both waypoints and basis curve are provided.
-        :return: The animation instance.
-        """
-
-        if waypoints is not None and basis_curve is not None:
-            raise ValueError("Must provide either waypoints or basis_curve")
-
-        if waypoints is not None:
-            Session.get_current().query_sim_rpc(
-                endpoint="animation/update_waypoints",
-                payload={"path": self._path, "waypoints": waypoints, "loop": loop},
-            )
-        elif basis_curve is not None:
-            Session.get_current().query_sim_rpc(
-                endpoint="animation/update_basis_curve",
-                payload={
-                    "path": self._path,
-                    "basis_curve": basis_curve,
-                    "samples_per_segment": samples_per_segment,
-                    "sort_by": sort_by,
-                    "ascending": ascending,
-                },
-            )
-        else:
-            raise ValueError("Must provide either waypoints or basis_curve")
-
-        return self
-
-    def remove(self) -> None:
-        """
-        Remove the animation from the scene (deletes the character).
-        """
-
-        self._session.query_sim_rpc(endpoint="animation/remove", payload={"path": self._path})

antioch/session/objects/articulation.py

@@ -1,180 +0,0 @@
-from antioch.session.session import Session, SessionContainer
-from common.message import JointState, JointTarget, Pose, Vector3
-from common.session.config import ArticulationConfig, ArticulationJointConfig
-
-
-class Articulation(SessionContainer):
-    """
-    Ergonomic wrapper for articulation operations.
-
-    Articulations should be added using scene.add_articulation() or retrieved using scene.get_articulation().
-
-    Example:
-        scene = Scene()
-
-        # Get an existing articulation
-        robot = scene.get_articulation(path="/World/robot")
-
-        # Use articulation
-        joint_states = robot.get_joint_states()
-        robot.set_joint_targets(
-            joint_targets=[
-                JointTarget(position=0.1, velocity=0.0, effort=0.0),
-                JointTarget(position=0.2, velocity=0.0, effort=0.0),
-            ]
-        )
-        pose = robot.get_world_pose()
-    """
-
-    def __init__(self, path: str):
-        """
-        Initialize articulation by resolving path and validating existence.
-
-        :param path: USD path for the articulation.
-        """
-
-        super().__init__()
-        self._session.query_sim_rpc(endpoint="articulation/get", payload={"path": path})
-        self._path = path
-
-    @classmethod
-    def add(
-        cls,
-        path: str,
-        config: ArticulationConfig,
-        world_pose: Pose | None,
-        local_pose: Pose | None,
-        scale: Vector3 | None,
-    ) -> "Articulation":
-        """
-        Add an articulation to the scene.
-
-        :param path: USD path for the articulation.
-        :param config: Articulation configuration.
-        :param world_pose: Optional world pose.
-        :param local_pose: Optional local pose.
-        :param scale: Optional scale.
-        :return: The articulation instance.
-        """
-
-        Session.get_current().query_sim_rpc(
-            endpoint="articulation/add",
-            payload={"path": path, "config": config, "world_pose": world_pose, "local_pose": local_pose, "scale": scale},
-        )
-        return cls(path)
-
-    def get_joint_states(self, joint_names: list[str] | None = None) -> list[JointState]:
-        """
-        Get current joint states.
-
-        :param joint_names: Optional list of joint names. If None, returns all joints.
-        :return: List of joint states.
-        """
-
-        response = self._session.query_sim_rpc(
-            endpoint="articulation/get_joint_states",
-            payload={"path": self._path, "joint_names": joint_names},
-        )
-        return [JointState.model_validate(js) for js in response] if response else []
-
-    def get_joint_targets(self, joint_names: list[str] | None = None) -> list[JointTarget]:
-        """
-        Get current applied control targets.
-
-        :param joint_names: Optional list of joint names. If None, returns all joints.
-        :return: List of joint control targets.
-        """
-
-        response = self._session.query_sim_rpc(
-            endpoint="articulation/get_joint_targets",
-            payload={"path": self._path, "joint_names": joint_names},
-        )
-        return [JointTarget.model_validate(jt) for jt in response] if response else []
-
-    def get_joint_configs(self, joint_names: list[str] | None = None) -> list[ArticulationJointConfig]:
-        """
-        Get complete joint configurations.
-
-        Only returns DOF joints. Non-DOF joints are automatically filtered out.
-        Use the joint_name field in each config to get joint names.
-
-        :param joint_names: Optional list of joint names. If None, returns all DOF joints.
-        :return: List of joint configurations (DOF joints only).
-        """
-
-        response = self._session.query_sim_rpc(
-            endpoint="articulation/get_joint_configs",
-            payload={"path": self._path, "joint_names": joint_names},
-        )
-        return [ArticulationJointConfig.model_validate(jc) for jc in response] if response else []
-
-    def set_joint_configs(self, joint_configs: list[ArticulationJointConfig]) -> None:
-        """
-        Set complete joint configurations.
-
-        :param joint_configs: List of joint configurations to apply.
-        """
-
-        self._session.query_sim_rpc(endpoint="articulation/set_joint_configs", payload={"path": self._path, "joint_configs": joint_configs})
-
-    def set_joint_states(self, joint_names: list[str] | None = None, joint_states: list[JointState] | None = None) -> None:
-        """
-        Set the joint states of the articulation (immediate teleport).
-
-        :param joint_names: Optional list of joint names. If None, sets all joints.
-        :param joint_states: List of joint states to set.
-        """
-
-        self._session.query_sim_rpc(
-            endpoint="articulation/set_joint_states",
-            payload={"path": self._path, "joint_names": joint_names, "joint_states": joint_states},
-        )
-
-    def set_joint_targets(self, joint_names: list[str] | None = None, joint_targets: list[JointTarget] | None = None) -> None:
-        """
-        Set control targets for the articulation's PD controllers.
-
-        :param joint_names: Optional list of joint names. If None, targets all joints.
-        :param joint_targets: List of joint control targets.
-        """
-
-        self._session.query_sim_rpc(
-            endpoint="articulation/set_joint_targets",
-            payload={"path": self._path, "joint_names": joint_names, "joint_targets": joint_targets},
-        )
-
-    def get_world_pose(self) -> Pose:
-        """
-        Get the world pose of the articulation.
-
-        :return: World pose.
-        """
-
-        return self._session.query_sim_rpc(endpoint="articulation/get_world_pose", payload={"path": self._path}, response_type=Pose)
-
-    def get_local_pose(self) -> Pose:
-        """
-        Get the local pose of the articulation.
-
-        :return: Local pose.
-        """
-
-        return self._session.query_sim_rpc(endpoint="articulation/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 articulation.
-
-        :param pose: World pose as Pose (or dict with position/orientation lists).
-        """
-
-        self._session.query_sim_rpc(endpoint="articulation/set_world_pose", payload={"path": self._path, "pose": pose})
-
-    def set_local_pose(self, pose: Pose | dict) -> None:
-        """
-        Set the local pose of the articulation.
-
-        :param pose: Local pose as Pose (or dict with position/orientation lists).
-        """
-
-        self._session.query_sim_rpc(endpoint="articulation/set_local_pose", payload={"path": self._path, "pose": pose})