SYMBOL INDEX (811 symbols across 82 files)

FILE: bigym/action_modes.py
  class TargetStateNotReachedWarning (line 24) | class TargetStateNotReachedWarning(Warning):
  class PelvisDof (line 30) | class PelvisDof(Enum):
  class ActionMode (line 42) | class ActionMode(ABC):
    method __init__ (line 45) | def __init__(
    method bind_robot (line 64) | def bind_robot(self, robot: Robot, mojo: Mojo):
    method floating_base (line 70) | def floating_base(self) -> bool:
    method floating_dofs (line 75) | def floating_dofs(self) -> list[PelvisDof]:
    method action_space (line 80) | def action_space(
    method step (line 87) | def step(self, action: np.ndarray):
    method reset (line 97) | def reset(self, reset_state: np.ndarray):
  class TorqueActionMode (line 105) | class TorqueActionMode(ActionMode):
    method action_space (line 115) | def action_space(
    method step (line 138) | def step(self, action: np.ndarray):
    method reset (line 151) | def reset(self, reset_state: np.ndarray):
  class JointPositionActionMode (line 173) | class JointPositionActionMode(ActionMode):
    method __init__ (line 188) | def __init__(
    method action_space (line 208) | def action_space(
    method step (line 234) | def step(self, action: np.ndarray):
    method reset (line 252) | def reset(self, reset_state: np.ndarray):
    method _step_until_reached (line 282) | def _step_until_reached(self):
    method _is_target_state_reached (line 296) | def _is_target_state_reached(self):

FILE: bigym/bigym_env.py
  class BiGymEnv (line 34) | class BiGymEnv(gym.Env):
    method __init__ (line 53) | def __init__(
    method task_name (line 134) | def task_name(self) -> str:
    method _use_pixels (line 139) | def _use_pixels(self):
    method seed (line 144) | def seed(self) -> Optional[int]:
    method success (line 149) | def success(self) -> bool:
    method fail (line 154) | def fail(self) -> bool:
    method reward (line 159) | def reward(self) -> float:
    method terminate (line 164) | def terminate(self) -> bool:
    method truncate (line 169) | def truncate(self) -> bool:
    method is_healthy (line 174) | def is_healthy(self) -> bool:
    method observation_config (line 179) | def observation_config(self) -> ObservationConfig:
    method control_frequency (line 184) | def control_frequency(self):
    method robot (line 189) | def robot(self) -> Robot:
    method floor (line 194) | def floor(self) -> Geom:
    method mojo (line 199) | def mojo(self) -> Mojo:
    method action (line 204) | def action(self) -> np.ndarray:
    method _initialize_renderers (line 208) | def _initialize_renderers(self):
    method _initialize_cameras (line 219) | def _initialize_cameras(self) -> dict[str, tuple[int, Camera]]:
    method _close_renderers (line 240) | def _close_renderers(self):
    method _initialize_env (line 248) | def _initialize_env(self):
    method get_observation_space (line 252) | def get_observation_space(self) -> spaces.Space:
    method _get_task_privileged_obs_space (line 307) | def _get_task_privileged_obs_space(self) -> dict[str, Any]:
    method get_observation (line 311) | def get_observation(self) -> dict[str, np.ndarray]:
    method _get_task_info (line 322) | def _get_task_info(self) -> dict[str, Any]:
    method get_info (line 326) | def get_info(self) -> dict[str, Any]:
    method _get_proprioception_obs (line 332) | def _get_proprioception_obs(self) -> dict[str, Any]:
    method _get_visual_obs (line 350) | def _get_visual_obs(self) -> dict[str, Any]:
    method _get_task_privileged_obs (line 367) | def _get_task_privileged_obs(self) -> dict[str, Any]:
    method _update_seed (line 371) | def _update_seed(self, override_seed=None):
    method reset (line 392) | def reset(self, *, seed: Optional[int] = None, options: Optional[dict]...
    method _on_reset (line 408) | def _on_reset(self):
    method _on_step (line 412) | def _on_step(self):
    method render (line 416) | def render(self):
    method step (line 420) | def step(
    method _step_mujoco_simulation (line 449) | def _step_mujoco_simulation(self, action):
    method _success (line 474) | def _success(self) -> bool:
    method _fail (line 478) | def _fail(self) -> bool:
    method _reward (line 484) | def _reward(self) -> float:
    method close (line 488) | def close(self):

FILE: bigym/bigym_renderer.py
  class BiGymRenderer (line 15) | class BiGymRenderer(MujocoRenderer):
    method __init__ (line 22) | def __init__(self, mojo: Mojo):
    method _get_viewer (line 26) | def _get_viewer(self, render_mode: str) -> BaseRender:
    method get_viewer (line 47) | def get_viewer(self, render_mode: str) -> BaseRender:
  class BiGymWindowViewer (line 52) | class BiGymWindowViewer(WindowViewer):
    method render (line 59) | def render(self):

FILE: bigym/const.py
  class ActuatorGroup (line 20) | class ActuatorGroup(IntEnum):
  class HandSide (line 28) | class HandSide(Enum):

FILE: bigym/envs/cupboards.py
  class _CupboardsInteractionEnv (line 14) | class _CupboardsInteractionEnv(BiGymEnv, ABC):
    method _initialize_env (line 21) | def _initialize_env(self):
  class DrawerTopOpen (line 34) | class DrawerTopOpen(_CupboardsInteractionEnv):
    method _success (line 37) | def _success(self) -> bool:
  class DrawerTopClose (line 41) | class DrawerTopClose(_CupboardsInteractionEnv):
    method _success (line 44) | def _success(self) -> bool:
    method _on_reset (line 47) | def _on_reset(self):
  class DrawersAllOpen (line 51) | class DrawersAllOpen(_CupboardsInteractionEnv):
    method _success (line 54) | def _success(self) -> bool:
  class DrawersAllClose (line 58) | class DrawersAllClose(_CupboardsInteractionEnv):
    method _success (line 61) | def _success(self) -> bool:
    method _on_reset (line 64) | def _on_reset(self):
  class WallCupboardOpen (line 68) | class WallCupboardOpen(_CupboardsInteractionEnv):
    method _success (line 71) | def _success(self) -> bool:
  class WallCupboardClose (line 75) | class WallCupboardClose(_CupboardsInteractionEnv):
    method _success (line 78) | def _success(self) -> bool:
    method _on_reset (line 81) | def _on_reset(self):
  class CupboardsOpenAll (line 85) | class CupboardsOpenAll(_CupboardsInteractionEnv):
    method _success (line 88) | def _success(self) -> bool:
  class CupboardsCloseAll (line 95) | class CupboardsCloseAll(_CupboardsInteractionEnv):
    method _success (line 98) | def _success(self) -> bool:
    method _on_reset (line 104) | def _on_reset(self):

FILE: bigym/envs/dishwasher.py
  class _DishwasherEnv (line 11) | class _DishwasherEnv(BiGymEnv, ABC):
    method _initialize_env (line 19) | def _initialize_env(self):
  class DishwasherOpen (line 23) | class DishwasherOpen(_DishwasherEnv):
    method _success (line 26) | def _success(self) -> bool:
    method _on_reset (line 29) | def _on_reset(self):
  class DishwasherClose (line 33) | class DishwasherClose(_DishwasherEnv):
    method _success (line 36) | def _success(self) -> bool:
    method _on_reset (line 39) | def _on_reset(self):
  class DishwasherCloseTrays (line 43) | class DishwasherCloseTrays(DishwasherClose):
    method _success (line 46) | def _success(self) -> bool:
  class DishwasherOpenTrays (line 50) | class DishwasherOpenTrays(DishwasherClose):
    method _success (line 53) | def _success(self) -> bool:
    method _on_reset (line 56) | def _on_reset(self):

FILE: bigym/envs/dishwasher_cups.py
  class _DishwasherCupsEnv (line 15) | class _DishwasherCupsEnv(BiGymEnv, ABC):
    method _initialize_env (line 23) | def _initialize_env(self):
    method _fail (line 28) | def _fail(self) -> bool:
    method _on_reset (line 36) | def _on_reset(self):
  class DishwasherUnloadCups (line 40) | class DishwasherUnloadCups(_DishwasherCupsEnv):
    method _success (line 52) | def _success(self) -> bool:
    method _on_reset (line 61) | def _on_reset(self):
  class DishwasherUnloadCupsLong (line 77) | class DishwasherUnloadCupsLong(DishwasherUnloadCups):
    method _initialize_env (line 85) | def _initialize_env(self):
    method _success (line 89) | def _success(self) -> bool:
  class DishwasherLoadCups (line 103) | class DishwasherLoadCups(_DishwasherCupsEnv):
    method _success (line 113) | def _success(self) -> bool:
    method _on_reset (line 122) | def _on_reset(self):

FILE: bigym/envs/dishwasher_cutlery.py
  class _DishwasherCutleryEnv (line 18) | class _DishwasherCutleryEnv(BiGymEnv, ABC):
    method _initialize_env (line 28) | def _initialize_env(self):
    method _fail (line 32) | def _fail(self) -> bool:
    method _on_reset (line 40) | def _on_reset(self):
  class _DishwasherUnloadCutleryEnv (line 44) | class _DishwasherUnloadCutleryEnv(_DishwasherCutleryEnv):
    method _on_reset (line 53) | def _on_reset(self):
  class DishwasherUnloadCutlery (line 69) | class DishwasherUnloadCutlery(_DishwasherUnloadCutleryEnv):
    method _initialize_env (line 76) | def _initialize_env(self):
    method _success (line 80) | def _success(self) -> bool:
    method _on_reset (line 89) | def _on_reset(self):
  class DishwasherUnloadCutleryLong (line 96) | class DishwasherUnloadCutleryLong(_DishwasherUnloadCutleryEnv):
    method _initialize_env (line 103) | def _initialize_env(self):
    method _success (line 108) | def _success(self) -> bool:
  class DishwasherLoadCutlery (line 122) | class DishwasherLoadCutlery(_DishwasherCutleryEnv):
    method _initialize_env (line 135) | def _initialize_env(self):
    method _success (line 139) | def _success(self) -> bool:
    method _on_reset (line 148) | def _on_reset(self):

FILE: bigym/envs/dishwasher_plates.py
  class _DishwasherPlatesEnv (line 17) | class _DishwasherPlatesEnv(BiGymEnv, ABC):
    method _initialize_env (line 36) | def _initialize_env(self):
    method _fail (line 43) | def _fail(self) -> bool:
    method _on_reset (line 51) | def _on_reset(self):
  class DishwasherUnloadPlates (line 57) | class DishwasherUnloadPlates(_DishwasherPlatesEnv):
    method _success (line 60) | def _success(self) -> bool:
    method _on_reset (line 69) | def _on_reset(self):
  class DishwasherUnloadPlatesLong (line 80) | class DishwasherUnloadPlatesLong(DishwasherUnloadPlates):
    method _initialize_env (line 91) | def _initialize_env(self):
    method _success (line 95) | def _success(self) -> bool:
  class DishwasherLoadPlates (line 103) | class DishwasherLoadPlates(_DishwasherPlatesEnv):
    method _success (line 106) | def _success(self) -> bool:
    method _on_reset (line 124) | def _on_reset(self):

FILE: bigym/envs/groceries.py
  class GroceriesStoreLower (line 14) | class GroceriesStoreLower(BiGymEnv):
    method _initialize_env (line 30) | def _initialize_env(self):
    method _on_reset (line 40) | def _on_reset(self):
    method _success (line 61) | def _success(self) -> bool:
  class GroceriesStoreUpper (line 75) | class GroceriesStoreUpper(GroceriesStoreLower):
    method _initialize_env (line 80) | def _initialize_env(self):
    method _success (line 85) | def _success(self) -> bool:

FILE: bigym/envs/manipulation.py
  class _ManipulationEnv (line 19) | class _ManipulationEnv(BiGymEnv, ABC):
    method _initialize_env (line 24) | def _initialize_env(self):
  class FlipCup (line 28) | class FlipCup(_ManipulationEnv):
    method _initialize_env (line 41) | def _initialize_env(self):
    method _success (line 45) | def _success(self) -> bool:
    method _on_reset (line 58) | def _on_reset(self):
  class FlipCutlery (line 73) | class FlipCutlery(_ManipulationEnv):
    method _initialize_env (line 90) | def _initialize_env(self):
    method _success (line 95) | def _success(self) -> bool:
    method _on_reset (line 109) | def _on_reset(self):
  class StackBlocks (line 126) | class StackBlocks(BiGymEnv):
    method _initialize_env (line 143) | def _initialize_env(self):
    method _on_reset (line 154) | def _on_reset(self):
    method _success (line 170) | def _success(self) -> bool:
    method _fail (line 184) | def _fail(self) -> bool:

FILE: bigym/envs/move_plates.py
  class _MovePlatesEnv (line 24) | class _MovePlatesEnv(BiGymEnv, ABC):
    method _initialize_env (line 34) | def _initialize_env(self):
    method _success (line 40) | def _success(self) -> bool:
    method _fail (line 64) | def _fail(self) -> bool:
    method _on_reset (line 72) | def _on_reset(self):
  class MovePlate (line 88) | class MovePlate(_MovePlatesEnv):
    method _get_task_privileged_obs_space (line 91) | def _get_task_privileged_obs_space(self):
    method _get_task_privileged_obs (line 101) | def _get_task_privileged_obs(self):
  class MoveTwoPlates (line 108) | class MoveTwoPlates(_MovePlatesEnv):
    method _get_task_privileged_obs_space (line 113) | def _get_task_privileged_obs_space(self):
    method _get_task_privileged_obs (line 116) | def _get_task_privileged_obs(self):

FILE: bigym/envs/pick_and_place.py
  class PutCups (line 17) | class PutCups(BiGymEnv):
    method _initialize_env (line 31) | def _initialize_env(self):
    method _success (line 36) | def _success(self) -> bool:
    method _on_reset (line 45) | def _on_reset(self):
  class TakeCups (line 61) | class TakeCups(PutCups):
    method _success (line 66) | def _success(self) -> bool:
  class StoreBox (line 76) | class StoreBox(BiGymEnv):
    method _initialize_env (line 85) | def _initialize_env(self):
    method _on_reset (line 89) | def _on_reset(self):
    method _success (line 95) | def _success(self) -> bool:
  class PickBox (line 104) | class PickBox(StoreBox):
    method _success (line 110) | def _success(self) -> bool:
    method _on_reset (line 118) | def _on_reset(self):
  class SaucepanToHob (line 127) | class SaucepanToHob(BiGymEnv):
    method _initialize_env (line 137) | def _initialize_env(self):
    method _success (line 141) | def _success(self) -> bool:
    method _on_reset (line 149) | def _on_reset(self):
  class StoreKitchenware (line 158) | class StoreKitchenware(BiGymEnv):
    method _initialize_env (line 168) | def _initialize_env(self):
    method _success (line 172) | def _success(self) -> bool:
    method _on_reset (line 181) | def _on_reset(self):
  class ToastSandwich (line 193) | class ToastSandwich(BiGymEnv):
    method _sandwich_anchor (line 219) | def _sandwich_anchor(self) -> Prop:
    method _initialize_env (line 222) | def _initialize_env(self):
    method _on_reset (line 231) | def _on_reset(self):
    method _success (line 250) | def _success(self) -> bool:
    method _fail (line 263) | def _fail(self) -> bool:
  class FlipSandwich (line 272) | class FlipSandwich(ToastSandwich):
    method _sandwich_anchor (line 282) | def _sandwich_anchor(self) -> Prop:
    method _success (line 285) | def _success(self) -> bool:
  class RemoveSandwich (line 298) | class RemoveSandwich(FlipSandwich):
    method _success (line 303) | def _success(self) -> bool:

FILE: bigym/envs/props/cabintets.py
  class ModularCabinet (line 15) | class ModularCabinet(CollidableProp, ABC):
    method _post_init (line 18) | def _post_init(self):
    method set_state (line 21) | def set_state(self, state: np.ndarray):
    method get_state (line 26) | def get_state(self) -> np.ndarray[float]:
    method _toggle_body (line 31) | def _toggle_body(model: mjcf.RootElement, name: str, enable: bool):
  class BaseCabinet (line 36) | class BaseCabinet(ModularCabinet):
    method _model_path (line 56) | def _model_path(self) -> Path:
    method _parse_kwargs (line 59) | def _parse_kwargs(self, kwargs: dict[str, Any]):
    method _on_loaded (line 83) | def _on_loaded(self, model: mjcf.RootElement):
  class WallCabinet (line 102) | class WallCabinet(ModularCabinet):
    method _model_path (line 112) | def _model_path(self) -> Path:
    method _parse_kwargs (line 115) | def _parse_kwargs(self, kwargs: dict[str, Any]):
    method _on_loaded (line 120) | def _on_loaded(self, model: mjcf.RootElement):
  class OpenShelf (line 132) | class OpenShelf(ModularCabinet):
    method _model_path (line 138) | def _model_path(self) -> Path:
    method _on_loaded (line 141) | def _on_loaded(self, model: mjcf.RootElement):

FILE: bigym/envs/props/cutlery.py
  class Fork (line 9) | class Fork(KinematicProp):
    method _model_path (line 13) | def _model_path(self) -> Path:
  class Knife (line 17) | class Knife(KinematicProp):
    method _model_path (line 21) | def _model_path(self) -> Path:
  class Spoon (line 25) | class Spoon(KinematicProp):
    method _model_path (line 29) | def _model_path(self) -> Path:
  class Spatula (line 33) | class Spatula(KinematicProp):
    method _model_path (line 37) | def _model_path(self) -> Path:

FILE: bigym/envs/props/dishwasher.py
  class DishwasherPart (line 14) | class DishwasherPart:
    method __init__ (line 17) | def __init__(
  class Dishwasher (line 46) | class Dishwasher(Prop):
    method _model_path (line 70) | def _model_path(self) -> Path:
    method _post_init (line 73) | def _post_init(self):
    method set_state (line 96) | def set_state(self, door: float, bottom_tray: float, middle_tray: float):
    method get_state (line 102) | def get_state(self) -> np.ndarray:

FILE: bigym/envs/props/holders.py
  class _Holder (line 11) | class _Holder(Prop, ABC):
  class CutleryTray (line 18) | class CutleryTray(_Holder):
    method _model_path (line 22) | def _model_path(self) -> Path:
  class DishDrainer (line 26) | class DishDrainer(_Holder):
    method _model_path (line 30) | def _model_path(self) -> Path:
    method _post_init (line 33) | def _post_init(self):

FILE: bigym/envs/props/items.py
  class Box (line 12) | class Box(KinematicProp):
    method _model_path (line 16) | def _model_path(self) -> Path:
  class Cube (line 20) | class Cube(KinematicProp):
    method _model_path (line 24) | def _model_path(self) -> Path:
  class Sandwich (line 28) | class Sandwich(KinematicProp):
    method _model_path (line 38) | def _model_path(self) -> Path:
    method _parse_kwargs (line 42) | def _parse_kwargs(self, kwargs: dict[str, Any]):
    method _on_loaded (line 46) | def _on_loaded(self, model: mjcf.RootElement):
  class Wine (line 53) | class Wine(KinematicProp):
    method _model_path (line 57) | def _model_path(self) -> Path:
  class Detergent (line 61) | class Detergent(KinematicProp):
    method _model_path (line 65) | def _model_path(self) -> Path:
  class Soap (line 69) | class Soap(KinematicProp):
    method _model_path (line 73) | def _model_path(self) -> Path:
  class Beer (line 77) | class Beer(KinematicProp):
    method _model_path (line 81) | def _model_path(self) -> Path:
  class Cereals (line 85) | class Cereals(KinematicProp):
    method _model_path (line 89) | def _model_path(self) -> Path:
  class Crisps (line 93) | class Crisps(KinematicProp):
    method _model_path (line 97) | def _model_path(self) -> Path:
  class Ketchup (line 101) | class Ketchup(KinematicProp):
    method _model_path (line 105) | def _model_path(self) -> Path:
  class Mustard (line 109) | class Mustard(KinematicProp):
    method _model_path (line 113) | def _model_path(self) -> Path:
  class Soda (line 117) | class Soda(KinematicProp):
    method _model_path (line 121) | def _model_path(self) -> Path:

FILE: bigym/envs/props/kitchenware.py
  class Plate (line 8) | class Plate(KinematicProp):
    method _model_path (line 12) | def _model_path(self) -> Path:
  class Mug (line 16) | class Mug(KinematicProp):
    method _model_path (line 20) | def _model_path(self) -> Path:
  class Pan (line 24) | class Pan(KinematicProp):
    method _model_path (line 28) | def _model_path(self) -> Path:
  class Saucepan (line 32) | class Saucepan(KinematicProp):
    method _model_path (line 36) | def _model_path(self) -> Path:
  class ChoppingBoard (line 40) | class ChoppingBoard(KinematicProp):
    method _model_path (line 44) | def _model_path(self) -> Path:

FILE: bigym/envs/props/preset.py
  class Preset (line 17) | class Preset:
    method __init__ (line 20) | def __init__(self, mojo: Mojo, path: Optional[Path]):
    method get_props (line 39) | def get_props(self, prop_type: Optional[Type[PT]] = None) -> list[PT]:
    method _load_prop (line 46) | def _load_prop(
    method _get_float_array (line 84) | def _get_float_array(

FILE: bigym/envs/props/prop.py
  class Prop (line 15) | class Prop(ABC):
    method __init__ (line 24) | def __init__(
    method _model_path (line 70) | def _model_path(self) -> Path:
    method _parse_kwargs (line 73) | def _parse_kwargs(self, kwargs: dict[str, Any]):
    method _on_loaded (line 77) | def _on_loaded(self, model: mjcf.RootElement):
    method _post_init (line 81) | def _post_init(self):
    method get_pose (line 85) | def get_pose(self) -> np.ndarray:
    method set_pose (line 92) | def set_pose(
    method disable (line 114) | def disable(self):
    method enable (line 125) | def enable(self):
    method get_velocities (line 136) | def get_velocities(self) -> np.ndarray:
    method is_static (line 143) | def is_static(self, atol_pos: float = 1.0e-3):
    method is_colliding (line 148) | def is_colliding(self, other: Union[Geom, Iterable[Geom], "Prop"]) -> ...
    method get_body_colliders (line 156) | def get_body_colliders(body: Body) -> list[Geom]:
    method get_body_sites (line 161) | def get_body_sites(body: Body, mojo: Mojo) -> list[Site]:
  class CollidableProp (line 167) | class CollidableProp(Prop, ABC):
  class KinematicProp (line 173) | class KinematicProp(Prop, ABC):

FILE: bigym/envs/props/tables.py
  class Table (line 9) | class Table(CollidableProp):
    method _model_path (line 13) | def _model_path(self) -> Path:
  class SmallTable (line 17) | class SmallTable(CollidableProp):
    method _model_path (line 21) | def _model_path(self) -> Path:

FILE: bigym/envs/reach_target.py
  class TargetConfig (line 17) | class TargetConfig:
  class Target (line 27) | class Target:
    method __init__ (line 30) | def __init__(self, mojo: Mojo, robot: Robot, config: TargetConfig):
    method reset_position (line 45) | def reset_position(self, offset: np.ndarray = np.zeros(3)):
    method distance (line 49) | def distance(self, pos: np.ndarray) -> float:
    method is_reached (line 53) | def is_reached(self, tolerance: float) -> bool:
    method set_highlight (line 65) | def set_highlight(self, highlight: bool):
  class _ReachTargetEnv (line 72) | class _ReachTargetEnv(BiGymEnv, ABC):
    method _initialize_env (line 87) | def _initialize_env(self):
    method _on_reset (line 92) | def _on_reset(self):
    method _success (line 98) | def _success(self) -> bool:
    method _on_step (line 104) | def _on_step(self):
  class ReachTarget (line 109) | class ReachTarget(_ReachTargetEnv):
    method _get_task_privileged_obs_space (line 112) | def _get_task_privileged_obs_space(self):
    method _get_task_privileged_obs (line 119) | def _get_task_privileged_obs(self):
  class ReachTargetSingle (line 127) | class ReachTargetSingle(ReachTarget):
  class ReachTargetDual (line 140) | class ReachTargetDual(_ReachTargetEnv):
    method _get_task_privileged_obs_space (line 158) | def _get_task_privileged_obs_space(self):
    method _get_task_privileged_obs (line 168) | def _get_task_privileged_obs(self):

FILE: bigym/robots/animated_legs.py
  class AnimatedLegs (line 15) | class AnimatedLegs(ABC):
    method __init__ (line 18) | def __init__(self, mojo: Mojo, pelvis: Body):
    method step (line 24) | def step(self, pelvis_z: float, is_moving: bool = True):
  class H1AnimatedLegs (line 29) | class H1AnimatedLegs(AnimatedLegs):
    method __init__ (line 64) | def __init__(self, mojo: Mojo, pelvis: Body):
    method step (line 78) | def step(self, pelvis_z: float, is_moving: bool = True):
    method _on_loaded (line 92) | def _on_loaded(self, model: mjcf.RootElement):
    method _get_offset (line 109) | def _get_offset(self, shift: float, scale: float) -> float:
    method _set_leg_state (line 118) | def _set_leg_state(self, leg: list[Body], state: np.ndarray):
    method _solve (line 124) | def _solve(self, pelvis_z: float, offset: float = 0.0) -> np.ndarray:

FILE: bigym/robots/config.py
  class GripperConfig (line 17) | class GripperConfig:
    method __post_init__ (line 37) | def __post_init__(self):
  class ArmConfig (line 44) | class ArmConfig:
  class FloatingBaseConfig (line 63) | class FloatingBaseConfig:
  class FullBodyConfig (line 75) | class FullBodyConfig:
  class RobotConfig (line 83) | class RobotConfig:

FILE: bigym/robots/configs/google_robot.py
  class GoogleRobot (line 86) | class GoogleRobot(Robot):
    method config (line 90) | def config(self) -> RobotConfig:

FILE: bigym/robots/configs/h1.py
  class H1 (line 173) | class H1(Robot):
    method config (line 177) | def config(self) -> RobotConfig:
  class H1FineManipulation (line 182) | class H1FineManipulation(Robot):
    method config (line 186) | def config(self) -> RobotConfig:

FILE: bigym/robots/configs/stretch.py
  class StretchRobot (line 86) | class StretchRobot(Robot):
    method config (line 90) | def config(self) -> RobotConfig:

FILE: bigym/robots/floating_base.py
  class RobotFloatingBase (line 21) | class RobotFloatingBase:
    method __init__ (line 27) | def __init__(
    method reset (line 90) | def reset(self, position: np.ndarray, quaternion: np.ndarray):
    method get_action_bounds (line 100) | def get_action_bounds(self) -> list[tuple[float, float]]:
    method set_control (line 111) | def set_control(self, control: np.ndarray):
    method is_target_reached (line 138) | def is_target_reached(self) -> bool:
    method dof_amount (line 153) | def dof_amount(self) -> int:
    method qpos (line 158) | def qpos(self) -> np.ndarray:
    method qvel (line 170) | def qvel(self) -> np.ndarray:
    method get_accumulated_actions (line 182) | def get_accumulated_actions(self) -> np.ndarray:
    method all_actuators (line 187) | def all_actuators(self) -> list[mjcf.Element]:
    method position_actuators (line 194) | def position_actuators(self) -> list[Optional[mjcf.Element]]:
    method rotation_actuators (line 199) | def rotation_actuators(self) -> list[Optional[mjcf.Element]]:
    method _pelvis_z (line 204) | def _pelvis_z(self) -> float:
    method _set_position (line 212) | def _set_position(self, position: np.ndarray):
    method _set_quaternion (line 216) | def _set_quaternion(self, quaternion: np.ndarray):
    method _set_value (line 220) | def _set_value(self, position: bool, values: np.ndarray):
    method _add_actuator (line 238) | def _add_actuator(self, positional: bool, axis: np.ndarray, actuator: ...

FILE: bigym/robots/gripper.py
  class Gripper (line 16) | class Gripper:
    method __init__ (line 22) | def __init__(
    method body (line 57) | def body(self) -> Body:
    method wrist_site (line 62) | def wrist_site(self) -> Site:
    method pinch_position (line 67) | def pinch_position(self) -> np.ndarray:
    method wrist_position (line 72) | def wrist_position(self) -> np.ndarray:
    method range (line 77) | def range(self) -> np.ndarray:
    method actuators (line 82) | def actuators(self) -> list[mjcf.Element]:
    method qpos (line 87) | def qpos(self) -> float:
    method qvel (line 98) | def qvel(self) -> float:
    method is_holding_object (line 106) | def is_holding_object(self, other: Union[Geom, Iterable[Geom], Prop]) ...
    method set_control (line 112) | def set_control(self, ctrl: float):
    method _on_loaded (line 123) | def _on_loaded(self, model: mjcf.RootElement):
    method _process_gripper (line 127) | def _process_gripper(
    method _get_pad_geoms (line 159) | def _get_pad_geoms(self) -> list[Geom]:

FILE: bigym/robots/robot.py
  class ActuatorType (line 33) | class ActuatorType(Enum):
  class Robot (line 41) | class Robot(ABC):
    method __init__ (line 44) | def __init__(
    method config (line 66) | def config(self) -> RobotConfig:
    method action_mode (line 71) | def action_mode(self) -> ActionMode:
    method pelvis (line 76) | def pelvis(self) -> Body:
    method limb_actuators (line 81) | def limb_actuators(self) -> list[mjcf.Element]:
    method grippers (line 86) | def grippers(self) -> dict[HandSide, Gripper]:
    method floating_base (line 91) | def floating_base(self) -> Optional[RobotFloatingBase]:
    method cameras (line 96) | def cameras(self) -> list[Camera]:
    method qpos (line 101) | def qpos(self) -> np.ndarray:
    method qpos_grippers (line 108) | def qpos_grippers(self) -> np.ndarray:
    method qpos_actuated (line 116) | def qpos_actuated(self) -> np.ndarray:
    method qvel (line 127) | def qvel(self) -> np.ndarray:
    method qvel_actuated (line 134) | def qvel_actuated(self) -> np.ndarray:
    method get_hand_pos (line 145) | def get_hand_pos(self, side: HandSide) -> np.ndarray:
    method is_gripper_holding_object (line 151) | def is_gripper_holding_object(
    method reset (line 159) | def reset(self, position: np.ndarray, orientation: np.ndarray):
    method _set_pose (line 170) | def _set_pose(self, position: np.ndarray, orientation: np.ndarray):
    method get_limb_control_range (line 178) | def get_limb_control_range(
    method _get_grippers (line 187) | def _get_grippers(self) -> dict[HandSide, Gripper]:
    method _get_joints (line 199) | def _get_joints(self) -> list[Joint]:
    method _on_loaded (line 204) | def _on_loaded(self, model: mjcf.RootElement):
    method _add_wrist (line 317) | def _add_wrist(model: mjcf.RootElement, side: HandSide, arm_config: Ar...

FILE: bigym/utils/callables_cache.py
  class CallablesCache (line 7) | class CallablesCache:
    method __init__ (line 10) | def __init__(self):
    method get (line 15) | def get(self, func: Callable) -> Any:
    method clean (line 26) | def clean(self):

FILE: bigym/utils/dof.py
  class Dof (line 9) | class Dof:

FILE: bigym/utils/env_health.py
  class UnstableSimulationWarning (line 9) | class UnstableSimulationWarning(UserWarning):
  class UnstableSimulationError (line 13) | class UnstableSimulationError(RuntimeError):
  class EnvHealth (line 17) | class EnvHealth:
    method __init__ (line 26) | def __init__(self):
    method reset (line 31) | def reset(self):
    method track (line 38) | def track(self):
    method is_healthy (line 55) | def is_healthy(self) -> bool:

FILE: bigym/utils/env_utils.py
  function get_random_sites (line 7) | def get_random_sites(
  function get_random_points_on_plane (line 38) | def get_random_points_on_plane(

FILE: bigym/utils/observation_config.py
  class CameraConfig (line 7) | class CameraConfig:
    method __post_init__ (line 17) | def __post_init__(self):
    method from_safetensors_metadata (line 32) | def from_safetensors_metadata(cls, metadata: dict):
    method to_string (line 38) | def to_string(self):
  class ObservationConfig (line 50) | class ObservationConfig:
    method from_safetensors_metadata (line 58) | def from_safetensors_metadata(cls, metadata: dict):

FILE: bigym/utils/physics_utils.py
  function get_critical_damping_from_stiffness (line 13) | def get_critical_damping_from_stiffness(
  function is_target_reached (line 31) | def is_target_reached(actuator: mjcf.Element, physics: mjcf.Physics, tol...
  function distance (line 40) | def distance(element1: MujocoElement, element2: MujocoElement):
  function set_joint_position (line 46) | def set_joint_position(joint: Joint, value: float, normalized: bool = Fa...
  function get_joint_position (line 58) | def get_joint_position(joint: Joint, normalized: bool = False) -> float:
  function get_actuator_qpos (line 67) | def get_actuator_qpos(actuator: mjcf.Element, physics: mjcf.Physics) -> ...
  function get_actuator_qvel (line 77) | def get_actuator_qvel(actuator: mjcf.Element, physics: mjcf.Physics) -> ...
  function get_colliders (line 91) | def get_colliders(obj: Union[Geom, Iterable[Geom], Any]) -> Iterable[Geom]:
  function has_collided_collections (line 108) | def has_collided_collections(

FILE: bigym/utils/robot_highlighter.py
  class RobotHighlighter (line 12) | class RobotHighlighter:
    method __init__ (line 15) | def __init__(self, robot: Robot, mojo: Mojo):
    method reset (line 39) | def reset(self):
    method highlight (line 45) | def highlight(self, index: int, tint: np.ndarray = np.array([1, 1, 1, ...

FILE: bigym/utils/shared.py
  function find_class_in_module (line 11) | def find_class_in_module(module: ModuleType, class_name: str) -> Optiona...
  function find_constant_in_module (line 16) | def find_constant_in_module(module: ModuleType, constant_name: str) -> O...
  function _find_member_in_module (line 21) | def _find_member_in_module(

FILE: demonstrations/demo.py
  class DemoStep (line 40) | class DemoStep:
    method __init__ (line 49) | def __init__(self, observation, reward, termination, truncation, info,...
    method executed_action (line 68) | def executed_action(self) -> ActType:
    method set_executed_action (line 72) | def set_executed_action(self, action):
    method has_visual_observations (line 78) | def has_visual_observations(self) -> bool:
    method visual_observations (line 86) | def visual_observations(self) -> dict[str, np.ndarray]:
  class Demo (line 95) | class Demo:
    method __init__ (line 98) | def __init__(
    method from_safetensors (line 116) | def from_safetensors(
    method from_env (line 146) | def from_env(cls, env: BiGymEnv) -> Demo:
    method load_timesteps_from_safetensors (line 160) | def load_timesteps_from_safetensors(
    method _saving_format (line 226) | def _saving_format(self):
    method save (line 249) | def save(self, path: Union[str, Path]) -> Path:
    method timesteps (line 290) | def timesteps(self) -> list[DemoStep]:
    method duration (line 295) | def duration(self) -> int:
    method seed (line 300) | def seed(self):
    method metadata (line 305) | def metadata(self) -> Metadata:
    method uuid (line 310) | def uuid(self):
    method safetensor_metadata (line 315) | def safetensor_metadata(self):
    method add_timestep (line 319) | def add_timestep(self, observation, reward, termination, truncation, i...
    method add_termination_steps (line 333) | def add_termination_steps(self, steps_count: int):
  class LightweightDemo (line 339) | class LightweightDemo(Demo):
    method __init__ (line 342) | def __init__(
    method from_safetensors (line 361) | def from_safetensors(
    method from_demo (line 394) | def from_demo(cls, demo: Demo) -> LightweightDemo:
    method from_env (line 409) | def from_env(cls, env: BiGymEnv) -> Demo:
    method _saving_format (line 423) | def _saving_format(self):
    method add_timestep (line 442) | def add_timestep(self, observation, reward, termination, truncation, i...
    method lighten_timesteps (line 457) | def lighten_timesteps(timesteps: list[DemoStep]) -> list[DemoStep]:

FILE: demonstrations/demo_converter.py
  class DemoConverter (line 17) | class DemoConverter:
    method absolute_to_delta (line 21) | def absolute_to_delta(demo: Demo) -> Demo:
    method clip_actions (line 70) | def clip_actions(demo: Demo, action_scale: float = 1) -> Demo:
    method decimate (line 83) | def decimate(
    method create_demo_in_new_env (line 140) | def create_demo_in_new_env(

FILE: demonstrations/demo_player.py
  class DemoPlayer (line 11) | class DemoPlayer:
    method replay (line 15) | def replay(
    method replay_in_env (line 26) | def replay_in_env(
    method validate (line 40) | def validate(
    method validate_in_env (line 50) | def validate_in_env(
    method _get_timesteps_for_replay (line 67) | def _get_timesteps_for_replay(

FILE: demonstrations/demo_recorder.py
  class DemoRecorder (line 10) | class DemoRecorder:
    method __init__ (line 13) | def __init__(self, demo_dir: Optional[Union[str, Path]] = None):
    method __del__ (line 30) | def __del__(self):
    method record (line 35) | def record(self, env: BiGymEnv, lightweight_demo: bool = False):
    method stop (line 51) | def stop(self):
    method add_timestep (line 56) | def add_timestep(self, timestep: tuple, action):
    method timesteps (line 67) | def timesteps(self) -> list[DemoStep]:
    method demo (line 72) | def demo(self) -> Optional[Demo]:
    method save_demo (line 76) | def save_demo(self, filename: Optional[str] = None) -> Optional[Path]:
    method is_recording (line 97) | def is_recording(self):

FILE: demonstrations/demo_store.py
  class DemoNotFoundError (line 24) | class DemoNotFoundError(Exception):
    method __init__ (line 27) | def __init__(self, metadata: Metadata):
  class TooManyDemosRequestedError (line 37) | class TooManyDemosRequestedError(Exception):
    method __init__ (line 40) | def __init__(self, requested: int, found: int):
  class DemoStore (line 55) | class DemoStore:
    method __init__ (line 61) | def __init__(self, cache_root: Optional[Path] = None):
    method cache_demo (line 67) | def cache_demo(self, demo: Demo, frequency: Optional[int] = None):
    method _cache_demo_file (line 84) | def _cache_demo_file(self, demo_path: Path, frequency: Optional[int] =...
    method get_demos (line 90) | def get_demos(
    method _get_demos (line 161) | def _get_demos(self, demos_dir: Path, amount: int) -> list[Demo]:
    method _get_demos_count (line 173) | def _get_demos_count(self, demos_dir: Path) -> int:
    method pull_demos (line 179) | def pull_demos(self):
    method cached (line 200) | def cached(self):
    method cached (line 206) | def cached(self, value: bool):
    method list_demo_paths (line 214) | def list_demo_paths(self, metadata: Metadata) -> list[Path]:
    method _create_path (line 222) | def _create_path(self, metadata: Metadata, frequency: Optional[int] = ...
    method light_demo_exists (line 238) | def light_demo_exists(
    method demo_exists (line 256) | def demo_exists(

FILE: demonstrations/utils.py
  class ObservationMode (line 37) | class ObservationMode(Enum):
  class Metadata (line 46) | class Metadata:
    method from_safetensors (line 61) | def from_safetensors(cls, demo_path: Path):
    method from_env (line 75) | def from_env(cls, env: BiGymEnv, is_lightweight: bool = False):
    method from_env_cls (line 94) | def from_env_cls(
    method ready_for_safetensors (line 125) | def ready_for_safetensors(self) -> dict:
    method env_name (line 137) | def env_name(self) -> str:
    method filename (line 142) | def filename(self) -> str:
    method floating_dof_count (line 147) | def floating_dof_count(self) -> int:
    method env_cls (line 154) | def env_cls(self) -> Type[BiGymEnv]:
    method robot_cls (line 159) | def robot_cls(self) -> Type[Robot]:
    method action_mode_cls (line 164) | def action_mode_cls(self) -> Type[ActionMode]:
    method _check_package_versions (line 168) | def _check_package_versions(self):
    method get_env (line 179) | def get_env(
    method get_action_mode (line 191) | def get_action_mode(self) -> ActionMode:
    method get_action_space (line 216) | def get_action_space(self, action_scale: float) -> spaces.Box:
    method get_robot (line 222) | def get_robot(self) -> Robot:
  class EnvData (line 228) | class EnvData:
    method __post_init__ (line 240) | def __post_init__(self):
    method from_safetensors_metadata (line 250) | def from_safetensors_metadata(cls, metadata: dict):
    method from_env (line 258) | def from_env(cls, env: BiGymEnv):
    method action_mode_description (line 284) | def action_mode_description(self) -> str:
    method camera_description (line 296) | def camera_description(self) -> str:
    method env_cls (line 305) | def env_cls(self) -> Type[BiGymEnv]:
    method action_mode_cls (line 315) | def action_mode_cls(self) -> Type[ActionMode]:
    method robot_cls (line 327) | def robot_cls(self) -> Type[Robot]:
  function get_package_version (line 337) | def get_package_version(package_name: str) -> Optional[str]:
  function decode_safetensors_metadata (line 345) | def decode_safetensors_metadata(metadata: dict) -> dict:
  function clean_metadata (line 365) | def clean_metadata(metadata: dict, cls: Type[dataclass]) -> dict:

FILE: doc/scripts/download_and_validate_demos.py
  function validate_all_demos (line 34) | def validate_all_demos(env_cls: Type[BiGymEnv]):

FILE: doc/scripts/preview_renderer.py
  class Resolution (line 20) | class Resolution(enum.Enum):
  class PreviewRenderer (line 29) | class PreviewRenderer:
    method render (line 30) | def render(
    method render_demo (line 70) | def render_demo(
    method _env_name (line 109) | def _env_name(env_cls: Type[BiGymEnv]) -> str:
    method _get_output_dir (line 113) | def _get_output_dir() -> Path:

FILE: doc/scripts/render_demos.py
  function get_camera (line 19) | def get_camera() -> mujoco.MjvCamera:

FILE: examples/record_and_replay_demo.py
  function update_plots (line 22) | def update_plots(axs, requested, expected, actual, xlim=None, ylim=None):
  function init_subplots (line 39) | def init_subplots(n):

FILE: setup.py
  function read (line 8) | def read(rel_path):
  function get_version (line 14) | def get_version(rel_path):

FILE: tests/conftest.py
  function pytest_addoption (line 4) | def pytest_addoption(parser):
  function pytest_collection_modifyitems (line 10) | def pytest_collection_modifyitems(config, items):

FILE: tests/tasks/test_move_plate.py
  class TestMovePlate (line 14) | class TestMovePlate:
    method test_terminates_when_plate_is_on_the_ground (line 15) | def test_terminates_when_plate_is_on_the_ground(

FILE: tests/tasks/test_stack_blocks.py
  class TestStackBlocks (line 13) | class TestStackBlocks:
    method test_terminates_when_any_block_is_on_the_ground (line 14) | def test_terminates_when_any_block_is_on_the_ground(

FILE: tests/tasks/test_tasks.py
  class TestEnvs (line 19) | class TestEnvs:
    method test_terminates_when_robot_out_of_bounds (line 20) | def test_terminates_when_robot_out_of_bounds(

FILE: tests/test_action_modes.py
  function test_join_position_absolute_block_until_reached (line 18) | def test_join_position_absolute_block_until_reached():
  function test_floating_base (line 47) | def test_floating_base():
  class TestActionModeStability (line 72) | class TestActionModeStability:
    method run_simulation (line 76) | def run_simulation(self, env: BiGymEnv, action: np.ndarray):
    method test_action_space_is_stable (line 81) | def test_action_space_is_stable(self, action_mode: ActionMode):
    method test_action_space_raises_when_beyond_bounds (line 88) | def test_action_space_raises_when_beyond_bounds(self, action_mode: Act...

FILE: tests/test_demo_store.py
  function temp_demo_store (line 42) | def temp_demo_store():
  class TestDemoStore (line 49) | class TestDemoStore:
    method record_demo (line 53) | def record_demo(
    method generate_demos (line 69) | def generate_demos(
    method test_upload_and_download_of_a_demo (line 103) | def test_upload_and_download_of_a_demo(self, temp_demo_store):
    method _test_upload_and_download_multiple_demos (line 115) | def _test_upload_and_download_multiple_demos(
    method test_upload_and_download_of_demos (line 161) | def test_upload_and_download_of_demos(self, temp_demo_store):
    method test_upload_and_download_of_demos_with_multiple_envs (line 170) | def test_upload_and_download_of_demos_with_multiple_envs(self, temp_de...
    method test_upload_and_download_of_demos_with_multiple_action_modes (line 179) | def test_upload_and_download_of_demos_with_multiple_action_modes(
    method test_upload_and_download_of_demos_with_multiple_obs_modes (line 190) | def test_upload_and_download_of_demos_with_multiple_obs_modes(
    method test_correct_file_structure (line 201) | def test_correct_file_structure(self, temp_demo_store):
    method test_get_demo_with_new_observations (line 238) | def test_get_demo_with_new_observations(self, temp_demo_store):
    method test_retrieve_n_demos (line 285) | def test_retrieve_n_demos(self, temp_demo_store):
    method test_implicit_saving_of_lightweight_demos (line 314) | def test_implicit_saving_of_lightweight_demos(self, temp_demo_store):
    method test_exception_thrown_if_demos_do_not_exist (line 319) | def test_exception_thrown_if_demos_do_not_exist(self, temp_demo_store):
    method test_exception_thrown_if_lightweight_demos_do_not_exist (line 328) | def test_exception_thrown_if_lightweight_demos_do_not_exist(self, temp...
    method test_exception_thrown_if_too_many_demos_requested (line 337) | def test_exception_thrown_if_too_many_demos_requested(self, temp_demo_...
  function _generate_simple_demo (line 344) | def _generate_simple_demo():

FILE: tests/test_demos.py
  function assert_timesteps_equal (line 20) | def assert_timesteps_equal(d1: Demo, d2: Demo, atol=1e-6) -> None:
  class TestDemos (line 41) | class TestDemos:
    method record_demo (line 45) | def record_demo(env: BiGymEnv, recorder: DemoRecorder, length: int = 10):
    method assert_replay_observations (line 55) | def assert_replay_observations(env: BiGymEnv, demo: Demo, atol=1e-6) -...
    method test_save_and_load_demo (line 63) | def test_save_and_load_demo(self, env_class, action_mode):
  function test_action_conversion (line 74) | def test_action_conversion():
  function test_demo_env_conversion (line 91) | def test_demo_env_conversion():
  function test_save_and_load_lightweight_demo (line 132) | def test_save_and_load_lightweight_demo():
  function test_recreation_from_lightweight_demo (line 148) | def test_recreation_from_lightweight_demo():
  function test_long_running_demo (line 198) | def test_long_running_demo():

FILE: tests/test_envs.py
  class TestEnvs (line 25) | class TestEnvs:
    method _assert_observations (line 26) | def _assert_observations(self, observation_space: spaces.Dict, observa...
    method _assert_step_data (line 32) | def _assert_step_data(self, observation_space, obs, rew, term, trunc, ...
    method _are_observations_equal (line 40) | def _are_observations_equal(obs1, obs2):
    method test_can_step_with_floating_base (line 44) | def test_can_step_with_floating_base(
    method test_can_step_without_floating_base (line 58) | def test_can_step_without_floating_base(
    method test_can_step_and_render_human_mode (line 72) | def test_can_step_and_render_human_mode(
    method test_can_step_and_render_rgb_array_mode (line 81) | def test_can_step_and_render_rgb_array_mode(
    method test_can_get_pixel_observations (line 92) | def test_can_get_pixel_observations(
    method test_seed_generation (line 119) | def test_seed_generation(
    method test_reset_with_seed (line 136) | def test_reset_with_seed(
    method test_correct_task_name_in_vr_env (line 154) | def test_correct_task_name_in_vr_env(

FILE: tests/test_observations.py
  class TestObservations (line 25) | class TestObservations:
    method test_visual_observations_exist (line 28) | def test_visual_observations_exist(self, rgb, depth, resolution):
  function test_no_visual_observations (line 53) | def test_no_visual_observations():
  function test_camera_pose_config (line 64) | def test_camera_pose_config():

FILE: tests/test_unstable_simulation.py
  function run_simulation (line 21) | def run_simulation(
  function test_unstable_simulation_warns (line 38) | def test_unstable_simulation_warns():
  function test_unstable_simulation_is_truncated (line 46) | def test_unstable_simulation_is_truncated():
  function test_unstable_simulation_consecutive_warnings (line 55) | def test_unstable_simulation_consecutive_warnings():
  function test_unstable_simulation_non_consecutive_warnings (line 66) | def test_unstable_simulation_non_consecutive_warnings():
  function test_gripper_model_is_stable (line 87) | def test_gripper_model_is_stable():

FILE: tools/demo_player/demo_converter_window.py
  class DemoConverterWindow (line 18) | class DemoConverterWindow(BaseWindow):
    method __init__ (line 21) | def __init__(self):
    method _setup_ui (line 27) | def _setup_ui(self):
    method _re_record (line 88) | def _re_record(self):
    method _convert (line 91) | def _convert(self):
    method _process_demos (line 98) | def _process_demos(self, demo_converter: Callable[[Demo], Demo] = None):
    method _update_progress (line 125) | def _update_progress(self, current, total):
    method _update_metadata (line 129) | def _update_metadata(self, metadata: Metadata):
    method _start_processing (line 136) | def _start_processing(self):
    method _finish_processing (line 141) | def _finish_processing(self):
    method _select_directory_callback (line 147) | def _select_directory_callback(self):
    method _on_target_dir_selected (line 150) | def _on_target_dir_selected(self, target_path: Path):
    method _set_target_dir (line 154) | def _set_target_dir(self, target_path: Path):
    method show (line 158) | def show(self, source_dir: Path):
    method _show_window (line 166) | def _show_window(self):

FILE: tools/demo_player/demo_player_rendering.py
  class DemoPlayerRenderer (line 14) | class DemoPlayerRenderer(BiGymRenderer):
    method __init__ (line 21) | def __init__(self, mojo: Mojo):
    method _get_viewer (line 26) | def _get_viewer(self, render_mode: Optional[str] = None):
    method close (line 31) | def close(self):
    method set_demo_data (line 36) | def set_demo_data(self, demo_info: DemoStep, actual_info: DemoStep):
  class DemoPlayerWindowViewer (line 41) | class DemoPlayerWindowViewer(BiGymWindowViewer):
    method __init__ (line 44) | def __init__(
    method set_step_data (line 54) | def set_step_data(self, demo_info: DemoStep, actual_info: DemoStep):
    method _create_overlay (line 59) | def _create_overlay(self):
    method _add_step_info (line 69) | def _add_step_info(self, position, step: DemoStep):
    method _format_value (line 77) | def _format_value(self, value) -> str:
    method _float_formatter (line 86) | def _float_formatter(value):

FILE: tools/demo_player/demo_player_window.py
  class DemosTableRow (line 25) | class DemosTableRow:
  class DemosTable (line 36) | class DemosTable:
    method __init__ (line 39) | def __init__(self):
    method populate (line 85) | def populate(self, demo_files: list[Path]):
    method clean (line 91) | def clean(self):
    method get_selected_demos (line 97) | def get_selected_demos(self) -> list[Path]:
    method update_demo_data (line 105) | def update_demo_data(
    method _add_row (line 122) | def _add_row(self, demo_file: Path):
    method _row_selected_callback (line 168) | def _row_selected_callback(self, sender, app_data, user_data: int):
  class DemoPlayerWindow (line 175) | class DemoPlayerWindow(BaseWindow):
    method __init__ (line 184) | def __init__(self):
    method _setup_ui (line 191) | def _setup_ui(self):
    method on_close (line 221) | def on_close(self):
    method _stop_demo_replay (line 225) | def _stop_demo_replay(self):
    method _start_demo_replay (line 231) | def _start_demo_replay(self, demo_path: Path):
    method _run_demo (line 241) | def _run_demo(self, demo: Demo):
    method _run_env (line 245) | def _run_env(self, demo: Demo):
    method _select_directory_callback (line 283) | def _select_directory_callback(self):
    method _on_directory_selected (line 286) | def _on_directory_selected(self, selected_path: Path):
    method _update_files_list (line 290) | def _update_files_list(self):
    method _replay_selected_callback (line 298) | def _replay_selected_callback(self):
    method _pull_demos_callback (line 308) | def _pull_demos_callback():
    method _get_frequency (line 311) | def _get_frequency(self) -> int:
    method _current_dir (line 315) | def _current_dir(self) -> Optional[Path]:
    method _current_dir (line 324) | def _current_dir(self, value):

FILE: tools/demo_player/main.py
  class DemoPlayer (line 8) | class DemoPlayer:
    method __init__ (line 11) | def __init__(self):

FILE: tools/demo_recorder/demo_recorder_window.py
  class DemoRecorder (line 27) | class DemoRecorder:
    method __init__ (line 32) | def __init__(self, target_dir: Path):
    method is_running (line 48) | def is_running(self) -> bool:
    method target_dir (line 53) | def target_dir(self) -> Path:
    method target_dir (line 58) | def target_dir(self, value: Path):
    method set_env_cls (line 62) | def set_env_cls(self, env_cls_name: str):
    method toggle_floating_dof (line 67) | def toggle_floating_dof(self, dof_name: str, active: bool):
    method get_active_floating_dofs (line 72) | def get_active_floating_dofs(self) -> list[PelvisDof]:
    method get_floating_dofs (line 76) | def get_floating_dofs(self) -> dict[PelvisDof, bool]:
    method get_robots (line 80) | def get_robots(self) -> list[str]:
    method set_robot (line 84) | def set_robot(self, robot_name: str):
    method get_control_profiles (line 88) | def get_control_profiles(self) -> list[str]:
    method set_control_profile (line 92) | def set_control_profile(self, profile_name: str):
    method get_env_names (line 97) | def get_env_names(filter_string: str = "") -> list[str]:
    method start_viewer (line 104) | def start_viewer(self, on_started: Optional[Callable] = None) -> bool:
    method _run_vr_viewer (line 140) | def _run_vr_viewer(
    method stop_viewer (line 164) | def stop_viewer(self, on_stopped: Optional[Callable] = None):
  class DemoRecorderWindow (line 176) | class DemoRecorderWindow(BaseWindow):
    method __init__ (line 179) | def __init__(self):
    method _setup_ui (line 184) | def _setup_ui(self):
    method _filter_env_names (line 240) | def _filter_env_names(self, sender, filter_string: str = ""):
    method _configure_recorder (line 244) | def _configure_recorder(self):
    method _change_target_dir (line 251) | def _change_target_dir(self):
    method _set_target_dir (line 254) | def _set_target_dir(self, target_dir: Path):
    method _start (line 258) | def _start(self):
    method _on_started (line 267) | def _on_started(self, popup: int):
    method _stop (line 272) | def _stop(self):
    method _on_stopped (line 278) | def _on_stopped(self, popup: int):
    method _exit (line 289) | def _exit():

FILE: tools/demo_recorder/main.py
  class DemoRecorder (line 7) | class DemoRecorder:
    method __init__ (line 10) | def __init__(self):

FILE: tools/shared/base_window.py
  class BaseWindow (line 9) | class BaseWindow(ABC):
    method __init__ (line 12) | def __init__(self):
    method _setup_ui (line 17) | def _setup_ui(self):
    method _select_directory (line 21) | def _select_directory(
    method _show_popup (line 36) | def _show_popup(
    method on_close (line 74) | def on_close(self):

FILE: tools/shared/primary_window.py
  class PrimaryWindow (line 9) | class PrimaryWindow:
    method __init__ (line 12) | def __init__(

FILE: tools/shared/settings_shelf.py
  class SettingsShelf (line 10) | class SettingsShelf:
    method __init__ (line 16) | def __init__(self, file_name: str):
    method get (line 26) | def get(self, key: str, default: Any) -> Any:
    method set (line 31) | def set(self, key: str, value: Any):

FILE: tools/shared/utils.py
  class ReplayMode (line 66) | class ReplayMode(Enum):
  function get_demos_in_dir (line 135) | def get_demos_in_dir(directory: Path) -> list[Path]:
  function select_directory (line 141) | def select_directory(default_path: Union[Path, str], callback: Callable[...
  function show_popup (line 155) | def show_popup(

FILE: vr/ik/h1_upper_body_ik.py
  class Pose (line 39) | class Pose:
  class H1UpperBodyIK (line 47) | class H1UpperBodyIK:
    method __init__ (line 56) | def __init__(self, env: BiGymEnv):
    method solve (line 157) | def solve(
    method _generate_ee_actuators (line 205) | def _generate_ee_actuators(self, site: str, origin: str):
    method _get_site_quaternion (line 237) | def _get_site_quaternion(self, site: mjcf.Element) -> Quaternion:

FILE: vr/viewer/__init__.py
  class Side (line 5) | class Side(enum.IntEnum):

FILE: vr/viewer/control_profiles/control_profile.py
  class ControlProfile (line 18) | class ControlProfile(ABC):
    method __init__ (line 21) | def __init__(self, env: BiGymEnv):
    method get_next_action (line 26) | def get_next_action(
    method reset (line 42) | def reset(self):
    method _get_controller_pose (line 47) | def _get_controller_pose(
    method _get_hmd_pose (line 56) | def _get_hmd_pose(

FILE: vr/viewer/control_profiles/h1_floating.py
  class H1Floating (line 15) | class H1Floating(ControlProfile):
    method __init__ (line 31) | def __init__(self, env: BiGymEnv):
    method get_next_action (line 38) | def get_next_action(

FILE: vr/viewer/control_profiles/universal_floating.py
  class UniversalFloating (line 15) | class UniversalFloating(ControlProfile):
    method __init__ (line 31) | def __init__(self, env: BiGymEnv):
    method get_next_action (line 54) | def get_next_action(
    method _get_base_control (line 71) | def _get_base_control(self, turn: float, forward: float, steps: int) -...
    method _get_joints_control (line 91) | def _get_joints_control(self, value: float, steps: int) -> np.ndarray:
    method _joystick_value (line 108) | def _joystick_value(self, value: float) -> float:
    method _toggle_control_mode (line 112) | def _toggle_control_mode(self):
    method _toggle_target_joint (line 116) | def _toggle_target_joint(self):
    method _indicate_control_mode (line 124) | def _indicate_control_mode(self):

FILE: vr/viewer/controller.py
  class ControllerState (line 32) | class ControllerState:
    method __init__ (line 35) | def __init__(self):
    method a_clicked (line 54) | def a_clicked(self):
    method b_clicked (line 59) | def b_clicked(self):
    method trigger_clicked (line 64) | def trigger_clicked(self):
  class Controller (line 69) | class Controller:
    method __init__ (line 72) | def __init__(
    method set_context (line 84) | def set_context(self, context: XRContextObject):
    method update (line 88) | def update(self, space_offset: Posef):
    method vibrate (line 105) | def vibrate(self):

FILE: vr/viewer/full_screen_renderer.py
  class VRFullScreenRenderer (line 37) | class VRFullScreenRenderer:
    method __init__ (line 40) | def __init__(self, width: int, height: int):
    method _create_shader (line 60) | def _create_shader() -> int:
    method _create_texture (line 73) | def _create_texture() -> int:
    method _update_texture (line 84) | def _update_texture(texture_id, width, height, data):
    method render (line 98) | def render(self, side: Side, pixels: np.array):

FILE: vr/viewer/pyopenxr_to_mujoco_converter.py
  function vector_from_pyopenxr (line 8) | def vector_from_pyopenxr(xr_vector: [Vector3f, np.array]) -> np.ndarray:
  function quaternion_from_pyopenxr (line 25) | def quaternion_from_pyopenxr(xr_quaternion: Quaternionf) -> np.ndarray:
  function camera_axes_from_pyopenxr (line 34) | def camera_axes_from_pyopenxr(

FILE: vr/viewer/vr_mujoco_renderer.py
  class Renderer (line 20) | class Renderer(mujoco.Renderer):
    method __init__ (line 23) | def __init__(
  class VRMujocoRenderer (line 41) | class VRMujocoRenderer:
    method __init__ (line 44) | def __init__(self, mojo: Mojo, height: int, width: int):
    method _scene (line 66) | def _scene(self) -> mujoco.MjvScene:
    method set_context (line 69) | def set_context(self, context: XRContextObject):
    method show_stats (line 74) | def show_stats(
    method add_marker (line 91) | def add_marker(self, **marker_params):
    method render (line 95) | def render(self, frame_state: FrameState, offset: Posef):
    method _render_mujoco_env (line 103) | def _render_mujoco_env(self) -> np.array:
    method _sync_mujoco_vr_cameras_with_views (line 110) | def _sync_mujoco_vr_cameras_with_views(self, views: list[View], offset...
    method _add_marker_to_scene (line 141) | def _add_marker_to_scene(self, marker: dict):

FILE: vr/viewer/vr_viewer.py
  class Resolution (line 30) | class Resolution(Enum):
  class VRViewerStats (line 39) | class VRViewerStats:
  class Countdown (line 51) | class Countdown:
    method __init__ (line 54) | def __init__(self, delay: int):
    method step (line 58) | def step(self):
    method is_up (line 64) | def is_up(self) -> bool:
  class VRViewer (line 69) | class VRViewer:
    method __init__ (line 79) | def __init__(
    method _vr_env (line 120) | def _vr_env(self, env_cls: Type[BiGymEnv]) -> Type[BiGymEnv]:
    method run (line 153) | def run(
    method _get_action (line 186) | def _get_action(self, steps_count: int) -> np.ndarray:
    method _handle_input (line 195) | def _handle_input(self, context: XRContextObject):
    method _render_frame (line 211) | def _render_frame(self, frame_state: FrameState):
    method _start_recording (line 215) | def _start_recording(self):
    method _stop_recording (line 224) | def _stop_recording(self):
    method _save_recording (line 230) | def _save_recording(self):
    method _predict_steps_count (line 236) | def _predict_steps_count(self, frame_state: FrameState) -> int:
    method _update_stats (line 244) | def _update_stats(self):

FILE: vr/viewer/xr_context.py
  class XRContextObject (line 20) | class XRContextObject(xr.ContextObject):
    method __init__ (line 28) | def __init__(
    method __enter__ (line 49) | def __enter__(self):
    method __exit__ (line 55) | def __exit__(self, exc_type, exc_val, exc_tb):
    method frame_loop (line 78) | def frame_loop(self):

FILE: vr/viewer/xr_input.py
  class XRInput (line 12) | class XRInput:
    method __init__ (line 18) | def __init__(self, context: xr.ContextObject):
    method state (line 313) | def state(self) -> list[ControllerState]:
    method views (line 318) | def views(self) -> list[View]:
    method hmd_pose (line 323) | def hmd_pose(self) -> Posef:
    method update (line 327) | def update(self, time: Time):
    method _get_action_state_float (line 405) | def _get_action_state_float(self, action: xr.Action, hand: Side) -> fl...
    method _get_action_state_bool (line 415) | def _get_action_state_bool(self, action: xr.Action, hand: Side) -> bool:
    method _get_action_state_pose (line 425) | def _get_action_state_pose(self, action: xr.Action, hand: Side) -> bool:
    method _get_space_pose (line 435) | def _get_space_pose(self, time: Time, space: xr.Space) -> Posef:
    method _apply_vibration (line 449) | def _apply_vibration(self, action: xr.Action, hand: Side):