Mesa 3.1.0__py3-none-any.whl → 3.1.0.dev0__py3-none-any.whl

mesa/__init__.py

@@ -13,16 +13,16 @@ from mesa.datacollection import DataCollector
 from mesa.model import Model
 
 __all__ = [
+    "Model",
     "Agent",
+    "space",
     "DataCollector",
-    "Model",
     "batch_run",
     "experimental",
-    "space",
 ]
 
 __title__ = "mesa"
-__version__ = "3.1.0"
+__version__ = "3.1.0.dev"
 __license__ = "Apache 2.0"
 _this_year = datetime.datetime.now(tz=datetime.UTC).date().year
 __copyright__ = f"Copyright {_this_year} Project Mesa Team"

mesa/agent.py

@@ -85,54 +85,6 @@ class Agent:
     def advance(self) -> None:  # noqa: D102
         pass
 
-    @classmethod
-    def create_agents(cls, model: Model, n: int, *args, **kwargs) -> AgentSet[Agent]:
-        """Create N agents.
-
-        Args:
-            model: the model to which the agents belong
-            args: arguments to pass onto agent instances
-                  each arg is either a single object or a sequence of length n
-            n: the number of agents to create
-            kwargs: keyword arguments to pass onto agent instances
-                   each keyword arg is either a single object or a sequence of length n
-
-        Returns:
-            AgentSet containing the agents created.
-
-        """
-
-        class ListLike:
-            """Helper class to make default arguments act as if they are in a list of length N."""
-
-            def __init__(self, value):
-                self.value = value
-
-            def __getitem__(self, i):
-                return self.value
-
-        listlike_args = []
-        for arg in args:
-            if isinstance(arg, (list | np.ndarray | tuple)) and len(arg) == n:
-                listlike_args.append(arg)
-            else:
-                listlike_args.append(ListLike(arg))
-
-        listlike_kwargs = {}
-        for k, v in kwargs.items():
-            if isinstance(v, (list | np.ndarray | tuple)) and len(v) == n:
-                listlike_kwargs[k] = v
-            else:
-                listlike_kwargs[k] = ListLike(v)
-
-        agents = []
-        for i in range(n):
-            instance_args = [arg[i] for arg in listlike_args]
-            instance_kwargs = {k: v[i] for k, v in listlike_kwargs.items()}
-            agent = cls(model, *instance_args, **instance_kwargs)
-            agents.append(agent)
-        return AgentSet(agents, random=model.random)
-
     @property
     def random(self) -> Random:
         """Return a seeded stdlib rng."""

mesa/batchrunner.py

@@ -106,14 +106,7 @@ def _make_model_kwargs(
     Parameters
     ----------
     parameters : Mapping[str, Union[Any, Iterable[Any]]]
-        Single or multiple values for each model parameter name.
-
-        Allowed values for each parameter:
-        - A single value (e.g., `32`, `"relu"`).
-        - A non-empty iterable (e.g., `[0.01, 0.1]`, `["relu", "sigmoid"]`).
-
-        Not allowed:
-        - Empty lists or empty iterables (e.g., `[]`, `()`, etc.). These should be removed manually.
+        Single or multiple values for each model parameter name
 
     Returns:
     -------
@@ -125,12 +118,6 @@ def _make_model_kwargs(
         if isinstance(values, str):
             # The values is a single string, so we shouldn't iterate over it.
             all_values = [(param, values)]
-        elif isinstance(values, list | tuple | set) and len(values) == 0:
-            # If it's an empty iterable, raise an error
-            raise ValueError(
-                f"Parameter '{param}' contains an empty iterable, which is not allowed."
-            )
-
         else:
             try:
                 all_values = [(param, value) for value in values]

mesa/datacollection.py

@@ -228,7 +228,12 @@ class DataCollector:
             reports = tuple(rep(agent) for rep in rep_funcs)
             return _prefix + reports
 
-        agent_records = map(get_reports, model.agents)
+        agent_records = map(
+            get_reports,
+            model.schedule.agents
+            if hasattr(model, "schedule") and model.schedule is not None
+            else model.agents,
+        )
         return agent_records
 
     def _record_agenttype(self, model, agent_type):

mesa/examples/__init__.py

@@ -12,10 +12,10 @@ __all__ = [
     "BoidFlockers",
     "BoltzmannWealth",
     "ConwaysGameOfLife",
+    "Schelling",
+    "VirusOnNetwork",
     "EpsteinCivilViolence",
     "PdGrid",
-    "Schelling",
     "SugarscapeG1mt",
-    "VirusOnNetwork",
     "WolfSheep",
 ]

mesa/examples/advanced/epstein_civil_violence/app.py

@@ -44,11 +44,6 @@ def post_process(ax):
 
 
 model_params = {
-    "seed": {
-        "type": "InputText",
-        "value": 42,
-        "label": "Random Seed",
-    },
     "height": 40,
     "width": 40,
     "citizen_density": Slider("Initial Agent Density", 0.7, 0.0, 0.9, 0.1),

mesa/examples/advanced/pd_grid/app.py

@@ -24,11 +24,6 @@ def pd_agent_portrayal(agent):
 
 # Model parameters
 model_params = {
-    "seed": {
-        "type": "InputText",
-        "value": 42,
-        "label": "Random Seed",
-    },
     "width": Slider("Grid Width", value=50, min=10, max=100, step=1),
     "height": Slider("Grid Height", value=50, min=10, max=100, step=1),
     "activation_order": {

mesa/examples/advanced/sugarscape_g1mt/app.py

@@ -47,11 +47,6 @@ def SpaceDrawer(model):
 
 
 model_params = {
-    "seed": {
-        "type": "InputText",
-        "value": 42,
-        "label": "Random Seed",
-    },
     "width": 50,
     "height": 50,
     # Population parameters
@@ -71,10 +66,10 @@ model_params = {
     "enable_trade": {"type": "Checkbox", "value": True, "label": "Enable Trading"},
 }
 
-model = SugarscapeG1mt()
+model1 = SugarscapeG1mt()
 
 page = SolaraViz(
-    model,
+    model1,
     components=[SpaceDrawer, make_plot_component(["Trader", "Price"])],
     model_params=model_params,
     name="Sugarscape {G1, M, T}",

mesa/examples/basic/boid_flockers/app.py

@@ -12,11 +12,6 @@ def boid_draw(agent):
 
 
 model_params = {
-    "seed": {
-        "type": "InputText",
-        "value": 42,
-        "label": "Random Seed",
-    },
     "population": Slider(
         label="Number of boids",
         value=100,

mesa/examples/basic/boltzmann_wealth_model/app.py

@@ -1,13 +1,10 @@
 from mesa.examples.basic.boltzmann_wealth_model.model import BoltzmannWealth
-from mesa.mesa_logging import DEBUG, log_to_stderr
 from mesa.visualization import (
     SolaraViz,
     make_plot_component,
     make_space_component,
 )
 
-log_to_stderr(DEBUG)
-
 
 def agent_portrayal(agent):
     color = agent.wealth  # we are using a colormap to translate wealth to color
@@ -15,11 +12,6 @@ def agent_portrayal(agent):
 
 
 model_params = {
-    "seed": {
-        "type": "InputText",
-        "value": 42,
-        "label": "Random Seed",
-    },
     "n": {
         "type": "SliderInt",
         "value": 50,
@@ -28,6 +20,11 @@ model_params = {
         "max": 100,
         "step": 1,
     },
+    "seed": {
+        "type": "InputText",
+        "value": 42,
+        "label": "Random Seed",
+    },
     "width": 10,
     "height": 10,
 }

mesa/examples/basic/boltzmann_wealth_model/st_app.py

@@ -68,7 +68,7 @@ if run:
     for i in range(num_ticks):
         model.step()
         my_bar.progress((i / num_ticks), text="Simulation progress")
-        placeholder.text(f"Step = {i}")
+        placeholder.text("Step = %d" % i)
         for cell in model.grid.coord_iter():
             cell_content, (x, y) = cell
             agent_count = len(cell_content)

mesa/examples/basic/conways_game_of_life/app.py

@@ -20,11 +20,6 @@ def post_process(ax):
 
 
 model_params = {
-    "seed": {
-        "type": "InputText",
-        "value": 42,
-        "label": "Random Seed",
-    },
     "width": {
         "type": "SliderInt",
         "value": 50,

mesa/examples/basic/conways_game_of_life/st_app.py

@@ -49,9 +49,9 @@ if run:
     for i in range(num_ticks):
         model.step()
         my_bar.progress((i / num_ticks), text="Simulation progress")
-        placeholder.text(f"Step = {i}")
+        placeholder.text("Step = %d" % i)
         for contents, (x, y) in model.grid.coord_iter():
-            # print(f"x: {x}, y: {y}, state: {contents}")
+            # print('x:',x,'y:',y, 'state:',contents)
             selected_row = df_grid[(df_grid["x"] == x) & (df_grid["y"] == y)]
             df_grid.loc[selected_row.index, "state"] = (
                 contents.state

mesa/examples/basic/schelling/app.py

@@ -19,11 +19,6 @@ def agent_portrayal(agent):
 
 
 model_params = {
-    "seed": {
-        "type": "InputText",
-        "value": 42,
-        "label": "Random Seed",
-    },
     "density": Slider("Agent density", 0.8, 0.1, 1.0, 0.1),
     "minority_pc": Slider("Fraction minority", 0.2, 0.0, 1.0, 0.05),
     "homophily": Slider("Homophily", 3, 0, 8, 1),

mesa/examples/basic/virus_on_network/app.py

@@ -35,11 +35,6 @@ def get_resistant_susceptible_ratio(model):
 
 
 model_params = {
-    "seed": {
-        "type": "InputText",
-        "value": 42,
-        "label": "Random Seed",
-    },
     "num_nodes": Slider(
         label="Number of agents",
         value=10,

mesa/experimental/UserParam.py

@@ -0,0 +1,67 @@
+"""helper classes."""
+
+
+class UserParam:  # noqa: D101
+    _ERROR_MESSAGE = "Missing or malformed inputs for '{}' Option '{}'"
+
+    def maybe_raise_error(self, param_type, valid):  # noqa: D102
+        if valid:
+            return
+        msg = self._ERROR_MESSAGE.format(param_type, self.label)
+        raise ValueError(msg)
+
+
+class Slider(UserParam):
+    """A number-based slider input with settable increment.
+
+    Example:
+    slider_option = Slider("My Slider", value=123, min=10, max=200, step=0.1)
+
+    Args:
+        label: The displayed label in the UI
+        value: The initial value of the slider
+        min: The minimum possible value of the slider
+        max: The maximum possible value of the slider
+        step: The step between min and max for a range of possible values
+        dtype: either int or float
+    """
+
+    def __init__(
+        self,
+        label="",
+        value=None,
+        min=None,
+        max=None,
+        step=1,
+        dtype=None,
+    ):
+        """Slider class.
+
+        Args:
+            label: The displayed label in the UI
+            value: The initial value of the slider
+            min: The minimum possible value of the slider
+            max: The maximum possible value of the slider
+            step: The step between min and max for a range of possible values
+            dtype: either int or float
+        """
+        self.label = label
+        self.value = value
+        self.min = min
+        self.max = max
+        self.step = step
+
+        # Validate option type to make sure values are supplied properly
+        valid = not (self.value is None or self.min is None or self.max is None)
+        self.maybe_raise_error("slider", valid)
+
+        if dtype is None:
+            self.is_float_slider = self._check_values_are_float(value, min, max, step)
+        else:
+            self.is_float_slider = dtype is float
+
+    def _check_values_are_float(self, value, min, max, step):
+        return any(isinstance(n, float) for n in (value, min, max, step))
+
+    def get(self, attr):  # noqa: D102
+        return getattr(self, attr)

mesa/experimental/__init__.py

@@ -1,20 +1,13 @@
-"""Experimental features package for Mesa.
+"""Experimental init."""
 
-This package contains modules that are under active development and testing. These
-features are provided to allow early access and feedback from the Mesa community, but
-their APIs may change between releases without following semantic versioning.
+from mesa.experimental import cell_space
 
-Current experimental modules:
-    cell_space: Alternative API for discrete spaces with cell-centric functionality
-    devs: Discrete event simulation system for scheduling events at arbitrary times
-    mesa_signals: Reactive programming capabilities for tracking state changes
+try:
+    from .solara_viz import JupyterViz, Slider, SolaraViz, make_text
 
-Notes:
-    - Features in this package may be changed or removed without notice
-    - APIs are not guaranteed to be stable between releases
-    - Features graduate from experimental status once their APIs are stabilized
-"""
-
-from mesa.experimental import cell_space, devs, mesa_signals
-
-__all__ = ["cell_space", "devs", "mesa_signals"]
+    __all__ = ["cell_space", "JupyterViz", "Slider", "SolaraViz", "make_text"]
+except ImportError:
+    print(
+        "Could not import SolaraViz. If you need it, install with 'pip install --pre mesa[viz]'"
+    )
+    __all__ = ["cell_space"]

mesa/experimental/cell_space/__init__.py

@@ -1,18 +1,8 @@
-"""Cell spaces for active, property-rich spatial modeling in Mesa.
+"""Cell spaces.
 
-Cell spaces extend Mesa's spatial modeling capabilities by making the space itself active -
-each position (cell) can have properties and behaviors rather than just containing agents.
-This enables more sophisticated environmental modeling and agent-environment interactions.
+Cell spaces offer an alternative API for discrete spaces. It is experimental and under development. The API is more
+expressive that the default grids available in `mesa.space`.
 
-Key components:
-- Cells: Active positions that can have properties and contain agents
-- CellAgents: Agents that understand how to interact with cells
-- Spaces: Different cell organization patterns (grids, networks, etc.)
-- PropertyLayers: Efficient property storage and manipulation
-
-This is particularly useful for models where the environment plays an active role,
-like resource growth, pollution diffusion, or infrastructure networks. The cell
-space system is experimental and under active development.
 """
 
 from mesa.experimental.cell_space.cell import Cell
@@ -30,21 +20,19 @@ from mesa.experimental.cell_space.grid import (
     OrthogonalVonNeumannGrid,
 )
 from mesa.experimental.cell_space.network import Network
-from mesa.experimental.cell_space.property_layer import PropertyLayer
 from mesa.experimental.cell_space.voronoi import VoronoiGrid
 
 __all__ = [
+    "CellCollection",
     "Cell",
     "CellAgent",
-    "CellCollection",
-    "DiscreteSpace",
+    "Grid2DMovingAgent",
     "FixedAgent",
+    "DiscreteSpace",
     "Grid",
-    "Grid2DMovingAgent",
     "HexGrid",
-    "Network",
     "OrthogonalMooreGrid",
     "OrthogonalVonNeumannGrid",
-    "PropertyLayer",
+    "Network",
     "VoronoiGrid",
 ]

mesa/experimental/cell_space/cell.py

@@ -1,25 +1,15 @@
-"""Cells are positions in space that can have properties and contain agents.
-
-A cell represents a location that can:
-- Have properties (like temperature or resources)
-- Track and limit the agents it contains
-- Connect to neighboring cells
-- Provide neighborhood information
-
-Cells form the foundation of the cell space system, enabling rich spatial
-environments where both location properties and agent behaviors matter. They're
-useful for modeling things like varying terrain, infrastructure capacity, or
-environmental conditions.
-"""
+"""The Cell in a cell space."""
 
 from __future__ import annotations
 
+from collections.abc import Callable
 from functools import cache, cached_property
 from random import Random
-from typing import TYPE_CHECKING
+from typing import TYPE_CHECKING, Any
 
 from mesa.experimental.cell_space.cell_agent import CellAgent
 from mesa.experimental.cell_space.cell_collection import CellCollection
+from mesa.space import PropertyLayer
 
 if TYPE_CHECKING:
     from mesa.agent import Agent
@@ -34,20 +24,31 @@ class Cell:
         coordinate (Tuple[int, int]) : the position of the cell in the discrete space
         agents (List[Agent]): the agents occupying the cell
         capacity (int): the maximum number of agents that can simultaneously occupy the cell
+        properties (dict[str, Any]): the properties of the cell
         random (Random): the random number generator
 
     """
 
     __slots__ = [
-        "__dict__",
+        "coordinate",
+        "connections",
         "agents",
         "capacity",
-        "connections",
-        "coordinate",
         "properties",
         "random",
+        "_mesa_property_layers",
+        "__dict__",
     ]
 
+    # def __new__(cls,
+    #     coordinate: tuple[int, ...],
+    #     capacity: float | None = None,
+    #     random: Random | None = None,):
+    #     if capacity != 1:
+    #         return object.__new__(cls)
+    #     else:
+    #         return object.__new__(SingleAgentCell)
+
     def __init__(
         self,
         coordinate: Coordinate,
@@ -69,10 +70,9 @@ class Cell:
             Agent
         ] = []  # TODO:: change to AgentSet or weakrefs? (neither is very performant, )
         self.capacity: int | None = capacity
-        self.properties: dict[
-            Coordinate, object
-        ] = {}  # fixme still used by voronoi mesh
+        self.properties: dict[Coordinate, object] = {}
         self.random = random
+        self._mesa_property_layers: dict[str, PropertyLayer] = {}
 
     def connect(self, other: Cell, key: Coordinate | None = None) -> None:
         """Connects this cell to another cell.
@@ -105,7 +105,6 @@ class Cell:
 
         """
         n = len(self.agents)
-        self.empty = False
 
         if self.capacity and n >= self.capacity:
             raise Exception(
@@ -122,7 +121,6 @@ class Cell:
 
         """
         self.agents.remove(agent)
-        self.empty = self.is_empty
 
     @property
     def is_empty(self) -> bool:
@@ -197,6 +195,23 @@ class Cell:
                 neighborhood.pop(self, None)
             return neighborhood
 
+    # PropertyLayer methods
+    def get_property(self, property_name: str) -> Any:
+        """Get the value of a property."""
+        return self._mesa_property_layers[property_name].data[self.coordinate]
+
+    def set_property(self, property_name: str, value: Any):
+        """Set the value of a property."""
+        self._mesa_property_layers[property_name].set_cell(self.coordinate, value)
+
+    def modify_property(
+        self, property_name: str, operation: Callable, value: Any = None
+    ):
+        """Modify the value of a property."""
+        self._mesa_property_layers[property_name].modify_cell(
+            self.coordinate, operation, value
+        )
+
     def __getstate__(self):
         """Return state of the Cell with connections set to empty."""
         # fixme, once we shift to 3.11, replace this with super. __getstate__

mesa/experimental/cell_space/cell_agent.py

@@ -1,15 +1,4 @@
-"""Agents that understand how to exist in and move through cell spaces.
-
-Provides specialized agent classes that handle cell occupation, movement, and
-proper registration:
-- CellAgent: Mobile agents that can move between cells
-- FixedAgent: Immobile agents permanently fixed to cells
-- Grid2DMovingAgent: Agents with grid-specific movement capabilities
-
-These classes ensure consistent agent-cell relationships and proper state management
-as agents move through the space. They can be used directly or as examples for
-creating custom cell-aware agents.
-"""
+"""An agent with movement methods for cell spaces."""
 
 from __future__ import annotations
 

mesa/experimental/cell_space/cell_collection.py

@@ -1,17 +1,4 @@
-"""Collection class for managing and querying groups of cells.
-
-The CellCollection class provides a consistent interface for operating on multiple
-cells, supporting:
-- Filtering and selecting cells based on conditions
-- Random cell and agent selection
-- Access to contained agents
-- Group operations
-
-This is useful for implementing area effects, zones, or any operation that needs
-to work with multiple cells as a unit. The collection handles efficient iteration
-and agent access across cells. The class is used throughout the cell space
-implementation to represent neighborhoods, selections, and other cell groupings.
-"""
+"""CellCollection class."""
 
 from __future__ import annotations
 
@@ -61,10 +48,8 @@ class CellCollection(Generic[T]):
         else:
             self._cells = {cell: cell.agents for cell in cells}
 
-        # Get capacity from first cell if collection is not empty
-        self._capacity: int | None = (
-            next(iter(self._cells.keys())).capacity if self._cells else None
-        )
+        #
+        self._capacity: int = next(iter(self._cells.keys())).capacity
 
         if random is None:
             warnings.warn(