multi-agent-rlenv 3.7.2__tar.gz → 3.7.4__tar.gz

multi_agent_rlenv-3.7.4/PKG-INFO

@@ -0,0 +1,156 @@
+Metadata-Version: 2.4
+Name: multi-agent-rlenv
+Version: 3.7.4
+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.12
+Requires-Dist: numpy>=2.0.0
+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: 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: scipy>=1.10; extra == 'all'
+Requires-Dist: smacv2; 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>=0.1.0; extra == 'overcooked'
+Provides-Extra: pettingzoo
+Requires-Dist: pettingzoo>=1.20; extra == 'pettingzoo'
+Requires-Dist: pymunk>=6.0; extra == 'pettingzoo'
+Requires-Dist: scipy>=1.10; extra == 'pettingzoo'
+Provides-Extra: smac
+Requires-Dist: pysc2; extra == 'smac'
+Requires-Dist: smacv2; extra == 'smac'
+Provides-Extra: torch
+Requires-Dist: torch>=2.0; extra == 'torch'
+Description-Content-Type: text/markdown
+
+# `marlenv` - A unified framework for muti-agent reinforcement learning
+**Documentation: [https://yamoling.github.io/multi-agent-rlenv](https://yamoling.github.io/multi-agent-rlenv)**
+
+`marlenv` is a strongly typed library for multi-agent and multi-objective reinforcement learning.
+
+Install the library with
+```sh
+$ pip install multi-agent-rlenv      # Basics
+$ pip install multi-agent-rlenv[all] # With all optional dependecies
+$ pip install multi-agent-rlenv[smac,overcooked] # Only SMACv2 & Overcooked
+```
+
+It aims to provide a simple and consistent interface for reinforcement learning environments by providing abstraction models such as `Observation`s or `Episode`s. `marlenv` provides adapters for popular libraries such as `gym` or `pettingzoo` and provides utility wrappers to add functionalities such as video recording or limiting the number of steps.
+
+Almost every class is a dataclass to enable seemless serialiation with the `orjson` library.
+
+# Fundamentals
+## States & Observations
+`MARLEnv.reset()` returns a pair of `(Observation, State)` and `MARLEnv.step()` returns a `Step`.
+
+- `Observation` contains:
+  - `data`: shape `[n_agents, *observation_shape]`
+  - `available_actions`: boolean mask `[n_agents, n_actions]`
+  - `extras`: extra features per agent (default shape `(n_agents, 0)`)
+- `State` represents the environment state and can also carry `extras`.
+- `Step` bundles `obs`, `state`, `reward`, `done`, `truncated`, and `info`.
+
+Rewards are stored as `np.float32` arrays. Multi-objective envs use reward vectors with `reward_space.size > 1`.
+
+## Extras
+Extras are auxiliary features appended by wrappers (agent id, last action, time ratio, available actions, ...).
+Wrappers that add extras must update both `extras_shape` and `extras_meanings` so downstream users can interpret them.
+`State` extras should stay in sync with `Observation` extras when applicable.
+
+# Environment catalog
+`marlenv.catalog` exposes curated environments and lazily imports optional dependencies.
+
+```python
+from marlenv import catalog
+
+env1 = catalog.overcooked().from_layout("scenario4")
+env2 = catalog.lle().level(6)
+env3 = catalog.DeepSea(mex_depth=5)
+```
+
+Catalog entries require their corresponding extras at install time (e.g., `marlenv[overcooked]`, `marlenv[lle]`).
+
+# Wrappers & builders
+Wrappers are composable through `RLEnvWrapper` and can be chained via `Builder` for fluent configuration.
+
+```python
+from marlenv import Builder
+from marlenv.adapters import SMAC
+
+env = (
+    Builder(SMAC("3m"))
+    .agent_id()
+    .time_limit(20)
+    .available_actions()
+    .build()
+)
+```
+
+Common wrappers include time limits, delayed rewards, masking available actions, and video recording.
+
+# Using the library
+## Adapters for existing libraries
+Adapters normalize external APIs into `MARLEnv`:
+
+```python
+import marlenv
+
+gym_env = marlenv.make("CartPole-v1", seed=25)
+
+from marlenv.adapters import SMAC
+smac_env = SMAC("3m", debug=True, difficulty="9")
+
+from pettingzoo.sisl import pursuit_v4
+from marlenv.adapters import PettingZoo
+env = PettingZoo(pursuit_v4.parallel_env())
+```
+
+## Designing a custom environment
+Create a custom environment by inheriting from `MARLEnv` and implementing `reset`, `step`, `get_observation`, and `get_state`.
+
+```python
+import numpy as np
+from marlenv import MARLEnv, DiscreteSpace, Observation, State, Step
+
+class CustomEnv(MARLEnv[DiscreteSpace]):
+    def __init__(self):
+        super().__init__(
+            n_agents=3,
+            action_space=DiscreteSpace.action(5).repeat(3),
+            observation_shape=(4,),
+            state_shape=(2,),
+        )
+        self.t = 0
+
+    def reset(self):
+        self.t = 0
+        return self.get_observation(), self.get_state()
+
+    def step(self, action):
+        self.t += 1
+        return Step(self.get_observation(), self.get_state(), reward=0.0, done=False)
+
+    def get_observation(self):
+        return Observation(np.zeros((3, 4), dtype=np.float32), self.available_actions())
+
+    def get_state(self):
+        return State(np.array([self.t, 0], dtype=np.float32))
+```
+
+# Related projects
+- MARL: Collection of multi-agent reinforcement learning algorithms based on `marlenv` [https://github.com/yamoling/marl](https://github.com/yamoling/marl)
+- Laser Learning Environment: a multi-agent gridworld that leverages `marlenv`'s capabilities [https://pypi.org/project/laser-learning-environment/](https://pypi.org/project/laser-learning-environment/)

multi_agent_rlenv-3.7.4/README.md

@@ -0,0 +1,117 @@
+# `marlenv` - A unified framework for muti-agent reinforcement learning
+**Documentation: [https://yamoling.github.io/multi-agent-rlenv](https://yamoling.github.io/multi-agent-rlenv)**
+
+`marlenv` is a strongly typed library for multi-agent and multi-objective reinforcement learning.
+
+Install the library with
+```sh
+$ pip install multi-agent-rlenv      # Basics
+$ pip install multi-agent-rlenv[all] # With all optional dependecies
+$ pip install multi-agent-rlenv[smac,overcooked] # Only SMACv2 & Overcooked
+```
+
+It aims to provide a simple and consistent interface for reinforcement learning environments by providing abstraction models such as `Observation`s or `Episode`s. `marlenv` provides adapters for popular libraries such as `gym` or `pettingzoo` and provides utility wrappers to add functionalities such as video recording or limiting the number of steps.
+
+Almost every class is a dataclass to enable seemless serialiation with the `orjson` library.
+
+# Fundamentals
+## States & Observations
+`MARLEnv.reset()` returns a pair of `(Observation, State)` and `MARLEnv.step()` returns a `Step`.
+
+- `Observation` contains:
+  - `data`: shape `[n_agents, *observation_shape]`
+  - `available_actions`: boolean mask `[n_agents, n_actions]`
+  - `extras`: extra features per agent (default shape `(n_agents, 0)`)
+- `State` represents the environment state and can also carry `extras`.
+- `Step` bundles `obs`, `state`, `reward`, `done`, `truncated`, and `info`.
+
+Rewards are stored as `np.float32` arrays. Multi-objective envs use reward vectors with `reward_space.size > 1`.
+
+## Extras
+Extras are auxiliary features appended by wrappers (agent id, last action, time ratio, available actions, ...).
+Wrappers that add extras must update both `extras_shape` and `extras_meanings` so downstream users can interpret them.
+`State` extras should stay in sync with `Observation` extras when applicable.
+
+# Environment catalog
+`marlenv.catalog` exposes curated environments and lazily imports optional dependencies.
+
+```python
+from marlenv import catalog
+
+env1 = catalog.overcooked().from_layout("scenario4")
+env2 = catalog.lle().level(6)
+env3 = catalog.DeepSea(mex_depth=5)
+```
+
+Catalog entries require their corresponding extras at install time (e.g., `marlenv[overcooked]`, `marlenv[lle]`).
+
+# Wrappers & builders
+Wrappers are composable through `RLEnvWrapper` and can be chained via `Builder` for fluent configuration.
+
+```python
+from marlenv import Builder
+from marlenv.adapters import SMAC
+
+env = (
+    Builder(SMAC("3m"))
+    .agent_id()
+    .time_limit(20)
+    .available_actions()
+    .build()
+)
+```
+
+Common wrappers include time limits, delayed rewards, masking available actions, and video recording.
+
+# Using the library
+## Adapters for existing libraries
+Adapters normalize external APIs into `MARLEnv`:
+
+```python
+import marlenv
+
+gym_env = marlenv.make("CartPole-v1", seed=25)
+
+from marlenv.adapters import SMAC
+smac_env = SMAC("3m", debug=True, difficulty="9")
+
+from pettingzoo.sisl import pursuit_v4
+from marlenv.adapters import PettingZoo
+env = PettingZoo(pursuit_v4.parallel_env())
+```
+
+## Designing a custom environment
+Create a custom environment by inheriting from `MARLEnv` and implementing `reset`, `step`, `get_observation`, and `get_state`.
+
+```python
+import numpy as np
+from marlenv import MARLEnv, DiscreteSpace, Observation, State, Step
+
+class CustomEnv(MARLEnv[DiscreteSpace]):
+    def __init__(self):
+        super().__init__(
+            n_agents=3,
+            action_space=DiscreteSpace.action(5).repeat(3),
+            observation_shape=(4,),
+            state_shape=(2,),
+        )
+        self.t = 0
+
+    def reset(self):
+        self.t = 0
+        return self.get_observation(), self.get_state()
+
+    def step(self, action):
+        self.t += 1
+        return Step(self.get_observation(), self.get_state(), reward=0.0, done=False)
+
+    def get_observation(self):
+        return Observation(np.zeros((3, 4), dtype=np.float32), self.available_actions())
+
+    def get_state(self):
+        return State(np.array([self.t, 0], dtype=np.float32))
+```
+
+# Related projects
+- MARL: Collection of multi-agent reinforcement learning algorithms based on `marlenv` [https://github.com/yamoling/marl](https://github.com/yamoling/marl)
+- Laser Learning Environment: a multi-agent gridworld that leverages `marlenv`'s capabilities [https://pypi.org/project/laser-learning-environment/](https://pypi.org/project/laser-learning-environment/)

{multi_agent_rlenv-3.7.2 → multi_agent_rlenv-3.7.4}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "multi-agent-rlenv"
-version = "3.7.2"
+version = "3.7.4"
 description = "A strongly typed Multi-Agent Reinforcement Learning framework"
 authors = [
     { "name" = "Yannick Molinghen", "email" = "yannick.molinghen@ulb.be" },
@@ -17,7 +17,7 @@ dependencies = ["numpy>=2.0.0", "opencv-python>=4.0", "typing_extensions>=4.0"]
 
 [project.optional-dependencies]
 gym = ["gymnasium>=0.29.1"]
-smac = ["smac", "pysc2"]
+smac = ["smacv2", "pysc2"]
 pettingzoo = ["pettingzoo>=1.20", "pymunk>=6.0", "scipy>=1.10"]
 overcooked = ["overcooked>=0.1.0"]
 lle = ["laser-learning-environment>=2.6.1"]
@@ -26,8 +26,7 @@ all = [
     "gymnasium>0.29.1",
     "pettingzoo>=1.20",
     "overcooked>=0.1.0",
-    "smac",
-    "pysc2",
+    "smacv2",
     "laser-learning-environment>=2.6.1",
     "pymunk>=6.0",
     "scipy>=1.10",
@@ -52,8 +51,8 @@ pythonpath = "src"
 filterwarnings = "ignore::DeprecationWarning"
 
 [tool.uv.sources]
-smac = { git = "https://github.com/oxwhirl/smac.git" }
-pysc2 = { git = "https://github.com/google-deepmind/pysc2.git" }
+smacv2 = { git = "https://github.com/oxwhirl/smacv2.git", rev = "577ab5a" }
+pysc2 = { git = "https://github.com/google-deepmind/pysc2.git", rev = "0df53d3" }
 
 
 [dependency-groups]

multi_agent_rlenv-3.7.4/src/marlenv/__init__.py

@@ -0,0 +1,167 @@
+"""
+`marlenv` is a strongly typed library for multi-agent and multi-objective reinforcement learning.
+
+Install the library with
+```sh
+$ pip install multi-agent-rlenv      # Basics
+$ pip install multi-agent-rlenv[all] # With all optional dependecies
+$ pip install multi-agent-rlenv[smac,overcooked] # Only SMACv2 & Overcooked
+```
+
+It aims to provide a simple and consistent interface for reinforcement learning environments by providing abstraction models such as `Observation`s or `Episode`s. `marlenv` provides adapters for popular libraries such as `gym` or `pettingzoo` and provides utility wrappers to add functionalities such as video recording or limiting the number of steps.
+
+Almost every class is a dataclass to enable seemless serialiation with the `orjson` library.
+
+# Fundamentals
+## States & Observations
+`MARLEnv.reset()` returns a pair of `(Observation, State)` and `MARLEnv.step()` returns a `Step`.
+
+- `Observation` contains:
+  - `data`: shape `[n_agents, *observation_shape]`
+  - `available_actions`: boolean mask `[n_agents, n_actions]`
+  - `extras`: extra features per agent (default shape `(n_agents, 0)`)
+- `State` represents the environment state and can also carry `extras`.
+- `Step` bundles `obs`, `state`, `reward`, `done`, `truncated`, and `info`.
+
+Rewards are stored as `np.float32` arrays. Multi-objective envs use reward vectors with `reward_space.size > 1`.
+
+## Extras
+Extras are auxiliary features appended by wrappers (agent id, last action, time ratio, available actions, ...).
+Wrappers that add extras must update both `extras_shape` and `extras_meanings` so downstream users can interpret them.
+`State` extras should stay in sync with `Observation` extras when applicable.
+
+# Environment catalog
+`marlenv.catalog` exposes curated environments and lazily imports optional dependencies.
+
+```python
+from marlenv import catalog
+
+env1 = catalog.overcooked().from_layout("scenario4")
+env2 = catalog.lle().level(6)
+env3 = catalog.DeepSea(mex_depth=5)
+```
+
+Catalog entries require their corresponding extras at install time (e.g., `marlenv[overcooked]`, `marlenv[lle]`).
+
+# Wrappers & builders
+Wrappers are composable through `RLEnvWrapper` and can be chained via `Builder` for fluent configuration.
+
+```python
+from marlenv import Builder
+from marlenv.adapters import SMAC
+
+env = (
+    Builder(SMAC("3m"))
+    .agent_id()
+    .time_limit(20)
+    .available_actions()
+    .build()
+)
+```
+
+Common wrappers include time limits, delayed rewards, masking available actions, and video recording.
+
+# Using the library
+## Adapters for existing libraries
+Adapters normalize external APIs into `MARLEnv`:
+
+```python
+import marlenv
+
+gym_env = marlenv.make("CartPole-v1", seed=25)
+
+from marlenv.adapters import SMAC
+smac_env = SMAC("3m", debug=True, difficulty="9")
+
+from pettingzoo.sisl import pursuit_v4
+from marlenv.adapters import PettingZoo
+env = PettingZoo(pursuit_v4.parallel_env())
+```
+
+## Designing a custom environment
+Create a custom environment by inheriting from `MARLEnv` and implementing `reset`, `step`, `get_observation`, and `get_state`.
+
+```python
+import numpy as np
+from marlenv import MARLEnv, DiscreteSpace, Observation, State, Step
+
+class CustomEnv(MARLEnv[DiscreteSpace]):
+    def __init__(self):
+        super().__init__(
+            n_agents=3,
+            action_space=DiscreteSpace.action(5).repeat(3),
+            observation_shape=(4,),
+            state_shape=(2,),
+        )
+        self.t = 0
+
+    def reset(self):
+        self.t = 0
+        return self.get_observation(), self.get_state()
+
+    def step(self, action):
+        self.t += 1
+        return Step(self.get_observation(), self.get_state(), reward=0.0, done=False)
+
+    def get_observation(self):
+        return Observation(np.zeros((3, 4), dtype=np.float32), self.available_actions())
+
+    def get_state(self):
+        return State(np.array([self.t, 0], dtype=np.float32))
+```
+"""
+
+from importlib.metadata import version, PackageNotFoundError
+
+try:
+    __version__ = version("multi-agent-rlenv")
+except PackageNotFoundError:
+    __version__ = "0.0.0"  # fallback for CI
+
+
+from . import models
+from .models import (
+    spaces,
+    MARLEnv,
+    State,
+    Step,
+    Observation,
+    Episode,
+    Transition,
+    DiscreteSpace,
+    ContinuousSpace,
+    Space,
+    MultiDiscreteSpace,
+)
+
+
+from . import wrappers
+from . import adapters
+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",
+    "Builder",
+    "MARLEnv",
+    "Step",
+    "State",
+    "Observation",
+    "Episode",
+    "Transition",
+    "DiscreteSpace",
+    "ContinuousSpace",
+    "DiscreteMockEnv",
+    "DiscreteMOMockEnv",
+    "RLEnvWrapper",
+    "Space",
+    "MultiDiscreteSpace",
+]

{multi_agent_rlenv-3.7.2 → multi_agent_rlenv-3.7.4}/src/marlenv/adapters/__init__.py

@@ -1,3 +1,18 @@
+"""
+Adapters for external RL libraries.
+
+This submodule provides optional wrappers that normalize third-party APIs into
+`MARLEnv`. Adapters are imported lazily via `try/except` so the base install
+remains lightweight. The availability flags (`HAS_GYM`, `HAS_PETTINGZOO`,
+`HAS_SMAC`) reflect whether the corresponding extra was installed.
+
+Install extras to enable adapters with `uv` or `pip`:
+- `multi-agent-rlenv[all]` for all optional dependencies
+- `multi-agent-rlenv[gym]` for Gymnasium
+- `multi-agent-rlenv[pettingzoo]` for PettingZoo
+- `multi-agent-rlenv[smac]` for SMAC
+"""
+
 from .pymarl_adapter import PymarlAdapter
 from marlenv.utils import dummy_function
 

{multi_agent_rlenv-3.7.2 → multi_agent_rlenv-3.7.4}/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  # pyright: ignore[reportMissingImports]
+from smacv2.env import StarCraft2Env
 
 from marlenv.models import MARLEnv, Observation, State, Step, MultiDiscreteSpace, DiscreteSpace
 

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

@@ -0,0 +1,51 @@
+"""
+Environment catalog for `marlenv`.
+
+This submodule exposes curated environments and provides lazy imports for optional
+dependencies to keep the base install lightweight. Use the catalog to construct
+environments without importing their packages directly.
+
+Examples:
+```python
+from marlenv import catalog
+
+env1 = catalog.DeepSea(mex_depth=5)
+env2 = catalog.CoordinatedGrid()
+env3 = catalog.connect_n()(width=7, height=6, n_to_connect=4)
+env4 = catalog.smac()("3m")
+```
+
+Optional entries such as `smac`, `lle`, and `overcooked` require installing their
+corresponding extras (e.g., `marlenv[smac]`, `marlenv[lle]`, `marlenv[overcooked]`).
+"""
+
+from .deepsea import DeepSea
+from .matrix_game import MatrixGame
+from .coordinated_grid import CoordinatedGrid
+
+
+__all__ = ["smac", "DeepSea", "lle", "overcooked", "MatrixGame", "connect_n", "CoordinatedGrid"]
+
+
+def smac():
+    from marlenv.adapters import SMAC
+
+    return SMAC
+
+
+def lle():
+    from lle import LLE  # pyright: ignore[reportMissingImports]
+
+    return LLE
+
+
+def overcooked():
+    from overcooked import Overcooked  # pyright: ignore[reportMissingImports]
+
+    return Overcooked
+
+
+def connect_n():
+    from .connectn import ConnectN
+
+    return ConnectN

{multi_agent_rlenv-3.7.2 → multi_agent_rlenv-3.7.4}/src/marlenv/models/__init__.py

@@ -1,3 +1,14 @@
+"""
+Core data models for the `marlenv` API.
+
+This package defines the typed containers and interfaces shared across adapters,
+wrappers, and environments:
+- `MARLEnv`: the abstract environment contract.
+- `Observation` / `State`: structured inputs to agents and state tracking.
+- `Step` / `Transition` / `Episode`: execution results and replayable logs.
+- `Space` variants: action/reward space definitions.
+"""
+
 from .spaces import DiscreteSpace, ContinuousSpace, MultiDiscreteSpace, Space
 from .observation import Observation
 from .step import Step

{multi_agent_rlenv-3.7.2 → multi_agent_rlenv-3.7.4}/src/marlenv/models/step.py

@@ -9,6 +9,15 @@ from .state import State
 
 @dataclass
 class Step:
+    """
+    The result of performing a step in the environment:
+        - the new observation
+        - the new state
+        - the reward received for the step performed
+        - whether the episode is done or truncated
+        - some info (mainly for logging purposes)
+    """
+
     obs: Observation
     """The new observation (1 per agent) of the environment resulting from the agent's action."""
     state: State

{multi_agent_rlenv-3.7.2 → multi_agent_rlenv-3.7.4}/tests/test_adapters.py

@@ -114,7 +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  # pyright: ignore[reportMissingImports]
+    from smacv2.env import StarCraft2Env  # pyright: ignore[reportMissingImports]
     from marlenv.adapters import SMAC
 
     env = SMAC(StarCraft2Env("3m"))

multi_agent_rlenv-3.7.2/PKG-INFO

@@ -1,144 +0,0 @@
-Metadata-Version: 2.4
-Name: multi-agent-rlenv
-Version: 3.7.2
-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.12
-Requires-Dist: numpy>=2.0.0
-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: 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'
-Requires-Dist: scipy>=1.10; extra == 'all'
-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>=0.1.0; extra == 'overcooked'
-Provides-Extra: pettingzoo
-Requires-Dist: pettingzoo>=1.20; extra == 'pettingzoo'
-Requires-Dist: pymunk>=6.0; extra == 'pettingzoo'
-Requires-Dist: scipy>=1.10; extra == 'pettingzoo'
-Provides-Extra: smac
-Requires-Dist: pysc2; extra == 'smac'
-Requires-Dist: smac; extra == 'smac'
-Provides-Extra: torch
-Requires-Dist: torch>=2.0; extra == 'torch'
-Description-Content-Type: text/markdown
-
-# `marlenv` - A unified framework for muti-agent reinforcement learning
-**Documentation: [https://yamoling.github.io/multi-agent-rlenv](https://yamoling.github.io/multi-agent-rlenv)**
-
-The objective of `marlenv` is to provide a common (typed) interface for many different reinforcement learning environments.
-
-As such, `marlenv` provides high level abstractions of RL concepts such as `Observation`s or `Transition`s that are commonly represented as mere (confusing) lists or tuples.
-
-## Installation
-Install with you preferred package manager (`uv`, `pip`, `poetry`, ...):
-```bash
-$ pip install marlenv[all] # Enable all features
-$ pip install marlenv      # Basic installation
-```
-
-There are multiple optional dependencies if you want to support specific libraries and environments. Available options are:
-- `smac` for StarCraft II environments
-- `gym` for OpenAI Gym environments
-- `pettingzoo` for PettingZoo environments
-- `overcooked` for Overcooked environments
-
-Install them with:
-```bash
-$ 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` provides adapters from most popular libraries to unify them under a single interface. Namely, `marlenv` supports `smac`, `gymnasium` and `pettingzoo`.
-
-```python
-import marlenv
-
-# You can instanciate gymnasium environments directly via their registry ID
-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 = SMAC("3m", debug=True, difficulty="9")
-
-# pettingzoo is also supported
-from pettingzoo.sisl import pursuit_v4
-from marlenv.adapters import PettingZoo
-pz_env = PettingZoo(pursuit_v4.parallel_env())
-```
-
-
-## Designing custom environments
-You can create your own custom environment by inheriting from the `RLEnv` class. The below example illustrates a gridworld with a discrete action space. Note that other methods such as `step` or `render` must also be implemented.
-```python
-import numpy as np
-from marlenv import RLEnv, DiscreteActionSpace, Observation
-
-N_AGENTS = 3
-N_ACTIONS = 5
-
-class CustomEnv(MARLEnv[DiscreteActionSpace]):
-    def __init__(self, width: int, height: int):
-        super().__init__(
-            action_space=DiscreteActionSpace(N_AGENTS, N_ACTIONS),
-            observation_shape=(height, width),
-            state_shape=(1,),
-        )
-        self.time = 0
-
-    def reset(self) -> Observation:
-        self.time = 0
-        ...
-        return obs
-
-    def get_state(self):
-        return np.array([self.time])
-```
-
-## Useful wrappers
-`marlenv` comes with multiple common environment wrappers, check the documentation for a complete list. The preferred way of using the wrappers is through a `marlenv.Builder`. The below example shows how to add a time limit (in number of steps) and an agent id to the observations of a SMAC environment.
-
-```python
-from marlenv import Builder
-from marlenv.adapters import SMAC
-
-env = Builder(SMAC("3m")).agent_id().time_limit(20).build()
-print(env.extras_shape) # -> (4, ) because there are 3 agents and the time counter
-```
-
-
-# Related projects
-- MARL: Collection of multi-agent reinforcement learning algorithms based on `marlenv` [https://github.com/yamoling/marl](https://github.com/yamoling/marl)
-- Laser Learning Environment: a multi-agent gridworld that leverages `marlenv`'s capabilities [https://pypi.org/project/laser-learning-environment/](https://pypi.org/project/laser-learning-environment/)

multi_agent_rlenv-3.7.2/README.md

@@ -1,104 +0,0 @@
-# `marlenv` - A unified framework for muti-agent reinforcement learning
-**Documentation: [https://yamoling.github.io/multi-agent-rlenv](https://yamoling.github.io/multi-agent-rlenv)**
-
-The objective of `marlenv` is to provide a common (typed) interface for many different reinforcement learning environments.
-
-As such, `marlenv` provides high level abstractions of RL concepts such as `Observation`s or `Transition`s that are commonly represented as mere (confusing) lists or tuples.
-
-## Installation
-Install with you preferred package manager (`uv`, `pip`, `poetry`, ...):
-```bash
-$ pip install marlenv[all] # Enable all features
-$ pip install marlenv      # Basic installation
-```
-
-There are multiple optional dependencies if you want to support specific libraries and environments. Available options are:
-- `smac` for StarCraft II environments
-- `gym` for OpenAI Gym environments
-- `pettingzoo` for PettingZoo environments
-- `overcooked` for Overcooked environments
-
-Install them with:
-```bash
-$ 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` provides adapters from most popular libraries to unify them under a single interface. Namely, `marlenv` supports `smac`, `gymnasium` and `pettingzoo`.
-
-```python
-import marlenv
-
-# You can instanciate gymnasium environments directly via their registry ID
-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 = SMAC("3m", debug=True, difficulty="9")
-
-# pettingzoo is also supported
-from pettingzoo.sisl import pursuit_v4
-from marlenv.adapters import PettingZoo
-pz_env = PettingZoo(pursuit_v4.parallel_env())
-```
-
-
-## Designing custom environments
-You can create your own custom environment by inheriting from the `RLEnv` class. The below example illustrates a gridworld with a discrete action space. Note that other methods such as `step` or `render` must also be implemented.
-```python
-import numpy as np
-from marlenv import RLEnv, DiscreteActionSpace, Observation
-
-N_AGENTS = 3
-N_ACTIONS = 5
-
-class CustomEnv(MARLEnv[DiscreteActionSpace]):
-    def __init__(self, width: int, height: int):
-        super().__init__(
-            action_space=DiscreteActionSpace(N_AGENTS, N_ACTIONS),
-            observation_shape=(height, width),
-            state_shape=(1,),
-        )
-        self.time = 0
-
-    def reset(self) -> Observation:
-        self.time = 0
-        ...
-        return obs
-
-    def get_state(self):
-        return np.array([self.time])
-```
-
-## Useful wrappers
-`marlenv` comes with multiple common environment wrappers, check the documentation for a complete list. The preferred way of using the wrappers is through a `marlenv.Builder`. The below example shows how to add a time limit (in number of steps) and an agent id to the observations of a SMAC environment.
-
-```python
-from marlenv import Builder
-from marlenv.adapters import SMAC
-
-env = Builder(SMAC("3m")).agent_id().time_limit(20).build()
-print(env.extras_shape) # -> (4, ) because there are 3 agents and the time counter
-```
-
-
-# Related projects
-- MARL: Collection of multi-agent reinforcement learning algorithms based on `marlenv` [https://github.com/yamoling/marl](https://github.com/yamoling/marl)
-- Laser Learning Environment: a multi-agent gridworld that leverages `marlenv`'s capabilities [https://pypi.org/project/laser-learning-environment/](https://pypi.org/project/laser-learning-environment/)

multi_agent_rlenv-3.7.2/src/marlenv/__init__.py

@@ -1,118 +0,0 @@
-"""
-`marlenv` is a strongly typed library for multi-agent and multi-objective reinforcement learning.
-
-It aims to provide a simple and consistent interface for reinforcement learning environments by providing abstraction models such as `Observation`s or `Episode`s. `marlenv` provides adapters for popular libraries such as `gym` or `pettingzoo` and provides utility wrappers to add functionalities such as video recording or limiting the number of steps.
-
-Almost every class is a dataclassto enable seemless serialiation with the `orjson` library.
-
-# Existing environments
-The `MARLEnv` class represents a multi-agent RL environment and is at the center of this library, and `marlenv` provides an adapted implementation of multiple common MARL environments (gym, pettingzoo, smac and overcooked) in `marlenv.adapters`. Note that these adapters will only work if you have the corresponding library installed.
-
-```python
-from marlenv.adapters import Gym, PettingZoo, SMAC, Overcooked
-import marlenv
-
-env1 = Gym("CartPole-v1")
-env2 = marlenv.make("CartPole-v1")
-env3 = PettingZoo("prospector_v4")
-env4 = SMAC("3m")
-env5 = Overcooked.from_layout("cramped_room")
-```
-
-# Wrappers & Builder
-To facilitate the create of an environment with common wrappers, `marlenv` provides a `Builder` class that can be used to chain the creation of multiple wrappers.
-
-```python
-from marlenv import make, Builder
-
-env = <your env>
-env = Builder(env).agent_id().time_limit(50).record("videos").build()
-```
-
-# Using the library
-A typical environment loop would look like this:
-
-```python
-from marlenv import DiscreteMockEnv, Builder, Episode
-
-env = Builder(DicreteMockEnv()).agent_id().build()
-obs, state = env.reset()
-terminated = False
-episode = Episode.new(obs, state)
-while not episode.is_finished:
-    action = env.sample_action() # a valid random action
-    step = env.step(action) # Step data `step.obs`, `step.reward`, ...
-    episode.add(step, action) # Progressively build the episode
-```
-
-# Extras
-To cope with complex observation spaces, `marlenv` distinguishes the "main" observation data from the "extra" observation data. A typical example would be the observation of a gridworld environment with a time limit. In that case, the main observation has shape (height, width), i.e. the content of the grid, but the current time is an extra observation data of shape (1, ).
-
-```python
-env = GridWorldEnv()
-print(env.observation_shape) # (height, width)
-print(env.extras_shape) # (0, )
-
-env = Builder(env).time_limit(25).build()
-print(env.observation_shape) # (height, width)
-print(env.extras_shape) # (1, )
-```
-
-# Creating a new environment
-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.
-"""
-
-from importlib.metadata import version, PackageNotFoundError
-
-try:
-    __version__ = version("multi-agent-rlenv")
-except PackageNotFoundError:
-    __version__ = "0.0.0"  # fallback for CI
-
-
-from . import models
-from .models import (
-    spaces,
-    MARLEnv,
-    State,
-    Step,
-    Observation,
-    Episode,
-    Transition,
-    DiscreteSpace,
-    ContinuousSpace,
-    Space,
-    MultiDiscreteSpace,
-)
-
-
-from . import wrappers
-from . import adapters
-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",
-    "Builder",
-    "MARLEnv",
-    "Step",
-    "State",
-    "Observation",
-    "Episode",
-    "Transition",
-    "DiscreteSpace",
-    "ContinuousSpace",
-    "DiscreteMockEnv",
-    "DiscreteMOMockEnv",
-    "RLEnvWrapper",
-    "Space",
-    "MultiDiscreteSpace",
-]

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

@@ -1,30 +0,0 @@
-from .deepsea import DeepSea
-from .matrix_game import MatrixGame
-from .coordinated_grid import CoordinatedGrid
-
-
-__all__ = ["smac", "DeepSea", "lle", "overcooked", "MatrixGame", "connect_n", "CoordinatedGrid"]
-
-
-def smac():
-    from marlenv.adapters import SMAC
-
-    return SMAC
-
-
-def lle():
-    from lle import LLE  # pyright: ignore[reportMissingImports]
-
-    return LLE
-
-
-def overcooked():
-    from overcooked import Overcooked  # pyright: ignore[reportMissingImports]
-
-    return Overcooked
-
-
-def connect_n():
-    from .connectn import ConnectN
-
-    return ConnectN