Removing return_info argument to env.reset() and deprecated env.seed() function (reset now always returns info)

README.md

@@ -23,14 +23,14 @@ The Gym API's API models environments as simple Python `env` classes. Creating e
 ```python
 import gym
 env = gym.make("CartPole-v1")
-observation, info = env.reset(seed=42, return_info=True)
+observation, info = env.reset(seed=42)
 
 for _ in range(1000):
     action = env.action_space.sample()
     observation, reward, done, info = env.step(action)
 
     if done:
-        observation, info = env.reset(return_info=True)
+        observation, info = env.reset()
 env.close()
 ```
 

gym/core.py

@@ -69,11 +69,10 @@ class Env(Generic[ObsType, ActType]):
     The main API methods that users of this class need to know are:
 
     - :meth:`step` - Takes a step in the environment using an action returning the next observation, reward,
-      if the environment terminated and more information.
-    - :meth:`reset` - Resets the environment to an initial state, returning the initial observation.
+      if the environment terminated and observation information.
+    - :meth:`reset` - Resets the environment to an initial state, returning the initial observation and observation information.
     - :meth:`render` - Renders the environment observation with modes depending on the output
     - :meth:`close` - Closes the environment, important for rendering where pygame is imported
-    - :meth:`seed` - Seeds the environment's random number generator, :deprecated: in favor of `Env.reset(seed=seed)`.
 
     And set the following attributes:
 
@@ -158,9 +157,8 @@ def reset(
         self,
         *,
         seed: Optional[int] = None,
-        return_info: bool = False,
         options: Optional[dict] = None,
-    ) -> Union[ObsType, Tuple[ObsType, dict]]:
+    ) -> 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
@@ -177,17 +175,14 @@ def reset(
                 If you pass an integer, the PRNG will be reset even if it already exists.
                 Usually, you want to pass an integer *right after the environment has been initialized and then never again*.
                 Please refer to the minimal example above to see this paradigm in action.
-            return_info (bool): If true, return additional information along with initial observation.
-                This info should be analogous to the info returned in :meth:`step`
             options (optional dict): Additional information to specify how the environment is reset (optional,
                 depending on the specific environment)
 
 
         Returns:
             observation (object): Observation of the initial state. This will be an element of :attr:`observation_space`
                 (typically a numpy array) and is analogous to the observation returned by :meth:`step`.
-            info (optional dictionary): This will *only* be returned if ``return_info=True`` is passed.
-                It contains auxiliary information complementing ``observation``. This dictionary should be analogous to
+            info (dictionary):  This dictionary contains auxiliary information complementing ``observation``. It should be analogous to
                 the ``info`` returned by :meth:`step`.
         """
         # Initialize the RNG if the seed is manually passed
@@ -233,33 +228,6 @@ def close(self):
         """
         pass
 
-    def seed(self, seed=None):
-        """:deprecated: function that sets the seed for the environment's random number generator(s).
-
-        Use `env.reset(seed=seed)` as the new API for setting the seed of the environment.
-
-        Note:
-            Some environments use multiple pseudorandom number generators.
-            We want to capture all such seeds used in order to ensure that
-            there aren't accidental correlations between multiple generators.
-
-        Args:
-            seed(Optional int): The seed value for the random number generator
-
-        Returns:
-            seeds (List[int]): Returns the list of seeds used in this environment's random
-              number generators. The first value in the list should be the
-              "main" seed, or the value which a reproducer should pass to
-              'seed'. Often, the main seed equals the provided 'seed', but
-              this won't be true `if seed=None`, for example.
-        """
-        deprecation(
-            "Function `env.seed(seed)` is marked as deprecated and will be removed in the future. "
-            "Please use `env.reset(seed=seed)` instead."
-        )
-        self._np_random, seed = seeding.np_random(seed)
-        return [seed]
-
     @property
     def unwrapped(self) -> "Env":
         """Returns the base non-wrapped environment.
@@ -410,7 +378,7 @@ def step(
 
         return step_api_compatibility(self.env.step(action), self.new_step_api)
 
-    def reset(self, **kwargs) -> Union[ObsType, Tuple[ObsType, dict]]:
+    def reset(self, **kwargs) -> Tuple[ObsType, dict]:
         """Resets the environment with kwargs."""
         return self.env.reset(**kwargs)
 
@@ -424,10 +392,6 @@ def close(self):
         """Closes the environment."""
         return self.env.close()
 
-    def seed(self, seed=None):
-        """Seeds the environment."""
-        return self.env.seed(seed)
-
     def __str__(self):
         """Returns the wrapper name and the unwrapped environment string."""
         return f"<{type(self).__name__}{self.env}>"
@@ -472,11 +436,8 @@ def observation(self, obs):
 
     def reset(self, **kwargs):
         """Resets the environment, returning a modified observation using :meth:`self.observation`."""
-        if kwargs.get("return_info", False):
-            obs, info = self.env.reset(**kwargs)
-            return self.observation(obs), info
-        else:
-            return self.observation(self.env.reset(**kwargs))
+        obs, info = self.env.reset(**kwargs)
+        return self.observation(obs), info
 
     def step(self, action):
         """Returns a modified observation using :meth:`self.observation` after calling :meth:`env.step`."""

gym/envs/box2d/bipedal_walker.py

@@ -428,7 +428,6 @@ def reset(
         self,
         *,
         seed: Optional[int] = None,
-        return_info: bool = False,
         options: Optional[dict] = None,
     ):
         super().reset(seed=seed)
@@ -514,10 +513,7 @@ def ReportFixture(self, fixture, point, normal, fraction):
 
         self.lidar = [LidarCallback() for _ in range(10)]
         self.renderer.reset()
-        if not return_info:
-            return self.step(np.array([0, 0, 0, 0]))[0]
-        else:
-            return self.step(np.array([0, 0, 0, 0]))[0], {}
+        return self.step(np.array([0, 0, 0, 0]))[0], {}
 
     def step(self, action: np.ndarray):
         assert self.hull is not None

gym/envs/box2d/car_racing.py

@@ -483,7 +483,6 @@ def reset(
         self,
         *,
         seed: Optional[int] = None,
-        return_info: bool = False,
         options: Optional[dict] = None,
     ):
         super().reset(seed=seed)
@@ -519,10 +518,7 @@ def reset(
         self.car = Car(self.world, *self.track[0][1:4])
 
         self.renderer.reset()
-        if not return_info:
-            return self.step(None)[0]
-        else:
-            return self.step(None)[0], {}
+        return self.step(None)[0], {}
 
     def step(self, action: Union[np.ndarray, int]):
         assert self.car is not None

gym/envs/box2d/lunar_lander.py

@@ -305,7 +305,6 @@ def reset(
         self,
         *,
         seed: Optional[int] = None,
-        return_info: bool = False,
         options: Optional[dict] = None,
     ):
         super().reset(seed=seed)
@@ -413,10 +412,7 @@ def reset(
         self.drawlist = [self.lander] + self.legs
 
         self.renderer.reset()
-        if not return_info:
-            return self.step(np.array([0, 0]) if self.continuous else 0)[0]
-        else:
-            return self.step(np.array([0, 0]) if self.continuous else 0)[0], {}
+        return self.step(np.array([0, 0]) if self.continuous else 0)[0], {}
 
     def _create_particle(self, mass, x, y, ttl):
         p = self.world.CreateDynamicBody(
@@ -777,7 +773,7 @@ def demo_heuristic_lander(env, seed=None, render=False):
 
     total_reward = 0
     steps = 0
-    s = env.reset(seed=seed)
+    s, info = env.reset(seed=seed)
     while True:
         a = heuristic(env, s)
         s, r, terminated, truncated, info = step_api_compatibility(env.step(a), True)

gym/envs/classic_control/acrobot.py

@@ -180,13 +180,7 @@ def __init__(self, render_mode: Optional[str] = None):
         self.action_space = spaces.Discrete(3)
         self.state = None
 
-    def reset(
-        self,
-        *,
-        seed: Optional[int] = None,
-        return_info: bool = False,
-        options: Optional[dict] = None
-    ):
+    def reset(self, *, seed: Optional[int] = None, options: Optional[dict] = None):
         super().reset(seed=seed)
         # Note that if you use custom reset bounds, it may lead to out-of-bound
         # state/observations.
@@ -199,10 +193,7 @@ def reset(
 
         self.renderer.reset()
         self.renderer.render_step()
-        if not return_info:
-            return self._get_ob()
-        else:
-            return self._get_ob(), {}
+        return self._get_ob(), {}
 
     def step(self, a):
         s = self.state

gym/envs/classic_control/cartpole.py

@@ -192,7 +192,6 @@ def reset(
         self,
         *,
         seed: Optional[int] = None,
-        return_info: bool = False,
         options: Optional[dict] = None,
     ):
         super().reset(seed=seed)
@@ -205,10 +204,7 @@ def reset(
         self.steps_beyond_terminated = None
         self.renderer.reset()
         self.renderer.render_step()
-        if not return_info:
-            return np.array(self.state, dtype=np.float32)
-        else:
-            return np.array(self.state, dtype=np.float32), {}
+        return np.array(self.state, dtype=np.float32), {}
 
     def render(self, mode="human"):
         if self.render_mode is not None:

gym/envs/classic_control/continuous_mountain_car.py

@@ -174,24 +174,15 @@ def step(self, action: np.ndarray):
         self.renderer.render_step()
         return self.state, reward, terminated, False, {}
 
-    def reset(
-        self,
-        *,
-        seed: Optional[int] = None,
-        return_info: bool = False,
-        options: Optional[dict] = None
-    ):
+    def reset(self, *, seed: Optional[int] = None, options: Optional[dict] = None):
         super().reset(seed=seed)
         # Note that if you use custom reset bounds, it may lead to out-of-bound
         # state/observations.
         low, high = utils.maybe_parse_reset_bounds(options, -0.6, -0.4)
         self.state = np.array([self.np_random.uniform(low=low, high=high), 0])
         self.renderer.reset()
         self.renderer.render_step()
-        if not return_info:
-            return np.array(self.state, dtype=np.float32)
-        else:
-            return np.array(self.state, dtype=np.float32), {}
+        return np.array(self.state, dtype=np.float32), {}
 
     def _height(self, xs):
         return np.sin(3 * xs) * 0.45 + 0.55

gym/envs/classic_control/mountain_car.py

@@ -152,7 +152,6 @@ def reset(
         self,
         *,
         seed: Optional[int] = None,
-        return_info: bool = False,
         options: Optional[dict] = None,
     ):
         super().reset(seed=seed)
@@ -162,10 +161,7 @@ def reset(
         self.state = np.array([self.np_random.uniform(low=low, high=high), 0])
         self.renderer.reset()
         self.renderer.render_step()
-        if not return_info:
-            return np.array(self.state, dtype=np.float32)
-        else:
-            return np.array(self.state, dtype=np.float32), {}
+        return np.array(self.state, dtype=np.float32), {}
 
     def _height(self, xs):
         return np.sin(3 * xs) * 0.45 + 0.55

gym/envs/classic_control/pendulum.py

@@ -138,13 +138,7 @@ def step(self, u):
         self.renderer.render_step()
         return self._get_obs(), -costs, False, False, {}
 
-    def reset(
-        self,
-        *,
-        seed: Optional[int] = None,
-        return_info: bool = False,
-        options: Optional[dict] = None
-    ):
+    def reset(self, *, seed: Optional[int] = None, options: Optional[dict] = None):
         super().reset(seed=seed)
         if options is None:
             high = np.array([DEFAULT_X, DEFAULT_Y])
@@ -162,10 +156,7 @@ def reset(
 
         self.renderer.reset()
         self.renderer.render_step()
-        if not return_info:
-            return self._get_obs()
-        else:
-            return self._get_obs(), {}
+        return self._get_obs(), {}
 
     def _get_obs(self):
         theta, thetadot = self.state

gym/envs/mujoco/mujoco_env.py

@@ -142,7 +142,6 @@ def reset(
         self,
         *,
         seed: Optional[int] = None,
-        return_info: bool = False,
         options: Optional[dict] = None,
     ):
         super().reset(seed=seed)
@@ -152,10 +151,7 @@ def reset(
         ob = self.reset_model()
         self.renderer.reset()
         self.renderer.render_step()
-        if not return_info:
-            return ob
-        else:
-            return ob, {}
+        return ob, {}
 
     def set_state(self, qpos, qvel):
         """

gym/envs/toy_text/blackjack.py

@@ -167,7 +167,6 @@ def _get_obs(self):
     def reset(
         self,
         seed: Optional[int] = None,
-        return_info: bool = False,
         options: Optional[dict] = None,
     ):
         super().reset(seed=seed)
@@ -189,10 +188,7 @@ def reset(
         self.renderer.reset()
         self.renderer.render_step()
 
-        if not return_info:
-            return self._get_obs()
-        else:
-            return self._get_obs(), {}
+        return self._get_obs(), {}
 
     def render(self, mode="human"):
         if self.render_mode is not None:

gym/envs/toy_text/cliffwalking.py

@@ -149,22 +149,14 @@ def step(self, a):
         self.renderer.render_step()
         return (int(s), r, t, False, {"prob": p})
 
-    def reset(
-        self,
-        *,
-        seed: Optional[int] = None,
-        return_info: bool = False,
-        options: Optional[dict] = None
-    ):
+    def reset(self, *, seed: Optional[int] = None, options: Optional[dict] = None):
         super().reset(seed=seed)
         self.s = categorical_sample(self.initial_state_distrib, self.np_random)
         self.lastaction = None
         self.renderer.reset()
         self.renderer.render_step()
-        if not return_info:
-            return int(self.s)
-        else:
-            return int(self.s), {"prob": 1}
+
+        return int(self.s), {"prob": 1}
 
     def render(self, mode="human"):
         if self.render_mode is not None: