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

mani_skill/utils/scene_builder/registration.py

@@ -1,5 +1,4 @@
 from dataclasses import dataclass
-from typing import Dict
 
 from mani_skill import logger
 from mani_skill.agents.base_agent import BaseAgent
@@ -13,7 +12,7 @@ class SceneBuilderSpec:
     scene_builder_cls: type[scene_builder.SceneBuilder]
 
 
-REGISTERED_SCENE_BUILDERS: Dict[str, SceneBuilderSpec] = {}
+REGISTERED_SCENE_BUILDERS: dict[str, SceneBuilderSpec] = {}
 
 
 def register_scene_builder(uid: str, override=False):

mani_skill/utils/scene_builder/replicacad/rearrange/scene_builder.py

@@ -6,7 +6,7 @@ import os.path as osp
 from collections import defaultdict
 from functools import cached_property
 from pathlib import Path
-from typing import Dict, List, Optional, Tuple
+from typing import Optional, Tuple
 
 import numpy as np
 import sapien
@@ -25,10 +25,10 @@ DEFAULT_HIDDEN_POS = [-10_000] * 3
 
 class ReplicaCADRearrangeSceneBuilder(ReplicaCADSceneBuilder):
 
-    task_names: List[str] = ["set_table:train"]
+    task_names: list[str] = ["set_table:train"]
 
     # init configs for Rearrange stasks are default_object_poses for each object type
-    init_configs: List[List[Dict[str, List[sapien.Pose]]]] = None
+    init_configs: list[list[dict[str, list[sapien.Pose]]]] = None
 
     def __init__(self, env):
         # the Habitat Rearrange tasks build on the base ReplicaCAD scenes by creating episode configs
@@ -87,7 +87,7 @@ class ReplicaCADRearrangeSceneBuilder(ReplicaCADSceneBuilder):
             )
 
     def build(
-        self, build_config_idxs: List[int], init_config_names: Optional[list] = None
+        self, build_config_idxs: list[int], init_config_names: Optional[list] = None
     ):
         if isinstance(build_config_idxs, int):
             build_config_idxs = [build_config_idxs] * self.env.num_envs
@@ -120,12 +120,12 @@ class ReplicaCADRearrangeSceneBuilder(ReplicaCADSceneBuilder):
 
         # self.rcad_to_rearrange_configs: which rearrange episode configs use each rcad config
         # default_object_poses: default poses for ycb objects from each rearrange episode config
-        self.rcad_to_rearrange_configs: Dict[str, List[str]] = dict()
-        default_object_poses: Dict[str, Dict[str, List[sapien.Pose]]] = dict()
+        self.rcad_to_rearrange_configs: dict[str, list[str]] = dict()
+        default_object_poses: dict[str, dict[str, list[sapien.Pose]]] = dict()
         if init_config_names is None:
             init_config_names = self._rearrange_configs
         for rc in init_config_names:
-            objects: Dict[str, List[sapien.Pose]] = defaultdict(list)
+            objects: dict[str, list[sapien.Pose]] = defaultdict(list)
 
             with open(
                 osp.join(
@@ -150,7 +150,7 @@ class ReplicaCADRearrangeSceneBuilder(ReplicaCADSceneBuilder):
             default_object_poses[rc] = objects
 
         # create init config
-        self.init_configs: List[List[Dict[str, List[sapien.Pose]]]] = [
+        self.init_configs: list[list[dict[str, list[sapien.Pose]]]] = [
             [
                 default_object_poses[rc]
                 for rc in self.rcad_to_rearrange_configs[self.build_configs[bci]]
@@ -163,7 +163,7 @@ class ReplicaCADRearrangeSceneBuilder(ReplicaCADSceneBuilder):
         # build multiple instances of each YCB object for each RCAD scene
         # when initializing, we set poses according to the sampled init configs,
         # and we hide any unused instances of YCB objects
-        rcad_config_to_num_ycb_objs_to_build: Dict[str, Dict[str, int]] = dict()
+        rcad_config_to_num_ycb_objs_to_build: dict[str, dict[str, int]] = dict()
         for rcad_config in self.rcad_to_rearrange_configs.keys():
             obj_ids = set()
             for rearrange_config in self.rcad_to_rearrange_configs[rcad_config]:
@@ -195,7 +195,7 @@ class ReplicaCADRearrangeSceneBuilder(ReplicaCADSceneBuilder):
             (env_num, copy.deepcopy(DEFAULT_HIDDEN_POS))
             for env_num in range(len(build_config_idxs))
         )
-        self._default_hidden_poses: Dict[Actor, sapien.Pose] = dict()
+        self._default_hidden_poses: dict[Actor, sapien.Pose] = dict()
         for env_num, bci in enumerate(build_config_idxs):
             rcad_config = self.build_configs[bci]
             num_ycb_objs_to_build = rcad_config_to_num_ycb_objs_to_build[rcad_config]
@@ -220,12 +220,12 @@ class ReplicaCADRearrangeSceneBuilder(ReplicaCADSceneBuilder):
                     self.movable_objects[obj_instance_name] = actor
             self.ycb_objs_per_env.append(ycb_objs)
 
-        self.rcad_config_to_rearrange_ao_states: Dict[
-            str, List[List[Tuple[Articulation, torch.Tensor]]]
+        self.rcad_config_to_rearrange_ao_states: dict[
+            str, list[list[Tuple[Articulation, torch.Tensor]]]
         ] = defaultdict(list)
         for env_num, bci in enumerate(build_config_idxs):
             rcad_config = self.build_configs[bci]
-            rearrange_ao_states: List[List[Tuple[Articulation, torch.Tensor]]] = []
+            rearrange_ao_states: list[list[Tuple[Articulation, torch.Tensor]]] = []
             for rearrange_config in self.rcad_to_rearrange_configs[rcad_config]:
                 with open(
                     osp.join(
@@ -236,8 +236,8 @@ class ReplicaCADRearrangeSceneBuilder(ReplicaCADSceneBuilder):
                     "rb",
                 ) as f:
                     episode_json = json.load(f)
-                episode_ao_states: Dict[str, Dict[str, int]] = episode_json["ao_states"]
-                articulation_qpos_pairs: List[Tuple[Articulation, torch.Tensor]] = []
+                episode_ao_states: dict[str, dict[str, int]] = episode_json["ao_states"]
+                articulation_qpos_pairs: list[Tuple[Articulation, torch.Tensor]] = []
                 for base_articulation_id, qpos_dict in episode_ao_states.items():
                     aid, anum = base_articulation_id.split(":")
                     articulation = self.articulations[
@@ -256,7 +256,7 @@ class ReplicaCADRearrangeSceneBuilder(ReplicaCADSceneBuilder):
             self.rcad_config_to_rearrange_ao_states[rcad_config] = rearrange_ao_states
 
     # TODO (arth): fix this to work with partial resets
-    def initialize(self, env_idx: torch.Tensor, init_config_idxs: List[int]):
+    def initialize(self, env_idx: torch.Tensor, init_config_idxs: list[int]):
         assert all(
             [isinstance(ici, int) for ici in init_config_idxs]
         ), f"init_config_idxs should be list of ints, instead got {init_config_idxs}"

mani_skill/utils/scene_builder/replicacad/scene_builder.py

@@ -9,7 +9,7 @@ import os.path as osp
 from collections import defaultdict
 from functools import cached_property
 from pathlib import Path
-from typing import Dict, List, Tuple, Union
+from typing import Tuple, Union
 
 import numpy as np
 import sapien
@@ -42,7 +42,7 @@ class ReplicaCADSceneBuilder(SceneBuilder):
     builds_lighting = True  # we set this true because the ReplicaCAD dataset defines some lighting for us so we don't need the default option from ManiSkill
 
     # build configs for RCAD are string file names
-    build_configs: List[str] = None
+    build_configs: list[str] = None
 
     def __init__(self, env, robot_init_qpos_noise=0.02, include_staging_scenes=False):
         super().__init__(env, robot_init_qpos_noise=robot_init_qpos_noise)
@@ -60,9 +60,9 @@ class ReplicaCADSceneBuilder(SceneBuilder):
         # cache navigable positions from files
         # assumes navigable position files saved
         self._navigable_positions = [None] * len(self.build_configs)
-        self.build_config_idxs: List[int] = None
+        self.build_config_idxs: list[int] = None
 
-    def build(self, build_config_idxs: Union[int, List[int]]):
+    def build(self, build_config_idxs: Union[int, list[int]]):
         # build_config_idxs is a list of integers, where the ith value is the scene idx for the ith parallel env
         if isinstance(build_config_idxs, int):
             build_config_idxs = [build_config_idxs] * self.env.num_envs
@@ -74,10 +74,10 @@ class ReplicaCADSceneBuilder(SceneBuilder):
 
         # Keep track of movable and static objects, build_config_idxs for envs, and poses
         self.build_config_idxs = build_config_idxs
-        self.scene_objects: Dict[str, Actor] = dict()
-        self.movable_objects: Dict[str, Actor] = dict()
-        self.articulations: Dict[str, Articulation] = dict()
-        self._default_object_poses: List[Tuple[Actor, sapien.Pose]] = []
+        self.scene_objects: dict[str, Actor] = dict()
+        self.movable_objects: dict[str, Actor] = dict()
+        self.articulations: dict[str, Articulation] = dict()
+        self._default_object_poses: list[Tuple[Actor, sapien.Pose]] = []
 
         # keep track of background objects separately as we need to disable mobile robot collisions
         # note that we will create a merged actor using these objects to represent the bg
@@ -235,12 +235,12 @@ class ReplicaCADSceneBuilder(SceneBuilder):
 
                 # for now classify articulated objects as "movable" object
                 for env_num in env_idx:
-                    self.articulations[f"env-{env_num}_{articulation_name}"] = (
-                        articulation
-                    )
-                    self.scene_objects[f"env-{env_num}_{articulation_name}"] = (
-                        articulation
-                    )
+                    self.articulations[
+                        f"env-{env_num}_{articulation_name}"
+                    ] = articulation
+                    self.scene_objects[
+                        f"env-{env_num}_{articulation_name}"
+                    ] = articulation
 
                 for link in articulation.links:
                     link.set_collision_group_bit(
@@ -335,7 +335,7 @@ class ReplicaCADSceneBuilder(SceneBuilder):
             )
 
     @property
-    def navigable_positions(self) -> List[trimesh.Trimesh]:
+    def navigable_positions(self) -> list[trimesh.Trimesh]:
         return [self._navigable_positions[bci] for bci in self.build_config_idxs]
 
     @cached_property

mani_skill/utils/scene_builder/robocasa/fixtures/windows.py

@@ -1,5 +1,3 @@
-from typing import List
-
 import numpy as np
 import sapien
 import sapien.physx as physx
@@ -53,7 +51,7 @@ class Window:
     ):
         self.scene = scene
         self.name = name
-        self.objects: List[ActorBuilder] = []
+        self.objects: list[ActorBuilder] = []
         self.euler = [0, 0, 0]
 
         self.size = size
@@ -137,7 +135,7 @@ class Window:
             self.rng = np.random.default_rng()
         # change to create objects then create positions
 
-    def build(self, scene_idxs: List[int]):
+    def build(self, scene_idxs: list[int]):
         self.actor_builder.set_scene_idxs(scene_idxs)
         self.actor_builder.initial_pose = sapien.Pose(
             p=np.array(self.pos), q=euler2quat(*self.euler)

mani_skill/utils/scene_builder/robocasa/scene_builder.py

@@ -2,7 +2,7 @@
 
 import logging
 from copy import deepcopy
-from typing import Dict, List, Optional
+from typing import Optional
 
 import numpy as np
 import torch
@@ -154,7 +154,7 @@ class RoboCasaSceneBuilder(SceneBuilder):
         self.scene_data = []  # maps scene_idx to {"fixtures", "fxtr_placements"}
         super().__init__(*args, **kwargs)
 
-    def build(self, build_config_idxs: Optional[List[int]] = None):
+    def build(self, build_config_idxs: Optional[list[int]] = None):
         if self.env.agent is not None:
             self.robot_poses = self.env.agent.robot.initial_pose
         else:
@@ -231,7 +231,7 @@ class RoboCasaSceneBuilder(SceneBuilder):
                 arena.extend(group_fixtures)
 
             # maps each fixture name to its object class
-            fixtures: Dict[str, Fixture] = dict()
+            fixtures: dict[str, Fixture] = dict()
             # maps each fixture name to its configuration
             configs = dict()
             # names of composites, delete from fixtures before returning
@@ -398,7 +398,7 @@ class RoboCasaSceneBuilder(SceneBuilder):
                     euler2quat(*robot_base_ori)
                 ).to(self.robot_poses.device)
 
-            actors: Dict[str, Actor] = {}
+            actors: dict[str, Actor] = {}
 
             ### collision handling and optimization ###
             # Generally we aim to ensure all articulations in a stack have the same collision bits so they can't collide with each other
@@ -560,7 +560,7 @@ class RoboCasaSceneBuilder(SceneBuilder):
             robot_base_ori = None
         return fxtr_placements, robot_base_pos, robot_base_ori
 
-    def initialize(self, env_idx: torch.Tensor, init_config_idxs: List[int] = None):
+    def initialize(self, env_idx: torch.Tensor, init_config_idxs: list[int] = None):
         with torch.device(self.env.device):
             if self.env.agent is not None:
                 if self.env.robot_uids == "fetch":

mani_skill/utils/scene_builder/scene_builder.py

@@ -1,7 +1,7 @@
 from __future__ import annotations
 
 from functools import cached_property
-from typing import TYPE_CHECKING, Any, Dict, List, Optional, Union
+from typing import TYPE_CHECKING, Any, Optional, Union
 
 import sapien
 import torch
@@ -30,38 +30,38 @@ class SceneBuilder:
     builds_lighting: bool = False
     """Whether this scene builder will add its own lighting when build is called. If False, ManiSkill will add some default lighting"""
 
-    build_configs: Optional[List[Any]] = None
-    """List of scene configuration information that can be used to **build** scenes during reconfiguration (i.e. `env.reset(seed=seed, options=dict(reconfigure=True))`). Can be a dictionary, a path to a json file, or some other data. If a scene needs to load build config data, it will index/sample such build configs from this list."""
-    init_configs: Optional[List[Any]] = None
-    """List of scene configuration information that can be used to **init** scenes during reconfiguration (i.e. `env.reset()`). Can be a dictionary, a path to a json file, or some other data. If a scene needs to load init config data, it will index/sample such init configs from this list."""
+    build_configs: Optional[list[Any]] = None
+    """list of scene configuration information that can be used to **build** scenes during reconfiguration (i.e. `env.reset(seed=seed, options=dict(reconfigure=True))`). Can be a dictionary, a path to a json file, or some other data. If a scene needs to load build config data, it will index/sample such build configs from this list."""
+    init_configs: Optional[list[Any]] = None
+    """list of scene configuration information that can be used to **init** scenes during reconfiguration (i.e. `env.reset()`). Can be a dictionary, a path to a json file, or some other data. If a scene needs to load init config data, it will index/sample such init configs from this list."""
 
-    scene_objects: Optional[Dict[str, Actor]] = None
+    scene_objects: Optional[dict[str, Actor]] = None
     """Scene objects are any dynamic, kinematic, or static Actor built by the scene builder. Useful for accessing objects in the scene directly."""
-    movable_objects: Optional[Dict[str, Actor]] = None
+    movable_objects: Optional[dict[str, Actor]] = None
     """Movable objects are any **dynamic** Actor built by the scene builder. movable_objects is a subset of scene_objects. Can be used to query dynamic objects for e.g. task initialization."""
-    articulations: Optional[Dict[str, Articulation]] = None
+    articulations: Optional[dict[str, Articulation]] = None
     """Articulations are any articulation loaded in by the scene builder."""
 
-    navigable_positions: Optional[List[Union[Array, spaces.Box]]] = None
+    navigable_positions: Optional[list[Union[Array, spaces.Box]]] = None
     """Some scenes allow for mobile robots to move through these scene. In this case, a list of navigable positions per env_idx (e.g. loaded from a navmesh) should be provided for easy initialization. Can be a discretized list, range, spaces.Box, etc."""
 
     def __init__(self, env, robot_init_qpos_noise=0.02):
         self.env = env
         self.robot_init_qpos_noise = robot_init_qpos_noise
 
-    def build(self, build_config_idxs: List[int] = None):
+    def build(self, build_config_idxs: list[int] = None):
         """
         Should create actor/articulation builders and only build objects into the scene without initializing pose, qpos, velocities etc.
         """
         raise NotImplementedError()
 
-    def initialize(self, env_idx: torch.Tensor, init_config_idxs: List[int] = None):
+    def initialize(self, env_idx: torch.Tensor, init_config_idxs: list[int] = None):
         """
         Should initialize the scene, which can include e.g. setting the pose of all objects, changing the qpos/pose of articulations/robots etc.
         """
         raise NotImplementedError()
 
-    def sample_build_config_idxs(self) -> List[int]:
+    def sample_build_config_idxs(self) -> list[int]:
         """
         Sample idxs of build configs for easy scene randomization. Should be changed to fit shape of self.build_configs.
         """
@@ -69,7 +69,7 @@ class SceneBuilder:
             low=0, high=len(self.build_configs), size=(self.env.num_envs,)
         ).tolist()
 
-    def sample_init_config_idxs(self) -> List[int]:
+    def sample_init_config_idxs(self) -> list[int]:
         """
         Sample idxs of init configs for easy scene randomization. Should be changed to fit shape of self.init_configs.
         """
@@ -78,11 +78,11 @@ class SceneBuilder:
         ).tolist()
 
     @cached_property
-    def build_config_names_to_idxs(self) -> Dict[str, int]:
+    def build_config_names_to_idxs(self) -> dict[str, int]:
         return dict((v, i) for i, v in enumerate(self.build_configs))
 
     @cached_property
-    def init_config_names_to_idxs(self) -> Dict[str, int]:
+    def init_config_names_to_idxs(self) -> dict[str, int]:
         return dict((v, i) for i, v in enumerate(self.init_configs))
 
     @property

mani_skill/utils/scene_builder/table/scene_builder.py

@@ -1,6 +1,5 @@
 import os.path as osp
 from pathlib import Path
-from typing import List
 
 import numpy as np
 import sapien
@@ -63,7 +62,7 @@ class TableSceneBuilder(SceneBuilder):
             self.scene, floor_width=floor_width, altitude=-self.table_height
         )
         self.table = table
-        self.scene_objects: List[sapien.Entity] = [self.table, self.ground]
+        self.scene_objects: list[sapien.Entity] = [self.table, self.ground]
 
     def initialize(self, env_idx: torch.Tensor):
         # table_height = 0.9196429

mani_skill/utils/structs/actor.py

@@ -2,7 +2,7 @@ from __future__ import annotations
 
 from dataclasses import dataclass
 from functools import cached_property
-from typing import TYPE_CHECKING, List, Literal, Optional, Union
+from typing import TYPE_CHECKING, Literal, Optional, Union
 
 import numpy as np
 import sapien
@@ -57,7 +57,7 @@ class Actor(PhysxRigidDynamicComponentStruct[sapien.Entity]):
     @classmethod
     def create_from_entities(
         cls,
-        entities: List[sapien.Entity],
+        entities: list[sapien.Entity],
         scene: ManiSkillScene,
         scene_idxs: torch.Tensor,
         shared_name: Optional[str] = None,
@@ -97,7 +97,7 @@ class Actor(PhysxRigidDynamicComponentStruct[sapien.Entity]):
         )
 
     @classmethod
-    def merge(cls, actors: List["Actor"], name: str = None):
+    def merge(cls, actors: list["Actor"], name: str = None):
         """
         Merge actors together under one view so that they can all be managed by one python dataclass object.
         This can be useful for e.g. randomizing the asset loaded into a task and being able to do object.pose to fetch the pose of all randomized assets
@@ -106,7 +106,7 @@ class Actor(PhysxRigidDynamicComponentStruct[sapien.Entity]):
         For example usage of this method, see mani_skill/envs/tasks/pick_single_ycb.py
 
         Args:
-            actors (List[Actor]): The actors to merge into one actor object to manage
+            actors (list[Actor]): The actors to merge into one actor object to manage
             name (str): A new name to give the merged actors. If none, the name will default to the first actor's name
         """
         objs = []
@@ -259,7 +259,7 @@ class Actor(PhysxRigidDynamicComponentStruct[sapien.Entity]):
 
     def get_collision_meshes(
         self, to_world_frame: bool = True, first_only: bool = False
-    ) -> Union[List[trimesh.Trimesh], trimesh.Trimesh]:
+    ) -> Union[list[trimesh.Trimesh], trimesh.Trimesh]:
         """
         Returns the collision mesh of each managed actor object. Note results of this are not cached or optimized at the moment
         so this function can be slow if called too often. Some actors have no collision meshes, in which case this function returns an empty list.
@@ -274,7 +274,7 @@ class Actor(PhysxRigidDynamicComponentStruct[sapien.Entity]):
             not self.merged
         ), "Currently you cannot fetch collision meshes of merged actors"
 
-        meshes: List[trimesh.Trimesh] = []
+        meshes: list[trimesh.Trimesh] = []
 
         for i, actor in enumerate(self._objs):
             actor_meshes = []

mani_skill/utils/structs/articulation.py

@@ -3,7 +3,7 @@ from __future__ import annotations
 from collections import defaultdict
 from dataclasses import dataclass, field
 from functools import cached_property
-from typing import TYPE_CHECKING, Dict, List, Optional, Tuple, Union
+from typing import TYPE_CHECKING, Optional, Tuple, Union
 
 import numpy as np
 import sapien
@@ -30,19 +30,19 @@ class Articulation(BaseStruct[physx.PhysxArticulation]):
     Wrapper around physx.PhysxArticulation objects
     """
 
-    links: List[Link]
-    """List of Link objects"""
-    links_map: Dict[str, Link]
+    links: list[Link]
+    """list of Link objects"""
+    links_map: dict[str, Link]
     """Maps link name to the Link object"""
     root: Link
     """The root Link object"""
-    joints: List[ArticulationJoint]
-    """List of Joint objects"""
-    joints_map: Dict[str, ArticulationJoint]
+    joints: list[ArticulationJoint]
+    """list of Joint objects"""
+    joints_map: dict[str, ArticulationJoint]
     """Maps joint name to the Joint object"""
-    active_joints: List[ArticulationJoint]
-    """List of active Joint objects, referencing elements in self.joints"""
-    active_joints_map: Dict[str, ArticulationJoint]
+    active_joints: list[ArticulationJoint]
+    """list of active Joint objects, referencing elements in self.joints"""
+    active_joints_map: dict[str, ArticulationJoint]
     """Maps active joint name to the Joint object, referencing elements in self.joints"""
 
     name: str = None
@@ -60,10 +60,10 @@ class Articulation(BaseStruct[physx.PhysxArticulation]):
     longer make "sense"
     """
 
-    _cached_joint_target_indices: Dict[int, torch.Tensor] = field(default_factory=dict)
+    _cached_joint_target_indices: dict[int, torch.Tensor] = field(default_factory=dict)
     """Map from a set of joints of this articulation and the indexing torch tensor to use for setting drive targets in GPU sims."""
 
-    _net_contact_force_queries: Dict[
+    _net_contact_force_queries: dict[
         Tuple, physx.PhysxGpuContactBodyImpulseQuery
     ] = field(default_factory=dict)
     """Maps a tuple of link names to pre-saved net contact force queries"""
@@ -80,7 +80,7 @@ class Articulation(BaseStruct[physx.PhysxArticulation]):
     @classmethod
     def create_from_physx_articulations(
         cls,
-        physx_articulations: List[physx.PhysxArticulation],
+        physx_articulations: list[physx.PhysxArticulation],
         scene: ManiSkillScene,
         scene_idxs: torch.Tensor,
         _merged: bool = False,
@@ -111,15 +111,15 @@ class Articulation(BaseStruct[physx.PhysxArticulation]):
         )
         # create link and joint structs
         num_links = max([len(x.links) for x in physx_articulations])
-        all_links_objs: List[List[physx.PhysxArticulationLinkComponent]] = [
+        all_links_objs: list[list[physx.PhysxArticulationLinkComponent]] = [
             [] for _ in range(num_links)
         ]
         num_joints = max([len(x.joints) for x in physx_articulations])
-        all_joint_objs: List[List[physx.PhysxArticulationJoint]] = [
+        all_joint_objs: list[list[physx.PhysxArticulationJoint]] = [
             [] for _ in range(num_joints)
         ]
 
-        links_map: Dict[str, Link] = dict()
+        links_map: dict[str, Link] = dict()
         for articulation in physx_articulations:
             if _process_links:
                 assert num_links == len(articulation.links) and num_joints == len(
@@ -130,7 +130,7 @@ class Articulation(BaseStruct[physx.PhysxArticulation]):
                 all_links_objs[i].append(link)
             for i, joint in enumerate(articulation.joints):
                 all_joint_objs[i].append(joint)
-        wrapped_links: List[Link] = []
+        wrapped_links: list[Link] = []
 
         root = None
         for links in all_links_objs:
@@ -164,7 +164,7 @@ class Articulation(BaseStruct[physx.PhysxArticulation]):
             ]
 
             joints_map = dict()
-            wrapped_joints: List[ArticulationJoint] = []
+            wrapped_joints: list[ArticulationJoint] = []
             for joint_index, joints in enumerate(all_joint_objs):
                 try:
                     active_joint_index = all_active_joint_names.index(
@@ -223,7 +223,7 @@ class Articulation(BaseStruct[physx.PhysxArticulation]):
     @classmethod
     def merge(
         cls,
-        articulations: List["Articulation"],
+        articulations: list["Articulation"],
         name: str = None,
         merge_links: bool = False,
     ):
@@ -343,7 +343,7 @@ class Articulation(BaseStruct[physx.PhysxArticulation]):
 
     def get_collision_meshes(
         self, to_world_frame: bool = True, first_only: bool = False
-    ) -> Union[List[trimesh.Trimesh], trimesh.Trimesh]:
+    ) -> Union[list[trimesh.Trimesh], trimesh.Trimesh]:
         """
         Returns the collision mesh of each managed articulation object. Note results of this are not cached or optimized at the moment
         so this function can be slow if called too often
@@ -365,7 +365,7 @@ class Articulation(BaseStruct[physx.PhysxArticulation]):
         else:
             self._objs[0].pose = self._objs[0].pose
         # TODO (stao): Can we have a batched version of trimesh?
-        meshes: List[trimesh.Trimesh] = []
+        meshes: list[trimesh.Trimesh] = []
 
         for i, art in enumerate(self._objs):
             art_meshes = []
@@ -396,7 +396,7 @@ class Articulation(BaseStruct[physx.PhysxArticulation]):
 
     def get_visual_meshes(
         self, to_world_frame: bool = True, first_only: bool = False
-    ) -> List[trimesh.Trimesh]:
+    ) -> list[trimesh.Trimesh]:
         """
         Returns the visual mesh of each managed articulation object. Note results of this are not cached or optimized at the moment
         so this function can be slow if called too often
@@ -411,7 +411,7 @@ class Articulation(BaseStruct[physx.PhysxArticulation]):
                 initialization, and link poses are needed to get the correct visual mesh of an entire articulation"
         else:
             self._objs[0].pose = self._objs[0].pose
-        meshes: List[trimesh.Trimesh] = []
+        meshes: list[trimesh.Trimesh] = []
         for i, art in enumerate(self._objs):
             art_meshes = []
             for link in art.links:
@@ -438,7 +438,7 @@ class Articulation(BaseStruct[physx.PhysxArticulation]):
             return meshes[0]
         return meshes
 
-    def get_net_contact_impulses(self, link_names: Union[List[str], Tuple[str]]):
+    def get_net_contact_impulses(self, link_names: Union[list[str], Tuple[str]]):
         """Get net contact impulses for several links together. This should be faster compared to using
         link.get_net_contact_impulses on each link.
 
@@ -487,7 +487,7 @@ class Articulation(BaseStruct[physx.PhysxArticulation]):
                     net_impulse[i] = common.to_tensor(total_impulse)
             return net_impulse[None, :]
 
-    def get_net_contact_forces(self, link_names: Union[List[str], Tuple[str]]):
+    def get_net_contact_forces(self, link_names: Union[list[str], Tuple[str]]):
         """Get net contact forces for several links together. This should be faster compared to using
         link.get_net_contact_forces on each link.
 
@@ -497,7 +497,7 @@ class Articulation(BaseStruct[physx.PhysxArticulation]):
         return self.get_net_contact_impulses(link_names) / self.scene.timestep
 
     def get_joint_target_indices(
-        self, joint_indices: Union[Array, List[int], List[ArticulationJoint]]
+        self, joint_indices: Union[Array, list[int], list[ArticulationJoint]]
     ):
         """
         Gets the meshgrid indexes for indexing px.cuda_articulation_target_* values given a 1D list of joint indexes or a 1D list of ArticulationJoint objects.
@@ -873,7 +873,7 @@ class Articulation(BaseStruct[physx.PhysxArticulation]):
     def set_joint_drive_targets(
         self,
         targets: Array,
-        joints: Optional[List[ArticulationJoint]] = None,
+        joints: Optional[list[ArticulationJoint]] = None,
         joint_indices: Optional[torch.Tensor] = None,
     ):
         """
@@ -888,7 +888,8 @@ class Articulation(BaseStruct[physx.PhysxArticulation]):
             else:
                 gx, gy = self.get_joint_target_indices(joint_indices)
             self.px.cuda_articulation_target_qpos.torch()[
-                gx[self.scene._reset_mask[self._scene_idxs]], gy[self.scene._reset_mask[self._scene_idxs]]
+                gx[self.scene._reset_mask[self._scene_idxs]],
+                gy[self.scene._reset_mask[self._scene_idxs]],
             ] = targets
         else:
             for i, joint in enumerate(joints):
@@ -897,7 +898,7 @@ class Articulation(BaseStruct[physx.PhysxArticulation]):
     def set_joint_drive_velocity_targets(
         self,
         targets: Array,
-        joints: Optional[List[ArticulationJoint]] = None,
+        joints: Optional[list[ArticulationJoint]] = None,
         joint_indices: Optional[torch.Tensor] = None,
     ):
         """
@@ -912,7 +913,8 @@ class Articulation(BaseStruct[physx.PhysxArticulation]):
             else:
                 gx, gy = self.get_joint_target_indices(joint_indices)
             self.px.cuda_articulation_target_qvel.torch()[
-                gx[self.scene._reset_mask[self._scene_idxs]], gy[self.scene._reset_mask[self._scene_idxs]]
+                gx[self.scene._reset_mask[self._scene_idxs]],
+                gy[self.scene._reset_mask[self._scene_idxs]],
             ] = targets
         else:
             for i, joint in enumerate(joints):