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

mani_skill/envs/tasks/tabletop/push_cube.py

@@ -15,7 +15,7 @@ in addition to initializing any task relevant data like a goal
 See comments for how to make your own environment and what each required function should do
 """
 
-from typing import Any, Dict, Union
+from typing import Any, Union
 
 import numpy as np
 import sapien
@@ -191,7 +191,7 @@ class PushCubeEnv(BaseEnv):
             "success": is_obj_placed,
         }
 
-    def _get_obs_extra(self, info: Dict):
+    def _get_obs_extra(self, info: dict):
         # some useful observation info for solving the task includes the pose of the tcp (tool center point) which is the point between the
         # grippers of the robot
         obs = dict(
@@ -206,7 +206,7 @@ class PushCubeEnv(BaseEnv):
             )
         return obs
 
-    def compute_dense_reward(self, obs: Any, action: Array, info: Dict):
+    def compute_dense_reward(self, obs: Any, action: Array, info: dict):
         # We also create a pose marking where the robot should push the cube from that is easiest (pushing from behind the cube)
         tcp_push_pose = Pose.create_from_pq(
             p=self.obj.pose.p
@@ -226,13 +226,13 @@ class PushCubeEnv(BaseEnv):
         )
         place_reward = 1 - torch.tanh(5 * obj_to_goal_dist)
         reward += place_reward * reached
-        
+
         # Compute a z reward to encourage the robot to keep the cube on the table
         desired_obj_z = self.cube_half_size
         current_obj_z = self.obj.pose.p[..., 2]
         z_deviation = torch.abs(current_obj_z - desired_obj_z)
         z_reward = 1 - torch.tanh(5 * z_deviation)
-        # We multiply the z reward by the place_reward and reached mask so that 
+        # We multiply the z reward by the place_reward and reached mask so that
         #   we only add the z reward if the robot has reached the desired push pose
         #   and the z reward becomes more important as the robot gets closer to the goal.
         reward += place_reward * z_reward * reached
@@ -241,7 +241,7 @@ class PushCubeEnv(BaseEnv):
         reward[info["success"]] = 4
         return reward
 
-    def compute_normalized_dense_reward(self, obs: Any, action: Array, info: Dict):
+    def compute_normalized_dense_reward(self, obs: Any, action: Array, info: dict):
         # this should be equal to compute_dense_reward / max possible reward
         max_reward = 4.0
         return self.compute_dense_reward(obs=obs, action=action, info=info) / max_reward

mani_skill/envs/tasks/tabletop/push_t.py

@@ -1,4 +1,4 @@
-from typing import Any, Dict
+from typing import Any
 
 import numpy as np
 import sapien
@@ -489,7 +489,7 @@ class PushTEnv(BaseEnv):
 
         return {"success": success}
 
-    def _get_obs_extra(self, info: Dict):
+    def _get_obs_extra(self, info: dict):
         # ee position is super useful for pandastick robot
         obs = dict(
             tcp_pose=self.agent.tcp.pose.raw_pose,
@@ -502,7 +502,7 @@ class PushTEnv(BaseEnv):
             )
         return obs
 
-    def compute_dense_reward(self, obs: Any, action: Array, info: Dict):
+    def compute_dense_reward(self, obs: Any, action: Array, info: dict):
         # reward for overlap of the tees
 
         # legacy reward
@@ -533,6 +533,6 @@ class PushTEnv(BaseEnv):
         reward[info["success"]] = 3
         return reward
 
-    def compute_normalized_dense_reward(self, obs: Any, action: Array, info: Dict):
+    def compute_normalized_dense_reward(self, obs: Any, action: Array, info: dict):
         max_reward = 3.0
         return self.compute_dense_reward(obs=obs, action=action, info=info) / max_reward

mani_skill/envs/tasks/tabletop/roll_ball.py

@@ -1,4 +1,4 @@
-from typing import Any, Dict
+from typing import Any
 
 import numpy as np
 import sapien
@@ -135,7 +135,7 @@ class RollBallEnv(BaseEnv):
             "success": is_obj_placed,
         }
 
-    def _get_obs_extra(self, info: Dict):
+    def _get_obs_extra(self, info: dict):
 
         obs = dict(
             tcp_pose=self.agent.tcp.pose.raw_pose,
@@ -150,7 +150,7 @@ class RollBallEnv(BaseEnv):
             )
         return obs
 
-    def compute_dense_reward(self, obs: Any, action: Array, info: Dict):
+    def compute_dense_reward(self, obs: Any, action: Array, info: dict):
         unit_vec = self.ball.pose.p - self.goal_region.pose.p
         unit_vec = unit_vec / torch.linalg.norm(unit_vec, axis=1, keepdim=True)
         tcp_hit_pose = Pose.create_from_pq(
@@ -176,6 +176,6 @@ class RollBallEnv(BaseEnv):
         reward[info["success"]] = 30.0
         return reward
 
-    def compute_normalized_dense_reward(self, obs: Any, action: Array, info: Dict):
+    def compute_normalized_dense_reward(self, obs: Any, action: Array, info: dict):
         max_reward = 30.0
         return self.compute_dense_reward(obs=obs, action=action, info=info) / max_reward

mani_skill/envs/tasks/tabletop/stack_cube.py

@@ -1,4 +1,4 @@
-from typing import Any, Dict, Union
+from typing import Any, Union
 
 import numpy as np
 import sapien
@@ -130,7 +130,7 @@ class StackCubeEnv(BaseEnv):
             "success": success.bool(),
         }
 
-    def _get_obs_extra(self, info: Dict):
+    def _get_obs_extra(self, info: dict):
         obs = dict(tcp_pose=self.agent.tcp.pose.raw_pose)
         if "state" in self.obs_mode:
             obs.update(
@@ -142,7 +142,7 @@ class StackCubeEnv(BaseEnv):
             )
         return obs
 
-    def compute_dense_reward(self, obs: Any, action: torch.Tensor, info: Dict):
+    def compute_dense_reward(self, obs: Any, action: torch.Tensor, info: dict):
         # reaching reward
         tcp_pose = self.agent.tcp.pose.p
         cubeA_pos = self.cubeA.pose.p
@@ -181,6 +181,6 @@ class StackCubeEnv(BaseEnv):
         return reward
 
     def compute_normalized_dense_reward(
-        self, obs: Any, action: torch.Tensor, info: Dict
+        self, obs: Any, action: torch.Tensor, info: dict
     ):
         return self.compute_dense_reward(obs=obs, action=action, info=info) / 8

mani_skill/envs/tasks/tabletop/stack_pyramid.py

@@ -1,4 +1,4 @@
-from typing import Any, Dict, Union
+from typing import Union
 
 import numpy as np
 import sapien
@@ -7,17 +7,18 @@ import torch
 from mani_skill.agents.robots import Fetch, Panda
 from mani_skill.envs.sapien_env import BaseEnv
 from mani_skill.envs.utils import randomization
+from mani_skill.sensors.camera import CameraConfig
+from mani_skill.utils import common, sapien_utils
+from mani_skill.utils.building import actors
 from mani_skill.utils.geometry.rotation_conversions import (
     euler_angles_to_matrix,
     matrix_to_quaternion,
 )
-from mani_skill.sensors.camera import CameraConfig
-from mani_skill.utils import common, sapien_utils
-from mani_skill.utils.building import actors
+from mani_skill.utils.logging_utils import logger
 from mani_skill.utils.registration import register_env
 from mani_skill.utils.scene_builder.table import TableSceneBuilder
-from mani_skill.utils.structs.pose import Pose  
-from mani_skill.utils.logging_utils import logger
+from mani_skill.utils.structs.pose import Pose
+
 
 @register_env("StackPyramid-v1", max_episode_steps=250)
 class StackPyramidEnv(BaseEnv):
@@ -40,7 +41,7 @@ class StackPyramidEnv(BaseEnv):
 
     SUPPORTED_ROBOTS = ["panda_wristcam", "panda", "fetch"]
     SUPPORTED_REWARD_MODES = ["none", "sparse"]
-    
+
     agent: Union[Panda, Fetch]
 
     def __init__(
@@ -59,7 +60,6 @@ class StackPyramidEnv(BaseEnv):
         pose = sapien_utils.look_at([0.6, 0.7, 0.6], [0.0, 0.0, 0.35])
         return CameraConfig("render_camera", pose, 512, 512, 1, 0.01, 100)
 
-
     def _load_scene(self, options: dict):
         self.cube_half_size = common.to_tensor([0.02] * 3)
         self.table_scene = TableSceneBuilder(
@@ -67,13 +67,25 @@ class StackPyramidEnv(BaseEnv):
         )
         self.table_scene.build()
         self.cubeA = actors.build_cube(
-            self.scene, half_size=0.02, color=[1, 0, 0, 1], name="cubeA", initial_pose=sapien.Pose(p=[0, 0, 0.2])
+            self.scene,
+            half_size=0.02,
+            color=[1, 0, 0, 1],
+            name="cubeA",
+            initial_pose=sapien.Pose(p=[0, 0, 0.2]),
         )
         self.cubeB = actors.build_cube(
-            self.scene, half_size=0.02, color=[0, 1, 0, 1], name="cubeB", initial_pose=sapien.Pose(p=[1, 0, 0.2])
+            self.scene,
+            half_size=0.02,
+            color=[0, 1, 0, 1],
+            name="cubeB",
+            initial_pose=sapien.Pose(p=[1, 0, 0.2]),
         )
         self.cubeC = actors.build_cube(
-            self.scene, half_size=0.02, color=[0, 0, 1, 1], name="cubeC", initial_pose=sapien.Pose(p=[-1, 0, 0.2])
+            self.scene,
+            half_size=0.02,
+            color=[0, 0, 1, 1],
+            name="cubeC",
+            initial_pose=sapien.Pose(p=[-1, 0, 0.2]),
         )
 
     def _initialize_episode(self, env_idx: torch.Tensor, options: dict):
@@ -85,7 +97,9 @@ class StackPyramidEnv(BaseEnv):
             xyz[:, 2] = 0.02
             xy = xyz[:, :2]
             region = [[-0.1, -0.2], [0.1, 0.2]]
-            sampler = randomization.UniformPlacementSampler(bounds=region, batch_size=b, device=self.device)
+            sampler = randomization.UniformPlacementSampler(
+                bounds=region, batch_size=b, device=self.device
+            )
             radius = torch.linalg.norm(torch.tensor([0.02, 0.02]))
             cubeA_xy = xy + sampler.sample(radius, 100)
             cubeB_xy = xy + sampler.sample(radius, 100, verbose=False)
@@ -93,7 +107,7 @@ class StackPyramidEnv(BaseEnv):
 
             # Cube A
             xyz[:, :2] = cubeA_xy
-            
+
             qs = randomization.random_quaternions(
                 b,
                 lock_x=True,
@@ -112,7 +126,7 @@ class StackPyramidEnv(BaseEnv):
                 lock_z=False,
             )
             self.cubeB.set_pose(Pose.create_from_pq(p=xyz.clone(), q=qs))
-            
+
             # Cube C
             xyz[:, :2] = cubeC_xy
             qs = randomization.random_quaternions(
@@ -133,33 +147,39 @@ class StackPyramidEnv(BaseEnv):
         offset_AC = pos_A - pos_C
 
         def evaluate_cube_distance(offset, cube_a, cube_b, top_or_next):
-            xy_flag = (torch.linalg.norm(offset[..., :2], axis=1) 
-                       <= torch.linalg.norm(2*self.cube_half_size[:2]) 
-                       + 0.005
-                       )
+            xy_flag = (
+                torch.linalg.norm(offset[..., :2], axis=1)
+                <= torch.linalg.norm(2 * self.cube_half_size[:2]) + 0.005
+            )
             z_flag = torch.abs(offset[..., 2]) > 0.02
             if top_or_next == "top":
                 is_cubeA_on_cubeB = torch.logical_and(xy_flag, z_flag)
             elif top_or_next == "next_to":
                 is_cubeA_on_cubeB = xy_flag
             else:
-                return NotImplementedError(f"Expect top_or_next to be either 'top' or 'next_to', got {top_or_next}")
-            
+                return NotImplementedError(
+                    f"Expect top_or_next to be either 'top' or 'next_to', got {top_or_next}"
+                )
+
             is_cubeA_static = cube_a.is_static(lin_thresh=1e-2, ang_thresh=0.5)
             is_cubeA_grasped = self.agent.is_grasping(cube_a)
 
-            success = is_cubeA_on_cubeB & is_cubeA_static & (~is_cubeA_grasped)            
+            success = is_cubeA_on_cubeB & is_cubeA_static & (~is_cubeA_grasped)
             return success.bool()
 
-        success_A_B = evaluate_cube_distance(offset_AB, self.cubeA, self.cubeB, "next_to")
+        success_A_B = evaluate_cube_distance(
+            offset_AB, self.cubeA, self.cubeB, "next_to"
+        )
         success_C_B = evaluate_cube_distance(offset_BC, self.cubeC, self.cubeB, "top")
         success_C_A = evaluate_cube_distance(offset_AC, self.cubeC, self.cubeA, "top")
-        success = torch.logical_and(success_A_B, torch.logical_and(success_C_B, success_C_A))
+        success = torch.logical_and(
+            success_A_B, torch.logical_and(success_C_B, success_C_A)
+        )
         return {
             "success": success,
         }
 
-    def _get_obs_extra(self, info: Dict):
+    def _get_obs_extra(self, info: dict):
         obs = dict(tcp_pose=self.agent.tcp.pose.raw_pose)
         if "state" in self.obs_mode:
             obs.update(
@@ -174,4 +194,3 @@ class StackPyramidEnv(BaseEnv):
                 cubeA_to_cubeC_pos=self.cubeC.pose.p - self.cubeA.pose.p,
             )
         return obs
-    

mani_skill/envs/tasks/tabletop/turn_faucet.py

@@ -1,4 +1,4 @@
-from typing import Dict, List, Union
+from typing import Union
 
 import numpy as np
 import sapien
@@ -85,7 +85,7 @@ class TurnFaucetEnv(BaseEnv):
         switch_link_ids = self._batched_episode_rng.randint(0, 2**31)
 
         self._faucets = []
-        self._target_switch_links: List[Link] = []
+        self._target_switch_links: list[Link] = []
         self.model_offsets = []
         for i, model_id in enumerate(model_ids):
             # partnet-mobility is a dataset source and the ids are the ones we sampled
@@ -188,7 +188,7 @@ class TurnFaucetEnv(BaseEnv):
         angle_dist = self.target_angle - self.current_angle
         return dict(success=angle_dist < 0, angle_dist=angle_dist)
 
-    def _get_obs_extra(self, info: Dict):
+    def _get_obs_extra(self, info: dict):
         obs = dict(
             tcp_pose=self.agent.tcp.pose.raw_pose,
             target_angle_diff=self.target_angle_diff,
@@ -231,7 +231,7 @@ class TurnFaucetEnv(BaseEnv):
     #     return reward
 
     # def compute_normalized_dense_reward(
-    #     self, obs: Any, action: torch.Tensor, info: Dict
+    #     self, obs: Any, action: torch.Tensor, info: dict
     # ):
     #     max_reward = 10.0
     #     return self.compute_dense_reward(obs=obs, action=action, info=info) / max_reward

mani_skill/envs/tasks/tabletop/two_robot_pick_cube.py

@@ -1,4 +1,4 @@
-from typing import Any, Dict, Tuple
+from typing import Any, Tuple
 
 import numpy as np
 import sapien
@@ -139,7 +139,7 @@ class TwoRobotPickCube(BaseEnv):
             "is_right_arm_static": is_right_arm_static,
         }
 
-    def _get_obs_extra(self, info: Dict):
+    def _get_obs_extra(self, info: dict):
         obs = dict(
             left_arm_tcp=self.left_agent.tcp.pose.raw_pose,
             right_arm_tcp=self.right_agent.tcp.pose.raw_pose,
@@ -154,7 +154,7 @@ class TwoRobotPickCube(BaseEnv):
             )
         return obs
 
-    def compute_dense_reward(self, obs: Any, action: torch.Tensor, info: Dict):
+    def compute_dense_reward(self, obs: Any, action: torch.Tensor, info: dict):
         # Stage 1: Reach and push cube to be near other robot
         tcp_to_obj_dist = torch.linalg.norm(
             self.cube.pose.p - self.left_agent.tcp.pose.p, axis=1
@@ -257,6 +257,6 @@ class TwoRobotPickCube(BaseEnv):
         return reward
 
     def compute_normalized_dense_reward(
-        self, obs: Any, action: torch.Tensor, info: Dict
+        self, obs: Any, action: torch.Tensor, info: dict
     ):
         return self.compute_dense_reward(obs=obs, action=action, info=info) / 21

mani_skill/envs/tasks/tabletop/two_robot_stack_cube.py

@@ -1,4 +1,4 @@
-from typing import Any, Dict, Tuple
+from typing import Any, Tuple
 
 import numpy as np
 import sapien
@@ -193,7 +193,7 @@ class TwoRobotStackCube(BaseEnv):
             "success": success.bool(),
         }
 
-    def _get_obs_extra(self, info: Dict):
+    def _get_obs_extra(self, info: dict):
         obs = dict(
             left_arm_tcp=self.left_agent.tcp.pose.raw_pose,
             right_arm_tcp=self.right_agent.tcp.pose.raw_pose,
@@ -211,7 +211,7 @@ class TwoRobotStackCube(BaseEnv):
             )
         return obs
 
-    def compute_dense_reward(self, obs: Any, action: torch.Tensor, info: Dict):
+    def compute_dense_reward(self, obs: Any, action: torch.Tensor, info: dict):
         # Stage 1: Reach and grasp
         # reaching reward for both robots to their respective cubes
         cubeA_to_left_arm_tcp_dist = torch.linalg.norm(
@@ -291,6 +291,6 @@ class TwoRobotStackCube(BaseEnv):
         return reward
 
     def compute_normalized_dense_reward(
-        self, obs: Any, action: torch.Tensor, info: Dict
+        self, obs: Any, action: torch.Tensor, info: dict
     ):
         return self.compute_dense_reward(obs=obs, action=action, info=info) / 10

mani_skill/envs/template.py

@@ -21,7 +21,7 @@ mani_skill /envs/tasks/push_cube.py which is annotated with comments to explain
 """
 
 
-from typing import Any, Dict, Union
+from typing import Any, Union
 
 import numpy as np
 import sapien
@@ -169,21 +169,21 @@ 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):
         # should return an dict of additional observation data for your tasks
         # this will be included as part of the observation in the "extra" key when obs_mode="state_dict" or any of the visual obs_modes
         # and included as part of a flattened observation when obs_mode="state". Moreover, you have access to the info object
         # which is generated by the `evaluate` function above
         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):
         # you can optionally provide a dense reward function by returning a scalar value here. This is used when reward_mode="dense"
         # note that as everything is batched, you must return a batch of of self.num_envs rewards as done in the example below.
         # Moreover, you have access to the info object which is generated by the `evaluate` function above
         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
     ):
         # this should be equal to compute_dense_reward / max possible reward
         max_reward = 1.0

mani_skill/envs/utils/observations/observations.py

@@ -2,7 +2,6 @@
 Functions that map a observation to a particular format, e.g. mapping the raw images to rgbd or pointcloud formats
 """
 
-from typing import Dict
 
 import numpy as np
 import sapien.physx as physx
@@ -14,7 +13,7 @@ from mani_skill.sensors.camera import Camera
 from mani_skill.utils import common
 
 
-def sensor_data_to_pointcloud(observation: Dict, sensors: Dict[str, BaseSensor]):
+def sensor_data_to_pointcloud(observation: dict, sensors: dict[str, BaseSensor]):
     """convert all camera data in sensor to pointcloud data"""
     sensor_data = observation["sensor_data"]
     camera_params = observation["sensor_param"]
@@ -29,7 +28,7 @@ def sensor_data_to_pointcloud(observation: Dict, sensors: Dict[str, BaseSensor])
             # TODO: double check if the .clone()s are necessary
             # Each pixel is (x, y, z, actor_id) in OpenGL camera space
             # actor_id = 0 for the background
-            images: Dict[str, torch.Tensor]
+            images: dict[str, torch.Tensor]
             position = images["position"].clone()
             segmentation = images["segmentation"].clone()
             position = position.float()

mani_skill/envs/utils/randomization/batched_rng.py

@@ -3,7 +3,7 @@ Code implementation for a batched random number generator. The goal is to enable
 in CPU simulators and GPU simulators are the same
 """
 
-from typing import List, Union
+from typing import Union
 
 import numpy as np
 
@@ -11,21 +11,21 @@ from mani_skill.utils import common
 
 
 class BatchedRNG(np.random.RandomState):
-    def __init__(self, rngs: List):
+    def __init__(self, rngs: list):
         self.rngs = rngs
         self.batch_size = len(rngs)
 
     @classmethod
-    def from_seeds(cls, seeds: List[int], backend: str = "numpy:random_state"):
+    def from_seeds(cls, seeds: list[int], backend: str = "numpy:random_state"):
         if backend == "numpy:random_state":
             return cls(rngs=[np.random.RandomState(seed) for seed in seeds])
         raise ValueError(f"Unknown batched RNG backend: {backend}")
 
     @classmethod
-    def from_rngs(cls, rngs: List):
+    def from_rngs(cls, rngs: list):
         return cls(rngs=rngs)
 
-    def __getitem__(self, idx: Union[int, List[int], np.ndarray]):
+    def __getitem__(self, idx: Union[int, list[int], np.ndarray]):
         idx = common.to_numpy(idx)
         if np.iterable(idx):
             return BatchedRNG.from_rngs([self.rngs[i] for i in idx])
@@ -33,8 +33,8 @@ class BatchedRNG(np.random.RandomState):
 
     def __setitem__(
         self,
-        idx: Union[int, List[int], np.ndarray],
-        value: Union[np.random.RandomState, List[np.random.RandomState]],
+        idx: Union[int, list[int], np.ndarray],
+        value: Union[np.random.RandomState, list[np.random.RandomState]],
     ):
         idx = common.to_numpy(idx)
         if np.iterable(idx):

mani_skill/envs/utils/randomization/samplers.py

@@ -2,7 +2,7 @@
 Various sampling functions/classes for fast, vectorized sampling of e.g. object poses
 """
 
-from typing import List, Tuple
+from typing import Tuple
 
 import torch
 
@@ -21,7 +21,7 @@ class UniformPlacementSampler:
 
     def __init__(
         self,
-        bounds: Tuple[List[float], List[float]],
+        bounds: Tuple[list[float], list[float]],
         batch_size: int,
         device: Device = None,
     ) -> None:

mani_skill/examples/benchmarking/envs/maniskill/franka_move.py

@@ -65,7 +65,7 @@ class FrankaMoveBenchmarkEnv(BaseEnv):
             qpos = self.agent.keyframes["rest"].qpos
             qpos[0] = 0.5
             self.agent.robot.set_qpos(qpos)
-    def _load_lighting(self, options: Dict):
+    def _load_lighting(self, options: dict):
         self.scene.set_ambient_light(np.array([1,1,1])*0.1)
         for i in range(self.num_envs):
             self.scene.sub_scenes[i].set_environment_map(os.path.join(os.path.dirname(__file__), "kloofendal_28d_misty_puresky_1k.hdr"))
@@ -75,5 +75,5 @@ class FrankaMoveBenchmarkEnv(BaseEnv):
     def evaluate(self):
         return {}
 
-    def _get_obs_extra(self, info: Dict):
+    def _get_obs_extra(self, info: dict):
         return dict()

mani_skill/examples/benchmarking/envs/maniskill/franka_pick_cube.py

@@ -79,7 +79,7 @@ class FrankaPickCubeBenchmarkEnv(BaseEnv):
             qpos = self.agent.keyframes["rest"].qpos
             self.agent.robot.set_qpos(qpos)
             self.cube.set_pose(sapien.Pose(p=[0.6, 0, 0.02]))
-    def _load_lighting(self, options: Dict):
+    def _load_lighting(self, options: dict):
         # self.scene.set_ambient_light(np.array([1,1,1])*0.05)
         for i in range(self.num_envs):
             self.scene.sub_scenes[i].set_environment_map(os.path.join(os.path.dirname(__file__), "kloofendal_28d_misty_puresky_1k.hdr"))
@@ -89,5 +89,5 @@ class FrankaPickCubeBenchmarkEnv(BaseEnv):
     def evaluate(self):
         return {}
 
-    def _get_obs_extra(self, info: Dict):
+    def _get_obs_extra(self, info: dict):
         return dict()

mani_skill/examples/benchmarking/profiling.py

@@ -31,7 +31,7 @@ class Profiler:
         self.output_format = output_format
         self.synchronize_torch = synchronize_torch
         self.stats = dict()
-        
+
         # Initialize NVML
         self._gpu_handle = None
         try:
@@ -133,7 +133,7 @@ class Profiler:
                     return memory_usage
         return None
 def images_to_video(
-    images: List[np.ndarray],
+    images: list[np.ndarray],
     output_dir: str,
     video_name: str,
     fps: int = 10,

mani_skill/examples/demo_random_action.py

@@ -52,7 +52,7 @@ class Args:
     quiet: bool = False
     """Disable verbose output."""
 
-    seed: Annotated[Optional[Union[int, List[int]]], tyro.conf.arg(aliases=["-s"])] = None
+    seed: Annotated[Optional[Union[int, list[int]]], tyro.conf.arg(aliases=["-s"])] = None
     """Seed(s) for random actions and simulator. Can be a single integer or a list of integers. Default is None (no seeds)"""
 
 def main(args: Args):

mani_skill/render/shaders.py

@@ -1,5 +1,5 @@
 from dataclasses import dataclass, field
-from typing import Any, Callable, Dict, List
+from typing import Any, Callable
 
 import sapien
 import torch
@@ -26,13 +26,13 @@ class ShaderConfig:
     """
 
     shader_pack: str
-    texture_names: Dict[str, List[str]] = field(default_factory=dict)
+    texture_names: dict[str, list[str]] = field(default_factory=dict)
     """dictionary mapping shader texture names to the image modalities that are rendered. e.g. Color, Depth, Segmentation, etc."""
-    shader_pack_config: Dict[str, Any] = field(default_factory=dict)
+    shader_pack_config: dict[str, Any] = field(default_factory=dict)
     """configs for the shader pack. for e.g. the ray tracing shader you can configure the denoiser, samples per pixel, etc."""
 
-    texture_transforms: Dict[
-        str, Callable[[torch.Tensor], Dict[str, torch.Tensor]]
+    texture_transforms: dict[
+        str, Callable[[torch.Tensor], dict[str, torch.Tensor]]
     ] = field(default_factory=dict)
     """texture transform functions that map each texture name to a function that converts the texture data into one or more standard image modalities. The return type should be a
     dictionary with keys equal to the names of standard image modalities and values equal to the transformed data"""

mani_skill/sensors/base_sensor.py

@@ -1,5 +1,4 @@
 from dataclasses import dataclass
-from typing import Dict
 
 import torch
 
@@ -36,7 +35,7 @@ class BaseSensor:
         """
         raise NotImplementedError()
 
-    def get_params(self) -> Dict:
+    def get_params(self) -> dict:
         """
         Get parameters for this sensor. Should return a dictionary with keys mapping to torch.Tensor values
         """

mani_skill/sensors/camera.py

@@ -2,7 +2,7 @@ from __future__ import annotations
 
 import copy
 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
@@ -68,7 +68,7 @@ class CameraConfig(BaseSensorConfig):
 
 
 def update_camera_configs_from_dict(
-    camera_configs: Dict[str, CameraConfig], config_dict: Dict[str, dict]
+    camera_configs: dict[str, CameraConfig], config_dict: dict[str, dict]
 ):
     # Update CameraConfig to StereoDepthCameraConfig
     if config_dict.pop("use_stereo_depth", False):
@@ -264,8 +264,8 @@ def normalize_depth(depth, min_depth=0, max_depth=None):
 
 
 def camera_observations_to_images(
-    observations: Dict[str, torch.Tensor], max_depth=None
-) -> List[Array]:
+    observations: dict[str, torch.Tensor], max_depth=None
+) -> list[Array]:
     """Parse images from camera observations."""
     images = dict()
     for key in observations: