SYMBOL INDEX (1374 symbols across 167 files)

FILE: gym/core.py
  class Env (line 35) | class Env(Generic[ObsType, ActType]):
    method np_random (line 76) | def np_random(self) -> np.random.Generator:
    method np_random (line 83) | def np_random(self, value: np.random.Generator):
    method step (line 86) | def step(self, action: ActType) -> Tuple[ObsType, float, bool, bool, d...
    method reset (line 117) | def reset(
    method render (line 153) | def render(self) -> Optional[Union[RenderFrame, List[RenderFrame]]]:
    method close (line 178) | def close(self):
    method unwrapped (line 187) | def unwrapped(self) -> "Env":
    method __str__ (line 195) | def __str__(self):
    method __enter__ (line 202) | def __enter__(self):
    method __exit__ (line 206) | def __exit__(self, *args):
  class Wrapper (line 213) | class Wrapper(Env[ObsType, ActType]):
    method __init__ (line 224) | def __init__(self, env: Env):
    method __getattr__ (line 237) | def __getattr__(self, name):
    method spec (line 244) | def spec(self):
    method class_name (line 249) | def class_name(cls):
    method action_space (line 254) | def action_space(self) -> spaces.Space[ActType]:
    method action_space (line 261) | def action_space(self, space: spaces.Space):
    method observation_space (line 265) | def observation_space(self) -> spaces.Space:
    method observation_space (line 272) | def observation_space(self, space: spaces.Space):
    method reward_range (line 276) | def reward_range(self) -> Tuple[SupportsFloat, SupportsFloat]:
    method reward_range (line 283) | def reward_range(self, value: Tuple[SupportsFloat, SupportsFloat]):
    method metadata (line 287) | def metadata(self) -> dict:
    method metadata (line 294) | def metadata(self, value):
    method render_mode (line 298) | def render_mode(self) -> Optional[str]:
    method np_random (line 303) | def np_random(self) -> np.random.Generator:
    method np_random (line 308) | def np_random(self, value):
    method _np_random (line 312) | def _np_random(self):
    method step (line 317) | def step(self, action: ActType) -> Tuple[ObsType, float, bool, bool, d...
    method reset (line 321) | def reset(self, **kwargs) -> Tuple[ObsType, dict]:
    method render (line 325) | def render(
    method close (line 331) | def close(self):
    method __str__ (line 335) | def __str__(self):
    method __repr__ (line 339) | def __repr__(self):
    method unwrapped (line 344) | def unwrapped(self) -> Env:
  class ObservationWrapper (line 349) | class ObservationWrapper(Wrapper):
    method reset (line 377) | def reset(self, **kwargs):
    method step (line 382) | def step(self, action):
    method observation (line 387) | def observation(self, observation):
  class RewardWrapper (line 392) | class RewardWrapper(Wrapper):
    method step (line 416) | def step(self, action):
    method reward (line 421) | def reward(self, reward):
  class ActionWrapper (line 426) | class ActionWrapper(Wrapper):
    method step (line 458) | def step(self, action):
    method action (line 462) | def action(self, action):
    method reverse_action (line 466) | def reverse_action(self, action):

FILE: gym/envs/box2d/bipedal_walker.py
  class ContactDetector (line 80) | class ContactDetector(contactListener):
    method __init__ (line 81) | def __init__(self, env):
    method BeginContact (line 85) | def BeginContact(self, contact):
    method EndContact (line 95) | def EndContact(self, contact):
  class BipedalWalker (line 101) | class BipedalWalker(gym.Env, EzPickle):
    method __init__ (line 170) | def __init__(self, render_mode: Optional[str] = None, hardcore: bool =...
    method _destroy (line 263) | def _destroy(self):
    method _generate_terrain (line 277) | def _generate_terrain(self, hardcore):
    method _generate_clouds (line 404) | def _generate_clouds(self):
    method reset (line 425) | def reset(
    method step (line 517) | def step(self, action: np.ndarray):
    method render (line 608) | def render(self):
    method close (line 757) | def close(self):
  class BipedalWalkerHardcore (line 766) | class BipedalWalkerHardcore:
    method __init__ (line 767) | def __init__(self):

FILE: gym/envs/box2d/car_dynamics.py
  class Car (line 50) | class Car:
    method __init__ (line 51) | def __init__(self, world, init_angle, init_x, init_y):
    method gas (line 138) | def gas(self, gas):
    method brake (line 151) | def brake(self, b):
    method steer (line 159) | def steer(self, s):
    method step (line 167) | def step(self, dt):
    method draw (line 263) | def draw(self, surface, zoom, translation, angle, draw_particles=True):
    method _create_particle (line 332) | def _create_particle(self, point1, point2, grass):
    method destroy (line 346) | def destroy(self):

FILE: gym/envs/box2d/car_racing.py
  class FrictionDetector (line 57) | class FrictionDetector(contactListener):
    method __init__ (line 58) | def __init__(self, env, lap_complete_percent):
    method BeginContact (line 63) | def BeginContact(self, contact):
    method EndContact (line 66) | def EndContact(self, contact):
    method _contact (line 69) | def _contact(self, contact, begin):
  class CarRacing (line 105) | class CarRacing(gym.Env, EzPickle):
    method __init__ (line 192) | def __init__(
    method _destroy (line 248) | def _destroy(self):
    method _init_colors (line 257) | def _init_colors(self):
    method _reinit_colors (line 273) | def _reinit_colors(self, randomize):
    method _create_track (line 288) | def _create_track(self):
    method reset (line 478) | def reset(
    method step (line 520) | def step(self, action: Union[np.ndarray, int]):
    method render (line 567) | def render(self):
    method _render (line 577) | def _render(self, mode: str):
    method _render_road (line 638) | def _render_road(self, zoom, translation, angle):
    method _render_indicators (line 676) | def _render_indicators(self, W, H):
    method _draw_colored_polygon (line 744) | def _draw_colored_polygon(
    method _create_image_array (line 764) | def _create_image_array(self, screen, size):
    method close (line 770) | def close(self):
  function register_input (line 780) | def register_input():

FILE: gym/envs/box2d/lunar_lander.py
  class ContactDetector (line 54) | class ContactDetector(contactListener):
    method __init__ (line 55) | def __init__(self, env):
    method BeginContact (line 59) | def BeginContact(self, contact):
    method EndContact (line 69) | def EndContact(self, contact):
  class LunarLander (line 75) | class LunarLander(gym.Env, EzPickle):
    method __init__ (line 191) | def __init__(
    method _destroy (line 296) | def _destroy(self):
    method reset (line 308) | def reset(
    method _create_particle (line 422) | def _create_particle(self, mass, x, y, ttl):
    method _clean_particles (line 440) | def _clean_particles(self, all):
    method step (line 444) | def step(self, action):
    method render (line 602) | def render(self):
    method close (line 717) | def close(self):
  function heuristic (line 726) | def heuristic(env, s):
  function demo_heuristic_lander (line 780) | def demo_heuristic_lander(env, seed=None, render=False):
  class LunarLanderContinuous (line 806) | class LunarLanderContinuous:
    method __init__ (line 807) | def __init__(self):

FILE: gym/envs/classic_control/acrobot.py
  class AcrobotEnv (line 26) | class AcrobotEnv(core.Env):
    method __init__ (line 168) | def __init__(self, render_mode: Optional[str] = None):
    method reset (line 181) | def reset(self, *, seed: Optional[int] = None, options: Optional[dict]...
    method step (line 196) | def step(self, a):
    method _get_ob (line 225) | def _get_ob(self):
    method _terminal (line 232) | def _terminal(self):
    method _dsdt (line 237) | def _dsdt(self, s_augmented):
    method render (line 279) | def render(self):
    method close (line 369) | def close(self):
  function wrap (line 378) | def wrap(x, m, M):
  function bound (line 399) | def bound(x, m, M=None):
  function rk4 (line 418) | def rk4(derivs, y0, t):

FILE: gym/envs/classic_control/cartpole.py
  class CartPoleEnv (line 17) | class CartPoleEnv(gym.Env[np.ndarray, Union[int, np.ndarray]]):
    method __init__ (line 89) | def __init__(self, render_mode: Optional[str] = None):
    method step (line 130) | def step(self, action):
    method reset (line 190) | def reset(
    method render (line 209) | def render(self):
    method close (line 306) | def close(self):

FILE: gym/envs/classic_control/continuous_mountain_car.py
  class Continuous_MountainCarEnv (line 27) | class Continuous_MountainCarEnv(gym.Env):
    method __init__ (line 108) | def __init__(self, render_mode: Optional[str] = None, goal_velocity=0):
    method step (line 142) | def step(self, action: np.ndarray):
    method reset (line 177) | def reset(self, *, seed: Optional[int] = None, options: Optional[dict]...
    method _height (line 188) | def _height(self, xs):
    method render (line 191) | def render(self):
    method close (line 294) | def close(self):

FILE: gym/envs/classic_control/mountain_car.py
  class MountainCarEnv (line 16) | class MountainCarEnv(gym.Env):
    method __init__ (line 103) | def __init__(self, render_mode: Optional[str] = None, goal_velocity=0):
    method step (line 127) | def step(self, action: int):
    method reset (line 150) | def reset(
    method _height (line 166) | def _height(self, xs):
    method render (line 169) | def render(self):
    method get_keys_to_action (line 272) | def get_keys_to_action(self):
    method close (line 276) | def close(self):

FILE: gym/envs/classic_control/pendulum.py
  class PendulumEnv (line 17) | class PendulumEnv(gym.Env):
    method __init__ (line 95) | def __init__(self, render_mode: Optional[str] = None, g=10.0):
    method step (line 119) | def step(self, u):
    method reset (line 141) | def reset(self, *, seed: Optional[int] = None, options: Optional[dict]...
    method _get_obs (line 161) | def _get_obs(self):
    method render (line 165) | def render(self):
    method close (line 261) | def close(self):
  function angle_normalize (line 270) | def angle_normalize(x):

FILE: gym/envs/classic_control/utils.py
  function verify_number_and_cast (line 8) | def verify_number_and_cast(x: SupportsFloat) -> float:
  function maybe_parse_reset_bounds (line 17) | def maybe_parse_reset_bounds(

FILE: gym/envs/mujoco/ant.py
  class AntEnv (line 8) | class AntEnv(MuJocoPyEnv, utils.EzPickle):
    method __init__ (line 18) | def __init__(self, **kwargs):
    method step (line 27) | def step(self, a):
    method _get_obs (line 61) | def _get_obs(self):
    method reset_model (line 70) | def reset_model(self):
    method viewer_setup (line 78) | def viewer_setup(self):

FILE: gym/envs/mujoco/ant_v3.py
  class AntEnv (line 12) | class AntEnv(MuJocoPyEnv, utils.EzPickle):
    method __init__ (line 22) | def __init__(
    method healthy_reward (line 78) | def healthy_reward(self):
    method control_cost (line 84) | def control_cost(self, action):
    method contact_forces (line 89) | def contact_forces(self):
    method contact_cost (line 96) | def contact_cost(self):
    method is_healthy (line 103) | def is_healthy(self):
    method terminated (line 110) | def terminated(self):
    method step (line 114) | def step(self, action):
    method _get_obs (line 151) | def _get_obs(self):
    method reset_model (line 163) | def reset_model(self):
    method viewer_setup (line 180) | def viewer_setup(self):

FILE: gym/envs/mujoco/ant_v4.py
  class AntEnv (line 12) | class AntEnv(MujocoEnv, utils.EzPickle):
    method __init__ (line 184) | def __init__(
    method healthy_reward (line 245) | def healthy_reward(self):
    method control_cost (line 251) | def control_cost(self, action):
    method contact_forces (line 256) | def contact_forces(self):
    method contact_cost (line 263) | def contact_cost(self):
    method is_healthy (line 270) | def is_healthy(self):
    method terminated (line 277) | def terminated(self):
    method step (line 281) | def step(self, action):
    method _get_obs (line 320) | def _get_obs(self):
    method reset_model (line 333) | def reset_model(self):
    method viewer_setup (line 350) | def viewer_setup(self):

FILE: gym/envs/mujoco/half_cheetah.py
  class HalfCheetahEnv (line 8) | class HalfCheetahEnv(MuJocoPyEnv, utils.EzPickle):
    method __init__ (line 18) | def __init__(self, **kwargs):
    method step (line 25) | def step(self, action):
    method _get_obs (line 46) | def _get_obs(self):
    method reset_model (line 54) | def reset_model(self):
    method viewer_setup (line 62) | def viewer_setup(self):

FILE: gym/envs/mujoco/half_cheetah_v3.py
  class HalfCheetahEnv (line 14) | class HalfCheetahEnv(MuJocoPyEnv, utils.EzPickle):
    method __init__ (line 24) | def __init__(
    method control_cost (line 66) | def control_cost(self, action):
    method step (line 70) | def step(self, action):
    method _get_obs (line 94) | def _get_obs(self):
    method reset_model (line 104) | def reset_model(self):
    method viewer_setup (line 121) | def viewer_setup(self):

FILE: gym/envs/mujoco/half_cheetah_v4.py
  class HalfCheetahEnv (line 14) | class HalfCheetahEnv(MujocoEnv, utils.EzPickle):
    method __init__ (line 144) | def __init__(
    method control_cost (line 184) | def control_cost(self, action):
    method step (line 188) | def step(self, action):
    method _get_obs (line 212) | def _get_obs(self):
    method reset_model (line 222) | def reset_model(self):
    method viewer_setup (line 239) | def viewer_setup(self):

FILE: gym/envs/mujoco/hopper.py
  class HopperEnv (line 8) | class HopperEnv(MuJocoPyEnv, utils.EzPickle):
    method __init__ (line 18) | def __init__(self, **kwargs):
    method step (line 25) | def step(self, a):
    method _get_obs (line 47) | def _get_obs(self):
    method reset_model (line 52) | def reset_model(self):
    method viewer_setup (line 62) | def viewer_setup(self):

FILE: gym/envs/mujoco/hopper_v3.py
  class HopperEnv (line 17) | class HopperEnv(MuJocoPyEnv, utils.EzPickle):
    method __init__ (line 27) | def __init__(
    method healthy_reward (line 87) | def healthy_reward(self):
    method control_cost (line 93) | def control_cost(self, action):
    method is_healthy (line 98) | def is_healthy(self):
    method terminated (line 115) | def terminated(self):
    method _get_obs (line 119) | def _get_obs(self):
    method step (line 129) | def step(self, action):
    method reset_model (line 155) | def reset_model(self):
    method viewer_setup (line 171) | def viewer_setup(self):

FILE: gym/envs/mujoco/hopper_v4.py
  class HopperEnv (line 15) | class HopperEnv(MujocoEnv, utils.EzPickle):
    method __init__ (line 150) | def __init__(
    method healthy_reward (line 208) | def healthy_reward(self):
    method control_cost (line 214) | def control_cost(self, action):
    method is_healthy (line 219) | def is_healthy(self):
    method terminated (line 236) | def terminated(self):
    method _get_obs (line 240) | def _get_obs(self):
    method step (line 250) | def step(self, action):
    method reset_model (line 276) | def reset_model(self):
    method viewer_setup (line 292) | def viewer_setup(self):

FILE: gym/envs/mujoco/humanoid.py
  function mass_center (line 8) | def mass_center(model, sim):
  class HumanoidEnv (line 14) | class HumanoidEnv(MuJocoPyEnv, utils.EzPickle):
    method __init__ (line 24) | def __init__(self, **kwargs):
    method _get_obs (line 33) | def _get_obs(self):
    method step (line 46) | def step(self, a):
    method reset_model (line 76) | def reset_model(self):
    method viewer_setup (line 89) | def viewer_setup(self):

FILE: gym/envs/mujoco/humanoid_v3.py
  function mass_center (line 15) | def mass_center(model, sim):
  class HumanoidEnv (line 21) | class HumanoidEnv(MuJocoPyEnv, utils.EzPickle):
    method __init__ (line 31) | def __init__(
    method healthy_reward (line 87) | def healthy_reward(self):
    method control_cost (line 93) | def control_cost(self, action):
    method contact_cost (line 98) | def contact_cost(self):
    method is_healthy (line 106) | def is_healthy(self):
    method terminated (line 113) | def terminated(self):
    method _get_obs (line 117) | def _get_obs(self):
    method step (line 141) | def step(self, action):
    method reset_model (line 178) | def reset_model(self):
    method viewer_setup (line 193) | def viewer_setup(self):

FILE: gym/envs/mujoco/humanoid_v4.py
  function mass_center (line 15) | def mass_center(model, data):
  class HumanoidEnv (line 21) | class HumanoidEnv(MujocoEnv, utils.EzPickle):
    method __init__ (line 224) | def __init__(
    method healthy_reward (line 273) | def healthy_reward(self):
    method control_cost (line 279) | def control_cost(self, action):
    method is_healthy (line 284) | def is_healthy(self):
    method terminated (line 291) | def terminated(self):
    method _get_obs (line 295) | def _get_obs(self):
    method step (line 319) | def step(self, action):
    method reset_model (line 353) | def reset_model(self):
    method viewer_setup (line 368) | def viewer_setup(self):

FILE: gym/envs/mujoco/humanoidstandup.py
  class HumanoidStandupEnv (line 8) | class HumanoidStandupEnv(MuJocoPyEnv, utils.EzPickle):
    method __init__ (line 18) | def __init__(self, **kwargs):
    method _get_obs (line 31) | def _get_obs(self):
    method step (line 44) | def step(self, a):
    method reset_model (line 69) | def reset_model(self):
    method viewer_setup (line 82) | def viewer_setup(self):

FILE: gym/envs/mujoco/humanoidstandup_v4.py
  class HumanoidStandupEnv (line 8) | class HumanoidStandupEnv(MujocoEnv, utils.EzPickle):
    method __init__ (line 190) | def __init__(self, **kwargs):
    method _get_obs (line 203) | def _get_obs(self):
    method step (line 216) | def step(self, a):
    method reset_model (line 241) | def reset_model(self):
    method viewer_setup (line 254) | def viewer_setup(self):

FILE: gym/envs/mujoco/inverted_double_pendulum.py
  class InvertedDoublePendulumEnv (line 8) | class InvertedDoublePendulumEnv(MuJocoPyEnv, utils.EzPickle):
    method __init__ (line 18) | def __init__(self, **kwargs):
    method step (line 29) | def step(self, action):
    method _get_obs (line 45) | def _get_obs(self):
    method reset_model (line 56) | def reset_model(self):
    method viewer_setup (line 64) | def viewer_setup(self):

FILE: gym/envs/mujoco/inverted_double_pendulum_v4.py
  class InvertedDoublePendulumEnv (line 8) | class InvertedDoublePendulumEnv(MujocoEnv, utils.EzPickle):
    method __init__ (line 124) | def __init__(self, **kwargs):
    method step (line 135) | def step(self, action):
    method _get_obs (line 149) | def _get_obs(self):
    method reset_model (line 160) | def reset_model(self):
    method viewer_setup (line 168) | def viewer_setup(self):

FILE: gym/envs/mujoco/inverted_pendulum.py
  class InvertedPendulumEnv (line 8) | class InvertedPendulumEnv(MuJocoPyEnv, utils.EzPickle):
    method __init__ (line 18) | def __init__(self, **kwargs):
    method step (line 29) | def step(self, a):
    method reset_model (line 40) | def reset_model(self):
    method _get_obs (line 50) | def _get_obs(self):
    method viewer_setup (line 53) | def viewer_setup(self):

FILE: gym/envs/mujoco/inverted_pendulum_v4.py
  class InvertedPendulumEnv (line 8) | class InvertedPendulumEnv(MujocoEnv, utils.EzPickle):
    method __init__ (line 95) | def __init__(self, **kwargs):
    method step (line 106) | def step(self, a):
    method reset_model (line 115) | def reset_model(self):
    method _get_obs (line 125) | def _get_obs(self):
    method viewer_setup (line 128) | def viewer_setup(self):

FILE: gym/envs/mujoco/mujoco_env.py
  class BaseMujocoEnv (line 28) | class BaseMujocoEnv(gym.Env):
    method __init__ (line 31) | def __init__(
    method _set_action_space (line 77) | def _set_action_space(self):
    method reset_model (line 86) | def reset_model(self):
    method viewer_setup (line 93) | def viewer_setup(self):
    method _initialize_simulation (line 99) | def _initialize_simulation(self):
    method _reset_simulation (line 105) | def _reset_simulation(self):
    method _step_mujoco_simulation (line 111) | def _step_mujoco_simulation(self, ctrl, n_frames):
    method render (line 117) | def render(self):
    method reset (line 125) | def reset(
    method set_state (line 140) | def set_state(self, qpos, qvel):
    method dt (line 147) | def dt(self):
    method do_simulation (line 150) | def do_simulation(self, ctrl, n_frames):
    method close (line 159) | def close(self):
    method get_body_com (line 164) | def get_body_com(self, body_name):
    method state_vector (line 168) | def state_vector(self):
  class MuJocoPyEnv (line 173) | class MuJocoPyEnv(BaseMujocoEnv):
    method __init__ (line 174) | def __init__(
    method _initialize_simulation (line 209) | def _initialize_simulation(self):
    method _reset_simulation (line 214) | def _reset_simulation(self):
    method set_state (line 217) | def set_state(self, qpos, qvel):
    method _step_mujoco_simulation (line 224) | def _step_mujoco_simulation(self, ctrl, n_frames):
    method render (line 230) | def render(self):
    method _get_viewer (line 277) | def _get_viewer(
    method get_body_com (line 297) | def get_body_com(self, body_name):
  class MujocoEnv (line 301) | class MujocoEnv(BaseMujocoEnv):
    method __init__ (line 304) | def __init__(
    method _initialize_simulation (line 330) | def _initialize_simulation(self):
    method _reset_simulation (line 337) | def _reset_simulation(self):
    method set_state (line 340) | def set_state(self, qpos, qvel):
    method _step_mujoco_simulation (line 348) | def _step_mujoco_simulation(self, ctrl, n_frames):
    method render (line 358) | def render(self):
    method close (line 406) | def close(self):
    method _get_viewer (line 411) | def _get_viewer(
    method get_body_com (line 436) | def get_body_com(self, body_name):

FILE: gym/envs/mujoco/mujoco_rendering.py
  function _import_egl (line 12) | def _import_egl(width, height):
  function _import_glfw (line 18) | def _import_glfw(width, height):
  function _import_osmesa (line 24) | def _import_osmesa(width, height):
  class RenderContext (line 39) | class RenderContext:
    method __init__ (line 42) | def __init__(self, model, data, offscreen=True):
    method _set_mujoco_buffers (line 65) | def _set_mujoco_buffers(self):
    method render (line 75) | def render(self, camera_id=None, segmentation=False):
    method read_pixels (line 119) | def read_pixels(self, depth=True, segmentation=False):
    method _init_camera (line 152) | def _init_camera(self):
    method add_overlay (line 159) | def add_overlay(self, gridpos: int, text1: str, text2: str):
    method add_marker (line 166) | def add_marker(self, **marker_params):
    method _add_marker_to_scene (line 169) | def _add_marker_to_scene(self, marker):
    method close (line 215) | def close(self):
  class RenderContextOffscreen (line 222) | class RenderContextOffscreen(RenderContext):
    method __init__ (line 225) | def __init__(self, model, data):
    method _get_opengl_backend (line 234) | def _get_opengl_backend(self, width, height):
  class Viewer (line 262) | class Viewer(RenderContext):
    method __init__ (line 265) | def __init__(self, model, data):
    method _key_callback (line 305) | def _key_callback(self, window, key, scancode, action, mods):
    method _cursor_pos_callback (line 372) | def _cursor_pos_callback(self, window, xpos, ypos):
    method _mouse_button_callback (line 407) | def _mouse_button_callback(self, window, button, act, mods):
    method _scroll_callback (line 419) | def _scroll_callback(self, window, x_offset, y_offset):
    method _create_overlay (line 430) | def _create_overlay(self):
    method render (line 480) | def render(self):
    method close (line 550) | def close(self):

FILE: gym/envs/mujoco/pusher.py
  class PusherEnv (line 8) | class PusherEnv(MuJocoPyEnv, utils.EzPickle):
    method __init__ (line 18) | def __init__(self, **kwargs):
    method step (line 25) | def step(self, a):
    method viewer_setup (line 47) | def viewer_setup(self):
    method reset_model (line 52) | def reset_model(self):
    method _get_obs (line 75) | def _get_obs(self):

FILE: gym/envs/mujoco/pusher_v4.py
  class PusherEnv (line 8) | class PusherEnv(MujocoEnv, utils.EzPickle):
    method __init__ (line 140) | def __init__(self, **kwargs):
    method step (line 147) | def step(self, a):
    method viewer_setup (line 169) | def viewer_setup(self):
    method reset_model (line 174) | def reset_model(self):
    method _get_obs (line 197) | def _get_obs(self):

FILE: gym/envs/mujoco/reacher.py
  class ReacherEnv (line 8) | class ReacherEnv(MuJocoPyEnv, utils.EzPickle):
    method __init__ (line 18) | def __init__(self, **kwargs):
    method step (line 25) | def step(self, a):
    method viewer_setup (line 44) | def viewer_setup(self):
    method reset_model (line 48) | def reset_model(self):
    method _get_obs (line 65) | def _get_obs(self):

FILE: gym/envs/mujoco/reacher_v4.py
  class ReacherEnv (line 8) | class ReacherEnv(MujocoEnv, utils.EzPickle):
    method __init__ (line 130) | def __init__(self, **kwargs):
    method step (line 137) | def step(self, a):
    method viewer_setup (line 156) | def viewer_setup(self):
    method reset_model (line 160) | def reset_model(self):
    method _get_obs (line 177) | def _get_obs(self):

FILE: gym/envs/mujoco/swimmer.py
  class SwimmerEnv (line 8) | class SwimmerEnv(MuJocoPyEnv, utils.EzPickle):
    method __init__ (line 18) | def __init__(self, **kwargs):
    method step (line 25) | def step(self, a):
    method _get_obs (line 47) | def _get_obs(self):
    method reset_model (line 52) | def reset_model(self):

FILE: gym/envs/mujoco/swimmer_v3.py
  class SwimmerEnv (line 12) | class SwimmerEnv(MuJocoPyEnv, utils.EzPickle):
    method __init__ (line 22) | def __init__(
    method control_cost (line 63) | def control_cost(self, action):
    method step (line 67) | def step(self, action):
    method _get_obs (line 96) | def _get_obs(self):
    method reset_model (line 106) | def reset_model(self):
    method viewer_setup (line 122) | def viewer_setup(self):

FILE: gym/envs/mujoco/swimmer_v4.py
  class SwimmerEnv (line 12) | class SwimmerEnv(MujocoEnv, utils.EzPickle):
    method __init__ (line 136) | def __init__(
    method control_cost (line 173) | def control_cost(self, action):
    method step (line 177) | def step(self, action):
    method _get_obs (line 207) | def _get_obs(self):
    method reset_model (line 217) | def reset_model(self):
    method viewer_setup (line 233) | def viewer_setup(self):

FILE: gym/envs/mujoco/walker2d.py
  class Walker2dEnv (line 8) | class Walker2dEnv(MuJocoPyEnv, utils.EzPickle):
    method __init__ (line 18) | def __init__(self, **kwargs):
    method step (line 25) | def step(self, a):
    method _get_obs (line 42) | def _get_obs(self):
    method reset_model (line 47) | def reset_model(self):
    method viewer_setup (line 56) | def viewer_setup(self):

FILE: gym/envs/mujoco/walker2d_v3.py
  class Walker2dEnv (line 15) | class Walker2dEnv(MuJocoPyEnv, utils.EzPickle):
    method __init__ (line 25) | def __init__(
    method healthy_reward (line 81) | def healthy_reward(self):
    method control_cost (line 87) | def control_cost(self, action):
    method is_healthy (line 92) | def is_healthy(self):
    method terminated (line 105) | def terminated(self):
    method _get_obs (line 109) | def _get_obs(self):
    method step (line 119) | def step(self, action):
    method reset_model (line 145) | def reset_model(self):
    method viewer_setup (line 161) | def viewer_setup(self):

FILE: gym/envs/mujoco/walker2d_v4.py
  class Walker2dEnv (line 15) | class Walker2dEnv(MujocoEnv, utils.EzPickle):
    method __init__ (line 155) | def __init__(
    method healthy_reward (line 209) | def healthy_reward(self):
    method control_cost (line 215) | def control_cost(self, action):
    method is_healthy (line 220) | def is_healthy(self):
    method terminated (line 233) | def terminated(self):
    method _get_obs (line 237) | def _get_obs(self):
    method step (line 247) | def step(self, action):
    method reset_model (line 274) | def reset_model(self):
    method viewer_setup (line 290) | def viewer_setup(self):

FILE: gym/envs/registration.py
  function load (line 51) | def load(name: str) -> callable:
  function parse_env_id (line 66) | def parse_env_id(id: str) -> Tuple[Optional[str], str, Optional[int]]:
  function get_env_id (line 97) | def get_env_id(ns: Optional[str], name: str, version: Optional[int]) -> ...
  class EnvSpec (line 118) | class EnvSpec:
    method __post_init__ (line 154) | def __post_init__(self):
    method make (line 158) | def make(self, **kwargs) -> Env:
  function _check_namespace_exists (line 163) | def _check_namespace_exists(ns: Optional[str]):
  function _check_name_exists (line 185) | def _check_name_exists(ns: Optional[str], name: str):
  function _check_version_exists (line 202) | def _check_version_exists(ns: Optional[str], name: str, version: Optiona...
  function find_highest_version (line 257) | def find_highest_version(ns: Optional[str], name: str) -> Optional[int]:
  function load_env_plugins (line 266) | def load_env_plugins(entry_point: str = "gym.envs") -> None:
  function make (line 314) | def make(id: str, **kwargs) -> Env: ...
  function make (line 316) | def make(id: EnvSpec, **kwargs) -> Env: ...
  function make (line 322) | def make(id: Literal["CartPole-v0", "CartPole-v1"], **kwargs) -> Env[np....
  function make (line 324) | def make(id: Literal["MountainCar-v0"], **kwargs) -> Env[np.ndarray, Uni...
  function make (line 326) | def make(id: Literal["MountainCarContinuous-v0"], **kwargs) -> Env[np.nd...
  function make (line 328) | def make(id: Literal["Pendulum-v1"], **kwargs) -> Env[np.ndarray, Union[...
  function make (line 330) | def make(id: Literal["Acrobot-v1"], **kwargs) -> Env[np.ndarray, Union[n...
  function make (line 336) | def make(id: Literal["LunarLander-v2", "LunarLanderContinuous-v2"], **kw...
  function make (line 338) | def make(id: Literal["BipedalWalker-v3", "BipedalWalkerHardcore-v3"], **...
  function make (line 340) | def make(id: Literal["CarRacing-v2"], **kwargs) -> Env[np.ndarray, Union...
  function make (line 346) | def make(id: Literal["Blackjack-v1"], **kwargs) -> Env[np.ndarray, Union...
  function make (line 348) | def make(id: Literal["FrozenLake-v1", "FrozenLake8x8-v1"], **kwargs) -> ...
  function make (line 350) | def make(id: Literal["CliffWalking-v0"], **kwargs) -> Env[np.ndarray, Un...
  function make (line 352) | def make(id: Literal["Taxi-v3"], **kwargs) -> Env[np.ndarray, Union[np.n...
  function make (line 358) | def make(id: Literal[
  function _check_spec_register (line 379) | def _check_spec_register(spec: EnvSpec):
  function namespace (line 426) | def namespace(ns: str):
  function register (line 434) | def register(
  function make (line 502) | def make(
  function spec (line 694) | def spec(env_id: str) -> EnvSpec:

FILE: gym/envs/toy_text/blackjack.py
  function cmp (line 11) | def cmp(a, b):
  function draw_card (line 19) | def draw_card(np_random):
  function draw_hand (line 23) | def draw_hand(np_random):
  function usable_ace (line 27) | def usable_ace(hand):  # Does this hand have a usable ace?
  function sum_hand (line 31) | def sum_hand(hand):  # Return current hand total
  function is_bust (line 37) | def is_bust(hand):  # Is this hand a bust?
  function score (line 41) | def score(hand):  # What is the score of this hand (0 if bust)
  function is_natural (line 45) | def is_natural(hand):  # Is this hand a natural blackjack?
  class BlackjackEnv (line 49) | class BlackjackEnv(gym.Env):
    method __init__ (line 118) | def __init__(self, render_mode: Optional[str] = None, natural=False, s...
    method step (line 133) | def step(self, action):
    method _get_obs (line 164) | def _get_obs(self):
    method reset (line 167) | def reset(
    method render (line 192) | def render(self):
    method close (line 310) | def close(self):

FILE: gym/envs/toy_text/cliffwalking.py
  class CliffWalkingEnv (line 18) | class CliffWalkingEnv(Env):
    method __init__ (line 70) | def __init__(self, render_mode: Optional[str] = None):
    method _limit_coordinates (line 117) | def _limit_coordinates(self, coord: np.ndarray) -> np.ndarray:
    method _calculate_transition_prob (line 125) | def _calculate_transition_prob(self, current, delta):
    method step (line 145) | def step(self, a):
    method reset (line 156) | def reset(self, *, seed: Optional[int] = None, options: Optional[dict]...
    method render (line 165) | def render(self):
    method _render_gui (line 177) | def _render_gui(self, mode):
    method _render_text (line 268) | def _render_text(self):

FILE: gym/envs/toy_text/frozen_lake.py
  function is_valid (line 33) | def is_valid(board: List[List[str]], max_size: int) -> bool:
  function generate_random_map (line 53) | def generate_random_map(size: int = 8, p: float = 0.8) -> List[str]:
  class FrozenLakeEnv (line 75) | class FrozenLakeEnv(Env):
    method __init__ (line 162) | def __init__(
    method step (line 244) | def step(self, a):
    method reset (line 255) | def reset(
    method render (line 269) | def render(self):
    method _render_gui (line 281) | def _render_gui(self, mode):
    method _center_small_rect (line 380) | def _center_small_rect(big_rect, small_dims):
    method _render_text (line 388) | def _render_text(self):
    method close (line 404) | def close(self):

FILE: gym/envs/toy_text/taxi.py
  class TaxiEnv (line 24) | class TaxiEnv(Env):
    method __init__ (line 128) | def __init__(self, render_mode: Optional[str] = None):
    method encode (line 210) | def encode(self, taxi_row, taxi_col, pass_loc, dest_idx):
    method decode (line 221) | def decode(self, i):
    method action_mask (line 233) | def action_mask(self, state: int):
    method step (line 254) | def step(self, a):
    method reset (line 265) | def reset(
    method render (line 280) | def render(self):
    method _render_gui (line 292) | def _render_gui(self, mode):
    method get_surf_loc (line 422) | def get_surf_loc(self, map_loc):
    method _render_text (line 427) | def _render_text(self):
    method close (line 463) | def close(self):

FILE: gym/envs/toy_text/utils.py
  function categorical_sample (line 4) | def categorical_sample(prob_n, np_random: np.random.Generator):

FILE: gym/error.py
  class Error (line 5) | class Error(Exception):
  class Unregistered (line 12) | class Unregistered(Error):
  class UnregisteredEnv (line 16) | class UnregisteredEnv(Unregistered):
  class NamespaceNotFound (line 20) | class NamespaceNotFound(UnregisteredEnv):
  class NameNotFound (line 24) | class NameNotFound(UnregisteredEnv):
  class VersionNotFound (line 28) | class VersionNotFound(UnregisteredEnv):
  class UnregisteredBenchmark (line 32) | class UnregisteredBenchmark(Unregistered):
  class DeprecatedEnv (line 36) | class DeprecatedEnv(Error):
  class RegistrationError (line 40) | class RegistrationError(Error):
  class UnseedableEnv (line 44) | class UnseedableEnv(Error):
  class DependencyNotInstalled (line 48) | class DependencyNotInstalled(Error):
  class UnsupportedMode (line 52) | class UnsupportedMode(Error):
  class ResetNeeded (line 56) | class ResetNeeded(Error):
  class ResetNotAllowed (line 60) | class ResetNotAllowed(Error):
  class InvalidAction (line 64) | class InvalidAction(Error):
  class APIError (line 71) | class APIError(Error):
    method __init__ (line 74) | def __init__(
    method __unicode__ (line 100) | def __unicode__(self):
    method __str__ (line 108) | def __str__(self):
  class APIConnectionError (line 113) | class APIConnectionError(APIError):
  class InvalidRequestError (line 117) | class InvalidRequestError(APIError):
    method __init__ (line 120) | def __init__(
  class AuthenticationError (line 134) | class AuthenticationError(APIError):
  class RateLimitError (line 138) | class RateLimitError(APIError):
  class VideoRecorderError (line 145) | class VideoRecorderError(Error):
  class InvalidFrame (line 149) | class InvalidFrame(Error):
  class DoubleWrapperError (line 156) | class DoubleWrapperError(Error):
  class WrapAfterConfigureError (line 160) | class WrapAfterConfigureError(Error):
  class RetriesExceededError (line 164) | class RetriesExceededError(Error):
  class AlreadyPendingCallError (line 171) | class AlreadyPendingCallError(Exception):
    method __init__ (line 174) | def __init__(self, message: str, name: str):
  class NoAsyncCallError (line 180) | class NoAsyncCallError(Exception):
    method __init__ (line 183) | def __init__(self, message: str, name: str):
  class ClosedEnvironmentError (line 189) | class ClosedEnvironmentError(Exception):
  class CustomSpaceError (line 193) | class CustomSpaceError(Exception):

FILE: gym/logger.py
  function set_level (line 21) | def set_level(level: int):
  function debug (line 27) | def debug(msg: str, *args: object):
  function info (line 33) | def info(msg: str, *args: object):
  function warn (line 39) | def warn(
  function deprecation (line 61) | def deprecation(msg: str, *args: object):
  function error (line 66) | def error(msg: str, *args: object):

FILE: gym/spaces/box.py
  function _short_repr (line 11) | def _short_repr(arr: np.ndarray) -> str:
  function is_float_integer (line 28) | def is_float_integer(var) -> bool:
  class Box (line 33) | class Box(Space[np.ndarray]):
    method __init__ (line 53) | def __init__(
    method shape (line 137) | def shape(self) -> Tuple[int, ...]:
    method is_np_flattenable (line 142) | def is_np_flattenable(self):
    method is_bounded (line 146) | def is_bounded(self, manner: str = "both") -> bool:
    method sample (line 171) | def sample(self, mask: None = None) -> np.ndarray:
    method contains (line 224) | def contains(self, x) -> bool:
    method to_jsonable (line 240) | def to_jsonable(self, sample_n):
    method from_jsonable (line 244) | def from_jsonable(self, sample_n: Sequence[Union[float, int]]) -> List...
    method __repr__ (line 248) | def __repr__(self) -> str:
    method __eq__ (line 259) | def __eq__(self, other) -> bool:
    method __setstate__ (line 269) | def __setstate__(self, state: Dict):
  function get_inf (line 281) | def get_inf(dtype, sign: str) -> SupportsFloat:
  function get_precision (line 313) | def get_precision(dtype) -> SupportsFloat:
  function _broadcast (line 321) | def _broadcast(

FILE: gym/spaces/dict.py
  class Dict (line 15) | class Dict(Space[TypingDict[str, Space]], Mapping):
    method __init__ (line 54) | def __init__(
    method is_np_flattenable (line 121) | def is_np_flattenable(self):
    method seed (line 125) | def seed(self, seed: Optional[Union[dict, int]] = None) -> list:
    method sample (line 162) | def sample(self, mask: Optional[TypingDict[str, Any]] = None) -> dict:
    method contains (line 186) | def contains(self, x) -> bool:
    method __getitem__ (line 192) | def __getitem__(self, key: str) -> Space:
    method __setitem__ (line 196) | def __setitem__(self, key: str, value: Space):
    method __iter__ (line 203) | def __iter__(self):
    method __len__ (line 207) | def __len__(self) -> int:
    method __repr__ (line 211) | def __repr__(self) -> str:
    method __eq__ (line 217) | def __eq__(self, other) -> bool:
    method to_jsonable (line 225) | def to_jsonable(self, sample_n: list) -> dict:
    method from_jsonable (line 233) | def from_jsonable(self, sample_n: TypingDict[str, list]) -> List[dict]:

FILE: gym/spaces/discrete.py
  class Discrete (line 9) | class Discrete(Space[int]):
    method __init__ (line 20) | def __init__(
    method is_np_flattenable (line 43) | def is_np_flattenable(self):
    method sample (line 47) | def sample(self, mask: Optional[np.ndarray] = None) -> int:
    method contains (line 83) | def contains(self, x) -> bool:
    method __repr__ (line 96) | def __repr__(self) -> str:
    method __eq__ (line 102) | def __eq__(self, other) -> bool:
    method __setstate__ (line 110) | def __setstate__(self, state):

FILE: gym/spaces/graph.py
  class GraphInstance (line 13) | class GraphInstance(NamedTuple):
  class Graph (line 26) | class Graph(Space):
    method __init__ (line 34) | def __init__(
    method is_np_flattenable (line 67) | def is_np_flattenable(self):
    method _generate_sample_space (line 71) | def _generate_sample_space(
    method sample (line 92) | def sample(
    method contains (line 163) | def contains(self, x: GraphInstance) -> bool:
    method __repr__ (line 190) | def __repr__(self) -> str:
    method __eq__ (line 200) | def __eq__(self, other) -> bool:
    method to_jsonable (line 208) | def to_jsonable(self, sample_n: NamedTuple) -> list:
    method from_jsonable (line 221) | def from_jsonable(self, sample_n: Sequence[dict]) -> list:

FILE: gym/spaces/multi_binary.py
  class MultiBinary (line 9) | class MultiBinary(Space[np.ndarray]):
    method __init__ (line 26) | def __init__(
    method shape (line 49) | def shape(self) -> Tuple[int, ...]:
    method is_np_flattenable (line 54) | def is_np_flattenable(self):
    method sample (line 58) | def sample(self, mask: Optional[np.ndarray] = None) -> np.ndarray:
    method contains (line 93) | def contains(self, x) -> bool:
    method to_jsonable (line 104) | def to_jsonable(self, sample_n) -> list:
    method from_jsonable (line 108) | def from_jsonable(self, sample_n) -> list:
    method __repr__ (line 112) | def __repr__(self) -> str:
    method __eq__ (line 116) | def __eq__(self, other) -> bool:

FILE: gym/spaces/multi_discrete.py
  class MultiDiscrete (line 11) | class MultiDiscrete(Space[np.ndarray]):
    method __init__ (line 38) | def __init__(
    method shape (line 60) | def shape(self) -> Tuple[int, ...]:
    method is_np_flattenable (line 65) | def is_np_flattenable(self):
    method sample (line 69) | def sample(self, mask: Optional[tuple] = None) -> np.ndarray:
    method contains (line 125) | def contains(self, x) -> bool:
    method to_jsonable (line 140) | def to_jsonable(self, sample_n: Iterable[np.ndarray]):
    method from_jsonable (line 144) | def from_jsonable(self, sample_n):
    method __repr__ (line 148) | def __repr__(self):
    method __getitem__ (line 152) | def __getitem__(self, index):
    method __len__ (line 165) | def __len__(self):
    method __eq__ (line 173) | def __eq__(self, other):

FILE: gym/spaces/sequence.py
  class Sequence (line 11) | class Sequence(Space[Tuple]):
    method __init__ (line 25) | def __init__(
    method seed (line 44) | def seed(self, seed: Optional[int] = None) -> list:
    method is_np_flattenable (line 51) | def is_np_flattenable(self):
    method sample (line 55) | def sample(
    method contains (line 105) | def contains(self, x) -> bool:
    method __repr__ (line 111) | def __repr__(self) -> str:
    method to_jsonable (line 115) | def to_jsonable(self, sample_n: list) -> list:
    method from_jsonable (line 120) | def from_jsonable(self, sample_n: List[List[Any]]) -> list:
    method __eq__ (line 124) | def __eq__(self, other) -> bool:

FILE: gym/spaces/space.py
  class Space (line 24) | class Space(Generic[T_cov]):
    method __init__ (line 50) | def __init__(
    method np_random (line 73) | def np_random(self) -> np.random.Generator:
    method shape (line 81) | def shape(self) -> Optional[Tuple[int, ...]]:
    method is_np_flattenable (line 86) | def is_np_flattenable(self):
    method sample (line 90) | def sample(self, mask: Optional[Any] = None) -> T_cov:
    method seed (line 103) | def seed(self, seed: Optional[int] = None) -> list:
    method contains (line 108) | def contains(self, x) -> bool:
    method __contains__ (line 112) | def __contains__(self, x) -> bool:
    method __setstate__ (line 116) | def __setstate__(self, state: Union[Iterable, Mapping]):
    method to_jsonable (line 142) | def to_jsonable(self, sample_n: Sequence[T_cov]) -> list:
    method from_jsonable (line 147) | def from_jsonable(self, sample_n: list) -> List[T_cov]:

FILE: gym/spaces/text.py
  class Text (line 13) | class Text(Space[str]):
    method __init__ (line 26) | def __init__(
    method sample (line 70) | def sample(
    method contains (line 141) | def contains(self, x: Any) -> bool:
    method __repr__ (line 148) | def __repr__(self) -> str:
    method __eq__ (line 154) | def __eq__(self, other) -> bool:
    method character_set (line 164) | def character_set(self) -> FrozenSet[str]:
    method character_list (line 169) | def character_list(self) -> Tuple[str, ...]:
    method character_index (line 173) | def character_index(self, char: str) -> np.int32:
    method characters (line 178) | def characters(self) -> str:
    method is_np_flattenable (line 183) | def is_np_flattenable(self) -> bool:

FILE: gym/spaces/tuple.py
  class Tuple (line 13) | class Tuple(Space[tuple], CollectionSequence):
    method __init__ (line 26) | def __init__(
    method is_np_flattenable (line 47) | def is_np_flattenable(self):
    method seed (line 51) | def seed(
    method sample (line 89) | def sample(
    method contains (line 118) | def contains(self, x) -> bool:
    method __repr__ (line 128) | def __repr__(self) -> str:
    method to_jsonable (line 132) | def to_jsonable(self, sample_n: CollectionSequence) -> list:
    method from_jsonable (line 140) | def from_jsonable(self, sample_n) -> list:
    method __getitem__ (line 152) | def __getitem__(self, index: int) -> Space:
    method __len__ (line 156) | def __len__(self) -> int:
    method __eq__ (line 160) | def __eq__(self, other) -> bool:

FILE: gym/spaces/utils.py
  function flatdim (line 30) | def flatdim(space: Space) -> int:
  function _flatdim_box_multibinary (line 60) | def _flatdim_box_multibinary(space: Union[Box, MultiBinary]) -> int:
  function _flatdim_discrete (line 65) | def _flatdim_discrete(space: Discrete) -> int:
  function _flatdim_multidiscrete (line 70) | def _flatdim_multidiscrete(space: MultiDiscrete) -> int:
  function _flatdim_tuple (line 75) | def _flatdim_tuple(space: Tuple) -> int:
  function _flatdim_dict (line 84) | def _flatdim_dict(space: Dict) -> int:
  function _flatdim_graph (line 93) | def _flatdim_graph(space: Graph):
  function _flatdim_text (line 100) | def _flatdim_text(space: Text) -> int:
  function flatten (line 109) | def flatten(space: Space[T], x: T) -> FlatType:
  function _flatten_box_multibinary (line 140) | def _flatten_box_multibinary(space, x) -> np.ndarray:
  function _flatten_discrete (line 145) | def _flatten_discrete(space, x) -> np.ndarray:
  function _flatten_multidiscrete (line 152) | def _flatten_multidiscrete(space, x) -> np.ndarray:
  function _flatten_tuple (line 162) | def _flatten_tuple(space, x) -> Union[tuple, np.ndarray]:
  function _flatten_dict (line 171) | def _flatten_dict(space, x) -> Union[dict, np.ndarray]:
  function _flatten_graph (line 178) | def _flatten_graph(space, x) -> GraphInstance:
  function _flatten_text (line 203) | def _flatten_text(space: Text, x: str) -> np.ndarray:
  function _flatten_sequence (line 213) | def _flatten_sequence(space, x) -> tuple:
  function unflatten (line 218) | def unflatten(space: Space[T], x: FlatType) -> T:
  function _unflatten_box_multibinary (line 239) | def _unflatten_box_multibinary(
  function _unflatten_discrete (line 246) | def _unflatten_discrete(space: Discrete, x: np.ndarray) -> int:
  function _unflatten_multidiscrete (line 251) | def _unflatten_multidiscrete(space: MultiDiscrete, x: np.ndarray) -> np....
  function _unflatten_tuple (line 260) | def _unflatten_tuple(space: Tuple, x: Union[np.ndarray, tuple]) -> tuple:
  function _unflatten_dict (line 278) | def _unflatten_dict(space: Dict, x: Union[np.ndarray, TypingDict]) -> dict:
  function _unflatten_graph (line 295) | def _unflatten_graph(space: Graph, x: GraphInstance) -> GraphInstance:
  function _unflatten_text (line 318) | def _unflatten_text(space: Text, x: np.ndarray) -> str:
  function _unflatten_sequence (line 325) | def _unflatten_sequence(space: Sequence, x: tuple) -> tuple:
  function flatten_space (line 330) | def flatten_space(space: Space) -> Union[Dict, Sequence, Tuple, Graph]:
  function _flatten_space_box (line 392) | def _flatten_space_box(space: Box) -> Box:
  function _flatten_space_binary (line 399) | def _flatten_space_binary(space: Union[Discrete, MultiBinary, MultiDiscr...
  function _flatten_space_tuple (line 404) | def _flatten_space_tuple(space: Tuple) -> Union[Box, Tuple]:
  function _flatten_space_dict (line 416) | def _flatten_space_dict(space: Dict) -> Union[Box, Dict]:
  function _flatten_space_graph (line 432) | def _flatten_space_graph(space: Graph) -> Graph:
  function _flatten_space_text (line 442) | def _flatten_space_text(space: Text) -> Box:
  function _flatten_space_sequence (line 449) | def _flatten_space_sequence(space: Sequence) -> Sequence:

FILE: gym/utils/colorize.py
  function colorize (line 19) | def colorize(

FILE: gym/utils/env_checker.py
  function data_equivalence (line 33) | def data_equivalence(data_1, data_2) -> bool:
  function check_reset_seed (line 62) | def check_reset_seed(env: gym.Env):
  function check_reset_options (line 131) | def check_reset_options(env: gym.Env):
  function check_reset_return_info_deprecation (line 159) | def check_reset_return_info_deprecation(env: gym.Env):
  function check_seed_deprecation (line 176) | def check_seed_deprecation(env: gym.Env):
  function check_reset_return_type (line 192) | def check_reset_return_type(env: gym.Env):
  function check_space_limit (line 217) | def check_space_limit(space, space_type: str):
  function check_env (line 255) | def check_env(env: gym.Env, warn: bool = None, skip_render_check: bool =...

FILE: gym/utils/ezpickle.py
  class EzPickle (line 4) | class EzPickle:
    method __init__ (line 20) | def __init__(self, *args, **kwargs):
    method __getstate__ (line 25) | def __getstate__(self):
    method __setstate__ (line 32) | def __setstate__(self, d):

FILE: gym/utils/passive_env_checker.py
  function _check_box_observation_space (line 11) | def _check_box_observation_space(observation_space: spaces.Box):
  function _check_box_action_space (line 50) | def _check_box_action_space(action_space: spaces.Box):
  function check_space (line 69) | def check_space(
  function check_obs (line 122) | def check_obs(obs, observation_space: spaces.Space, method_name: str):
  function env_reset_passive_checker (line 170) | def env_reset_passive_checker(env, **kwargs):
  function env_step_passive_checker (line 211) | def env_step_passive_checker(env, action):
  function env_render_passive_checker (line 268) | def env_render_passive_checker(env, *args, **kwargs):

FILE: gym/utils/play.py
  class MissingKeysToAction (line 33) | class MissingKeysToAction(Exception):
  class PlayableGame (line 37) | class PlayableGame:
    method __init__ (line 40) | def __init__(
    method _get_relevant_keys (line 66) | def _get_relevant_keys(
    method _get_video_size (line 83) | def _get_video_size(self, zoom: Optional[float] = None) -> Tuple[int, ...
    method process_event (line 95) | def process_event(self, event: Event):
  function display_arr (line 119) | def display_arr(
  function play (line 137) | def play(
  class PlayPlot (line 278) | class PlayPlot:
    method __init__ (line 306) | def __init__(
    method callback (line 344) | def callback(

FILE: gym/utils/save_video.py
  function capped_cubic_video_schedule (line 16) | def capped_cubic_video_schedule(episode_id: int) -> bool:
  function save_video (line 33) | def save_video(

FILE: gym/utils/seeding.py
  function np_random (line 9) | def np_random(seed: Optional[int] = None) -> Tuple[np.random.Generator, ...

FILE: gym/utils/step_api_compatibility.py
  function convert_to_terminated_truncated_step_api (line 24) | def convert_to_terminated_truncated_step_api(
  function convert_to_done_step_api (line 76) | def convert_to_done_step_api(
  function step_api_compatibility (line 131) | def step_api_compatibility(

FILE: gym/vector/__init__.py
  function make (line 12) | def make(

FILE: gym/vector/async_vector_env.py
  class AsyncState (line 35) | class AsyncState(Enum):
  class AsyncVectorEnv (line 42) | class AsyncVectorEnv(VectorEnv):
    method __init__ (line 59) | def __init__(
    method reset_async (line 170) | def reset_async(
    method reset_wait (line 213) | def reset_wait(
    method step_async (line 263) | def step_async(self, actions: np.ndarray):
    method step_wait (line 288) | def step_wait(
    method call_async (line 348) | def call_async(self, name: str, *args, **kwargs):
    method call_wait (line 372) | def call_wait(self, timeout: Optional[Union[int, float]] = None) -> list:
    method set_attr (line 405) | def set_attr(self, name: str, values: Union[list, tuple, object]):
    method close_extras (line 440) | def close_extras(
    method _poll (line 483) | def _poll(self, timeout=None):
    method _check_spaces (line 497) | def _check_spaces(self):
    method _assert_is_running (line 518) | def _assert_is_running(self):
    method _raise_if_errors (line 524) | def _raise_if_errors(self, successes):
    method __del__ (line 543) | def __del__(self):
  function _worker (line 549) | def _worker(index, env_fn, pipe, parent_pipe, shared_memory, error_queue):
  function _worker_shared_memory (line 616) | def _worker_shared_memory(index, env_fn, pipe, parent_pipe, shared_memor...

FILE: gym/vector/sync_vector_env.py
  class SyncVectorEnv (line 15) | class SyncVectorEnv(VectorEnv):
    method __init__ (line 30) | def __init__(
    method seed (line 74) | def seed(self, seed: Optional[Union[int, Sequence[int]]] = None):
    method reset_wait (line 90) | def reset_wait(
    method step_async (line 131) | def step_async(self, actions):
    method step_wait (line 135) | def step_wait(self):
    method call (line 171) | def call(self, name, *args, **kwargs) -> tuple:
    method set_attr (line 192) | def set_attr(self, name: str, values: Union[list, tuple, Any]):
    method close_extras (line 216) | def close_extras(self, **kwargs):
    method _check_spaces (line 220) | def _check_spaces(self) -> bool:

FILE: gym/vector/utils/misc.py
  class CloudpickleWrapper (line 8) | class CloudpickleWrapper:
    method __init__ (line 11) | def __init__(self, fn: callable):
    method __getstate__ (line 15) | def __getstate__(self):
    method __setstate__ (line 21) | def __setstate__(self, ob):
    method __call__ (line 27) | def __call__(self):
  function clear_mpi_env_vars (line 33) | def clear_mpi_env_vars():

FILE: gym/vector/utils/numpy_utils.py
  function concatenate (line 14) | def concatenate(
  function _concatenate_base (line 49) | def _concatenate_base(space, items, out):
  function _concatenate_tuple (line 54) | def _concatenate_tuple(space, items, out):
  function _concatenate_dict (line 62) | def _concatenate_dict(space, items, out):
  function _concatenate_custom (line 72) | def _concatenate_custom(space, items, out):
  function create_empty_array (line 77) | def create_empty_array(
  function _create_empty_array_base (line 114) | def _create_empty_array_base(space, n=1, fn=np.zeros):
  function _create_empty_array_tuple (line 120) | def _create_empty_array_tuple(space, n=1, fn=np.zeros):
  function _create_empty_array_dict (line 125) | def _create_empty_array_dict(space, n=1, fn=np.zeros):
  function _create_empty_array_custom (line 135) | def _create_empty_array_custom(space, n=1, fn=np.zeros):

FILE: gym/vector/utils/shared_memory.py
  function create_shared_memory (line 17) | def create_shared_memory(
  function _create_base_shared_memory (line 48) | def _create_base_shared_memory(space, n: int = 1, ctx=mp):
  function _create_tuple_shared_memory (line 56) | def _create_tuple_shared_memory(space, n: int = 1, ctx=mp):
  function _create_dict_shared_memory (line 63) | def _create_dict_shared_memory(space, n=1, ctx=mp):
  function read_from_shared_memory (line 73) | def read_from_shared_memory(
  function _read_base_from_shared_memory (line 108) | def _read_base_from_shared_memory(space, shared_memory, n: int = 1):
  function _read_tuple_from_shared_memory (line 115) | def _read_tuple_from_shared_memory(space, shared_memory, n: int = 1):
  function _read_dict_from_shared_memory (line 123) | def _read_dict_from_shared_memory(space, shared_memory, n: int = 1):
  function write_to_shared_memory (line 133) | def write_to_shared_memory(
  function _write_base_to_shared_memory (line 164) | def _write_base_to_shared_memory(space, index, value, shared_memory):
  function _write_tuple_to_shared_memory (line 174) | def _write_tuple_to_shared_memory(space, index, values, shared_memory):
  function _write_dict_to_shared_memory (line 180) | def _write_dict_to_shared_memory(space, index, values, shared_memory):

FILE: gym/vector/utils/spaces.py
  function batch_space (line 18) | def batch_space(space: Space, n: int = 1) -> Space:
  function _batch_space_box (line 47) | def _batch_space_box(space, n=1):
  function _batch_space_discrete (line 54) | def _batch_space_discrete(space, n=1):
  function _batch_space_multidiscrete (line 72) | def _batch_space_multidiscrete(space, n=1):
  function _batch_space_multibinary (line 84) | def _batch_space_multibinary(space, n=1):
  function _batch_space_tuple (line 95) | def _batch_space_tuple(space, n=1):
  function _batch_space_dict (line 103) | def _batch_space_dict(space, n=1):
  function _batch_space_custom (line 116) | def _batch_space_custom(space, n=1):
  function iterate (line 128) | def iterate(space: Space, items) -> Iterator:
  function _iterate_discrete (line 164) | def _iterate_discrete(space, items):
  function _iterate_base (line 171) | def _iterate_base(space, items):
  function _iterate_tuple (line 179) | def _iterate_tuple(space, items):
  function _iterate_dict (line 194) | def _iterate_dict(space, items):
  function _iterate_custom (line 206) | def _iterate_custom(space, items):

FILE: gym/vector/vector_env.py
  class VectorEnv (line 12) | class VectorEnv(gym.Env):
    method __init__ (line 25) | def __init__(
    method reset_async (line 51) | def reset_async(
    method reset_wait (line 67) | def reset_wait(
    method reset (line 88) | def reset(
    method step_async (line 106) | def step_async(self, actions):
    method step_wait (line 115) | def step_wait(self, **kwargs):
    method step (line 127) | def step(self, actions):
    method call_async (line 139) | def call_async(self, name, *args, **kwargs):
    method call_wait (line 142) | def call_wait(self, **kwargs) -> List[Any]:  # type: ignore
    method call (line 145) | def call(self, name: str, *args, **kwargs) -> List[Any]:
    method get_attr (line 159) | def get_attr(self, name: str):
    method set_attr (line 170) | def set_attr(self, name: str, values: Union[list, tuple, object]):
    method close_extras (line 180) | def close_extras(self, **kwargs):
    method close (line 184) | def close(self, **kwargs):
    method _add_info (line 208) | def _add_info(self, infos: dict, info: dict, env_num: int) -> dict:
    method _init_info_arrays (line 235) | def _init_info_arrays(self, dtype: type) -> Tuple[np.ndarray, np.ndarr...
    method __del__ (line 260) | def __del__(self):
    method __repr__ (line 265) | def __repr__(self) -> str:
  class VectorEnvWrapper (line 277) | class VectorEnvWrapper(VectorEnv):
    method __init__ (line 288) | def __init__(self, env: VectorEnv):
    method reset_async (line 294) | def reset_async(self, **kwargs):
    method reset_wait (line 297) | def reset_wait(self, **kwargs):
    method step_async (line 300) | def step_async(self, actions):
    method step_wait (line 303) | def step_wait(self):
    method close (line 306) | def close(self, **kwargs):
    method close_extras (line 309) | def close_extras(self, **kwargs):
    method call (line 312) | def call(self, name, *args, **kwargs):
    method set_attr (line 315) | def set_attr(self, name, values):
    method __getattr__ (line 319) | def __getattr__(self, name):
    method unwrapped (line 325) | def unwrapped(self):
    method __repr__ (line 328) | def __repr__(self):
    method __del__ (line 331) | def __del__(self):

FILE: gym/wrappers/atari_preprocessing.py
  class AtariPreprocessing (line 13) | class AtariPreprocessing(gym.Wrapper):
    method __init__ (line 30) | def __init__(
    method ale (line 115) | def ale(self):
    method step (line 119) | def step(self, action):
    method reset (line 148) | def reset(self, **kwargs):
    method _get_obs (line 173) | def _get_obs(self):

FILE: gym/wrappers/autoreset.py
  class AutoResetWrapper (line 5) | class AutoResetWrapper(gym.Wrapper):
    method __init__ (line 27) | def __init__(self, env: gym.Env):
    method step (line 35) | def step(self, action):

FILE: gym/wrappers/clip_action.py
  class ClipAction (line 9) | class ClipAction(ActionWrapper):
    method __init__ (line 22) | def __init__(self, env: gym.Env):
    method action (line 31) | def action(self, action):

FILE: gym/wrappers/compatibility.py
  class LegacyEnv (line 19) | class LegacyEnv(Protocol):
    method reset (line 25) | def reset(self) -> Any:
    method step (line 29) | def step(self, action: Any) -> Tuple[Any, float, bool, Dict]:
    method render (line 33) | def render(self, mode: Optional[str] = "human") -> Any:
    method close (line 37) | def close(self):
    method seed (line 41) | def seed(self, seed: Optional[int] = None):
  class EnvCompatibility (line 46) | class EnvCompatibility(gym.Env):
    method __init__ (line 57) | def __init__(self, old_env: LegacyEnv, render_mode: Optional[str] = No...
    method reset (line 75) | def reset(
    method step (line 96) | def step(self, action: Any) -> Tuple[Any, float, bool, bool, Dict]:
    method render (line 112) | def render(self) -> Any:
    method close (line 120) | def close(self):
    method __str__ (line 124) | def __str__(self):
    method __repr__ (line 128) | def __repr__(self):

FILE: gym/wrappers/env_checker.py
  class PassiveEnvChecker (line 13) | class PassiveEnvChecker(gym.Wrapper):
    method __init__ (line 16) | def __init__(self, env):
    method step (line 33) | def step(self, action: ActType):
    method reset (line 41) | def reset(self, **kwargs):
    method render (line 49) | def render(self, *args, **kwargs):

FILE: gym/wrappers/filter_observation.py
  class FilterObservation (line 9) | class FilterObservation(gym.ObservationWrapper):
    method __init__ (line 27) | def __init__(self, env: gym.Env, filter_keys: Sequence[str] = None):
    method observation (line 71) | def observation(self, observation):
    method _filter_observation (line 83) | def _filter_observation(self, observation):

FILE: gym/wrappers/flatten_observation.py
  class FlattenObservation (line 6) | class FlattenObservation(gym.ObservationWrapper):
    method __init__ (line 22) | def __init__(self, env: gym.Env):
    method observation (line 31) | def observation(self, observation):

FILE: gym/wrappers/frame_stack.py
  class LazyFrames (line 12) | class LazyFrames:
    method __init__ (line 23) | def __init__(self, frames: list, lz4_compress: bool = False):
    method __array__ (line 48) | def __array__(self, dtype=None):
    method __len__ (line 62) | def __len__(self):
    method __getitem__ (line 70) | def __getitem__(self, int_or_slice: Union[int, slice]):
    method __eq__ (line 86) | def __eq__(self, other):
    method _check_decompress (line 90) | def _check_decompress(self, frame):
  class FrameStack (line 100) | class FrameStack(gym.ObservationWrapper):
    method __init__ (line 125) | def __init__(
    method observation (line 152) | def observation(self, observation):
    method step (line 164) | def step(self, action):
    method reset (line 177) | def reset(self, **kwargs):

FILE: gym/wrappers/gray_scale_observation.py
  class GrayScaleObservation (line 8) | class GrayScaleObservation(gym.ObservationWrapper):
    method __init__ (line 23) | def __init__(self, env: gym.Env, keep_dim: bool = False):
    method observation (line 50) | def observation(self, observation):

FILE: gym/wrappers/human_rendering.py
  class HumanRendering (line 8) | class HumanRendering(gym.Wrapper):
    method __init__ (line 42) | def __init__(self, env):
    method render_mode (line 62) | def render_mode(self):
    method step (line 66) | def step(self, *args, **kwargs):
    method reset (line 72) | def reset(self, *args, **kwargs):
    method render (line 78) | def render(self):
    method _render_frame (line 82) | def _render_frame(self):
    method close (line 125) | def close(self):

FILE: gym/wrappers/monitoring/video_recorder.py
  class VideoRecorder (line 11) | class VideoRecorder:
    method __init__ (line 20) | def __init__(
    method functional (line 105) | def functional(self):
    method capture_frame (line 109) | def capture_frame(self):
    method close (line 139) | def close(self):
    method write_metadata (line 170) | def write_metadata(self):
    method __del__ (line 175) | def __del__(self):

FILE: gym/wrappers/normalize.py
  class RunningMeanStd (line 8) | class RunningMeanStd:
    method __init__ (line 12) | def __init__(self, epsilon=1e-4, shape=()):
    method update (line 18) | def update(self, x):
    method update_from_moments (line 25) | def update_from_moments(self, batch_mean, batch_var, batch_count):
  function update_mean_var_count_from_moments (line 32) | def update_mean_var_count_from_moments(
  class NormalizeObservation (line 49) | class NormalizeObservation(gym.core.Wrapper):
    method __init__ (line 57) | def __init__(self, env: gym.Env, epsilon: float = 1e-8):
    method step (line 73) | def step(self, action):
    method reset (line 82) | def reset(self, **kwargs):
    method normalize (line 91) | def normalize(self, obs):
  class NormalizeReward (line 97) | class NormalizeReward(gym.core.Wrapper):
    method __init__ (line 107) | def __init__(
    method step (line 128) | def step(self, action):
    method normalize (line 141) | def normalize(self, rews):

FILE: gym/wrappers/order_enforcing.py
  class OrderEnforcing (line 6) | class OrderEnforcing(gym.Wrapper):
    method __init__ (line 22) | def __init__(self, env: gym.Env, disable_render_order_enforcing: bool ...
    method step (line 33) | def step(self, action):
    method reset (line 39) | def reset(self, **kwargs):
    method render (line 44) | def render(self, *args, **kwargs):
    method has_reset (line 54) | def has_reset(self):

FILE: gym/wrappers/pixel_observation.py
  class PixelObservationWrapper (line 15) | class PixelObservationWrapper(gym.ObservationWrapper):
    method __init__ (line 49) | def __init__(
    method observation (line 165) | def observation(self, observation):
    method _add_pixel_observation (line 177) | def _add_pixel_observation(self, wrapped_observation):
    method render (line 195) | def render(self, *args, **kwargs):
    method _render (line 203) | def _render(self, *args, **kwargs):

FILE: gym/wrappers/record_episode_statistics.py
  function add_vector_episode_statistics (line 11) | def add_vector_episode_statistics(
  class RecordEpisodeStatistics (line 40) | class RecordEpisodeStatistics(gym.Wrapper):
    method __init__ (line 79) | def __init__(self, env: gym.Env, deque_size: int = 100):
    method reset (line 96) | def reset(self, **kwargs):
    method step (line 103) | def step(self, action):

FILE: gym/wrappers/record_video.py
  function capped_cubic_video_schedule (line 10) | def capped_cubic_video_schedule(episode_id: int) -> bool:
  class RecordVideo (line 27) | class RecordVideo(gym.Wrapper):
    method __init__ (line 40) | def __init__(
    method reset (line 92) | def reset(self, **kwargs):
    method start_video_recorder (line 109) | def start_video_recorder(self):
    method _video_enabled (line 128) | def _video_enabled(self):
    method step (line 134) | def step(self, action):
    method close_video_recorder (line 176) | def close_video_recorder(self):
    method render (line 184) | def render(self, *args, **kwargs):
    method close (line 204) | def close(self):
    method __del__ (line 209) | def __del__(self):

FILE: gym/wrappers/render_collection.py
  class RenderCollection (line 5) | class RenderCollection(gym.Wrapper):
    method __init__ (line 8) | def __init__(self, env: gym.Env, pop_frames: bool = True, reset_clean:...
    method render_mode (line 26) | def render_mode(self):
    method step (line 30) | def step(self, *args, **kwargs):
    method reset (line 36) | def reset(self, *args, **kwargs):
    method render (line 46) | def render(self):

FILE: gym/wrappers/rescale_action.py
  class RescaleAction (line 10) | class RescaleAction(gym.ActionWrapper):
    method __init__ (line 30) | def __init__(
    method action (line 62) | def action(self, action):

FILE: gym/wrappers/resize_observation.py
  class ResizeObservation (line 11) | class ResizeObservation(gym.ObservationWrapper):
    method __init__ (line 28) | def __init__(self, env: gym.Env, shape: Union[tuple, int]):
    method observation (line 48) | def observation(self, observation):

FILE: gym/wrappers/step_api_compatibility.py
  class StepAPICompatibility (line 10) | class StepAPICompatibility(gym.Wrapper):
    method __init__ (line 31) | def __init__(self, env: gym.Env, output_truncation_bool: bool = True):
    method step (line 45) | def step(self, action):

FILE: gym/wrappers/time_aware_observation.py
  class TimeAwareObservation (line 8) | class TimeAwareObservation(gym.ObservationWrapper):
    method __init__ (line 24) | def __init__(self, env: gym.Env):
    method observation (line 38) | def observation(self, observation):
    method step (line 49) | def step(self, action):
    method reset (line 61) | def reset(self, **kwargs):

FILE: gym/wrappers/time_limit.py
  class TimeLimit (line 7) | class TimeLimit(gym.Wrapper):
    method __init__ (line 20) | def __init__(
    method step (line 39) | def step(self, action):
    method reset (line 58) | def reset(self, **kwargs):

FILE: gym/wrappers/transform_observation.py
  class TransformObservation (line 7) | class TransformObservation(gym.ObservationWrapper):
    method __init__ (line 23) | def __init__(self, env: gym.Env, f: Callable[[Any], Any]):
    method observation (line 34) | def observation(self, observation):

FILE: gym/wrappers/transform_reward.py
  class TransformReward (line 8) | class TransformReward(RewardWrapper):
    method __init__ (line 24) | def __init__(self, env: gym.Env, f: Callable[[float], float]):
    method reward (line 35) | def reward(self, reward):

FILE: gym/wrappers/vector_list_info.py
  class VectorListInfo (line 8) | class VectorListInfo(gym.Wrapper):
    method __init__ (line 32) | def __init__(self, env):
    method step (line 43) | def step(self, action):
    method reset (line 50) | def reset(self, **kwargs):
    method _convert_info_to_list (line 56) | def _convert_info_to_list(self, infos: dict) -> List[dict]:
    method _process_episode_statistics (line 80) | def _process_episode_statistics(self, infos: dict, list_info: list) ->...

FILE: tests/envs/test_action_dim_check.py
  function test_mujoco_action_dimensions (line 15) | def test_mujoco_action_dimensions(env_spec: EnvSpec):
  function test_discrete_actions_out_of_bound (line 62) | def test_discrete_actions_out_of_bound(env: gym.Env):
  function test_box_actions_out_of_bound (line 91) | def test_box_actions_out_of_bound(env: gym.Env):

FILE: tests/envs/test_compatibility.py
  class LegacyEnvExplicit (line 11) | class LegacyEnvExplicit(LegacyEnv, gym.Env):
    method __init__ (line 18) | def __init__(self):
    method reset (line 21) | def reset(self):
    method step (line 24) | def step(self, action):
    method render (line 27) | def render(self, mode="human"):
    method close (line 33) | def close(self):
    method seed (line 36) | def seed(self, seed=None):
  class LegacyEnvImplicit (line 40) | class LegacyEnvImplicit(gym.Env):
    method __init__ (line 47) | def __init__(self):
    method reset (line 50) | def reset(self):  # type: ignore
    method step (line 53) | def step(self, action: Any) -> Tuple[int, float, bool, Dict]:
    method render (line 56) | def render(self, mode: Optional[str] = "human") -> Any:
    method close (line 62) | def close(self):
    method seed (line 65) | def seed(self, seed: Optional[int] = None):
  function test_explicit (line 69) | def test_explicit():
  function test_implicit (line 82) | def test_implicit():
  function test_make_compatibility_in_spec (line 97) | def test_make_compatibility_in_spec():
  function test_make_compatibility_in_make (line 116) | def test_make_compatibility_in_make():

FILE: tests/envs/test_env_implementation.py
  function test_lunar_lander_heuristics (line 13) | def test_lunar_lander_heuristics():
  function test_carracing_domain_randomize (line 20) | def test_carracing_domain_randomize():
  function test_bipedal_walker_hardcore_creation (line 60) | def test_bipedal_walker_hardcore_creation(seed: int):
  function test_frozenlake_dfs_map_generation (line 99) | def test_frozenlake_dfs_map_generation(map_size: int):
  function test_taxi_action_mask (line 129) | def test_taxi_action_mask():
  function test_taxi_encode_decode (line 139) | def test_taxi_encode_decode():
  function test_customizable_resets (line 157) | def test_customizable_resets(env_name: str, low_high: Optional[list]):
  function test_customizable_pendulum_resets (line 180) | def test_customizable_pendulum_resets(low_high: Optional[list]):
  function test_invalid_customizable_resets (line 209) | def test_invalid_customizable_resets(env_name: str, low_high: list):

FILE: tests/envs/test_envs.py
  function test_envs_pass_env_checker (line 41) | def test_envs_pass_env_checker(spec):
  function test_env_determinism_rollout (line 63) | def test_env_determinism_rollout(env_spec: EnvSpec):
  function check_rendered (line 118) | def check_rendered(rendered_frame, mode: str):
  function test_render_modes (line 161) | def test_render_modes(spec):
  function test_pickle_env (line 192) | def test_pickle_env(env: gym.Env):

FILE: tests/envs/test_make.py
  function test_make (line 49) | def test_make():
  function test_make_deprecated (line 56) | def test_make_deprecated():
  function test_make_max_episode_steps (line 67) | def test_make_max_episode_steps():
  function test_gym_make_autoreset (line 91) | def test_gym_make_autoreset():
  function test_make_disable_env_checker (line 106) | def test_make_disable_env_checker():
  function test_apply_api_compatibility (line 135) | def test_apply_api_compatibility():
  function test_passive_checker_wrapper_warnings (line 168) | def test_passive_checker_wrapper_warnings(spec):
  function test_make_order_enforcing (line 182) | def test_make_order_enforcing():
  function test_make_render_mode (line 203) | def test_make_render_mode():
  function test_make_kwargs (line 288) | def test_make_kwargs():
  function test_import_module_during_make (line 303) | def test_import_module_during_make():

FILE: tests/envs/test_mujoco.py
  function verify_environments_match (line 12) | def verify_environments_match(
  function test_obs_space_mujoco_environments (line 61) | def test_obs_space_mujoco_environments(env_spec: EnvSpec):
  function test_mujoco_v2_to_v3_conversion (line 113) | def test_mujoco_v2_to_v3_conversion(env_name: str):
  function test_mujoco_incompatible_v3_to_v2 (line 119) | def test_mujoco_incompatible_v3_to_v2(env_name: str):

FILE: tests/envs/test_register.py
  function register_testing_envs (line 11) | def register_testing_envs():
  function test_register (line 63) | def test_register(
  function test_register_error (line 88) | def test_register_error(env_id):
  function test_env_suggestions (line 108) | def test_env_suggestions(register_testing_envs, env_id_input, env_id_sug...
  function test_env_version_suggestions (line 126) | def test_env_version_suggestions(
  function test_register_versioned_unversioned (line 143) | def test_register_versioned_unversioned():
  function test_make_latest_versioned_env (line 176) | def test_make_latest_versioned_env(register_testing_envs):
  function test_namespace (line 189) | def test_namespace():

FILE: tests/envs/test_spec.py
  function test_spec (line 10) | def test_spec():
  function test_spec_kwargs (line 16) | def test_spec_kwargs():
  function test_spec_missing_lookup (line 22) | def test_spec_missing_lookup():
  function test_spec_malformed_lookup (line 51) | def test_spec_malformed_lookup():
  function test_spec_versioned_lookups (line 59) | def test_spec_versioned_lookups():
  function test_spec_default_lookups (line 81) | def test_spec_default_lookups():

FILE: tests/envs/utils.py
  function try_make_env (line 11) | def try_make_env(env_spec: EnvSpec) -> Optional[gym.Env]:
  function assert_equals (line 66) | def assert_equals(a, b, prefix=None):

FILE: tests/envs/utils_envs.py
  class RegisterDuringMakeEnv (line 4) | class RegisterDuringMakeEnv(gym.Env):
    method __init__ (line 7) | def __init__(self):
  class ArgumentEnv (line 12) | class ArgumentEnv(gym.Env):
    method __init__ (line 16) | def __init__(self, arg1, arg2, arg3):
  class NoHuman (line 23) | class NoHuman(gym.Env):
    method __init__ (line 28) | def __init__(self, render_mode=None):
  class NoHumanOldAPI (line 33) | class NoHumanOldAPI(gym.Env):
    method __init__ (line 38) | def __init__(self):
  class NoHumanNoRGB (line 42) | class NoHumanNoRGB(gym.Env):
    method __init__ (line 47) | def __init__(self, render_mode=None):

FILE: tests/spaces/test_box.py
  function test_shape_inference (line 36) | def test_shape_inference(box, expected_shape):
  function test_low_high_values (line 60) | def test_low_high_values(value, valid: bool):
  function test_init_errors (line 142) | def test_init_errors(low, high, kwargs, error, message):
  function test_dtype_check (line 148) | def test_dtype_check():
  function test_infinite_space (line 199) | def test_infinite_space(space):
  function test_legacy_state_pickling (line 264) | def test_legacy_state_pickling():
  function test_get_inf (line 286) | def test_get_inf():
  function test_sample_mask (line 309) | def test_sample_mask():

FILE: tests/spaces/test_dict.py
  function test_dict_init (line 9) | def test_dict_init():
  function test_dict_seeding (line 56) | def test_dict_seeding():
  function test_int_seeding (line 83) | def test_int_seeding():
  function test_none_seeding (line 106) | def test_none_seeding():
  function test_bad_seed (line 111) | def test_bad_seed():
  function test_mapping (line 116) | def test_mapping():
  function test_iterator (line 135) | def test_iterator():

FILE: tests/spaces/test_discrete.py
  function test_space_legacy_pickling (line 6) | def test_space_legacy_pickling():
  function test_sample_mask (line 35) | def test_sample_mask():

FILE: tests/spaces/test_graph.py
  function test_node_space_sample (line 9) | def test_node_space_sample():
  function test_edge_space_sample (line 49) | def test_edge_space_sample():
  function test_not_contains (line 135) | def test_not_contains(sample):

FILE: tests/spaces/test_multibinary.py
  function test_sample (line 6) | def test_sample():

FILE: tests/spaces/test_multidiscrete.py
  function test_multidiscrete_as_tuple (line 7) | def test_multidiscrete_as_tuple():
  function test_multidiscrete_subspace_reproducibility (line 31) | def test_multidiscrete_subspace_reproducibility():
  function test_multidiscrete_length (line 57) | def test_multidiscrete_length():

FILE: tests/spaces/test_sequence.py
  function test_sample (line 9) | def test_sample():

FILE: tests/spaces/test_space.py
  function test_not_implemented_errors (line 22) | def test_not_implemented_errors(func):

FILE: tests/spaces/test_spaces.py
  function test_roundtripping (line 36) | def test_roundtripping(space: Space):
  function test_space_equality (line 60) | def test_space_equality(space_1, space_2):
  function test_sample (line 91) | def test_sample(space: Space, n_trials: int = 1_000):
  function test_space_sample_mask (line 234) | def test_space_sample_mask(space: Space, mask, n_trials: int = 100):
  function test_seed_reproducibility (line 385) | def test_seed_reproducibility(space):
  function test_seed_np_random (line 425) | def test_seed_np_random(space_cls, kwarg):
  function test_sample_contains (line 437) | def test_sample_contains(space):
  function test_repr (line 453) | def test_repr(space):
  function test_space_pickling (line 458) | def test_space_pickling(space):

FILE: tests/spaces/test_text.py
  function test_sample_mask (line 9) | def test_sample_mask():

FILE: tests/spaces/test_tuple.py
  function test_sequence_inheritance (line 9) | def test_sequence_inheritance():
  function test_seeds (line 64) | def test_seeds(space, seed, expected_len):
  function test_bad_space_calls (line 86) | def test_bad_space_calls(space_fn):
  function test_contains_promotion (line 91) | def test_contains_promotion():
  function test_bad_seed (line 103) | def test_bad_seed():

FILE: tests/spaces/test_utils.py
  function test_flatdim (line 59) | def test_flatdim(space: gym.spaces.Space, flatdim: Optional[int]):
  function test_flatten_space (line 72) | def test_flatten_space(space):
  function test_flatten (line 100) | def test_flatten(space):
  function test_flat_space_contains_flat_points (line 115) | def test_flat_space_contains_flat_points(space):
  function test_flatten_roundtripping (line 125) | def test_flatten_roundtripping(space):

FILE: tests/test_core.py
  class ArgumentEnv (line 10) | class ArgumentEnv(core.Env):
    method __init__ (line 15) | def __init__(self, arg):
  class UnittestEnv (line 20) | class UnittestEnv(core.Env):
    method reset (line 24) | def reset(self, *, seed: Optional[int] = None, options: Optional[dict]...
    method step (line 28) | def step(self, action):
  class UnknownSpacesEnv (line 33) | class UnknownSpacesEnv(core.Env):
    method reset (line 40) | def reset(self, *, seed: Optional[int] = None, options: Optional[dict]...
    method step (line 48) | def step(self, action):
  class OldStyleEnv (line 53) | class OldStyleEnv(core.Env):
    method __init__ (line 56) | def __init__(self):
    method reset (line 59) | def reset(self):
    method step (line 63) | def step(self, action):
  class NewPropertyWrapper (line 67) | class NewPropertyWrapper(core.Wrapper):
    method __init__ (line 68) | def __init__(
  function test_env_instantiation (line 88) | def test_env_instantiation():
  function test_wrapper_property_forwarding (line 116) | def test_wrapper_property_forwarding(class_, props):
  function test_compatibility_with_old_style_env (line 134) | def test_compatibility_with_old_style_env():

FILE: tests/testing_env.py
  function basic_reset_fn (line 11) | def basic_reset_fn(
  function new_step_fn (line 23) | def new_step_fn(self, action: ActType) -> Tuple[ObsType, float, bool, bo...
  function old_step_fn (line 28) | def old_step_fn(self, action: ActType) -> Tuple[ObsType, float, bool, di...
  function basic_render_fn (line 33) | def basic_render_fn(self):
  class GenericTestEnv (line 39) | class GenericTestEnv(gym.Env):
    method __init__ (line 42) | def __init__(
    method reset (line 69) | def reset(
    method step (line 78) | def step(self, action: ActType) -> Tuple[ObsType, float, bool, dict]:
    method render (line 81) | def render(self):

FILE: tests/utils/test_env_checker.py
  function test_no_error_warnings (line 48) | def test_no_error_warnings(env):
  function _no_super_reset (line 56) | def _no_super_reset(self, seed=None, options=None):
  function _super_reset_fixed (line 63) | def _super_reset_fixed(self, seed=None, options=None):
  function _reset_default_seed (line 71) | def _reset_default_seed(self: GenericTestEnv, seed="Error", options=None):
  function test_check_reset_seed (line 109) | def test_check_reset_seed(test, func: callable, message: str):
  function _deprecated_return_info (line 121) | def _deprecated_return_info(
  function _reset_var_keyword_kwargs (line 131) | def _reset_var_keyword_kwargs(self, kwargs):
  function _reset_return_info_type (line 135) | def _reset_return_info_type(self, seed=None, options=None):
  function _reset_return_info_length (line 141) | def _reset_return_info_length(self, seed=None, options=None):
  function _return_info_obs_outside (line 145) | def _return_info_obs_outside(self, seed=None, options=None):
  function _return_info_not_dict (line 149) | def _return_info_not_dict(self, seed=None, options=None):
  function test_check_reset_return_type (line 178) | def test_check_reset_return_type(test, func: callable, message: str):
  function test_check_reset_return_info_deprecation (line 197) | def test_check_reset_return_info_deprecation(test, func: callable, messa...
  function test_check_seed_deprecation (line 204) | def test_check_seed_deprecation():
  function test_check_reset_options (line 231) | def test_check_reset_options():
  function test_check_env (line 259) | def test_check_env(env: gym.Env, message: str):

FILE: tests/utils/test_passive_env_checker.py
  function _modify_space (line 21) | def _modify_space(space: spaces.Space, attribute: str, value):
  function test_check_observation_space (line 108) | def test_check_observation_space(test, space, message: str):
  function test_check_action_space (line 175) | def test_check_action_space(
  function test_check_obs (line 232) | def test_check_obs(test, obs, obs_space: spaces.Space, message: str):
  function _reset_no_seed (line 246) | def _reset_no_seed(self, options=None):
  function _reset_seed_default (line 250) | def _reset_seed_default(self, seed="error", options=None):
  function _reset_no_option (line 254) | def _reset_no_option(self, seed=None):
  function _make_reset_results (line 258) | def _make_reset_results(results):
  function test_passive_env_reset_checker (line 300) | def test_passive_env_reset_checker(test, func: callable, message: str, k...
  function _modified_step (line 314) | def _modified_step(
  function test_passive_env_step_checker (line 378) | def test_passive_env_step_checker(
  function test_passive_render_checker (line 447) | def test_passive_render_checker(test, env: GenericTestEnv, message: str):

FILE: tests/utils/test_play.py
  class KeysToActionWrapper (line 27) | class KeysToActionWrapper(gym.Wrapper):
    method __init__ (line 28) | def __init__(self, env, keys_to_action):
    method get_keys_to_action (line 32) | def get_keys_to_action(self):
  class PlayStatus (line 36) | class PlayStatus:
    method __init__ (line 37) | def __init__(self, callback: Callable):
    method callback (line 42) | def callback(self, obs_t, obs_tp1, action, rew, terminated, truncated,...
  function dummy_keys_to_action (line 50) | def dummy_keys_to_action():
  function dummy_keys_to_action_str (line 54) | def dummy_keys_to_action_str():
  function close_pygame (line 60) | def close_pygame():
  function test_play_relevant_keys (line 65) | def test_play_relevant_keys():
  function test_play_relevant_keys_no_mapping (line 71) | def test_play_relevant_keys_no_mapping():
  function test_play_relevant_keys_with_env_attribute (line 78) | def test_play_relevant_keys_with_env_attribute():
  function test_video_size_no_zoom (line 86) | def test_video_size_no_zoom():
  function test_video_size_zoom (line 92) | def test_video_size_zoom():
  function test_keyboard_quit_event (line 99) | def test_keyboard_quit_event():
  function test_pygame_quit_event (line 108) | def test_pygame_quit_event():
  function test_keyboard_relevant_keydown_event (line 117) | def test_keyboard_relevant_keydown_event():
  function test_keyboard_irrelevant_keydown_event (line 125) | def test_keyboard_irrelevant_keydown_event():
  function test_keyboard_keyup_event (line 133) | def test_keyboard_keyup_event():
  function test_play_loop_real_env (line 143) | def test_play_loop_real_env():
  function test_play_no_keys (line 207) | def test_play_no_keys():

FILE: tests/utils/test_save_video.py
  function test_record_video_using_default_trigger (line 10) | def test_record_video_using_default_trigger():
  function modulo_step_trigger (line 42) | def modulo_step_trigger(mod: int):
  function test_record_video_step_trigger (line 49) | def test_record_video_step_trigger():
  function test_record_video_within_vector (line 79) | def test_record_video_within_vector():

FILE: tests/utils/test_seeding.py
  function test_invalid_seeds (line 7) | def test_invalid_seeds():
  function test_valid_seeds (line 17) | def test_valid_seeds():
  function test_rng_pickle (line 23) | def test_rng_pickle():

FILE: tests/utils/test_step_api_compatibility.py
  function test_to_done_step_api (line 57) | def test_to_done_step_api(
  function test_to_terminated_truncated_step_api (line 115) | def test_to_terminated_truncated_step_api(
  function test_edge_case (line 148) | def test_edge_case():

FILE: tests/vector/test_async_vector_env.py
  function test_create_async_vector_env (line 19) | def test_create_async_vector_env(shared_memory):
  function test_reset_async_vector_env (line 28) | def test_reset_async_vector_env(shared_memory):
  function test_step_async_vector_env (line 59) | def test_step_async_vector_env(shared_memory, use_single_action_space):
  function test_call_async_vector_env (line 99) | def test_call_async_vector_env(shared_memory):
  function test_set_attr_async_vector_env (line 125) | def test_set_attr_async_vector_env(shared_memory):
  function test_copy_async_vector_env (line 137) | def test_copy_async_vector_env(shared_memory):
  function test_no_copy_async_vector_env (line 149) | def test_no_copy_async_vector_env(shared_memory):
  function test_reset_timeout_async_vector_env (line 161) | def test_reset_timeout_async_vector_env(shared_memory):
  function test_step_timeout_async_vector_env (line 173) | def test_step_timeout_async_vector_env(shared_memory):
  function test_reset_out_of_order_async_vector_env (line 185) | def test_reset_out_of_order_async_vector_env(shared_memory):
  function test_step_out_of_order_async_vector_env (line 221) | def test_step_out_of_order_async_vector_env(shared_memory):
  function test_already_closed_async_vector_env (line 256) | def test_already_closed_async_vector_env(shared_memory):
  function test_check_spaces_async_vector_env (line 265) | def test_check_spaces_async_vector_env(shared_memory):
  function test_custom_space_async_vector_env (line 275) | def test_custom_space_async_vector_env():
  function test_custom_space_async_vector_env_shared_memory (line 304) | def test_custom_space_async_vector_env_shared_memory():

FILE: tests/vector/test_numpy_utils.py
  function test_concatenate (line 15) | def test_concatenate(space):
  function test_create_empty_array (line 58) | def test_create_empty_array(space, n):
  function test_create_empty_array_zeros (line 88) | def test_create_empty_array_zeros(space, n):
  function test_create_empty_array_none_shape_ones (line 118) | def test_create_empty_array_none_shape_ones(space):

FILE: tests/vector/test_shared_memory.py
  function test_create_shared_memory (line 51) | def test_create_shared_memory(space, expected_type, n, ctx):
  function test_create_shared_memory_custom_space (line 82) | def test_create_shared_memory_custom_space(n, ctx, space):
  function _write_shared_memory (line 88) | def _write_shared_memory(space, i, shared_memory, sample):
  function test_write_to_shared_memory (line 95) | def test_write_to_shared_memory(space):
  function _process_write (line 130) | def _process_write(space, i, shared_memory, sample):
  function test_read_from_shared_memory (line 137) | def test_read_from_shared_memory(space):

FILE: tests/vector/test_spaces.py
  function test_batch_space (line 96) | def test_batch_space(space, expected_batch_space_4):
  function test_batch_space_custom_space (line 106) | def test_batch_space_custom_space(space, expected_batch_space_4):
  function test_iterate (line 116) | def test_iterate(space, batch_space):
  function test_iterate_custom_space (line 130) | def test_iterate_custom_space(space, batch_space):
  function test_rng_different_at_each_index (line 146) | def test_rng_different_at_each_index(space: Space, n: int, base_seed: int):
  function test_deterministic (line 169) | def test_deterministic(space: Space, n: int, base_seed: int):

FILE: tests/vector/test_sync_vector_env.py
  function test_create_sync_vector_env (line 16) | def test_create_sync_vector_env():
  function test_reset_sync_vector_env (line 24) | def test_reset_sync_vector_env():
  function test_step_sync_vector_env (line 40) | def test_step_sync_vector_env(use_single_action_space):
  function test_call_sync_vector_env (line 79) | def test_call_sync_vector_env():
  function test_set_attr_sync_vector_env (line 104) | def test_set_attr_sync_vector_env():
  function test_check_spaces_sync_vector_env (line 115) | def test_check_spaces_sync_vector_env():
  function test_custom_space_sync_vector_env (line 125) | def test_custom_space_sync_vector_env():
  function test_sync_vector_env_seed (line 154) | def test_sync_vector_env_seed():
  function test_sync_vector_determinism (line 168) | def test_sync_vector_determinism(spec: EnvSpec, seed: int = 123, n: int ...

FILE: tests/vector/test_vector_env.py
  function test_vector_env_equal (line 15) | def test_vector_env_equal(shared_memory):
  function test_custom_space_vector_env (line 56) | def test_custom_space_vector_env():
  function test_final_obs_info (line 75) | def test_final_obs_info(vectoriser):

FILE: tests/vector/test_vector_env_info.py
  function test_vector_env_info (line 15) | def test_vector_env_info(asynchronous):
  function test_vector_env_info_concurrent_termination (line 40) | def test_vector_env_info_concurrent_termination(concurrent_ends):

FILE: tests/vector/test_vector_env_wrapper.py
  class DummyWrapper (line 6) | class DummyWrapper(VectorEnvWrapper):
    method __init__ (line 7) | def __init__(self, env):
    method reset_async (line 11) | def reset_async(self, **kwargs):
  function test_vector_env_wrapper_inheritance (line 16) | def test_vector_env_wrapper_inheritance():
  function test_vector_env_wrapper_attributes (line 23) | def test_vector_env_wrapper_attributes():

FILE: tests/vector/test_vector_make.py
  function test_vector_make_id (line 10) | def test_vector_make_id():
  function test_vector_make_num_envs (line 18) | def test_vector_make_num_envs(num_envs):
  function test_vector_make_asynchronous (line 24) | def test_vector_make_asynchronous():
  function test_vector_make_wrappers (line 34) | def test_vector_make_wrappers():
  function test_vector_make_disable_env_checker (line 64) | def test_vector_make_disable_env_checker():

FILE: tests/vector/utils.py
  class UnittestSlowEnv (line 53) | class UnittestSlowEnv(gym.Env):
    method __init__ (line 54) | def __init__(self, slow_reset=0.3):
    method reset (line 62) | def reset(self, *, seed: Optional[int] = None, options: Optional[dict]...
    method step (line 68) | def step(self, action):
  class CustomSpace (line 75) | class CustomSpace(gym.Space):
    method sample (line 78) | def sample(self):
    method contains (line 81) | def contains(self, x):
    method __eq__ (line 84) | def __eq__(self, other):
  class CustomSpaceEnv (line 94) | class CustomSpaceEnv(gym.Env):
    method __init__ (line 95) | def __init__(self):
    method reset (line 100) | def reset(self, *, seed: Optional[int] = None, options: Optional[dict]...
    method step (line 104) | def step(self, action):
  function make_env (line 110) | def make_env(env_name, seed, **kwargs):
  function make_slow_env (line 120) | def make_slow_env(slow_reset, seed):
  function make_custom_space_env (line 129) | def make_custom_space_env(seed):
  function assert_rng_equal (line 138) | def assert_rng_equal(rng_1: RandomNumberGenerator, rng_2: RandomNumberGe...

FILE: tests/wrappers/test_atari_preprocessing.py
  class AleTesting (line 9) | class AleTesting:
    method lives (line 15) | def lives(self) -> int:
    method getScreenGrayscale (line 19) | def getScreenGrayscale(self, buffer: np.ndarray):
    method getScreenRGB (line 23) | def getScreenRGB(self, buffer: np.ndarray):
  class AtariTestingEnv (line 28) | class AtariTestingEnv(GenericTestEnv):
    method __init__ (line 31) | def __init__(self):
    method get_action_meanings (line 41) | def get_action_meanings(self):
  function test_atari_preprocessing_grayscale (line 83) | def test_atari_preprocessing_grayscale(env, obs_shape):
  function test_atari_preprocessing_scale (line 104) | def test_atari_preprocessing_scale(grayscale, scaled, max_test_steps=10):

FILE: tests/wrappers/test_autoreset.py
  class DummyResetEnv (line 13) | class DummyResetEnv(gym.Env):
    method __init__ (line 23) | def __init__(self):
    method step (line 31) | def step(self, action: int):
    method reset (line 42) | def reset(self, *, seed: Optional[int] = None, options: Optional[dict]...
  function unwrap_env (line 48) | def unwrap_env(env) -> Generator[gym.Wrapper, None, None]:
  function test_make_autoreset_true (line 58) | def test_make_autoreset_true(spec):
  function test_gym_make_autoreset (line 83) | def test_gym_make_autoreset(spec):
  function test_autoreset_wrapper_autoreset (line 98) | def test_autoreset_wrapper_autoreset():

FILE: tests/wrappers/test_clip_action.py
  function test_clip_action (line 7) | def test_clip_action():

FILE: tests/wrappers/test_filter_observation.py
  class FakeEnvironment (line 11) | class FakeEnvironment(gym.Env):
    method __init__ (line 12) | def __init__(
    method render (line 24) | def render(self, mode="human"):
    method reset (line 28) | def reset(self, *, seed: Optional[int] = None, options: Optional[dict]...
    method step (line 33) | def step(self, action):
  class TestFilterObservation (line 54) | class TestFilterObservation:
    method test_filter_observation (line 58) | def test_filter_observation(self, observation_keys, filter_keys):
    method test_raises_with_incorrect_arguments (line 81) | def test_raises_with_incorrect_arguments(

FILE: tests/wrappers/test_flatten.py
  class FakeEnvironment (line 14) | class FakeEnvironment(gym.Env):
    method __init__ (line 15) | def __init__(self, observation_space):
    method reset (line 18) | def reset(self, *, seed: Optional[int] = None, options: Optional[dict]...
  class TestFlattenEnvironment (line 62) | class TestFlattenEnvironment:
    method test_flattened_environment (line 64) | def test_flattened_environment(self, observation_space, ordered_values):
    method test_flatten_unflatten (line 78) | def test_flatten_unflatten(self, observation_space, ordered_values):
    method _check_observations (line 89) | def _check_observations(self, original, flattened, unflattened, ordere...

FILE: tests/wrappers/test_flatten_observation.py
  function test_flatten_observation (line 10) | def test_flatten_observation(env_id):

FILE: tests/wrappers/test_frame_stack.py
  function test_frame_stack (line 27) | def test_frame_stack(env_id, num_stack, lz4_compress):

FILE: tests/wrappers/test_gray_scale_observation.py
  function test_gray_scale_observation (line 10) | def test_gray_scale_observation(env_id, keep_dim):

FILE: tests/wrappers/test_human_rendering.py
  function test_human_rendering (line 9) | def test_human_rendering():

FILE: tests/wrappers/test_nested_dict.py
  class FakeEnvironment (line 12) | class FakeEnvironment(gym.Env):
    method __init__ (line 13) | def __init__(self, observation_space, render_mode=None):
    method render (line 19) | def render(self, mode="human"):
    method reset (line 23) | def reset(self, *, seed: Optional[int] = None, options: Optional[dict]...
    method step (line 28) | def step(self, action):
  class TestNestedDictWrapper (line 100) | class TestNestedDictWrapper:
    method test_nested_dicts_size (line 102) | def test_nested_dicts_size(self, observation_space, flat_shape):
    method test_nested_dicts_ravel (line 115) | def test_nested_dicts_ravel(self, observation_space, flat_shape):

FILE: tests/wrappers/test_normalize.py
  class DummyRewardEnv (line 10) | class DummyRewardEnv(gym.Env):
    method __init__ (line 13) | def __init__(self, return_reward_idx=0):
    method step (line 22) | def step(self, action):
    method reset (line 32) | def reset(self, *, seed: Optional[int] = None, options: Optional[dict]...
  function make_env (line 38) | def make_env(return_reward_idx):
  function test_normalize_observation (line 46) | def test_normalize_observation():
  function test_normalize_reset_info (line 56) | def test_normalize_reset_info():
  function test_normalize_return (line 64) | def test_normalize_return():
  function test_normalize_observation_vector_env (line 82) | def test_normalize_observation_vector_env():
  function test_normalize_return_vector_env (line 107) | def test_normalize_return_vector_env():

FILE: tests/wrappers/test_order_enforcing.py
  function test_gym_make_order_enforcing (line 14) | def test_gym_make_order_enforcing(spec):
  function test_order_enforcing (line 21) | def test_order_enforcing():

FILE: tests/wrappers/test_passive_env_checker.py
  function test_passive_checker_wrapper_warnings (line 19) | def test_passive_checker_wrapper_warnings(env):
  function test_initialise_failures (line 54) | def test_initialise_failures(env, message):
  function _reset_failure (line 61) | def _reset_failure(self, seed=None, options=None):
  function _step_failure (line 65) | def _step_failure(self, action):
  function test_api_failures (line 69) | def test_api_failures():

FILE: tests/wrappers/test_pixel_observation.py
  class FakeEnvironment (line 12) | class FakeEnvironment(gym.Env):
    method __init__ (line 13) | def __init__(self, render_mode="single_rgb_array"):
    method render (line 17) | def render(self, mode="human", width=32, height=32):
    method reset (line 21) | def reset(self, *, seed: Optional[int] = None, options: Optional[dict]...
    method step (line 26) | def step(self, action):
  class FakeArrayObservationEnvironment (line 33) | class FakeArrayObservationEnvironment(FakeEnvironment):
    method __init__ (line 34) | def __init__(self, *args, **kwargs):
  class FakeDictObservationEnvironment (line 41) | class FakeDictObservationEnvironment(FakeEnvironment):
    method __init__ (line 42) | def __init__(self, *args, **kwargs):
  function test_dict_observation (line 52) | def test_dict_observation(pixels_only):
  function test_single_array_observation (line 94) | def test_single_array_observation(pixels_only):

FILE: tests/wrappers/test_record_episode_statistics.py
  function test_record_episode_statistics (line 11) | def test_record_episode_statistics(env_id, deque_size):
  function test_record_episode_statistics_reset_info (line 30) | def test_record_episode_statistics_reset_info():
  function test_record_episode_statistics_with_vectorenv (line 42) | def test_record_episode_statistics_with_vectorenv(num_envs, asynchronous):
  function test_wrong_wrapping_order (line 70) | def test_wrong_wrapping_order():
  function test_add_vector_episode_statistics (line 79) | def test_add_vector_episode_statistics():

FILE: tests/wrappers/test_record_video.py
  function test_record_video_using_default_trigger (line 8) | def test_record_video_using_default_trigger():
  function test_record_video_reset (line 28) | def test_record_video_reset():
  function test_record_video_step_trigger (line 40) | def test_record_video_step_trigger():
  function make_env (line 57) | def make_env(gym_id, seed, **kwargs):
  function test_record_video_within_vector (line 70) | def test_record_video_within_vector():

FILE: tests/wrappers/test_rescale_action.py
  function test_rescale_action (line 8) | def test_rescale_action():

FILE: tests/wrappers/test_resize_observation.py
  function test_resize_observation (line 10) | def test_resize_observation(env_id, shape):

FILE: tests/wrappers/test_step_compatibility.py
  class OldStepEnv (line 8) | class OldStepEnv(gym.Env):
    method __init__ (line 9) | def __init__(self):
    method step (line 13) | def step(self, action):
  class NewStepEnv (line 21) | class NewStepEnv(gym.Env):
    method __init__ (line 22) | def __init__(self):
    method step (line 26) | def step(self, action):
  function test_step_compatibility_to_new_api (line 37) | def test_step_compatibility_to_new_api(env, output_truncation_bool):
  function test_step_compatibility_to_old_api (line 49) | def test_step_compatibility_to_old_api(env):
  function test_step_compatibility_in_make (line 58) | def test_step_compatibility_in_make(apply_api_compatibility):

FILE: tests/wrappers/test_time_aware_observation.py
  function test_time_aware_observation (line 9) | def test_time_aware_observation(env_id):

FILE: tests/wrappers/test_time_limit.py
  function test_time_limit_reset_info (line 8) | def test_time_limit_reset_info():
  function test_time_limit_wrapper (line 18) | def test_time_limit_wrapper(double_wrap):
  function test_termination_on_last_step (line 39) | def test_termination_on_last_step(double_wrap):

FILE: tests/wrappers/test_transform_observation.py
  function test_transform_observation (line 9) | def test_transform_observation(env_id):

FILE: tests/wrappers/test_transform_reward.py
  function test_transform_reward (line 9) | def test_transform_reward(env_id):

FILE: tests/wrappers/test_vector_list_info.py
  function test_usage_in_vector_env (line 12) | def test_usage_in_vector_env():
  function test_info_to_list (line 22) | def test_info_to_list():
  function test_info_to_list_statistics (line 40) | def test_info_to_list_statistics():

FILE: tests/wrappers/test_video_recorder.py
  class BrokenRecordableEnv (line 12) | class BrokenRecordableEnv(gym.Env):
    method __init__ (line 15) | def __init__(self, render_mode="rgb_array_list"):
    method render (line 18) | def render(self):
  class UnrecordableEnv (line 22) | class UnrecordableEnv(gym.Env):
    method __init__ (line 25) | def __init__(self, render_mode=None):
    method render (line 28) | def render(self):
  function test_record_simple (line 32) | def test_record_simple():
  function test_autoclose (line 48) | def test_autoclose():
  function test_no_frames (line 73) | def test_no_frames():
  function test_record_unrecordable_method (line 81) | def test_record_unrecordable_method():
  function test_record_breaking_render_method (line 94) | def test_record_breaking_render_method():
  function test_text_envs (line 109) | def test_text_envs():

FILE: tests/wrappers/utils.py
  function has_wrapper (line 4) | def has_wrapper(wrapped_env: gym.Env, wrapper_type: type) -> bool: