multi-agent-rlenv 3.5.5__tar.gz → 3.6.0__tar.gz

{multi_agent_rlenv-3.5.5 → multi_agent_rlenv-3.6.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: multi-agent-rlenv
-Version: 3.5.5
+Version: 3.6.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>
@@ -13,7 +13,8 @@ Requires-Dist: opencv-python>=4.0
 Requires-Dist: typing-extensions>=4.0
 Provides-Extra: all
 Requires-Dist: gymnasium>0.29.1; extra == 'all'
-Requires-Dist: overcooked-ai; extra == 'all'
+Requires-Dist: laser-learning-environment>=2.6.1; extra == 'all'
+Requires-Dist: overcooked>=0.1.0; extra == 'all'
 Requires-Dist: pettingzoo>=1.20; extra == 'all'
 Requires-Dist: pymunk>=6.0; extra == 'all'
 Requires-Dist: pysc2; extra == 'all'
@@ -22,9 +23,10 @@ Requires-Dist: smac; extra == 'all'
 Requires-Dist: torch>=2.0; extra == 'all'
 Provides-Extra: gym
 Requires-Dist: gymnasium>=0.29.1; extra == 'gym'
+Provides-Extra: lle
+Requires-Dist: laser-learning-environment>=2.6.1; extra == 'lle'
 Provides-Extra: overcooked
-Requires-Dist: overcooked-ai>=1.1.0; extra == 'overcooked'
-Requires-Dist: scipy>=1.10; extra == 'overcooked'
+Requires-Dist: overcooked>=0.1.0; extra == 'overcooked'
 Provides-Extra: pettingzoo
 Requires-Dist: pettingzoo>=1.20; extra == 'pettingzoo'
 Requires-Dist: pymunk>=6.0; extra == 'pettingzoo'
@@ -62,9 +64,24 @@ $ pip install marlenv[smac] # Install SMAC
 $ pip install marlenv[gym,smac]  # Install Gym & smac support
 ```
 
+## Using the `marlenv` environment catalog
+Some environments are registered in the `marlenv` and can be easily instantiated via its catalog. 
+
+```python
+from marlenv import catalog
+
+env1 = catalog.Overcooked.from_layout("scenario4")
+env2 = catalog.LLE.level(6)
+env3 = catalog.DeepSea(mex_depth=5)
+```
+Note that using the catalog requires the corresponding environment package to be installed. For instance you need to install the `laser-learning-environment` package to use `catalog.LLE`, which can be done by using the corresponding feature when at installation as shown below.
+```bash
+pip install multi-agent-rlenv[lle]
+```
+
 
 ## Using `marlenv` with existing libraries
-`marlenv` unifies multiple popular libraries under a single interface. Namely, `marlenv` supports `smac`, `gymnasium` and `pettingzoo`.
+`marlenv` provides adapters from most popular libraries to unify them under a single interface. Namely, `marlenv` supports `smac`, `gymnasium` and `pettingzoo`.
 
 ```python
 import marlenv
@@ -74,7 +91,7 @@ gym_env = marlenv.make("CartPole-v1", seed=25)
 
 # You can seemlessly instanciate a SMAC environment and directly pass your required arguments
 from marlenv.adapters import SMAC
-smac_env = env2 = SMAC("3m", debug=True, difficulty="9")
+smac_env = SMAC("3m", debug=True, difficulty="9")
 
 # pettingzoo is also supported
 from pettingzoo.sisl import pursuit_v4

{multi_agent_rlenv-3.5.5 → multi_agent_rlenv-3.6.0}/README.md

@@ -24,9 +24,24 @@ $ pip install marlenv[smac] # Install SMAC
 $ pip install marlenv[gym,smac]  # Install Gym & smac support
 ```
 
+## Using the `marlenv` environment catalog
+Some environments are registered in the `marlenv` and can be easily instantiated via its catalog. 
+
+```python
+from marlenv import catalog
+
+env1 = catalog.Overcooked.from_layout("scenario4")
+env2 = catalog.LLE.level(6)
+env3 = catalog.DeepSea(mex_depth=5)
+```
+Note that using the catalog requires the corresponding environment package to be installed. For instance you need to install the `laser-learning-environment` package to use `catalog.LLE`, which can be done by using the corresponding feature when at installation as shown below.
+```bash
+pip install multi-agent-rlenv[lle]
+```
+
 
 ## Using `marlenv` with existing libraries
-`marlenv` unifies multiple popular libraries under a single interface. Namely, `marlenv` supports `smac`, `gymnasium` and `pettingzoo`.
+`marlenv` provides adapters from most popular libraries to unify them under a single interface. Namely, `marlenv` supports `smac`, `gymnasium` and `pettingzoo`.
 
 ```python
 import marlenv
@@ -36,7 +51,7 @@ gym_env = marlenv.make("CartPole-v1", seed=25)
 
 # You can seemlessly instanciate a SMAC environment and directly pass your required arguments
 from marlenv.adapters import SMAC
-smac_env = env2 = SMAC("3m", debug=True, difficulty="9")
+smac_env = SMAC("3m", debug=True, difficulty="9")
 
 # pettingzoo is also supported
 from pettingzoo.sisl import pursuit_v4

{multi_agent_rlenv-3.5.5 → multi_agent_rlenv-3.6.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "multi-agent-rlenv"
-dynamic = ["version"]
+version = "3.6.0"
 description = "A strongly typed Multi-Agent Reinforcement Learning framework"
 authors = [
     { "name" = "Yannick Molinghen", "email" = "yannick.molinghen@ulb.be" },
@@ -19,14 +19,16 @@ dependencies = ["numpy>=2.0.0", "opencv-python>=4.0", "typing_extensions>=4.0"]
 gym = ["gymnasium>=0.29.1"]
 smac = ["smac", "pysc2"]
 pettingzoo = ["pettingzoo>=1.20", "pymunk>=6.0", "scipy>=1.10"]
-overcooked = ["overcooked-ai>=1.1.0", "scipy>=1.10"]
+overcooked = ["overcooked>=0.1.0"]
+lle = ["laser-learning-environment>=2.6.1"]
 torch = ["torch>=2.0"]
 all = [
     "gymnasium>0.29.1",
     "pettingzoo>=1.20",
-    "overcooked-ai",
+    "overcooked>=0.1.0",
     "smac",
     "pysc2",
+    "laser-learning-environment>=2.6.1",
     "pymunk>=6.0",
     "scipy>=1.10",
     "torch>=2.0",
@@ -42,9 +44,6 @@ line-length = 140
 [tool.hatch.build.targets.wheel]
 packages = ["src/marlenv"]
 
-[tool.hatch]
-version = { "path" = "src/marlenv/__init__.py", "attr" = "__version__" }
-
 
 [tool.pytest.ini_options]
 testpaths = ["tests"]

{multi_agent_rlenv-3.5.5 → multi_agent_rlenv-3.6.0}/src/marlenv/__init__.py

@@ -62,7 +62,13 @@ 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.5.5"
+from importlib.metadata import version, PackageNotFoundError
+
+try:
+    __version__ = version("overcooked")
+except PackageNotFoundError:
+    __version__ = "0.0.0"  # fallback pratique en dev/CI
+
 
 from . import models
 from .models import (
@@ -82,16 +88,19 @@ from .models import (
 
 from . import wrappers
 from . import adapters
-from .env_builder import make, Builder
+from .env_builder import Builder
 from .wrappers import RLEnvWrapper
 from .mock_env import DiscreteMockEnv, DiscreteMOMockEnv
+from . import catalog
+from .adapters import make
 
 __all__ = [
     "models",
+    "make",
+    "catalog",
     "wrappers",
     "adapters",
     "spaces",
-    "make",
     "Builder",
     "MARLEnv",
     "Step",

multi_agent_rlenv-3.6.0/src/marlenv/adapters/__init__.py

@@ -0,0 +1,33 @@
+from importlib.util import find_spec
+from .pymarl_adapter import PymarlAdapter
+from marlenv.utils import DummyClass, dummy_function
+
+HAS_GYM = find_spec("gymnasium") is not None
+if HAS_GYM:
+    from .gym_adapter import Gym, make
+else:
+    Gym = DummyClass("gymnasium")
+    make = dummy_function("gymnasium")
+
+HAS_PETTINGZOO = find_spec("pettingzoo") is not None
+if HAS_PETTINGZOO:
+    from .pettingzoo_adapter import PettingZoo
+else:
+    PettingZoo = DummyClass("pettingzoo")
+
+HAS_SMAC = find_spec("smac") is not None
+if HAS_SMAC:
+    from .smac_adapter import SMAC
+else:
+    SMAC = DummyClass("smac", "https://github.com/oxwhirl/smac.git")
+
+__all__ = [
+    "PymarlAdapter",
+    "Gym",
+    "make",
+    "PettingZoo",
+    "SMAC",
+    "HAS_GYM",
+    "HAS_PETTINGZOO",
+    "HAS_SMAC",
+]

{multi_agent_rlenv-3.5.5 → multi_agent_rlenv-3.6.0}/src/marlenv/adapters/gym_adapter.py

@@ -78,3 +78,9 @@ class Gym(MARLEnv[Space]):
 
     def seed(self, seed_value: int):
         self._gym_env.reset(seed=seed_value)
+
+
+def make(env_id: str, **kwargs):
+    """Make an RLEnv from str (Gym) or PettingZoo"""
+    gym_env = gym.make(env_id, render_mode="rgb_array", **kwargs)
+    return Gym(gym_env)

multi_agent_rlenv-3.6.0/src/marlenv/catalog/__init__.py

@@ -0,0 +1,26 @@
+from importlib.util import find_spec
+from ..utils.import_placeholders import DummyClass
+from marlenv.adapters import SMAC
+from .deepsea import DeepSea
+
+
+HAS_LLE = find_spec("lle") is not None
+if HAS_LLE:
+    from lle import LLE  # pyright: ignore[reportMissingImports]
+else:
+    LLE = DummyClass("lle", "laser-learning-environment")
+
+HAS_OVERCOOKED = find_spec("overcooked") is not None
+if HAS_OVERCOOKED:
+    from overcooked import Overcooked  # pyright: ignore[reportMissingImports]
+else:
+    Overcooked = DummyClass("overcooked", "overcooked")
+
+__all__ = [
+    "Overcooked",
+    "SMAC",
+    "LLE",
+    "DeepSea",
+    "HAS_LLE",
+    "HAS_OVERCOOKED",
+]

multi_agent_rlenv-3.6.0/src/marlenv/catalog/deepsea.py

@@ -0,0 +1,73 @@
+from typing import Sequence
+import numpy as np
+from marlenv import MARLEnv, MultiDiscreteSpace, DiscreteSpace, Observation, State, Step
+from dataclasses import dataclass
+
+
+LEFT = 0
+RIGHT = 1
+
+
+@dataclass
+class DeepSea(MARLEnv[MultiDiscreteSpace]):
+    """
+    Deep Sea single-agent environment to test for deep exploration. The probability of reaching the goal state under random exploration is 2^(-max_depth).
+
+    The agent explores a 2D grid where the bottom-right corner (max_depth, max_depth) is the goal and is the only state to yield a reward.
+    The agent starts in the top-left corner (0, 0).
+    The agent has two actions: left or right, and taking an action makes the agent dive one row deeper. The agent can not go beyond the grid boundaries.
+    Going right gives a penalty of (0.01 / max_depth).
+    """
+
+    max_depth: int
+
+    def __init__(self, max_depth: int):
+        super().__init__(
+            n_agents=1,
+            action_space=DiscreteSpace(size=2, labels=["left", "right"]).repeat(1),
+            observation_shape=(2,),
+            state_shape=(2,),
+        )
+        self.max_depth = max_depth
+        self._row = 0
+        self._col = 0
+        self._step_right_penalty = -0.01 / self.max_depth
+
+    def get_observation(self) -> Observation:
+        return Observation(np.array([self._row, self._col], dtype=np.float32), self.available_actions())
+
+    def get_state(self) -> State:
+        return State(np.array([self._row, self._col], dtype=np.float32))
+
+    def reset(self):
+        self._row = 0
+        self._col = 0
+        return self.get_observation(), self.get_state()
+
+    def step(self, action: Sequence[int]):
+        self._row += 1
+        if action[0] == LEFT:
+            self._col -= 1
+        else:
+            self._col += 1
+        self._col = max(0, self._col)
+        if action[0] == RIGHT:
+            if self._row == self.max_depth:
+                reward = 1.0
+            else:
+                reward = self._step_right_penalty
+        else:
+            reward = 0.0
+        return Step(
+            self.get_observation(),
+            self.get_state(),
+            reward,
+            done=self._row == self.max_depth,
+        )
+
+    def set_state(self, state: State):
+        self._row, self._col = state.data
+
+    @property
+    def agent_state_size(self):
+        return 2

{multi_agent_rlenv-3.5.5 → multi_agent_rlenv-3.6.0}/src/marlenv/env_builder.py

@@ -1,73 +1,13 @@
 from dataclasses import dataclass
-from typing import Generic, Literal, Optional, TypeVar, overload
+from typing import Generic, Literal, Optional, TypeVar
 import numpy as np
 import numpy.typing as npt
 
 from . import wrappers
-from marlenv import adapters
 from .models import Space, MARLEnv
 
 AS = TypeVar("AS", bound=Space)
 
-if adapters.HAS_PETTINGZOO:
-    from .adapters import PettingZoo
-    from pettingzoo import ParallelEnv
-
-    @overload
-    def make(env: ParallelEnv) -> PettingZoo: ...
-
-
-if adapters.HAS_GYM:
-    from .adapters import Gym
-    from gymnasium import Env
-    import gymnasium
-
-    @overload
-    def make(env: Env) -> Gym: ...
-
-    @overload
-    def make(env: str, **kwargs) -> Gym:
-        """
-        Make an RLEnv from the `gymnasium` registry (e.g: "CartPole-v1").
-        """
-
-
-if adapters.HAS_SMAC:
-    from .adapters import SMAC
-    from smac.env import StarCraft2Env
-
-    @overload
-    def make(env: StarCraft2Env) -> SMAC: ...
-
-
-if adapters.HAS_OVERCOOKED:
-    from .adapters import Overcooked
-    from overcooked_ai_py.mdp.overcooked_env import OvercookedEnv
-
-    @overload
-    def make(env: OvercookedEnv) -> Overcooked: ...
-
-
-def make(env, **kwargs):
-    """Make an RLEnv from str (Gym) or PettingZoo"""
-    match env:
-        case MARLEnv():
-            return env
-        case str(env_id):
-            if adapters.HAS_GYM:
-                gym_env = gymnasium.make(env_id, render_mode="rgb_array", **kwargs)
-                return Gym(gym_env)
-
-    if adapters.HAS_PETTINGZOO and isinstance(env, ParallelEnv):
-        return PettingZoo(env)  # type: ignore
-    if adapters.HAS_SMAC and isinstance(env, StarCraft2Env):
-        return SMAC(env)
-    if adapters.HAS_OVERCOOKED and isinstance(env, OvercookedEnv):
-        return Overcooked(env)  # type: ignore
-    if adapters.HAS_GYM and isinstance(env, Env):
-        return Gym(env)
-    raise ValueError(f"Unknown environment type: {type(env)}")
-
 
 @dataclass
 class Builder(Generic[AS]):

{multi_agent_rlenv-3.5.5 → multi_agent_rlenv-3.6.0}/src/marlenv/models/spaces.py

@@ -105,7 +105,7 @@ class MultiDiscreteSpace(Space):
     def sample(self, mask: Optional[npt.NDArray[np.bool] | list[npt.NDArray[np.bool]]] = None):
         if mask is None:
             return np.array([space.sample() for space in self.spaces], dtype=np.int32)
-        return np.array([space.sample(mask=mask) for mask, space in zip(mask, self.spaces)], dtype=np.int32)
+        return np.array([space.sample(mask=mask) for mask, space in zip(mask, self.spaces)], dtype=np.int32)  # type: ignore
 
     def __eq__(self, value: object) -> bool:
         if not isinstance(value, MultiDiscreteSpace):

{multi_agent_rlenv-3.5.5 → multi_agent_rlenv-3.6.0}/src/marlenv/utils/__init__.py

@@ -1,5 +1,6 @@
 from .cached_property_collector import CachedPropertyCollector, CachedPropertyInvalidator
 from .schedule import ExpSchedule, LinearSchedule, MultiSchedule, RoundedSchedule, Schedule
+from .import_placeholders import DummyClass, dummy_function
 
 __all__ = [
     "Schedule",
@@ -9,4 +10,6 @@ __all__ = [
     "RoundedSchedule",
     "CachedPropertyCollector",
     "CachedPropertyInvalidator",
+    "DummyClass",
+    "dummy_function",
 ]

multi_agent_rlenv-3.6.0/src/marlenv/utils/import_placeholders.py

@@ -0,0 +1,30 @@
+from typing import Optional, Any
+
+
+class DummyClass:
+    def __init__(self, module_name: str, package_name: Optional[str] = None):
+        self.module_name = module_name
+        if package_name is None:
+            self.package_name = module_name
+        else:
+            self.package_name = package_name
+
+    def _raise_error(self):
+        raise ImportError(
+            f"The optional dependency `{self.module_name}` is not installed.\nInstall the `{self.package_name}` package (e.g. pip install {self.package_name})."
+        )
+
+    def __getattr__(self, _):
+        self._raise_error()
+
+    def __call__(self, *args, **kwargs):
+        self._raise_error()
+
+
+def dummy_function(module_name: str, package_name: Optional[str] = None):
+    dummy = DummyClass(module_name, package_name)
+
+    def fail(*args, **kwargs) -> Any:
+        dummy()
+
+    return fail

{multi_agent_rlenv-3.5.5 → multi_agent_rlenv-3.6.0}/src/marlenv/utils/schedule.py

@@ -1,6 +1,6 @@
 from abc import abstractmethod
 from dataclasses import dataclass
-from typing import Callable, Optional, TypeVar
+from typing import Any, Callable, Optional, TypeVar
 
 T = TypeVar("T")
 
@@ -142,6 +142,21 @@ class Schedule:
     def __int__(self) -> int:
         return int(self.value)
 
+    @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":
+            raise NotImplementedError("ArbitrarySchedule cannot be deserialized from JSON")
+        else:
+            raise ValueError(f"Unknown schedule type: {classname}")
+
 
 @dataclass(eq=False)
 class LinearSchedule(Schedule):

{multi_agent_rlenv-3.5.5 → multi_agent_rlenv-3.6.0}/tests/test_adapters.py

@@ -8,9 +8,6 @@ from marlenv.adapters import PymarlAdapter
 skip_gym = not marlenv.adapters.HAS_GYM
 skip_pettingzoo = not marlenv.adapters.HAS_PETTINGZOO
 skip_smac = not marlenv.adapters.HAS_SMAC
-# Check for "overcooked_ai_py.mdp" specifically because after uninstalling, the package
-# can still be found because of some remaining .pkl file.
-skip_overcooked = not marlenv.adapters.HAS_OVERCOOKED
 
 
 @pytest.mark.skipif(skip_gym, reason="Gymnasium is not installed")
@@ -80,10 +77,9 @@ def test_pettingzoo_adapter_discrete_action():
 
 @pytest.mark.skipif(skip_pettingzoo, reason="PettingZoo is not installed")
 def test_pettingzoo_adapter_continuous_action():
-    from pettingzoo.sisl import waterworld_v4
+    from pettingzoo.mpe import simple_v3
 
-    # https://pettingzoo.farama.org/environments/sisl/waterworld/
-    env = marlenv.adapters.PettingZoo(waterworld_v4.parallel_env())
+    env = marlenv.adapters.PettingZoo(simple_v3.parallel_env(continuous_actions=True))
     env.reset()
     action = env.action_space.sample()
     step = env.step(action)
@@ -93,8 +89,8 @@ def test_pettingzoo_adapter_continuous_action():
     assert isinstance(step.done, bool)
     assert isinstance(step.truncated, bool)
     assert isinstance(step.info, dict)
-    assert env.n_actions == 2
-    assert env.n_agents == 2
+    assert env.n_actions == 5
+    assert env.n_agents == 1
     assert isinstance(env.action_space, ContinuousSpace)
 
 
@@ -135,105 +131,6 @@ def test_smac_render():
     env.render()
 
 
-@pytest.mark.skipif(skip_overcooked, reason="Overcooked is not installed")
-def test_overcooked_attributes():
-    from overcooked_ai_py.mdp.overcooked_mdp import Action
-
-    from marlenv.adapters import Overcooked
-
-    env = Overcooked.from_layout("simple_o")
-    height, width = env._mdp.shape
-    assert env.n_agents == 2
-    assert env.n_actions == Action.NUM_ACTIONS
-    assert env.observation_shape == (25, height, width)
-    assert env.reward_space.shape == (1,)
-    assert env.extras_shape == (2,)
-    assert not env.is_multi_objective
-
-
-@pytest.mark.skipif(skip_overcooked, reason="Overcooked is not installed")
-def test_overcooked_obs_state():
-    from marlenv.adapters import Overcooked
-
-    HORIZON = 100
-    env = Overcooked.from_layout("coordination_ring", horizon=HORIZON)
-    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 == (25, height, width)
-        assert obs.extras_shape == (2,)
-        assert state.shape == (25, height, width)
-        assert state.extras_shape == (2,)
-
-        assert np.all(obs.extras[:, 0] == i / HORIZON)
-        assert np.all(state.extras[0] == i / HORIZON)
-
-        step = env.random_step()
-        obs = step.obs
-        state = step.state
-        if i < HORIZON - 1:
-            assert not step.done
-        else:
-            assert step.done
-
-
-@pytest.mark.skipif(skip_overcooked, reason="Overcooked is not installed")
-def test_overcooked_shaping():
-    from marlenv.adapters import Overcooked
-
-    UP = 0
-    RIGHT = 2
-    STAY = 4
-    INTERACT = 5
-    grid = [
-        ["X", "X", "X", "D", "X"],
-        ["X", "O", "S", "2", "X"],
-        ["X", "1", "P", " ", "X"],
-        ["X", "T", "S", " ", "X"],
-        ["X", "X", "X", "X", "X"],
-    ]
-
-    env = Overcooked.from_grid(grid)
-    env.reset()
-    actions_rewards = [
-        ([UP, STAY], False),
-        ([INTERACT, STAY], False),
-        ([RIGHT, STAY], False),
-        ([INTERACT, STAY], True),
-    ]
-
-    for action, expected_reward in actions_rewards:
-        step = env.step(action)
-        if expected_reward:
-            assert step.reward.item() > 0
-
-
-@pytest.mark.skipif(skip_overcooked, reason="Overcooked is not installed")
-def test_overcooked_name():
-    from marlenv.adapters import Overcooked
-
-    grid = [
-        ["X", "X", "X", "D", "X"],
-        ["X", "O", "S", "2", "X"],
-        ["X", "1", "P", " ", "X"],
-        ["X", "T", "S", " ", "X"],
-        ["X", "X", "X", "X", "X"],
-    ]
-
-    env = Overcooked.from_grid(grid)
-    assert env.name == "Overcooked-custom-layout"
-
-    env = Overcooked.from_grid(grid, layout_name="my incredible grid")
-    assert env.name == "Overcooked-my incredible grid"
-
-    env = Overcooked.from_layout("asymmetric_advantages")
-    assert env.name == "Overcooked-asymmetric_advantages"
-
-
 def test_pymarl():
     LIMIT = 20
     N_AGENTS = 2

multi_agent_rlenv-3.6.0/tests/test_catalog.py

@@ -0,0 +1,41 @@
+import pytest
+from marlenv import catalog
+from marlenv.utils import DummyClass, dummy_function
+
+skip_lle = isinstance(catalog.LLE, DummyClass)
+skip_overcooked = isinstance(catalog.Overcooked, DummyClass)
+
+
+@pytest.mark.skipif(skip_lle, reason="LLE is not installed")
+def test_lle():
+    catalog.LLE.level(1)
+
+
+@pytest.mark.skipif(skip_overcooked, reason="Overcooked is not installed")
+def test_overcooked():
+    catalog.Overcooked.from_layout("scenario4")
+
+
+def test_dummy_class():
+    try:
+        x = DummyClass("")
+        x.abc
+        assert False, "Expected ImportError upon usage because DummyClass is not installed"
+    except ImportError:
+        pass
+
+    try:
+        x = DummyClass("")
+        x.abc()
+        assert False, "Expected ImportError upon usage because DummyClass is not installed"
+    except ImportError:
+        pass
+
+
+def test_dummy_function():
+    try:
+        f = dummy_function("")
+        f()
+        assert False, "Expected ImportError upon usage because dummy_function is not installed"
+    except ImportError:
+        pass

multi_agent_rlenv-3.6.0/tests/test_others.py

@@ -0,0 +1,6 @@
+import marlenv
+
+
+def test_version():
+    assert hasattr(marlenv, "__version__")
+    x, y, z = marlenv.__version__.split(".")

{multi_agent_rlenv-3.5.5 → multi_agent_rlenv-3.6.0}/tests/test_schedules.py

@@ -153,3 +153,18 @@ def test_inequality_different_schedules():
     s3 = Schedule.linear(1, 2, 10)
     assert s1 != s2
     assert not s1 != s3
+
+
+def test_from_json():
+    json_data = {"name": "LinearSchedule", "start_value": 0, "end_value": 1, "n_steps": 10}
+    s = Schedule.from_json(json_data)
+    assert isinstance(s, Schedule)
+    assert is_close(s.value, 0)
+    s.update()
+    assert is_close(s.value, 0.1)
+    s.update(5)
+    assert is_close(s.value, 0.5)
+    s.update(10)
+    assert is_close(s.value, 1.0)
+    s.update(15)
+    assert is_close(s.value, 1.0)

{multi_agent_rlenv-3.5.5 → multi_agent_rlenv-3.6.0}/tests/test_serialization.py

@@ -1,9 +1,8 @@
 import pickle
+
 import numpy as np
 import orjson
 import pytest
-import os
-from copy import deepcopy
 
 import marlenv
 from marlenv import DiscreteMockEnv, wrappers
@@ -193,87 +192,6 @@ def test_serialize_episode():
     _ = orjson.dumps(episode, option=orjson.OPT_SERIALIZE_NUMPY)
 
 
-@pytest.mark.skipif(not marlenv.adapters.HAS_OVERCOOKED, reason="Overcooked is not installed")
-def test_deepcopy_overcooked():
-    env = marlenv.adapters.Overcooked.from_layout("scenario4")
-    env2 = deepcopy(env)
-    assert env == env2
-
-
-@pytest.mark.skipif(not marlenv.adapters.HAS_OVERCOOKED, reason="Overcooked is not installed")
-def test_deepcopy_overcooked_schedule():
-    env = marlenv.adapters.Overcooked.from_layout("scenario4", reward_shaping_factor=Schedule.linear(1, 0, 10))
-    env2 = deepcopy(env)
-    assert env == env2
-
-    env.random_step()
-    assert not env == env2, "The reward shaping factor should be different"
-
-
-@pytest.mark.skipif(not marlenv.adapters.HAS_OVERCOOKED, reason="Overcooked is not installed")
-def test_pickle_overcooked():
-    env = marlenv.adapters.Overcooked.from_layout("scenario1_s", horizon=60)
-    serialized = pickle.dumps(env)
-    restored = pickle.loads(serialized)
-    assert env == restored
-
-    env.reset()
-    restored.reset()
-
-    for _ in range(50):
-        actions = env.sample_action()
-        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
-
-
 @pytest.mark.skipif(not marlenv.adapters.HAS_GYM, reason="Gymnasium is not installed")
 def test_json_serialize_gym():
     env = marlenv.make("CartPole-v1")

multi_agent_rlenv-3.5.5/src/marlenv/adapters/__init__.py

@@ -1,42 +0,0 @@
-from importlib.util import find_spec
-from .pymarl_adapter import PymarlAdapter
-
-HAS_GYM = False
-if find_spec("gymnasium") is not None:
-    from .gym_adapter import Gym
-
-    HAS_GYM = True
-
-HAS_PETTINGZOO = False
-if find_spec("pettingzoo") is not None:
-    from .pettingzoo_adapter import PettingZoo
-
-    HAS_PETTINGZOO = True
-
-HAS_SMAC = False
-if find_spec("smac") is not None:
-    from .smac_adapter import SMAC
-
-    HAS_SMAC = True
-
-HAS_OVERCOOKED = False
-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.
-    setattr(numpy, "Inf", numpy.inf)
-    from .overcooked_adapter import Overcooked
-
-    HAS_OVERCOOKED = True
-
-__all__ = [
-    "PymarlAdapter",
-    "Gym",
-    "PettingZoo",
-    "SMAC",
-    "Overcooked",
-    "HAS_GYM",
-    "HAS_PETTINGZOO",
-    "HAS_SMAC",
-    "HAS_OVERCOOKED",
-]

multi_agent_rlenv-3.5.5/src/marlenv/adapters/overcooked_adapter.py

@@ -1,241 +0,0 @@
-import sys
-from dataclasses import dataclass
-from typing import Literal, Sequence, Optional
-from copy import deepcopy
-
-import cv2
-import numpy as np
-import numpy.typing as npt
-import pygame
-from marlenv.models import ContinuousSpace, DiscreteSpace, MARLEnv, Observation, State, Step, MultiDiscreteSpace
-from marlenv.utils import Schedule
-
-from overcooked_ai_py.mdp.overcooked_env import OvercookedEnv
-from overcooked_ai_py.mdp.overcooked_mdp import Action, OvercookedGridworld, OvercookedState
-from overcooked_ai_py.visualization.state_visualizer import StateVisualizer
-
-
-@dataclass
-class Overcooked(MARLEnv[MultiDiscreteSpace]):
-    horizon: int
-    shaping_factor: Schedule
-
-    def __init__(
-        self,
-        oenv: OvercookedEnv,
-        shaping_factor: float | Schedule = 1.0,
-        name_suffix: Optional[str] = None,
-    ):
-        if isinstance(shaping_factor, (int, float)):
-            shaping_factor = Schedule.constant(shaping_factor)
-        self.shaping_factor = shaping_factor
-        self._oenv = oenv
-        assert isinstance(oenv.mdp, OvercookedGridworld)
-        self._mdp = oenv.mdp
-        self._visualizer = StateVisualizer()
-        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__(
-            n_agents=self._mdp.num_players,
-            action_space=DiscreteSpace(Action.NUM_ACTIONS, labels=[Action.ACTION_TO_CHAR[a] for a in Action.ALL_ACTIONS]).repeat(
-                self._mdp.num_players
-            ),
-            observation_shape=shape,
-            extras_shape=(2,),
-            extras_meanings=["timestep", "urgent"],
-            state_shape=shape,
-            state_extra_shape=(2,),
-            reward_space=ContinuousSpace.from_shape(1),
-        )
-        self.horizon = int(self._oenv.horizon)
-        if name_suffix is not None:
-            self.name = f"{self.name}-{name_suffix}"
-
-    @property
-    def state(self) -> OvercookedState:
-        """Current state of the environment"""
-        return self._oenv.state
-
-    def set_state(self, state: State):
-        raise NotImplementedError("Not yet implemented")
-
-    @property
-    def time_step(self):
-        return self.state.timestep
-
-    def _state_data(self):
-        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))
-        # 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):
-        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=data,
-            available_actions=self.available_actions(),
-            extras=np.array([[self.time_step / self.horizon, is_urgent]] * self.n_agents, dtype=np.float32),
-        )
-
-    def available_actions(self):
-        available_actions = np.full((self.n_agents, self.n_actions), False)
-        actions = self._mdp.get_actions(self._oenv.state)
-        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, dtype=np.bool)
-
-    def step(self, actions: Sequence[int] | np.ndarray) -> Step:
-        self.shaping_factor.update()
-        actions = [Action.ALL_ACTIONS[a] for a in actions]
-        _, reward, done, info = self._oenv.step(actions, display_phi=True)
-
-        reward += sum(info["shaped_r_by_agent"]) * self.shaping_factor
-        return Step(
-            obs=self.get_observation(),
-            state=self.get_state(),
-            reward=np.array([reward], dtype=np.float32),
-            done=done,
-            truncated=False,
-            info=info,
-        )
-
-    def reset(self):
-        self._oenv.reset()
-        return self.get_observation(), self.get_state()
-
-    def __deepcopy__(self, _):
-        """
-        Note: a specific implementation is needed because `pygame.font.Font` objects are not deep-copiable by default.
-        """
-        mdp = deepcopy(self._mdp)
-        copy = Overcooked(OvercookedEnv.from_mdp(mdp, horizon=self.horizon), deepcopy(self.shaping_factor))
-        copy.name = self.name
-        return copy
-
-    def __getstate__(self):
-        return {"horizon": self.horizon, "mdp": self._mdp, "name": self.name, "schedule": self.shaping_factor}
-
-    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"]), shaping_factor=state["schedule"])
-        self.name = state["name"]
-
-    def get_image(self):
-        rewards_dict = {}  # dictionary of details you want rendered in the UI
-        for key, value in self._oenv.game_stats.items():
-            if key in [
-                "cumulative_shaped_rewards_by_agent",
-                "cumulative_sparse_rewards_by_agent",
-            ]:
-                rewards_dict[key] = value
-
-        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),
-        )
-
-        image = pygame.surfarray.array3d(image)
-        image = np.flip(np.rot90(image, 3), 1)
-        # Depending on the platform, the image may need to be converted to RGB
-        if sys.platform in ("linux", "linux2"):
-            image = cv2.cvtColor(image, cv2.COLOR_RGB2BGR)
-        return image
-
-    @staticmethod
-    def from_layout(
-        layout: Literal[
-            "asymmetric_advantages",
-            "asymmetric_advantages_tomato",
-            "bonus_order_test",
-            "bottleneck",
-            "centre_objects",
-            "centre_pots",
-            "coordination_ring",
-            "corridor",
-            "counter_circuit",
-            "counter_circuit_o_1order",
-            "cramped_corridor",
-            "cramped_room",
-            "cramped_room_o_3orders",
-            "cramped_room_single",
-            "cramped_room_tomato",
-            "five_by_five",
-            "forced_coordination",
-            "forced_coordination_tomato",
-            "inverse_marshmallow_experiment",
-            "large_room",
-            "long_cook_time",
-            "marshmallow_experiment_coordination",
-            "marshmallow_experiment",
-            "mdp_test",
-            "m_shaped_s",
-            "multiplayer_schelling",
-            "pipeline",
-            "scenario1_s",
-            "scenario2",
-            "scenario2_s",
-            "scenario3",
-            "scenario4",
-            "schelling",
-            "schelling_s",
-            "simple_o",
-            "simple_o_t",
-            "simple_tomato",
-            "small_corridor",
-            "soup_coordination",
-            "tutorial_0",
-            "tutorial_1",
-            "tutorial_2",
-            "tutorial_3",
-            "unident",
-            "you_shall_not_pass",
-        ],
-        horizon: int = 400,
-        reward_shaping_factor: float | Schedule = 1.0,
-    ):
-        mdp = OvercookedGridworld.from_layout_name(layout)
-        return Overcooked(OvercookedEnv.from_mdp(mdp, horizon=horizon, info_level=0), reward_shaping_factor, layout)
-
-    @staticmethod
-    def from_grid(
-        grid: Sequence[Sequence[Literal["S", "P", "X", "O", "D", "T", "1", "2", " "] | str]],
-        horizon: int = 400,
-        shaping_factor: float | Schedule = 1.0,
-        layout_name: Optional[str] = None,
-    ):
-        """
-        Create an Overcooked environment from a grid layout where
-        - S is a serving location
-        - P is a cooking pot
-        - X is a counter
-        - O is an onion dispenser
-        - D is a dish dispenser
-        - T is a tomato dispenser
-        - 1 is a player 1 starting location
-        - 2 is a player 2 starting location
-        - ' ' is a walkable space
-
-        If provided, `custom_name` is added to the environment name.
-        """
-        # It is necessary to add an explicit layout name because Overcooked saves some files under this
-        # name. By default the name is a concatenation of the grid elements, which may include characters
-        # such as white spaces, pipes ('|') and square brackets ('[' and ']') that are invalid Windows file paths.
-        if layout_name is None:
-            layout_name = "custom-layout"
-        mdp = OvercookedGridworld.from_grid(grid, base_layout_params={"layout_name": layout_name})
-
-        return Overcooked(OvercookedEnv.from_mdp(mdp, horizon=horizon, info_level=0), shaping_factor, layout_name)