multi-agent-rlenv 3.6.3__py3-none-any.whl → 3.7.1__py3-none-any.whl

marlenv/__init__.py

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

marlenv/adapters/gym_adapter.py

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

marlenv/adapters/pettingzoo_adapter.py

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

marlenv/adapters/smac_adapter.py

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

marlenv/catalog/__init__.py

@@ -1,13 +1,10 @@
 from marlenv.adapters import SMAC
 from .deepsea import DeepSea
+from .matrix_game import MatrixGame
+from .coordinated_grid import CoordinatedGrid
 
 
-__all__ = [
-    "SMAC",
-    "DeepSea",
-    "lle",
-    "overcooked",
-]
+__all__ = ["SMAC", "DeepSea", "lle", "overcooked", "MatrixGame", "connect_n", "CoordinatedGrid"]
 
 
 def lle():
@@ -20,3 +17,9 @@ def overcooked():
     from overcooked import Overcooked  # pyright: ignore[reportMissingImports]
 
     return Overcooked
+
+
+def connect_n():
+    from .connectn import ConnectN
+
+    return ConnectN

marlenv/catalog/connectn/__init__.py

@@ -0,0 +1,11 @@
+"""
+Connect-N game environment.
+
+Inspiration from: https://github.com/Gualor/connect4-montecarlo
+"""
+
+from .board import GameBoard
+from .env import ConnectN
+
+
+__all__ = ["ConnectN", "GameBoard"]

marlenv/catalog/connectn/board.py

@@ -0,0 +1,186 @@
+from enum import IntEnum
+
+import numpy as np
+
+
+class StepResult(IntEnum):
+    NOTHING = 0
+    TIE = 1
+    WIN = 2
+
+
+class GameBoard:
+    """Connect4 game board class."""
+
+    def __init__(self, width: int, height: int, n: int):
+        assert width >= n or height >= height, "Impossible to win with this combination of width, height and n"
+        self.turn = 1
+        self.board = np.zeros(shape=(height, width), dtype=np.float32)
+        self.width = width
+        self.height = height
+        self.n_to_align = n
+        self.n_items_in_column = np.zeros(width, dtype=np.int32)
+
+        self.str_row = "+" + "-" * (self.width * 4 - 1) + "+"
+        self.numbers = "|" + " ".join([f" {i} " for i in range(self.width)]) + "|"
+
+    def valid_moves(self):
+        """Get list of valid moves (i.e. not full columns)."""
+        return self.n_items_in_column < self.height
+
+    def clear(self):
+        self.board = np.zeros(shape=(self.height, self.width), dtype=np.float32)
+        self.n_items_in_column = np.zeros(self.width, dtype=np.int32)
+        self.turn = 0
+
+    def show(self):
+        """Print out game board on console."""
+        print(self.str_row)
+        for j in range(self.height - 1, -1, -1):
+            for i in range(self.width):
+                match self.board[j, i]:
+                    case 1:
+                        print("| X", end=" ")
+                    case -1:
+                        print("| O", end=" ")
+                    case _:
+                        print("|  ", end=" ")
+            print("|")
+        print(self.str_row)
+        print(self.numbers)
+        print(self.str_row)
+
+    def check_win(self, move_played: tuple[int, int]) -> bool:
+        if self.check_rows(move_played):
+            return True
+        if self.check_cols(move_played):
+            return True
+        if self.check_diags(move_played):
+            return True
+        return False
+
+    def check_tie(self) -> bool:
+        """
+        Check whether the game is a tie (i.e. the board is full).
+
+        Note that it does not check for a win, so it should be called after check_win.
+        """
+        # If the last row is full, the game is a tie
+        return bool(np.all(self.board[-1] != 0))
+
+    def check_rows(self, move_played: tuple[int, int]) -> bool:
+        row, col = move_played
+        start_index = max(0, col - self.n_to_align + 1)
+        end_index = min(self.width - self.n_to_align, col) + 1
+        for start in range(start_index, end_index):
+            slice = self.board[row, start : start + self.n_to_align]
+            if np.all(slice == self.turn):
+                return True
+        return False
+
+    def check_cols(self, move_played: tuple[int, int]) -> bool:
+        row, col = move_played
+        start_index = max(0, row - self.n_to_align + 1)
+        end_index = min(self.height - self.n_to_align, row) + 1
+        for start in range(start_index, end_index):
+            slice = self.board[start : start + self.n_to_align, col]
+            if np.all(slice == self.turn):
+                return True
+        return False
+
+    def check_diags(self, move_played: tuple[int, int]) -> bool:
+        row, col = move_played
+        # count the adjacent items in the / diagonal
+        n_adjacent = 0
+        # Top right
+        row_i, col_i = row + 1, col + 1
+        while row_i < self.height and col_i < self.width and self.board[row_i, col_i] == self.turn:
+            n_adjacent += 1
+            row_i += 1
+            col_i += 1
+        # Bottom left
+        row_i, col_i = row - 1, col - 1
+        while row_i >= 0 and col_i >= 0 and self.board[row_i, col_i] == self.turn:
+            n_adjacent += 1
+            row_i -= 1
+            col_i -= 1
+        if n_adjacent >= self.n_to_align - 1:
+            return True
+
+        # Count adjacent items in the \ diagonal
+        n_adjacent = 0
+        # Top left
+        row_i, col_i = row + 1, col - 1
+        while row_i < self.height and col_i >= 0 and self.board[row_i, col_i] == self.turn:
+            n_adjacent += 1
+            row_i += 1
+            col_i -= 1
+        # Bottom right
+        row_i, col_i = row - 1, col + 1
+        while row_i >= 0 and col_i < self.width and self.board[row_i, col_i] == self.turn:
+            n_adjacent += 1
+            row_i -= 1
+            col_i += 1
+
+        return n_adjacent >= self.n_to_align - 1
+
+    def play(self, column: int) -> StepResult:
+        """Apply move to board.
+
+        Args:
+            column (int): Selected column index (between 0 and the number of cols - 1).
+
+        Returns:
+            bool: whether the player has won.
+        """
+        row_index = self.n_items_in_column[column]
+        if row_index >= self.height:
+            raise ValueError(f"Column {column} is full, use `valid_moves` to check valid moves.")
+        self.n_items_in_column[column] += 1
+        self.board[row_index, column] = self.turn
+        if self.check_win((row_index, column)):
+            result = StepResult.WIN
+        elif self.check_tie():
+            result = StepResult.TIE
+        else:
+            result = StepResult.NOTHING
+        self.switch_turn()
+        return result
+
+    def switch_turn(self) -> None:
+        """Switch turn between players."""
+        self.turn = -self.turn
+
+
+def test_win():
+    board = GameBoard(4, 1, 2)
+    assert board.play(0) == StepResult.NOTHING
+    assert board.play(2) == StepResult.NOTHING
+    assert board.play(1) == StepResult.WIN
+
+
+def test_tie():
+    board = GameBoard(4, 1, 2)
+    assert board.play(0) == StepResult.NOTHING
+    assert board.play(1) == StepResult.NOTHING
+    assert board.play(2) == StepResult.NOTHING
+    assert board.play(3) == StepResult.TIE
+
+
+def test_win_diag():
+    board = GameBoard(2, 2, 2)
+    assert board.play(0) == StepResult.NOTHING
+    assert board.play(1) == StepResult.NOTHING
+    assert board.play(1) == StepResult.WIN
+
+    board.clear()
+    assert board.play(1) == StepResult.NOTHING
+    assert board.play(1) == StepResult.NOTHING
+    assert board.play(0) == StepResult.WIN
+
+
+if __name__ == "__main__":
+    test_win()
+    test_tie()
+    test_win_diag()
+    print("All tests passed!")

marlenv/catalog/connectn/env.py

@@ -0,0 +1,51 @@
+from typing import Sequence
+import numpy as np
+import numpy.typing as npt
+from marlenv import MARLEnv, MultiDiscreteSpace, Step, State, Observation, DiscreteSpace
+
+from .board import GameBoard, StepResult
+
+
+class ConnectN(MARLEnv[MultiDiscreteSpace]):
+    def __init__(self, width: int = 7, height: int = 6, n: int = 4):
+        self.board = GameBoard(width, height, n)
+        action_space = DiscreteSpace(self.board.width).repeat(1)
+        observation_shape = (self.board.height, self.board.width)
+        state_shape = observation_shape
+        super().__init__(1, action_space, observation_shape, state_shape)
+
+    def reset(self):
+        self.board.clear()
+        return self.get_observation(), self.get_state()
+
+    def step(self, action: Sequence[int] | npt.NDArray[np.uint32]):
+        match self.board.play(action[0]):
+            case StepResult.NOTHING:
+                done = False
+                reward = 0
+            case StepResult.WIN:
+                done = True
+                reward = 1
+            case StepResult.TIE:
+                done = True
+                reward = 0
+        return Step(self.get_observation(), self.get_state(), reward, done, False)
+
+    def available_actions(self):
+        """Full columns are not available."""
+        return np.expand_dims(self.board.valid_moves(), axis=0)
+
+    def get_observation(self):
+        return Observation(self.board.board.copy(), self.available_actions())
+
+    def get_state(self):
+        return State(self.board.board.copy(), np.array([self.board.turn]))
+
+    def set_state(self, state: State):
+        self.board.board = state.data.copy()  # type: ignore Currently a type error because of the unchecked shape
+        self.board.turn = int(state.extras[0])
+        n_completed = np.count_nonzero(self.board.board, axis=0)
+        self.board.n_items_in_column = n_completed
+
+    def render(self):
+        self.board.show()

marlenv/catalog/coordinated_grid.py

@@ -0,0 +1,139 @@
+import numpy as np
+import itertools
+from marlenv import MARLEnv, DiscreteSpace, Observation, State, Step
+
+
+N_ROWS = 11
+N_COLS = 12
+
+
+class CoordinatedGrid(MARLEnv):
+    """
+    Coordinated grid world environment used in the EMC paper to test the effectiveness of the proposed method.
+    https://proceedings.neurips.cc/paper_files/paper/2021/file/1e8ca836c962598551882e689265c1c5-Paper.pdf
+    """
+
+    def __init__(
+        self,
+        episode_limit=30,
+        time_penalty=2,
+    ):
+        super().__init__(
+            n_agents=2,
+            action_space=DiscreteSpace(5, ["SOUTH", "NORTH", "WEST", "EAST", "STAY"]).repeat(2),
+            observation_shape=(N_ROWS + N_COLS,),
+            state_shape=(N_ROWS + N_COLS,) * 2,
+        )
+        self._episode_steps = 0
+        self.episode_limit = episode_limit
+        self.center = N_COLS // 2
+        ###larger gridworld
+        visible_row = [i for i in range(N_ROWS // 2 - 2, N_ROWS // 2 + 3)]
+        visible_col = [i for i in range(N_COLS // 2 - 3, N_COLS // 2 + 3)]
+        self.vision_index = [[i, j] for i, j in list(itertools.product(visible_row, visible_col))]
+        self.agents_location = [[0, 0], [N_ROWS - 1, N_COLS - 1]]
+        self.time_penalty = time_penalty
+
+    def reset(self):
+        self.agents_location = [[0, 0], [N_ROWS - 1, N_COLS - 1]]
+        self._episode_steps = 0
+        return self.get_observation(), self.get_state()
+
+    def get_observation(self):
+        obs_1 = [[0 for _ in range(N_ROWS)], [0 for _ in range(N_COLS)]]
+        # obs_2 = obs_1.copy()
+        import copy
+
+        obs_2 = copy.deepcopy(obs_1)
+
+        obs_1[0][self.agents_location[0][0]] = 1
+        obs_1[1][self.agents_location[0][1]] = 1
+        obs_1 = obs_1[0] + obs_1[1]
+
+        obs_2[0][self.agents_location[1][0]] = 1
+        obs_2[1][self.agents_location[1][1]] = 1
+        obs_2 = obs_2[0] + obs_2[1]
+
+        if self.agents_location[0] in self.vision_index and self.agents_location[1] in self.vision_index:
+            temp = obs_1.copy()
+            obs_1 += obs_2.copy()
+            obs_2 += temp.copy()
+        elif self.agents_location[0] in self.vision_index:
+            obs_2 += obs_1.copy()
+            obs_1 += [0 for _ in range(N_ROWS + N_COLS)]
+        elif self.agents_location[1] in self.vision_index:
+            obs_1 += obs_2.copy()
+            obs_2 += [0 for _ in range(N_ROWS + N_COLS)]
+        else:
+            obs_2 += [0 for _ in range(N_ROWS + N_COLS)]
+            obs_1 += [0 for _ in range(N_ROWS + N_COLS)]
+
+        obs_data = np.array([obs_1, obs_2])
+        return Observation(obs_data, self.available_actions())
+
+    def get_state(self):
+        obs = self.get_observation()
+        state_data = obs.data.reshape(-1)
+        return State(state_data)
+
+    def available_actions(self):
+        avail_actions = np.full((self.n_agents, self.n_actions), True)
+        for agent_num, (y, x) in enumerate(self.agents_location):
+            if x == 0:
+                avail_actions[agent_num, 0] = 0
+            elif x == N_ROWS - 1:
+                avail_actions[agent_num, 1] = 0
+            if y == 0:
+                avail_actions[agent_num, 2] = 0
+            # Check for center line (depends on the agent number)
+            elif y == self.center + agent_num - 1:
+                avail_actions[agent_num, 3] = 0
+        return avail_actions
+
+    def step(self, action):
+        for idx, action in enumerate(action):
+            match action:
+                case 0:
+                    self.agents_location[idx][0] -= 1
+                case 1:
+                    self.agents_location[idx][0] += 1
+                case 2:
+                    self.agents_location[idx][1] -= 1
+                case 3:
+                    self.agents_location[idx][1] += 1
+                case 4:
+                    pass
+                case _:
+                    raise ValueError(f"Invalid action {action} for agent {idx}!")
+
+        self._episode_steps += 1
+        terminated = self._episode_steps >= self.episode_limit
+        env_info = {"battle_won": False}
+        n_arrived = self.n_agents_arrived()
+        if n_arrived == 1:
+            reward = -self.time_penalty
+        elif n_arrived == 2:
+            reward = 10
+            terminated = True
+            env_info = {"battle_won": True}
+        else:
+            reward = 0
+        return Step(self.get_observation(), self.get_state(), reward, terminated, terminated, env_info)
+
+    def n_agents_arrived(self):
+        n = 0
+        if self.agents_location[0] == [N_ROWS // 2, self.center - 1]:
+            n += 1
+        if self.agents_location[1] == [N_ROWS // 2, self.center]:
+            n += 1
+        return n
+
+    def render(self):
+        print("Agents location: ", self.agents_location)
+        for row in range(N_ROWS):
+            for col in range(N_COLS):
+                if [row, col] in self.agents_location:
+                    print("X", end=" ")
+                else:
+                    print(".", end=" ")
+            print()

marlenv/catalog/deepsea.py

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

marlenv/catalog/matrix_game.py

@@ -0,0 +1,52 @@
+import numpy as np
+from marlenv import MARLEnv, Observation, DiscreteSpace, State, Step
+
+
+class MatrixGame(MARLEnv):
+    """Single step matrix game used in QTRAN, Qatten and QPLEX papers."""
+
+    N_AGENTS = 2
+    UNIT_DIM = 1
+    OBS_SHAPE = (1,)
+    STATE_SIZE = UNIT_DIM * N_AGENTS
+
+    QPLEX_PAYOFF_MATRIX = [
+        [8.0, -12.0, -12.0],
+        [-12.0, 0.0, 0.0],
+        [-12.0, 0.0, 0.0],
+    ]
+
+    def __init__(self, payoff_matrix: list[list[float]]):
+        action_names = [chr(ord("A") + i) for i in range(len(payoff_matrix[0]))]
+        super().__init__(
+            2,
+            action_space=DiscreteSpace(len(payoff_matrix[0]), action_names).repeat(2),
+            observation_shape=MatrixGame.OBS_SHAPE,
+            state_shape=(MatrixGame.STATE_SIZE,),
+        )
+        self.current_step = 0
+        self.payoffs = payoff_matrix
+
+    def reset(self):
+        self.current_step = 0
+        return self.get_observation(), self.get_state()
+
+    def get_observation(self):
+        return Observation(
+            np.array([[self.current_step]] * MatrixGame.N_AGENTS, np.float32),
+            self.available_actions(),
+        )
+
+    def step(self, action):
+        action = list(action)
+        self.current_step += 1
+        return Step(self.get_observation(), self.get_state(), self.payoffs[action[0]][action[1]], True)
+
+    def render(self):
+        return
+
+    def get_state(self):
+        return State(np.zeros((MatrixGame.STATE_SIZE,), np.float32))
+
+    def seed(self, seed_value):
+        return

marlenv/catalog/two_steps.py

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

marlenv/env_pool.py

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

marlenv/mock_env.py

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

marlenv/models/spaces.py

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

marlenv/utils/schedule.py

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

marlenv/wrappers/agent_id_wrapper.py

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

marlenv/wrappers/blind_wrapper.py

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

marlenv/wrappers/centralised.py

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

marlenv/wrappers/delayed_rewards.py

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

marlenv/wrappers/last_action_wrapper.py

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

marlenv/wrappers/paddings.py

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

marlenv/wrappers/potential_shaping.py

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

marlenv/wrappers/rlenv_wrapper.py

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

marlenv/wrappers/state_counter.py

@@ -0,0 +1,35 @@
+from typing import Sequence
+from marlenv import RLEnvWrapper, MARLEnv, Space, State
+import numpy as np
+from dataclasses import dataclass
+
+
+@dataclass
+class StateCounter[S: Space](RLEnvWrapper[S]):
+    def __init__(self, wrapped: MARLEnv[S]):
+        super().__init__(wrapped)
+        self._per_agent = [set[int]() for _ in range(self.n_agents)]
+        self._joint = set[int]()
+
+    def _register(self, state: State):
+        self._joint.add(hash(state))
+        eh = hash(state.extras.tobytes())
+        for i in range(self.n_agents):
+            agent_data = state.data[i * self.agent_state_size : (i + 1) * self.agent_state_size]
+            h = hash((agent_data.tobytes(), eh))
+            self._per_agent[i].add(h)
+
+    def step(self, action: np.ndarray | Sequence):
+        step = super().step(action)
+        self._register(step.state)
+        if step.is_terminal:
+            step.info = step.info | {
+                "joint-count": len(self._joint),
+                **{f"agent-{i}-count": len(agent_set) for i, agent_set in enumerate(self._per_agent)},
+            }
+        return step
+
+    def reset(self):
+        obs, state = super().reset()
+        self._register(state)
+        return obs, state

marlenv/wrappers/time_limit.py

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

marlenv/wrappers/video_recorder.py

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

{multi_agent_rlenv-3.6.3.dist-info → multi_agent_rlenv-3.7.1.dist-info}/METADATA

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

multi_agent_rlenv-3.7.1.dist-info/RECORD

@@ -0,0 +1,51 @@
+marlenv/__init__.py,sha256=mxpDjgGSc5eq67w1PIKat0UWkAg9A7VjchWwtzzsvW8,3881
+marlenv/env_builder.py,sha256=RUMFvW7dAJtHMLm8-oPVpjBefDtNliZtjlHci97Xj-Q,3874
+marlenv/env_pool.py,sha256=mJhJUROX9k2A2njwnUOBl2EAuhotksQMugH_Zydg1IU,951
+marlenv/exceptions.py,sha256=gJUC_2rVAvOfK_ypVFc7Myh-pIfSU3To38VBVS_0rZA,1179
+marlenv/mock_env.py,sha256=rvl4QAn046HM79IMMiAj1Aoy3_GBSNBBR1_9fHPutR8,4682
+marlenv/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+marlenv/adapters/__init__.py,sha256=JsKWaeXvUjWEg3JC9TOtyjtZlTI9AAkLyab-jDa5yzM,783
+marlenv/adapters/gym_adapter.py,sha256=DXQ1czcvRoL9hTwcVzfMyXArZeVIHP1gAKqZJO87y7Y,3065
+marlenv/adapters/pettingzoo_adapter.py,sha256=A3dcwsQa7jlWc14TybXpBknl0FPK5YK9w-6tzMBHlDI,2913
+marlenv/adapters/pymarl_adapter.py,sha256=2s7EY31s1hrml3q-BBaXo_eDMXTjkebozZPvzsgrb9c,3353
+marlenv/adapters/smac_adapter.py,sha256=nGWNRpn1F6ZFIoTcU0IJGApc_1GHaoBOVsoNljJ-PAg,8509
+marlenv/catalog/__init__.py,sha256=UCJGbmVzNtKvO3fZQWxR_EigGpXhAyIMevyXxghB2F8,535
+marlenv/catalog/coordinated_grid.py,sha256=Kq5UzG9rr5gYRO0QWFCmKmO56JIzgIR19an9_pvypJU,4997
+marlenv/catalog/deepsea.py,sha256=yTyvskWZiAZem11L8cZwHedBIDQ4EAxE2IaUKrjKL2U,2413
+marlenv/catalog/matrix_game.py,sha256=zkErnh6ZIa1kBryYMVLw-jeMCd2AJ-BlP2yROxpbb0w,1519
+marlenv/catalog/two_steps.py,sha256=lI-q4-Q8283QZTjY0wk7OfXWB6Ln-lquYUjHyT4URi4,2970
+marlenv/catalog/connectn/__init__.py,sha256=BKfM0ZofMK6zqGURi2bzILyNFfYjfbZpKTs5ikKiJAk,195
+marlenv/catalog/connectn/board.py,sha256=GVcFA1OJgLUmQoTIfOO9M7nL9dFv-4T3tGrVsP15zyg,6124
+marlenv/catalog/connectn/env.py,sha256=Ot5vfAbzS6eRe3-nLW_AkhEH7F1WVvv4_odoxZU7HNg,1905
+marlenv/models/__init__.py,sha256=uihmRs71Gg5z7Bvau_xtaQVg7xEtX8sTzi74bIHL5P0,443
+marlenv/models/env.py,sha256=BG1iVHxGD_p827mF0ewyOBn6wU2gtFsHLW1b4UtW-V0,7841
+marlenv/models/episode.py,sha256=zsyxsW4LIioPKyY4DZKn64A31e5ZvlwOf3HIGuRUzhs,13531
+marlenv/models/observation.py,sha256=RhvKvmys4bu3UwwVsvu7fJ7TMKt2QkKnBD1e0hw2r7s,3528
+marlenv/models/spaces.py,sha256=d_aIPWwPdaOWZeNRUUdzSiDxs9XQb9itPnrE_EyhhfQ,7810
+marlenv/models/state.py,sha256=LbP--JxBzRwMFpEAaZyxCX13xKQ27xPE2fabohaq9YI,2058
+marlenv/models/step.py,sha256=00PhD_ccdCIYAY1SVJdJU91weU0Y_tNIJwK16TN_53I,3056
+marlenv/models/transition.py,sha256=UkJVRNxZoyRkjE7YmKtUf_4xA7cOEh20O60dTldbvys,5070
+marlenv/utils/__init__.py,sha256=ky5mz_T7EF65YNaEN1UDCUYZVlz7hFyKResgIJlE_1Q,462
+marlenv/utils/cached_property_collector.py,sha256=IOjbr61f0DqLhcidXKrl7MhN1BOEGiTzCANIKQCxaF0,600
+marlenv/utils/import_placeholders.py,sha256=QN7gsfbFgSP2Lh-7YBC1RH-SNjbFacvRFmBgNs4Eb90,972
+marlenv/utils/schedule.py,sha256=4S0V0RyYHuReVafeHnpfvSLf3oF0buAzD09qMFfexa0,9133
+marlenv/wrappers/__init__.py,sha256=Z4_M-mxRNKQeu52tkmQ4B2m3-zrsmjfXXL5NsWQ4vu4,952
+marlenv/wrappers/action_randomizer.py,sha256=A1kejqGOTA0sc_RQL0EOd6sMSbcIdiV5zlscjKUlzdY,474
+marlenv/wrappers/agent_id_wrapper.py,sha256=i2EhZtWTt4xcu3lPINizg_OS0ISx3DW8lBhKqUxFt2c,1124
+marlenv/wrappers/available_actions_mask.py,sha256=OMyt2KntsR8JA2RuRgvwdzqzPe-_H-KKkbUUJfe_mks,1404
+marlenv/wrappers/available_actions_wrapper.py,sha256=_HRl9zsjJgSrLgVuT-BjpnnfrfM8ic6wBUWlg67uCx4,926
+marlenv/wrappers/blind_wrapper.py,sha256=fEZH4zb8XhC01-G5Oll_rjBdHpvQF-Ax6g6KZgin8Dk,763
+marlenv/wrappers/centralised.py,sha256=HYgdvFrOD8ETXAMLYD_YwdQ02mSGBaEswDZutQFIuvk,3131
+marlenv/wrappers/delayed_rewards.py,sha256=wGj_a0IQ-2OsgMbuBEaiUKbyJLd5dZGcnlxtKTwCjIU,1106
+marlenv/wrappers/last_action_wrapper.py,sha256=Hq4SffR4dhiYmt_LjKhyez56o1Zkiw57617oo8_p4ps,2599
+marlenv/wrappers/paddings.py,sha256=DlYYnPbRPTBcpYuuUQPTlU0ZT4j26WmUIrJP-B5RF44,2020
+marlenv/wrappers/penalty_wrapper.py,sha256=3YBoUV6ETksZ8tFEOq1WYXvPs3ejMAehE6-QA8e4JOE,864
+marlenv/wrappers/potential_shaping.py,sha256=9-CtYe1uGcPTfbc-jx5jHPbgjZ2DpwuyNjmOyhaUvKQ,1659
+marlenv/wrappers/rlenv_wrapper.py,sha256=iFSQsDMkUUbQJKEO8l6SosNi-eOUVSh4pIJVu7aM8Qo,2991
+marlenv/wrappers/state_counter.py,sha256=QmEMb55vOnK-VJuvKsDIIBgcNRsHuovqgpK2pcCY7sA,1211
+marlenv/wrappers/time_limit.py,sha256=HctKeiepPQ2NAIa208SnvknioSkRIuUQ4X-Xhf_XTs0,3974
+marlenv/wrappers/video_recorder.py,sha256=mtWcqaYNCu-zjVXvpa8DJe3_062tpK_TChOu-Xyxs3s,2533
+multi_agent_rlenv-3.7.1.dist-info/METADATA,sha256=1yiAoMwqkzgpKby8KV09M-vVLRgJS5ZKZMqZCfHn80A,5751
+multi_agent_rlenv-3.7.1.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
+multi_agent_rlenv-3.7.1.dist-info/licenses/LICENSE,sha256=_eeiGVoIJ7kYt6l1zbIvSBQppTnw0mjnYk1lQ4FxEjE,1074
+multi_agent_rlenv-3.7.1.dist-info/RECORD,,

{multi_agent_rlenv-3.6.3.dist-info → multi_agent_rlenv-3.7.1.dist-info}/WHEEL

@@ -1,4 +1,4 @@
 Wheel-Version: 1.0
-Generator: hatchling 1.27.0
+Generator: hatchling 1.28.0
 Root-Is-Purelib: true
 Tag: py3-none-any

multi_agent_rlenv-3.6.3.dist-info/RECORD

@@ -1,44 +0,0 @@
-marlenv/__init__.py,sha256=MJgaW73zWYJKTNMWE8V3hTvrcMk-WEX3RaG-K_oIDD8,3886
-marlenv/env_builder.py,sha256=RUMFvW7dAJtHMLm8-oPVpjBefDtNliZtjlHci97Xj-Q,3874
-marlenv/env_pool.py,sha256=nCEBkGQU62fcvCAANyAqY8gCFjYlVnSCg-V3Fhx00yc,933
-marlenv/exceptions.py,sha256=gJUC_2rVAvOfK_ypVFc7Myh-pIfSU3To38VBVS_0rZA,1179
-marlenv/mock_env.py,sha256=kKvTdZl4_xSTTI9V6otZ1P709sfPYrqZSbbZaTip9iI,4684
-marlenv/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-marlenv/adapters/__init__.py,sha256=JsKWaeXvUjWEg3JC9TOtyjtZlTI9AAkLyab-jDa5yzM,783
-marlenv/adapters/gym_adapter.py,sha256=5HZF3g0QD4n7K4GQoMis4q0zj97uFTLdzdxMYHzM_UE,3041
-marlenv/adapters/pettingzoo_adapter.py,sha256=w9Ta-X4L_6ZXdDGmREOdcU0vpLR8lGP__s49DyK3dk8,2852
-marlenv/adapters/pymarl_adapter.py,sha256=2s7EY31s1hrml3q-BBaXo_eDMXTjkebozZPvzsgrb9c,3353
-marlenv/adapters/smac_adapter.py,sha256=8uWC7YKsaSXeTS8AUhpGOKvrWMbVEQT2-pml5BaFUB0,8343
-marlenv/catalog/__init__.py,sha256=dlT_xXdjV9gdXc518xRXC4Np1TSpAMV5Wdwk4M2br8c,351
-marlenv/catalog/deepsea.py,sha256=kwmTkp_iUf1ltpYIcZoZVJKriWSAQa8z6pv7qy4jFDE,2400
-marlenv/models/__init__.py,sha256=uihmRs71Gg5z7Bvau_xtaQVg7xEtX8sTzi74bIHL5P0,443
-marlenv/models/env.py,sha256=BG1iVHxGD_p827mF0ewyOBn6wU2gtFsHLW1b4UtW-V0,7841
-marlenv/models/episode.py,sha256=zsyxsW4LIioPKyY4DZKn64A31e5ZvlwOf3HIGuRUzhs,13531
-marlenv/models/observation.py,sha256=RhvKvmys4bu3UwwVsvu7fJ7TMKt2QkKnBD1e0hw2r7s,3528
-marlenv/models/spaces.py,sha256=1aPmTcoOTU9nlwlcN7aswNrORwghOYAGqCLAMpk39SA,7793
-marlenv/models/state.py,sha256=LbP--JxBzRwMFpEAaZyxCX13xKQ27xPE2fabohaq9YI,2058
-marlenv/models/step.py,sha256=00PhD_ccdCIYAY1SVJdJU91weU0Y_tNIJwK16TN_53I,3056
-marlenv/models/transition.py,sha256=UkJVRNxZoyRkjE7YmKtUf_4xA7cOEh20O60dTldbvys,5070
-marlenv/utils/__init__.py,sha256=ky5mz_T7EF65YNaEN1UDCUYZVlz7hFyKResgIJlE_1Q,462
-marlenv/utils/cached_property_collector.py,sha256=IOjbr61f0DqLhcidXKrl7MhN1BOEGiTzCANIKQCxaF0,600
-marlenv/utils/import_placeholders.py,sha256=QN7gsfbFgSP2Lh-7YBC1RH-SNjbFacvRFmBgNs4Eb90,972
-marlenv/utils/schedule.py,sha256=BdjefYgAtGlh1wWGHENid4WNnPOU78kkNiRvR5A9GEA,9308
-marlenv/wrappers/__init__.py,sha256=Z4_M-mxRNKQeu52tkmQ4B2m3-zrsmjfXXL5NsWQ4vu4,952
-marlenv/wrappers/action_randomizer.py,sha256=A1kejqGOTA0sc_RQL0EOd6sMSbcIdiV5zlscjKUlzdY,474
-marlenv/wrappers/agent_id_wrapper.py,sha256=9qHV3LMQ4AjcDCSuvQhz5h9hUf7Xtrdi2sIxmNZk5NA,1126
-marlenv/wrappers/available_actions_mask.py,sha256=OMyt2KntsR8JA2RuRgvwdzqzPe-_H-KKkbUUJfe_mks,1404
-marlenv/wrappers/available_actions_wrapper.py,sha256=_HRl9zsjJgSrLgVuT-BjpnnfrfM8ic6wBUWlg67uCx4,926
-marlenv/wrappers/blind_wrapper.py,sha256=In4zhygJqWf5ibwq80kf5NtE1fRtHGw-IpAPvBUs1HU,765
-marlenv/wrappers/centralised.py,sha256=1QWxjzLecC3vlf0G3EVC58_v1uR2shluzUa_9HrcN9o,3131
-marlenv/wrappers/delayed_rewards.py,sha256=P8az9rYmu67OzL1ZEFqfTQcCxRI_AXKXrKUBQ3pURl8,1108
-marlenv/wrappers/last_action_wrapper.py,sha256=QVepSLcWExqACwKvAM0G2LALapSoWdd7YHmah2LZ3vE,2603
-marlenv/wrappers/paddings.py,sha256=0aAi7RP1yL8I5mR4Oxzl9-itKys88mgsPjqe7q-frbk,2024
-marlenv/wrappers/penalty_wrapper.py,sha256=3YBoUV6ETksZ8tFEOq1WYXvPs3ejMAehE6-QA8e4JOE,864
-marlenv/wrappers/potential_shaping.py,sha256=T_QvnmWReCgpyoInxRw2UXbmdvcBD5U-vV1ledLG7y8,1661
-marlenv/wrappers/rlenv_wrapper.py,sha256=S6G1VjFklTEzU6bj0AXrTDXnsTQJARq8VB4uUH6AXe4,2993
-marlenv/wrappers/time_limit.py,sha256=GxbxcbfFyuVg14ylQU2C_cjmV9q4uDAt5wepfgX_PyM,3976
-marlenv/wrappers/video_recorder.py,sha256=ucBQSNRPqDr-2mYxrTCqlrWcxSWtSJ7XlRC9-LdukBM,2535
-multi_agent_rlenv-3.6.3.dist-info/METADATA,sha256=jfW3dd1O5u8VurE32m6YTKeDXHU6iIDxF04G8sSisWM,5751
-multi_agent_rlenv-3.6.3.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-multi_agent_rlenv-3.6.3.dist-info/licenses/LICENSE,sha256=_eeiGVoIJ7kYt6l1zbIvSBQppTnw0mjnYk1lQ4FxEjE,1074
-multi_agent_rlenv-3.6.3.dist-info/RECORD,,