Add support for python 3.6

.github/workflows/build.yml

@@ -6,7 +6,7 @@ jobs:
     runs-on: ubuntu-latest
     strategy:
       matrix:
-        python-version: ['3.7', '3.8', '3.9', '3.10']
+        python-version: ['3.6', '3.7', '3.8', '3.9', '3.10']
     steps:
       - uses: actions/checkout@v2
       - run: |

.pre-commit-config.yaml

@@ -41,7 +41,7 @@ repos:
     hooks:
       - id: pyupgrade
         # TODO: remove `--keep-runtime-typing` option
-        args: ["--py37-plus", "--keep-runtime-typing"]
+        args: ["--py36-plus", "--keep-runtime-typing"]
   - repo: local
     hooks:
       - id: pyright

gym/core.py

@@ -1,8 +1,5 @@
 """Core API for Environment, Wrapper, ActionWrapper, RewardWrapper and ObservationWrapper."""
-from __future__ import annotations
-
-from abc import abstractmethod
-from typing import Generic, Optional, SupportsFloat, TypeVar, Union
+from typing import Generic, Optional, SupportsFloat, Tuple, TypeVar, Union
 
 from gym import spaces
 from gym.logger import deprecation
@@ -63,8 +60,7 @@ def np_random(self) -> RandomNumberGenerator:
     def np_random(self, value: RandomNumberGenerator):
         self._np_random = value
 
-    @abstractmethod
-    def step(self, action: ActType) -> tuple[ObsType, float, bool, dict]:
+    def step(self, action: ActType) -> Tuple[ObsType, float, bool, dict]:
         """Run one timestep of the environment's dynamics.
 
         When end of episode is reached, you are responsible for calling :meth:`reset` to reset this environment's state.
@@ -88,14 +84,13 @@ def step(self, action: ActType) -> tuple[ObsType, float, bool, dict]:
         """
         raise NotImplementedError
 
-    @abstractmethod
     def reset(
         self,
         *,
         seed: Optional[int] = None,
         return_info: bool = False,
         options: Optional[dict] = None,
-    ) -> Union[ObsType, tuple[ObsType, dict]]:
+    ) -> Union[ObsType, Tuple[ObsType, dict]]:
         """Resets the environment to an initial state and returns the initial observation.
 
         This method can reset the environment's random number generator(s) if ``seed`` is an integer or
@@ -129,7 +124,6 @@ def reset(
         if seed is not None:
             self._np_random, seed = seeding.np_random(seed)
 
-    @abstractmethod
     def render(self, mode="human"):
         """Renders the environment.
 
@@ -204,7 +198,7 @@ def seed(self, seed=None):
         return [seed]
 
     @property
-    def unwrapped(self) -> Env:
+    def unwrapped(self) -> "Env":
         """Returns the base non-wrapped environment.
 
         Returns:
@@ -251,7 +245,7 @@ def __init__(self, env: Env):
 
         self._action_space: Optional[spaces.Space] = None
         self._observation_space: Optional[spaces.Space] = None
-        self._reward_range: Optional[tuple[SupportsFloat, SupportsFloat]] = None
+        self._reward_range: Optional[Tuple[SupportsFloat, SupportsFloat]] = None
         self._metadata: Optional[dict] = None
 
     def __getattr__(self, name):
@@ -293,14 +287,14 @@ def observation_space(self, space: spaces.Space):
         self._observation_space = space
 
     @property
-    def reward_range(self) -> tuple[SupportsFloat, SupportsFloat]:
+    def reward_range(self) -> Tuple[SupportsFloat, SupportsFloat]:
         """Return the reward range of the environment."""
         if self._reward_range is None:
             return self.env.reward_range
         return self._reward_range
 
     @reward_range.setter
-    def reward_range(self, value: tuple[SupportsFloat, SupportsFloat]):
+    def reward_range(self, value: Tuple[SupportsFloat, SupportsFloat]):
         self._reward_range = value
 
     @property
@@ -314,11 +308,11 @@ def metadata(self) -> dict:
     def metadata(self, value):
         self._metadata = value
 
-    def step(self, action: ActType) -> tuple[ObsType, float, bool, dict]:
+    def step(self, action: ActType) -> Tuple[ObsType, float, bool, dict]:
         """Steps through the environment with action."""
         return self.env.step(action)
 
-    def reset(self, **kwargs) -> Union[ObsType, tuple[ObsType, dict]]:
+    def reset(self, **kwargs) -> Union[ObsType, Tuple[ObsType, dict]]:
         """Resets the environment with kwargs."""
         return self.env.reset(**kwargs)
 
@@ -389,7 +383,6 @@ def step(self, action):
         observation, reward, done, info = self.env.step(action)
         return self.observation(observation), reward, done, info
 
-    @abstractmethod
     def observation(self, observation):
         """Returns a modified observation."""
         raise NotImplementedError
@@ -424,7 +417,6 @@ def step(self, action):
         observation, reward, done, info = self.env.step(action)
         return observation, self.reward(reward), done, info
 
-    @abstractmethod
     def reward(self, reward):
         """Returns a modified ``reward``."""
         raise NotImplementedError
@@ -466,12 +458,10 @@ def step(self, action):
         """Runs the environment :meth:`env.step` using the modified ``action`` from :meth:`self.action`."""
         return self.env.step(self.action(action))
 
-    @abstractmethod
     def action(self, action):
         """Returns a modified action before :meth:`env.step` is called."""
         raise NotImplementedError
 
-    @abstractmethod
     def reverse_action(self, action):
         """Returns a reversed ``action``."""
         raise NotImplementedError

gym/envs/registration.py

@@ -1,5 +1,3 @@
-from __future__ import annotations
-
 import contextlib
 import copy
 import difflib
@@ -10,9 +8,10 @@
 import warnings
 from dataclasses import dataclass, field
 from typing import (
-    Any,
     Callable,
+    Dict,
     Iterable,
+    List,
     Optional,
     Sequence,
     SupportsFloat,
@@ -36,15 +35,12 @@
 if sys.version_info >= (3, 8):
     from typing import Literal
 else:
-
-    class Literal(str):
-        def __class_getitem__(cls, item):
-            return Any
+    from typing_extensions import Literal
 
 
 from gym import Env, error, logger
 
-ENV_ID_RE: re.Pattern = re.compile(
+ENV_ID_RE = re.compile(
     r"^(?:(?P<namespace>[\w:-]+)\/)?(?:(?P<name>[\w:.-]+?))(?:-v(?P<version>\d+))?$"
 )
 
@@ -215,7 +211,7 @@ def _check_version_exists(ns: Optional[str], name: str, version: Optional[int]):
 
 
 def find_highest_version(ns: Optional[str], name: str) -> Optional[int]:
-    version: list[int] = [
+    version: List[int] = [
         spec_.version
         for spec_ in registry.values()
         if spec_.namespace == ns and spec_.name == name and spec_.version is not None
@@ -276,39 +272,39 @@ def load_env_plugins(entry_point: str = "gym.envs") -> None:
 
 
 @overload
-def make(id: Literal["CartPole-v1"], **kwargs) -> Env[np.ndarray, np.ndarray | int]: ...
+def make(id: Literal["CartPole-v0", "CartPole-v1"], **kwargs) -> Env[np.ndarray, Union[np.ndarray, int]]: ...
 @overload
-def make(id: Literal["MountainCar-v0"], **kwargs) -> Env[np.ndarray, np.ndarray | int]: ...
+def make(id: Literal["MountainCar-v0"], **kwargs) -> Env[np.ndarray, Union[np.ndarray, int]]: ...
 @overload
-def make(id: Literal["MountainCarContinuous-v0"], **kwargs) -> Env[np.ndarray, np.ndarray | Sequence[SupportsFloat]]: ...
+def make(id: Literal["MountainCarContinuous-v0"], **kwargs) -> Env[np.ndarray, Union[np.ndarray, Sequence[SupportsFloat]]]: ...
 @overload
-def make(id: Literal["Pendulum-v1"], **kwargs) -> Env[np.ndarray, np.ndarray | Sequence[SupportsFloat]]: ...
+def make(id: Literal["Pendulum-v1"], **kwargs) -> Env[np.ndarray, Union[np.ndarray, Sequence[SupportsFloat]]]: ...
 @overload
-def make(id: Literal["Acrobot-v1"], **kwargs) -> Env[np.ndarray, np.ndarray | int]: ...
+def make(id: Literal["Acrobot-v1"], **kwargs) -> Env[np.ndarray, Union[np.ndarray, int]]: ...
 
 # Box2d
 # ----------------------------------------
 
 
 @overload
-def make(id: Literal["LunarLander-v2", "LunarLanderContinuous-v2"], **kwargs) -> Env[np.ndarray, np.ndarray | int]: ...
+def make(id: Literal["LunarLander-v2", "LunarLanderContinuous-v2"], **kwargs) -> Env[np.ndarray, Union[np.ndarray, int]]: ...
 @overload
-def make(id: Literal["BipedalWalker-v3", "BipedalWalkerHardcore-v3"], **kwargs) -> Env[np.ndarray, np.ndarray | Sequence[SupportsFloat]]: ...
+def make(id: Literal["BipedalWalker-v3", "BipedalWalkerHardcore-v3"], **kwargs) -> Env[np.ndarray, Union[np.ndarray, Sequence[SupportsFloat]]]: ...
 @overload
-def make(id: Literal["CarRacing-v1", "CarRacingDomainRandomize-v1"], **kwargs) -> Env[np.ndarray, np.ndarray | Sequence[SupportsFloat]]: ...
+def make(id: Literal["CarRacing-v1", "CarRacingDomainRandomize-v1"], **kwargs) -> Env[np.ndarray, Union[np.ndarray, Sequence[SupportsFloat]]]: ...
 
 # Toy Text
 # ----------------------------------------
 
 
 @overload
-def make(id: Literal["Blackjack-v1"], **kwargs) -> Env[np.ndarray, np.ndarray | int]: ...
+def make(id: Literal["Blackjack-v1"], **kwargs) -> Env[np.ndarray, Union[np.ndarray, int]]: ...
 @overload
-def make(id: Literal["FrozenLake-v1", "FrozenLake8x8-v1"], **kwargs) -> Env[np.ndarray, np.ndarray | int]: ...
+def make(id: Literal["FrozenLake-v1", "FrozenLake8x8-v1"], **kwargs) -> Env[np.ndarray, Union[np.ndarray, int]]: ...
 @overload
-def make(id: Literal["CliffWalking-v0"], **kwargs) -> Env[np.ndarray, np.ndarray | int]: ...
+def make(id: Literal["CliffWalking-v0"], **kwargs) -> Env[np.ndarray, Union[np.ndarray, int]]: ...
 @overload
-def make(id: Literal["Taxi-v3"], **kwargs) -> Env[np.ndarray, np.ndarray | int]: ...
+def make(id: Literal["Taxi-v3"], **kwargs) -> Env[np.ndarray, Union[np.ndarray, int]]: ...
 
 # Mujoco
 # ----------------------------------------
@@ -388,7 +384,7 @@ def env_specs(self):
 
 
 # Global registry of environments. Meant to be accessed through `register` and `make`
-registry: dict[str, EnvSpec] = EnvRegistry()
+registry: Dict[str, EnvSpec] = EnvRegistry()
 current_namespace: Optional[str] = None
 
 
@@ -492,7 +488,7 @@ def register(id: str, **kwargs):
 
 
 def make(
-    id: str | EnvSpec,
+    id: Union[str, EnvSpec],
     max_episode_steps: Optional[int] = None,
     autoreset: bool = False,
     disable_env_checker: bool = False,

gym/spaces/box.py

@@ -1,7 +1,5 @@
 """Implementation of a space that represents closed boxes in euclidean space."""
-from __future__ import annotations
-
-from typing import Optional, Sequence, SupportsFloat, Tuple, Type, Union
+from typing import List, Optional, Sequence, SupportsFloat, Tuple, Type, Union
 
 import numpy as np
 
@@ -47,7 +45,7 @@ def __init__(
         high: Union[SupportsFloat, np.ndarray],
         shape: Optional[Sequence[int]] = None,
         dtype: Type = np.float32,
-        seed: Optional[int | seeding.RandomNumberGenerator] = None,
+        seed: Optional[Union[int, seeding.RandomNumberGenerator]] = None,
     ):
         r"""Constructor of :class:`Box`.
 
@@ -195,7 +193,7 @@ def to_jsonable(self, sample_n):
         """Convert a batch of samples from this space to a JSONable data type."""
         return np.array(sample_n).tolist()
 
-    def from_jsonable(self, sample_n: Sequence[SupportsFloat]) -> list[np.ndarray]:
+    def from_jsonable(self, sample_n: Sequence[SupportsFloat]) -> List[np.ndarray]:
         """Convert a JSONable data type to a batch of samples from this space."""
         return [np.asarray(sample) for sample in sample_n]
 
@@ -253,7 +251,7 @@ def get_precision(dtype) -> SupportsFloat:
 def _broadcast(
     value: Union[SupportsFloat, np.ndarray],
     dtype,
-    shape: tuple[int, ...],
+    shape: Tuple[int, ...],
     inf_sign: str,
 ) -> np.ndarray:
     """Handle infinite bounds and broadcast at the same time if needed."""

gym/spaces/dict.py

@@ -1,10 +1,8 @@
 """Implementation of a space that represents the cartesian product of other spaces as a dictionary."""
-from __future__ import annotations
-
 from collections import OrderedDict
 from collections.abc import Mapping, Sequence
 from typing import Dict as TypingDict
-from typing import Optional
+from typing import Optional, Union
 
 import numpy as np
 
@@ -53,8 +51,8 @@ class Dict(Space[TypingDict[str, Space]], Mapping):
 
     def __init__(
         self,
-        spaces: Optional[dict[str, Space]] = None,
-        seed: Optional[dict | int | seeding.RandomNumberGenerator] = None,
+        spaces: Optional[TypingDict[str, Space]] = None,
+        seed: Optional[Union[dict, int, seeding.RandomNumberGenerator]] = None,
         **spaces_kwargs: Space,
     ):
         """Constructor of :class:`Dict` space.
@@ -101,7 +99,7 @@ def __init__(
             None, None, seed  # type: ignore
         )  # None for shape and dtype, since it'll require special handling
 
-    def seed(self, seed: Optional[dict | int] = None) -> list:
+    def seed(self, seed: Optional[Union[dict, int]] = None) -> list:
         """Seed the PRNG of this space and all subspaces."""
         seeds = []
         if isinstance(seed, dict):
@@ -189,9 +187,9 @@ def to_jsonable(self, sample_n: list) -> dict:
             for key, space in self.spaces.items()
         }
 
-    def from_jsonable(self, sample_n: dict[str, list]) -> list:
+    def from_jsonable(self, sample_n: TypingDict[str, list]) -> list:
         """Convert a JSONable data type to a batch of samples from this space."""
-        dict_of_list: dict[str, list] = {}
+        dict_of_list: TypingDict[str, list] = {}
         for key, space in self.spaces.items():
             dict_of_list[key] = space.from_jsonable(sample_n[key])
         ret = []

gym/spaces/discrete.py

@@ -1,7 +1,5 @@
 """Implementation of a space consisting of finitely many elements."""
-from __future__ import annotations
-
-from typing import Optional
+from typing import Optional, Union
 
 import numpy as np
 
@@ -23,7 +21,7 @@ class Discrete(Space[int]):
     def __init__(
         self,
         n: int,
-        seed: Optional[int | seeding.RandomNumberGenerator] = None,
+        seed: Optional[Union[int, seeding.RandomNumberGenerator]] = None,
         start: int = 0,
     ):
         r"""Constructor of :class:`Discrete` space.

gym/spaces/multi_binary.py

@@ -1,7 +1,5 @@
 """Implementation of a space that consists of binary np.ndarrays of a fixed shape."""
-from __future__ import annotations
-
-from typing import Optional, Sequence, Union
+from typing import Optional, Sequence, Tuple, Union
 
 import numpy as np
 
@@ -29,7 +27,7 @@ class MultiBinary(Space[np.ndarray]):
     def __init__(
         self,
         n: Union[np.ndarray, Sequence[int], int],
-        seed: Optional[int | seeding.RandomNumberGenerator] = None,
+        seed: Optional[Union[int, seeding.RandomNumberGenerator]] = None,
     ):
         """Constructor of :class:`MultiBinary` space.
 
@@ -49,7 +47,7 @@ def __init__(
         super().__init__(input_n, np.int8, seed)
 
     @property
-    def shape(self) -> tuple[int, ...]:
+    def shape(self) -> Tuple[int, ...]:
         """Has stricter type than gym.Space - never None."""
         return self._shape  # type: ignore