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

mesa/examples/advanced/sugarscape_g1mt/agents.py

@@ -1,6 +1,6 @@
 import math
 
-from mesa.experimental.cell_space import CellAgent, FixedAgent
+from mesa.experimental.cell_space import CellAgent
 
 
 # Helper function
@@ -18,31 +18,6 @@ def get_distance(cell_1, cell_2):
     return math.sqrt(dx**2 + dy**2)
 
 
-class Resource(FixedAgent):
-    """
-    Resource:
-    - contains an amount of sugar and spice
-    - grows 1 amount of sugar at each turn
-    - grows 1 amount of spice at each turn
-    """
-
-    def __init__(self, model, max_sugar, max_spice, cell):
-        super().__init__(model)
-        self.sugar_amount = max_sugar
-        self.max_sugar = max_sugar
-        self.spice_amount = max_spice
-        self.max_spice = max_spice
-        self.cell = cell
-
-    def step(self):
-        """
-        Growth function, adds one unit of sugar and spice each step up to
-        max amount
-        """
-        self.sugar_amount = min([self.max_sugar, self.sugar_amount + 1])
-        self.spice_amount = min([self.max_spice, self.spice_amount + 1])
-
-
 class Trader(CellAgent):
     """
     Trader:
@@ -70,12 +45,6 @@ class Trader(CellAgent):
         self.prices = []
         self.trade_partners = []
 
-    def get_resource(self, cell):
-        for agent in cell.agents:
-            if isinstance(agent, Resource):
-                return agent
-        raise Exception(f"Resource agent not found in the position {cell.coordinate}")
-
     def get_trader(self, cell):
         """
         helper function used in self.trade_with_neighbors()
@@ -85,17 +54,6 @@ class Trader(CellAgent):
             if isinstance(agent, Trader):
                 return agent
 
-    def is_occupied_by_other(self, cell):
-        """
-        helper function part 1 of self.move()
-        """
-
-        if cell is self.cell:
-            # agent's position is considered unoccupied as agent can stay there
-            return False
-        # get contents of each cell in neighborhood
-        return any(isinstance(a, Trader) for a in cell.agents)
-
     def calculate_welfare(self, sugar, spice):
         """
         helper function
@@ -264,15 +222,15 @@ class Trader(CellAgent):
         neighboring_cells = [
             cell
             for cell in self.cell.get_neighborhood(self.vision, include_center=True)
-            if not self.is_occupied_by_other(cell)
+            if cell.is_empty
         ]
 
         # 2. determine which move maximizes welfare
 
         welfares = [
             self.calculate_welfare(
-                self.sugar + self.get_resource(cell).sugar_amount,
-                self.spice + self.get_resource(cell).spice_amount,
+                self.sugar + cell.sugar,
+                self.spice + cell.spice,
             )
             for cell in neighboring_cells
         ]
@@ -282,6 +240,7 @@ class Trader(CellAgent):
         # find the highest welfare in welfares
         max_welfare = max(welfares)
         # get the index of max welfare cells
+        # fixme: rewrite using enumerate and single loop
         candidate_indices = [
             i for i in range(len(welfares)) if math.isclose(welfares[i], max_welfare)
         ]
@@ -296,19 +255,17 @@ class Trader(CellAgent):
             for cell in candidates
             if math.isclose(get_distance(self.cell, cell), min_dist, rel_tol=1e-02)
         ]
+
         # 4. Move Agent
         self.cell = self.random.choice(final_candidates)
 
     def eat(self):
-        patch = self.get_resource(self.cell)
-        if patch.sugar_amount > 0:
-            self.sugar += patch.sugar_amount
-            patch.sugar_amount = 0
+        self.sugar += self.cell.sugar
+        self.cell.sugar = 0
         self.sugar -= self.metabolism_sugar
 
-        if patch.spice_amount > 0:
-            self.spice += patch.spice_amount
-            patch.spice_amount = 0
+        self.spice += self.cell.spice
+        self.cell.spice = 0
         self.spice -= self.metabolism_spice
 
     def maybe_die(self):
@@ -327,18 +284,8 @@ class Trader(CellAgent):
         2- trade (2 sessions)
         3- collect data
         """
-
-        neighbor_agents = [
-            self.get_trader(cell)
-            for cell in self.cell.get_neighborhood(radius=self.vision)
-            if self.is_occupied_by_other(cell)
-        ]
-
-        if len(neighbor_agents) == 0:
-            return
-
-            # iterate through traders in neighboring cells and trade
-        for a in neighbor_agents:
+        # iterate through traders in neighboring cells and trade
+        for a in self.cell.get_neighborhood(radius=self.vision).agents:
             self.trade(a)
 
         return

mesa/examples/advanced/sugarscape_g1mt/app.py

@@ -2,7 +2,6 @@ import numpy as np
 import solara
 from matplotlib.figure import Figure
 
-from mesa.examples.advanced.sugarscape_g1mt.agents import Trader
 from mesa.examples.advanced.sugarscape_g1mt.model import SugarscapeG1mt
 from mesa.visualization import Slider, SolaraViz, make_plot_component
 
@@ -10,24 +9,13 @@ from mesa.visualization import Slider, SolaraViz, make_plot_component
 def SpaceDrawer(model):
     def portray(g):
         layers = {
-            "sugar": [[np.nan for j in range(g.height)] for i in range(g.width)],
-            "spice": [[np.nan for j in range(g.height)] for i in range(g.width)],
             "trader": {"x": [], "y": [], "c": "tab:red", "marker": "o", "s": 10},
         }
 
         for agent in g.all_cells.agents:
             i, j = agent.cell.coordinate
-            if isinstance(agent, Trader):
-                layers["trader"]["x"].append(i)
-                layers["trader"]["y"].append(j)
-            else:
-                # Don't visualize resource with value <= 1.
-                layers["sugar"][i][j] = (
-                    agent.sugar_amount if agent.sugar_amount > 1 else np.nan
-                )
-                layers["spice"][i][j] = (
-                    agent.spice_amount if agent.spice_amount > 1 else np.nan
-                )
+            layers["trader"]["x"].append(i)
+            layers["trader"]["y"].append(j)
         return layers
 
     fig = Figure()
@@ -36,10 +24,18 @@ def SpaceDrawer(model):
     # Sugar
     # Important note: imshow by default draws from upper left. You have to
     # always explicitly specify origin="lower".
-    im = ax.imshow(out["sugar"], cmap="spring", origin="lower")
+    im = ax.imshow(
+        np.ma.masked_where(model.grid.sugar.data <= 1, model.grid.sugar.data),
+        cmap="spring",
+        origin="lower",
+    )
     fig.colorbar(im, orientation="vertical")
     # Spice
-    ax.imshow(out["spice"], cmap="winter", origin="lower")
+    ax.imshow(
+        np.ma.masked_where(model.grid.spice.data <= 1, model.grid.spice.data),
+        cmap="winter",
+        origin="lower",
+    )
     # Trader
     ax.scatter(**out["trader"])
     ax.set_axis_off()
@@ -47,6 +43,11 @@ def SpaceDrawer(model):
 
 
 model_params = {
+    "seed": {
+        "type": "InputText",
+        "value": 42,
+        "label": "Random Seed",
+    },
     "width": 50,
     "height": 50,
     # Population parameters
@@ -66,11 +67,15 @@ model_params = {
     "enable_trade": {"type": "Checkbox", "value": True, "label": "Enable Trading"},
 }
 
-model1 = SugarscapeG1mt()
+model = SugarscapeG1mt()
 
 page = SolaraViz(
-    model1,
-    components=[SpaceDrawer, make_plot_component(["Trader", "Price"])],
+    model,
+    components=[
+        SpaceDrawer,
+        make_plot_component("#Traders"),
+        make_plot_component("Price"),
+    ],
     model_params=model_params,
     name="Sugarscape {G1, M, T}",
     play_interval=150,

mesa/examples/advanced/sugarscape_g1mt/model.py

@@ -3,8 +3,9 @@ from pathlib import Path
 import numpy as np
 
 import mesa
-from mesa.examples.advanced.sugarscape_g1mt.agents import Resource, Trader
+from mesa.examples.advanced.sugarscape_g1mt.agents import Trader
 from mesa.experimental.cell_space import OrthogonalVonNeumannGrid
+from mesa.experimental.cell_space.property_layer import PropertyLayer
 
 
 # Helper Functions
@@ -58,14 +59,8 @@ class SugarscapeG1mt(mesa.Model):
         # Initiate width and height of sugarscape
         self.width = width
         self.height = height
+
         # Initiate population attributes
-        self.initial_population = initial_population
-        self.endowment_min = endowment_min
-        self.endowment_max = endowment_max
-        self.metabolism_min = metabolism_min
-        self.metabolism_max = metabolism_max
-        self.vision_min = vision_min
-        self.vision_max = vision_max
         self.enable_trade = enable_trade
         self.running = True
 
@@ -76,55 +71,46 @@ class SugarscapeG1mt(mesa.Model):
         # initiate datacollector
         self.datacollector = mesa.DataCollector(
             model_reporters={
-                "Trader": lambda m: len(m.agents_by_type[Trader]),
-                "Trade Volume": lambda m: sum(
-                    len(a.trade_partners) for a in m.agents_by_type[Trader]
-                ),
+                "#Traders": lambda m: len(m.agents),
+                "Trade Volume": lambda m: sum(len(a.trade_partners) for a in m.agents),
                 "Price": lambda m: geometric_mean(
-                    flatten([a.prices for a in m.agents_by_type[Trader]])
+                    flatten([a.prices for a in m.agents])
                 ),
             },
             agent_reporters={"Trade Network": lambda a: get_trade(a)},
         )
 
-        # read in landscape file from supplmentary material
-        sugar_distribution = np.genfromtxt(Path(__file__).parent / "sugar-map.txt")
-        spice_distribution = np.flip(sugar_distribution, 1)
-
-        for cell in self.grid.all_cells:
-            max_sugar = sugar_distribution[cell.coordinate]
-            max_spice = spice_distribution[cell.coordinate]
-            Resource(self, max_sugar, max_spice, cell)
-
-        for _ in range(self.initial_population):
-            # get agent position
-            x = self.random.randrange(self.width)
-            y = self.random.randrange(self.height)
-            # see Growing Artificial Societies p. 108 for initialization
-            # give agents initial endowment
-            sugar = int(self.random.uniform(self.endowment_min, self.endowment_max + 1))
-            spice = int(self.random.uniform(self.endowment_min, self.endowment_max + 1))
-            # give agents initial metabolism
-            metabolism_sugar = int(
-                self.random.uniform(self.metabolism_min, self.metabolism_max + 1)
-            )
-            metabolism_spice = int(
-                self.random.uniform(self.metabolism_min, self.metabolism_max + 1)
-            )
-            # give agents vision
-            vision = int(self.random.uniform(self.vision_min, self.vision_max + 1))
-
-            cell = self.grid[(x, y)]
-            # create Trader object
-            Trader(
-                self,
-                cell,
-                sugar=sugar,
-                spice=spice,
-                metabolism_sugar=metabolism_sugar,
-                metabolism_spice=metabolism_spice,
-                vision=vision,
-            )
+        # read in landscape file from supplementary material
+        self.sugar_distribution = np.genfromtxt(Path(__file__).parent / "sugar-map.txt")
+        self.spice_distribution = np.flip(self.sugar_distribution, 1)
+
+        self.grid.add_property_layer(
+            PropertyLayer.from_data("sugar", self.sugar_distribution)
+        )
+        self.grid.add_property_layer(
+            PropertyLayer.from_data("spice", self.spice_distribution)
+        )
+
+        Trader.create_agents(
+            self,
+            initial_population,
+            self.random.choices(self.grid.all_cells.cells, k=initial_population),
+            sugar=self.rng.integers(
+                endowment_min, endowment_max, (initial_population,), endpoint=True
+            ),
+            spice=self.rng.integers(
+                endowment_min, endowment_max, (initial_population,), endpoint=True
+            ),
+            metabolism_sugar=self.rng.integers(
+                metabolism_min, metabolism_max, (initial_population,), endpoint=True
+            ),
+            metabolism_spice=self.rng.integers(
+                metabolism_min, metabolism_max, (initial_population,), endpoint=True
+            ),
+            vision=self.rng.integers(
+                vision_min, vision_max, (initial_population,), endpoint=True
+            ),
+        )
 
     def step(self):
         """
@@ -132,7 +118,12 @@ class SugarscapeG1mt(mesa.Model):
         and then randomly activates traders
         """
         # step Resource agents
-        self.agents_by_type[Resource].do("step")
+        self.grid.sugar.data = np.minimum(
+            self.grid.sugar.data + 1, self.sugar_distribution
+        )
+        self.grid.spice.data = np.minimum(
+            self.grid.spice.data + 1, self.spice_distribution
+        )
 
         # step trader agents
         # to account for agent death and removal we need a separate data structure to
@@ -157,6 +148,8 @@ class SugarscapeG1mt(mesa.Model):
             agent.trade_with_neighbors()
 
         # collect model level data
+        # fixme we can already collect agent class data
+        # fixme, we don't have resource agents anymore so this can be done simpler
         self.datacollector.collect(self)
         """
         Mesa is working on updating datacollector agent reporter

mesa/examples/advanced/wolf_sheep/agents.py

@@ -4,7 +4,9 @@ from mesa.experimental.cell_space import CellAgent, FixedAgent
 class Animal(CellAgent):
     """The base animal class."""
 
-    def __init__(self, model, energy, p_reproduce, energy_from_food, cell):
+    def __init__(
+        self, model, energy=8, p_reproduce=0.04, energy_from_food=4, cell=None
+    ):
         """Initialize an animal.
 
         Args:
@@ -37,7 +39,8 @@ class Animal(CellAgent):
     def step(self):
         """Execute one step of the animal's behavior."""
         # Move to random neighboring cell
-        self.cell = self.cell.neighborhood.select_random_cell()
+        self.move()
+
         self.energy -= 1
 
         # Try to feed
@@ -62,6 +65,27 @@ class Sheep(Animal):
             self.energy += self.energy_from_food
             grass_patch.fully_grown = False
 
+    def move(self):
+        """Move towards a cell where there isn't a wolf, and preferably with grown grass."""
+        cells_without_wolves = self.cell.neighborhood.select(
+            lambda cell: not any(isinstance(obj, Wolf) for obj in cell.agents)
+        )
+        # If all surrounding cells have wolves, stay put
+        if len(cells_without_wolves) == 0:
+            return
+
+        # Among safe cells, prefer those with grown grass
+        cells_with_grass = cells_without_wolves.select(
+            lambda cell: any(
+                isinstance(obj, GrassPatch) and obj.fully_grown for obj in cell.agents
+            )
+        )
+        # Move to a cell with grass if available, otherwise move to any safe cell
+        target_cells = (
+            cells_with_grass if len(cells_with_grass) > 0 else cells_without_wolves
+        )
+        self.cell = target_cells.select_random_cell()
+
 
 class Wolf(Animal):
     """A wolf that walks around, reproduces (asexually) and eats sheep."""
@@ -74,6 +98,16 @@ class Wolf(Animal):
             self.energy += self.energy_from_food
             sheep_to_eat.remove()
 
+    def move(self):
+        """Move to a neighboring cell, preferably one with sheep."""
+        cells_with_sheep = self.cell.neighborhood.select(
+            lambda cell: any(isinstance(obj, Sheep) for obj in cell.agents)
+        )
+        target_cells = (
+            cells_with_sheep if len(cells_with_sheep) > 0 else self.cell.neighborhood
+        )
+        self.cell = target_cells.select_random_cell()
+
 
 class GrassPatch(FixedAgent):
     """A patch of grass that grows at a fixed rate and can be eaten by sheep."""

mesa/examples/advanced/wolf_sheep/model.py

@@ -90,22 +90,23 @@ class WolfSheep(Model):
         self.datacollector = DataCollector(model_reporters)
 
         # Create sheep:
-        for _ in range(initial_sheep):
-            pos = (
-                self.random.randrange(width),
-                self.random.randrange(height),
-            )
-            energy = self.random.randrange(2 * sheep_gain_from_food)
-            Sheep(self, energy, sheep_reproduce, sheep_gain_from_food, self.grid[pos])
-
-        # Create wolves
-        for _ in range(initial_wolves):
-            pos = (
-                self.random.randrange(width),
-                self.random.randrange(height),
-            )
-            energy = self.random.randrange(2 * wolf_gain_from_food)
-            Wolf(self, energy, wolf_reproduce, wolf_gain_from_food, self.grid[pos])
+        Sheep.create_agents(
+            self,
+            initial_sheep,
+            energy=self.rng.random((initial_sheep,)) * 2 * sheep_gain_from_food,
+            p_reproduce=sheep_reproduce,
+            energy_from_food=sheep_gain_from_food,
+            cell=self.random.choices(self.grid.all_cells.cells, k=initial_sheep),
+        )
+        # Create Wolves:
+        Wolf.create_agents(
+            self,
+            initial_wolves,
+            energy=self.rng.random((initial_wolves,)) * 2 * wolf_gain_from_food,
+            p_reproduce=wolf_reproduce,
+            energy_from_food=wolf_gain_from_food,
+            cell=self.random.choices(self.grid.all_cells.cells, k=initial_wolves),
+        )
 
         # Create grass patches if enabled
         if grass:

mesa/examples/basic/boid_flockers/app.py

@@ -12,6 +12,11 @@ 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,10 +1,13 @@
 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
@@ -12,6 +15,11 @@ def agent_portrayal(agent):
 
 
 model_params = {
+    "seed": {
+        "type": "InputText",
+        "value": 42,
+        "label": "Random Seed",
+    },
     "n": {
         "type": "SliderInt",
         "value": 50,
@@ -20,11 +28,6 @@ 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("Step = %d" % i)
+        placeholder.text(f"Step = {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,6 +20,11 @@ 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("Step = %d" % i)
+        placeholder.text(f"Step = {i}")
         for contents, (x, y) in model.grid.coord_iter():
-            # print('x:',x,'y:',y, 'state:',contents)
+            # print(f"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/agents.py

@@ -6,7 +6,6 @@ class SchellingAgent(Agent):
 
     def __init__(self, model, agent_type: int) -> 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)
@@ -16,15 +15,22 @@ class SchellingAgent(Agent):
 
     def step(self) -> None:
         """Determine if agent is happy and move if necessary."""
-        neighbors = self.model.grid.iter_neighbors(
+        neighbors = self.model.grid.get_neighbors(
             self.pos, moore=True, radius=self.model.radius
         )
 
         # Count similar neighbors
-        similar = sum(neighbor.type == self.type for neighbor in neighbors)
+        similar_neighbors = len([n for n in neighbors if n.type == self.type])
+
+        # Calculate the fraction of similar neighbors
+        if (valid_neighbors := len(neighbors)) > 0:
+            similarity_fraction = similar_neighbors / valid_neighbors
+        else:
+            # If there are no neighbors, the similarity fraction is 0
+            similarity_fraction = 0.0
 
-        # If unhappy, move to a random empty cell:
-        if similar < self.model.homophily:
+        # Move if unhappy
+        if similarity_fraction < self.model.homophily:
             self.model.grid.move_to_empty(self)
         else:
             self.model.happy += 1