mirror of
https://github.com/Farama-Foundation/Gymnasium.git
synced 2025-08-28 17:27:08 +00:00
15049e22d7
* initial draft of optional info dict in reset function, implemented for cartpole, tests seem to be passing * merged core.py * updated return type annotation for reset function in core.py * optional metadata with return_info from reset added for all first party environments, with corresponding tests. Incomplete implementation for wrappers and vector wrappers * removed Optional type for return_info arguments * added tests for return_info to normalize wrapper and sync_vector_env * autoformatted using black * added optional reset metadata tests to several wrappers * added return_info capability to async_vector_env.py and test to verify functionality * added optional return_info test for record_video.py * removed tests for mujoco environments * autoformatted * improved test coverage for optional reset return_info * re-removed unit test envs accidentally reintroduced in merge * removed unnecessary import * changes based on code-review * small fix to core wrapper typing and autoformatted record_epsisode_stats * small change to pass flake8 style
299 lines
10 KiB
Python
299 lines
10 KiB
Python
import pytest
|
|
import numpy as np
|
|
|
|
from multiprocessing import TimeoutError
|
|
from gym.spaces import Box, Tuple, Discrete, MultiDiscrete
|
|
from gym.error import AlreadyPendingCallError, NoAsyncCallError, ClosedEnvironmentError
|
|
from tests.vector.utils import (
|
|
CustomSpace,
|
|
make_env,
|
|
make_slow_env,
|
|
make_custom_space_env,
|
|
)
|
|
|
|
from gym.vector.async_vector_env import AsyncVectorEnv
|
|
|
|
|
|
@pytest.mark.parametrize("shared_memory", [True, False])
|
|
def test_create_async_vector_env(shared_memory):
|
|
env_fns = [make_env("CartPole-v1", i) for i in range(8)]
|
|
try:
|
|
env = AsyncVectorEnv(env_fns, shared_memory=shared_memory)
|
|
finally:
|
|
env.close()
|
|
|
|
assert env.num_envs == 8
|
|
|
|
|
|
@pytest.mark.parametrize("shared_memory", [True, False])
|
|
def test_reset_async_vector_env(shared_memory):
|
|
env_fns = [make_env("CartPole-v1", i) for i in range(8)]
|
|
try:
|
|
env = AsyncVectorEnv(env_fns, shared_memory=shared_memory)
|
|
observations = env.reset()
|
|
finally:
|
|
env.close()
|
|
|
|
assert isinstance(env.observation_space, Box)
|
|
assert isinstance(observations, np.ndarray)
|
|
assert observations.dtype == env.observation_space.dtype
|
|
assert observations.shape == (8,) + env.single_observation_space.shape
|
|
assert observations.shape == env.observation_space.shape
|
|
|
|
try:
|
|
env = AsyncVectorEnv(env_fns, shared_memory=shared_memory)
|
|
observations = env.reset(return_info=False)
|
|
finally:
|
|
env.close()
|
|
|
|
assert isinstance(env.observation_space, Box)
|
|
assert isinstance(observations, np.ndarray)
|
|
assert observations.dtype == env.observation_space.dtype
|
|
assert observations.shape == (8,) + env.single_observation_space.shape
|
|
assert observations.shape == env.observation_space.shape
|
|
|
|
try:
|
|
env = AsyncVectorEnv(env_fns, shared_memory=shared_memory)
|
|
observations, infos = env.reset(return_info=True)
|
|
finally:
|
|
env.close()
|
|
|
|
assert isinstance(env.observation_space, Box)
|
|
assert isinstance(observations, np.ndarray)
|
|
assert observations.dtype == env.observation_space.dtype
|
|
assert observations.shape == (8,) + env.single_observation_space.shape
|
|
assert observations.shape == env.observation_space.shape
|
|
assert isinstance(infos, list)
|
|
assert all([isinstance(info, dict) for info in infos])
|
|
|
|
|
|
@pytest.mark.parametrize("shared_memory", [True, False])
|
|
@pytest.mark.parametrize("use_single_action_space", [True, False])
|
|
def test_step_async_vector_env(shared_memory, use_single_action_space):
|
|
env_fns = [make_env("CartPole-v1", i) for i in range(8)]
|
|
try:
|
|
env = AsyncVectorEnv(env_fns, shared_memory=shared_memory)
|
|
observations = env.reset()
|
|
|
|
assert isinstance(env.single_action_space, Discrete)
|
|
assert isinstance(env.action_space, MultiDiscrete)
|
|
|
|
if use_single_action_space:
|
|
actions = [env.single_action_space.sample() for _ in range(8)]
|
|
else:
|
|
actions = env.action_space.sample()
|
|
observations, rewards, dones, _ = env.step(actions)
|
|
finally:
|
|
env.close()
|
|
|
|
assert isinstance(env.observation_space, Box)
|
|
assert isinstance(observations, np.ndarray)
|
|
assert observations.dtype == env.observation_space.dtype
|
|
assert observations.shape == (8,) + env.single_observation_space.shape
|
|
assert observations.shape == env.observation_space.shape
|
|
|
|
assert isinstance(rewards, np.ndarray)
|
|
assert isinstance(rewards[0], (float, np.floating))
|
|
assert rewards.ndim == 1
|
|
assert rewards.size == 8
|
|
|
|
assert isinstance(dones, np.ndarray)
|
|
assert dones.dtype == np.bool_
|
|
assert dones.ndim == 1
|
|
assert dones.size == 8
|
|
|
|
|
|
@pytest.mark.parametrize("shared_memory", [True, False])
|
|
def test_call_async_vector_env(shared_memory):
|
|
env_fns = [make_env("CartPole-v1", i) for i in range(4)]
|
|
try:
|
|
env = AsyncVectorEnv(env_fns, shared_memory=shared_memory)
|
|
_ = env.reset()
|
|
images = env.call("render", mode="rgb_array")
|
|
gravity = env.call("gravity")
|
|
finally:
|
|
env.close()
|
|
|
|
assert isinstance(images, tuple)
|
|
assert len(images) == 4
|
|
for i in range(4):
|
|
assert isinstance(images[i], np.ndarray)
|
|
|
|
assert isinstance(gravity, tuple)
|
|
assert len(gravity) == 4
|
|
for i in range(4):
|
|
assert isinstance(gravity[i], float)
|
|
assert gravity[i] == 9.8
|
|
|
|
|
|
@pytest.mark.parametrize("shared_memory", [True, False])
|
|
def test_set_attr_async_vector_env(shared_memory):
|
|
env_fns = [make_env("CartPole-v1", i) for i in range(4)]
|
|
try:
|
|
env = AsyncVectorEnv(env_fns, shared_memory=shared_memory)
|
|
env.set_attr("gravity", [9.81, 3.72, 8.87, 1.62])
|
|
gravity = env.get_attr("gravity")
|
|
assert gravity == (9.81, 3.72, 8.87, 1.62)
|
|
finally:
|
|
env.close()
|
|
|
|
|
|
@pytest.mark.parametrize("shared_memory", [True, False])
|
|
def test_copy_async_vector_env(shared_memory):
|
|
env_fns = [make_env("CartPole-v1", i) for i in range(8)]
|
|
try:
|
|
env = AsyncVectorEnv(env_fns, shared_memory=shared_memory, copy=True)
|
|
observations = env.reset()
|
|
observations[0] = 0
|
|
finally:
|
|
env.close()
|
|
|
|
|
|
@pytest.mark.parametrize("shared_memory", [True, False])
|
|
def test_no_copy_async_vector_env(shared_memory):
|
|
env_fns = [make_env("CartPole-v1", i) for i in range(8)]
|
|
try:
|
|
env = AsyncVectorEnv(env_fns, shared_memory=shared_memory, copy=False)
|
|
observations = env.reset()
|
|
observations[0] = 0
|
|
finally:
|
|
env.close()
|
|
|
|
|
|
@pytest.mark.parametrize("shared_memory", [True, False])
|
|
def test_reset_timeout_async_vector_env(shared_memory):
|
|
env_fns = [make_slow_env(0.3, i) for i in range(4)]
|
|
with pytest.raises(TimeoutError):
|
|
try:
|
|
env = AsyncVectorEnv(env_fns, shared_memory=shared_memory)
|
|
env.reset_async()
|
|
observations = env.reset_wait(timeout=0.1)
|
|
finally:
|
|
env.close(terminate=True)
|
|
|
|
|
|
@pytest.mark.parametrize("shared_memory", [True, False])
|
|
def test_step_timeout_async_vector_env(shared_memory):
|
|
env_fns = [make_slow_env(0.0, i) for i in range(4)]
|
|
with pytest.raises(TimeoutError):
|
|
try:
|
|
env = AsyncVectorEnv(env_fns, shared_memory=shared_memory)
|
|
observations = env.reset()
|
|
env.step_async([0.1, 0.1, 0.3, 0.1])
|
|
observations, rewards, dones, _ = env.step_wait(timeout=0.1)
|
|
finally:
|
|
env.close(terminate=True)
|
|
|
|
|
|
@pytest.mark.filterwarnings("ignore::UserWarning")
|
|
@pytest.mark.parametrize("shared_memory", [True, False])
|
|
def test_reset_out_of_order_async_vector_env(shared_memory):
|
|
env_fns = [make_env("CartPole-v1", i) for i in range(4)]
|
|
with pytest.raises(NoAsyncCallError):
|
|
try:
|
|
env = AsyncVectorEnv(env_fns, shared_memory=shared_memory)
|
|
observations = env.reset_wait()
|
|
except NoAsyncCallError as exception:
|
|
assert exception.name == "reset"
|
|
raise
|
|
finally:
|
|
env.close(terminate=True)
|
|
|
|
with pytest.raises(AlreadyPendingCallError):
|
|
try:
|
|
env = AsyncVectorEnv(env_fns, shared_memory=shared_memory)
|
|
actions = env.action_space.sample()
|
|
observations = env.reset()
|
|
env.step_async(actions)
|
|
env.reset_async()
|
|
except NoAsyncCallError as exception:
|
|
assert exception.name == "step"
|
|
raise
|
|
finally:
|
|
env.close(terminate=True)
|
|
|
|
|
|
@pytest.mark.filterwarnings("ignore::UserWarning")
|
|
@pytest.mark.parametrize("shared_memory", [True, False])
|
|
def test_step_out_of_order_async_vector_env(shared_memory):
|
|
env_fns = [make_env("CartPole-v1", i) for i in range(4)]
|
|
with pytest.raises(NoAsyncCallError):
|
|
try:
|
|
env = AsyncVectorEnv(env_fns, shared_memory=shared_memory)
|
|
actions = env.action_space.sample()
|
|
observations = env.reset()
|
|
observations, rewards, dones, infos = env.step_wait()
|
|
except AlreadyPendingCallError as exception:
|
|
assert exception.name == "step"
|
|
raise
|
|
finally:
|
|
env.close(terminate=True)
|
|
|
|
with pytest.raises(AlreadyPendingCallError):
|
|
try:
|
|
env = AsyncVectorEnv(env_fns, shared_memory=shared_memory)
|
|
actions = env.action_space.sample()
|
|
env.reset_async()
|
|
env.step_async(actions)
|
|
except AlreadyPendingCallError as exception:
|
|
assert exception.name == "reset"
|
|
raise
|
|
finally:
|
|
env.close(terminate=True)
|
|
|
|
|
|
@pytest.mark.parametrize("shared_memory", [True, False])
|
|
def test_already_closed_async_vector_env(shared_memory):
|
|
env_fns = [make_env("CartPole-v1", i) for i in range(4)]
|
|
with pytest.raises(ClosedEnvironmentError):
|
|
env = AsyncVectorEnv(env_fns, shared_memory=shared_memory)
|
|
env.close()
|
|
observations = env.reset()
|
|
|
|
|
|
@pytest.mark.parametrize("shared_memory", [True, False])
|
|
def test_check_spaces_async_vector_env(shared_memory):
|
|
# CartPole-v1 - observation_space: Box(4,), action_space: Discrete(2)
|
|
env_fns = [make_env("CartPole-v1", i) for i in range(8)]
|
|
# FrozenLake-v1 - Discrete(16), action_space: Discrete(4)
|
|
env_fns[1] = make_env("FrozenLake-v1", 1)
|
|
with pytest.raises(RuntimeError):
|
|
env = AsyncVectorEnv(env_fns, shared_memory=shared_memory)
|
|
env.close(terminate=True)
|
|
|
|
|
|
def test_custom_space_async_vector_env():
|
|
env_fns = [make_custom_space_env(i) for i in range(4)]
|
|
try:
|
|
env = AsyncVectorEnv(env_fns, shared_memory=False)
|
|
reset_observations = env.reset()
|
|
|
|
assert isinstance(env.single_action_space, CustomSpace)
|
|
assert isinstance(env.action_space, Tuple)
|
|
|
|
actions = ("action-2", "action-3", "action-5", "action-7")
|
|
step_observations, rewards, dones, _ = env.step(actions)
|
|
finally:
|
|
env.close()
|
|
|
|
assert isinstance(env.single_observation_space, CustomSpace)
|
|
assert isinstance(env.observation_space, Tuple)
|
|
|
|
assert isinstance(reset_observations, tuple)
|
|
assert reset_observations == ("reset", "reset", "reset", "reset")
|
|
|
|
assert isinstance(step_observations, tuple)
|
|
assert step_observations == (
|
|
"step(action-2)",
|
|
"step(action-3)",
|
|
"step(action-5)",
|
|
"step(action-7)",
|
|
)
|
|
|
|
|
|
def test_custom_space_async_vector_env_shared_memory():
|
|
env_fns = [make_custom_space_env(i) for i in range(4)]
|
|
with pytest.raises(ValueError):
|
|
env = AsyncVectorEnv(env_fns, shared_memory=True)
|
|
env.close(terminate=True)
|