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

mani_skill/envs/tasks/humanoid/humanoid_pick_place.py

@@ -1,6 +1,6 @@
 import copy
 import os
-from typing import Any, Dict
+from typing import Any
 
 import numpy as np
 import sapien
@@ -65,7 +65,7 @@ class HumanoidPickPlaceEnv(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()
 
 
@@ -100,7 +100,7 @@ class HumanoidPlaceAppleInBowl(HumanoidPickPlaceEnv):
             100,
         )
 
-    def _load_scene(self, options: Dict):
+    def _load_scene(self, options: dict):
         super()._load_scene(options)
         scale = self.kitchen_scene_scale
         builder = self.scene.create_actor_builder()
@@ -149,7 +149,7 @@ class HumanoidPlaceAppleInBowl(HumanoidPickPlaceEnv):
             "is_grasped": is_grasped,
         }
 
-    def _get_obs_extra(self, info: Dict):
+    def _get_obs_extra(self, info: dict):
         # in reality some people hack is_grasped into observations by checking if the gripper can close fully or not
         obs = dict(
             is_grasped=info["is_grasped"],
@@ -168,7 +168,7 @@ class HumanoidPlaceAppleInBowl(HumanoidPickPlaceEnv):
         """a dense reward that rewards the agent for opening their hand"""
         return 1 - torch.tanh(self.agent.right_hand_dist_to_open_grasp())
 
-    def compute_dense_reward(self, obs: Any, action: torch.Tensor, info: Dict):
+    def compute_dense_reward(self, obs: Any, action: torch.Tensor, info: dict):
         tcp_to_obj_dist = torch.linalg.norm(
             self.apple.pose.p - self.agent.right_tcp.pose.p, axis=1
         )
@@ -201,7 +201,7 @@ class HumanoidPlaceAppleInBowl(HumanoidPickPlaceEnv):
         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
 
@@ -254,7 +254,7 @@ class UnitreeG1PlaceAppleInBowlEnv(HumanoidPlaceAppleInBowl):
             scene_config=SceneConfig(contact_offset=0.01),
         )
 
-    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, options)
         with torch.device(self.device):
             b = len(env_idx)

mani_skill/envs/tasks/humanoid/humanoid_stand.py

@@ -1,4 +1,4 @@
-from typing import Any, Dict, Union
+from typing import Any, Union
 
 import numpy as np
 import sapien
@@ -46,17 +46,17 @@ class HumanoidStandEnv(BaseEnv):
         self.agent.is_fallen()
         return {"is_standing": is_standing, "fail": ~is_standing}
 
-    def _get_obs_extra(self, info: Dict):
+    def _get_obs_extra(self, info: dict):
         return dict()
 
-    def compute_sparse_reward(self, obs: Any, action: torch.Tensor, info: Dict):
+    def compute_sparse_reward(self, obs: Any, action: torch.Tensor, info: dict):
         return info["is_standing"]
 
-    # 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

mani_skill/envs/tasks/humanoid/transport_box.py

@@ -1,7 +1,7 @@
 import copy
 import os
 from pathlib import Path
-from typing import Any, Dict
+from typing import Any
 
 import numpy as np
 import sapien
@@ -226,7 +226,7 @@ class TransportBoxEnv(BaseEnv):
             "facing_table_with_box": facing_table_with_box,
         }
 
-    def _get_obs_extra(self, info: Dict):
+    def _get_obs_extra(self, info: dict):
         obs = dict(
             right_tcp_pose=self.agent.right_tcp.pose.raw_pose,
             left_tcp_pose=self.agent.left_tcp.pose.raw_pose,
@@ -252,7 +252,7 @@ class TransportBoxEnv(BaseEnv):
             torch.tensor([0.165, 0.07, 0.05], device=self.device)
         )
 
-    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, move to face the box on the table. Succeeds if facing_table_with_box
         reward = 1 - torch.tanh((self.agent.robot.qpos[:, 0] + 1.4).abs())
 
@@ -306,6 +306,6 @@ class TransportBoxEnv(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, action, info) / 5

mani_skill/envs/tasks/mobile_manipulation/open_cabinet_drawer.py

@@ -1,4 +1,4 @@
-from typing import Any, Dict, List, Optional, Union
+from typing import Any, Optional, Union
 
 import numpy as np
 import sapien
@@ -125,15 +125,15 @@ class OpenCabinetDrawerEnv(BaseEnv):
             group=2, bit_idx=CABINET_COLLISION_BIT, bit=1
         )
 
-    def _load_cabinets(self, joint_types: List[str]):
+    def _load_cabinets(self, joint_types: list[str]):
         # we sample random cabinet model_ids with numpy as numpy is always deterministic based on seed, regardless of
         # GPU/CPU simulation backends. This is useful for replaying demonstrations.
         model_ids = self._batched_episode_rng.choice(self.all_model_ids)
         link_ids = self._batched_episode_rng.randint(0, 2**31)
 
-        self._cabinets: List[Articulation] = []
-        handle_links: List[List[Link]] = []
-        handle_links_meshes: List[List[trimesh.Trimesh]] = []
+        self._cabinets: list[Articulation] = []
+        handle_links: list[list[Link]] = []
+        handle_links_meshes: list[list[trimesh.Trimesh]] = []
         for i, model_id in enumerate(model_ids):
             # partnet-mobility is a dataset source and the ids are the ones we sampled
             # we provide tools to easily create the articulation builder like so by querying
@@ -320,7 +320,7 @@ class OpenCabinetDrawerEnv(BaseEnv):
             "open_enough": open_enough,
         }
 
-    def _get_obs_extra(self, info: Dict):
+    def _get_obs_extra(self, info: dict):
         obs = dict(
             tcp_pose=self.agent.tcp.pose.raw_pose,
         )
@@ -333,7 +333,7 @@ class OpenCabinetDrawerEnv(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):
         tcp_to_handle_dist = torch.linalg.norm(
             self.agent.tcp.pose.p - info["handle_link_pos"], axis=1
         )
@@ -352,7 +352,7 @@ class OpenCabinetDrawerEnv(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 = 5.0
         return self.compute_dense_reward(obs=obs, action=action, info=info) / max_reward

mani_skill/envs/tasks/mobile_manipulation/robocasa/kitchen.py

@@ -1,5 +1,4 @@
 from copy import deepcopy
-from typing import Dict
 
 import numpy as np
 import sapien
@@ -55,7 +54,7 @@ class RoboCasaKitchenEnv(BaseEnv):
             overrides the default gripper. Should either be single str if same gripper type is to be used for all
             robots or else it should be a list of the same length as "robots" param
 
-        initialization_noise (dict or list of dict): Dict containing the initialization noise parameters.
+        initialization_noise (dict or list of dict): dict containing the initialization noise parameters.
             The expected keys and corresponding value types are specified below:
 
             :`'magnitude'`: The scale factor of uni-variate random noise applied to each of a robot's given initial
@@ -456,7 +455,7 @@ class RoboCasaKitchenEnv(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/quadruped/quadruped_reach.py

@@ -1,4 +1,4 @@
-from typing import Any, Dict, List
+from typing import Any
 
 import numpy as np
 import sapien
@@ -21,7 +21,7 @@ class QuadrupedReachEnv(BaseEnv):
     agent: ANYmalC
     default_qpos: torch.Tensor
 
-    _UNDESIRED_CONTACT_LINK_NAMES: List[str] = None
+    _UNDESIRED_CONTACT_LINK_NAMES: list[str] = None
 
     def __init__(self, *args, robot_uids="anymal-c", **kwargs):
         super().__init__(*args, robot_uids=robot_uids, **kwargs)
@@ -110,7 +110,7 @@ class QuadrupedReachEnv(BaseEnv):
             "is_fallen": is_fallen,
         }
 
-    def _get_obs_extra(self, info: Dict):
+    def _get_obs_extra(self, info: dict):
         obs = dict(
             root_linear_velocity=self.agent.robot.root_linear_velocity,
             root_angular_velocity=self.agent.robot.root_angular_velocity,
@@ -130,7 +130,7 @@ class QuadrupedReachEnv(BaseEnv):
         contact_exists = torch.norm(forces, dim=-1).max(-1).values > threshold
         return contact_exists
 
-    def compute_dense_reward(self, obs: Any, action: torch.Tensor, info: Dict):
+    def compute_dense_reward(self, obs: Any, action: torch.Tensor, info: dict):
         robot_to_goal_dist = info["robot_to_goal_dist"]
         reaching_reward = 1 - torch.tanh(1 * robot_to_goal_dist)
 
@@ -151,7 +151,7 @@ class QuadrupedReachEnv(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 = 3.0
         return self.compute_dense_reward(obs=obs, action=action, info=info) / max_reward

mani_skill/envs/tasks/quadruped/quadruped_spin.py

@@ -1,4 +1,4 @@
-from typing import Any, Dict, List
+from typing import Any
 
 import numpy as np
 import sapien
@@ -21,7 +21,7 @@ class QuadrupedSpinEnv(BaseEnv):
     agent: ANYmalC
     default_qpos: torch.Tensor
 
-    _UNDESIRED_CONTACT_LINK_NAMES: List[str] = None
+    _UNDESIRED_CONTACT_LINK_NAMES: list[str] = None
 
     def __init__(self, *args, robot_uids="anymal-c", **kwargs):
         super().__init__(*args, robot_uids=robot_uids, **kwargs)
@@ -86,7 +86,7 @@ class QuadrupedSpinEnv(BaseEnv):
             "is_fallen": is_fallen,
         }
 
-    def _get_obs_extra(self, info: Dict):
+    def _get_obs_extra(self, info: dict):
         obs = dict(
             root_linear_velocity=self.agent.robot.root_linear_velocity,
             root_angular_velocity=self.agent.robot.root_angular_velocity,
@@ -100,7 +100,7 @@ class QuadrupedSpinEnv(BaseEnv):
         contact_exists = torch.norm(forces, dim=-1).max(-1).values > threshold
         return contact_exists
 
-    def compute_dense_reward(self, obs: Any, action: torch.Tensor, info: Dict):
+    def compute_dense_reward(self, obs: Any, action: torch.Tensor, info: dict):
         rotation_reward = self.agent.robot.root_angular_velocity[:, 2]
         # various penalties:
         lin_vel_z_l2 = torch.square(self.agent.robot.root_linear_velocity[:, 2])
@@ -119,7 +119,7 @@ class QuadrupedSpinEnv(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 = 2.0
         return self.compute_dense_reward(obs=obs, action=action, info=info) / max_reward

mani_skill/envs/tasks/rotate_cube.py

@@ -1,4 +1,4 @@
-from typing import Any, Dict, Tuple
+from typing import Any, Tuple
 
 import numpy as np
 import torch
@@ -250,7 +250,7 @@ class RotateCubeEnv(BaseEnv):
                 )
             )
 
-    def _get_obs_extra(self, info: Dict):
+    def _get_obs_extra(self, info: dict):
         obs = dict(
             goal_pos=self.obj_goal.pose.p,
             goal_q=self.obj_goal.pose.q,
@@ -262,7 +262,7 @@ class RotateCubeEnv(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):
         obj_pos = self.obj.pose.p
         obj_q = self.obj.pose.q
         goal_pos = self.obj_goal.pose.p
@@ -341,7 +341,7 @@ class RotateCubeEnv(BaseEnv):
         total_reward[info["success"]] = 15
         return total_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):
         self.max_reward = 15
         dense_reward = self.compute_dense_reward(obs=obs, action=action, info=info)
         norm_dense_reward = dense_reward / (2 * self.max_reward) + 0.5

mani_skill/envs/tasks/tabletop/assembling_kits.py

@@ -1,5 +1,5 @@
 from pathlib import Path
-from typing import Dict, Union
+from typing import Union
 
 import numpy as np
 import sapien.core as sapien
@@ -278,7 +278,7 @@ class AssemblingKitsEnv(BaseEnv):
             "success": pos_correct & rot_correct & in_slot,
         }
 
-    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/tabletop/lift_peg_upright.py

@@ -1,4 +1,4 @@
-from typing import Any, Dict, Union
+from typing import Any, Union
 
 import numpy as np
 import sapien
@@ -98,7 +98,7 @@ class LiftPegUprightEnv(BaseEnv):
             "success": is_peg_upright & close_to_table,
         }
 
-    def _get_obs_extra(self, info: Dict):
+    def _get_obs_extra(self, info: dict):
         obs = dict(
             tcp_pose=self.agent.tcp.pose.raw_pose,
         )
@@ -108,7 +108,7 @@ class LiftPegUprightEnv(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):
         # rotation reward as cosine similarity between peg direction vectors
         # peg center of mass to end of peg, (1,0,0), rotated by peg pose rotation
         # dot product with its goal orientation: (0,0,1) or (0,0,-1)
@@ -139,6 +139,6 @@ class LiftPegUprightEnv(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/peg_insertion_side.py

@@ -1,4 +1,4 @@
-from typing import Any, Dict, Union
+from typing import Any, Union
 
 import numpy as np
 import sapien
@@ -286,7 +286,7 @@ class PegInsertionSideEnv(BaseEnv):
         success, peg_head_pos_at_hole = self.has_peg_inserted()
         return dict(success=success, peg_head_pos_at_hole=peg_head_pos_at_hole)
 
-    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(
@@ -297,7 +297,7 @@ class PegInsertionSideEnv(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: Encourage gripper to be rotated to be lined up with the peg
 
         # Stage 2: Encourage gripper to move close to peg tail and grasp it
@@ -355,6 +355,6 @@ class PegInsertionSideEnv(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, action, info) / 10

mani_skill/envs/tasks/tabletop/pick_clutter_ycb.py

@@ -1,5 +1,5 @@
 import os
-from typing import Dict, List, Union
+from typing import Union
 
 import numpy as np
 import sapien
@@ -51,7 +51,7 @@ class PickClutterEnv(BaseEnv):
                 "To download default json:"
                 "`python -m mani_skill.utils.download_asset pick_clutter_ycb`."
             )
-        self._episodes: List[Dict] = load_json(episode_json)
+        self._episodes: list[dict] = load_json(episode_json)
         if reconfiguration_freq is None:
             if num_envs == 1:
                 reconfiguration_freq = 1
@@ -110,7 +110,7 @@ class PickClutterEnv(BaseEnv):
         # sample some clutter configurations
         eps_idxs = self._batched_episode_rng.randint(0, len(self._episodes))
 
-        self.selectable_target_objects: List[List[Actor]] = []
+        self.selectable_target_objects: list[list[Actor]] = []
         """for each sub-scene, a list of objects that can be selected as targets"""
         all_objects = []
 
@@ -182,7 +182,7 @@ class PickClutterEnv(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()
 

mani_skill/envs/tasks/tabletop/pick_cube.py

@@ -1,4 +1,4 @@
-from typing import Any, Dict, Union
+from typing import Any, Union
 
 import numpy as np
 import sapien
@@ -129,7 +129,7 @@ class PickCubeEnv(BaseEnv):
             goal_xyz[:, 2] = torch.rand((b)) * self.max_goal_height + xyz[:, 2]
             self.goal_site.set_pose(Pose.create_from_pq(goal_xyz))
 
-    def _get_obs_extra(self, info: Dict):
+    def _get_obs_extra(self, info: dict):
         # in reality some people hack is_grasped into observations by checking if the gripper can close fully or not
         obs = dict(
             is_grasped=info["is_grasped"],
@@ -158,7 +158,7 @@ class PickCubeEnv(BaseEnv):
             "is_grasped": is_grasped,
         }
 
-    def compute_dense_reward(self, obs: Any, action: torch.Tensor, info: Dict):
+    def compute_dense_reward(self, obs: Any, action: torch.Tensor, info: dict):
         tcp_to_obj_dist = torch.linalg.norm(
             self.cube.pose.p - self.agent.tcp_pose.p, axis=1
         )
@@ -186,7 +186,7 @@ class PickCubeEnv(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) / 5
 

mani_skill/envs/tasks/tabletop/pick_single_ycb.py

@@ -1,4 +1,4 @@
-from typing import Any, Dict, List, Union
+from typing import Any, Union
 
 import numpy as np
 import sapien
@@ -134,7 +134,7 @@ class PickSingleYCBEnv(BaseEnv):
                 or set reconfiguration_freq to be >= 1."""
             )
 
-        self._objs: List[Actor] = []
+        self._objs: list[Actor] = []
         self.obj_heights = []
         for i, model_id in enumerate(model_ids):
             # TODO: before official release we will finalize a metadata dataclass that these build functions should return.
@@ -212,7 +212,7 @@ class PickSingleYCBEnv(BaseEnv):
             success=torch.logical_and(is_obj_placed, is_robot_static),
         )
 
-    def _get_obs_extra(self, info: Dict):
+    def _get_obs_extra(self, info: dict):
         obs = dict(
             tcp_pose=self.agent.tcp.pose.raw_pose,
             goal_pos=self.goal_site.pose.p,
@@ -227,7 +227,7 @@ class PickSingleYCBEnv(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):
         tcp_to_obj_dist = torch.linalg.norm(
             self.obj.pose.p - self.agent.tcp.pose.p, axis=1
         )
@@ -254,6 +254,6 @@ class PickSingleYCBEnv(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) / 6

mani_skill/envs/tasks/tabletop/place_sphere.py

@@ -1,4 +1,4 @@
-from typing import Any, Dict, Union
+from typing import Any, Union
 
 import gymnasium as gym
 import matplotlib.pyplot as plt
@@ -200,7 +200,7 @@ class PlaceSphereEnv(BaseEnv):
             "success": success,
         }
 
-    def _get_obs_extra(self, info: Dict):
+    def _get_obs_extra(self, info: dict):
         obs = dict(
             is_grasped=info["is_obj_grasped"],
             tcp_pose=self.agent.tcp.pose.raw_pose,
@@ -213,7 +213,7 @@ class PlaceSphereEnv(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
         obj_pos = self.obj.pose.p
@@ -252,7 +252,7 @@ class PlaceSphereEnv(BaseEnv):
         reward[info["success"]] = 13
         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 = 13.0
         return self.compute_dense_reward(obs=obs, action=action, info=info) / max_reward

mani_skill/envs/tasks/tabletop/plug_charger.py

@@ -1,4 +1,4 @@
-from typing import Dict, Union
+from typing import Union
 
 import numpy as np
 import sapien
@@ -271,7 +271,7 @@ class PlugChargerEnv(BaseEnv):
             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 self.obs_mode_struct.use_state:
             obs.update(

mani_skill/envs/tasks/tabletop/poke_cube.py

@@ -1,4 +1,4 @@
-from typing import Any, Dict, Union
+from typing import Any, Union
 
 import numpy as np
 import sapien
@@ -140,7 +140,7 @@ class PokeCubeEnv(BaseEnv):
             goal_region_pose = Pose.create_from_pq(p=goal_region_xyz, q=goal_region_q)
             self.goal_region.set_pose(goal_region_pose)
 
-    def _get_obs_extra(self, info: Dict):
+    def _get_obs_extra(self, info: dict):
         obs = dict(
             tcp_pose=self.agent.tcp.pose.raw_pose,
         )
@@ -190,7 +190,7 @@ class PokeCubeEnv(BaseEnv):
             "head_to_cube_dist": head_to_cube_dist,
         }
 
-    def compute_dense_reward(self, obs: Any, action: torch.Tensor, info: Dict):
+    def compute_dense_reward(self, obs: Any, action: torch.Tensor, info: dict):
         # reach peg
         tcp_pos = self.agent.tcp.pose.p
         tgt_tcp_pose = self.peg.pose
@@ -224,7 +224,7 @@ class PokeCubeEnv(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/pull_cube.py

@@ -1,4 +1,4 @@
-from typing import Any, Dict, Union
+from typing import Any, Union
 
 import numpy as np
 import sapien
@@ -43,7 +43,7 @@ class PullCubeEnv(BaseEnv):
 
     @property
     def _default_sensor_configs(self):
-        pose = look_at(eye=[-0.5,0.0,0.25], target=[0.2,0.0,-0.5])
+        pose = look_at(eye=[-0.5, 0.0, 0.25], target=[0.2, 0.0, -0.5])
         return [CameraConfig("base_camera", pose, 128, 128, np.pi / 2, 0.01, 100)]
 
     @property
@@ -114,7 +114,7 @@ class PullCubeEnv(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,
             goal_pos=self.goal_region.pose.p,
@@ -125,7 +125,7 @@ class PullCubeEnv(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):
         # grippers should close and pull from behind the cube, not grip it
         # distance to backside of cube (+ 2*0.005) sufficiently encourages this
         tcp_pull_pos = self.obj.pose.p + torch.tensor(
@@ -146,6 +146,6 @@ class PullCubeEnv(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/pull_cube_tool.py

@@ -1,4 +1,4 @@
-from typing import Any, Dict, Union
+from typing import Any, Union
 
 import numpy as np
 import sapien
@@ -176,7 +176,7 @@ class PullCubeToolEnv(BaseEnv):
             cube_pose = Pose.create_from_pq(p=cube_xyz, q=cube_q)
             self.cube.set_pose(cube_pose)
 
-    def _get_obs_extra(self, info: Dict):
+    def _get_obs_extra(self, info: dict):
         obs = dict(
             tcp_pose=self.agent.tcp.pose.raw_pose,
         )
@@ -217,7 +217,7 @@ class PullCubeToolEnv(BaseEnv):
             ),
         }
 
-    def compute_dense_reward(self, obs: Any, action: torch.Tensor, info: Dict):
+    def compute_dense_reward(self, obs: Any, action: torch.Tensor, info: dict):
 
         tcp_pos = self.agent.tcp.pose.p
         cube_pos = self.cube.pose.p
@@ -272,7 +272,7 @@ class PullCubeToolEnv(BaseEnv):
         return reward
 
     def compute_normalized_dense_reward(
-        self, obs: Any, action: torch.Tensor, info: Dict
+        self, obs: Any, action: torch.Tensor, info: dict
     ):
         """
         Normalizes the dense reward by the maximum possible reward (success bonus)