multi-agent-rlenv 3.6.3__tar.gz → 3.7.0__tar.gz

{multi_agent_rlenv-3.6.3 → multi_agent_rlenv-3.7.0}/.github/workflows/ci.yaml

@@ -27,8 +27,6 @@ jobs:
           - x86_64
           - aarch64
         python-version: 
-          - '3.10'
-          - '3.11'
           - '3.12'
           - '3.13'
     runs-on: ${{ matrix.os }}
@@ -43,7 +41,7 @@ jobs:
       - name: Install uv
         uses: yezz123/setup-uv@v4
         with:
-          uv-version: 0.6.4
+          uv-version: 0.9.24
       - name: Install dependencies and run pytest
         run: |
           uv sync --extra overcooked --extra gym --extra pettingzoo --extra torch
@@ -59,11 +57,11 @@ jobs:
     - name: Set up Python
       uses: actions/setup-python@v5
       with:
-        python-version: 3.12
+        python-version: 3.13
     - name: Install UV
       uses: yezz123/setup-uv@v4
       with:
-          uv-version: 0.6.4
+          uv-version: 0.9.24
     - name: Build wheels
       run: |
         uv venv

{multi_agent_rlenv-3.6.3 → multi_agent_rlenv-3.7.0}/PKG-INFO

@@ -1,13 +1,13 @@
 Metadata-Version: 2.4
 Name: multi-agent-rlenv
-Version: 3.6.3
+Version: 3.7.0
 Summary: A strongly typed Multi-Agent Reinforcement Learning framework
 Project-URL: repository, https://github.com/yamoling/multi-agent-rlenv
 Author-email: Yannick Molinghen <yannick.molinghen@ulb.be>
 License-File: LICENSE
 Classifier: Operating System :: OS Independent
 Classifier: Programming Language :: Python :: 3
-Requires-Python: <4,>=3.10
+Requires-Python: <4,>=3.12
 Requires-Dist: numpy>=2.0.0
 Requires-Dist: opencv-python>=4.0
 Requires-Dist: typing-extensions>=4.0

{multi_agent_rlenv-3.6.3 → multi_agent_rlenv-3.7.0}/pyproject.toml

@@ -1,12 +1,12 @@
 [project]
 name = "multi-agent-rlenv"
-version = "3.6.3"
+version = "3.7.0"
 description = "A strongly typed Multi-Agent Reinforcement Learning framework"
 authors = [
     { "name" = "Yannick Molinghen", "email" = "yannick.molinghen@ulb.be" },
 ]
 readme = "README.md"
-requires-python = ">=3.10, <4"
+requires-python = ">=3.12, <4"
 urls = { "repository" = "https://github.com/yamoling/multi-agent-rlenv" }
 classifiers = [
     "Programming Language :: Python :: 3",

{multi_agent_rlenv-3.6.3 → multi_agent_rlenv-3.7.0}/src/marlenv/__init__.py

@@ -65,9 +65,9 @@ If you want to create a new environment, you can simply create a class that inhe
 from importlib.metadata import version, PackageNotFoundError
 
 try:
-    __version__ = version("overcooked")
+    __version__ = version("multi-agent-rlenv")
 except PackageNotFoundError:
-    __version__ = "0.0.0"  # fallback pratique en dev/CI
+    __version__ = "0.0.0"  # fallback for CI
 
 
 from . import models

{multi_agent_rlenv-3.6.3 → multi_agent_rlenv-3.7.0}/src/marlenv/adapters/gym_adapter.py

@@ -44,8 +44,8 @@ class Gym(MARLEnv[Space]):
             raise ValueError("No observation available. Call reset() first.")
         return self._last_obs
 
-    def step(self, actions):
-        obs, reward, done, truncated, info = self._gym_env.step(list(actions)[0])
+    def step(self, action):
+        obs, reward, done, truncated, info = self._gym_env.step(list(action)[0])
         self._last_obs = Observation(
             np.array([obs], dtype=np.float32),
             self.available_actions(),
@@ -74,7 +74,7 @@ class Gym(MARLEnv[Space]):
         image = np.array(self._gym_env.render())
         if sys.platform in ("linux", "linux2"):
             image = cv2.cvtColor(image, cv2.COLOR_RGB2BGR)
-        return image
+        return np.array(image, dtype=np.uint8)
 
     def seed(self, seed_value: int):
         self._gym_env.reset(seed=seed_value)

{multi_agent_rlenv-3.6.3 → multi_agent_rlenv-3.7.0}/src/marlenv/adapters/pettingzoo_adapter.py

@@ -33,39 +33,39 @@ class PettingZoo(MARLEnv[Space]):
         if obs_space.shape is None:
             raise NotImplementedError("Only discrete observation spaces are supported")
         self._pz_env = env
-        env.reset()
-        super().__init__(n_agents, space, obs_space.shape, self.get_state().shape)
+        self.n_agents = n_agents
+        self.n_actions = space.shape[-1]
+        self.last_observation, state = self.reset()
+        super().__init__(n_agents, space, obs_space.shape, state.shape)
         self.agents = env.possible_agents
-        self.last_observation = None
 
     def get_state(self):
         try:
-            return self._pz_env.state()
+            return State(self._pz_env.state())
         except NotImplementedError:
-            return np.array([0])
+            assert self.last_observation is not None, "Cannot get the state unless there is a previous observation"
+            return State(self.last_observation.data)
 
-    def step(self, actions: npt.NDArray | Sequence):
-        action_dict = dict(zip(self.agents, actions))
+    def step(self, action: npt.NDArray | Sequence):
+        action_dict = dict(zip(self.agents, action))
         obs, reward, term, trunc, info = self._pz_env.step(action_dict)
         obs_data = np.array([v for v in obs.values()])
         reward = np.sum([r for r in reward.values()], keepdims=True)
         self.last_observation = Observation(obs_data, self.available_actions())
-        state = State(self.get_state())
+        state = self.get_state()
         return Step(self.last_observation, state, reward, any(term.values()), any(trunc.values()), info)
 
     def reset(self):
         obs = self._pz_env.reset()[0]
         obs_data = np.array([v for v in obs.values()])
-        self.last_observation = Observation(obs_data, self.available_actions(), self.get_state())
-        return self.last_observation
+        self.last_observation = Observation(obs_data, self.available_actions())
+        return self.last_observation, self.get_state()
 
     def get_observation(self):
-        if self.last_observation is None:
-            raise ValueError("No observation available. Call reset() first.")
         return self.last_observation
 
     def seed(self, seed_value: int):
         self._pz_env.reset(seed=seed_value)
 
-    def render(self, *_):
-        return self._pz_env.render()
+    def render(self):
+        self._pz_env.render()

{multi_agent_rlenv-3.6.3 → multi_agent_rlenv-3.7.0}/src/marlenv/adapters/smac_adapter.py

@@ -3,7 +3,7 @@ from typing import overload
 
 import numpy as np
 import numpy.typing as npt
-from smac.env import StarCraft2Env
+from smac.env import StarCraft2Env  # type:ignore[import]
 
 from marlenv.models import MARLEnv, Observation, State, Step, MultiDiscreteSpace, DiscreteSpace
 
@@ -169,17 +169,18 @@ class SMAC(MARLEnv[MultiDiscreteSpace]):
 
     def reset(self):
         obs, state = self._env.reset()
-        obs = Observation(np.array(obs), self.available_actions(), state)
-        return obs
+        obs = Observation(np.array(obs), self.available_actions())
+        state = State(state)
+        return obs, state
 
     def get_observation(self):
-        return self._env.get_obs()
+        return Observation(np.array(self._env.get_obs()), self.available_actions())
 
     def get_state(self):
         return State(self._env.get_state())
 
-    def step(self, actions):
-        reward, done, info = self._env.step(actions)
+    def step(self, action):
+        reward, done, info = self._env.step(action)
         obs = Observation(
             self._env.get_obs(),  # type: ignore
             self.available_actions(),
@@ -199,7 +200,9 @@ class SMAC(MARLEnv[MultiDiscreteSpace]):
         return np.array(self._env.get_avail_actions()) == 1
 
     def get_image(self):
-        return self._env.render(mode="rgb_array")
+        img = self._env.render(mode="rgb_array")
+        assert img is not None
+        return img
 
     def seed(self, seed_value: int):
         self._env = StarCraft2Env(map_name=self._env.map_name, seed=seed_value)

{multi_agent_rlenv-3.6.3 → multi_agent_rlenv-3.7.0}/src/marlenv/catalog/deepsea.py

@@ -45,7 +45,7 @@ class DeepSea(MARLEnv[MultiDiscreteSpace]):
         self._col = 0
         return self.get_observation(), self.get_state()
 
-    def step(self, action: Sequence[int]):
+    def step(self, action: Sequence[int] | np.ndarray):
         self._row += 1
         if action[0] == LEFT:
             self._col -= 1

multi_agent_rlenv-3.7.0/src/marlenv/catalog/two_steps.py

@@ -0,0 +1,93 @@
+from enum import IntEnum
+import cv2
+import marlenv
+import numpy as np
+import numpy.typing as npt
+from typing import Sequence
+from marlenv import Observation, State, DiscreteSpace, Step
+
+PAYOFF_INITIAL = [[0, 0], [0, 0]]
+PAYOFF_2A = [[7, 7], [7, 7]]
+PAYOFF_2B = [[0, 1], [1, 8]]
+
+
+class TwoStepsState(IntEnum):
+    INITIAL = 0
+    STATE_2A = 1
+    STATE_2B = 2
+    END = 3
+
+    def one_hot(self):
+        res = np.zeros((4,), dtype=np.float32)
+        res[self.value] = 1
+        return res
+
+    @staticmethod
+    def from_one_hot(x: np.ndarray):
+        for s in TwoStepsState:
+            if x[s.value] == 1:
+                return s
+        raise ValueError()
+
+
+class TwoStepsGame(marlenv.MARLEnv):
+    """
+    Two-steps game used in QMix paper (https://arxiv.org/pdf/1803.11485.pdf, section 5)
+    to demonstrate its superior representationability compared to VDN.
+    """
+
+    def __init__(self):
+        self.state = TwoStepsState.INITIAL
+        self._identity = np.identity(2, dtype=np.float32)
+        super().__init__(
+            2,
+            DiscreteSpace(2).repeat(2),
+            observation_shape=(self.state.one_hot().shape[0] + 2,),
+            state_shape=self.state.one_hot().shape,
+        )
+
+    def reset(self):
+        self.state = TwoStepsState.INITIAL
+        return self.observation(), self.get_state()
+
+    def step(self, action: npt.NDArray[np.int32] | Sequence):
+        match self.state:
+            case TwoStepsState.INITIAL:
+                # In the initial step, only agent 0's actions have an influence on the state
+                payoffs = PAYOFF_INITIAL
+                if action[0] == 0:
+                    self.state = TwoStepsState.STATE_2A
+                elif action[0] == 1:
+                    self.state = TwoStepsState.STATE_2B
+                else:
+                    raise ValueError(f"Invalid action: {action[0]}")
+            case TwoStepsState.STATE_2A:
+                payoffs = PAYOFF_2A
+                self.state = TwoStepsState.END
+            case TwoStepsState.STATE_2B:
+                payoffs = PAYOFF_2B
+                self.state = TwoStepsState.END
+            case TwoStepsState.END:
+                raise ValueError("Episode is already over")
+        reward = payoffs[action[0]][action[1]]
+        done = self.state == TwoStepsState.END
+        return Step(self.observation(), self.get_state(), reward, done, False)
+
+    def get_state(self):
+        return State(self.state.one_hot())
+
+    def observation(self):
+        obs_data = np.array([self.state.one_hot(), self.state.one_hot()])
+        extras = self._identity
+        return Observation(obs_data, self.available_actions(), extras)
+
+    def render(self):
+        print(self.state)
+
+    def get_image(self):
+        state = self.state.one_hot()
+        img = cv2.cvtColor(state, cv2.COLOR_GRAY2BGR)
+        return np.array(img, dtype=np.uint8)
+
+    def set_state(self, state: State):
+        self.state = TwoStepsState.from_one_hot(state.data)

{multi_agent_rlenv-3.6.3 → multi_agent_rlenv-3.7.0}/src/marlenv/env_pool.py

@@ -20,10 +20,10 @@ class EnvPool(RLEnvWrapper[ActionSpaceType]):
             assert env.has_same_inouts(self.envs[0]), "All environments must have the same inputs and outputs"
         super().__init__(self.envs[0])
 
-    def seed(self, seed: int):
-        random.seed(seed)
+    def seed(self, seed_value: int):
+        random.seed(seed_value)
         for env in self.envs:
-            env.seed(seed)
+            env.seed(seed_value)
 
     def reset(self):
         self.wrapped = random.choice(self.envs)

{multi_agent_rlenv-3.6.3 → multi_agent_rlenv-3.7.0}/src/marlenv/mock_env.py

@@ -73,9 +73,9 @@ class DiscreteMockEnv(MARLEnv[MultiDiscreteSpace]):
     def render(self, mode: str = "human"):
         return
 
-    def step(self, actions):
+    def step(self, action):
         self.t += 1
-        self.actions_history.append(actions)
+        self.actions_history.append(action)
         return Step(
             self.get_observation(),
             self.get_state(),

{multi_agent_rlenv-3.6.3 → multi_agent_rlenv-3.7.0}/src/marlenv/models/spaces.py

@@ -8,7 +8,7 @@ import numpy.typing as npt
 
 
 @dataclass
-class Space(ABC):
+class Space[T](ABC):
     shape: tuple[int, ...]
     size: int
     labels: list[str]
@@ -21,7 +21,7 @@ class Space(ABC):
         self.labels = labels
 
     @abstractmethod
-    def sample(self, mask: Optional[npt.NDArray[np.bool_]] = None) -> npt.NDArray[np.float32]:
+    def sample(self, mask: npt.NDArray[np.bool] | None = None) -> T:
         """Sample a value from the space."""
 
     def __eq__(self, value: object) -> bool:
@@ -44,7 +44,7 @@ class Space(ABC):
 
 
 @dataclass
-class DiscreteSpace(Space):
+class DiscreteSpace(Space[int]):
     size: int
     """Number of categories"""
 
@@ -53,7 +53,7 @@ class DiscreteSpace(Space):
         self.size = size
         self.space = np.arange(size)
 
-    def sample(self, mask: Optional[npt.NDArray[np.bool]] = None):
+    def sample(self, mask: npt.NDArray[np.bool] | None = None):
         space = self.space.copy()
         if mask is not None:
             space = space[mask]
@@ -87,7 +87,7 @@ class DiscreteSpace(Space):
 
 
 @dataclass
-class MultiDiscreteSpace(Space):
+class MultiDiscreteSpace(Space[npt.NDArray[np.int32]]):
     n_dims: int
     spaces: tuple[DiscreteSpace, ...]
 
@@ -123,7 +123,7 @@ class MultiDiscreteSpace(Space):
 
 
 @dataclass
-class ContinuousSpace(Space):
+class ContinuousSpace(Space[npt.NDArray[np.float32]]):
     """A continuous space (box) in R^n."""
 
     low: npt.NDArray[np.float32]
@@ -192,7 +192,7 @@ class ContinuousSpace(Space):
             action = np.array(action)
         return np.clip(action, self.low, self.high)
 
-    def sample(self) -> npt.NDArray[np.float32]:
+    def sample(self, *args, **kwargs):
         r = np.random.random(self.shape) * (self.high - self.low) + self.low
         return r.astype(np.float32)
 

{multi_agent_rlenv-3.6.3 → multi_agent_rlenv-3.7.0}/src/marlenv/utils/schedule.py

@@ -145,17 +145,15 @@ class Schedule:
     @staticmethod
     def from_json(data: dict[str, Any]):
         """Create a Schedule from a JSON-like dictionary."""
-        classname = data.get("name")
-        if classname == "LinearSchedule":
-            return LinearSchedule(data["start_value"], data["end_value"], data["n_steps"])
-        elif classname == "ExpSchedule":
-            return ExpSchedule(data["start_value"], data["end_value"], data["n_steps"])
-        elif classname == "ConstantSchedule":
-            return ConstantSchedule(data["value"])
-        elif classname == "ArbitrarySchedule":
+        candidates = [LinearSchedule, ExpSchedule, ConstantSchedule]
+        data = data.copy()
+        classname = data.pop("name")
+        for cls in candidates:
+            if cls.__name__ == classname:
+                return cls(**data)
+        if classname == "ArbitrarySchedule":
             raise NotImplementedError("ArbitrarySchedule cannot be deserialized from JSON")
-        else:
-            raise ValueError(f"Unknown schedule type: {classname}")
+        raise ValueError(f"Unknown schedule type: {classname}")
 
 
 @dataclass(eq=False)

{multi_agent_rlenv-3.6.3 → multi_agent_rlenv-3.7.0}/src/marlenv/wrappers/agent_id_wrapper.py

@@ -18,8 +18,8 @@ class AgentId(RLEnvWrapper[AS]):
         super().__init__(env, extra_shape=(env.n_agents + env.extras_shape[0],), extra_meanings=meanings)
         self._identity = np.identity(env.n_agents, dtype=np.float32)
 
-    def step(self, actions):
-        step = super().step(actions)
+    def step(self, action):
+        step = super().step(action)
         step.obs.add_extra(self._identity)
         return step
 

{multi_agent_rlenv-3.6.3 → multi_agent_rlenv-3.7.0}/src/marlenv/wrappers/blind_wrapper.py

@@ -18,8 +18,8 @@ class Blind(RLEnvWrapper[AS]):
         super().__init__(env)
         self.p = float(p)
 
-    def step(self, actions):
-        step = super().step(actions)
+    def step(self, action):
+        step = super().step(action)
         if random.random() < self.p:
             step.obs.data = np.zeros_like(step.obs.data)
         return step

{multi_agent_rlenv-3.6.3 → multi_agent_rlenv-3.7.0}/src/marlenv/wrappers/centralised.py

@@ -42,9 +42,9 @@ class Centralized(RLEnvWrapper[MultiDiscreteSpace]):
         action_names = [str(a) for a in product(*agent_actions)]
         return DiscreteSpace(env.n_actions**env.n_agents, action_names).repeat(1)
 
-    def step(self, actions: npt.NDArray | Sequence):
-        action = actions[0]
-        individual_actions = self._individual_actions(action)
+    def step(self, action: npt.NDArray | Sequence):
+        action1 = action[0]
+        individual_actions = self._individual_actions(action1)
         individual_actions = np.array(individual_actions)
         step = self.wrapped.step(individual_actions)  # type: ignore
         step.obs = self._joint_observation(step.obs)

{multi_agent_rlenv-3.6.3 → multi_agent_rlenv-3.7.0}/src/marlenv/wrappers/delayed_rewards.py

@@ -27,8 +27,8 @@ class DelayedReward(RLEnvWrapper[AS]):
             self.reward_queue.append(np.zeros(self.reward_space.shape, dtype=np.float32))
         return super().reset()
 
-    def step(self, actions):
-        step = super().step(actions)
+    def step(self, action):
+        step = super().step(action)
         self.reward_queue.append(step.reward)
         # If the step is terminal, we sum all the remaining rewards
         if step.is_terminal:

{multi_agent_rlenv-3.6.3 → multi_agent_rlenv-3.7.0}/src/marlenv/wrappers/last_action_wrapper.py

@@ -33,13 +33,13 @@ class LastAction(RLEnvWrapper[AS]):
         state.add_extra(self.last_one_hot_actions.flatten())
         return obs, state
 
-    def step(self, actions):
-        step = super().step(actions)
+    def step(self, action):
+        step = super().step(action)
         match self.wrapped.action_space:
             case ContinuousSpace():
-                self.last_actions = actions
+                self.last_actions = action
             case DiscreteSpace() | MultiDiscreteSpace():
-                self.last_one_hot_actions = self.compute_one_hot_actions(actions)
+                self.last_one_hot_actions = self.compute_one_hot_actions(action)
             case other:
                 raise NotImplementedError(f"Action space {other} not supported")
         step.obs.add_extra(self.last_one_hot_actions)

{multi_agent_rlenv-3.6.3 → multi_agent_rlenv-3.7.0}/src/marlenv/wrappers/paddings.py

@@ -24,8 +24,8 @@ class PadExtras(RLEnvWrapper[AS]):
         )
         self.n = n_added
 
-    def step(self, actions):
-        step = super().step(actions)
+    def step(self, action):
+        step = super().step(action)
         step.obs = self._add_extras(step.obs)
         return step
 
@@ -48,8 +48,8 @@ class PadObservations(RLEnvWrapper[AS]):
         super().__init__(env, observation_shape=(env.observation_shape[0] + n_added,))
         self.n = n_added
 
-    def step(self, actions):
-        step = super().step(actions)
+    def step(self, action):
+        step = super().step(action)
         step.obs = self._add_obs(step.obs)
         return step
 

{multi_agent_rlenv-3.6.3 → multi_agent_rlenv-3.7.0}/src/marlenv/wrappers/potential_shaping.py

@@ -39,9 +39,9 @@ class PotentialShaping(RLEnvWrapper[A], ABC):
         self._current_potential = self.compute_potential()
         return self.add_extras(obs), state
 
-    def step(self, actions):
+    def step(self, action):
         prev_potential = self._current_potential
-        step = super().step(actions)
+        step = super().step(action)
 
         self._current_potential = self.compute_potential()
         shaped_reward = self.gamma * self._current_potential - prev_potential

{multi_agent_rlenv-3.6.3 → multi_agent_rlenv-3.7.0}/src/marlenv/wrappers/rlenv_wrapper.py

@@ -62,8 +62,8 @@ class RLEnvWrapper(MARLEnv[AS]):
     def agent_state_size(self):
         return self.wrapped.agent_state_size
 
-    def step(self, actions: np.ndarray | Sequence):
-        return self.wrapped.step(actions)
+    def step(self, action: np.ndarray | Sequence):
+        return self.wrapped.step(action)
 
     def reset(self):
         return self.wrapped.reset()

{multi_agent_rlenv-3.6.3 → multi_agent_rlenv-3.7.0}/src/marlenv/wrappers/time_limit.py

@@ -64,9 +64,9 @@ class TimeLimit(RLEnvWrapper[AS]):
             self.add_time_extra(obs, state)
         return obs, state
 
-    def step(self, actions):
+    def step(self, action):
         self._current_step += 1
-        step = super().step(actions)
+        step = super().step(action)
         if self.add_extra:
             self.add_time_extra(step.obs, step.state)
         # If we reach the time limit

{multi_agent_rlenv-3.6.3 → multi_agent_rlenv-3.7.0}/src/marlenv/wrappers/video_recorder.py

@@ -44,10 +44,10 @@ class VideoRecorder(RLEnvWrapper[AS]):
             case other:
                 raise ValueError(f"Unsupported file video encoding: {other}")
 
-    def step(self, actions):
+    def step(self, action):
         if self._recorder is None:
             raise RuntimeError("VideoRecorder not initialized")
-        step = super().step(actions)
+        step = super().step(action)
         img = self.get_image()
         self._recorder.write(img)
         if step.is_terminal:

{multi_agent_rlenv-3.6.3 → multi_agent_rlenv-3.7.0}/tests/test_adapters.py

@@ -98,7 +98,7 @@ def _check_env_3m(env):
     from marlenv.adapters import SMAC
 
     assert isinstance(env, SMAC)
-    obs = env.reset()
+    obs, state = env.reset()
     assert isinstance(obs, Observation)
     assert env.n_agents == 3
     assert isinstance(env.action_space, MultiDiscreteSpace)
@@ -114,8 +114,7 @@ def _check_env_3m(env):
 
 @pytest.mark.skipif(skip_smac, reason="SMAC is not installed")
 def test_smac_from_class():
-    from smac.env import StarCraft2Env
-
+    from smac.env import StarCraft2Env  # type: ignore[import]
     from marlenv.adapters import SMAC
 
     env = SMAC(StarCraft2Env("3m"))

{multi_agent_rlenv-3.6.3 → multi_agent_rlenv-3.7.0}/tests/test_models.py

@@ -380,8 +380,8 @@ def test_env_replay():
                 available[(agent + self._seed) % self.n_actions] = True
             return availables
 
-        def step(self, actions):
-            return super().step(actions)
+        def step(self, action):
+            return super().step(action)
 
         def seed(self, seed_value: int):
             np.random.seed(seed_value)
@@ -409,16 +409,16 @@ def test_wrong_extras_meanings_length():
             super().__init__(4, DiscreteSpace(5), (10,), (10,), extras_shape=(5,), extras_meanings=["a", "b", "c"])
 
         def get_observation(self):
-            pass
+            raise NotImplementedError()
 
         def get_state(self):
-            pass
+            raise NotImplementedError()
 
-        def step(self, actions):
-            pass
+        def step(self, action):
+            raise NotImplementedError()
 
         def reset(self):
-            pass
+            raise NotImplementedError()
 
     try:
         TestClass()

{multi_agent_rlenv-3.6.3 → multi_agent_rlenv-3.7.0}/tests/test_serialization.py

@@ -241,7 +241,7 @@ def test_serialize_schedule():
     try:
         pickle.dumps(s)
         assert False, "Should not be able to pickle arbitrary schedules because of the callable lambda"
-    except AttributeError:
+    except (pickle.PicklingError, AttributeError):
         pass
 
     s = Schedule.arbitrary(C())

{multi_agent_rlenv-3.6.3 → multi_agent_rlenv-3.7.0}/tests/test_wrappers.py

@@ -1,6 +1,6 @@
 import numpy as np
 from marlenv import Builder, DiscreteMOMockEnv, DiscreteMockEnv, MARLEnv
-from marlenv.wrappers import Centralized, AvailableActionsMask, TimeLimit, LastAction, DelayedReward, ActionRandomizer
+from marlenv.wrappers import Centralized, AvailableActionsMask, TimeLimit, LastAction, DelayedReward
 import marlenv
 
 
@@ -55,13 +55,12 @@ def test_time_limit_wrapper():
     env = Builder(DiscreteMockEnv(1)).time_limit(MAX_T).build()
     assert env.extras_shape == (1,)
     assert env.state_extra_shape == (1,)
-    done = False
-    t = 0
-    while not done:
-        step = env.step(np.array([0]))
+    t = 1
+    step = env.step(np.array([0]))
+    while not step.done:
         assert step.obs.extras.shape == (env.n_agents, 1)
         assert step.state.extras_shape == (1,)
-        done = step.done
+        step = env.step(np.array([0]))
         t += 1
     assert t == MAX_T
     assert step.truncated
@@ -73,12 +72,15 @@ def test_truncated_and_done():
     env = marlenv.wrappers.TimeLimit(DiscreteMockEnv(2, end_game=END_GAME), END_GAME)
     obs, state = env.reset()
     episode = marlenv.Episode.new(obs, state)
+    action = env.action_space.sample()
+    step = env.step(action)
     while not episode.is_finished:
-        action = env.action_space.sample()
-        step = env.step(action)
         episode.add(marlenv.Transition.from_step(obs, state, action, step))
         obs = step.obs
         state = step.state
+        action = env.action_space.sample()
+        step = env.step(action)
+
     assert step.done
     assert not step.truncated, (
         "The episode is done, so it does not have to be truncated even though the time limit is reached at the same time."
@@ -97,11 +99,10 @@ def test_time_limit_wrapper_with_extra():
     assert env.extras_shape == (1,)
     obs, _ = env.reset()
     assert obs.extras.shape == (5, 1)
-    stop = False
-    t = 0
-    while not stop:
+    t = 1
+    step = env.step(np.array([0]))
+    while not step.is_terminal:
         step = env.step(np.array([0]))
-        stop = step.done or step.truncated
         t += 1
     assert t == MAX_T
     assert np.all(step.obs.extras == 1.0)
@@ -129,11 +130,10 @@ def test_time_limit_wrapper_with_truncation_penalty():
     assert env.extras_shape == (1,)
     obs, _ = env.reset()
     assert obs.extras.shape == (5, 1)
-    stop = False
-    t = 0
-    while not stop:
+    t = 1
+    step = env.step(np.array([0]))
+    while not step.is_terminal:
         step = env.step(np.array([0]))
-        stop = step.done or step.truncated
         t += 1
     assert t == MAX_T
     assert np.all(step.obs.extras[:] == 1)
@@ -374,9 +374,9 @@ def test_potential_shaping():
         def compute_potential(self) -> float:
             return self.phi
 
-        def step(self, actions):
+        def step(self, action):
             self.phi = max(0, self.phi - 1)
-            return super().step(actions)
+            return super().step(action)
 
     EP_LENGTH = 20
     env = PS(DiscreteMockEnv(reward_step=0, end_game=EP_LENGTH))