mettagrid 0.2.0.23__tar.gz → 0.2.0.25__tar.gz

{mettagrid-0.2.0.23 → mettagrid-0.2.0.25}/PKG-INFO

@@ -1,13 +1,13 @@
 Metadata-Version: 2.4
 Name: mettagrid
-Version: 0.2.0.23
+Version: 0.2.0.25
 Summary: A fast grid-based open-ended MARL environment
 Author-email: David Bloomin <daveey@gmail.com>
 License-Expression: MIT
 Project-URL: Homepage, https://daveey.github.io
 Project-URL: Repository, https://github.com/Metta-AI/mettagrid
 Keywords: gridworld,minigrid,rl,reinforcement-learning,environment,gym
-Requires-Python: >=3.11
+Requires-Python: <3.13,>=3.11
 Description-Content-Type: text/markdown
 License-File: LICENSE
 Requires-Dist: boto3>=1.38.32

{mettagrid-0.2.0.23 → mettagrid-0.2.0.25}/benchmarks/test_mettagrid_env_benchmark.cpp

@@ -55,7 +55,6 @@ GameConfig CreateBenchmarkConfig(size_t num_agents) {
   actions_cfg.push_back({"swap", action_cfg});
   actions_cfg.push_back({"put_items", action_cfg});
   actions_cfg.push_back({"get_items", action_cfg});
-  actions_cfg.push_back({"change_color", action_cfg});
   actions_cfg.push_back({"change_glyph", change_glyph_cfg});
 
   std::map<std::string, std::shared_ptr<GridObjectConfig>> objects_cfg;

{mettagrid-0.2.0.23 → mettagrid-0.2.0.25}/cpp/bindings/mettagrid_c.cpp

@@ -285,6 +285,70 @@ void MettaGrid::init_action_handlers() {
       _max_action_arg = _max_action_args[i];
     }
   }
+
+  build_flat_action_catalog();
+}
+
+void MettaGrid::build_flat_action_catalog() {
+  _flat_action_map.clear();
+  _flat_action_names.clear();
+  _action_arg_to_flat.clear();
+
+  size_t total_variants = 0;
+  for (unsigned char max_arg : _max_action_args) {
+    total_variants += static_cast<size_t>(max_arg) + 1;
+  }
+
+  _flat_action_map.reserve(total_variants);
+  _flat_action_names.reserve(total_variants);
+  _action_arg_to_flat.resize(_action_handlers.size());
+
+  std::unordered_set<std::string> seen_names;
+  seen_names.reserve(total_variants);
+
+  for (size_t handler_index = 0; handler_index < _action_handlers.size(); ++handler_index) {
+    auto& handler = _action_handlers[handler_index];
+    unsigned char max_arg = _max_action_args[handler_index];
+    auto& arg_map = _action_arg_to_flat[handler_index];
+    arg_map.assign(static_cast<size_t>(max_arg) + 1, -1);
+
+    const int max_arg_int = static_cast<int>(max_arg);
+    for (int raw_arg = 0; raw_arg <= max_arg_int; ++raw_arg) {
+      const ActionArg arg = static_cast<ActionArg>(raw_arg);
+
+      std::string base_name = handler->variant_name(arg);
+      if (base_name.empty()) {
+        base_name = handler->action_name();
+      }
+
+      std::string variant = base_name;
+      int suffix = 1;
+      while (!seen_names.insert(variant).second) {
+        variant = base_name + "_" + std::to_string(suffix++);
+      }
+
+      const auto flat_index = static_cast<int>(_flat_action_map.size());
+      _flat_action_map.emplace_back(static_cast<ActionType>(handler_index), arg);
+      _flat_action_names.emplace_back(std::move(variant));
+      arg_map[static_cast<size_t>(arg)] = flat_index;
+    }
+  }
+}
+
+int MettaGrid::flat_action_index(ActionType action, ActionArg arg) const {
+  if (action < 0) {
+    return -1;
+  }
+  size_t action_idx = static_cast<size_t>(action);
+  if (action_idx >= _action_arg_to_flat.size()) {
+    return -1;
+  }
+  size_t arg_idx = static_cast<size_t>(arg);
+  const auto& mapping = _action_arg_to_flat[action_idx];
+  if (arg_idx >= mapping.size()) {
+    return -1;
+  }
+  return mapping[arg_idx];
 }
 
 void MettaGrid::add_agent(Agent* agent) {
@@ -325,6 +389,7 @@ void MettaGrid::_compute_observation(GridCoord observer_row,
 
   // Build global tokens based on configuration
   std::vector<PartialObservationToken> global_tokens;
+  int flat_action = flat_action_index(action, action_arg);
 
   if (_global_obs_config.episode_completion_pct) {
     ObservationType episode_completion_pct = 0;
@@ -337,7 +402,8 @@ void MettaGrid::_compute_observation(GridCoord observer_row,
   }
 
   if (_global_obs_config.last_action) {
-    global_tokens.push_back({ObservationFeature::LastAction, static_cast<ObservationType>(action)});
+    ObservationType action_value = static_cast<ObservationType>(std::max(0, flat_action));
+    global_tokens.push_back({ObservationFeature::LastAction, action_value});
     global_tokens.push_back({ObservationFeature::LastActionArg, static_cast<ObservationType>(action_arg)});
   }
 
@@ -651,7 +717,56 @@ void MettaGrid::set_buffers(const py::array_t<uint8_t, py::array::c_style>& obse
 }
 
 py::tuple MettaGrid::step(const py::array_t<ActionType, py::array::c_style> actions) {
-  _step(actions);
+  auto info = actions.request();
+  py::array_t<ActionType, py::array::c_style> converted;
+
+  auto assign_flat = [&](auto& view, size_t agent_idx, ActionType flat_index) {
+    if (flat_index < 0 || static_cast<size_t>(flat_index) >= _flat_action_map.size()) {
+      view(agent_idx, 0) = -1;
+      view(agent_idx, 1) = 0;
+      return;
+    }
+    const auto& mapping = _flat_action_map[static_cast<size_t>(flat_index)];
+    view(agent_idx, 0) = mapping.first;
+    view(agent_idx, 1) = mapping.second;
+  };
+
+  if (info.ndim == 1) {
+    if (info.shape[0] != static_cast<ssize_t>(_agents.size())) {
+      throw std::runtime_error("actions has the wrong shape");
+    }
+    auto view = actions.unchecked<1>();
+    converted = py::array_t<ActionType, py::array::c_style>(
+        py::array::ShapeContainer{static_cast<ssize_t>(_agents.size()), static_cast<ssize_t>(2)});
+    auto converted_view = converted.mutable_unchecked<2>();
+    for (size_t agent_idx = 0; agent_idx < _agents.size(); ++agent_idx) {
+      auto flat_index = view(agent_idx);
+      assign_flat(converted_view, agent_idx, flat_index);
+    }
+    _step(converted);
+  } else if (info.ndim == 2) {
+    if (info.shape[0] != static_cast<ssize_t>(_agents.size())) {
+      throw std::runtime_error("actions has the wrong shape");
+    }
+
+    if (info.shape[1] == 1) {
+      auto view = actions.unchecked<2>();
+      converted = py::array_t<ActionType, py::array::c_style>(
+          py::array::ShapeContainer{static_cast<ssize_t>(_agents.size()), static_cast<ssize_t>(2)});
+      auto converted_view = converted.mutable_unchecked<2>();
+      for (size_t agent_idx = 0; agent_idx < _agents.size(); ++agent_idx) {
+        auto flat_index = view(agent_idx, 0);
+        assign_flat(converted_view, agent_idx, flat_index);
+      }
+      _step(converted);
+    } else if (info.shape[1] == 2) {
+      _step(actions);
+    } else {
+      throw std::runtime_error("actions has the wrong shape");
+    }
+  } else {
+    throw std::runtime_error("actions has the wrong shape");
+  }
 
   auto rewards_view = _rewards.mutable_unchecked<1>();
 
@@ -876,8 +991,8 @@ py::dict MettaGrid::grid_objects(int min_row, int max_row, int min_col, int max_
 
 py::list MettaGrid::action_names() {
   py::list names;
-  for (const auto& handler : _action_handlers) {
-    names.append(handler->action_name());
+  for (const auto& name : _flat_action_names) {
+    names.append(py::str(name));
   }
   return names;
 }
@@ -947,10 +1062,7 @@ py::object MettaGrid::action_space() {
   auto gym = py::module_::import("gymnasium");
   auto spaces = gym.attr("spaces");
 
-  size_t number_of_actions = py::len(action_names());
-  size_t number_of_action_args = _max_action_arg + 1;
-  return spaces.attr("MultiDiscrete")(py::make_tuple(number_of_actions, number_of_action_args),
-                                      py::arg("dtype") = dtype_actions());
+  return spaces.attr("Discrete")(py::int_(_flat_action_map.size()));
 }
 
 py::object MettaGrid::observation_space() {

{mettagrid-0.2.0.23 → mettagrid-0.2.0.25}/cpp/bindings/mettagrid_c.hpp

@@ -162,6 +162,10 @@ private:
   std::mt19937 _rng;
   unsigned int _seed;
 
+  std::vector<std::pair<ActionType, ActionArg>> _flat_action_map;
+  std::vector<std::string> _flat_action_names;
+  std::vector<std::vector<int>> _action_arg_to_flat;
+
   // Movement tracking
   bool _track_movement_metrics;
   float _resource_loss_prob;
@@ -188,6 +192,8 @@ private:
   AgentConfig _create_agent_config(const py::dict& agent_group_cfg_py);
   ConverterConfig _create_converter_config(const py::dict& converter_cfg_py);
   WallConfig _create_wall_config(const py::dict& wall_cfg_py);
+  void build_flat_action_catalog();
+  int flat_action_index(ActionType action, ActionArg arg) const;
 };
 
 #endif  // PACKAGES_METTAGRID_CPP_BINDINGS_METTAGRID_C_HPP_

{mettagrid-0.2.0.23 → mettagrid-0.2.0.25}/cpp/include/mettagrid/actions/action_handler.hpp

@@ -144,6 +144,13 @@ public:
     return _action_name;
   }
 
+  virtual std::string variant_name(ActionArg arg) const {
+    if (max_arg() == 0) {
+      return _action_name;
+    }
+    return _action_name + "_" + std::to_string(static_cast<int>(arg));
+  }
+
 protected:
   virtual bool _handle_action(Agent& actor, ActionArg arg) = 0;
 

{mettagrid-0.2.0.23 → mettagrid-0.2.0.25}/cpp/include/mettagrid/actions/move.hpp

@@ -88,6 +88,14 @@ protected:
     return _grid->move_object(actor, target_location);
   }
 
+  std::string variant_name(ActionArg arg) const override {
+    Orientation move_direction = static_cast<Orientation>(arg);
+    if (!isValidOrientation(move_direction, _game_config->allow_diagonals)) {
+      return ActionHandler::variant_name(arg);
+    }
+    return std::string(action_name()) + "_" + OrientationFullNames[static_cast<size_t>(move_direction)];
+  }
+
 private:
   const GameConfig* _game_config;
 };

{mettagrid-0.2.0.23 → mettagrid-0.2.0.25}/cpp/include/mettagrid/actions/orientation.hpp

@@ -125,4 +125,15 @@ inline const char* OrientationNames[8] = {
     "SE"   // 7
 };
 
+inline const char* OrientationFullNames[8] = {
+    "north",      // 0
+    "south",      // 1
+    "west",       // 2
+    "east",       // 3
+    "northwest",  // 4
+    "northeast",  // 5
+    "southwest",  // 6
+    "southeast"   // 7
+};
+
 #endif  // PACKAGES_METTAGRID_CPP_INCLUDE_METTAGRID_ACTIONS_ORIENTATION_HPP_

{mettagrid-0.2.0.23 → mettagrid-0.2.0.25}/cpp/include/mettagrid/actions/resource_mod.hpp

@@ -63,6 +63,13 @@ public:
   }
 
 protected:
+  std::string variant_name(ActionArg arg) const override {
+    if (arg == 0) {
+      return action_name();
+    }
+    return ActionHandler::variant_name(arg);
+  }
+
   bool _handle_action(Agent& actor, ActionArg /* arg */) override {
     // Center AoE on actor's position
     int center_row = static_cast<int>(actor.location.r);

{mettagrid-0.2.0.23 → mettagrid-0.2.0.25}/cpp/include/mettagrid/actions/rotate.hpp

@@ -42,6 +42,14 @@ protected:
     return true;
   }
 
+  std::string variant_name(ActionArg arg) const override {
+    Orientation orientation = static_cast<Orientation>(arg);
+    if (!_game_config->allow_diagonals && isDiagonal(orientation)) {
+      return ActionHandler::variant_name(arg);
+    }
+    return std::string(action_name()) + "_" + OrientationFullNames[static_cast<size_t>(orientation)];
+  }
+
 private:
   const GameConfig* _game_config;
 };

{mettagrid-0.2.0.23 → mettagrid-0.2.0.25}/demos/README.md

@@ -169,7 +169,7 @@ flag.
 
 **PettingZoo test closes env**: Don't try to reuse the same env instance after `parallel_api_test`; create a new one.
 
-**Action data types**: Make sure actions are `int32` for MultiDiscrete spaces (Puffer/PettingZoo).
+**Action data types**: Make sure actions are `int32` scalars for the discrete action space.
 
 **SB3 shape complaints**: Verify you're using the single-agent wrapper and that obs/action spaces match SB3
 expectations.

{mettagrid-0.2.0.23 → mettagrid-0.2.0.25}/demos/demo_train_gym.py

@@ -63,7 +63,7 @@ def demo_single_agent_gym():
     from gymnasium import spaces
 
     assert isinstance(env.observation_space, spaces.Box), "Single-agent obs space should be Box"
-    assert isinstance(env.action_space, spaces.MultiDiscrete), "Single-agent action space should be MultiDiscrete"
+    assert isinstance(env.action_space, spaces.Discrete), "Single-agent action space should be Discrete"
     print("Single-agent Gymnasium compatibility verified")
 
     env.close()

{mettagrid-0.2.0.23 → mettagrid-0.2.0.25}/demos/demo_train_pettingzoo.py

@@ -78,10 +78,8 @@ def demo_random_rollout():
         actions = {}
         for agent in env.agents:
             action_space = env.action_space(agent)
-            if isinstance(action_space, spaces.MultiDiscrete):
-                actions[agent] = np.random.randint(0, action_space.nvec, size=len(action_space.nvec), dtype=np.int32)
-            else:
-                actions[agent] = action_space.sample()
+            assert isinstance(action_space, spaces.Discrete)
+            actions[agent] = int(action_space.sample())
 
         _, rewards, terminations, truncations, _ = env.step(actions)
 
@@ -124,14 +122,8 @@ def demo_simple_marl_training():
     policies = {}
     for agent in env.possible_agents:
         action_space = env.action_space(agent)
-        if isinstance(action_space, spaces.MultiDiscrete):
-            # MultiDiscrete case
-            policies[agent] = (
-                np.ones((len(action_space.nvec), max(action_space.nvec))) / action_space.nvec[:, np.newaxis]
-            )
-        elif isinstance(action_space, spaces.Discrete):
-            # Discrete case
-            policies[agent] = np.ones(action_space.n) / action_space.n
+        assert isinstance(action_space, spaces.Discrete)
+        policies[agent] = np.ones(action_space.n) / action_space.n
 
     _, _ = env.reset(seed=42)
     total_rewards = {agent: 0 for agent in env.possible_agents}
@@ -145,36 +137,24 @@ def demo_simple_marl_training():
         for agent in env.agents:
             if agent in policies:
                 action_space = env.action_space(agent)
-                if isinstance(action_space, spaces.MultiDiscrete):
-                    # MultiDiscrete case
-                    action = []
-                    for i, nvec in enumerate(action_space.nvec):
-                        probs = policies[agent][i, :nvec]
-                        probs = probs / probs.sum()
-                        action.append(np.random.choice(nvec, p=probs))
-                    actions[agent] = np.array(action, dtype=np.int32)
-                elif isinstance(action_space, spaces.Discrete):
-                    # Discrete case
-                    probs = policies[agent] / policies[agent].sum()
-                    actions[agent] = np.random.choice(action_space.n, p=probs)
+                assert isinstance(action_space, spaces.Discrete)
+                probs = policies[agent]
+                probs = probs / probs.sum()
+                actions[agent] = int(np.random.choice(action_space.n, p=probs))
             else:
-                actions[agent] = env.action_space(agent).sample()
+                action_space = env.action_space(agent)
+                assert isinstance(action_space, spaces.Discrete)
+                actions[agent] = int(action_space.sample())
 
         _, rewards, terminations, truncations, _ = env.step(actions)
 
         for agent, reward in rewards.items():
             if agent in policies and agent in actions and reward > 0:
-                action_taken = actions[agent]
+                action_taken = int(actions[agent])
                 action_space = env.action_space(agent)
-                if isinstance(action_space, spaces.MultiDiscrete):
-                    # MultiDiscrete case
-                    for i, a in enumerate(action_taken):
-                        policies[agent][i, a] *= 1.1
-                        policies[agent][i] /= policies[agent][i].sum()
-                elif isinstance(action_space, spaces.Discrete):
-                    # Discrete case
-                    policies[agent][action_taken] *= 1.1
-                    policies[agent] /= policies[agent].sum()
+                assert isinstance(action_space, spaces.Discrete)
+                policies[agent][action_taken] *= 1.1
+                policies[agent] /= policies[agent].sum()
 
             total_rewards[agent] += reward
 

{mettagrid-0.2.0.23 → mettagrid-0.2.0.25}/demos/demo_train_puffer.py

@@ -32,7 +32,7 @@ import numpy as np
 
 # MettaGrid imports
 # Note: MettaGridEnv inherits from PufferEnv, so it's fully PufferLib-compatible
-from mettagrid import MettaGridEnv
+from mettagrid import MettaGridEnv, dtype_actions
 from mettagrid.builder.envs import make_arena
 from mettagrid.config.mettagrid_config import MettaGridConfig
 
@@ -75,20 +75,8 @@ def demo_puffer_env():
     # Generate random actions compatible with the action space
     from gymnasium import spaces
 
-    if isinstance(env.action_space, spaces.MultiDiscrete):
-        # MultiDiscrete case
-        actions = np.zeros((env.num_agents, len(env.action_space.nvec)), dtype=np.int32)
-        for i in range(env.num_agents):
-            for j, n in enumerate(env.action_space.nvec):
-                actions[i, j] = np.random.randint(0, n)
-    else:
-        # Box case
-        actions = np.random.randint(
-            env.action_space.low,
-            env.action_space.high + 1,
-            size=env.action_space.shape,
-            dtype=np.int32,
-        )
+    assert isinstance(env.action_space, spaces.Discrete)
+    actions = np.random.randint(0, env.action_space.n, size=(env.num_agents,)).astype(dtype_actions, copy=False)
 
     _, rewards, terminals, truncations, _ = env.step(actions)
     print(f"   - Step successful: obs {observations.shape}, rewards {rewards.shape}")
@@ -123,17 +111,8 @@ def demo_random_rollout():
         # Generate random actions for all agents
         from gymnasium import spaces
 
-        if isinstance(env.action_space, spaces.MultiDiscrete):
-            # MultiDiscrete case
-            actions = np.zeros((env.num_agents, len(env.action_space.nvec)), dtype=np.int32)
-            for i in range(env.num_agents):
-                for j, n in enumerate(env.action_space.nvec):
-                    actions[i, j] = np.random.randint(0, n)
-        else:
-            # Box case
-            actions = np.random.randint(
-                env.action_space.low, env.action_space.high + 1, size=env.action_space.shape, dtype=np.int32
-            )
+        assert isinstance(env.action_space, spaces.Discrete)
+        actions = np.random.randint(0, env.action_space.n, size=(env.num_agents,)).astype(dtype_actions, copy=False)
 
         _, rewards, terminals, truncations, _ = env.step(actions)
         total_reward += rewards.sum()
@@ -195,63 +174,25 @@ def demo_pufferlib_training():
         # Initialize simple policies based on action space type
         from gymnasium import spaces
 
-        if isinstance(env.action_space, spaces.MultiDiscrete):
-            # MultiDiscrete: maintain preferences per action value
-            action_preferences = []
-            for n in env.action_space.nvec:
-                action_preferences.append(np.ones(n) / n)
-        else:
-            # Box: track preferences for discretized bins
-            action_low = env.action_space.low
-            action_high = env.action_space.high
-            num_bins = 10
-            action_preferences = np.ones((env.num_agents, env.action_space.shape[1], num_bins))
+        assert isinstance(env.action_space, spaces.Discrete)
+        action_preferences = np.ones(env.action_space.n)
 
         for _ in range(max_steps):
             # Sample actions based on current preferences
-            if isinstance(env.action_space, spaces.MultiDiscrete):
-                # MultiDiscrete case
-                actions = np.zeros((env.num_agents, len(env.action_space.nvec)), dtype=np.int32)
-                for i in range(env.num_agents):
-                    for j, n in enumerate(env.action_space.nvec):
-                        probs = action_preferences[j] / action_preferences[j].sum()
-                        actions[i, j] = np.random.choice(n, p=probs)
-            else:
-                # Box case
-                actions = np.zeros((env.num_agents, env.action_space.shape[1]), dtype=np.int32)
-                for i in range(env.num_agents):
-                    for j in range(env.action_space.shape[1]):
-                        # Convert preferences to probabilities
-                        probs = action_preferences[i, j] / action_preferences[i, j].sum()
-                        # Sample bin and convert to action value
-                        bin_idx = np.random.choice(num_bins, p=probs)
-                        action_range = action_high[i, j] - action_low[i, j] + 1
-                        action_val = int(action_low[i, j] + (bin_idx * action_range) / num_bins)
-                        action_val = np.clip(action_val, action_low[i, j], action_high[i, j])
-                        actions[i, j] = action_val
+            probs = action_preferences / action_preferences.sum()
+            actions = np.random.choice(env.action_space.n, size=env.num_agents, p=probs).astype(
+                dtype_actions, copy=False
+            )
 
             _, rewards, terminals, truncations, _ = env.step(actions)
             total_reward += rewards.sum()
             steps += 1
 
             # Simple "learning": increase preference for actions that led to positive rewards
-            if isinstance(env.action_space, spaces.MultiDiscrete):
-                # MultiDiscrete learning
-                for i in range(env.num_agents):
-                    if rewards[i] > 0:
-                        for j in range(len(env.action_space.nvec)):
-                            action_preferences[j][actions[i, j]] *= 1.1
-            else:
-                # Box learning
-                for i in range(env.num_agents):
-                    if rewards[i] > 0:
-                        for j in range(env.action_space.shape[1]):
-                            # Find which bin the action belonged to
-                            action_range = action_high[i, j] - action_low[i, j] + 1
-                            bin_idx = int((actions[i, j] - action_low[i, j]) * num_bins / action_range)
-                            bin_idx = np.clip(bin_idx, 0, num_bins - 1)
-                            # Increase preference for this bin
-                            action_preferences[i, j, bin_idx] *= 1.1
+            if rewards.any():
+                for action, reward in zip(actions, rewards, strict=False):
+                    if reward > 0:
+                        action_preferences[action] *= 1.1
 
             if terminals.any() or truncations.any():
                 _, _ = env.reset()

{mettagrid-0.2.0.23 → mettagrid-0.2.0.25}/mettagrid.egg-info/PKG-INFO

@@ -1,13 +1,13 @@
 Metadata-Version: 2.4
 Name: mettagrid
-Version: 0.2.0.23
+Version: 0.2.0.25
 Summary: A fast grid-based open-ended MARL environment
 Author-email: David Bloomin <daveey@gmail.com>
 License-Expression: MIT
 Project-URL: Homepage, https://daveey.github.io
 Project-URL: Repository, https://github.com/Metta-AI/mettagrid
 Keywords: gridworld,minigrid,rl,reinforcement-learning,environment,gym
-Requires-Python: >=3.11
+Requires-Python: <3.13,>=3.11
 Description-Content-Type: text/markdown
 License-File: LICENSE
 Requires-Dist: boto3>=1.38.32

{mettagrid-0.2.0.23 → mettagrid-0.2.0.25}/mettagrid.egg-info/SOURCES.txt

@@ -399,7 +399,6 @@ python/src/mettagrid/map_builder/random.py
 python/src/mettagrid/map_builder/utils.py
 python/src/mettagrid/mapgen/__init__.py
 python/src/mettagrid/mapgen/area.py
-python/src/mettagrid/mapgen/load.py
 python/src/mettagrid/mapgen/mapgen.py
 python/src/mettagrid/mapgen/mapgen_ascii.py
 python/src/mettagrid/mapgen/scene.py
@@ -724,7 +723,6 @@ python/src/mettagrid/mapgen/scenes/dcss/wfc/zelgadis_glass_arrival_small.yaml
 python/src/mettagrid/mapgen/tools/dcss_import.py
 python/src/mettagrid/mapgen/tools/gen.py
 python/src/mettagrid/mapgen/tools/gen_scene.py
-python/src/mettagrid/mapgen/tools/view.py
 python/src/mettagrid/mapgen/utils/ascii_grid.py
 python/src/mettagrid/mapgen/utils/draw.py
 python/src/mettagrid/mapgen/utils/make_scene_config.py

{mettagrid-0.2.0.23 → mettagrid-0.2.0.25}/nim/mettascope/README.md

@@ -24,5 +24,5 @@ cd mettascope2
 ## Running
 
 ```
-./tools/run.py experiments.recipes.arena.play mettascope2=true
+./tools/run.py arena.play mettascope2=true
 ```

{mettagrid-0.2.0.23 → mettagrid-0.2.0.25}/pyproject.toml

@@ -8,7 +8,7 @@ name = "mettagrid" # Do not change! Has to be 'mettagrid' for our PyPi package
 dynamic = ["version"]
 description = "A fast grid-based open-ended MARL environment"
 authors = [{ name = "David Bloomin", email = "daveey@gmail.com" }]
-requires-python = ">=3.11"
+requires-python = ">=3.11,<3.13"
 license = "MIT"
 readme = "README.md"
 urls = { Homepage = "https://daveey.github.io", Repository = "https://github.com/Metta-AI/mettagrid" }

{mettagrid-0.2.0.23 → mettagrid-0.2.0.25}/python/src/mettagrid/__init__.py

@@ -47,7 +47,7 @@ _LAZY_ATTRS: Dict[str, Tuple[str, str]] = {
     ),
     "validate_action_space": ("mettagrid.types", "validate_action_space"),
     "get_observation_shape": ("mettagrid.types", "get_observation_shape"),
-    "get_action_nvec": ("mettagrid.types", "get_action_nvec"),
+    "get_action_count": ("mettagrid.types", "get_action_count"),
     # Supporting classes
     "GameMap": ("mettagrid.map_builder.map_builder", "GameMap"),
     "ReplayWriter": ("mettagrid.util.replay_writer", "ReplayWriter"),
@@ -71,7 +71,7 @@ if TYPE_CHECKING:
         dtype_truncations,
     )
     from mettagrid.types import (
-        get_action_nvec,
+        get_action_count,
         get_observation_shape,
         validate_action_space,
         validate_observation_space,
@@ -108,7 +108,7 @@ __all__ = [
     "validate_observation_space",
     "validate_action_space",
     "get_observation_shape",
-    "get_action_nvec",
+    "get_action_count",
     # Supporting classes
     "GameMap",
     "ReplayWriter",

{mettagrid-0.2.0.23 → mettagrid-0.2.0.25}/python/src/mettagrid/config/mettagrid_config.py

@@ -112,7 +112,7 @@ class GlobalObsConfig(Config):
 
     episode_completion_pct: bool = Field(default=True)
 
-    # Controls both last_action and last_action_arg
+    # Controls whether the last_action global token is included
     last_action: bool = Field(default=True)
 
     last_reward: bool = Field(default=True)