Merge branch 'main' into sync-pyproject-with-mesa

# Conflicts:
#	examples/boltzmann_wealth_model_network/boltzmann_wealth_model_network/model.py
#	examples/boltzmann_wealth_model_network/boltzmann_wealth_model_network/server.py
#	examples/color_patches/color_patches/model.py

Author: derkweijers

examples/bank_reserves/app.py

@@ -0,0 +1,101 @@
+from bank_reserves.agents import Person
+from bank_reserves.model import BankReservesModel
+from mesa.visualization import (
+    SolaraViz,
+    make_plot_component,
+    make_space_component,
+)
+from mesa.visualization.user_param import (
+    Slider,
+)
+
+# The colors here are taken from Matplotlib's tab10 palette
+# Green
+RICH_COLOR = "#2ca02c"
+# Red
+POOR_COLOR = "#d62728"
+# Blue
+MID_COLOR = "#1f77b4"
+
+
+def person_portrayal(agent):
+    if agent is None:
+        return
+
+    portrayal = {}
+
+    # update portrayal characteristics for each Person object
+    if isinstance(agent, Person):
+        portrayal["Shape"] = "circle"
+        portrayal["r"] = 0.5
+        portrayal["Layer"] = 0
+        portrayal["Filled"] = "true"
+
+        color = MID_COLOR
+
+        # set agent color based on savings and loans
+        if agent.savings > agent.model.rich_threshold:
+            color = RICH_COLOR
+        if agent.savings < 10 and agent.loans < 10:
+            color = MID_COLOR
+        if agent.loans > 10:
+            color = POOR_COLOR
+
+        portrayal["color"] = color
+
+    return portrayal
+
+
+def post_process_space(ax):
+    ax.set_aspect("equal")
+    ax.set_xticks([])
+    ax.set_yticks([])
+
+
+def post_process_lines(ax):
+    ax.legend(loc="center left", bbox_to_anchor=(1, 0.9))
+
+
+# dictionary of user settable parameters - these map to the model __init__ parameters
+model_params = {
+    "init_people": Slider(
+        "People",
+        25,
+        1,
+        200,
+        # description="Initial Number of People"
+    ),
+    "rich_threshold": Slider(
+        "Rich Threshold",
+        10,
+        1,
+        20,
+        # description="Upper End of Random Initial Wallet Amount",
+    ),
+    "reserve_percent": Slider(
+        "Reserves",
+        50,
+        1,
+        100,
+        # description="Percent of deposits the bank has to hold in reserve",
+    ),
+}
+
+space_component = make_space_component(
+    person_portrayal,
+    draw_grid=False,
+    post_process=post_process_space,
+)
+lineplot_component = make_plot_component(
+    {"Rich": RICH_COLOR, "Poor": POOR_COLOR, "Middle Class": MID_COLOR},
+    post_process=post_process_lines,
+)
+model = BankReservesModel()
+
+page = SolaraViz(
+    model,
+    components=[space_component, lineplot_component],
+    model_params=model_params,
+    name="Bank Reserves Model",
+)
+page  # noqa

examples/bank_reserves/bank_reserves/server.py

@@ -1,4 +1,4 @@
-itertools
-mesa~=2.0
+mesa[viz]>=3.1.4
+networkx
 numpy
 pandas

examples/bank_reserves/requirements.txt

@@ -10,31 +10,29 @@ In this network implementation, agents must be located on a node, with a limit o
 
 As the model runs, the distribution of wealth among agents goes from being perfectly uniform (all agents have the same starting wealth), to highly skewed -- a small number have high wealth, more have none at all.
 
-JavaScript library used in this example to render the network: [sigma.js](http://sigmajs.org/).
-
 ## Installation
 
-To install the dependencies use pip and the requirements.txt in this directory. e.g.
+To install the dependencies use `pip` to install `mesa[rec]`
 
-```
-    $ pip install -r requirements.txt
+```bash
+    $ pip install mesa[rec]
 ```
 
 ## How to Run
 
-To run the model interactively, run ``mesa runserver`` in this directory. e.g.
+To run the model interactively, run ``solara run`` in this directory. e.g.
 
-```
-    $ mesa runserver
+```bash
+    $ 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.
+Then open your browser to [http://localhost:8765/](http://localhost:8765/) and press Reset, then Run.
 
 ## Files
 
-* ``run.py``: Launches a model visualization server.
-* ``model.py``: Contains the agent class, and the overall model class.
-* ``server.py``: Defines classes for visualizing the model (network layout) in the browser via Mesa's modular server, and instantiates a visualization server.
+* ``model.py``: Contains creation of agents, the network, and management of agent execution.
+* ``agents.py``: Contains logic for giving money, and moving on the network.
+* ``app.py``: Contains the code for the interactive Solara visualization.
 
 ## Further Reading
 

examples/bank_reserves/run.py

@@ -0,0 +1,96 @@
+from boltzmann_wealth_model_network.model import BoltzmannWealthModelNetwork
+from mesa.mesa_logging import INFO, log_to_stderr
+from mesa.visualization import (
+    SolaraViz,
+    make_plot_component,
+    make_space_component,
+)
+
+log_to_stderr(INFO)
+
+
+# Tells Solara how to draw each agent.
+def agent_portrayal(agent):
+    return {
+        "color": agent.wealth,  # using a colormap to convert wealth to color
+        "size": 50,
+    }
+
+
+model_params = {
+    "seed": {
+        "type": "InputText",
+        "value": 42,
+        "label": "Random seed",
+    },
+    "n": {
+        "type": "SliderInt",
+        "value": 7,
+        "label": "Number of agents",
+        "min": 2,
+        "max": 10,
+        "step": 1,
+        # "description": "Choose how many agents to include in the model",
+    },
+    "num_nodes": {
+        "type": "SliderInt",
+        "value": 10,
+        "label": "Number of nodes",
+        "min": 3,
+        "max": 12,
+        "step": 1,
+        # "description": "Choose how many nodes to include in the model, with at least the same number of agents",
+    },
+}
+
+
+def post_process(ax):
+    ax.get_figure().colorbar(ax.collections[0], label="wealth", ax=ax)
+
+
+# Create initial model instance
+money_model = BoltzmannWealthModelNetwork(n=7, num_nodes=10, seed=42)
+
+# 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, 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.
+#
+# 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(
+    money_model,
+    components=[SpaceGraph, GiniPlot],
+    model_params=model_params,
+    name="Boltzmann Wealth Model: Network",
+)
+page  # noqa
+
+
+# In a notebook environment, we can also display the visualization elements
+# directly.
+#
+#   SpaceGraph(model1)
+#   GiniPlot(model1)
+
+# The plots will be static. If you want to pick up model steps,
+# you have to make the model reactive first
+#
+#   reactive_model = solara.reactive(model1)
+#   SpaceGraph(reactive_model)
+
+# In a different notebook block:
+#
+#   reactive_model.value.step()

examples/boltzmann_wealth_model_network/README.md

@@ -0,0 +1,36 @@
+from mesa.discrete_space import CellAgent
+
+
+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
+    if they occupy the same cell.
+
+    Attributes:
+        wealth (int): The agent's current wealth (starts at 1)
+    """
+
+    def __init__(self, model):
+        """Create a new agent.
+
+        Args:
+            model (Model): The model instance that contains the agent
+        """
+        super().__init__(model)
+        self.wealth = 1
+
+    def give_money(self):
+        neighbors = [agent for agent in self.cell.neighborhood.agents if agent != self]
+        if len(neighbors) > 0:
+            other = self.random.choice(neighbors)
+            other.wealth += 1
+            self.wealth -= 1
+
+    def step(self):
+        empty_neighbors = [cell for cell in self.cell.neighborhood if cell.is_empty]
+        if empty_neighbors:
+            self.cell = self.random.choice(empty_neighbors)
+
+        if self.wealth > 0:
+            self.give_money()