pass precommit

Author: ooctipus

scripts/demos/h1_locomotion.py

@@ -45,11 +45,10 @@
 
 import carb
 import omni
-from omni.kit.viewport.utility import get_viewport_from_window_name
-from omni.kit.viewport.utility.camera_state import ViewportCameraState
 from pxr import Gf, Sdf
 from rsl_rl.runners import OnPolicyRunner
 
+from isaaclab import lazy
 from isaaclab.envs import ManagerBasedRLEnv
 from isaaclab.sim.utils.stage import get_current_stage
 from isaaclab.utils.math import quat_apply
@@ -112,7 +111,7 @@ def __init__(self):
     def create_camera(self):
         """Creates a camera to be used for third-person view."""
         stage = get_current_stage()
-        self.viewport = get_viewport_from_window_name("Viewport")
+        self.viewport = lazy.omni_kit_viewport_utility.get_viewport_from_window_name("Viewport")
         # Create camera
         self.camera_path = "/World/Camera"
         self.perspective_path = "/OmniverseKit_Persp"
@@ -200,7 +199,7 @@ def _update_camera(self):
 
         camera_pos = quat_apply(base_quat, self._camera_local_transform) + base_pos
 
-        camera_state = ViewportCameraState(self.camera_path, self.viewport)
+        camera_state = lazy.omni_kit_viewport_utility.camera_state.ViewportCameraState(self.camera_path, self.viewport)
         eye = Gf.Vec3d(camera_pos[0].item(), camera_pos[1].item(), camera_pos[2].item())
         target = Gf.Vec3d(base_pos[0].item(), base_pos[1].item(), base_pos[2].item() + 0.6)
         camera_state.set_position_world(eye, True)

source/isaaclab/isaaclab/envs/ui/base_env_window.py

@@ -115,7 +115,7 @@ def _build_sim_frame(self):
             width=omni.ui.Fraction(1),
             height=0,
             collapsed=False,
-            style=lazy.lazy.isaacsim.gui.components.ui_utils.get_style(),
+            style=lazy.isaacsim.gui.components.ui_utils.get_style(),
             horizontal_scrollbar_policy=omni.ui.ScrollBarPolicy.SCROLLBAR_AS_NEEDED,
             vertical_scrollbar_policy=omni.ui.ScrollBarPolicy.SCROLLBAR_ALWAYS_ON,
         )

source/isaaclab/isaaclab/lazy.py

@@ -8,5 +8,15 @@
 # Lazily import heavy dependencies so importing ``isaaclab`` does not
 # immediately import them. Currently only ``isaacsim`` is required.
 isaacsim = LazyImporter("isaacsim")
+isaacsim_core_utils_viewports = LazyImporter("isaacsim.core.utils.viewports")
+omni = LazyImporter("omni")
+omni_metrics_assembler_core = LazyImporter("omni.metrics.assembler.core")
+omni_kit_viewport_utility = LazyImporter("omni.kit.viewport.utility")
 
-__all__ = ["isaacsim"]
+__all__ = [
+    "isaacsim",
+    "isaacsim_core_utils_viewports",
+    "omni",
+    "omni_metrics_assembler_core",
+    "omni_kit_viewport_utility",
+]

source/isaaclab/isaaclab/scene/interactive_scene.py

@@ -783,7 +783,9 @@ def _add_entities_from_cfg(self):
                     )
                 # store xform prim view corresponding to this asset
                 # all prims in the scene are Xform prims (i.e. have a transform component)
-                self._extras[asset_name] = XFormPrim(asset_cfg.prim_path, reset_xform_properties=False)
+                self._extras[asset_name] = lazy.isaacsim.core.prims.XFormPrim(
+                    asset_cfg.prim_path, reset_xform_properties=False
+                )
             else:
                 raise ValueError(f"Unknown asset config type for {asset_name}: {asset_cfg}")
             # store global collision paths

source/isaaclab/isaaclab/sensors/camera/tiled_camera.py

@@ -13,10 +13,10 @@
 from typing import TYPE_CHECKING, Any
 
 import carb
-import lazy
 import warp as wp
 from pxr import UsdGeom
 
+from isaaclab import lazy
 from isaaclab.utils.warp.kernels import reshape_tiled_image
 
 from ..sensor_base import SensorBase

source/isaaclab/isaaclab/sim/simulation_context.py

@@ -191,13 +191,12 @@ def __init__(self, cfg: SimulationCfg | None = None):
         else:
             # note: need to import here in case the UI is not available (ex. headless mode)
             import omni.ui as ui
-            from omni.kit.viewport.utility import get_active_viewport
 
             # set default render mode
             # note: this can be changed by calling the `set_render_mode` function
             self.render_mode = self.RenderMode.FULL_RENDERING
             # acquire viewport context
-            self._viewport_context = get_active_viewport()
+            self._viewport_context = lazy.omni_kit_viewport_utility.get_active_viewport()
             self._viewport_context.updates_enabled = True  # pyright: ignore [reportOptionalMemberAccess]
             # acquire viewport window
             # TODO @mayank: Why not just use get_active_viewport_and_window() directly?
@@ -210,10 +209,8 @@ def __init__(self, cfg: SimulationCfg | None = None):
         # check the case where we don't need to render the viewport
         # since render_viewport can only be False in headless mode, we only need to check for offscreen_render
         if not self._render_viewport and self._offscreen_render:
-            # disable the viewport if offscreen_render is enabled
-            from omni.kit.viewport.utility import get_active_viewport
 
-            get_active_viewport().updates_enabled = False
+            lazy.omni_kit_viewport_utility.get_active_viewport().updates_enabled = False
 
         # override enable scene querying if rendering is enabled
         # this is needed for some GUI features
@@ -389,7 +386,7 @@ def set_camera_view(
         """
         # safe call only if we have a GUI or viewport rendering enabled
         if self._has_gui or self._offscreen_render or self._render_viewport:
-            lazy.isaacsim.core.utils.viewports.set_camera_view(eye, target, camera_prim_path)
+            lazy.isaacsim_core_utils_viewports.set_camera_view(eye, target, camera_prim_path)
 
     def set_render_mode(self, mode: RenderMode):
         """Change the current render mode of the simulation.

source/isaaclab/isaaclab/sim/utils/stage.py

@@ -407,7 +407,7 @@ def add_reference_to_stage(usd_path: str, prim_path: str, prim_type: str = "Xfor
         # logger.info(f"Could not get Sdf layer for {usd_path}")
     else:
         stage_id = UsdUtils.StageCache.Get().GetId(stage).ToLongInt()
-        ret_val = omni.metrics.assembler.core.get_metrics_assembler_interface().check_layers(
+        ret_val = lazy.omni_metrics_assembler_core.get_metrics_assembler_interface().check_layers(
             stage.GetRootLayer().identifier, sdf_layer.identifier, stage_id
         )
         if ret_val["ret_val"]:

source/isaaclab_tasks/isaaclab_tasks/direct/locomotion/locomotion_env.py

@@ -23,6 +23,12 @@ class LocomotionEnv(DirectRLEnv):
     def __init__(self, cfg: DirectRLEnvCfg, render_mode: str | None = None, **kwargs):
         super().__init__(cfg, render_mode, **kwargs)
 
+        self._compute_intermediate_values_fn = _make_compute_intermediate_values(
+            lazy.isaacsim.core.utils.torch.rotations.compute_heading_and_up,
+            lazy.isaacsim.core.utils.torch.rotations.compute_rot,
+            lazy.isaacsim.core.utils.torch.maths.unscale,
+        )
+
         self.action_scale = self.cfg.action_scale
         self.joint_gears = torch.tensor(self.cfg.joint_gears, dtype=torch.float32, device=self.sim.device)
         self.motor_effort_ratio = torch.ones_like(self.joint_gears, device=self.sim.device)
@@ -88,7 +94,7 @@ def _compute_intermediate_values(self):
             self.dof_pos_scaled,
             self.prev_potentials,
             self.potentials,
-        ) = compute_intermediate_values(
+        ) = self._compute_intermediate_values_fn(
             self.targets,
             self.torso_position,
             self.torso_rotation,
@@ -228,55 +234,56 @@ def compute_rewards(
     return total_reward
 
 
-@torch.jit.script
-def compute_intermediate_values(
-    targets: torch.Tensor,
-    torso_position: torch.Tensor,
-    torso_rotation: torch.Tensor,
-    velocity: torch.Tensor,
-    ang_velocity: torch.Tensor,
-    dof_pos: torch.Tensor,
-    dof_lower_limits: torch.Tensor,
-    dof_upper_limits: torch.Tensor,
-    inv_start_rot: torch.Tensor,
-    basis_vec0: torch.Tensor,
-    basis_vec1: torch.Tensor,
-    potentials: torch.Tensor,
-    prev_potentials: torch.Tensor,
-    dt: float,
-):
-    to_target = targets - torso_position
-    to_target[:, 2] = 0.0
+def _make_compute_intermediate_values(compute_heading_and_up_fn, compute_rot_fn, unscale_fn):
+    @torch.jit.script
+    def _compute_intermediate_values(
+        targets: torch.Tensor,
+        torso_position: torch.Tensor,
+        torso_rotation: torch.Tensor,
+        velocity: torch.Tensor,
+        ang_velocity: torch.Tensor,
+        dof_pos: torch.Tensor,
+        dof_lower_limits: torch.Tensor,
+        dof_upper_limits: torch.Tensor,
+        inv_start_rot: torch.Tensor,
+        basis_vec0: torch.Tensor,
+        basis_vec1: torch.Tensor,
+        potentials: torch.Tensor,
+        prev_potentials: torch.Tensor,
+        dt: float,
+    ):
+        to_target = targets - torso_position
+        to_target[:, 2] = 0.0
 
-    torso_quat, up_proj, heading_proj, up_vec, heading_vec = (
-        lazy.isaacsim.core.utils.torch.rotations.compute_heading_and_up(
+        torso_quat, up_proj, heading_proj, up_vec, heading_vec = compute_heading_and_up_fn(
             torso_rotation, inv_start_rot, to_target, basis_vec0, basis_vec1, 2
         )
-    )
 
-    vel_loc, angvel_loc, roll, pitch, yaw, angle_to_target = lazy.isaacsim.core.utils.torch.rotations.compute_rot(
-        torso_quat, velocity, ang_velocity, targets, torso_position
-    )
+        vel_loc, angvel_loc, roll, pitch, yaw, angle_to_target = compute_rot_fn(
+            torso_quat, velocity, ang_velocity, targets, torso_position
+        )
 
-    dof_pos_scaled = lazy.isaacsim.core.utils.torch.maths.unscale(dof_pos, dof_lower_limits, dof_upper_limits)
-
-    to_target = targets - torso_position
-    to_target[:, 2] = 0.0
-    prev_potentials[:] = potentials
-    potentials = -torch.norm(to_target, p=2, dim=-1) / dt
-
-    return (
-        up_proj,
-        heading_proj,
-        up_vec,
-        heading_vec,
-        vel_loc,
-        angvel_loc,
-        roll,
-        pitch,
-        yaw,
-        angle_to_target,
-        dof_pos_scaled,
-        prev_potentials,
-        potentials,
-    )
+        dof_pos_scaled = unscale_fn(dof_pos, dof_lower_limits, dof_upper_limits)
+
+        to_target = targets - torso_position
+        to_target[:, 2] = 0.0
+        prev_potentials[:] = potentials
+        potentials = -torch.norm(to_target, p=2, dim=-1) / dt
+
+        return (
+            up_proj,
+            heading_proj,
+            up_vec,
+            heading_vec,
+            vel_loc,
+            angvel_loc,
+            roll,
+            pitch,
+            yaw,
+            angle_to_target,
+            dof_pos_scaled,
+            prev_potentials,
+            potentials,
+        )
+
+    return _compute_intermediate_values