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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: multi-agent-rlenv
-Version: 3.3.2
+Version: 3.3.5
 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.2 → multi_agent_rlenv-3.3.5}/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.2"
+__version__ = "3.3.5"
 
 from . import models
 from . import wrappers

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

@@ -22,7 +22,7 @@ class Overcooked(MARLEnv[Sequence[int] | npt.NDArray, DiscreteActionSpace]):
         self._oenv = oenv
         assert isinstance(oenv.mdp, OvercookedGridworld)
         self._mdp = oenv.mdp
-        self.visualizer = StateVisualizer()
+        self._visualizer = StateVisualizer()
         shape = tuple(int(s) for s in self._mdp.get_lossless_state_encoding_shape())
         shape = (shape[2], shape[0], shape[1])
         super().__init__(
@@ -53,19 +53,19 @@ 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))
+        state = np.array(self._mdp.lossless_state_encoding(self.state), 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
 
     def get_state(self):
-        return State(self._state_data()[0], np.array([self.time_step / self.horizon]))
+        return State(self._state_data()[0], np.array([self.time_step / self.horizon], dtype=np.float32))
 
     def get_observation(self) -> Observation:
         return Observation(
             data=self._state_data(),
             available_actions=self.available_actions(),
-            extras=np.array([[self.time_step / self.horizon]] * self.n_agents),
+            extras=np.array([[self.time_step / self.horizon]] * self.n_agents, dtype=np.float32),
         )
 
     def available_actions(self):
@@ -88,6 +88,10 @@ class Overcooked(MARLEnv[Sequence[int] | npt.NDArray, DiscreteActionSpace]):
             info=info,
         )
 
+    def reset(self):
+        self._oenv.reset()
+        return self.get_observation(), self.get_state()
+
     def __deepcopy__(self, memo: dict):
         mdp = deepcopy(self._mdp)
         return Overcooked(OvercookedEnv.from_mdp(mdp, horizon=self.horizon))
@@ -96,6 +100,10 @@ class Overcooked(MARLEnv[Sequence[int] | npt.NDArray, DiscreteActionSpace]):
         return {"horizon": self.horizon, "mdp": self._mdp}
 
     def __setstate__(self, state: dict):
+        from overcooked_ai_py.mdp.overcooked_mdp import Recipe
+
+        mdp = state["mdp"]
+        Recipe.configure(mdp.recipe_config)
         self.__init__(OvercookedEnv.from_mdp(state["mdp"], horizon=state["horizon"]))
 
     def get_image(self):
@@ -107,7 +115,7 @@ class Overcooked(MARLEnv[Sequence[int] | npt.NDArray, DiscreteActionSpace]):
             ]:
                 rewards_dict[key] = value
 
-        image = self.visualizer.render_state(
+        image = self._visualizer.render_state(
             state=self._oenv.state,
             grid=self._mdp.terrain_mtx,
             hud_data=StateVisualizer.default_hud_data(self._oenv.state, **rewards_dict),

{multi_agent_rlenv-3.3.2 → multi_agent_rlenv-3.3.5}/src/marlenv/models/env.py

@@ -127,7 +127,7 @@ class MARLEnv(ABC, Generic[ActionType, ActionSpaceType]):
 
     def seed(self, seed_value: int):
         """Set the environment seed"""
-        raise NotImplementedError("Method not implemented")
+        return
 
     @abstractmethod
     def get_observation(self) -> Observation:
@@ -158,9 +158,9 @@ class MARLEnv(ABC, Generic[ActionType, ActionSpaceType]):
         """Perform a random step in the environment."""
         return self.step(self.sample_action())
 
+    @abstractmethod
     def reset(self) -> tuple[Observation, State]:
         """Reset the environment and return the initial observation and state."""
-        return self.get_observation(), self.get_state()
 
     def render(self):
         """Render the environment in a window (or in console)"""

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

@@ -162,6 +162,10 @@ def test_overcooked_obs_state():
     height, width = env._mdp.shape
     obs, state = env.reset()
     for i in range(HORIZON):
+        assert obs.data.dtype == np.float32
+        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)

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

@@ -2,6 +2,7 @@ import pickle
 import numpy as np
 import orjson
 import pytest
+import os
 from copy import deepcopy
 
 import marlenv
@@ -156,3 +157,50 @@ def test_pickle_overcooked():
         step = env.step(actions)
         step_restored = restored.step(actions)
         assert step == step_restored
+
+
+@pytest.mark.skipif(not marlenv.adapters.HAS_OVERCOOKED, reason="Overcooked is not installed")
+def test_unpickling_from_blank_process():
+    from marlenv.adapters import Overcooked
+    import pickle
+    import subprocess
+    import tempfile
+
+    env = Overcooked.from_layout("large_room")
+    env_file = tempfile.NamedTemporaryFile("wb", delete=False)
+    pickle.dump(env, env_file)
+    env_file.close()
+
+    # Write the python file
+
+    f = tempfile.NamedTemporaryFile("w", delete=False)
+    f.write("""
+import pickle
+import sys
+
+with open(sys.argv[1], "rb") as f:
+    env = pickle.load(f)
+
+env.reset()""")
+    f.close()
+    try:
+        output = subprocess.run(f"python {f.name} {env_file.name}", shell=True, capture_output=True)
+        assert output.returncode == 0, output.stderr.decode("utf-8")
+    finally:
+        os.remove(f.name)
+        os.remove(env_file.name)
+
+
+@pytest.mark.skipif(not marlenv.adapters.HAS_OVERCOOKED, reason="Overcooked is not installed")
+def test_serialize_json_overcooked():
+    env = marlenv.adapters.Overcooked.from_layout("scenario1_s", horizon=60)
+    res = orjson.dumps(env, option=orjson.OPT_SERIALIZE_NUMPY)
+    deserialized = orjson.loads(res)
+
+    assert deserialized["n_agents"] == env.n_agents
+    assert tuple(deserialized["observation_shape"]) == env.observation_shape
+    assert tuple(deserialized["state_shape"]) == env.state_shape
+    assert tuple(deserialized["extras_shape"]) == env.extras_shape
+    assert deserialized["n_actions"] == env.n_actions
+    assert deserialized["name"] == env.name
+    assert deserialized["extras_meanings"] == env.extras_meanings