Mesa 3.0.0b1__py3-none-any.whl → 3.0.0rc0__py3-none-any.whl

{examples → mesa/examples}/advanced/sugarscape_g1mt/Readme.md

@@ -34,51 +34,28 @@ cross over one another otherwise *end*.
 (Epstein and Axtell, 1996, p. 105)
 
 The model demonstrates several Mesa concepts and features:
- - MultiGrid
+ - OrthogonalMooreGrid
  - Multiple agent types (traders, sugar, spice)
  - Dynamically removing agents from the grid and schedule when they die
  - Data Collection at the model and agent level
- - Batchrunner (i.e. parameter sweeps)
+ - custom solara matplotlib space visualization
 
-## Installation
-
-To install the dependencies use pip and the requirements.txt in this directory. e.g.
-
-```
-  $ pip install -r requirements.txt
-```
 
 ## How to Run
-
-To run the model a single instance of the model:
-
-```
-  $ python run.py -s
-```
-
-To run the model with BatchRunner:
-
-```
-  $ python run.py -b
-```
-
 To run the model interactively:
 
 ```
-  $ mesa runserver
+  $ solara run app.py
 ```
 
 Then open your browser to [http://127.0.0.1:8521/](http://127.0.0.1:8521/) and press Reset, then Run.
 
 ## Files
 
-* `sugarscape_g1mt/trader_agents.py`: Defines the Trader agent class.
-* `sugarscape_g1mt/resource_agents.py`: Defines the Resource agent class which contains an amount of sugar and spice.
-* `sugarscape_g1mt/model.py`: Manages the Sugarscape Constant Growback with Traders model.
-* `sugarscape_g1mt/sugar_map.txt`: Provides sugar and spice landscape in raster type format.
-* `server.py`: Sets up an interactive visualization server.
-* `run.py`: Runs Server, Single Run or Batch Run  with data collection and basic analysis.
+* `model.py`: The Sugarscape Constant Growback with Traders model.
+* `agents.py`: Defines the Trader agent class and the Resource agent class which contains an amount of sugar and spice.
 * `app.py`: Runs a visualization server via Solara (`solara run app.py`).
+* `sugar_map.txt`: Provides sugar and spice landscape in raster type format.
 * `tests.py`: Has tests to ensure that the model reproduces the results in shown in Growing Artificial Societies.
 
 ## Additional Resources

examples/advanced/sugarscape_g1mt/sugarscape_g1mt/trader_agents.py → mesa/examples/advanced/sugarscape_g1mt/agents.py

@@ -1,8 +1,6 @@
 import math
 
-from mesa.experimental.cell_space import CellAgent
-
-from .resource_agents import Resource
+from mesa.experimental.cell_space import CellAgent, FixedAgent
 
 
 # Helper function
@@ -20,6 +18,31 @@ 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:

{examples → mesa/examples}/advanced/sugarscape_g1mt/app.py

@@ -1,9 +1,10 @@
 import numpy as np
 import solara
 from matplotlib.figure import Figure
-from mesa.visualization import SolaraViz, make_plot_measure
-from sugarscape_g1mt.model import SugarscapeG1mt
-from sugarscape_g1mt.trader_agents import Trader
+
+from mesa.examples.advanced.sugarscape_g1mt.agents import Trader
+from mesa.examples.advanced.sugarscape_g1mt.model import SugarscapeG1mt
+from mesa.visualization import SolaraViz, make_plot_component
 
 
 def SpaceDrawer(model):
@@ -14,19 +15,19 @@ def SpaceDrawer(model):
             "trader": {"x": [], "y": [], "c": "tab:red", "marker": "o", "s": 10},
         }
 
-        for content, (i, j) in g.coord_iter():
-            for agent in content:
-                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
-                    )
+        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
+                )
         return layers
 
     fig = Figure()
@@ -54,8 +55,8 @@ model1 = SugarscapeG1mt(50, 50)
 
 page = SolaraViz(
     model1,
-    components=[SpaceDrawer, make_plot_measure(["Trader", "Price"])],
+    components=[SpaceDrawer, make_plot_component(["Trader", "Price"])],
     name="Sugarscape {G1, M, T}",
-    play_interval=1500,
+    play_interval=150,
 )
 page  # noqa

{examples/advanced/sugarscape_g1mt → mesa/examples/advanced}/sugarscape_g1mt/model.py

@@ -1,11 +1,10 @@
 from pathlib import Path
 
-import mesa
 import numpy as np
-from mesa.experimental.cell_space import OrthogonalVonNeumannGrid
 
-from .resource_agents import Resource
-from .trader_agents import Trader
+import mesa
+from mesa.examples.advanced.sugarscape_g1mt.agents import Resource, Trader
+from mesa.experimental.cell_space import OrthogonalVonNeumannGrid
 
 
 # Helper Functions
@@ -53,8 +52,9 @@ class SugarscapeG1mt(mesa.Model):
         vision_min=1,
         vision_max=5,
         enable_trade=True,
+        seed=None,
     ):
-        super().__init__()
+        super().__init__(seed=seed)
         # Initiate width and height of sugarscape
         self.width = width
         self.height = height
@@ -176,5 +176,5 @@ class SugarscapeG1mt(mesa.Model):
         self.datacollector._agent_records[self.steps] = agent_trades
 
     def run_model(self, step_count=1000):
-        for i in range(step_count):
+        for _ in range(step_count):
             self.step()

{examples → mesa/examples}/advanced/sugarscape_g1mt/tests.py

@@ -1,11 +1,8 @@
-import random
-
 import numpy as np
 from scipy import stats
-from sugarscape_g1mt.model import SugarscapeG1mt, flatten
-from sugarscape_g1mt.trader_agents import Trader
 
-random.seed(1)
+from .agents import Trader
+from .model import SugarscapeG1mt, flatten
 
 
 def check_slope(y, increasing):
@@ -19,7 +16,7 @@ def check_slope(y, increasing):
 def test_decreasing_price_variance():
     # The variance of the average trade price should decrease over time (figure IV-3)
     # See Growing Artificial Societies p. 109.
-    model = SugarscapeG1mt()
+    model = SugarscapeG1mt(42)
     model.datacollector._new_model_reporter(
         "price_variance",
         lambda m: np.var(

mesa/examples/advanced/wolf_sheep/app.py

@@ -0,0 +1,84 @@
+from mesa.examples.advanced.wolf_sheep.agents import GrassPatch, Sheep, Wolf
+from mesa.examples.advanced.wolf_sheep.model import WolfSheep
+from mesa.visualization import (
+    Slider,
+    SolaraViz,
+    make_plot_component,
+    make_space_component,
+)
+
+
+def wolf_sheep_portrayal(agent):
+    if agent is None:
+        return
+
+    portrayal = {
+        "size": 25,
+    }
+
+    if isinstance(agent, Wolf):
+        portrayal["color"] = "tab:red"
+        portrayal["marker"] = "o"
+        portrayal["zorder"] = 2
+    elif isinstance(agent, Sheep):
+        portrayal["color"] = "tab:cyan"
+        portrayal["marker"] = "o"
+        portrayal["zorder"] = 2
+    elif isinstance(agent, GrassPatch):
+        if agent.fully_grown:
+            portrayal["color"] = "tab:green"
+        else:
+            portrayal["color"] = "tab:brown"
+        portrayal["marker"] = "s"
+        portrayal["size"] = 75
+
+    return portrayal
+
+
+model_params = {
+    # The following line is an example to showcase StaticText.
+    "grass": {
+        "type": "Select",
+        "value": True,
+        "values": [True, False],
+        "label": "grass regrowth enabled?",
+    },
+    "grass_regrowth_time": Slider("Grass Regrowth Time", 20, 1, 50),
+    "initial_sheep": Slider("Initial Sheep Population", 100, 10, 300),
+    "sheep_reproduce": Slider("Sheep Reproduction Rate", 0.04, 0.01, 1.0, 0.01),
+    "initial_wolves": Slider("Initial Wolf Population", 10, 5, 100),
+    "wolf_reproduce": Slider(
+        "Wolf Reproduction Rate",
+        0.05,
+        0.01,
+        1.0,
+        0.01,
+    ),
+    "wolf_gain_from_food": Slider("Wolf Gain From Food Rate", 20, 1, 50),
+    "sheep_gain_from_food": Slider("Sheep Gain From Food", 4, 1, 10),
+}
+
+
+def post_process(ax):
+    ax.set_aspect("equal")
+    ax.set_xticks([])
+    ax.set_yticks([])
+
+
+space_component = make_space_component(
+    wolf_sheep_portrayal, draw_grid=False, post_process=post_process
+)
+lineplot_component = make_plot_component(
+    {"Wolves": "tab:orange", "Sheep": "tab:cyan", "Grass": "tab:green"}
+)
+
+model = WolfSheep(grass=True)
+
+
+page = SolaraViz(
+    model,
+    components=[space_component, lineplot_component],
+    model_params=model_params,
+    name="Wolf Sheep",
+)
+page  # noqa

{examples/advanced/wolf_sheep → mesa/examples/advanced}/wolf_sheep/model.py

@@ -10,10 +10,9 @@ Replication of the model found in NetLogo:
 """
 
 import mesa
+from mesa.examples.advanced.wolf_sheep.agents import GrassPatch, Sheep, Wolf
 from mesa.experimental.cell_space import OrthogonalMooreGrid
 
-from .agents import GrassPatch, Sheep, Wolf
-
 
 class WolfSheep(mesa.Model):
     """
@@ -67,7 +66,7 @@ class WolfSheep(mesa.Model):
                                  once it is eaten
             sheep_gain_from_food: Energy sheep gain from grass, if enabled.
         """
-        super().__init__(seed=None)
+        super().__init__(seed=seed)
         # Set parameters
         self.width = width
         self.height = height
@@ -81,15 +80,17 @@ class WolfSheep(mesa.Model):
         collectors = {
             "Wolves": lambda m: len(m.agents_by_type[Wolf]),
             "Sheep": lambda m: len(m.agents_by_type[Sheep]),
+            "Grass": lambda m: len(
+                m.agents_by_type[GrassPatch].select(lambda a: a.fully_grown)
+            )
+            if m.grass
+            else -1,
         }
 
-        if grass:
-            collectors["Grass"] = lambda m: len(m.agents_by_type[GrassPatch])
-
         self.datacollector = mesa.DataCollector(collectors)
 
         # Create sheep:
-        for i in range(self.initial_sheep):
+        for _ in range(self.initial_sheep):
             x = self.random.randrange(self.width)
             y = self.random.randrange(self.height)
             energy = self.random.randrange(2 * self.sheep_gain_from_food)
@@ -132,5 +133,5 @@ class WolfSheep(mesa.Model):
         self.datacollector.collect(self)
 
     def run_model(self, step_count=200):
-        for i in range(step_count):
+        for _ in range(step_count):
             self.step()

mesa/examples/basic/boid_flockers/Readme.md

@@ -0,0 +1,22 @@
+# Boids Flockers
+
+## Summary
+
+An implementation of Craig Reynolds's Boids flocker model. Agents (simulated birds) try to fly towards the average position of their neighbors and in the same direction as them, while maintaining a minimum distance. This produces flocking behavior.
+
+This model tests Mesa's continuous space feature, and uses numpy arrays to represent vectors.
+
+## How to Run
+
+* To launch the visualization interactively, run ``solara run app.py`` in this directory.It will automatically open a browser page.
+
+## Files
+
+* [model.py](model.py): Ccntains the Boid Model
+* [agents.py](agents.py): Contains the Boid agent
+* [app.py](app.py): Solara based Visualization code.
+
+## Further Reading
+
+The following link can be visited for more information on the boid flockers model:
+https://cs.stanford.edu/people/eroberts/courses/soco/projects/2008-09/modeling-natural-systems/boids.html

{examples → mesa/examples}/basic/boid_flockers/app.py

@@ -1,6 +1,5 @@
-from mesa.visualization import Slider, SolaraViz, make_space_matplotlib
-
-from .model import BoidFlockers
+from mesa.examples.basic.boid_flockers.model import BoidFlockers
+from mesa.visualization import Slider, SolaraViz, make_space_component
 
 
 def boid_draw(agent):
@@ -52,7 +51,7 @@ model = BoidFlockers()
 
 page = SolaraViz(
     model,
-    [make_space_matplotlib(agent_portrayal=boid_draw)],
+    [make_space_component(agent_portrayal=boid_draw, backend="matplotlib")],
     model_params=model_params,
     name="Boid Flocking Model",
 )

{examples → mesa/examples}/basic/boid_flockers/model.py

@@ -7,8 +7,7 @@ Uses numpy arrays to represent vectors.
 import numpy as np
 
 import mesa
-
-from .agents import Boid
+from mesa.examples.basic.boid_flockers.agents import Boid
 
 
 class BoidFlockers(mesa.Model):

{examples → mesa/examples}/basic/boltzmann_wealth_model/Readme.md

@@ -12,11 +12,6 @@ As the model runs, the distribution of wealth among agents goes from being perfe
 
 To follow the tutorial example, launch the Jupyter Notebook and run the code in ``Introduction to Mesa Tutorial Code.ipynb`` which you can find in the main mesa repo [here](https://github.com/projectmesa/mesa/blob/main/docs/tutorials/intro_tutorial.ipynb)
 
-Make sure to install the requirements first:
-
-```
-    $ pip install -r requirements.txt
-```
 
 To launch the interactive server, as described in the [last section of the tutorial](https://mesa.readthedocs.io/en/latest/tutorials/intro_tutorial.html#adding-visualization), run:
 
@@ -30,6 +25,7 @@ If your browser doesn't open automatically, point it to [http://127.0.0.1:8765/]
 ## Files
 
 * ``model.py``: Final version of the model.
+* ``agents.py``: Final version of the agent.
 * ``app.py``: Code for the interactive visualization.
 
 ## Optional

{examples → mesa/examples}/basic/boltzmann_wealth_model/app.py

@@ -1,19 +1,14 @@
+from mesa.examples.basic.boltzmann_wealth_model.model import BoltzmannWealthModel
 from mesa.visualization import (
     SolaraViz,
-    make_plot_measure,
-    make_space_matplotlib,
+    make_plot_component,
+    make_space_component,
 )
 
-from .model import BoltzmannWealthModel
-
 
 def agent_portrayal(agent):
-    size = 10
-    color = "tab:red"
-    if agent.wealth > 0:
-        size = 50
-        color = "tab:blue"
-    return {"size": size, "color": color}
+    color = agent.wealth  # we are using a colormap to translate wealth to color
+    return {"color": color}
 
 
 model_params = {
@@ -29,6 +24,11 @@ model_params = {
     "height": 10,
 }
 
+
+def post_process(ax):
+    ax.get_figure().colorbar(ax.collections[0], label="wealth", ax=ax)
+
+
 # Create initial model instance
 model1 = BoltzmannWealthModel(50, 10, 10)
 
@@ -37,8 +37,11 @@ model1 = BoltzmannWealthModel(50, 10, 10)
 # Under the hood these are just classes that receive the model instance.
 # You can also author your own visualization elements, which can also be functions
 # that receive the model instance and return a valid solara component.
-SpaceGraph = make_space_matplotlib(agent_portrayal)
-GiniPlot = make_plot_measure("Gini")
+
+SpaceGraph = make_space_component(
+    agent_portrayal, cmap="viridis", vmin=0, vmax=10, post_process=post_process
+)
+GiniPlot = make_plot_component("Gini")
 
 # Create the SolaraViz page. This will automatically create a server and display the
 # visualization elements in a web browser.

{examples → mesa/examples}/basic/boltzmann_wealth_model/model.py

@@ -1,6 +1,5 @@
 import mesa
-
-from .agents import MoneyAgent
+from mesa.examples.basic.boltzmann_wealth_model.agents import MoneyAgent
 
 
 class BoltzmannWealthModel(mesa.Model):
@@ -11,8 +10,8 @@ class BoltzmannWealthModel(mesa.Model):
     highly skewed distribution of wealth.
     """
 
-    def __init__(self, n=100, width=10, height=10):
-        super().__init__()
+    def __init__(self, n=100, width=10, height=10, seed=None):
+        super().__init__(seed=seed)
         self.num_agents = n
         self.grid = mesa.space.MultiGrid(width, height, True)
 

{examples → mesa/examples}/basic/conways_game_of_life/Readme.md

@@ -9,26 +9,30 @@ The "game" is a zero-player game, meaning that its evolution is determined by it
 
 ## How to Run
 
-To run the model interactively, run ``mesa runserver`` in this directory. e.g.
+To run the model interactively you can use either the streamlit or solara version. For solara, you use
 
 ```
-    $ mesa runserver
+    $ solara run app.py
 ```
 
-Then open your browser to [http://127.0.0.1:8521/](http://127.0.0.1:8521/) and press ``run``.
+For streamlit, you need
+
+```
+    $ streamlit run st_app.py
+```
+
+This will open your browser and show you the controls. You can start the model by hitting the run button.
 
 ## Files
 
 * ``agents.py``: Defines the behavior of an individual cell, which can be in two states: DEAD or ALIVE.
 * ``model.py``: Defines the model itself, initialized with a random configuration of alive and dead cells.
-* ``portrayal.py``: Describes for the front end how to render a cell.
+* ``app.py``: Defines an interactive visualization using solara.
 * ``st_app.py``: Defines an interactive visualization using Streamlit.
 
 ## Optional
 
-*  ``conways_game_of_life/st_app.py``: can be used to run the simulation via the streamlit interface.
-* For this some additional packages like ``streamlit`` and ``altair`` needs to be installed.
-* Once installed, the app can be opened in the browser using : ``streamlit run st_app.py``
+* For the streamlit version, you need to have streamlit installed (can be done via pip install streamlit)
 
 
 ## Further Reading

{examples → mesa/examples}/basic/conways_game_of_life/agents.py

@@ -12,10 +12,10 @@ class Cell(Agent):
         super().__init__(model)
         self.x, self.y = pos
         self.state = init_state
-        self._nextState = None
+        self._next_state = None
 
     @property
-    def isAlive(self):
+    def is_alive(self):
         return self.state == self.ALIVE
 
     @property
@@ -31,17 +31,17 @@ class Cell(Agent):
         """
         # Get the neighbors and apply the rules on whether to be alive or dead
         # at the next tick.
-        live_neighbors = sum(neighbor.isAlive for neighbor in self.neighbors)
+        live_neighbors = sum(neighbor.is_alive for neighbor in self.neighbors)
 
         # Assume nextState is unchanged, unless changed below.
-        self._nextState = self.state
-        if self.isAlive:
+        self._next_state = self.state
+        if self.is_alive:
             if live_neighbors < 2 or live_neighbors > 3:
-                self._nextState = self.DEAD
+                self._next_state = self.DEAD
         else:
             if live_neighbors == 3:
-                self._nextState = self.ALIVE
+                self._next_state = self.ALIVE
 
     def assume_state(self):
         """Set the state to the new computed state -- computed in step()."""
-        self.state = self._nextState
+        self.state = self._next_state

mesa/examples/basic/conways_game_of_life/app.py

@@ -0,0 +1,51 @@
+from mesa.examples.basic.conways_game_of_life.model import ConwaysGameOfLife
+from mesa.visualization import (
+    SolaraViz,
+    make_space_component,
+)
+
+
+def agent_portrayal(agent):
+    return {
+        "color": "white" if agent.state == 0 else "black",
+        "marker": "s",
+        "size": 25,
+    }
+
+
+def post_process(ax):
+    ax.set_aspect("equal")
+    ax.set_xticks([])
+    ax.set_yticks([])
+
+
+model_params = {
+    "width": 50,
+    "height": 50,
+}
+
+# Create initial model instance
+model1 = ConwaysGameOfLife(50, 50)
+
+# Create visualization elements. The visualization elements are solara components
+# that receive the model instance as a "prop" and display it in a certain way.
+# Under the hood these are just classes that receive the model instance.
+# You can also author your own visualization elements, which can also be functions
+# that receive the model instance and return a valid solara component.
+SpaceGraph = make_space_component(
+    agent_portrayal, post_process=post_process, draw_grid=False
+)
+
+
+# Create the SolaraViz page. This will automatically create a server and display the
+# visualization elements in a web browser.
+# Display it using the following command in the example directory:
+# solara run app.py
+# It will automatically update and display any changes made to this file
+page = SolaraViz(
+    model1,
+    components=[SpaceGraph],
+    model_params=model_params,
+    name="Game of Life",
+)
+page  # noqa

{examples → mesa/examples}/basic/conways_game_of_life/model.py

@@ -1,15 +1,14 @@
 from mesa import Model
+from mesa.examples.basic.conways_game_of_life.agents import Cell
 from mesa.space import SingleGrid
 
-from .agents import Cell
-
 
 class ConwaysGameOfLife(Model):
     """Represents the 2-dimensional array of cells in Conway's Game of Life."""
 
-    def __init__(self, width=50, height=50):
+    def __init__(self, width=50, height=50, seed=None):
         """Create a new playing area of (width, height) cells."""
-        super().__init__()
+        super().__init__(seed=seed)
         # Use a simple grid, where edges wrap around.
         self.grid = SingleGrid(width, height, torus=True)
 

{examples → mesa/examples}/basic/conways_game_of_life/st_app.py

@@ -4,7 +4,8 @@ import altair as alt
 import numpy as np
 import pandas as pd
 import streamlit as st
-from model import ConwaysGameOfLife
+
+from mesa.examples.basic.conways_game_of_life.model import ConwaysGameOfLife
 
 model = st.title("Conway's Game of Life")
 num_ticks = st.slider("Select number of Steps", min_value=1, max_value=100, value=50)