Mesa 3.1.4__py3-none-any.whl → 3.2.0.dev0__py3-none-any.whl

mesa/examples/basic/boltzmann_wealth_model/agents.py

@@ -1,7 +1,7 @@
-from mesa import Agent
+from mesa.discrete_space import CellAgent
 
 
-class MoneyAgent(Agent):
+class MoneyAgent(CellAgent):
     """An agent with fixed initial wealth.
 
     Each agent starts with 1 unit of wealth and can give 1 unit to other agents
@@ -11,28 +11,23 @@ class MoneyAgent(Agent):
         wealth (int): The agent's current wealth (starts at 1)
     """
 
-    def __init__(self, model):
+    def __init__(self, model, cell):
         """Create a new agent.
 
         Args:
             model (Model): The model instance that contains the agent
         """
         super().__init__(model)
+        self.cell = cell
         self.wealth = 1
 
     def move(self):
         """Move the agent to a random neighboring cell."""
-        possible_steps = self.model.grid.get_neighborhood(
-            self.pos, moore=True, include_center=False
-        )
-        new_position = self.random.choice(possible_steps)
-        self.model.grid.move_agent(self, new_position)
+        self.cell = self.cell.neighborhood.select_random_cell()
 
     def give_money(self):
         """Give 1 unit of wealth to a random agent in the same cell."""
-        cellmates = self.model.grid.get_cell_list_contents([self.pos])
-        # Remove self from potential recipients
-        cellmates.pop(cellmates.index(self))
+        cellmates = [a for a in self.cell.agents if a is not self]
 
         if cellmates:  # Only give money if there are other agents present
             other = self.random.choice(cellmates)

mesa/examples/basic/boltzmann_wealth_model/app.py

@@ -1,12 +1,12 @@
 from mesa.examples.basic.boltzmann_wealth_model.model import BoltzmannWealth
-from mesa.mesa_logging import DEBUG, log_to_stderr
+from mesa.mesa_logging import INFO, log_to_stderr
 from mesa.visualization import (
     SolaraViz,
     make_plot_component,
     make_space_component,
 )
 
-log_to_stderr(DEBUG)
+log_to_stderr(INFO)
 
 
 def agent_portrayal(agent):

mesa/examples/basic/boltzmann_wealth_model/model.py

@@ -9,8 +9,8 @@ when they occupy the same cell.
 
 from mesa import Model
 from mesa.datacollection import DataCollector
+from mesa.discrete_space import OrthogonalMooreGrid
 from mesa.examples.basic.boltzmann_wealth_model.agents import MoneyAgent
-from mesa.space import MultiGrid
 
 
 class BoltzmannWealth(Model):
@@ -39,22 +39,18 @@ class BoltzmannWealth(Model):
         super().__init__(seed=seed)
 
         self.num_agents = n
-        self.grid = MultiGrid(width, height, torus=True)
+        self.grid = OrthogonalMooreGrid((width, height), random=self.random)
 
         # Set up data collection
         self.datacollector = DataCollector(
             model_reporters={"Gini": self.compute_gini},
             agent_reporters={"Wealth": "wealth"},
         )
-
-        # Create and place the agents
-        for _ in range(self.num_agents):
-            agent = MoneyAgent(self)
-
-            # Add agent to random grid cell
-            x = self.random.randrange(self.grid.width)
-            y = self.random.randrange(self.grid.height)
-            self.grid.place_agent(agent, (x, y))
+        MoneyAgent.create_agents(
+            self,
+            self.num_agents,
+            self.random.choices(self.grid.all_cells.cells, k=self.num_agents),
+        )
 
         self.running = True
         self.datacollector.collect(self)

mesa/examples/basic/conways_game_of_life/agents.py

@@ -1,16 +1,24 @@
-from mesa import Agent
+from mesa.discrete_space import FixedAgent
 
 
-class Cell(Agent):
+class Cell(FixedAgent):
     """Represents a single ALIVE or DEAD cell in the simulation."""
 
     DEAD = 0
     ALIVE = 1
 
-    def __init__(self, pos, model, init_state=DEAD):
+    @property
+    def x(self):
+        return self.cell.coordinate[0]
+
+    @property
+    def y(self):
+        return self.cell.coordinate[1]
+
+    def __init__(self, model, cell, init_state=DEAD):
         """Create a cell, in the given state, at the given x, y position."""
         super().__init__(model)
-        self.x, self.y = pos
+        self.cell = cell
         self.state = init_state
         self._next_state = None
 
@@ -20,7 +28,7 @@ class Cell(Agent):
 
     @property
     def neighbors(self):
-        return self.model.grid.iter_neighbors((self.x, self.y), True)
+        return self.cell.neighborhood.agents
 
     def determine_state(self):
         """Compute if the cell will be dead or alive at the next tick.  This is

mesa/examples/basic/conways_game_of_life/model.py

@@ -1,6 +1,6 @@
 from mesa import Model
+from mesa.discrete_space import OrthogonalMooreGrid
 from mesa.examples.basic.conways_game_of_life.agents import Cell
-from mesa.space import SingleGrid
 
 
 class ConwaysGameOfLife(Model):
@@ -10,15 +10,18 @@ class ConwaysGameOfLife(Model):
         """Create a new playing area of (width, height) cells."""
         super().__init__(seed=seed)
         # Use a simple grid, where edges wrap around.
-        self.grid = SingleGrid(width, height, torus=True)
+        self.grid = OrthogonalMooreGrid((width, height), capacity=1, torus=True)
 
         # Place a cell at each location, with some initialized to
         # ALIVE and some to DEAD.
-        for _contents, (x, y) in self.grid.coord_iter():
-            cell = Cell((x, y), self)
-            if self.random.random() < initial_fraction_alive:
-                cell.state = cell.ALIVE
-            self.grid.place_agent(cell, (x, y))
+        for cell in self.grid.all_cells:
+            Cell(
+                self,
+                cell,
+                init_state=Cell.ALIVE
+                if self.random.random() < initial_fraction_alive
+                else Cell.DEAD,
+            )
 
         self.running = True
 

mesa/examples/basic/schelling/agents.py

@@ -1,23 +1,28 @@
-from mesa import Agent
+from mesa.discrete_space import CellAgent
 
 
-class SchellingAgent(Agent):
+class SchellingAgent(CellAgent):
     """Schelling segregation agent."""
 
-    def __init__(self, model, agent_type: int) -> None:
+    def __init__(
+        self, model, cell, agent_type: int, homophily: float = 0.4, radius: int = 1
+    ) -> None:
         """Create a new Schelling agent.
         Args:
             model: The model instance the agent belongs to
             agent_type: Indicator for the agent's type (minority=1, majority=0)
+            homophily: Minimum number of similar neighbors needed for happiness
+            radius: Search radius for checking neighbor similarity
         """
         super().__init__(model)
+        self.cell = cell
         self.type = agent_type
+        self.homophily = homophily
+        self.radius = radius
 
     def step(self) -> None:
         """Determine if agent is happy and move if necessary."""
-        neighbors = self.model.grid.get_neighbors(
-            self.pos, moore=True, radius=self.model.radius
-        )
+        neighbors = list(self.cell.get_neighborhood(radius=self.radius).agents)
 
         # Count similar neighbors
         similar_neighbors = len([n for n in neighbors if n.type == self.type])
@@ -30,7 +35,7 @@ class SchellingAgent(Agent):
             similarity_fraction = 0.0
 
         # Move if unhappy
-        if similarity_fraction < self.model.homophily:
-            self.model.grid.move_to_empty(self)
+        if similarity_fraction < self.homophily:
+            self.cell = self.model.grid.select_random_empty_cell()
         else:
             self.model.happy += 1

mesa/examples/basic/schelling/model.py

@@ -1,7 +1,7 @@
 from mesa import Model
 from mesa.datacollection import DataCollector
+from mesa.discrete_space import OrthogonalMooreGrid
 from mesa.examples.basic.schelling.agents import SchellingAgent
-from mesa.space import SingleGrid
 
 
 class Schelling(Model):
@@ -31,15 +31,11 @@ class Schelling(Model):
         super().__init__(seed=seed)
 
         # Model parameters
-        self.height = height
-        self.width = width
         self.density = density
         self.minority_pc = minority_pc
-        self.homophily = homophily
-        self.radius = radius
 
         # Initialize grid
-        self.grid = SingleGrid(width, height, torus=True)
+        self.grid = OrthogonalMooreGrid((width, height), random=self.random, capacity=1)
 
         # Track happiness
         self.happy = 0
@@ -64,11 +60,12 @@ class Schelling(Model):
         )
 
         # Create agents and place them on the grid
-        for _, pos in self.grid.coord_iter():
+        for cell in self.grid.all_cells:
             if self.random.random() < self.density:
                 agent_type = 1 if self.random.random() < minority_pc else 0
-                agent = SchellingAgent(self, agent_type)
-                self.grid.place_agent(agent, pos)
+                SchellingAgent(
+                    self, cell, agent_type, homophily=homophily, radius=radius
+                )
 
         # Collect initial state
         self.datacollector.collect(self)

mesa/examples/basic/virus_on_network/agents.py

@@ -1,6 +1,6 @@
 from enum import Enum
 
-from mesa import Agent
+from mesa.discrete_space import FixedAgent
 
 
 class State(Enum):
@@ -9,7 +9,7 @@ class State(Enum):
     RESISTANT = 2
 
 
-class VirusAgent(Agent):
+class VirusAgent(FixedAgent):
     """Individual Agent definition and its properties/interaction methods."""
 
     def __init__(
@@ -20,6 +20,7 @@ class VirusAgent(Agent):
         virus_check_frequency,
         recovery_chance,
         gain_resistance_chance,
+        cell,
     ):
         super().__init__(model)
 
@@ -29,19 +30,14 @@ class VirusAgent(Agent):
         self.virus_check_frequency = virus_check_frequency
         self.recovery_chance = recovery_chance
         self.gain_resistance_chance = gain_resistance_chance
+        self.cell = cell
 
     def try_to_infect_neighbors(self):
-        neighbors_nodes = self.model.grid.get_neighborhood(
-            self.pos, include_center=False
-        )
-        susceptible_neighbors = [
-            agent
-            for agent in self.model.grid.get_cell_list_contents(neighbors_nodes)
-            if agent.state is State.SUSCEPTIBLE
-        ]
-        for a in susceptible_neighbors:
-            if self.random.random() < self.virus_spread_chance:
-                a.state = State.INFECTED
+        for agent in self.cell.neighborhood.agents:
+            if (agent.state is State.SUSCEPTIBLE) and (
+                self.random.random() < self.virus_spread_chance
+            ):
+                agent.state = State.INFECTED
 
     def try_gain_resistance(self):
         if self.random.random() < self.gain_resistance_chance:
@@ -57,13 +53,13 @@ class VirusAgent(Agent):
             # Failed
             self.state = State.INFECTED
 
-    def try_check_situation(self):
-        if (self.random.random() < self.virus_check_frequency) and (
-            self.state is State.INFECTED
+    def check_situation(self):
+        if (self.state is State.INFECTED) and (
+            self.random.random() < self.virus_check_frequency
         ):
             self.try_remove_infection()
 
     def step(self):
         if self.state is State.INFECTED:
             self.try_to_infect_neighbors()
-        self.try_check_situation()
+        self.check_situation()

mesa/examples/basic/virus_on_network/model.py

@@ -4,11 +4,12 @@ import networkx as nx
 
 import mesa
 from mesa import Model
+from mesa.discrete_space import CellCollection, Network
 from mesa.examples.basic.virus_on_network.agents import State, VirusAgent
 
 
 def number_state(model, state):
-    return sum(1 for a in model.grid.get_all_cell_contents() if a.state is state)
+    return sum(1 for a in model.grid.all_cells.agents if a.state is state)
 
 
 def number_infected(model):
@@ -38,18 +39,13 @@ class VirusOnNetwork(Model):
         seed=None,
     ):
         super().__init__(seed=seed)
-        self.num_nodes = num_nodes
-        prob = avg_node_degree / self.num_nodes
-        self.G = nx.erdos_renyi_graph(n=self.num_nodes, p=prob)
-        self.grid = mesa.space.NetworkGrid(self.G)
+        prob = avg_node_degree / num_nodes
+        graph = nx.erdos_renyi_graph(n=num_nodes, p=prob)
+        self.grid = Network(graph, capacity=1, random=self.random)
 
         self.initial_outbreak_size = (
             initial_outbreak_size if initial_outbreak_size <= num_nodes else num_nodes
         )
-        self.virus_spread_chance = virus_spread_chance
-        self.virus_check_frequency = virus_check_frequency
-        self.recovery_chance = recovery_chance
-        self.gain_resistance_chance = gain_resistance_chance
 
         self.datacollector = mesa.DataCollector(
             {
@@ -60,23 +56,23 @@ class VirusOnNetwork(Model):
             }
         )
 
-        # Create agents
-        for node in self.G.nodes():
-            a = VirusAgent(
-                self,
-                State.SUSCEPTIBLE,
-                self.virus_spread_chance,
-                self.virus_check_frequency,
-                self.recovery_chance,
-                self.gain_resistance_chance,
-            )
-
-            # Add the agent to the node
-            self.grid.place_agent(a, node)
+        VirusAgent.create_agents(
+            self,
+            num_nodes,
+            State.SUSCEPTIBLE,
+            virus_spread_chance,
+            virus_check_frequency,
+            recovery_chance,
+            gain_resistance_chance,
+            list(self.grid.all_cells),
+        )
 
         # Infect some nodes
-        infected_nodes = self.random.sample(list(self.G), self.initial_outbreak_size)
-        for a in self.grid.get_cell_list_contents(infected_nodes):
+        infected_nodes = CellCollection(
+            self.random.sample(list(self.grid.all_cells), self.initial_outbreak_size),
+            random=self.random,
+        )
+        for a in infected_nodes.agents:
             a.state = State.INFECTED
 
         self.running = True

mesa/experimental/__init__.py

@@ -15,6 +15,6 @@ Notes:
     - Features graduate from experimental status once their APIs are stabilized
 """
 
-from mesa.experimental import cell_space, continuous_space, devs, mesa_signals
+from mesa.experimental import continuous_space, devs, mesa_signals
 
-__all__ = ["cell_space", "continuous_space", "devs", "mesa_signals"]
+__all__ = ["continuous_space", "devs", "mesa_signals"]

mesa/experimental/cell_space/__init__.py

@@ -15,23 +15,25 @@ 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
-from mesa.experimental.cell_space.cell_agent import (
+import warnings
+
+from mesa.discrete_space.cell import Cell
+from mesa.discrete_space.cell_agent import (
     CellAgent,
     FixedAgent,
     Grid2DMovingAgent,
 )
-from mesa.experimental.cell_space.cell_collection import CellCollection
-from mesa.experimental.cell_space.discrete_space import DiscreteSpace
-from mesa.experimental.cell_space.grid import (
+from mesa.discrete_space.cell_collection import CellCollection
+from mesa.discrete_space.discrete_space import DiscreteSpace
+from mesa.discrete_space.grid import (
     Grid,
     HexGrid,
     OrthogonalMooreGrid,
     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
+from mesa.discrete_space.network import Network
+from mesa.discrete_space.property_layer import PropertyLayer
+from mesa.discrete_space.voronoi import VoronoiGrid
 
 __all__ = [
     "Cell",
@@ -48,3 +50,11 @@ __all__ = [
     "PropertyLayer",
     "VoronoiGrid",
 ]
+
+
+warnings.warn(
+    "you are importing from mesa.experimental.cell_space, "
+    "all cell spaces have been moved to mesa.discrete_space",
+    DeprecationWarning,
+    stacklevel=2,
+)

mesa/space.py

@@ -6,7 +6,7 @@ Objects used to add a spatial component to a model.
     All Grid classes (:class:`_Grid`, :class:`SingleGrid`, :class:`MultiGrid`,
     :class:`HexGrid`, etc.) are now in maintenance-only mode. While these classes remain
     fully supported, new development occurs in the experimental cell space module
-    (:mod:`mesa.experimental.cell_space`).
+    (:mod:`mesa.discrete_space`).
 
     The :class:`PropertyLayer` and :class:`ContinuousSpace` classes remain fully supported
     and actively developed.
@@ -607,8 +607,6 @@ class PropertyLayer:
 
     """
 
-    propertylayer_experimental_warning_given = False
-
     def __init__(
         self, name: str, width: int, height: int, default_value, dtype=np.float64
     ):
@@ -653,15 +651,6 @@ class PropertyLayer:
 
         self.data = np.full((width, height), default_value, dtype=dtype)
 
-        if not self.__class__.propertylayer_experimental_warning_given:
-            warnings.warn(
-                "The new PropertyLayer and _PropertyGrid classes experimental. It may be changed or removed in any and all future releases, including patch releases.\n"
-                "We would love to hear what you think about this new feature. If you have any thoughts, share them with us here: https://github.com/projectmesa/mesa/discussions/1932",
-                FutureWarning,
-                stacklevel=2,
-            )
-            self.__class__.propertylayer_experimental_warning_given = True
-
     def set_cell(self, position: Coordinate, value):
         """Update a single cell's value in-place."""
         self.data[position] = value

mesa/visualization/__init__.py

@@ -9,12 +9,14 @@ from mesa.visualization.mpl_space_drawing import (
     draw_space,
 )
 
+from .command_console import CommandConsole
 from .components import make_plot_component, make_space_component
 from .components.altair_components import make_space_altair
 from .solara_viz import JupyterViz, SolaraViz
 from .user_param import Slider
 
 __all__ = [
+    "CommandConsole",
     "JupyterViz",
     "Slider",
     "SolaraViz",