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

mani_skill/envs/tasks/control/humanoid.py

@@ -1,6 +1,6 @@
 """Adapted from https://github.com/google-deepmind/dm_control/blob/main/dm_control/suite/humanoid.py"""
 
-from typing import Any, Dict, Union
+from typing import Any, Union
 
 import numpy as np
 import sapien
@@ -118,7 +118,7 @@ class HumanoidEnvBase(BaseEnv):
         return com_vel
 
     # cache re-used computation
-    def evaluate(self) -> Dict:
+    def evaluate(self) -> dict:
         return dict(
             torso_xmat=self.agent.robot.links_map[
                 "torso"
@@ -186,7 +186,7 @@ class HumanoidEnvBase(BaseEnv):
             margin=_STAND_HEIGHT / 4,
         ).view(-1)
 
-    def upright_rew(self, info: Dict):
+    def upright_rew(self, info: dict):
         return rewards.tolerance(
             self.torso_upright(info),
             lower=0.9,
@@ -205,7 +205,7 @@ class HumanoidEnvStandard(HumanoidEnvBase):
     def __init__(self, *args, robot_uids="humanoid", **kwargs):
         super().__init__(*args, robot_uids=robot_uids, **kwargs)
 
-    def _get_obs_state_dict(self, info: Dict):
+    def _get_obs_state_dict(self, info: dict):
         # our qpos model doesn't include the free joint, meaning qpos and qvel are 21 dims, not 27
         # global dpos/dt and root (torso) dquaterion/dt are lost as result
         # we replace them with linear root linvel and root angularvel (equivalent info)
@@ -232,7 +232,7 @@ class HumanoidEnvStandard(HumanoidEnvBase):
 
     # standard humanoid env resets if torso is below a certain point
     # therefore, we disable all contacts except feet and floor
-    def _load_scene(self, options: Dict):
+    def _load_scene(self, options: dict):
         super()._load_scene(options)
         self.ground.set_collision_group_bit(group=2, bit_idx=30, bit=1)
 
@@ -240,7 +240,7 @@ class HumanoidEnvStandard(HumanoidEnvBase):
             if not "foot" in link.name:
                 link.set_collision_group_bit(group=2, bit_idx=30, bit=1)
 
-    def _initialize_episode(self, env_idx: torch.Tensor, options: Dict):
+    def _initialize_episode(self, env_idx: torch.Tensor, options: dict):
         with torch.device(self.device):
             b = len(env_idx)
             # set agent root pose - torso now centered at dummy root at (0,0,0)
@@ -260,7 +260,7 @@ class HumanoidEnvStandard(HumanoidEnvBase):
             self.agent.robot.set_qvel(qvel_noise)
 
     # in standard (non-hard) version, we terminate early if the torso is in unacceptable range
-    def evaluate(self) -> Dict:
+    def evaluate(self) -> dict:
         info = super().evaluate()
         torso_z = self.agent.robot.links_map["torso"].pose.p[:, -1]
         failure = torch.logical_or(torso_z < 0.7, torso_z > 2.0)
@@ -300,7 +300,7 @@ class HumanoidStand(HumanoidEnvStandard):
     def __init__(self, *args, robot_uids="humanoid", **kwargs):
         super().__init__(*args, robot_uids=robot_uids, **kwargs)
 
-    def _get_obs_state_dict(self, info: Dict):
+    def _get_obs_state_dict(self, info: dict):
         # make all obs completely egocentric, for z rotation invariance, since stand has z rot randomization
         root_pose_mat = self.agent.robot.links_map[
             "dummy_root_0"
@@ -325,7 +325,7 @@ class HumanoidStand(HumanoidEnvStandard):
         )
 
     # in stand, we also randomize the agent rotation around z axis
-    def _initialize_episode(self, env_idx: torch.Tensor, options: Dict):
+    def _initialize_episode(self, env_idx: torch.Tensor, options: dict):
         super()._initialize_episode(env_idx=env_idx, options=options)
         with torch.device(self.device):
             b = len(env_idx)
@@ -338,7 +338,7 @@ class HumanoidStand(HumanoidEnvStandard):
             self.agent.robot.set_root_pose(pose)
 
     def compute_normalized_dense_reward(
-        self, obs: Any, action: torch.Tensor, info: Dict
+        self, obs: Any, action: torch.Tensor, info: dict
     ):
         small_control = (4 + self.control_rew(action)) / 5
         stand_rew = (
@@ -370,7 +370,7 @@ class HumanoidWalk(HumanoidEnvStandard):
         super().__init__(*args, robot_uids=robot_uids, **kwargs)
 
     def compute_normalized_dense_reward(
-        self, obs: Any, action: torch.Tensor, info: Dict
+        self, obs: Any, action: torch.Tensor, info: dict
     ):
         small_control = (4 + self.control_rew(action)) / 5
         walk_rew = (
@@ -402,7 +402,7 @@ class HumanoidRun(HumanoidEnvStandard):
         super().__init__(*args, robot_uids=robot_uids, **kwargs)
 
     def compute_normalized_dense_reward(
-        self, obs: Any, action: torch.Tensor, info: Dict
+        self, obs: Any, action: torch.Tensor, info: dict
     ):
         # reward function used by mjx for ppo humanoid run
         rew_scale = 0.1
@@ -421,7 +421,7 @@ class HumanoidRun(HumanoidEnvStandard):
 #     def __init__(self, *args, robot_uids="humanoid", **kwargs):
 #         super().__init__(*args, robot_uids=robot_uids, **kwargs)
 
-#     def _get_obs_state_dict(self, info: Dict):
+#     def _get_obs_state_dict(self, info: dict):
 #         # our qpos model doesn't include the free joint, meaning qpos and qvel are 21 dims, not 27
 #         # global dpos/dt and root (torso) dquaterion/dt lost
 #         # we replace with linear root linvel and root angularvel (equivalent info)
@@ -439,7 +439,7 @@ class HumanoidRun(HumanoidEnvStandard):
 #             ].get_angular_velocity(),  # free joint info, (b, 3)
 #         )
 
-#     def _initialize_episode(self, env_idx: torch.Tensor, options: Dict):
+#     def _initialize_episode(self, env_idx: torch.Tensor, options: dict):
 #         self.camera_mount.set_pose(
 #             Pose.create_from_pq(p=self.agent.robot.links_map["torso"].pose.p)
 #         )
@@ -465,7 +465,7 @@ class HumanoidRun(HumanoidEnvStandard):
 #     def __init__(self, *args, robot_uids="humanoid", **kwargs):
 #         super().__init__(*args, robot_uids=robot_uids, **kwargs)
 
-#     def compute_dense_reward(self, obs: Any, action: torch.Tensor, info: Dict):
+#     def compute_dense_reward(self, obs: Any, action: torch.Tensor, info: dict):
 #         small_control = (4 + self.control_rew(action)) / 5
 #         return (
 #             small_control
@@ -475,7 +475,7 @@ class HumanoidRun(HumanoidEnvStandard):
 #         )
 
 #     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, action, info)
 
@@ -487,7 +487,7 @@ class HumanoidRun(HumanoidEnvStandard):
 #     def __init__(self, *args, robot_uids="humanoid", **kwargs):
 #         super().__init__(*args, robot_uids=robot_uids, **kwargs)
 
-#     def compute_dense_reward(self, obs: Any, action: torch.Tensor, info: Dict):
+#     def compute_dense_reward(self, obs: Any, action: torch.Tensor, info: dict):
 #         small_control = (4 + self.control_rew(action)) / 5
 #         return (
 #             small_control
@@ -497,7 +497,7 @@ class HumanoidRun(HumanoidEnvStandard):
 #         )
 
 #     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, action, info)
 
@@ -509,7 +509,7 @@ class HumanoidRun(HumanoidEnvStandard):
 #     def __init__(self, *args, robot_uids="humanoid", **kwargs):
 #         super().__init__(*args, robot_uids=robot_uids, **kwargs)
 
-#     def compute_dense_reward(self, obs: Any, action: torch.Tensor, info: Dict):
+#     def compute_dense_reward(self, obs: Any, action: torch.Tensor, info: dict):
 #         small_control = (4 + self.control_rew(action)) / 5
 #         return (
 #             small_control
@@ -519,6 +519,6 @@ class HumanoidRun(HumanoidEnvStandard):
 #         )
 
 #     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, action, info)

mani_skill/envs/tasks/dexterity/insert_flower.py

@@ -1,9 +1,10 @@
+import os
+from typing import Any, Union
 
-from typing import Any, Dict, Union
 import numpy as np
 import sapien.physx as physx
 import torch
-import os 
+
 from mani_skill import ASSET_DIR
 from mani_skill.agents.robots import FloatingInspireHandRight
 from mani_skill.envs.sapien_env import BaseEnv
@@ -16,9 +17,7 @@ from mani_skill.utils.structs.types import Array, GPUMemoryConfig, SimConfig
 
 
 @register_env(
-    "InsertFlower-v1",
-    max_episode_steps=300,
-    asset_download_ids=["oakink-v2"]
+    "InsertFlower-v1", max_episode_steps=300, asset_download_ids=["oakink-v2"]
 )
 class InsertFlowerEnv(BaseEnv):
     agent: Union[FloatingInspireHandRight]
@@ -63,7 +62,9 @@ class InsertFlowerEnv(BaseEnv):
 
     @property
     def _default_sensor_configs(self):
-        pose = sapien_utils.look_at(eye=[0.15, 0, 0.45], target=[-0.1, 0, self.hand_init_height])
+        pose = sapien_utils.look_at(
+            eye=[0.15, 0, 0.45], target=[-0.1, 0, self.hand_init_height]
+        )
         return [CameraConfig("base_camera", pose, 128, 128, np.pi / 2, 0.01, 100)]
 
     @property
@@ -72,12 +73,16 @@ class InsertFlowerEnv(BaseEnv):
         return CameraConfig("render_camera", pose, 512, 512, 1, 0.01, 100)
 
     def _load_scene(self, options: dict):
-        self.table_scene = TableSceneBuilder(env=self, robot_init_qpos_noise=self.robot_init_qpos_noise)
+        self.table_scene = TableSceneBuilder(
+            env=self, robot_init_qpos_noise=self.robot_init_qpos_noise
+        )
         self.table_scene.build()
 
         # === Load Vase (Static) ===
         vase_builder = self.scene.create_actor_builder()
-        vase_visual_mesh_file = os.path.join(self.asset_path, "O02@0080@00001/model.obj")
+        vase_visual_mesh_file = os.path.join(
+            self.asset_path, "O02@0080@00001/model.obj"
+        )
         vase_collision_mesh_file = os.path.join(
             self.asset_path, "O02@0080@00001/model.obj.coacd.ply"
         )
@@ -97,7 +102,9 @@ class InsertFlowerEnv(BaseEnv):
         )
         flower_builder.add_visual_from_file(flower_mesh_file)
 
-        flower_material = physx.PhysxMaterial(static_friction=1, dynamic_friction=1, restitution=1)
+        flower_material = physx.PhysxMaterial(
+            static_friction=1, dynamic_friction=1, restitution=1
+        )
         flower_builder.add_multiple_convex_collisions_from_file(
             flower_collision_file, density=200, material=flower_material
         )
@@ -109,7 +116,9 @@ class InsertFlowerEnv(BaseEnv):
         self.flower = flower_builder.build(name="flower")
         self.target_area_box = list(self.target_area.values())
         # Convert target_area into tensor for fast computation
-        self.target_area_box = torch.tensor(self.target_area_box, device=self.device, dtype=torch.float32).view(2, 3)
+        self.target_area_box = torch.tensor(
+            self.target_area_box, device=self.device, dtype=torch.float32
+        ).view(2, 3)
 
     def _after_reconfigure(self, options: dict):
         pass
@@ -125,7 +134,10 @@ class InsertFlowerEnv(BaseEnv):
             self.table_scene.initialize(env_idx)
 
             flower_pose = self.init_flower_pose
-            flower_pose.p[:, :2] += torch.rand((b, 2)) * self.flower_spawn_half_size * 2 - self.flower_spawn_half_size
+            flower_pose.p[:, :2] += (
+                torch.rand((b, 2)) * self.flower_spawn_half_size * 2
+                - self.flower_spawn_half_size
+            )
             self.flower.set_pose(flower_pose)
 
     def _initialize_agent(self, env_idx: torch.Tensor):
@@ -139,16 +151,18 @@ class InsertFlowerEnv(BaseEnv):
             self.agent.robot.set_pose(
                 Pose.create_from_pq(
                     torch.tensor([0.0, 0, self.hand_init_height]),
-                    torch.tensor([
-                        0,
-                        0.707,
-                        0,
-                        -0.707,
-                    ]),
+                    torch.tensor(
+                        [
+                            0,
+                            0.707,
+                            0,
+                            -0.707,
+                        ]
+                    ),
                 )
             )
 
-    def _get_obs_extra(self, info: Dict):
+    def _get_obs_extra(self, info: dict):
         return {}
 
     def evaluate(self, **kwargs) -> dict:
@@ -162,19 +176,23 @@ class InsertFlowerEnv(BaseEnv):
 
         return {"success": is_within}
 
-    def compute_dense_reward(self, obs: Any, action: Array, info: Dict) -> float:
+    def compute_dense_reward(self, obs: Any, action: Array, info: dict) -> float:
         object_pos = self.flower.pose.p
         dist_outside = torch.max(
-            torch.max(self.target_area_box[0] - object_pos, torch.zeros_like(object_pos)),  # lower bound
-            torch.max(object_pos - self.target_area_box[1], torch.zeros_like(object_pos)),  # upper bound
+            torch.max(
+                self.target_area_box[0] - object_pos, torch.zeros_like(object_pos)
+            ),  # lower bound
+            torch.max(
+                object_pos - self.target_area_box[1], torch.zeros_like(object_pos)
+            ),  # upper bound
         )
         reward = torch.exp(-5 * torch.norm(dist_outside)).reshape(-1)
 
         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):
         return self.compute_dense_reward(obs=obs, action=action, info=info) / 4.0
 
 
 if __name__ == "__main__":
-    print(InsertFlowerEnv.asset_path)
+    print(InsertFlowerEnv.asset_path)

mani_skill/envs/tasks/dexterity/rotate_single_object_in_hand.py

@@ -1,4 +1,4 @@
-from typing import Any, Dict, List, Union
+from typing import Any, Union
 
 import numpy as np
 import sapien
@@ -106,7 +106,7 @@ class RotateSingleObjectInHand(BaseEnv):
             obj_heights.append(0.03)
         elif self.difficulty_level == 1:
             half_sizes = (self._batched_episode_rng.randn() * 0.1 + 1) * 0.04
-            self._objs: List[Actor] = []
+            self._objs: list[Actor] = []
             for i, half_size in enumerate(half_sizes):
                 builder = self.scene.create_actor_builder()
                 builder.add_box_collision(
@@ -131,7 +131,7 @@ class RotateSingleObjectInHand(BaseEnv):
                 )
             )
             model_ids = self._batched_episode_rng.choice(all_model_ids)
-            self._objs: List[Actor] = []
+            self._objs: list[Actor] = []
             for i, model_id in enumerate(model_ids):
                 builder = actors.get_actor_builder(self.scene, id=f"ycb:{model_id}")
                 builder.set_scene_idxs([i])
@@ -216,7 +216,7 @@ class RotateSingleObjectInHand(BaseEnv):
                 )
             )
 
-    def _get_obs_extra(self, info: Dict):
+    def _get_obs_extra(self, info: dict):
         with torch.device(self.device):
             obs = dict(rotate_dir=self.rot_dir)
             if self.obs_mode_struct.use_state:
@@ -283,7 +283,7 @@ class RotateSingleObjectInHand(BaseEnv):
             fail=obj_fall,
         )
 
-    def compute_dense_reward(self, obs: Any, action: Array, info: Dict):
+    def compute_dense_reward(self, obs: Any, action: Array, info: dict):
         # 1. rotation reward
         angle = info["rotation_angle"]
         reward = 20 * angle
@@ -312,7 +312,7 @@ class RotateSingleObjectInHand(BaseEnv):
 
         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
         return self.compute_dense_reward(obs=obs, action=action, info=info) / 4.0
 

mani_skill/envs/tasks/dexterity/rotate_valve.py

@@ -1,4 +1,4 @@
-from typing import Any, Dict, List, Union
+from typing import Any, Union
 
 import numpy as np
 import torch
@@ -107,7 +107,7 @@ class RotateValveEnv(BaseEnv):
                 f"Difficulty level must be a int within 0-4, but get {self.difficulty_level}"
             )
 
-        valves: List[Articulation] = []
+        valves: list[Articulation] = []
         capsule_lens = []
         valve_links = []
         for i, valve_angles in enumerate(valve_angles_list):
@@ -183,7 +183,7 @@ class RotateValveEnv(BaseEnv):
                 )
             )
 
-    def _get_obs_extra(self, info: Dict):
+    def _get_obs_extra(self, info: dict):
         with torch.device(self.device):
             valve_qpos = self.valve.qpos
             valve_qvel = self.valve.qvel
@@ -205,7 +205,7 @@ class RotateValveEnv(BaseEnv):
         success = valve_rotation * self.rotate_direction > self.success_threshold
         return dict(success=success, valve_rotation=valve_rotation)
 
-    def compute_dense_reward(self, obs: Any, action: Array, info: Dict):
+    def compute_dense_reward(self, obs: Any, action: Array, info: dict):
         rotation = info["valve_rotation"]
         qvel = self.valve.qvel
 
@@ -226,7 +226,7 @@ class RotateValveEnv(BaseEnv):
 
         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
         return self.compute_dense_reward(obs=obs, action=action, info=info) / 6.0
 

mani_skill/envs/tasks/digital_twins/base_env.py

@@ -1,5 +1,5 @@
 import os
-from typing import Dict, List, Union
+from typing import Union
 
 import cv2
 import torch
@@ -39,15 +39,15 @@ class BaseDigitalTwinEnv(BaseEnv):
     Use `self.remove_object_from_greenscreen(object: Actor | Link | Articulation)` to exclude those objects from the greenscreen process.
     """
 
-    rgb_overlay_paths: Dict[str, str] = None
+    rgb_overlay_paths: dict[str, str] = None
     """dict mapping camera name to the file path of the greenscreening image"""
-    _rgb_overlay_images: Dict[str, torch.Tensor] = dict()
+    _rgb_overlay_images: dict[str, torch.Tensor] = dict()
     """dict mapping camera name to the image torch tensor"""
     rgb_overlay_mode: str = "background"
     """which RGB overlay mode to use during the greenscreen process. The default is 'background' which enables greenscreening like normal. The other option is 'debug' mode which
     will make the opacity of the original render and greenscreen overlay both 50%. The third option is "none" which will not perform any greenscreening."""
 
-    _objects_to_remove_from_greenscreen: List[Union[Actor, Link]] = []
+    _objects_to_remove_from_greenscreen: list[Union[Actor, Link]] = []
     """list of articulations/actors/links that should be removed from the greenscreen process"""
     _segmentation_ids_to_keep: torch.Tensor = None
     """torch tensor of segmentation ids that reference the objects that should not be greenscreened"""

mani_skill/envs/tasks/digital_twins/bridge_dataset_eval/base_env.py

@@ -2,7 +2,7 @@
 Base environment for Bridge dataset environments
 """
 import os
-from typing import Dict, List, Literal
+from typing import Literal
 
 import numpy as np
 import sapien
@@ -158,7 +158,7 @@ class BaseBridgeEnv(BaseDigitalTwinEnv):
     SUPPORTED_OBS_MODES = ["rgb+segmentation"]
     SUPPORTED_REWARD_MODES = ["none"]
     scene_setting: Literal["flat_table", "sink"] = "flat_table"
-    objects_excluded_from_greenscreening: List[str] = []
+    objects_excluded_from_greenscreening: list[str] = []
     """object ids that should not be greenscreened"""
 
     obj_static_friction = 0.5
@@ -166,12 +166,12 @@ class BaseBridgeEnv(BaseDigitalTwinEnv):
 
     def __init__(
         self,
-        obj_names: List[str],
+        obj_names: list[str],
         xyz_configs: torch.Tensor,
         quat_configs: torch.Tensor,
         **kwargs,
     ):
-        self.objs: Dict[str, Actor] = dict()
+        self.objs: dict[str, Actor] = dict()
         self.obj_names = obj_names
         self.source_obj_name = obj_names[0]
         self.target_obj_name = obj_names[1]
@@ -192,13 +192,13 @@ class BaseBridgeEnv(BaseDigitalTwinEnv):
             }
             robot_cls = WidowX250SBridgeDatasetSink
 
-        self.model_db: Dict[str, Dict] = io_utils.load_json(
+        self.model_db: dict[str, dict] = io_utils.load_json(
             BRIDGE_DATASET_ASSET_PATH / "custom/" / self.MODEL_JSON
         )
-        
+
         self.consecutive_grasp = None
         self.episode_stats = None
-        
+
         super().__init__(
             robot_uids=robot_cls,
             **kwargs,
@@ -459,13 +459,23 @@ class BaseBridgeEnv(BaseDigitalTwinEnv):
             """target object bbox size (3, )"""
 
             if self.consecutive_grasp is None:
-                self.consecutive_grasp = torch.zeros(self.num_envs, dtype=torch.int32).to(self.device)
+                self.consecutive_grasp = torch.zeros(
+                    self.num_envs, dtype=torch.int32
+                ).to(self.device)
             if self.episode_stats is None:
                 self.episode_stats = dict(
-                    moved_correct_obj=torch.zeros((self.num_envs,), dtype=torch.bool).to(self.device),
-                    moved_wrong_obj=torch.zeros((self.num_envs,), dtype=torch.bool).to(self.device),
-                    is_src_obj_grasped=torch.zeros((self.num_envs,), dtype=torch.bool).to(self.device),
-                    consecutive_grasp=torch.zeros((self.num_envs,), dtype=torch.bool).to(self.device),
+                    moved_correct_obj=torch.zeros(
+                        (self.num_envs,), dtype=torch.bool
+                    ).to(self.device),
+                    moved_wrong_obj=torch.zeros((self.num_envs,), dtype=torch.bool).to(
+                        self.device
+                    ),
+                    is_src_obj_grasped=torch.zeros(
+                        (self.num_envs,), dtype=torch.bool
+                    ).to(self.device),
+                    consecutive_grasp=torch.zeros(
+                        (self.num_envs,), dtype=torch.bool
+                    ).to(self.device),
                 )
             # stats to track
             self.consecutive_grasp[env_idx] = 0

mani_skill/envs/tasks/digital_twins/so100_arm/grasp_cube.py

@@ -1,5 +1,5 @@
 from dataclasses import asdict, dataclass
-from typing import Any, Dict, Optional, Sequence, Union
+from typing import Any, Optional, Sequence, Union
 
 import dacite
 import numpy as np
@@ -394,7 +394,7 @@ class SO100GraspCubeEnv(BaseDigitalTwinEnv):
             obs.update(controller=controller_state)
         return obs
 
-    def _get_obs_extra(self, info: Dict):
+    def _get_obs_extra(self, info: dict):
         # we ensure that the observation data is always retrievable in the real world, using only real world
         # available data (joint positions or the controllers target joint positions in this case).
         obs = dict(
@@ -453,7 +453,7 @@ class SO100GraspCubeEnv(BaseDigitalTwinEnv):
             "success": success,
         }
 
-    def compute_dense_reward(self, obs: Any, action: torch.Tensor, info: Dict):
+    def compute_dense_reward(self, obs: Any, action: torch.Tensor, info: dict):
         # note the info object is the data returned by the evaluate function. We can reuse information
         # to save compute time.
         # this reward function essentially has two stages, before and after grasping.
@@ -473,7 +473,7 @@ class SO100GraspCubeEnv(BaseDigitalTwinEnv):
         return reward
 
     def compute_normalized_dense_reward(
-        self, obs: Any, action: torch.Tensor, info: Dict
+        self, obs: Any, action: torch.Tensor, info: dict
     ):
         # for more stable RL we often also permit defining a noramlized reward function where you manually scale the reward down by its max value like so
         return self.compute_dense_reward(obs=obs, action=action, info=info) / 3

mani_skill/envs/tasks/drawing/draw.py

@@ -1,5 +1,3 @@
-from typing import Dict
-
 import numpy as np
 import sapien
 import torch
@@ -196,7 +194,7 @@ class TableTopFreeDrawEnv(BaseEnv):
     def evaluate(self):
         return {}
 
-    def _get_obs_extra(self, info: Dict):
+    def _get_obs_extra(self, info: dict):
         return dict(
             tcp_pose=self.agent.tcp.pose.raw_pose,
         )

mani_skill/envs/tasks/drawing/draw_svg.py

@@ -1,9 +1,9 @@
-from typing import Dict
-
-import mani_skill.envs.utils.randomization as randomization
 import numpy as np
 import sapien
 import torch
+from transforms3d.euler import euler2quat
+
+import mani_skill.envs.utils.randomization as randomization
 from mani_skill.agents.robots.panda.panda_stick import PandaStick
 from mani_skill.envs.sapien_env import BaseEnv
 from mani_skill.sensors.camera import CameraConfig
@@ -14,7 +14,6 @@ from mani_skill.utils.scene_builder.table.scene_builder import TableSceneBuilder
 from mani_skill.utils.structs.actor import Actor
 from mani_skill.utils.structs.pose import Pose
 from mani_skill.utils.structs.types import SceneConfig, SimConfig
-from transforms3d.euler import euler2quat
 
 
 @register_env("DrawSVG-v1", max_episode_steps=500)
@@ -22,18 +21,17 @@ class DrawSVGEnv(BaseEnv):
     r"""
     **Task Description:**
     Instantiates a table with a white canvas on it and a svg path specified with an outline. A robot with a stick is to draw the triangle with a red line.
-    
+
     **Randomizations:**
     - the goal svg's position on the xy-plane is randomized
     - the goal svg's z-rotation is randomized in range [0, 2 $\pi$]
-    
+
     **Success Conditions:**
     - the drawn points by the robot are within a euclidean distance of 0.05m with points on the goal svg
     """
 
     _sample_video_link = "https://github.com/haosulab/ManiSkill/raw/main/figures/environment_demos/DrawSVG-v1_rt.mp4"
 
-
     MAX_DOTS = 1000
     """
     The total "ink" available to use and draw with before you need to call env.reset. NOTE that on GPU simulation it is not recommended to have a very high value for this as it can slow down rendering
@@ -340,7 +338,7 @@ class DrawSVGEnv(BaseEnv):
         out = self.success_check()
         return {"success": out}
 
-    def _get_obs_extra(self, info: Dict):
+    def _get_obs_extra(self, info: dict):
         obs = dict(
             tcp_pose=self.agent.tcp.pose.raw_pose,
         )

mani_skill/envs/tasks/drawing/draw_triangle.py

@@ -1,5 +1,4 @@
 import math
-from typing import Dict
 
 import numpy as np
 import sapien
@@ -309,7 +308,7 @@ class DrawTriangleEnv(BaseEnv):
         out = self.success_check()
         return {"success": out}
 
-    def _get_obs_extra(self, info: Dict):
+    def _get_obs_extra(self, info: dict):
         obs = dict(
             tcp_pose=self.agent.tcp.pose.raw_pose,
         )

mani_skill/envs/tasks/empty_env.py

@@ -1,5 +1,3 @@
-from typing import Dict
-
 import numpy as np
 import sapien
 import torch
@@ -47,5 +45,5 @@ class EmptyEnv(BaseEnv):
     def evaluate(self):
         return {}
 
-    def _get_obs_extra(self, info: Dict):
+    def _get_obs_extra(self, info: dict):
         return dict()

mani_skill/envs/tasks/fmb/fmb.py

@@ -1,5 +1,4 @@
 import os.path as osp
-from typing import Dict
 
 import numpy as np
 import sapien
@@ -178,7 +177,7 @@ class FMBAssembly1Env(BaseEnv):
         )
         return {"success": bridge_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)
         if self.obs_mode_struct.use_state:
             obs.update(