multi-agent-rlenv 3.6.3__py3-none-any.whl → 3.7.0__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  # type:ignore[import]
 
 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/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/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/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.0.dist-info}/METADATA

@@ -1,13 +1,13 @@
 Metadata-Version: 2.4
 Name: multi-agent-rlenv
-Version: 3.6.3
+Version: 3.7.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>
 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.0.dist-info/RECORD

@@ -0,0 +1,45 @@
+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=0OuhBvmsMIocwXqfLvU0NC4riEdOHFTYHQptSPzFsyU,8491
+marlenv/catalog/__init__.py,sha256=dlT_xXdjV9gdXc518xRXC4Np1TSpAMV5Wdwk4M2br8c,351
+marlenv/catalog/deepsea.py,sha256=yTyvskWZiAZem11L8cZwHedBIDQ4EAxE2IaUKrjKL2U,2413
+marlenv/catalog/two_steps.py,sha256=lI-q4-Q8283QZTjY0wk7OfXWB6Ln-lquYUjHyT4URi4,2970
+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/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.0.dist-info/METADATA,sha256=r_SzCu0nvthSQ7c4HPL1BR3oFSFG_ZlWRPr1j-IVprM,5751
+multi_agent_rlenv-3.7.0.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
+multi_agent_rlenv-3.7.0.dist-info/licenses/LICENSE,sha256=_eeiGVoIJ7kYt6l1zbIvSBQppTnw0mjnYk1lQ4FxEjE,1074
+multi_agent_rlenv-3.7.0.dist-info/RECORD,,

{multi_agent_rlenv-3.6.3.dist-info → multi_agent_rlenv-3.7.0.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,,