multi-agent-rlenv 3.3.5__tar.gz → 3.3.6__tar.gz

{multi_agent_rlenv-3.3.5 → multi_agent_rlenv-3.3.6}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: multi-agent-rlenv
-Version: 3.3.5
+Version: 3.3.6
 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>

{multi_agent_rlenv-3.3.5 → multi_agent_rlenv-3.3.6}/src/marlenv/__init__.py

@@ -62,7 +62,7 @@ print(env.extras_shape) # (1, )
 If you want to create a new environment, you can simply create a class that inherits from `MARLEnv`. If you want to create a wrapper around an existing `MARLEnv`, you probably want to subclass `RLEnvWrapper` which implements a default behaviour for every method.
 """
 
-__version__ = "3.3.5"
+__version__ = "3.3.6"
 
 from . import models
 from . import wrappers

{multi_agent_rlenv-3.3.5 → multi_agent_rlenv-3.3.6}/src/marlenv/adapters/__init__.py

@@ -20,7 +20,7 @@ if find_spec("smac") is not None:
     HAS_SMAC = True
 
 HAS_OVERCOOKED = False
-if find_spec("overcooked_ai_py.mdp") is not None:
+if find_spec("overcooked_ai_py") is not None and find_spec("overcooked_ai_py.mdp") is not None:
     import numpy
 
     # Overcooked assumes a version of numpy <2.0 where np.Inf is available.

{multi_agent_rlenv-3.3.5 → multi_agent_rlenv-3.3.6}/src/marlenv/adapters/gym_adapter.py

@@ -42,26 +42,26 @@ class Gym(MARLEnv[Sequence | npt.NDArray, ActionSpace]):
             case other:
                 raise NotImplementedError(f"Action space {other} not supported")
         super().__init__(space, env.observation_space.shape, (1,))
-        self.env = env
-        if self.env.unwrapped.spec is not None:
-            self.name = self.env.unwrapped.spec.id
+        self._gym_env = env
+        if self._gym_env.unwrapped.spec is not None:
+            self.name = self._gym_env.unwrapped.spec.id
         else:
             self.name = "gym-no-id"
-        self.last_obs = None
+        self._last_obs = None
 
     def get_observation(self):
-        if self.last_obs is None:
+        if self._last_obs is None:
             raise ValueError("No observation available. Call reset() first.")
-        return self.last_obs
+        return self._last_obs
 
     def step(self, actions):
-        obs, reward, done, truncated, info = self.env.step(list(actions)[0])
-        self.last_obs = Observation(
+        obs, reward, done, truncated, info = self._gym_env.step(list(actions)[0])
+        self._last_obs = Observation(
             np.array([obs], dtype=np.float32),
             self.available_actions(),
         )
         return Step(
-            self.last_obs,
+            self._last_obs,
             self.get_state(),
             np.array([reward]),
             done,
@@ -73,18 +73,18 @@ class Gym(MARLEnv[Sequence | npt.NDArray, ActionSpace]):
         return State(np.zeros(1, dtype=np.float32))
 
     def reset(self):
-        obs_data, _info = self.env.reset()
-        self.last_obs = Observation(
+        obs_data, _info = self._gym_env.reset()
+        self._last_obs = Observation(
             np.array([obs_data], dtype=np.float32),
             self.available_actions(),
         )
-        return self.last_obs, self.get_state()
+        return self._last_obs, self.get_state()
 
     def get_image(self):
-        image = np.array(self.env.render())
+        image = np.array(self._gym_env.render())
         if sys.platform in ("linux", "linux2"):
             image = cv2.cvtColor(image, cv2.COLOR_RGB2BGR)
         return image
 
     def seed(self, seed_value: int):
-        self.env.reset(seed=seed_value)
+        self._gym_env.reset(seed=seed_value)

{multi_agent_rlenv-3.3.5 → multi_agent_rlenv-3.3.6}/src/marlenv/adapters/overcooked_adapter.py

@@ -23,8 +23,9 @@ class Overcooked(MARLEnv[Sequence[int] | npt.NDArray, DiscreteActionSpace]):
         assert isinstance(oenv.mdp, OvercookedGridworld)
         self._mdp = oenv.mdp
         self._visualizer = StateVisualizer()
-        shape = tuple(int(s) for s in self._mdp.get_lossless_state_encoding_shape())
-        shape = (shape[2], shape[0], shape[1])
+        width, height, layers = tuple(self._mdp.lossless_state_encoding_shape)
+        # -1 because we extract the "urgent" layer to the extras
+        shape = (int(layers - 1), int(width), int(height))
         super().__init__(
             action_space=DiscreteActionSpace(
                 n_agents=self._mdp.num_players,
@@ -32,10 +33,10 @@ class Overcooked(MARLEnv[Sequence[int] | npt.NDArray, DiscreteActionSpace]):
                 action_names=[Action.ACTION_TO_CHAR[a] for a in Action.ALL_ACTIONS],
             ),
             observation_shape=shape,
-            extras_shape=(1,),
-            extras_meanings=["timestep"],
+            extras_shape=(2,),
+            extras_meanings=["timestep", "urgent"],
             state_shape=shape,
-            state_extra_shape=(1,),
+            state_extra_shape=(2,),
             reward_space=ContinuousSpace.from_shape(1),
         )
         self.horizon = int(self._oenv.horizon)
@@ -53,19 +54,25 @@ class Overcooked(MARLEnv[Sequence[int] | npt.NDArray, DiscreteActionSpace]):
         return self.state.timestep
 
     def _state_data(self):
-        state = np.array(self._mdp.lossless_state_encoding(self.state), dtype=np.float32)
+        players_layers = self._mdp.lossless_state_encoding(self.state)
+        state = np.array(players_layers, dtype=np.float32)
         # Use axes (agents, channels, height, width) instead of (agents, height, width, channels)
         state = np.transpose(state, (0, 3, 1, 2))
-        return state
+        # The last last layer is for "urgency", put it in the extras
+        urgency = float(np.all(state[:, -1]))
+        state = state[:, :-1]
+        return state, urgency
 
     def get_state(self):
-        return State(self._state_data()[0], np.array([self.time_step / self.horizon], dtype=np.float32))
+        data, is_urgent = self._state_data()
+        return State(data[0], np.array([self.time_step / self.horizon, is_urgent], dtype=np.float32))
 
     def get_observation(self) -> Observation:
+        data, is_urgent = self._state_data()
         return Observation(
-            data=self._state_data(),
+            data=data,
             available_actions=self.available_actions(),
-            extras=np.array([[self.time_step / self.horizon]] * self.n_agents, dtype=np.float32),
+            extras=np.array([[self.time_step / self.horizon, is_urgent]] * self.n_agents, dtype=np.float32),
         )
 
     def available_actions(self):
@@ -74,7 +81,7 @@ class Overcooked(MARLEnv[Sequence[int] | npt.NDArray, DiscreteActionSpace]):
         for agent_num, agent_actions in enumerate(actions):
             for action in agent_actions:
                 available_actions[agent_num, Action.ACTION_TO_INDEX[action]] = True
-        return np.array(available_actions)
+        return np.array(available_actions, dtype=np.bool)
 
     def step(self, actions: Sequence[int] | npt.NDArray[np.int32 | np.int64]) -> Step:
         actions = [Action.ALL_ACTIONS[a] for a in actions]

{multi_agent_rlenv-3.3.5 → multi_agent_rlenv-3.3.6}/src/marlenv/adapters/pettingzoo_adapter.py

@@ -32,7 +32,7 @@ class PettingZoo(MARLEnv[npt.NDArray, ActionSpace]):
         obs_space = env.observation_space(env.possible_agents[0])
         if obs_space.shape is None:
             raise NotImplementedError("Only discrete observation spaces are supported")
-        self._env = env
+        self._pz_env = env
         env.reset()
         super().__init__(space, obs_space.shape, self.get_state().shape)
         self.agents = env.possible_agents
@@ -40,13 +40,13 @@ class PettingZoo(MARLEnv[npt.NDArray, ActionSpace]):
 
     def get_state(self):
         try:
-            return self._env.state()
+            return self._pz_env.state()
         except NotImplementedError:
             return np.array([0])
 
     def step(self, actions: npt.NDArray | Sequence):
         action_dict = dict(zip(self.agents, actions))
-        obs, reward, term, trunc, info = self._env.step(action_dict)
+        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())
@@ -54,7 +54,7 @@ class PettingZoo(MARLEnv[npt.NDArray, ActionSpace]):
         return Step(self.last_observation, state, reward, any(term.values()), any(trunc.values()), info)
 
     def reset(self):
-        obs = self._env.reset()[0]
+        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
@@ -65,7 +65,7 @@ class PettingZoo(MARLEnv[npt.NDArray, ActionSpace]):
         return self.last_observation
 
     def seed(self, seed_value: int):
-        self._env.reset(seed=seed_value)
+        self._pz_env.reset(seed=seed_value)
 
     def render(self, *_):
-        return self._env.render()
+        return self._pz_env.render()

{multi_agent_rlenv-3.3.5 → multi_agent_rlenv-3.3.6}/src/marlenv/env_builder.py

@@ -127,7 +127,7 @@ class Builder(Generic[A, AS]):
         from marlenv.models import DiscreteActionSpace
 
         assert isinstance(self._env.action_space, DiscreteActionSpace)
-        self._env = wrappers.Centralised(self._env)  # type: ignore
+        self._env = wrappers.Centralized(self._env)  # type: ignore
         return self
 
     def record(

{multi_agent_rlenv-3.3.5 → multi_agent_rlenv-3.3.6}/src/marlenv/wrappers/__init__.py

@@ -7,7 +7,7 @@ from .paddings import PadObservations, PadExtras
 from .penalty_wrapper import TimePenalty
 from .available_actions_wrapper import AvailableActions
 from .blind_wrapper import Blind
-from .centralised import Centralised
+from .centralised import Centralized
 from .available_actions_mask import AvailableActionsMask
 from .delayed_rewards import DelayedReward
 
@@ -24,6 +24,6 @@ __all__ = [
     "TimePenalty",
     "AvailableActions",
     "Blind",
-    "Centralised",
+    "Centralized",
     "DelayedReward",
 ]

{multi_agent_rlenv-3.3.5 → multi_agent_rlenv-3.3.6}/src/marlenv/wrappers/centralised.py

@@ -14,7 +14,7 @@ A = TypeVar("A", bound=npt.NDArray | Sequence[int] | Sequence[Sequence[float]])
 
 
 @dataclass
-class Centralised(RLEnvWrapper[A, DiscreteActionSpace]):
+class Centralized(RLEnvWrapper[A, DiscreteActionSpace]):
     joint_action_space: ActionSpace
 
     def __init__(self, env: MARLEnv[A, DiscreteActionSpace]):

{multi_agent_rlenv-3.3.5 → multi_agent_rlenv-3.3.6}/tests/test_adapters.py

@@ -147,9 +147,9 @@ def test_overcooked_attributes():
     height, width = env._mdp.shape
     assert env.n_agents == 2
     assert env.n_actions == Action.NUM_ACTIONS
-    assert env.observation_shape == (26, height, width)
+    assert env.observation_shape == (25, height, width)
     assert env.reward_space.shape == (1,)
-    assert env.extras_shape == (1,)
+    assert env.extras_shape == (2,)
     assert not env.is_multi_objective
 
 
@@ -166,13 +166,13 @@ def test_overcooked_obs_state():
         assert state.data.dtype == np.float32
         assert obs.extras.dtype == np.float32
         assert state.extras.dtype == np.float32
-        assert obs.shape == (26, height, width)
-        assert obs.extras_shape == (1,)
-        assert state.shape == (26, height, width)
-        assert state.extras_shape == (1,)
+        assert obs.shape == (25, height, width)
+        assert obs.extras_shape == (2,)
+        assert state.shape == (25, height, width)
+        assert state.extras_shape == (2,)
 
-        assert np.all(obs.extras == i / HORIZON)
-        assert np.all(state.extras == i / HORIZON)
+        assert np.all(obs.extras[:, 0] == i / HORIZON)
+        assert np.all(state.extras[0] == i / HORIZON)
 
         step = env.random_step()
         obs = step.obs

{multi_agent_rlenv-3.3.5 → multi_agent_rlenv-3.3.6}/tests/test_serialization.py

@@ -6,7 +6,7 @@ import os
 from copy import deepcopy
 
 import marlenv
-from marlenv import DiscreteMockEnv
+from marlenv import DiscreteMockEnv, wrappers
 
 
 def test_registry():
@@ -76,21 +76,78 @@ def test_serialize_episode_fields():
         assert field in episode
 
 
+def serde_and_check_key_values(env: object):
+    serialized = orjson.dumps(env, option=orjson.OPT_SERIALIZE_NUMPY)
+    deserialized = orjson.loads(serialized)
+    checked_keys = []
+    for key, value in env.__dict__.items():
+        if key.startswith("_"):
+            continue
+        checked_keys.append(key)
+        assert key in deserialized
+        match value:
+            case int() | float() | str() | bool() | list() | dict():
+                assert deserialized[key] == value
+            case np.ndarray():
+                assert np.all(deserialized[key] == value)
+    assert len(checked_keys) > 0
+
+
+def test_serialize_blind():
+    env = DiscreteMockEnv(4)
+    serde_and_check_key_values(wrappers.Blind(env, 0.2))
+
+
+def test_serialize_time_limit():
+    env = DiscreteMockEnv(4)
+    serde_and_check_key_values(wrappers.TimeLimit(env, 10))
+
+
+def test_serialize_time_penalty():
+    env = DiscreteMockEnv(4)
+    serde_and_check_key_values(wrappers.TimePenalty(env, 0.2))
+
+
+def test_serialize_agent_id():
+    env = DiscreteMockEnv(4)
+    serde_and_check_key_values(wrappers.AgentId(env))
+
+
+def test_serialize_last_action():
+    env = DiscreteMockEnv(4)
+    serde_and_check_key_values(wrappers.LastAction(env))
+
+
+def test_serialize_available_actions():
+    env = DiscreteMockEnv(4)
+    serde_and_check_key_values(wrappers.AvailableActions(env))
+
+
+def test_serialize_video():
+    env = DiscreteMockEnv(4)
+    serde_and_check_key_values(wrappers.VideoRecorder(env))
+
+
+def test_serialize_centralised():
+    env = DiscreteMockEnv(4)
+    serde_and_check_key_values(wrappers.Centralized(env))
+
+
+def test_serialize_pad_extras():
+    env = DiscreteMockEnv(4)
+    serde_and_check_key_values(wrappers.PadExtras(env, 5))
+
+
+def test_serialize_pad_observation():
+    env = DiscreteMockEnv(4)
+    serde_and_check_key_values(wrappers.PadObservations(env, 5))
+
+
 def test_wrappers_serializable():
     env = DiscreteMockEnv(4)
     env = marlenv.Builder(env).agent_id().available_actions().time_limit(10).last_action().time_penalty(5).blind(0.2).build()
-    as_bytes = orjson.dumps(env, option=orjson.OPT_SERIALIZE_NUMPY)
-    deserialized = orjson.loads(as_bytes)
 
-    def check_key_values(env: object, deserialized: dict):
-        for key, value in env.__dict__.items():
-            if key.startswith("_"):
-                continue
-            assert key in deserialized
-            if key == "wrapped":
-                check_key_values(value, deserialized[key])
-
-    check_key_values(env, deserialized)
+    serde_and_check_key_values(env)
 
 
 def test_serialize_observation():
@@ -204,3 +261,23 @@ def test_serialize_json_overcooked():
     assert deserialized["n_actions"] == env.n_actions
     assert deserialized["name"] == env.name
     assert deserialized["extras_meanings"] == env.extras_meanings
+
+
+@pytest.mark.skipif(not marlenv.adapters.HAS_GYM, reason="Gymnasium is not installed")
+def test_json_serialize_gym():
+    env = marlenv.make("CartPole-v1")
+    serde_and_check_key_values(env)
+
+
+@pytest.mark.skipif(not marlenv.adapters.HAS_PETTINGZOO, reason="PettingZoo is not installed")
+def test_json_serialize_pettingzoo():
+    from pettingzoo.sisl import pursuit_v4
+
+    env = marlenv.adapters.PettingZoo(pursuit_v4.parallel_env())
+    serde_and_check_key_values(env)
+
+
+@pytest.mark.skipif(not marlenv.adapters.HAS_SMAC, reason="SMAC is not installed")
+def test_json_serialize_smac():
+    env = marlenv.adapters.SMAC("3m")
+    serde_and_check_key_values(env)

{multi_agent_rlenv-3.3.5 → multi_agent_rlenv-3.3.6}/tests/test_wrappers.py

@@ -1,7 +1,7 @@
 import numpy as np
 from typing import Any
 from marlenv import Builder, DiscreteMOMockEnv, DiscreteMockEnv, MARLEnv
-from marlenv.wrappers import Centralised, AvailableActionsMask, TimeLimit, LastAction, DelayedReward
+from marlenv.wrappers import Centralized, AvailableActionsMask, TimeLimit, LastAction, DelayedReward
 import marlenv
 
 
@@ -181,7 +181,7 @@ def test_centralised_shape():
 
 def test_centralised_action():
     mock = DiscreteMockEnv(2)
-    env = Centralised(mock)
+    env = Centralized(mock)
     for action1 in range(mock.n_actions):
         for action2 in range(mock.n_actions):
             joint_action = action1 * mock.n_actions + action2
@@ -192,7 +192,7 @@ def test_centralised_action():
 
 def test_centralised_obs_and_state():
     wrapped = DiscreteMockEnv(2)
-    env = Centralised(wrapped)
+    env = Centralized(wrapped)
     assert env.observation_shape == (2 * wrapped.obs_size,)
     assert env.state_shape == (wrapped.agent_state_size * wrapped.n_agents,)
     obs, state = env.reset()
@@ -214,7 +214,7 @@ def test_centralised_available_actions():
     mask = np.zeros((N_AGENTS, mock.n_actions), dtype=np.bool_)
     mask[0, 0] = True
     mask[1, 0] = True
-    env = Centralised(AvailableActionsMask(mock, mask))
+    env = Centralized(AvailableActionsMask(mock, mask))
     expected_joint_mask = np.zeros((1, mock.n_actions**N_AGENTS))
     expected_joint_mask[0, 0] = 1
     obs, _ = env.reset()