SYMBOL INDEX (1248 symbols across 82 files)

FILE: docs/conf.py
  function setup (line 120) | def setup(app):

FILE: stable_baselines3/__init__.py
  function HER (line 18) | def HER(*args, **kwargs):

FILE: stable_baselines3/a2c/a2c.py
  class A2C (line 16) | class A2C(OnPolicyAlgorithm):
    method __init__ (line 66) | def __init__(
    method train (line 132) | def train(self) -> None:
    method learn (line 192) | def learn(

FILE: stable_baselines3/common/atari_wrappers.py
  class StickyActionEnv (line 17) | class StickyActionEnv(gym.Wrapper[np.ndarray, int, np.ndarray, int]):
    method __init__ (line 28) | def __init__(self, env: gym.Env, action_repeat_probability: float) -> ...
    method reset (line 33) | def reset(self, **kwargs) -> AtariResetReturn:
    method step (line 37) | def step(self, action: int) -> AtariStepReturn:
  class NoopResetEnv (line 43) | class NoopResetEnv(gym.Wrapper[np.ndarray, int, np.ndarray, int]):
    method __init__ (line 52) | def __init__(self, env: gym.Env, noop_max: int = 30) -> None:
    method reset (line 59) | def reset(self, **kwargs) -> AtariResetReturn:
  class FireResetEnv (line 75) | class FireResetEnv(gym.Wrapper[np.ndarray, int, np.ndarray, int]):
    method __init__ (line 82) | def __init__(self, env: gym.Env) -> None:
    method reset (line 87) | def reset(self, **kwargs) -> AtariResetReturn:
  class EpisodicLifeEnv (line 98) | class EpisodicLifeEnv(gym.Wrapper[np.ndarray, int, np.ndarray, int]):
    method __init__ (line 114) | def __init__(self, env: gym.Env) -> None:
    method step (line 119) | def step(self, action: int) -> AtariStepReturn:
    method reset (line 133) | def reset(self, **kwargs) -> AtariResetReturn:
  class MaxAndSkipEnv (line 157) | class MaxAndSkipEnv(gym.Wrapper[np.ndarray, int, np.ndarray, int]):
    method __init__ (line 167) | def __init__(self, env: gym.Env, skip: int = 4) -> None:
    method step (line 175) | def step(self, action: int) -> AtariStepReturn:
  class ClipRewardEnv (line 202) | class ClipRewardEnv(gym.RewardWrapper):
    method __init__ (line 209) | def __init__(self, env: gym.Env) -> None:
    method reward (line 212) | def reward(self, reward: SupportsFloat) -> float:
  class WarpFrame (line 222) | class WarpFrame(gym.ObservationWrapper[np.ndarray, int, np.ndarray]):
    method __init__ (line 232) | def __init__(self, env: gym.Env, width: int = 84, height: int = 84) ->...
    method observation (line 245) | def observation(self, frame: np.ndarray) -> np.ndarray:
  class AtariWrapper (line 258) | class AtariWrapper(gym.Wrapper[np.ndarray, int, np.ndarray, int]):
    method __init__ (line 289) | def __init__(

FILE: stable_baselines3/common/base_class.py
  function maybe_make_env (line 48) | def maybe_make_env(env: GymEnv | str, verbose: int) -> GymEnv:
  class BaseAlgorithm (line 67) | class BaseAlgorithm(ABC):
    method __init__ (line 106) | def __init__(
    method _wrap_env (line 204) | def _wrap_env(env: GymEnv, verbose: int = 0, monitor_wrapper: bool = T...
    method _setup_model (line 252) | def _setup_model(self) -> None:
    method set_logger (line 255) | def set_logger(self, logger: Logger) -> None:
    method logger (line 270) | def logger(self) -> Logger:
    method _setup_lr_schedule (line 274) | def _setup_lr_schedule(self) -> None:
    method _update_current_progress_remaining (line 278) | def _update_current_progress_remaining(self, num_timesteps: int, total...
    method _update_learning_rate (line 287) | def _update_learning_rate(self, optimizers: list[th.optim.Optimizer] |...
    method _excluded_save_params (line 303) | def _excluded_save_params(self) -> list[str]:
    method _get_policy_from_name (line 323) | def _get_policy_from_name(self, policy_name: str) -> type[BasePolicy]:
    method _get_torch_save_params (line 340) | def _get_torch_save_params(self) -> tuple[list[str], list[str]]:
    method _init_callback (line 358) | def _init_callback(
    method _setup_learn (line 383) | def _setup_learn(
    method _update_info_buffer (line 438) | def _update_info_buffer(self, infos: list[dict[str, Any]], dones: np.n...
    method get_env (line 459) | def get_env(self) -> VecEnv | None:
    method get_vec_normalize_env (line 467) | def get_vec_normalize_env(self) -> VecNormalize | None:
    method set_env (line 476) | def set_env(self, env: GymEnv, force_reset: bool = True) -> None:
    method learn (line 512) | def learn(
    method predict (line 537) | def predict(
    method set_random_seed (line 559) | def set_random_seed(self, seed: int | None = None) -> None:
    method set_parameters (line 574) | def set_parameters(
    method load (line 643) | def load(  # noqa: C901
    method get_parameters (line 804) | def get_parameters(self) -> dict[str, dict]:
    method save (line 819) | def save(
    method dump_logs (line 869) | def dump_logs(self) -> None:
    method _dump_logs (line 875) | def _dump_logs(self, *args) -> None:

FILE: stable_baselines3/common/buffers.py
  class BaseBuffer (line 27) | class BaseBuffer(ABC):
    method __init__ (line 42) | def __init__(
    method swap_and_flatten (line 63) | def swap_and_flatten(arr: np.ndarray) -> np.ndarray:
    method size (line 77) | def size(self) -> int:
    method add (line 85) | def add(self, *args, **kwargs) -> None:
    method extend (line 91) | def extend(self, *args, **kwargs) -> None:
    method reset (line 99) | def reset(self) -> None:
    method sample (line 106) | def sample(self, batch_size: int, env: VecNormalize | None = None):
    method _get_samples (line 118) | def _get_samples(
    method to_torch (line 128) | def to_torch(self, array: np.ndarray, copy: bool = True) -> th.Tensor:
    method _normalize_obs (line 143) | def _normalize_obs(
    method _normalize_reward (line 152) | def _normalize_reward(reward: np.ndarray, env: VecNormalize | None = N...
  class ReplayBuffer (line 158) | class ReplayBuffer(BaseBuffer):
    method __init__ (line 185) | def __init__(
    method add (line 247) | def add(
    method sample (line 285) | def sample(self, batch_size: int, env: VecNormalize | None = None) -> ...
    method _get_samples (line 307) | def _get_samples(self, batch_inds: np.ndarray, env: VecNormalize | Non...
    method _maybe_cast_dtype (line 328) | def _maybe_cast_dtype(dtype: np.typing.DTypeLike | None) -> np.typing....
  class RolloutBuffer (line 343) | class RolloutBuffer(BaseBuffer):
    method __init__ (line 375) | def __init__(
    method reset (line 391) | def reset(self) -> None:
    method compute_returns_and_advantage (line 403) | def compute_returns_and_advantage(self, last_values: th.Tensor, dones:...
    method add (line 440) | def add(
    method get (line 481) | def get(self, batch_size: int | None = None) -> Generator[RolloutBuffe...
    method _get_samples (line 508) | def _get_samples(
  class DictReplayBuffer (line 525) | class DictReplayBuffer(ReplayBuffer):
    method __init__ (line 547) | def __init__(
    method add (line 612) | def add(  # type: ignore[override]
    method sample (line 649) | def sample(  # type: ignore[override]
    method _get_samples (line 664) | def _get_samples(  # type: ignore[override]
  class DictRolloutBuffer (line 697) | class DictRolloutBuffer(RolloutBuffer):
    method __init__ (line 726) | def __init__(
    method reset (line 746) | def reset(self) -> None:
    method add (line 762) | def add(  # type: ignore[override]
    method get (line 805) | def get(  # type: ignore[override]
    method _get_samples (line 831) | def _get_samples(  # type: ignore[override]
  class NStepReplayBuffer (line 847) | class NStepReplayBuffer(ReplayBuffer):
    method __init__ (line 879) | def __init__(self, *args, n_steps: int = 3, gamma: float = 0.99, **kwa...
    method _get_samples (line 886) | def _get_samples(self, batch_inds: np.ndarray, env: VecNormalize | Non...

FILE: stable_baselines3/common/callbacks.py
  class BaseCallback (line 31) | class BaseCallback(ABC):
    method __init__ (line 42) | def __init__(self, verbose: int = 0):
    method training_env (line 56) | def training_env(self) -> VecEnv:
    method logger (line 64) | def logger(self) -> Logger:
    method init_callback (line 68) | def init_callback(self, model: "base_class.BaseAlgorithm") -> None:
    method _init_callback (line 76) | def _init_callback(self) -> None:
    method on_training_start (line 79) | def on_training_start(self, locals_: dict[str, Any], globals_: dict[st...
    method _on_training_start (line 87) | def _on_training_start(self) -> None:
    method on_rollout_start (line 90) | def on_rollout_start(self) -> None:
    method _on_rollout_start (line 93) | def _on_rollout_start(self) -> None:
    method _on_step (line 97) | def _on_step(self) -> bool:
    method on_step (line 103) | def on_step(self) -> bool:
    method on_training_end (line 117) | def on_training_end(self) -> None:
    method _on_training_end (line 120) | def _on_training_end(self) -> None:
    method on_rollout_end (line 123) | def on_rollout_end(self) -> None:
    method _on_rollout_end (line 126) | def _on_rollout_end(self) -> None:
    method update_locals (line 129) | def update_locals(self, locals_: dict[str, Any]) -> None:
    method update_child_locals (line 138) | def update_child_locals(self, locals_: dict[str, Any]) -> None:
  class EventCallback (line 147) | class EventCallback(BaseCallback):
    method __init__ (line 156) | def __init__(self, callback: BaseCallback | None = None, verbose: int ...
    method init_callback (line 164) | def init_callback(self, model: "base_class.BaseAlgorithm") -> None:
    method _on_training_start (line 169) | def _on_training_start(self) -> None:
    method _on_event (line 173) | def _on_event(self) -> bool:
    method _on_step (line 178) | def _on_step(self) -> bool:
    method update_child_locals (line 181) | def update_child_locals(self, locals_: dict[str, Any]) -> None:
  class CallbackList (line 191) | class CallbackList(BaseCallback):
    method __init__ (line 199) | def __init__(self, callbacks: list[BaseCallback]):
    method _init_callback (line 204) | def _init_callback(self) -> None:
    method _on_training_start (line 212) | def _on_training_start(self) -> None:
    method _on_rollout_start (line 216) | def _on_rollout_start(self) -> None:
    method _on_step (line 220) | def _on_step(self) -> bool:
    method _on_rollout_end (line 227) | def _on_rollout_end(self) -> None:
    method _on_training_end (line 231) | def _on_training_end(self) -> None:
    method update_child_locals (line 235) | def update_child_locals(self, locals_: dict[str, Any]) -> None:
  class CheckpointCallback (line 245) | class CheckpointCallback(BaseCallback):
    method __init__ (line 268) | def __init__(
    method _init_callback (line 284) | def _init_callback(self) -> None:
    method _checkpoint_path (line 289) | def _checkpoint_path(self, checkpoint_type: str = "", extension: str =...
    method _on_step (line 300) | def _on_step(self) -> bool:
  class ConvertCallback (line 324) | class ConvertCallback(BaseCallback):
    method __init__ (line 332) | def __init__(self, callback: Callable[[dict[str, Any], dict[str, Any]]...
    method _on_step (line 336) | def _on_step(self) -> bool:
  class EvalCallback (line 342) | class EvalCallback(EventCallback):
    method __init__ (line 370) | def __init__(
    method _init_callback (line 416) | def _init_callback(self) -> None:
    method _log_success_callback (line 431) | def _log_success_callback(self, locals_: dict[str, Any], globals_: dic...
    method _on_step (line 447) | def _on_step(self) -> bool:
    method update_child_locals (line 534) | def update_child_locals(self, locals_: dict[str, Any]) -> None:
  class StopTrainingOnRewardThreshold (line 544) | class StopTrainingOnRewardThreshold(BaseCallback):
    method __init__ (line 559) | def __init__(self, reward_threshold: float, verbose: int = 0):
    method _on_step (line 563) | def _on_step(self) -> bool:
  class EveryNTimesteps (line 574) | class EveryNTimesteps(EventCallback):
    method __init__ (line 583) | def __init__(self, n_steps: int, callback: BaseCallback):
    method _on_step (line 588) | def _on_step(self) -> bool:
  class LogEveryNTimesteps (line 595) | class LogEveryNTimesteps(EveryNTimesteps):
    method __init__ (line 602) | def __init__(self, n_steps: int):
    method _log_data (line 605) | def _log_data(self, _locals: dict[str, Any], _globals: dict[str, Any])...
  class StopTrainingOnMaxEpisodes (line 610) | class StopTrainingOnMaxEpisodes(BaseCallback):
    method __init__ (line 622) | def __init__(self, max_episodes: int, verbose: int = 0):
    method _init_callback (line 628) | def _init_callback(self) -> None:
    method _on_step (line 632) | def _on_step(self) -> bool:
  class StopTrainingOnNoModelImprovement (line 654) | class StopTrainingOnNoModelImprovement(BaseCallback):
    method __init__ (line 669) | def __init__(self, max_no_improvement_evals: int, min_evals: int = 0, ...
    method _on_step (line 676) | def _on_step(self) -> bool:
  class ProgressBarCallback (line 699) | class ProgressBarCallback(BaseCallback):
    method __init__ (line 707) | def __init__(self) -> None:
    method _on_training_start (line 716) | def _on_training_start(self) -> None:
    method _on_step (line 721) | def _on_step(self) -> bool:
    method _on_training_end (line 726) | def _on_training_end(self) -> None:

FILE: stable_baselines3/common/distributions.py
  class Distribution (line 26) | class Distribution(ABC):
    method __init__ (line 31) | def __init__(self):
    method proba_distribution_net (line 35) | def proba_distribution_net(self, *args, **kwargs) -> nn.Module | tuple...
    method proba_distribution (line 42) | def proba_distribution(self: SelfDistribution, *args, **kwargs) -> Sel...
    method log_prob (line 49) | def log_prob(self, actions: th.Tensor) -> th.Tensor:
    method entropy (line 58) | def entropy(self) -> th.Tensor | None:
    method sample (line 66) | def sample(self) -> th.Tensor:
    method mode (line 74) | def mode(self) -> th.Tensor:
    method get_actions (line 82) | def get_actions(self, deterministic: bool = False) -> th.Tensor:
    method actions_from_params (line 94) | def actions_from_params(self, *args, **kwargs) -> th.Tensor:
    method log_prob_from_params (line 103) | def log_prob_from_params(self, *args, **kwargs) -> tuple[th.Tensor, th...
  function sum_independent_dims (line 112) | def sum_independent_dims(tensor: th.Tensor) -> th.Tensor:
  class DiagGaussianDistribution (line 127) | class DiagGaussianDistribution(Distribution):
    method __init__ (line 136) | def __init__(self, action_dim: int):
    method proba_distribution_net (line 140) | def proba_distribution_net(self, latent_dim: int, log_std_init: float ...
    method proba_distribution (line 155) | def proba_distribution(
    method log_prob (line 169) | def log_prob(self, actions: th.Tensor) -> th.Tensor:
    method entropy (line 180) | def entropy(self) -> th.Tensor | None:
    method sample (line 183) | def sample(self) -> th.Tensor:
    method mode (line 187) | def mode(self) -> th.Tensor:
    method actions_from_params (line 190) | def actions_from_params(self, mean_actions: th.Tensor, log_std: th.Ten...
    method log_prob_from_params (line 195) | def log_prob_from_params(self, mean_actions: th.Tensor, log_std: th.Te...
  class SquashedDiagGaussianDistribution (line 209) | class SquashedDiagGaussianDistribution(DiagGaussianDistribution):
    method __init__ (line 217) | def __init__(self, action_dim: int, epsilon: float = 1e-6):
    method proba_distribution (line 223) | def proba_distribution(
    method log_prob (line 229) | def log_prob(self, actions: th.Tensor, gaussian_actions: th.Tensor | N...
    method entropy (line 244) | def entropy(self) -> th.Tensor | None:
    method sample (line 249) | def sample(self) -> th.Tensor:
    method mode (line 254) | def mode(self) -> th.Tensor:
    method log_prob_from_params (line 259) | def log_prob_from_params(self, mean_actions: th.Tensor, log_std: th.Te...
  class CategoricalDistribution (line 265) | class CategoricalDistribution(Distribution):
    method __init__ (line 274) | def __init__(self, action_dim: int):
    method proba_distribution_net (line 278) | def proba_distribution_net(self, latent_dim: int) -> nn.Module:
    method proba_distribution (line 291) | def proba_distribution(self: SelfCategoricalDistribution, action_logit...
    method log_prob (line 295) | def log_prob(self, actions: th.Tensor) -> th.Tensor:
    method entropy (line 298) | def entropy(self) -> th.Tensor:
    method sample (line 301) | def sample(self) -> th.Tensor:
    method mode (line 304) | def mode(self) -> th.Tensor:
    method actions_from_params (line 307) | def actions_from_params(self, action_logits: th.Tensor, deterministic:...
    method log_prob_from_params (line 312) | def log_prob_from_params(self, action_logits: th.Tensor) -> tuple[th.T...
  class MultiCategoricalDistribution (line 318) | class MultiCategoricalDistribution(Distribution):
    method __init__ (line 327) | def __init__(self, action_dims: list[int]):
    method proba_distribution_net (line 331) | def proba_distribution_net(self, latent_dim: int) -> nn.Module:
    method proba_distribution (line 345) | def proba_distribution(
    method log_prob (line 351) | def log_prob(self, actions: th.Tensor) -> th.Tensor:
    method entropy (line 357) | def entropy(self) -> th.Tensor:
    method sample (line 360) | def sample(self) -> th.Tensor:
    method mode (line 363) | def mode(self) -> th.Tensor:
    method actions_from_params (line 366) | def actions_from_params(self, action_logits: th.Tensor, deterministic:...
    method log_prob_from_params (line 371) | def log_prob_from_params(self, action_logits: th.Tensor) -> tuple[th.T...
  class BernoulliDistribution (line 377) | class BernoulliDistribution(Distribution):
    method __init__ (line 386) | def __init__(self, action_dims: int):
    method proba_distribution_net (line 390) | def proba_distribution_net(self, latent_dim: int) -> nn.Module:
    method proba_distribution (line 402) | def proba_distribution(self: SelfBernoulliDistribution, action_logits:...
    method log_prob (line 406) | def log_prob(self, actions: th.Tensor) -> th.Tensor:
    method entropy (line 409) | def entropy(self) -> th.Tensor:
    method sample (line 412) | def sample(self) -> th.Tensor:
    method mode (line 415) | def mode(self) -> th.Tensor:
    method actions_from_params (line 418) | def actions_from_params(self, action_logits: th.Tensor, deterministic:...
    method log_prob_from_params (line 423) | def log_prob_from_params(self, action_logits: th.Tensor) -> tuple[th.T...
  class StateDependentNoiseDistribution (line 429) | class StateDependentNoiseDistribution(Distribution):
    method __init__ (line 459) | def __init__(
    method get_std (line 480) | def get_std(self, log_std: th.Tensor) -> th.Tensor:
    method sample_weights (line 506) | def sample_weights(self, log_std: th.Tensor, batch_size: int = 1) -> N...
    method proba_distribution_net (line 521) | def proba_distribution_net(
    method proba_distribution (line 548) | def proba_distribution(
    method log_prob (line 565) | def log_prob(self, actions: th.Tensor) -> th.Tensor:
    method entropy (line 580) | def entropy(self) -> th.Tensor | None:
    method sample (line 587) | def sample(self) -> th.Tensor:
    method mode (line 594) | def mode(self) -> th.Tensor:
    method get_noise (line 600) | def get_noise(self, latent_sde: th.Tensor) -> th.Tensor:
    method actions_from_params (line 612) | def actions_from_params(
    method log_prob_from_params (line 619) | def log_prob_from_params(
  class TanhBijector (line 627) | class TanhBijector:
    method __init__ (line 635) | def __init__(self, epsilon: float = 1e-6):
    method forward (line 640) | def forward(x: th.Tensor) -> th.Tensor:
    method atanh (line 644) | def atanh(x: th.Tensor) -> th.Tensor:
    method inverse (line 654) | def inverse(y: th.Tensor) -> th.Tensor:
    method log_prob_correction (line 665) | def log_prob_correction(self, x: th.Tensor) -> th.Tensor:
  function make_proba_distribution (line 670) | def make_proba_distribution(
  function kl_divergence (line 705) | def kl_divergence(dist_true: Distribution, dist_pred: Distribution) -> t...

FILE: stable_baselines3/common/env_checker.py
  function _is_oneof_space (line 12) | def _is_oneof_space(space: spaces.Space) -> bool:
  function _is_numpy_array_space (line 24) | def _is_numpy_array_space(space: spaces.Space) -> bool:
  function _starts_at_zero (line 32) | def _starts_at_zero(space: spaces.Discrete | spaces.MultiDiscrete) -> bool:
  function _check_non_zero_start (line 39) | def _check_non_zero_start(space: spaces.Space, space_type: str = "observ...
  function _check_image_input (line 57) | def _check_image_input(observation_space: spaces.Box, key: str = "") -> ...
  function _check_unsupported_spaces (line 95) | def _check_unsupported_spaces(env: gym.Env, observation_space: spaces.Sp...
  function _check_nan (line 190) | def _check_nan(env: gym.Env) -> None:
  function _is_goal_env (line 199) | def _is_goal_env(env: gym.Env) -> bool:
  function _check_goal_env_obs (line 207) | def _check_goal_env_obs(obs: dict, observation_space: spaces.Dict, metho...
  function _check_goal_env_compute_reward (line 227) | def _check_goal_env_compute_reward(
  function _check_obs (line 254) | def _check_obs(obs: tuple | dict | np.ndarray | int, observation_space: ...
  function _check_box_obs (line 311) | def _check_box_obs(observation_space: spaces.Box, key: str = "") -> None:
  function _check_returned_values (line 331) | def _check_returned_values(env: gym.Env, observation_space: spaces.Space...
  function _check_spaces (line 413) | def _check_spaces(env: gym.Env) -> None:
  function _check_render (line 442) | def _check_render(env: gym.Env, warn: bool = False) -> None:  # pragma: ...
  function check_env (line 467) | def check_env(env: gym.Env, warn: bool = True, skip_render_check: bool =...

FILE: stable_baselines3/common/env_util.py
  function unwrap_wrapper (line 13) | def unwrap_wrapper(env: gym.Env, wrapper_class: type[gym.Wrapper]) -> gy...
  function is_wrapped (line 29) | def is_wrapped(env: gym.Env, wrapper_class: type[gym.Wrapper]) -> bool:
  function make_vec_env (line 40) | def make_vec_env(
  function make_atari_env (line 132) | def make_atari_env(

FILE: stable_baselines3/common/envs/bit_flipping_env.py
  class BitFlippingEnv (line 11) | class BitFlippingEnv(Env):
    method __init__ (line 33) | def __init__(
    method seed (line 68) | def seed(self, seed: int) -> None:
    method convert_if_needed (line 71) | def convert_if_needed(self, state: np.ndarray) -> int | np.ndarray:
    method convert_to_bit_vector (line 92) | def convert_to_bit_vector(self, state: int | np.ndarray, batch_size: i...
    method _make_observation_space (line 111) | def _make_observation_space(self, discrete_obs_space: bool, image_obs_...
    method _get_obs (line 169) | def _get_obs(self) -> dict[str, int | np.ndarray]:
    method reset (line 183) | def reset(self, *, seed: int | None = None, options: dict | None = Non...
    method step (line 190) | def step(self, action: np.ndarray | int) -> GymStepReturn:
    method compute_reward (line 210) | def compute_reward(
    method render (line 229) | def render(self) -> np.ndarray | None:  # type: ignore[override]
    method close (line 235) | def close(self) -> None:

FILE: stable_baselines3/common/envs/identity_env.py
  class IdentityEnv (line 12) | class IdentityEnv(gym.Env, Generic[T]):
    method __init__ (line 13) | def __init__(self, dim: int | None = None, space: spaces.Space | None ...
    method reset (line 37) | def reset(self, *, seed: int | None = None, options: dict | None = Non...
    method step (line 45) | def step(self, action: T) -> tuple[T, float, bool, bool, dict[str, Any]]:
    method _choose_next_state (line 53) | def _choose_next_state(self) -> None:
    method _get_reward (line 56) | def _get_reward(self, action: T) -> float:
    method render (line 59) | def render(self, mode: str = "human") -> None:
  class IdentityEnvBox (line 63) | class IdentityEnvBox(IdentityEnv[np.ndarray]):
    method __init__ (line 64) | def __init__(self, low: float = -1.0, high: float = 1.0, eps: float = ...
    method step (line 77) | def step(self, action: np.ndarray) -> tuple[np.ndarray, float, bool, b...
    method _get_reward (line 85) | def _get_reward(self, action: np.ndarray) -> float:
  class IdentityEnvMultiDiscrete (line 89) | class IdentityEnvMultiDiscrete(IdentityEnv[np.ndarray]):
    method __init__ (line 90) | def __init__(self, dim: int = 1, ep_length: int = 100) -> None:
  class IdentityEnvMultiBinary (line 101) | class IdentityEnvMultiBinary(IdentityEnv[np.ndarray]):
    method __init__ (line 102) | def __init__(self, dim: int = 1, ep_length: int = 100) -> None:
  class FakeImageEnv (line 113) | class FakeImageEnv(gym.Env):
    method __init__ (line 125) | def __init__(
    method reset (line 145) | def reset(self, *, seed: int | None = None, options: dict | None = Non...
    method step (line 151) | def step(self, action: np.ndarray | int) -> GymStepReturn:
    method render (line 158) | def render(self, mode: str = "human") -> None:

FILE: stable_baselines3/common/envs/multi_input_envs.py
  class SimpleMultiObsEnv (line 8) | class SimpleMultiObsEnv(gym.Env):
    method __init__ (line 36) | def __init__(
    method init_state_mapping (line 79) | def init_state_mapping(self, num_col: int, num_row: int) -> None:
    method get_state_mapping (line 95) | def get_state_mapping(self) -> dict[str, np.ndarray]:
    method init_possible_transitions (line 103) | def init_possible_transitions(self) -> None:
    method step (line 122) | def step(self, action: int | np.ndarray) -> GymStepReturn:
    method render (line 159) | def render(self, mode: str = "human") -> None:
    method reset (line 167) | def reset(self, *, seed: int | None = None, options: dict | None = Non...

FILE: stable_baselines3/common/evaluation.py
  function evaluate_policy (line 12) | def evaluate_policy(

FILE: stable_baselines3/common/logger.py
  class Video (line 35) | class Video:
    method __init__ (line 43) | def __init__(self, frames: th.Tensor, fps: float):
  class Figure (line 48) | class Figure:
    method __init__ (line 56) | def __init__(self, figure: matplotlib.figure.Figure, close: bool):
  class Image (line 61) | class Image:
    method __init__ (line 71) | def __init__(self, image: th.Tensor | np.ndarray | str, dataformats: s...
  class HParam (line 76) | class HParam:
    method __init__ (line 85) | def __init__(self, hparam_dict: Mapping[str, bool | str | float | None...
  class FormatUnsupportedError (line 92) | class FormatUnsupportedError(NotImplementedError):
    method __init__ (line 102) | def __init__(self, unsupported_formats: Sequence[str], value_descripti...
  class KVWriter (line 113) | class KVWriter:
    method write (line 118) | def write(self, key_values: dict[str, Any], key_excluded: dict[str, tu...
    method close (line 128) | def close(self) -> None:
  class SeqWriter (line 135) | class SeqWriter:
    method write_sequence (line 140) | def write_sequence(self, sequence: list[str]) -> None:
  class HumanOutputFormat (line 149) | class HumanOutputFormat(KVWriter, SeqWriter):
    method __init__ (line 163) | def __init__(self, filename_or_file: str | TextIO, max_length: int = 36):
    method write (line 176) | def write(self, key_values: dict[str, Any], key_excluded: dict[str, tu...
    method _truncate (line 243) | def _truncate(self, string: str) -> str:
    method write_sequence (line 248) | def write_sequence(self, sequence: list[str]) -> None:
    method close (line 256) | def close(self) -> None:
  function filter_excluded_keys (line 264) | def filter_excluded_keys(key_values: dict[str, Any], key_excluded: dict[...
  class JSONOutputFormat (line 280) | class JSONOutputFormat(KVWriter):
    method __init__ (line 287) | def __init__(self, filename: str):
    method write (line 290) | def write(self, key_values: dict[str, Any], key_excluded: dict[str, tu...
    method close (line 316) | def close(self) -> None:
  class CSVOutputFormat (line 324) | class CSVOutputFormat(KVWriter):
    method __init__ (line 331) | def __init__(self, filename: str):
    method write (line 337) | def write(self, key_values: dict[str, Any], key_excluded: dict[str, tu...
    method close (line 384) | def close(self) -> None:
  class TensorBoardOutputFormat (line 391) | class TensorBoardOutputFormat(KVWriter):
    method __init__ (line 398) | def __init__(self, folder: str):
    method write (line 403) | def write(self, key_values: dict[str, Any], key_excluded: dict[str, tu...
    method close (line 439) | def close(self) -> None:
  function make_output_format (line 448) | def make_output_format(_format: str, log_dir: str, log_suffix: str = "")...
  class Logger (line 477) | class Logger:
    method __init__ (line 485) | def __init__(self, folder: str | None, output_formats: list[KVWriter]):
    method to_tuple (line 494) | def to_tuple(string_or_tuple: str | tuple[str, ...] | None) -> tuple[s...
    method record (line 504) | def record(self, key: str, value: Any, exclude: str | tuple[str, ...] ...
    method record_mean (line 517) | def record_mean(self, key: str, value: float | None, exclude: str | tu...
    method dump (line 532) | def dump(self, step: int = 0) -> None:
    method log (line 546) | def log(self, *args, level: int = INFO) -> None:
    method debug (line 560) | def debug(self, *args) -> None:
    method info (line 570) | def info(self, *args) -> None:
    method warn (line 580) | def warn(self, *args) -> None:
    method error (line 590) | def error(self, *args) -> None:
    method set_level (line 602) | def set_level(self, level: int) -> None:
    method get_dir (line 610) | def get_dir(self) -> str | None:
    method close (line 619) | def close(self) -> None:
    method _do_log (line 628) | def _do_log(self, args: tuple[Any, ...]) -> None:
  function configure (line 639) | def configure(folder: str | None = None, format_strings: list[str] | Non...
  function read_json (line 675) | def read_json(filename: str) -> pandas.DataFrame:
  function read_csv (line 689) | def read_csv(filename: str) -> pandas.DataFrame:

FILE: stable_baselines3/common/monitor.py
  class Monitor (line 15) | class Monitor(gym.Wrapper[ObsType, ActType, ObsType, ActType]):
    method __init__ (line 31) | def __init__(
    method reset (line 64) | def reset(self, **kwargs) -> tuple[ObsType, dict[str, Any]]:
    method step (line 85) | def step(self, action: ActType) -> tuple[ObsType, SupportsFloat, bool,...
    method close (line 113) | def close(self) -> None:
    method get_total_steps (line 121) | def get_total_steps(self) -> int:
    method get_episode_rewards (line 129) | def get_episode_rewards(self) -> list[float]:
    method get_episode_lengths (line 137) | def get_episode_lengths(self) -> list[int]:
    method get_episode_times (line 145) | def get_episode_times(self) -> list[float]:
  class LoadMonitorResultsError (line 154) | class LoadMonitorResultsError(Exception):
  class ResultsWriter (line 162) | class ResultsWriter:
    method __init__ (line 175) | def __init__(
    method write_row (line 203) | def write_row(self, epinfo: dict[str, float]) -> None:
    method close (line 213) | def close(self) -> None:
  function get_monitor_files (line 220) | def get_monitor_files(path: str) -> list[str]:
  function load_results (line 230) | def load_results(path: str) -> pandas.DataFrame:

FILE: stable_baselines3/common/noise.py
  class ActionNoise (line 9) | class ActionNoise(ABC):
    method __init__ (line 14) | def __init__(self) -> None:
    method reset (line 17) | def reset(self) -> None:
    method __call__ (line 24) | def __call__(self) -> np.ndarray:
  class NormalActionNoise (line 28) | class NormalActionNoise(ActionNoise):
    method __init__ (line 37) | def __init__(self, mean: np.ndarray, sigma: np.ndarray, dtype: DTypeLi...
    method __call__ (line 43) | def __call__(self) -> np.ndarray:
    method __repr__ (line 46) | def __repr__(self) -> str:
  class OrnsteinUhlenbeckActionNoise (line 50) | class OrnsteinUhlenbeckActionNoise(ActionNoise):
    method __init__ (line 64) | def __init__(
    method __call__ (line 83) | def __call__(self) -> np.ndarray:
    method reset (line 92) | def reset(self) -> None:
    method __repr__ (line 98) | def __repr__(self) -> str:
  class VectorizedActionNoise (line 102) | class VectorizedActionNoise(ActionNoise):
    method __init__ (line 110) | def __init__(self, base_noise: ActionNoise, n_envs: int) -> None:
    method reset (line 120) | def reset(self, indices: Iterable[int] | None = None) -> None:
    method __repr__ (line 133) | def __repr__(self) -> str:
    method __call__ (line 136) | def __call__(self) -> np.ndarray:
    method base_noise (line 144) | def base_noise(self) -> ActionNoise:
    method base_noise (line 148) | def base_noise(self, base_noise: ActionNoise) -> None:
    method noises (line 156) | def noises(self) -> list[ActionNoise]:
    method noises (line 160) | def noises(self, noises: list[ActionNoise]) -> None:

FILE: stable_baselines3/common/off_policy_algorithm.py
  class OffPolicyAlgorithm (line 27) | class OffPolicyAlgorithm(BaseAlgorithm):
    method __init__ (line 81) | def __init__(
    method _convert_train_freq (line 150) | def _convert_train_freq(self) -> None:
    method _setup_model (line 174) | def _setup_model(self) -> None:
    method save_replay_buffer (line 217) | def save_replay_buffer(self, path: str | pathlib.Path | io.BufferedIOB...
    method load_replay_buffer (line 227) | def load_replay_buffer(
    method _setup_learn (line 259) | def _setup_learn(
    method learn (line 312) | def learn(
    method train (line 360) | def train(self, gradient_steps: int, batch_size: int) -> None:
    method _sample_action (line 367) | def _sample_action(
    method dump_logs (line 417) | def dump_logs(self) -> None:
    method _on_step (line 441) | def _on_step(self) -> None:
    method _store_transition (line 449) | def _store_transition(
    method collect_rollouts (line 514) | def collect_rollouts(

FILE: stable_baselines3/common/on_policy_algorithm.py
  class OnPolicyAlgorithm (line 21) | class OnPolicyAlgorithm(BaseAlgorithm):
    method __init__ (line 61) | def __init__(
    method _setup_model (line 115) | def _setup_model(self) -> None:
    method _maybe_recommend_cpu (line 142) | def _maybe_recommend_cpu(self, mlp_class_name: str = "ActorCriticPolic...
    method collect_rollouts (line 162) | def collect_rollouts(
    method train (line 270) | def train(self) -> None:
    method dump_logs (line 277) | def dump_logs(self, iteration: int = 0) -> None:
    method learn (line 300) | def learn(
    method _get_torch_save_params (line 343) | def _get_torch_save_params(self) -> tuple[list[str], list[str]]:

FILE: stable_baselines3/common/policies.py
  class BaseModel (line 39) | class BaseModel(nn.Module):
    method __init__ (line 63) | def __init__(
    method _update_features_extractor (line 96) | def _update_features_extractor(
    method make_features_extractor (line 118) | def make_features_extractor(self) -> BaseFeaturesExtractor:
    method extract_features (line 122) | def extract_features(self, obs: PyTorchObs, features_extractor: BaseFe...
    method _get_constructor_parameters (line 133) | def _get_constructor_parameters(self) -> dict[str, Any]:
    method device (line 149) | def device(self) -> th.device:
    method save (line 158) | def save(self, path: str) -> None:
    method load (line 167) | def load(cls: type[SelfBaseModel], path: str, device: th.device | str ...
    method load_from_vector (line 187) | def load_from_vector(self, vector: np.ndarray) -> None:
    method parameters_to_vector (line 195) | def parameters_to_vector(self) -> np.ndarray:
    method set_training_mode (line 203) | def set_training_mode(self, mode: bool) -> None:
    method is_vectorized_observation (line 213) | def is_vectorized_observation(self, observation: np.ndarray | dict[str...
    method obs_to_tensor (line 236) | def obs_to_tensor(self, observation: np.ndarray | dict[str, np.ndarray...
  class BasePolicy (line 280) | class BasePolicy(BaseModel, ABC):
    method __init__ (line 293) | def __init__(self, *args, squash_output: bool = False, **kwargs):
    method _dummy_schedule (line 298) | def _dummy_schedule(progress_remaining: float) -> float:
    method squash_output (line 304) | def squash_output(self) -> bool:
    method init_weights (line 309) | def init_weights(module: nn.Module, gain: float = 1) -> None:
    method _predict (line 319) | def _predict(self, observation: PyTorchObs, deterministic: bool = Fals...
    method predict (line 331) | def predict(
    method scale_action (line 388) | def scale_action(self, action: np.ndarray) -> np.ndarray:
    method unscale_action (line 402) | def unscale_action(self, scaled_action: np.ndarray) -> np.ndarray:
  class ActorCriticPolicy (line 416) | class ActorCriticPolicy(BasePolicy):
    method __init__ (line 448) | def __init__(
    method _get_constructor_parameters (line 537) | def _get_constructor_parameters(self) -> dict[str, Any]:
    method reset_noise (line 561) | def reset_noise(self, n_envs: int = 1) -> None:
    method _build_mlp_extractor (line 570) | def _build_mlp_extractor(self) -> None:
    method _build (line 585) | def _build(self, lr_schedule: Schedule) -> None:
    method forward (line 636) | def forward(self, obs: th.Tensor, deterministic: bool = False) -> tupl...
    method extract_features (line 660) | def extract_features(  # type: ignore[override]
    method _get_action_dist_from_latent (line 684) | def _get_action_dist_from_latent(self, latent_pi: th.Tensor) -> Distri...
    method _predict (line 709) | def _predict(self, observation: PyTorchObs, deterministic: bool = Fals...
    method evaluate_actions (line 719) | def evaluate_actions(self, obs: PyTorchObs, actions: th.Tensor) -> tup...
    method get_distribution (line 743) | def get_distribution(self, obs: PyTorchObs) -> Distribution:
    method predict_values (line 754) | def predict_values(self, obs: PyTorchObs) -> th.Tensor:
  class ActorCriticCnnPolicy (line 766) | class ActorCriticCnnPolicy(ActorCriticPolicy):
    method __init__ (line 798) | def __init__(
  class MultiInputActorCriticPolicy (line 839) | class MultiInputActorCriticPolicy(ActorCriticPolicy):
    method __init__ (line 871) | def __init__(
  class ContinuousCritic (line 912) | class ContinuousCritic(BaseModel):
    method __init__ (line 941) | def __init__(
    method forward (line 971) | def forward(self, obs: th.Tensor, actions: th.Tensor) -> tuple[th.Tens...
    method q1_forward (line 979) | def q1_forward(self, obs: th.Tensor, actions: th.Tensor) -> th.Tensor:

FILE: stable_baselines3/common/preprocessing.py
  function is_image_space_channels_first (line 9) | def is_image_space_channels_first(observation_space: spaces.Box) -> bool:
  function is_image_space (line 26) | def is_image_space(
  function maybe_transpose (line 71) | def maybe_transpose(observation: np.ndarray, observation_space: spaces.S...
  function preprocess_obs (line 91) | def preprocess_obs(
  function get_obs_shape (line 142) | def get_obs_shape(
  function get_flattened_obs_dim (line 169) | def get_flattened_obs_dim(observation_space: spaces.Space) -> int:
  function get_action_dim (line 188) | def get_action_dim(action_space: spaces.Space) -> int:
  function check_for_nested_spaces (line 213) | def check_for_nested_spaces(obs_space: spaces.Space) -> None:

FILE: stable_baselines3/common/results_plotter.py
  function rolling_window (line 19) | def rolling_window(array: np.ndarray, window: int) -> np.ndarray:
  function window_func (line 32) | def window_func(var_1: np.ndarray, var_2: np.ndarray, window: int, func:...
  function ts2xy (line 47) | def ts2xy(data_frame: pd.DataFrame, x_axis: str) -> tuple[np.ndarray, np...
  function plot_curves (line 72) | def plot_curves(
  function plot_results (line 102) | def plot_results(

FILE: stable_baselines3/common/running_mean_std.py
  class RunningMeanStd (line 4) | class RunningMeanStd:
    method __init__ (line 5) | def __init__(self, epsilon: float = 1e-4, shape: tuple[int, ...] = ()):
    method copy (line 17) | def copy(self) -> "RunningMeanStd":
    method combine (line 27) | def combine(self, other: "RunningMeanStd") -> None:
    method update (line 35) | def update(self, arr: np.ndarray) -> None:
    method update_from_moments (line 41) | def update_from_moments(self, batch_mean: np.ndarray, batch_var: np.nd...

FILE: stable_baselines3/common/save_util.py
  function recursive_getattr (line 25) | def recursive_getattr(obj: Any, attr: str, *args) -> Any:
  function recursive_setattr (line 44) | def recursive_setattr(obj: Any, attr: str, val: Any) -> None:
  function is_json_serializable (line 60) | def is_json_serializable(item: Any) -> bool:
  function data_to_json (line 76) | def data_to_json(data: dict[str, Any]) -> str:
  function json_to_data (line 131) | def json_to_data(json_string: str, custom_objects: dict[str, Any] | None...
  function open_path (line 182) | def open_path(
  function open_path_str (line 226) | def open_path_str(path: str, mode: str, verbose: int = 0, suffix: str | ...
  function open_path_pathlib (line 244) | def open_path_pathlib(path: pathlib.Path, mode: str, verbose: int = 0, s...
  function save_to_zip_file (line 294) | def save_to_zip_file(
  function save_to_pkl (line 339) | def save_to_pkl(path: str | pathlib.Path | io.BufferedIOBase, obj: Any, ...
  function load_from_pkl (line 359) | def load_from_pkl(path: str | pathlib.Path | io.BufferedIOBase, verbose:...
  function load_from_zip_file (line 376) | def load_from_zip_file(

FILE: stable_baselines3/common/sb2_compat/rmsprop_tf_like.py
  class RMSpropTFLike (line 8) | class RMSpropTFLike(Optimizer):
    method __init__ (line 47) | def __init__(
    method __setstate__ (line 71) | def __setstate__(self, state: dict[str, Any]) -> None:
    method step (line 78) | def step(self, closure: Callable[[], float] | None = None) -> float | ...

FILE: stable_baselines3/common/torch_layers.py
  class BaseFeaturesExtractor (line 11) | class BaseFeaturesExtractor(nn.Module):
    method __init__ (line 19) | def __init__(self, observation_space: gym.Space, features_dim: int = 0...
    method features_dim (line 26) | def features_dim(self) -> int:
  class FlattenExtractor (line 31) | class FlattenExtractor(BaseFeaturesExtractor):
    method __init__ (line 39) | def __init__(self, observation_space: gym.Space) -> None:
    method forward (line 43) | def forward(self, observations: th.Tensor) -> th.Tensor:
  class NatureCNN (line 47) | class NatureCNN(BaseFeaturesExtractor):
    method __init__ (line 63) | def __init__(
    method forward (line 104) | def forward(self, observations: th.Tensor) -> th.Tensor:
  function create_mlp (line 108) | def create_mlp(
  class MlpExtractor (line 184) | class MlpExtractor(nn.Module):
    method __init__ (line 209) | def __init__(
    method forward (line 250) | def forward(self, features: th.Tensor) -> tuple[th.Tensor, th.Tensor]:
    method forward_actor (line 257) | def forward_actor(self, features: th.Tensor) -> th.Tensor:
    method forward_critic (line 260) | def forward_critic(self, features: th.Tensor) -> th.Tensor:
  class CombinedExtractor (line 264) | class CombinedExtractor(BaseFeaturesExtractor):
    method __init__ (line 280) | def __init__(
    method forward (line 306) | def forward(self, observations: TensorDict) -> th.Tensor:
  function get_actor_critic_arch (line 314) | def get_actor_critic_arch(net_arch: list[int] | dict[str, list[int]]) ->...

FILE: stable_baselines3/common/type_aliases.py
  class RolloutBufferSamples (line 32) | class RolloutBufferSamples(NamedTuple):
  class DictRolloutBufferSamples (line 41) | class DictRolloutBufferSamples(NamedTuple):
  class ReplayBufferSamples (line 50) | class ReplayBufferSamples(NamedTuple):
  class DictReplayBufferSamples (line 60) | class DictReplayBufferSamples(NamedTuple):
  class RolloutReturn (line 69) | class RolloutReturn(NamedTuple):
  class TrainFrequencyUnit (line 75) | class TrainFrequencyUnit(Enum):
  class TrainFreq (line 80) | class TrainFreq(NamedTuple):
  class PolicyPredictor (line 85) | class PolicyPredictor(Protocol):
    method predict (line 86) | def predict(

FILE: stable_baselines3/common/utils.py
  function set_random_seed (line 28) | def set_random_seed(seed: int, using_cuda: bool = False) -> None:
  function explained_variance (line 49) | def explained_variance(y_pred: np.ndarray, y_true: np.ndarray) -> float:
  function update_learning_rate (line 68) | def update_learning_rate(optimizer: th.optim.Optimizer, learning_rate: f...
  class FloatSchedule (line 80) | class FloatSchedule:
    method __init__ (line 89) | def __init__(self, value_schedule: Schedule | float):
    method __call__ (line 98) | def __call__(self, progress_remaining: float) -> float:
    method __repr__ (line 103) | def __repr__(self) -> str:
  class LinearSchedule (line 107) | class LinearSchedule:
    method __init__ (line 120) | def __init__(self, start: float, end: float, end_fraction: float) -> N...
    method __call__ (line 125) | def __call__(self, progress_remaining: float) -> float:
    method __repr__ (line 131) | def __repr__(self) -> str:
  class ConstantSchedule (line 135) | class ConstantSchedule:
    method __init__ (line 143) | def __init__(self, val: float):
    method __call__ (line 146) | def __call__(self, _: float) -> float:
    method __repr__ (line 149) | def __repr__(self) -> str:
  function get_schedule_fn (line 158) | def get_schedule_fn(value_schedule: Schedule | float) -> Schedule:
  function get_linear_fn (line 179) | def get_linear_fn(start: float, end: float, end_fraction: float) -> Sche...
  function constant_fn (line 204) | def constant_fn(val: float) -> Schedule:
  function get_device (line 223) | def get_device(device: th.device | str = "auto") -> th.device:
  function get_latest_run_id (line 246) | def get_latest_run_id(log_path: str = "", log_name: str = "") -> int:
  function configure_logger (line 265) | def configure_logger(
  function check_for_correct_spaces (line 302) | def check_for_correct_spaces(env: GymEnv, observation_space: spaces.Spac...
  function check_shape_equal (line 320) | def check_shape_equal(space1: spaces.Space, space2: spaces.Space) -> None:
  function is_vectorized_box_observation (line 340) | def is_vectorized_box_observation(observation: np.ndarray, observation_s...
  function is_vectorized_discrete_observation (line 361) | def is_vectorized_discrete_observation(observation: int | np.ndarray, ob...
  function is_vectorized_multidiscrete_observation (line 381) | def is_vectorized_multidiscrete_observation(observation: np.ndarray, obs...
  function is_vectorized_multibinary_observation (line 402) | def is_vectorized_multibinary_observation(observation: np.ndarray, obser...
  function is_vectorized_dict_observation (line 423) | def is_vectorized_dict_observation(observation: np.ndarray, observation_...
  function is_vectorized_observation (line 467) | def is_vectorized_observation(observation: int | np.ndarray, observation...
  function safe_mean (line 493) | def safe_mean(arr: np.ndarray | list | deque) -> float:
  function get_parameters_by_name (line 504) | def get_parameters_by_name(model: th.nn.Module, included_names: Iterable...
  function zip_strict (line 517) | def zip_strict(*iterables: Iterable) -> Iterable:
  function polyak_update (line 530) | def polyak_update(
  function obs_as_tensor (line 556) | def obs_as_tensor(obs: np.ndarray | dict[str, np.ndarray], device: th.de...
  function should_collect_more_steps (line 572) | def should_collect_more_steps(
  function get_system_info (line 600) | def get_system_info(print_info: bool = True) -> tuple[dict[str, str], str]:

FILE: stable_baselines3/common/vec_env/__init__.py
  function unwrap_vec_wrapper (line 19) | def unwrap_vec_wrapper(env: VecEnv, vec_wrapper_class: type[VecEnvWrappe...
  function unwrap_vec_normalize (line 35) | def unwrap_vec_normalize(env: VecEnv) -> VecNormalize | None:
  function is_vecenv_wrapped (line 45) | def is_vecenv_wrapped(env: VecEnv, vec_wrapper_class: type[VecEnvWrapper...
  function sync_envs_normalization (line 56) | def sync_envs_normalization(env: VecEnv, eval_env: VecEnv) -> None:

FILE: stable_baselines3/common/vec_env/base_vec_env.py
  function tile_images (line 24) | def tile_images(images_nhwc: Sequence[np.ndarray]) -> np.ndarray:  # pra...
  class VecEnv (line 50) | class VecEnv(ABC):
    method __init__ (line 59) | def __init__(
    method _reset_seeds (line 96) | def _reset_seeds(self) -> None:
    method _reset_options (line 102) | def _reset_options(self) -> None:
    method reset (line 109) | def reset(self) -> VecEnvObs:
    method step_async (line 123) | def step_async(self, actions: np.ndarray) -> None:
    method step_wait (line 135) | def step_wait(self) -> VecEnvStepReturn:
    method close (line 144) | def close(self) -> None:
    method has_attr (line 150) | def has_attr(self, attr_name: str) -> bool:
    method get_attr (line 166) | def get_attr(self, attr_name: str, indices: VecEnvIndices = None) -> l...
    method set_attr (line 177) | def set_attr(self, attr_name: str, value: Any, indices: VecEnvIndices ...
    method env_method (line 189) | def env_method(self, method_name: str, *method_args, indices: VecEnvIn...
    method env_is_wrapped (line 202) | def env_is_wrapped(self, wrapper_class: type[gym.Wrapper], indices: Ve...
    method step (line 214) | def step(self, actions: np.ndarray) -> VecEnvStepReturn:
    method get_images (line 224) | def get_images(self) -> Sequence[np.ndarray | None]:
    method render (line 230) | def render(self, mode: str | None = None) -> np.ndarray | None:
    method seed (line 292) | def seed(self, seed: int | None = None) -> Sequence[None | int]:
    method set_options (line 311) | def set_options(self, options: list[dict] | dict | None = None) -> None:
    method unwrapped (line 328) | def unwrapped(self) -> "VecEnv":
    method getattr_depth_check (line 334) | def getattr_depth_check(self, name: str, already_found: bool) -> str |...
    method _get_indices (line 346) | def _get_indices(self, indices: VecEnvIndices) -> Iterable[int]:
  class VecEnvWrapper (line 360) | class VecEnvWrapper(VecEnv):
    method __init__ (line 369) | def __init__(
    method step_async (line 384) | def step_async(self, actions: np.ndarray) -> None:
    method reset (line 388) | def reset(self) -> VecEnvObs:
    method step_wait (line 392) | def step_wait(self) -> VecEnvStepReturn:
    method seed (line 395) | def seed(self, seed: int | None = None) -> Sequence[None | int]:
    method set_options (line 398) | def set_options(self, options: list[dict] | dict | None = None) -> None:
    method close (line 401) | def close(self) -> None:
    method render (line 404) | def render(self, mode: str | None = None) -> np.ndarray | None:
    method get_images (line 407) | def get_images(self) -> Sequence[np.ndarray | None]:
    method has_attr (line 410) | def has_attr(self, attr_name: str) -> bool:
    method get_attr (line 413) | def get_attr(self, attr_name: str, indices: VecEnvIndices = None) -> l...
    method set_attr (line 416) | def set_attr(self, attr_name: str, value: Any, indices: VecEnvIndices ...
    method env_method (line 419) | def env_method(self, method_name: str, *method_args, indices: VecEnvIn...
    method env_is_wrapped (line 422) | def env_is_wrapped(self, wrapper_class: type[gym.Wrapper], indices: Ve...
    method __getattr__ (line 425) | def __getattr__(self, name: str) -> Any:
    method _get_all_attributes (line 441) | def _get_all_attributes(self) -> dict[str, Any]:
    method getattr_recursive (line 450) | def getattr_recursive(self, name: str) -> Any:
    method getattr_depth_check (line 468) | def getattr_depth_check(self, name: str, already_found: bool) -> str |...
  class CloudpickleWrapper (line 487) | class CloudpickleWrapper:
    method __init__ (line 494) | def __init__(self, var: Any):
    method __getstate__ (line 497) | def __getstate__(self) -> Any:
    method __setstate__ (line 500) | def __setstate__(self, var: Any) -> None:

FILE: stable_baselines3/common/vec_env/dummy_vec_env.py
  class DummyVecEnv (line 15) | class DummyVecEnv(VecEnv):
    method __init__ (line 30) | def __init__(self, env_fns: list[Callable[[], gym.Env]]):
    method step_async (line 53) | def step_async(self, actions: np.ndarray) -> None:
    method step_wait (line 56) | def step_wait(self) -> VecEnvStepReturn:
    method reset (line 75) | def reset(self) -> VecEnvObs:
    method close (line 85) | def close(self) -> None:
    method get_images (line 89) | def get_images(self) -> Sequence[np.ndarray | None]:
    method render (line 97) | def render(self, mode: str | None = None) -> np.ndarray | None:
    method _save_obs (line 106) | def _save_obs(self, env_idx: int, obs: VecEnvObs) -> None:
    method _obs_from_buf (line 113) | def _obs_from_buf(self) -> VecEnvObs:
    method get_attr (line 116) | def get_attr(self, attr_name: str, indices: VecEnvIndices = None) -> l...
    method set_attr (line 121) | def set_attr(self, attr_name: str, value: Any, indices: VecEnvIndices ...
    method env_method (line 127) | def env_method(self, method_name: str, *method_args, indices: VecEnvIn...
    method env_is_wrapped (line 132) | def env_is_wrapped(self, wrapper_class: type[gym.Wrapper], indices: Ve...
    method _get_target_envs (line 140) | def _get_target_envs(self, indices: VecEnvIndices) -> list[gym.Env]:

FILE: stable_baselines3/common/vec_env/patch_gym.py
  function _patch_env (line 15) | def _patch_env(env: Union["gym.Env", gymnasium.Env]) -> gymnasium.Env:  ...
  function _convert_space (line 63) | def _convert_space(space: Union["gym.Space", gymnasium.Space]) -> gymnas...

FILE: stable_baselines3/common/vec_env/stacked_observations.py
  class StackedObservations (line 13) | class StackedObservations(Generic[TObs]):
    method __init__ (line 28) | def __init__(
    method compute_stacking (line 68) | def compute_stacking(
    method reset (line 102) | def reset(self, observation: TObs) -> TObs:
    method update (line 119) | def update(

FILE: stable_baselines3/common/vec_env/subproc_vec_env.py
  function _worker (line 20) | def _worker(  # noqa: C901
  class SubprocVecEnv (line 79) | class SubprocVecEnv(VecEnv):
    method __init__ (line 103) | def __init__(self, env_fns: list[Callable[[], gym.Env]], start_method:...
    method step_async (line 131) | def step_async(self, actions: np.ndarray) -> None:
    method step_wait (line 136) | def step_wait(self) -> VecEnvStepReturn:
    method reset (line 142) | def reset(self) -> VecEnvObs:
    method close (line 152) | def close(self) -> None:
    method get_images (line 164) | def get_images(self) -> Sequence[np.ndarray | None]:
    method has_attr (line 176) | def has_attr(self, attr_name: str) -> bool:
    method get_attr (line 183) | def get_attr(self, attr_name: str, indices: VecEnvIndices = None) -> l...
    method set_attr (line 190) | def set_attr(self, attr_name: str, value: Any, indices: VecEnvIndices ...
    method env_method (line 198) | def env_method(self, method_name: str, *method_args, indices: VecEnvIn...
    method env_is_wrapped (line 205) | def env_is_wrapped(self, wrapper_class: type[gym.Wrapper], indices: Ve...
    method _get_target_remotes (line 212) | def _get_target_remotes(self, indices: VecEnvIndices) -> list[Any]:
  function _stack_obs (line 224) | def _stack_obs(obs_list: list[VecEnvObs] | tuple[VecEnvObs], space: spac...

FILE: stable_baselines3/common/vec_env/util.py
  function dict_to_obs (line 14) | def dict_to_obs(obs_space: spaces.Space, obs_dict: dict[Any, np.ndarray]...
  function obs_space_info (line 35) | def obs_space_info(obs_space: spaces.Space) -> tuple[list[str], dict[Any...

FILE: stable_baselines3/common/vec_env/vec_check_nan.py
  class VecCheckNan (line 9) | class VecCheckNan(VecEnvWrapper):
    method __init__ (line 20) | def __init__(self, venv: VecEnv, raise_exception: bool = False, warn_o...
    method step_async (line 33) | def step_async(self, actions: np.ndarray) -> None:
    method step_wait (line 38) | def step_wait(self) -> VecEnvStepReturn:
    method reset (line 44) | def reset(self) -> VecEnvObs:
    method check_array_value (line 50) | def check_array_value(self, name: str, value: np.ndarray) -> list[tupl...
    method _check_val (line 67) | def _check_val(self, event: str, **kwargs) -> None:

FILE: stable_baselines3/common/vec_env/vec_extract_dict_obs.py
  class VecExtractDictObs (line 7) | class VecExtractDictObs(VecEnvWrapper):
    method __init__ (line 15) | def __init__(self, venv: VecEnv, key: str):
    method reset (line 22) | def reset(self) -> np.ndarray:
    method step_wait (line 27) | def step_wait(self) -> VecEnvStepReturn:

FILE: stable_baselines3/common/vec_env/vec_frame_stack.py
  class VecFrameStack (line 11) | class VecFrameStack(VecEnvWrapper):
    method __init__ (line 22) | def __init__(self, venv: VecEnv, n_stack: int, channels_order: str | M...
    method step_wait (line 31) | def step_wait(
    method reset (line 43) | def reset(self) -> np.ndarray | dict[str, np.ndarray]:

FILE: stable_baselines3/common/vec_env/vec_monitor.py
  class VecMonitor (line 9) | class VecMonitor(VecEnvWrapper):
    method __init__ (line 25) | def __init__(
    method reset (line 68) | def reset(self) -> VecEnvObs:
    method step_wait (line 74) | def step_wait(self) -> VecEnvStepReturn:
    method close (line 96) | def close(self) -> None:

FILE: stable_baselines3/common/vec_env/vec_normalize.py
  class VecNormalize (line 15) | class VecNormalize(VecEnvWrapper):
    method __init__ (line 35) | def __init__(
    method _sanity_checks (line 100) | def _sanity_checks(self) -> None:
    method __getstate__ (line 128) | def __getstate__(self) -> dict[str, Any]:
    method __setstate__ (line 141) | def __setstate__(self, state: dict[str, Any]) -> None:
    method set_venv (line 155) | def set_venv(self, venv: VecEnv) -> None:
    method step_wait (line 174) | def step_wait(self) -> VecEnvStepReturn:
    method _update_reward (line 209) | def _update_reward(self, reward: np.ndarray) -> None:
    method _normalize_obs (line 214) | def _normalize_obs(self, obs: np.ndarray, obs_rms: RunningMeanStd) -> ...
    method _unnormalize_obs (line 223) | def _unnormalize_obs(self, obs: np.ndarray, obs_rms: RunningMeanStd) -...
    method normalize_obs (line 232) | def normalize_obs(self, obs: np.ndarray | dict[str, np.ndarray]) -> np...
    method normalize_reward (line 250) | def normalize_reward(self, reward: np.ndarray) -> np.ndarray:
    method unnormalize_obs (line 261) | def unnormalize_obs(self, obs: np.ndarray | dict[str, np.ndarray]) -> ...
    method unnormalize_reward (line 274) | def unnormalize_reward(self, reward: np.ndarray) -> np.ndarray:
    method get_original_obs (line 279) | def get_original_obs(self) -> np.ndarray | dict[str, np.ndarray]:
    method get_original_reward (line 286) | def get_original_reward(self) -> np.ndarray:
    method reset (line 292) | def reset(self) -> np.ndarray | dict[str, np.ndarray]:
    method load (line 311) | def load(load_path: str, venv: VecEnv) -> "VecNormalize":
    method save (line 324) | def save(self, save_path: str) -> None:

FILE: stable_baselines3/common/vec_env/vec_transpose.py
  class VecTransposeImage (line 10) | class VecTransposeImage(VecEnvWrapper):
    method __init__ (line 20) | def __init__(self, venv: VecEnv, skip: bool = False):
    method transpose_space (line 46) | def transpose_space(observation_space: spaces.Box, key: str = "") -> s...
    method transpose_image (line 64) | def transpose_image(image: np.ndarray) -> np.ndarray:
    method transpose_observations (line 75) | def transpose_observations(self, observations: np.ndarray | dict) -> n...
    method step_wait (line 95) | def step_wait(self) -> VecEnvStepReturn:
    method reset (line 108) | def reset(self) -> np.ndarray | dict:
    method close (line 116) | def close(self) -> None:

FILE: stable_baselines3/common/vec_env/vec_video_recorder.py
  class VecVideoRecorder (line 13) | class VecVideoRecorder(VecEnvWrapper):
    method __init__ (line 35) | def __init__(
    method reset (line 81) | def reset(self) -> VecEnvObs:
    method _start_video_recorder (line 87) | def _start_video_recorder(self) -> None:
    method _video_enabled (line 94) | def _video_enabled(self) -> bool:
    method step_wait (line 97) | def step_wait(self) -> VecEnvStepReturn:
    method _capture_frame (line 111) | def _capture_frame(self) -> None:
    method close (line 124) | def close(self) -> None:
    method _start_recording (line 130) | def _start_recording(self) -> None:
    method _stop_recording (line 137) | def _stop_recording(self) -> None:
    method __del__ (line 154) | def __del__(self) -> None:

FILE: stable_baselines3/ddpg/ddpg.py
  class DDPG (line 14) | class DDPG(TD3):
    method __init__ (line 57) | def __init__(
    method learn (line 117) | def learn(

FILE: stable_baselines3/dqn/dqn.py
  class DQN (line 19) | class DQN(OffPolicyAlgorithm):
    method __init__ (line 77) | def __init__(
    method _setup_model (line 146) | def _setup_model(self) -> None:
    method _create_aliases (line 167) | def _create_aliases(self) -> None:
    method _on_step (line 171) | def _on_step(self) -> None:
    method train (line 187) | def train(self, gradient_steps: int, batch_size: int = 100) -> None:
    method predict (line 233) | def predict(
    method learn (line 263) | def learn(
    method _excluded_save_params (line 281) | def _excluded_save_params(self) -> list[str]:
    method _get_torch_save_params (line 284) | def _get_torch_save_params(self) -> tuple[list[str], list[str]]:

FILE: stable_baselines3/dqn/policies.py
  class QNetwork (line 18) | class QNetwork(BasePolicy):
    method __init__ (line 32) | def __init__(
    method forward (line 59) | def forward(self, obs: PyTorchObs) -> th.Tensor:
    method _predict (line 68) | def _predict(self, observation: PyTorchObs, deterministic: bool = True...
    method _get_constructor_parameters (line 74) | def _get_constructor_parameters(self) -> dict[str, Any]:
  class DQNPolicy (line 88) | class DQNPolicy(BasePolicy):
    method __init__ (line 111) | def __init__(
    method _build (line 153) | def _build(self, lr_schedule: Schedule) -> None:
    method make_q_net (line 175) | def make_q_net(self) -> QNetwork:
    method forward (line 180) | def forward(self, obs: PyTorchObs, deterministic: bool = True) -> th.T...
    method _predict (line 183) | def _predict(self, obs: PyTorchObs, deterministic: bool = True) -> th....
    method _get_constructor_parameters (line 186) | def _get_constructor_parameters(self) -> dict[str, Any]:
    method set_training_mode (line 202) | def set_training_mode(self, mode: bool) -> None:
  class CnnPolicy (line 217) | class CnnPolicy(DQNPolicy):
    method __init__ (line 235) | def __init__(
  class MultiInputPolicy (line 262) | class MultiInputPolicy(DQNPolicy):
    method __init__ (line 280) | def __init__(

FILE: stable_baselines3/her/goal_selection_strategy.py
  class GoalSelectionStrategy (line 4) | class GoalSelectionStrategy(Enum):

FILE: stable_baselines3/her/her_replay_buffer.py
  class HerReplayBuffer (line 15) | class HerReplayBuffer(DictReplayBuffer):
    method __init__ (line 50) | def __init__(
    method __getstate__ (line 101) | def __getstate__(self) -> dict[str, Any]:
    method __setstate__ (line 112) | def __setstate__(self, state: dict[str, Any]) -> None:
    method set_env (line 124) | def set_env(self, env: VecEnv) -> None:
    method add (line 135) | def add(  # type: ignore[override]
    method _compute_episode_length (line 169) | def _compute_episode_length(self, env_idx: int) -> None:
    method sample (line 186) | def sample(self, batch_size: int, env: VecNormalize | None = None) -> ...
    method _get_real_samples (line 248) | def _get_real_samples(
    method _get_virtual_samples (line 287) | def _get_virtual_samples(
    method _sample_goals (line 355) | def _sample_goals(self, batch_indices: np.ndarray, env_indices: np.nda...
    method truncate_last_trajectory (line 386) | def truncate_last_trajectory(self) -> None:

FILE: stable_baselines3/ppo/ppo.py
  class PPO (line 18) | class PPO(OnPolicyAlgorithm):
    method __init__ (line 80) | def __init__(
    method _setup_model (line 173) | def _setup_model(self) -> None:
    method train (line 184) | def train(self) -> None:
    method learn (line 302) | def learn(

FILE: stable_baselines3/sac/policies.py
  class Actor (line 25) | class Actor(BasePolicy):
    method __init__ (line 50) | def __init__(
    method _get_constructor_parameters (line 105) | def _get_constructor_parameters(self) -> dict[str, Any]:
    method get_std (line 123) | def get_std(self) -> th.Tensor:
    method reset_noise (line 137) | def reset_noise(self, batch_size: int = 1) -> None:
    method get_action_dist_params (line 147) | def get_action_dist_params(self, obs: PyTorchObs) -> tuple[th.Tensor, ...
    method forward (line 167) | def forward(self, obs: PyTorchObs, deterministic: bool = False) -> th....
    method action_log_prob (line 172) | def action_log_prob(self, obs: PyTorchObs) -> tuple[th.Tensor, th.Tens...
    method _predict (line 177) | def _predict(self, observation: PyTorchObs, deterministic: bool = Fals...
  class SACPolicy (line 181) | class SACPolicy(BasePolicy):
    method __init__ (line 214) | def __init__(
    method _build (line 280) | def _build(self, lr_schedule: Schedule) -> None:
    method _get_constructor_parameters (line 312) | def _get_constructor_parameters(self) -> dict[str, Any]:
    method reset_noise (line 333) | def reset_noise(self, batch_size: int = 1) -> None:
    method make_actor (line 341) | def make_actor(self, features_extractor: BaseFeaturesExtractor | None ...
    method make_critic (line 345) | def make_critic(self, features_extractor: BaseFeaturesExtractor | None...
    method forward (line 349) | def forward(self, obs: PyTorchObs, deterministic: bool = False) -> th....
    method _predict (line 352) | def _predict(self, observation: PyTorchObs, deterministic: bool = Fals...
    method set_training_mode (line 355) | def set_training_mode(self, mode: bool) -> None:
  class CnnPolicy (line 371) | class CnnPolicy(SACPolicy):
    method __init__ (line 398) | def __init__(
  class MultiInputPolicy (line 437) | class MultiInputPolicy(SACPolicy):
    method __init__ (line 464) | def __init__(

FILE: stable_baselines3/sac/sac.py
  class SAC (line 19) | class SAC(OffPolicyAlgorithm):
    method __init__ (line 91) | def __init__(
    method _setup_model (line 162) | def _setup_model(self) -> None:
    method _create_aliases (line 197) | def _create_aliases(self) -> None:
    method train (line 202) | def train(self, gradient_steps: int, batch_size: int = 64) -> None:
    method learn (line 304) | def learn(
    method _excluded_save_params (line 322) | def _excluded_save_params(self) -> list[str]:
    method _get_torch_save_params (line 325) | def _get_torch_save_params(self) -> tuple[list[str], list[str]]:

FILE: stable_baselines3/td3/policies.py
  class Actor (line 20) | class Actor(BasePolicy):
    method __init__ (line 35) | def __init__(
    method _get_constructor_parameters (line 62) | def _get_constructor_parameters(self) -> dict[str, Any]:
    method forward (line 75) | def forward(self, obs: th.Tensor) -> th.Tensor:
    method _predict (line 80) | def _predict(self, observation: PyTorchObs, deterministic: bool = Fals...
  class TD3Policy (line 86) | class TD3Policy(BasePolicy):
    method __init__ (line 114) | def __init__(
    method _build (line 172) | def _build(self, lr_schedule: Schedule) -> None:
    method _get_constructor_parameters (line 210) | def _get_constructor_parameters(self) -> dict[str, Any]:
    method make_actor (line 228) | def make_actor(self, features_extractor: BaseFeaturesExtractor | None ...
    method make_critic (line 232) | def make_critic(self, features_extractor: BaseFeaturesExtractor | None...
    method forward (line 236) | def forward(self, observation: PyTorchObs, deterministic: bool = False...
    method _predict (line 239) | def _predict(self, observation: PyTorchObs, deterministic: bool = Fals...
    method set_training_mode (line 244) | def set_training_mode(self, mode: bool) -> None:
  class CnnPolicy (line 260) | class CnnPolicy(TD3Policy):
    method __init__ (line 283) | def __init__(
  class MultiInputPolicy (line 314) | class MultiInputPolicy(TD3Policy):
    method __init__ (line 337) | def __init__(

FILE: stable_baselines3/td3/td3.py
  class TD3 (line 19) | class TD3(OffPolicyAlgorithm):
    method __init__ (line 80) | def __init__(
    method _setup_model (line 142) | def _setup_model(self) -> None:
    method _create_aliases (line 151) | def _create_aliases(self) -> None:
    method train (line 157) | def train(self, gradient_steps: int, batch_size: int = 100) -> None:
    method learn (line 218) | def learn(
    method _excluded_save_params (line 236) | def _excluded_save_params(self) -> list[str]:
    method _get_torch_save_params (line 239) | def _get_torch_save_params(self) -> tuple[list[str], list[str]]:

FILE: tests/test_buffers.py
  class DummyEnv (line 16) | class DummyEnv(gym.Env):
    method __init__ (line 21) | def __init__(self):
    method reset (line 29) | def reset(self, *, seed=None, options=None):
    method step (line 34) | def step(self, action):
  class DummyDictEnv (line 44) | class DummyDictEnv(gym.Env):
    method __init__ (line 49) | def __init__(self):
    method reset (line 59) | def reset(self, seed=None, options=None):
    method step (line 64) | def step(self, action):
  function test_env (line 75) | def test_env(env_cls):
  function test_replay_buffer_normalization (line 82) | def test_replay_buffer_normalization(replay_buffer_cls):
  function test_device_buffer (line 114) | def test_device_buffer(replay_buffer_cls, device):
  function test_buffer_dtypes (line 191) | def test_buffer_dtypes(obs_dtype, use_dict, action_space):
  function test_custom_rollout_buffer (line 235) | def test_custom_rollout_buffer():

FILE: tests/test_callbacks.py
  function select_env (line 26) | def select_env(model_class) -> str:
  function test_callbacks (line 34) | def test_callbacks(tmp_path, model_class):
  function test_eval_callback_vec_env (line 114) | def test_eval_callback_vec_env():
  class AlwaysFailCallback (line 130) | class AlwaysFailCallback(BaseCallback):
    method __init__ (line 131) | def __init__(self, *args, callback_false_value, **kwargs):
    method _on_step (line 135) | def _on_step(self) -> bool:
  function test_callbacks_can_cancel_runs (line 154) | def test_callbacks_can_cancel_runs(model_class, model_kwargs, callback_f...
  function test_eval_success_logging (line 164) | def test_eval_success_logging(tmp_path):
  function test_eval_callback_logs_are_written_with_the_correct_timestep (line 188) | def test_eval_callback_logs_are_written_with_the_correct_timestep(tmp_pa...
  function test_eval_friendly_error (line 214) | def test_eval_friendly_error():
  function test_checkpoint_additional_info (line 245) | def test_checkpoint_additional_info(tmp_path):
  function test_eval_callback_chaining (line 271) | def test_eval_callback_chaining(tmp_path):

FILE: tests/test_cnn.py
  function test_cnn (line 17) | def test_cnn(tmp_path, model_class, share_features_extractor):
  function test_vec_transpose_skip (line 70) | def test_vec_transpose_skip(tmp_path, model_class):
  function patch_dqn_names_ (line 96) | def patch_dqn_names_(model):
  function params_should_match (line 103) | def params_should_match(params, other_params):
  function params_should_differ (line 108) | def params_should_differ(params, other_params):
  function check_td3_feature_extractor_match (line 113) | def check_td3_feature_extractor_match(model):
  function check_td3_feature_extractor_differ (line 121) | def check_td3_feature_extractor_differ(model):
  function test_features_extractor_target_net (line 131) | def test_features_extractor_target_net(model_class, share_features_extra...
  function test_channel_first_env (line 240) | def test_channel_first_env(tmp_path):
  function test_image_space_checks (line 269) | def test_image_space_checks():
  function test_image_like_input (line 321) | def test_image_like_input(model_class, normalize_images):

FILE: tests/test_custom_policy.py
  function test_flexible_mlp (line 26) | def test_flexible_mlp(model_class, net_arch):
  function test_custom_offpolicy (line 36) | def test_custom_offpolicy(model_class, net_arch):
  function test_custom_optimizer (line 42) | def test_custom_optimizer(model_class, optimizer_kwargs):
  function test_tf_like_rmsprop_optimizer (line 59) | def test_tf_like_rmsprop_optimizer():
  function test_dqn_custom_policy (line 64) | def test_dqn_custom_policy():
  function test_create_mlp (line 69) | def test_create_mlp():

FILE: tests/test_deterministic.py
  function test_deterministic_training_common (line 12) | def test_deterministic_training_common(algo):

FILE: tests/test_dict_env.py
  class DummyDictEnv (line 14) | class DummyDictEnv(gym.Env):
    method __init__ (line 19) | def __init__(
    method seed (line 64) | def seed(self, seed=None):
    method step (line 68) | def step(self, action):
    method reset (line 73) | def reset(self, *, seed: int | None = None, options: dict | None = None):
    method render (line 78) | def render(self):
  function test_env (line 86) | def test_env(use_discrete_actions, channel_last, nested_dict_obs, vec_on...
  function test_policy_hint (line 96) | def test_policy_hint(policy):
  function test_goal_env (line 103) | def test_goal_env(model_class):
  function test_consistency (line 111) | def test_consistency(model_class):
  function test_dict_spaces (line 157) | def test_dict_spaces(model_class, channel_last):
  function test_multiprocessing (line 200) | def test_multiprocessing(model_class):
  function test_dict_vec_framestack (line 238) | def test_dict_vec_framestack(model_class, channel_last):
  function test_vec_normalize (line 285) | def test_vec_normalize(model_class):
  function test_dict_nested (line 324) | def test_dict_nested():
  function test_vec_normalize_image (line 340) | def test_vec_normalize_image():

FILE: tests/test_distributions.py
  function test_bijector (line 26) | def test_bijector():
  function test_squashed_gaussian (line 41) | def test_squashed_gaussian(model_class):
  function dummy_model_distribution_obs_and_actions (line 57) | def dummy_model_distribution_obs_and_actions() -> tuple[A2C, np.ndarray,...
  function test_get_distribution (line 69) | def test_get_distribution(dummy_model_distribution_obs_and_actions):
  function test_predict_values (line 85) | def test_predict_values(dummy_model_distribution_obs_and_actions):
  function test_sde_distribution (line 96) | def test_sde_distribution():
  function test_entropy (line 121) | def test_entropy(dist):
  function test_categorical (line 149) | def test_categorical(dist, CAT_ACTIONS):
  function test_kl_divergence (line 174) | def test_kl_divergence(dist_type):

FILE: tests/test_env_checker.py
  class ActionDictTestEnv (line 11) | class ActionDictTestEnv(gym.Env):
    method step (line 18) | def step(self, action):
    method reset (line 26) | def reset(self, *, seed=None, options=None):
    method render (line 29) | def render(self):
  function test_check_env_dict_action (line 33) | def test_check_env_dict_action():
  class CustomEnv (line 40) | class CustomEnv(gym.Env):
    method __init__ (line 43) | def __init__(self, render_mode=None):
    method reset (line 48) | def reset(self, *, seed=None, options=None):
    method step (line 52) | def step(self, action):
  function test_check_env_detailed_error (line 121) | def test_check_env_detailed_error(obs_tuple, method):
  class LimitedStepsTestEnv (line 146) | class LimitedStepsTestEnv(gym.Env):
    method __init__ (line 150) | def __init__(self, steps_before_termination: int = 1):
    method reset (line 159) | def reset(self, *, seed: int | None = None, options: dict | None = Non...
    method step (line 167) | def step(self, action: np.ndarray) -> tuple[int, float, bool, bool, di...
    method render (line 179) | def render(self) -> None:
  function test_check_env_single_step_env (line 183) | def test_check_env_single_step_env():
  class SimpleGraphEnv (line 190) | class SimpleGraphEnv(CustomEnv):
    method __init__ (line 191) | def __init__(self):
  class SimpleDictGraphEnv (line 199) | class SimpleDictGraphEnv(CustomEnv):
    method __init__ (line 200) | def __init__(self):
  function test_check_env_graph_space (line 212) | def test_check_env_graph_space():
  class SequenceInDictEnv (line 221) | class SequenceInDictEnv(CustomEnv):
    method __init__ (line 224) | def __init__(self):
  class SequenceInTupleEnv (line 231) | class SequenceInTupleEnv(CustomEnv):
    method __init__ (line 234) | def __init__(self):
  class SequenceInOneOfEnv (line 239) | class SequenceInOneOfEnv(CustomEnv):
    method __init__ (line 242) | def __init__(self):
  function test_check_env_sequence_obs (line 253) | def test_check_env_sequence_obs(env_class):
  function test_check_env_sequence_tuple (line 258) | def test_check_env_sequence_tuple():
  function test_check_env_oneof (line 266) | def test_check_env_oneof():

FILE: tests/test_envs.py
  function test_env (line 32) | def test_env(env_id):
  function test_custom_envs (line 52) | def test_custom_envs(env_class):
  function test_bit_flipping (line 69) | def test_bit_flipping(kwargs):
  function test_high_dimension_action_space (line 90) | def test_high_dimension_action_space():
  function test_non_default_spaces (line 134) | def test_non_default_spaces(new_obs_space):
  function test_non_default_action_spaces (line 177) | def test_non_default_action_spaces(new_action_space):
  function check_reset_assert_error (line 210) | def check_reset_assert_error(env, new_reset_return):
  function test_common_failures_reset (line 226) | def test_common_failures_reset():
  function check_step_assert_error (line 277) | def check_step_assert_error(env, new_step_return=()):
  function test_common_failures_step (line 293) | def test_common_failures_step():

FILE: tests/test_gae.py
  class CustomEnv (line 13) | class CustomEnv(gym.Env):
    method __init__ (line 14) | def __init__(self, max_steps=8):
    method seed (line 21) | def seed(self, seed):
    method reset (line 24) | def reset(self, *, seed: int | None = None, options: dict | None = None):
    method step (line 30) | def step(self, action):
  class InfiniteHorizonEnv (line 46) | class InfiniteHorizonEnv(gym.Env):
    method __init__ (line 47) | def __init__(self, n_states=4):
    method reset (line 54) | def reset(self, *, seed: int | None = None, options: dict | None = None):
    method step (line 61) | def step(self, action):
  class CheckGAECallback (line 66) | class CheckGAECallback(BaseCallback):
    method __init__ (line 67) | def __init__(self):
    method _on_rollout_end (line 70) | def _on_rollout_end(self):
    method _on_step (line 105) | def _on_step(self):
  class CustomPolicy (line 109) | class CustomPolicy(ActorCriticPolicy):
    method __init__ (line 112) | def __init__(self, *args, **kwargs):
    method forward (line 116) | def forward(self, obs, deterministic=False):
  function test_env (line 124) | def test_env(env_cls):
  function test_gae_computation (line 133) | def test_gae_computation(model_class, gae_lambda, gamma, num_episodes):
  function test_infinite_horizon (line 153) | def test_infinite_horizon(model_class, handle_timeout_termination):

FILE: tests/test_her.py
  function test_import_error (line 20) | def test_import_error():
  function test_her (line 30) | def test_her(model_class, image_obs_space):
  function test_multiprocessing (line 68) | def test_multiprocessing(model_class, image_obs_space):
  function test_goal_selection_strategy (line 88) | def test_goal_selection_strategy(goal_selection_strategy):
  function test_save_load (line 122) | def test_save_load(tmp_path, model_class, use_sde):
  function test_save_load_replay_buffer (line 227) | def test_save_load_replay_buffer(n_envs, tmp_path, recwarn, truncate_las...
  function test_full_replay_buffer (line 292) | def test_full_replay_buffer():
  function test_truncate_last_trajectory (line 329) | def test_truncate_last_trajectory(n_envs, recwarn, n_steps, handle_timeo...
  function test_performance_her (line 435) | def test_performance_her(n_bits):

FILE: tests/test_identity.py
  function test_discrete (line 15) | def test_discrete(model_class, env):
  function test_continuous (line 34) | def test_continuous(model_class):

FILE: tests/test_logger.py
  class LogContent (line 55) | class LogContent:
    method __init__ (line 60) | def __init__(self, _format: str, lines: Sequence):
    method empty (line 65) | def empty(self):
    method __repr__ (line 68) | def __repr__(self):
  function read_log (line 73) | def read_log(tmp_path, capsys):
  function test_set_logger (line 109) | def test_set_logger(tmp_path):
  function test_main (line 154) | def test_main(tmp_path):
  function test_make_output (line 192) | def test_make_output(tmp_path, read_log, _format):
  function test_make_output_fail (line 208) | def test_make_output_fail(tmp_path):
  function test_exclude_keys (line 218) | def test_exclude_keys(tmp_path, read_log, _format):
  function test_report_video_to_tensorboard (line 229) | def test_report_video_to_tensorboard(tmp_path, read_log, capsys):
  function is_moviepy_installed (line 250) | def is_moviepy_installed():
  function test_unsupported_video_format (line 255) | def test_unsupported_video_format(tmp_path, unsupported_format):
  function test_log_histogram (line 274) | def test_log_histogram(tmp_path, read_log, histogram):
  function test_unsupported_type_histogram (line 299) | def test_unsupported_type_histogram(tmp_path, read_log, histogram):
  function test_report_image_to_tensorboard (line 313) | def test_report_image_to_tensorboard(tmp_path, read_log):
  function test_unsupported_image_format (line 325) | def test_unsupported_image_format(tmp_path, unsupported_format):
  function test_report_figure_to_tensorboard (line 335) | def test_report_figure_to_tensorboard(tmp_path, read_log):
  function test_unsupported_figure_format (line 349) | def test_unsupported_figure_format(tmp_path, unsupported_format):
  function test_unsupported_hparam (line 362) | def test_unsupported_hparam(tmp_path, unsupported_format):
  function test_key_length (line 374) | def test_key_length(tmp_path):
  class TimeDelayEnv (line 405) | class TimeDelayEnv(gym.Env):
    method __init__ (line 410) | def __init__(self, delay: float = 0.01):
    method reset (line 416) | def reset(self, seed=None):
    method step (line 419) | def step(self, action):
  function test_env (line 426) | def test_env(env_cls):
  class InMemoryLogger (line 431) | class InMemoryLogger(Logger):
    method __init__ (line 436) | def __init__(self):
    method dump (line 439) | def dump(self, step: int = 0) -> None:
  function test_fps_logger (line 444) | def test_fps_logger(tmp_path, algo):
  function test_fps_no_div_zero (line 469) | def test_fps_no_div_zero(algo):
  function test_human_output_same_keys_different_tags (line 481) | def test_human_output_same_keys_different_tags():
  function test_ep_buffers_stats_window_size (line 491) | def test_ep_buffers_stats_window_size(algo, stats_window_size):
  function test_human_out_custom_text_io (line 501) | def test_human_out_custom_text_io(base_class):
  class DummySuccessEnv (line 539) | class DummySuccessEnv(gym.Env):
    method __init__ (line 545) | def __init__(self, dummy_successes, ep_steps):
    method reset (line 566) | def reset(self, seed=None, options=None):
    method step (line 578) | def step(self, action):
  function test_rollout_success_rate_onpolicy_algo (line 593) | def test_rollout_success_rate_onpolicy_algo(tmp_path):

FILE: tests/test_monitor.py
  function test_monitor (line 20) | def test_monitor(tmp_path):
  function test_monitor_load_results (line 70) | def test_monitor_load_results(tmp_path):

FILE: tests/test_n_step_replay.py
  function test_run (line 11) | def test_run(model_class):
  function create_buffer (line 33) | def create_buffer(buffer_size=10, n_steps=3, gamma=0.99, n_envs=1):
  function create_normal_buffer (line 47) | def create_normal_buffer(buffer_size=10, n_envs=1):
  function fill_buffer (line 59) | def fill_buffer(buffer, length, done_at=None, truncated_at=None):
  function compute_expected_nstep_reward (line 78) | def compute_expected_nstep_reward(gamma, n_steps, stop_idx=None):
  function test_nstep_early_termination (line 96) | def test_nstep_early_termination(done_at, n_steps, base_idx):
  function test_nstep_early_truncation (line 111) | def test_nstep_early_truncation(truncated_at, n_steps, base_idx):
  function test_nstep_no_terminations (line 124) | def test_nstep_no_terminations(n_steps):
  function test_match_normal_buffer (line 161) | def test_match_normal_buffer():

FILE: tests/test_predict.py
  class SubClassedBox (line 22) | class SubClassedBox(spaces.Box):
    method __init__ (line 23) | def __init__(self, *args, **kwargs):
  class CustomSubClassedSpaceEnv (line 27) | class CustomSubClassedSpaceEnv(gym.Env):
    method __init__ (line 28) | def __init__(self):
    method reset (line 33) | def reset(self, seed=None):
    method step (line 36) | def step(self, action):
  function test_env (line 41) | def test_env(env_cls):
  function test_auto_wrap (line 47) | def test_auto_wrap(model_class):
  function test_predict (line 62) | def test_predict(model_class, env_id, device):
  function test_dqn_epsilon_greedy (line 102) | def test_dqn_epsilon_greedy():
  function test_subclassed_space_env (line 113) | def test_subclassed_space_env(model_class):
  function test_mixing_gym_vecenv_api (line 121) | def test_mixing_gym_vecenv_api():

FILE: tests/test_preprocessing.py
  function test_get_obs_shape_discrete (line 7) | def test_get_obs_shape_discrete():
  function test_get_obs_shape_multidiscrete (line 11) | def test_get_obs_shape_multidiscrete():
  function test_get_obs_shape_multibinary (line 15) | def test_get_obs_shape_multibinary():
  function test_get_obs_shape_multidimensional_multibinary (line 19) | def test_get_obs_shape_multidimensional_multibinary():
  function test_get_obs_shape_box (line 23) | def test_get_obs_shape_box():
  function test_get_obs_shape_multidimensional_box (line 27) | def test_get_obs_shape_multidimensional_box():
  function test_preprocess_obs_discrete (line 31) | def test_preprocess_obs_discrete():
  function test_preprocess_obs_multidiscrete (line 37) | def test_preprocess_obs_multidiscrete():
  function test_preprocess_obs_multibinary (line 43) | def test_preprocess_obs_multibinary():
  function test_preprocess_obs_multidimensional_multibinary (line 49) | def test_preprocess_obs_multidimensional_multibinary():
  function test_preprocess_obs_box (line 55) | def test_preprocess_obs_box():
  function test_preprocess_obs_multidimensional_box (line 61) | def test_preprocess_obs_multidimensional_box():

FILE: tests/test_run.py
  function test_deterministic_pg (line 18) | def test_deterministic_pg(model_class, action_noise):
  function test_a2c (line 35) | def test_a2c(env_id):
  function test_advantage_normalization (line 42) | def test_advantage_normalization(model_class, normalize_advantage):
  function test_ppo (line 49) | def test_ppo(env_id, clip_range_vf):
  function test_sac (line 76) | def test_sac(ent_coef):
  function test_n_critics (line 91) | def test_n_critics(n_critics):
  function test_dqn (line 104) | def test_dqn():
  function test_train_freq (line 118) | def test_train_freq(tmp_path, train_freq):
  function test_train_freq_fail (line 138) | def test_train_freq_fail(train_freq):
  function test_offpolicy_multi_env (line 153) | def test_offpolicy_multi_env(model_class):
  function test_warn_dqn_multi_env (line 204) | def test_warn_dqn_multi_env():
  function test_ppo_warnings (line 214) | def test_ppo_warnings():

FILE: tests/test_save_load.py
  function select_env (line 28) | def select_env(model_class: BaseAlgorithm) -> gym.Env:
  function test_save_load (line 39) | def test_save_load(tmp_path, model_class):
  function test_set_env (line 181) | def test_set_env(tmp_path, model_class):
  function test_exclude_include_saved_params (line 256) | def test_exclude_include_saved_params(tmp_path, model_class):
  function test_save_load_pytorch_var (line 296) | def test_save_load_pytorch_var(tmp_path):
  function test_save_load_env_cnn (line 334) | def test_save_load_env_cnn(tmp_path, model_class):
  function test_save_load_replay_buffer (line 363) | def test_save_load_replay_buffer(tmp_path, model_class):
  function test_warn_buffer (line 400) | def test_warn_buffer(recwarn, model_class, optimize_memory_usage):
  function test_save_load_policy (line 443) | def test_save_load_policy(tmp_path, model_class, policy_str, use_sde):
  function test_save_load_q_net (line 548) | def test_save_load_q_net(tmp_path, model_class, policy_str):
  function test_open_file_str_pathlib (line 623) | def test_open_file_str_pathlib(tmp_path, pathtype):
  function test_open_file (line 671) | def test_open_file(tmp_path):
  function test_save_load_large_model (line 706) | def test_save_load_large_model(tmp_path):
  function test_load_invalid_object (line 726) | def test_load_invalid_object(tmp_path):
  function test_dqn_target_update_interval (line 756) | def test_dqn_target_update_interval(tmp_path):
  function test_no_resource_warning (line 769) | def test_no_resource_warning(tmp_path):
  function test_cast_lr_schedule (line 802) | def test_cast_lr_schedule(tmp_path):
  function test_save_load_net_arch_none (line 816) | def test_save_load_net_arch_none(tmp_path):
  function test_save_load_no_target_params (line 828) | def test_save_load_no_target_params(tmp_path):
  function test_save_load_backward_compatible (line 841) | def test_save_load_backward_compatible(tmp_path, model_class):
  function test_save_load_clip_range_portable (line 864) | def test_save_load_clip_range_portable(tmp_path, model_class):

FILE: tests/test_sde.py
  function test_state_dependent_exploration_grad (line 10) | def test_state_dependent_exploration_grad():
  function test_sde_check (line 59) | def test_sde_check():
  function test_only_sde_squashed (line 64) | def test_only_sde_squashed():
  function test_state_dependent_noise (line 72) | def test_state_dependent_noise(model_class, use_expln, squash_output):
  class StoreActionEnvWrapper (line 109) | class StoreActionEnvWrapper(gym.Wrapper):
    method __init__ (line 114) | def __init__(self, env):
    method step (line 119) | def step(self, action):

FILE: tests/test_spaces.py
  class DummyEnv (line 19) | class DummyEnv(gym.Env):
    method step (line 23) | def step(self, action):
    method reset (line 26) | def reset(self, *, seed: int | None = None, options: dict | None = None):
  class DummyMultidimensionalAction (line 32) | class DummyMultidimensionalAction(DummyEnv):
    method __init__ (line 33) | def __init__(self):
  class DummyMultiBinary (line 40) | class DummyMultiBinary(DummyEnv):
    method __init__ (line 41) | def __init__(self, n):
  class DummyMultiDiscreteSpace (line 48) | class DummyMultiDiscreteSpace(DummyEnv):
    method __init__ (line 49) | def __init__(self, nvec):
  function test_env (line 65) | def test_env(env):
  function test_identity_spaces (line 72) | def test_identity_spaces(model_class, env):
  function test_action_spaces (line 91) | def test_action_spaces(model_class, env):
  function test_sde_multi_dim (line 112) | def test_sde_multi_dim():
  function test_discrete_obs_space (line 125) | def test_discrete_obs_space(model_class, env):
  function test_float64_action_space (line 152) | def test_float64_action_space(model_class, obs_space, action_space):
  function test_multidim_binary_not_supported (line 172) | def test_multidim_binary_not_supported():

FILE: tests/test_tensorboard.py
  class HParamCallback (line 20) | class HParamCallback(BaseCallback):
    method _on_training_start (line 25) | def _on_training_start(self) -> None:
    method _on_step (line 44) | def _on_step(self) -> bool:
  function test_tensorboard (line 49) | def test_tensorboard(tmp_path, model_name):
  function test_escape_log_name (line 76) | def test_escape_log_name(tmp_path):

FILE: tests/test_train_eval_mode.py
  class FlattenBatchNormDropoutExtractor (line 20) | class FlattenBatchNormDropoutExtractor(BaseFeaturesExtractor):
    method __init__ (line 28) | def __init__(self, observation_space: gym.Space):
    method forward (line 37) | def forward(self, observations: th.Tensor) -> th.Tensor:
  function clone_batch_norm_stats (line 44) | def clone_batch_norm_stats(batch_norm: nn.BatchNorm1d) -> (th.Tensor, th...
  function clone_dqn_batch_norm_stats (line 54) | def clone_dqn_batch_norm_stats(model: DQN) -> (th.Tensor, th.Tensor, th....
  function clone_td3_batch_norm_stats (line 70) | def clone_td3_batch_norm_stats(
  function clone_sac_batch_norm_stats (line 103) | def clone_sac_batch_norm_stats(
  function clone_on_policy_batch_norm (line 124) | def clone_on_policy_batch_norm(model: A2C | PPO) -> (th.Tensor, th.Tensor):
  function test_dqn_train_with_batch_norm (line 137) | def test_dqn_train_with_batch_norm():
  function test_td3_train_with_batch_norm (line 178) | def test_td3_train_with_batch_norm():
  function test_sac_train_with_batch_norm (line 227) | def test_sac_train_with_batch_norm():
  function test_a2c_ppo_train_with_batch_norm (line 271) | def test_a2c_ppo_train_with_batch_norm(model_class, env_id):
  function test_offpolicy_collect_rollout_batch_norm (line 290) | def test_offpolicy_collect_rollout_batch_norm(model_class):
  function test_a2c_ppo_collect_rollouts_with_batch_norm (line 322) | def test_a2c_ppo_collect_rollouts_with_batch_norm(model_class, env_id):
  function test_predict_with_dropout_batch_norm (line 346) | def test_predict_with_dropout_batch_norm(model_class, env_id):

FILE: tests/test_utils.py
  function test_make_vec_env (line 41) | def test_make_vec_env(env_id, n_envs, vec_env_cls, wrapper_class):
  function test_make_vec_env_func_checker (line 58) | def test_make_vec_env_func_checker():
  function test_make_atari_env (line 76) | def test_make_atari_env(
  function test_vec_env_kwargs (line 119) | def test_vec_env_kwargs():
  function test_vec_env_wrapper_kwargs (line 124) | def test_vec_env_wrapper_kwargs():
  function test_vec_env_monitor_kwargs (line 129) | def test_vec_env_monitor_kwargs():
  function test_env_auto_monitor_wrap (line 148) | def test_env_auto_monitor_wrap():
  function test_custom_vec_env (line 161) | def test_custom_vec_env(tmp_path):
  function test_evaluate_policy (line 189) | def test_evaluate_policy(direct_policy):
  class ZeroRewardWrapper (line 237) | class ZeroRewardWrapper(gym.RewardWrapper):
    method reward (line 238) | def reward(self, reward):
  class AlwaysDoneWrapper (line 242) | class AlwaysDoneWrapper(gym.Wrapper):
    method __init__ (line 245) | def __init__(self, env):
    method step (line 250) | def step(self, action):
    method reset (line 256) | def reset(self, **kwargs):
  function test_evaluate_vector_env (line 266) | def test_evaluate_vector_env(n_envs):
  function test_evaluate_policy_monitors (line 289) | def test_evaluate_policy_monitors(vec_env_class):
  function test_vec_noise (line 354) | def test_vec_noise():
  function test_get_parameters_by_name (line 387) | def test_get_parameters_by_name():
  function test_polyak (line 403) | def test_polyak():
  function test_zip_strict (line 416) | def test_zip_strict():
  function test_is_wrapped (line 434) | def test_is_wrapped():
  function test_get_system_info (line 447) | def test_get_system_info():
  function test_is_vectorized_observation (line 457) | def test_is_vectorized_observation():
  function test_policy_is_vectorized_obs (line 533) | def test_policy_is_vectorized_obs():
  function test_check_shape_equal (line 582) | def test_check_shape_equal():
  function test_deprecated_schedules (line 602) | def test_deprecated_schedules():

FILE: tests/test_vec_check_nan.py
  class NanAndInfEnv (line 9) | class NanAndInfEnv(gym.Env):
    method __init__ (line 14) | def __init__(self):
    method step (line 20) | def step(action):
    method reset (line 30) | def reset(seed=None):
    method render (line 33) | def render(self):
  function test_check_nan (line 37) | def test_check_nan():

FILE: tests/test_vec_envs.py
  class CustomGymEnv (line 30) | class CustomGymEnv(gym.Env):
    method __init__ (line 31) | def __init__(self, space, render_mode: str = "rgb_array"):
    method reset (line 42) | def reset(self, *, seed: int | None = None, options: dict | None = None):
    method step (line 50) | def step(self, action):
    method _choose_next_state (line 58) | def _choose_next_state(self):
    method render (line 61) | def render(self):
    method seed (line 65) | def seed(self, seed=None):
    method custom_method (line 71) | def custom_method(dim_0=1, dim_1=1):
  function test_vecenv_func_checker (line 83) | def test_vecenv_func_checker():
  function test_vecenv_custom_calls (line 95) | def test_vecenv_custom_calls(vec_env_class, vec_env_wrapper):
  class StepEnv (line 218) | class StepEnv(gym.Env):
    method __init__ (line 219) | def __init__(self, max_steps):
    method reset (line 227) | def reset(self, *, seed: int | None = None, options: dict | None = None):
    method step (line 231) | def step(self, action):
  function test_vecenv_terminal_obs (line 241) | def test_vecenv_terminal_obs(vec_env_class, vec_env_wrapper):
  function check_vecenv_spaces (line 294) | def check_vecenv_spaces(vec_env_class, space, obs_assert):
  function check_vecenv_obs (line 312) | def check_vecenv_obs(obs, space):
  function test_vecenv_single_space (line 321) | def test_vecenv_single_space(vec_env_class, space):
  class _UnorderedDictSpace (line 328) | class _UnorderedDictSpace(spaces.Dict):
    method sample (line 331) | def sample(self):
  function test_vecenv_dict_spaces (line 336) | def test_vecenv_dict_spaces(vec_env_class):
  function test_vecenv_tuple_spaces (line 354) | def test_vecenv_tuple_spaces(vec_env_class):
  function test_subproc_start_method (line 367) | def test_subproc_start_method():
  class CustomWrapperA (line 388) | class CustomWrapperA(VecNormalize):
    method __init__ (line 389) | def __init__(self, venv):
  class CustomWrapperB (line 394) | class CustomWrapperB(VecNormalize):
    method __init__ (line 395) | def __init__(self, venv):
    method func_b (line 399) | def func_b(self):
    method name_test (line 402) | def name_test(self):
  class CustomWrapperBB (line 406) | class CustomWrapperBB(CustomWrapperB):
    method __init__ (line 407) | def __init__(self, venv):
  function test_vecenv_wrapper_getattr (line 412) | def test_vecenv_wrapper_getattr():
  function test_framestack_vecenv (line 432) | def test_framestack_vecenv():
  function test_vec_env_is_wrapped (line 506) | def test_vec_env_is_wrapped():
  function test_vec_deterministic (line 531) | def test_vec_deterministic(vec_env_class):
  function test_vec_seeding (line 561) | def test_vec_seeding(vec_env_class):
  function test_render (line 592) | def test_render(vec_env_class):
  function test_video_recorder (line 661) | def test_video_recorder(tmp_path):

FILE: tests/test_vec_extract_dict_obs.py
  class DictObsVecEnv (line 8) | class DictObsVecEnv(VecEnv):
    method __init__ (line 13) | def __init__(self):
    method step_async (line 21) | def step_async(self, actions):
    method step_wait (line 24) | def step_wait(self):
    method reset (line 41) | def reset(self):
    method render (line 45) | def render(self, mode=""):
    method get_attr (line 48) | def get_attr(self, attr_name, indices=None):
    method close (line 52) | def close(self):
    method env_is_wrapped (line 55) | def env_is_wrapped(self, wrapper_class, indices=None):
    method env_method (line 59) | def env_method(self):
    method set_attr (line 62) | def set_attr(self, attr_name, value, indices=None) -> None:
  function test_extract_dict_obs (line 66) | def test_extract_dict_obs():
  function test_vec_with_ppo (line 84) | def test_vec_with_ppo():

FILE: tests/test_vec_monitor.py
  function test_vec_monitor (line 18) | def test_vec_monitor(tmp_path):
  function test_vec_monitor_info_keywords (line 51) | def test_vec_monitor_info_keywords(tmp_path):
  function test_vec_monitor_load_results (line 82) | def test_vec_monitor_load_results(tmp_path):
  function test_vec_monitor_ppo (line 132) | def test_vec_monitor_ppo(recwarn):
  function test_vec_monitor_warn (line 148) | def test_vec_monitor_warn():

FILE: tests/test_vec_normalize.py
  class DummyRewardEnv (line 24) | class DummyRewardEnv(gym.Env):
    method __init__ (line 27) | def __init__(self, return_reward_idx=0):
    method step (line 34) | def step(self, action):
    method reset (line 42) | def reset(self, *, seed: int | None = None, options: dict | None = None):
  class DummyDictEnv (line 49) | class DummyDictEnv(gym.Env):
    method __init__ (line 54) | def __init__(self):
    method reset (line 65) | def reset(self, *, seed: int | None = None, options: dict | None = None):
    method step (line 70) | def step(self, action):
    method compute_reward (line 76) | def compute_reward(self, achieved_goal: np.ndarray, desired_goal: np.n...
  class DummyMixedDictEnv (line 81) | class DummyMixedDictEnv(gym.Env):
    method __init__ (line 86) | def __init__(self):
    method reset (line 97) | def reset(self, *, seed: int | None = None, options: dict | None = None):
    method step (line 102) | def step(self, action):
  function allclose (line 108) | def allclose(obs_1, obs_2):
  function make_env (line 122) | def make_env():
  function make_env_render (line 126) | def make_env_render():
  function make_dict_env (line 130) | def make_dict_env():
  function make_image_env (line 134) | def make_image_env():
  function check_rms_equal (line 138) | def check_rms_equal(rmsa, rmsb):
  function check_vec_norm_equal (line 150) | def check_vec_norm_equal(norma, normb):
  function _make_warmstart (line 168) | def _make_warmstart(env_fn, **kwargs):
  function _make_warmstart_cliffwalking (line 181) | def _make_warmstart_cliffwalking(**kwargs):
  function _make_warmstart_cartpole (line 190) | def _make_warmstart_cartpole():
  function _make_warmstart_dict_env (line 195) | def _make_warmstart_dict_env(**kwargs):
  function test_runningmeanstd (line 200) | def test_runningmeanstd():
  function test_combining_stats (line 218) | def test_combining_stats():
  function test_obs_rms_vec_normalize (line 250) | def test_obs_rms_vec_normalize():
  function test_vec_env (line 269) | def test_vec_env(tmp_path, make_gym_env):
  function test_get_original (line 306) | def test_get_original():
  function test_get_original_dict (line 325) | def test_get_original_dict():
  function test_normalize_external (line 345) | def test_normalize_external():
  function test_normalize_dict_selected_keys (line 355) | def test_normalize_dict_selected_keys():
  function test_her_normalization (line 370) | def test_her_normalization():
  function test_offpolicy_normalization (line 400) | def test_offpolicy_normalization(model_class):
  function test_sync_vec_normalize (line 421) | def test_sync_vec_normalize(make_env):
  function test_discrete_obs (line 479) | def test_discrete_obs():
  function test_non_dict_obs_keys (line 487) | def test_non_dict_obs_keys():

FILE: tests/test_vec_stacked_obs.py
  function test_compute_stacking_box (line 12) | def test_compute_stacking_box():
  function test_compute_stacking_multidim_box (line 21) | def test_compute_stacking_multidim_box():
  function test_compute_stacking_multidim_box_channel_first (line 30) | def test_compute_stacking_multidim_box_channel_first():
  function test_compute_stacking_image_channel_first (line 41) | def test_compute_stacking_image_channel_first():
  function test_compute_stacking_image_channel_last (line 51) | def test_compute_stacking_image_channel_last():
  function test_compute_stacking_image_channel_first_stack_last (line 61) | def test_compute_stacking_image_channel_first_stack_last():
  function test_compute_stacking_image_channel_last_stack_first (line 73) | def test_compute_stacking_image_channel_last_stack_first():
  function test_reset_update_box (line 85) | def test_reset_update_box():
  function test_reset_update_multidim_box (line 106) | def test_reset_update_multidim_box():
  function test_reset_update_multidim_box_channel_first (line 127) | def test_reset_update_multidim_box_channel_first():
  function test_reset_update_image_channel_first (line 146) | def test_reset_update_image_channel_first():
  function test_reset_update_image_channel_last (line 165) | def test_reset_update_image_channel_last():
  function test_reset_update_image_channel_first_stack_last (line 186) | def test_reset_update_image_channel_first_stack_last():
  function test_reset_update_image_channel_last_stack_first (line 207) | def test_reset_update_image_channel_last_stack_first():
  function test_reset_update_dict (line 226) | def test_reset_update_dict():
  function test_episode_termination_box (line 271) | def test_episode_termination_box():
  function test_episode_termination_dict (line 292) | def test_episode_termination_dict():