mani-skill-nightly 2025.10.22.143__py3-none-any.whl → 2025.10.22.325__py3-none-any.whl

mani_skill/agents/base_agent.py

@@ -2,7 +2,7 @@ from __future__ import annotations
 
 import os
 from dataclasses import dataclass
-from typing import TYPE_CHECKING, Dict, List, Optional, Union
+from typing import TYPE_CHECKING, Optional, Union
 
 import numpy as np
 import sapien
@@ -28,7 +28,9 @@ from .controllers.base_controller import (
 
 if TYPE_CHECKING:
     from mani_skill.envs.scene import ManiSkillScene
-DictControllerConfig = Dict[str, ControllerConfig]
+    from mani_skill.utils.building.mjcf_loader import MJCFLoader
+    from mani_skill.utils.building.urdf_loader import URDFLoader
+DictControllerConfig = dict[str, ControllerConfig]
 
 
 @dataclass
@@ -60,7 +62,7 @@ class BaseAgent:
     """unique identifier string of this"""
     urdf_path: Union[str, None] = None
     """path to the .urdf file describe the agent's geometry and visuals. One of urdf_path or mjcf_path must be provided."""
-    urdf_config: Union[str, Dict] = None
+    urdf_config: Union[str, dict, None] = None
     """Optional provide a urdf_config to further modify the created articulation"""
     mjcf_path: Union[str, None] = None
     """path to a MJCF .xml file defining a robot. This will only load the articulation defined in the XML and nothing else.
@@ -75,9 +77,12 @@ class BaseAgent:
     However for some robots/tasks it may be easier to disable all self collisions between links in the robot to increase simulation speed
     """
 
-    keyframes: Dict[str, Keyframe] = dict()
+    keyframes: dict[str, Keyframe] = dict()
     """a dict of predefined keyframes similar to what Mujoco does that you can use to reset the agent to that may be of interest"""
 
+    robot: Articulation
+    """The robot object, which is an Articulation. Data like pose, qpos etc. can be accessed from this object."""
+
     def __init__(
         self,
         scene: ManiSkillScene,
@@ -92,11 +97,9 @@ class BaseAgent:
         self._agent_idx = agent_idx
         self.build_separate = build_separate
 
-        self.robot: Articulation = None
-        """The robot object, which is an Articulation. Data like pose, qpos etc. can be accessed from this object."""
-        self.controllers: Dict[str, BaseController] = dict()
+        self.controllers: dict[str, BaseController] = dict()
         """The controllers of the robot."""
-        self.sensors: Dict[str, BaseSensor] = dict()
+        self.sensors: dict[str, BaseSensor] = dict()
         """The sensors that come with the robot."""
 
         self._load_articulation(initial_pose)
@@ -114,14 +117,14 @@ class BaseAgent:
         self._after_init()
 
     @property
-    def _sensor_configs(self) -> List[BaseSensorConfig]:
+    def _sensor_configs(self) -> list[BaseSensorConfig]:
         """Returns a list of sensor configs for this agent. By default this is empty."""
         return []
 
     @property
     def _controller_configs(
         self,
-    ) -> Dict[str, Union[ControllerConfig, DictControllerConfig]]:
+    ) -> dict[str, Union[ControllerConfig, DictControllerConfig]]:
         """Returns a dict of controller configs for this agent. By default this is a PDJointPos (delta and non delta) controller for all active joints."""
         return dict(
             pd_joint_pos=PDJointPosControllerConfig(
@@ -154,14 +157,17 @@ class BaseAgent:
         Loads the robot articulation
         """
 
-        def build_articulation(scene_idxs: Optional[List[int]] = None):
+        def build_articulation(scene_idxs: Optional[list[int]] = None):
+            loader: Union[URDFLoader, MJCFLoader, None] = None
             if self.urdf_path is not None:
                 loader = self.scene.create_urdf_loader()
                 asset_path = format_path(str(self.urdf_path))
             elif self.mjcf_path is not None:
                 loader = self.scene.create_mjcf_loader()
                 asset_path = format_path(str(self.mjcf_path))
-
+            assert (
+                loader is not None
+            ), "No loader found. Provide either path in either urdf_path or mjcf_path"
             loader.name = self.uid
             if self._agent_idx is not None:
                 loader.name = f"{self.uid}-agent-{self._agent_idx}"
@@ -352,7 +358,7 @@ class BaseAgent:
         """
         self.controller.set_state(state)
 
-    def get_state(self) -> Dict:
+    def get_state(self) -> dict:
         """Get current state, including robot state and controller state"""
         state = dict()
 
@@ -369,7 +375,7 @@ class BaseAgent:
 
         return state
 
-    def set_state(self, state: Dict, ignore_controller=False):
+    def set_state(self, state: dict, ignore_controller=False):
         """Set the state of the agent, including the robot state and controller state.
         If ignore_controller is True, the controller state will not be updated."""
         # robot state

mani_skill/agents/base_real_agent.py

@@ -1,5 +1,5 @@
 from dataclasses import dataclass
-from typing import Dict, List, Optional
+from typing import Optional
 
 import numpy as np
 
@@ -15,10 +15,10 @@ class BaseRealAgent:
     to the real world.
 
     Args:
-        sensor_configs (Dict[str, BaseSensorConfig]): the sensor configs to create the agent with.
+        sensor_configs (dict[str, BaseSensorConfig]): the sensor configs to create the agent with.
     """
 
-    def __init__(self, sensor_configs: Dict[str, BaseSensorConfig] = dict()):
+    def __init__(self, sensor_configs: dict[str, BaseSensorConfig] = dict()):
         self.sensor_configs = sensor_configs
 
         self._sim_agent: BaseAgent = None
@@ -99,13 +99,13 @@ class BaseRealAgent:
     # data access for e.g. joint position values, sensor observations etc.
     # All of the def get_x() functions should return numpy arrays and be implemented
     # ---------------------------------------------------------------------------- #
-    def capture_sensor_data(self, sensor_names: Optional[List[str]] = None):
+    def capture_sensor_data(self, sensor_names: Optional[list[str]] = None):
         """
         Capture the sensor data asynchronously from the agent based on the given sensor names. If sensor_names is None then all sensor data should be captured. This should not return anything and should be async if possible.
         """
         raise NotImplementedError
 
-    def get_sensor_data(self, sensor_names: Optional[List[str]] = None):
+    def get_sensor_data(self, sensor_names: Optional[list[str]] = None):
         """
         Get the desired sensor observations from the agent based on the given sensor names. If sensor_names is None then all sensor data should be returned. The expected format for cameras is in line with the simulation's
         format for cameras.
@@ -126,7 +126,7 @@ class BaseRealAgent:
         """
         raise NotImplementedError
 
-    def get_sensor_params(self, sensor_names: List[str] = None):
+    def get_sensor_params(self, sensor_names: list[str] = None):
         """
         Get the parameters of the desired sensors based on the given sensor names. If sensor_names is None then all sensor parameters should be returned. The expected format for cameras is in line with the simulation's
         format is:

mani_skill/agents/controllers/base_controller.py

@@ -1,7 +1,7 @@
 from __future__ import annotations
 
 from dataclasses import dataclass
-from typing import TYPE_CHECKING, Dict, List, Optional
+from typing import TYPE_CHECKING, Optional
 
 import numpy as np
 import sapien
@@ -28,7 +28,7 @@ class BaseController:
     The controller is an interface for the robot to interact with the environment.
     """
 
-    joints: List[ArticulationJoint]
+    joints: list[ArticulationJoint]
     """active joints controlled"""
     active_joint_indices: torch.Tensor
     """indices of active joints controlled. Equivalent to [x.active_index for x in self.joints]"""
@@ -179,7 +179,7 @@ class BaseController:
 
 @dataclass
 class ControllerConfig:
-    joint_names: List[str]
+    joint_names: list[str]
     """the names of the joints to control. Note that some controller configurations might not actually let you directly control all the given joints
     and will instead have some other implicit control (e.g. Passive controllers or mimic controllers)."""
     # NOTE(jigu): It is a class variable in this base class,
@@ -193,7 +193,7 @@ class ControllerConfig:
 class DictController(BaseController):
     def __init__(
         self,
-        configs: Dict[str, ControllerConfig],
+        configs: dict[str, ControllerConfig],
         articulation: Articulation,
         control_freq: int,
         sim_freq: int = None,
@@ -204,7 +204,7 @@ class DictController(BaseController):
         self.articulation = articulation
         self._control_freq = control_freq
 
-        self.controllers: Dict[str, BaseController] = dict()
+        self.controllers: dict[str, BaseController] = dict()
         for uid, config in configs.items():
             self.controllers[uid] = config.controller_cls(
                 config, articulation, control_freq, sim_freq=sim_freq, scene=scene
@@ -252,7 +252,7 @@ class DictController(BaseController):
         for controller in self.controllers.values():
             controller.reset()
 
-    def set_action(self, action: Dict[str, np.ndarray]):
+    def set_action(self, action: dict[str, np.ndarray]):
         for uid, controller in self.controllers.items():
             controller.set_action(action[uid])
 

mani_skill/agents/controllers/pd_joint_pos.py

@@ -1,5 +1,5 @@
 from dataclasses import dataclass, field
-from typing import Dict, Sequence, Union
+from typing import Sequence, Union
 
 import numpy as np
 import torch
@@ -255,5 +255,5 @@ class PDJointPosMimicControllerConfig(PDJointPosControllerConfig):
     """
 
     controller_cls = PDJointPosMimicController
-    mimic: Dict[str, Dict[str, float]] = field(default_factory=dict)
+    mimic: dict[str, dict[str, float]] = field(default_factory=dict)
     """the mimic targets. Maps the actual mimic joint name to a dictionary of the format dict(joint: str, multiplier: float, offset: float)"""

mani_skill/agents/controllers/utils/kinematics.py

@@ -4,7 +4,7 @@ Code for kinematics utilities on CPU/GPU
 
 from contextlib import contextmanager, redirect_stderr, redirect_stdout
 from os import devnull
-from typing import List, Optional, Union
+from typing import Optional, Union
 
 from mani_skill.utils.geometry import rotation_conversions
 
@@ -62,7 +62,7 @@ class Kinematics:
 
         # note that everything past the end-link is ignored. Any joint whose ancestor is self.end_link is ignored
         cur_link = self.end_link
-        active_ancestor_joints: List[ArticulationJoint] = []
+        active_ancestor_joints: list[ArticulationJoint] = []
         while cur_link is not None:
             if cur_link.joint.active_index is not None:
                 active_ancestor_joints.append(cur_link.joint)
@@ -188,7 +188,9 @@ class Kinematics:
         q0: torch.Tensor,
         is_delta_pose: bool = False,
         current_pose: Optional[Pose] = None,
-        solver_config: dict = dict(type="levenberg_marquardt", solver_iterations=1, alpha=1.0),
+        solver_config: dict = dict(
+            type="levenberg_marquardt", solver_iterations=1, alpha=1.0
+        ),
     ):
         """Given a target pose, initial joint positions, this computes the target joint positions that will achieve the target pose.
         For optimization you can also provide the delta pose instead and specify is_delta_pose=True.
@@ -200,14 +202,21 @@ class Kinematics:
             current_pose (Optional[Pose]): current pose of the controlled link in the world frame. This is used to optimize the function by avoiding computing the current pose from q0 to compute the delta pose. If is_delta_pose is False, this is not used.
             solver_config (dict): configuration for the IK solver. Default is `dict(type="levenberg_marquardt", alpha=1.0)`. type can be one of "levenberg_marquardt" or "pseudo_inverse". alpha is a scaling term applied to the delta joint positions generated by the solver.
         """
-        assert isinstance(pose, Pose) or pose.shape[1] == 6, "pose must be a Pose or a tensor with shape (N, 6)"
+        assert (
+            isinstance(pose, Pose) or pose.shape[1] == 6
+        ), "pose must be a Pose or a tensor with shape (N, 6)"
         if self.use_gpu_ik:
             B = pose.shape[0]
             q0 = q0[:, self.active_ancestor_joint_idxs]
             if not is_delta_pose:
                 if current_pose is None:
                     current_pose = self.pk_chain.forward_kinematics(q0).get_matrix()
-                    current_pose = Pose.create_from_pq(current_pose[:, :3, 3], rotation_conversions.matrix_to_quaternion(current_pose[:, :3, :3]))
+                    current_pose = Pose.create_from_pq(
+                        current_pose[:, :3, 3],
+                        rotation_conversions.matrix_to_quaternion(
+                            current_pose[:, :3, :3]
+                        ),
+                    )
                 if isinstance(pose, torch.Tensor):
                     target_pos, target_rot = pose[:, 0:3], pose[:, 3:6]
                     target_quat = rotation_conversions.matrix_to_quaternion(
@@ -217,17 +226,23 @@ class Kinematics:
                 if isinstance(pose, Pose):
                     # the following assumes root_translation:root_aligned_body_rotation control frame
                     translation = pose.p - current_pose.p
-                    quaternion = rotation_conversions.quaternion_multiply(pose.q, rotation_conversions.quaternion_invert(current_pose.q))
+                    quaternion = rotation_conversions.quaternion_multiply(
+                        pose.q, rotation_conversions.quaternion_invert(current_pose.q)
+                    )
                     pose = Pose.create_from_pq(translation, quaternion)
             if isinstance(pose, Pose):
-                delta_pose = torch.zeros((B, 6), device=self.device, dtype=torch.float32)
+                delta_pose = torch.zeros(
+                    (B, 6), device=self.device, dtype=torch.float32
+                )
                 delta_pose[:, 0:3] = pose.p
-                delta_pose[:, 3:6] = rotation_conversions.matrix_to_euler_angles(rotation_conversions.quaternion_to_matrix(pose.q), "XYZ")
+                delta_pose[:, 3:6] = rotation_conversions.matrix_to_euler_angles(
+                    rotation_conversions.quaternion_to_matrix(pose.q), "XYZ"
+                )
             else:
                 delta_pose = pose
             jacobian = self.pk_chain.jacobian(q0)[:, :, self.qmask]
             if solver_config["type"] == "levenberg_marquardt":
-                lambd = 0.0001 # Regularization parameter to ensure J^T * J is non-singular.
+                lambd = 0.0001  # Regularization parameter to ensure J^T * J is non-singular.
                 J_T = jacobian.transpose(1, 2)
                 lfs_A = torch.bmm(J_T, jacobian) + lambd * torch.eye(
                     len(self.qmask), device=self.device
@@ -239,9 +254,9 @@ class Kinematics:
                 # NOTE (stao): this method of IK is from https://mathweb.ucsd.edu/~sbuss/ResearchWeb/ikmethods/iksurvey.pdf by Samuel R. Buss
                 delta_joint_pos = torch.linalg.pinv(jacobian) @ delta_pose.unsqueeze(-1)
 
-            return q0[:, self.qmask] + solver_config[
-                "alpha"
-            ] * delta_joint_pos.squeeze(-1)
+            return q0[:, self.qmask] + solver_config["alpha"] * delta_joint_pos.squeeze(
+                -1
+            )
         else:
             q0 = q0[:, self.pmodel_active_joint_indices]
             result, success, error = self.pmodel.compute_inverse_kinematics(

mani_skill/agents/multi_agent.py

@@ -1,4 +1,4 @@
-from typing import Dict, Generic, List, TypeVar
+from typing import Generic, TypeVar
 
 import torch
 from gymnasium import spaces
@@ -11,9 +11,9 @@ T = TypeVar("T")
 class MultiAgent(BaseAgent, Generic[T]):
     agents: T
 
-    def __init__(self, agents: List[BaseAgent]):
+    def __init__(self, agents: list[BaseAgent]):
         self.agents = agents
-        self.agents_dict: Dict[str, BaseAgent] = dict()
+        self.agents_dict: dict[str, BaseAgent] = dict()
         self.scene = agents[0].scene
         self.sensor_configs = []
         for i, agent in enumerate(self.agents):
@@ -31,7 +31,7 @@ class MultiAgent(BaseAgent, Generic[T]):
         """Get the currently activated controller uid of each robot"""
         return {uid: agent.control_mode for uid, agent in self.agents_dict.items()}
 
-    def set_control_mode(self, control_mode: List[str] = None):
+    def set_control_mode(self, control_mode: list[str] = None):
         """Set the controller, drive properties, and reset for each agent. If given control mode is None, will set defaults"""
         if control_mode is None:
             for agent in self.agents:
@@ -78,7 +78,7 @@ class MultiAgent(BaseAgent, Generic[T]):
             uid: agent.get_controller_state() for uid, agent in self.agents_dict.items()
         }
 
-    def set_controller_state(self, state: Dict):
+    def set_controller_state(self, state: dict):
         for uid, agent in self.agents_dict.items():
             agent.set_controller_state(state[uid])
 

mani_skill/agents/registration.py

@@ -1,5 +1,4 @@
 from dataclasses import dataclass
-from typing import Dict, List
 
 from mani_skill import logger
 from mani_skill.agents.base_agent import BaseAgent
@@ -9,13 +8,13 @@ from mani_skill.utils import assets
 @dataclass
 class AgentSpec:
     agent_cls: type[BaseAgent]
-    asset_download_ids: List[str]
+    asset_download_ids: list[str]
 
 
-REGISTERED_AGENTS: Dict[str, AgentSpec] = {}
+REGISTERED_AGENTS: dict[str, AgentSpec] = {}
 
 
-def register_agent(asset_download_ids: List[str] = [], override=False):
+def register_agent(asset_download_ids: list[str] = [], override=False):
     """A decorator to register agents into ManiSkill so they can be used easily by string uid.
 
     Args:

mani_skill/agents/robots/allegro_hand/allegro.py

@@ -1,5 +1,4 @@
 from copy import deepcopy
-from typing import List
 
 import numpy as np
 import sapien
@@ -83,7 +82,7 @@ class AllegroHandRight(BaseAgent):
         super().__init__(*args, **kwargs)
 
     def _after_init(self):
-        self.tip_links: List[sapien.Entity] = sapien_utils.get_objs_by_names(
+        self.tip_links: list[sapien.Entity] = sapien_utils.get_objs_by_names(
             self.robot.get_links(), self.tip_link_names
         )
         self.palm_link: sapien.Entity = sapien_utils.get_obj_by_name(

mani_skill/agents/robots/allegro_hand/allegro_touch.py

@@ -1,5 +1,5 @@
 import itertools
-from typing import Dict, List, Optional, Tuple
+from typing import Optional, Tuple
 
 import numpy as np
 import sapien
@@ -45,7 +45,7 @@ class AllegroHandRightTouch(AllegroHandRight):
 
         super().__init__(*args, **kwargs)
 
-        self.pair_query: Dict[
+        self.pair_query: dict[
             str, Tuple[physx.PhysxGpuContactPairImpulseQuery, Tuple[int, int, int]]
         ] = dict()
         self.body_query: Optional[
@@ -54,7 +54,7 @@ class AllegroHandRightTouch(AllegroHandRight):
 
     def _after_init(self):
         super()._after_init()
-        self.fsr_links: List[Actor] = sapien_utils.get_objs_by_names(
+        self.fsr_links: list[Actor] = sapien_utils.get_objs_by_names(
             self.robot.get_links(),
             self.palm_fsr_link_names + self.finger_fsr_link_names,
         )

mani_skill/agents/robots/dclaw/dclaw.py

@@ -1,5 +1,4 @@
 from copy import deepcopy
-from typing import List
 
 import numpy as np
 import sapien
@@ -58,10 +57,10 @@ class DClaw(BaseAgent):
         super().__init__(*args, **kwargs)
 
     def _after_init(self):
-        self.tip_links: List[Link] = sapien_utils.get_objs_by_names(
+        self.tip_links: list[Link] = sapien_utils.get_objs_by_names(
             self.robot.get_links(), self.tip_link_names
         )
-        self.root_joints: List[ArticulationJoint] = [
+        self.root_joints: list[ArticulationJoint] = [
             self.robot.find_joint_by_name(n) for n in self.root_joint_names
         ]
         self.root_joint_indices = get_active_joint_indices(

mani_skill/agents/robots/fetch/fetch.py

@@ -1,5 +1,5 @@
 from copy import deepcopy
-from typing import Dict, Tuple
+from typing import Tuple
 
 import numpy as np
 import sapien
@@ -367,7 +367,7 @@ class Fetch(BaseAgent):
             self.robot.get_links(), "head_camera_link"
         )
 
-        self.queries: Dict[
+        self.queries: dict[
             str, Tuple[physx.PhysxGpuContactPairImpulseQuery, Tuple[int]]
         ] = dict()
 

mani_skill/agents/robots/floating_ability_hand/floating_ability_hand.py

@@ -1,5 +1,4 @@
-from copy import deepcopy
-from typing import Dict, Tuple
+from typing import Tuple
 
 import numpy as np
 import sapien
@@ -15,7 +14,9 @@ from mani_skill.utils import sapien_utils
 @register_agent()
 class FloatingAbilityHandRight(BaseAgent):
     uid = "floating_ability_hand_right"
-    urdf_path = f"{PACKAGE_ASSET_DIR}/robots/ability_hand/ability_hand_right_floating.urdf"
+    urdf_path = (
+        f"{PACKAGE_ASSET_DIR}/robots/ability_hand/ability_hand_right_floating.urdf"
+    )
     urdf_config = dict(
         _materials=dict(
             front_finger=dict(
@@ -87,7 +88,6 @@ class FloatingAbilityHandRight(BaseAgent):
             "middle_q2",
             "ring_q2",
             "pinky_q2",
-
             # "thumb_q1",
             # "index_q1",
             # "middle_q1",
@@ -99,10 +99,7 @@ class FloatingAbilityHandRight(BaseAgent):
             # "ring_q2",
             # "pinky_q2",
         ]
-        self.thumb_joint_names = [
-            "thumb_q1",
-            "thumb_q2"
-        ]
+        self.thumb_joint_names = ["thumb_q1", "thumb_q2"]
         self.hand_stiffness = 1e3
         self.hand_damping = 1e2
         self.hand_force_limit = 50
@@ -131,8 +128,8 @@ class FloatingAbilityHandRight(BaseAgent):
         # -------------------------------------------------------------------------- #
         hand_joint_pos = PDJointPosMimicControllerConfig(
             self.hand_joint_names,
-            None,# [0, 0, 0, 0, 0, 0, 0, 0, -2.0943951, 0],
-            None, # [2.0943951, 2.0943951, 2.0943951, 2.0943951, 2.65860, 2.65860, 2.65860, 2.65860, 0, 2.0943951],
+            None,  # [0, 0, 0, 0, 0, 0, 0, 0, -2.0943951, 0],
+            None,  # [2.0943951, 2.0943951, 2.0943951, 2.0943951, 2.65860, 2.65860, 2.65860, 2.65860, 0, 2.0943951],
             self.hand_stiffness,
             self.hand_damping,
             self.hand_force_limit,
@@ -162,8 +159,8 @@ class FloatingAbilityHandRight(BaseAgent):
         )
         thumb_joint_pos = PDJointPosControllerConfig(
             self.thumb_joint_names,
-            None, # [0, 0, 0, 0, 0, 0, 0, 0, -2.0943951, 0],
-            None, # [2.0943951, 2.0943951, 2.0943951, 2.0943951, 2.65860, 2.65860, 2.65860, 2.65860, 0, 2.0943951],
+            None,  # [0, 0, 0, 0, 0, 0, 0, 0, -2.0943951, 0],
+            None,  # [2.0943951, 2.0943951, 2.0943951, 2.0943951, 2.65860, 2.65860, 2.65860, 2.65860, 0, 2.0943951],
             self.hand_stiffness,
             self.hand_damping,
             self.hand_force_limit,
@@ -214,4 +211,4 @@ class FloatingAbilityHandRight(BaseAgent):
             self.robot.get_links(), self.ee_link_name
         )
 
-        self.queries: Dict[str, Tuple[physx.PhysxGpuContactQuery, Tuple[int]]] = dict()
+        self.queries: dict[str, Tuple[physx.PhysxGpuContactQuery, Tuple[int]]] = dict()

mani_skill/agents/robots/floating_robotiq_2f_85_gripper/floating_robotiq_2f_85_gripper.py

@@ -1,4 +1,4 @@
-from typing import Dict, Union
+from typing import Union
 
 import numpy as np
 import sapien
@@ -59,7 +59,7 @@ class FloatingRobotiq2F85Gripper(BaseAgent):
     @property
     def _controller_configs(
         self,
-    ) -> Dict[str, Union[ControllerConfig, DictControllerConfig]]:
+    ) -> dict[str, Union[ControllerConfig, DictControllerConfig]]:
 
         # define a simple controller to control the floating base with XYZ/RPY control.
         base_pd_joint_pos = PDJointPosControllerConfig(

mani_skill/agents/robots/lerobot/manipulator.py

@@ -3,7 +3,7 @@ Code based on https://github.com/huggingface/lerobot for supporting real robot c
 """
 
 import time
-from typing import List, Optional
+from typing import Optional
 
 import numpy as np
 import torch
@@ -39,7 +39,7 @@ class LeRobotRealAgent(BaseRealAgent):
         self.real_robot = robot
         self.use_cached_qpos = use_cached_qpos
         self._cached_qpos = None
-        self._motor_keys: List[str] = None
+        self._motor_keys: list[str] = None
 
         if self.real_robot.name == "so100_follower":
             self.real_robot.bus.motors["gripper"].norm_mode = MotorNormMode.DEGREES
@@ -78,7 +78,7 @@ class LeRobotRealAgent(BaseRealAgent):
             dt_s = time.perf_counter() - start_loop_t
             busy_wait(1 / freq - dt_s)
 
-    def capture_sensor_data(self, sensor_names: Optional[List[str]] = None):
+    def capture_sensor_data(self, sensor_names: Optional[list[str]] = None):
         sensor_obs = dict()
         cameras: dict[str, Camera] = self.real_robot.cameras
         if sensor_names is None:
@@ -90,7 +90,7 @@ class LeRobotRealAgent(BaseRealAgent):
             sensor_obs[name] = dict(rgb=(common.to_tensor(data)).unsqueeze(0))
         self._captured_sensor_data = sensor_obs
 
-    def get_sensor_data(self, sensor_names: Optional[List[str]] = None):
+    def get_sensor_data(self, sensor_names: Optional[list[str]] = None):
         if self._captured_sensor_data is None:
             raise RuntimeError(
                 "No sensor data captured yet. Please call capture_sensor_data() first."

mani_skill/agents/robots/panda/panda_stick.py

@@ -1,5 +1,5 @@
 from copy import deepcopy
-from typing import Dict, Tuple
+from typing import Tuple
 
 import numpy as np
 import sapien
@@ -169,7 +169,7 @@ class PandaStick(BaseAgent):
             self.robot.get_links(), self.ee_link_name
         )
 
-        self.queries: Dict[
+        self.queries: dict[
             str, Tuple[physx.PhysxGpuContactPairImpulseQuery, Tuple[int]]
         ] = dict()
 

mani_skill/agents/robots/trifingerpro/trifingerpro.py

@@ -1,5 +1,4 @@
 from copy import deepcopy
-from typing import List
 
 import sapien
 import torch
@@ -77,7 +76,7 @@ class TriFingerPro(BaseAgent):
         super().__init__(*args, **kwargs)
 
     def _after_init(self):
-        self.tip_links: List[sapien.Entity] = get_objs_by_names(
+        self.tip_links: list[sapien.Entity] = get_objs_by_names(
             self.robot.get_links(), self.tip_link_names
         )
         self.root_joints = [

mani_skill/agents/robots/xarm/xarm7_ability.py

@@ -1,5 +1,5 @@
 from copy import deepcopy
-from typing import Dict, Tuple
+from typing import Tuple
 
 import numpy as np
 import sapien
@@ -201,4 +201,4 @@ class XArm7Ability(BaseAgent):
             self.robot.get_links(), self.ee_link_name
         )
 
-        self.queries: Dict[str, Tuple[physx.PhysxGpuContactQuery, Tuple[int]]] = dict()
+        self.queries: dict[str, Tuple[physx.PhysxGpuContactQuery, Tuple[int]]] = dict()

mani_skill/agents/utils.py

@@ -1,6 +1,6 @@
 # TODO(jigu): Move to sapien_utils.py
 
-from typing import Dict, Sequence
+from typing import Sequence
 
 import numpy as np
 import sapien
@@ -25,7 +25,7 @@ def get_joints_by_names(articulation: Articulation, joint_names: Sequence[str]):
     return [joints[idx] for idx in joint_indices]
 
 
-def flatten_action_spaces(action_spaces: Dict[str, spaces.Space]):
+def flatten_action_spaces(action_spaces: dict[str, spaces.Space]):
     """Flat multiple Box action spaces into a single Box space."""
     action_dims = []
     low = []

mani_skill/envs/minimal_template.py

@@ -1,4 +1,4 @@
-from typing import Any, Dict, Union
+from typing import Any, Union
 
 import numpy as np
 import sapien
@@ -53,14 +53,14 @@ class CustomEnv(BaseEnv):
             "fail": torch.zeros(self.num_envs, device=self.device, dtype=bool),
         }
 
-    def _get_obs_extra(self, info: Dict):
+    def _get_obs_extra(self, info: dict):
         return dict()
 
-    def compute_dense_reward(self, obs: Any, action: torch.Tensor, info: Dict):
+    def compute_dense_reward(self, obs: Any, action: torch.Tensor, info: dict):
         return torch.zeros(self.num_envs, device=self.device)
 
     def compute_normalized_dense_reward(
-        self, obs: Any, action: torch.Tensor, info: Dict
+        self, obs: Any, action: torch.Tensor, info: dict
     ):
         max_reward = 1.0
         return self.compute_dense_reward(obs=obs, action=action, info=info) / max_reward