Mesa 3.0.0__py3-none-any.whl → 3.0.0a1__py3-none-any.whl

mesa/examples/basic/boltzmann_wealth_model/Readme.md

@@ -1,56 +0,0 @@
-# Boltzmann Wealth Model (Tutorial)
-
-## Summary
-
-A simple model of agents exchanging wealth. All agents start with the same amount of money. Every step, each agent with one unit of money or more gives one unit of wealth to another random agent. This is the model described in the [Intro Tutorial](https://mesa.readthedocs.io/en/latest/tutorials/intro_tutorial.html), with the completed code.
-
-If you want to go over the step-by-step tutorial, please go and run the [Jupyter Notebook](https://github.com/projectmesa/mesa/blob/main/docs/tutorials/intro_tutorial.ipynb). The code here runs the finalized code in the last cells directly.
-
-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.
-
-## How to Run
-
-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)
-
-
-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:
-
-```
-    $ solara run app.py
-```
-
-If your browser doesn't open automatically, point it to [http://127.0.0.1:8765/](http://127.0.0.1:8765/). When the visualization loads, click on the Play button.
-
-
-## Files
-
-* ``model.py``: Final version of the model.
-* ``agents.py``: Final version of the agent.
-* ``app.py``: Code for the interactive visualization.
-
-## Optional
-
-An optional visualization is also provided using Streamlit, which is another popular Python library for creating interactive web applications.
-
-To run the Streamlit app, you will need to install the `streamlit` and `altair` libraries:
-
-```
-    $ pip install streamlit altair
-```
-
-Then, you can run the Streamlit app using the following command:
-
-```
-    $ streamlit run st_app.py
-```
-
-## Further Reading
-
-The full tutorial describing how the model is built can be found at:
-https://mesa.readthedocs.io/en/latest/tutorials/intro_tutorial.html
-
-This model is drawn from econophysics and presents a statistical mechanics approach to wealth distribution. Some examples of further reading on the topic can be found at:
-
-[Milakovic, M. A Statistical Equilibrium Model of Wealth Distribution. February, 2001.](https://editorialexpress.com/cgi-bin/conference/download.cgi?db_name=SCE2001&paper_id=214)
-
-[Dragulescu, A and Yakovenko, V. Statistical Mechanics of Money, Income, and Wealth: A Short Survey. November, 2002](http://arxiv.org/pdf/cond-mat/0211175v1.pdf)

mesa/examples/basic/boltzmann_wealth_model/agents.py

@@ -1,31 +0,0 @@
-from mesa import Agent
-
-
-class MoneyAgent(Agent):
-    """An agent with fixed initial wealth."""
-
-    def __init__(self, model):
-        super().__init__(model)
-        self.wealth = 1
-
-    def move(self):
-        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)
-
-    def give_money(self):
-        cellmates = self.model.grid.get_cell_list_contents([self.pos])
-        cellmates.pop(
-            cellmates.index(self)
-        )  # Ensure agent is not giving money to itself
-        if len(cellmates) > 0:
-            other = self.random.choice(cellmates)
-            other.wealth += 1
-            self.wealth -= 1
-
-    def step(self):
-        self.move()
-        if self.wealth > 0:
-            self.give_money()

mesa/examples/basic/boltzmann_wealth_model/app.py

@@ -1,74 +0,0 @@
-from mesa.examples.basic.boltzmann_wealth_model.model import BoltzmannWealthModel
-from mesa.visualization import (
-    SolaraViz,
-    make_plot_component,
-    make_space_component,
-)
-
-
-def agent_portrayal(agent):
-    color = agent.wealth  # we are using a colormap to translate wealth to color
-    return {"color": color}
-
-
-model_params = {
-    "n": {
-        "type": "SliderInt",
-        "value": 50,
-        "label": "Number of agents:",
-        "min": 10,
-        "max": 100,
-        "step": 1,
-    },
-    "seed": {
-        "type": "InputText",
-        "value": 42,
-        "label": "Random Seed",
-    },
-    "width": 10,
-    "height": 10,
-}
-
-
-def post_process(ax):
-    ax.get_figure().colorbar(ax.collections[0], label="wealth", ax=ax)
-
-
-# Create initial model instance
-model = BoltzmannWealthModel(50, 10, 10)
-
-# 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(
-    model,
-    components=[SpaceGraph, GiniPlot],
-    model_params=model_params,
-    name="Boltzmann Wealth Model",
-)
-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()

mesa/examples/basic/boltzmann_wealth_model/model.py

@@ -1,43 +0,0 @@
-import mesa
-from mesa.examples.basic.boltzmann_wealth_model.agents import MoneyAgent
-
-
-class BoltzmannWealthModel(mesa.Model):
-    """A simple model of an economy where agents exchange currency at random.
-
-    All the agents begin with one unit of currency, and each time step can give
-    a unit of currency to another agent. Note how, over time, this produces a
-    highly skewed distribution of wealth.
-    """
-
-    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)
-
-        self.datacollector = mesa.DataCollector(
-            model_reporters={"Gini": self.compute_gini},
-            agent_reporters={"Wealth": "wealth"},
-        )
-        # Create agents
-        for _ in range(self.num_agents):
-            a = MoneyAgent(self)
-
-            # Add the agent to a random grid cell
-            x = self.random.randrange(self.grid.width)
-            y = self.random.randrange(self.grid.height)
-            self.grid.place_agent(a, (x, y))
-
-        self.running = True
-        self.datacollector.collect(self)
-
-    def step(self):
-        self.agents.shuffle_do("step")
-        self.datacollector.collect(self)
-
-    def compute_gini(self):
-        agent_wealths = [agent.wealth for agent in self.agents]
-        x = sorted(agent_wealths)
-        n = self.num_agents
-        b = sum(xi * (n - i) for i, xi in enumerate(x)) / (n * sum(x))
-        return 1 + (1 / n) - 2 * b

mesa/examples/basic/boltzmann_wealth_model/st_app.py

@@ -1,115 +0,0 @@
-# Run with streamlit run st_app.py
-
-import time
-
-import altair as alt
-import pandas as pd
-import streamlit as st
-from model import BoltzmannWealthModel
-
-model = st.title("Boltzman Wealth Model")
-num_agents = st.slider(
-    "Choose how many agents to include in the model",
-    min_value=1,
-    max_value=100,
-    value=50,
-)
-num_ticks = st.slider(
-    "Select number of Simulation Runs", min_value=1, max_value=100, value=50
-)
-height = st.slider("Select Grid Height", min_value=10, max_value=100, step=10, value=15)
-width = st.slider("Select Grid Width", min_value=10, max_value=100, step=10, value=20)
-model = BoltzmannWealthModel(num_agents, height, width)
-
-
-status_text = st.empty()
-run = st.button("Run Simulation")
-
-
-if run:
-    tick = time.time()
-    step = 0
-    # init grid
-    df_grid = pd.DataFrame()
-    df_gini = pd.DataFrame({"step": [0], "gini": [-1]})
-    for x in range(width):
-        for y in range(height):
-            df_grid = pd.concat(
-                [df_grid, pd.DataFrame({"x": [x], "y": [y], "agent_count": 0})],
-                ignore_index=True,
-            )
-
-    heatmap = (
-        alt.Chart(df_grid)
-        .mark_point(size=100)
-        .encode(x="x", y="y", color=alt.Color("agent_count"))
-        .interactive()
-        .properties(width=800, height=600)
-    )
-
-    line = (
-        alt.Chart(df_gini)
-        .mark_line(point=True)
-        .encode(x="step", y="gini")
-        .properties(width=800, height=600)
-    )
-
-    # init progress bar
-    my_bar = st.progress(0, text="Simulation Progress")  # progress
-    placeholder = st.empty()
-    st.subheader("Agent Grid")
-    chart = st.altair_chart(heatmap)
-    st.subheader("Gini Values")
-    line_chart = st.altair_chart(line)
-
-    color_scale = alt.Scale(
-        domain=[0, 1, 2, 3, 4], range=["red", "cyan", "white", "white", "blue"]
-    )
-    for i in range(num_ticks):
-        model.step()
-        my_bar.progress((i / num_ticks), text="Simulation progress")
-        placeholder.text("Step = %d" % i)
-        for cell in model.grid.coord_iter():
-            cell_content, (x, y) = cell
-            agent_count = len(cell_content)
-            selected_row = df_grid[(df_grid["x"] == x) & (df_grid["y"] == y)]
-            df_grid.loc[selected_row.index, "agent_count"] = (
-                agent_count  # random.choice([1,2])
-            )
-
-        df_gini = pd.concat(
-            [
-                df_gini,
-                pd.DataFrame(
-                    {"step": [i], "gini": [model.datacollector.model_vars["Gini"][i]]}
-                ),
-            ]
-        )
-        # st.table(df_grid)
-        heatmap = (
-            alt.Chart(df_grid)
-            .mark_circle(size=100)
-            .encode(x="x", y="y", color=alt.Color("agent_count", scale=color_scale))
-            .interactive()
-            .properties(width=800, height=600)
-        )
-        chart.altair_chart(heatmap)
-
-        line = (
-            alt.Chart(df_gini)
-            .mark_line(point=True)
-            .encode(x="step", y="gini")
-            .properties(width=800, height=600)
-        )
-        line_chart.altair_chart(line)
-
-        time.sleep(0.01)
-
-    tock = time.time()
-    st.success(f"Simulation completed in {tock - tick:.2f} secs")
-
-    # st.subheader('Agent Grid')
-    # fig = px.imshow(agent_counts,labels={'color':'Agent Count'})
-    # st.plotly_chart(fig)
-    # st.subheader('Gini value over sim ticks (Plotly)')
-    # chart = st.line_chart(model.datacollector.model_vars['Gini'])

mesa/examples/basic/conways_game_of_life/Readme.md

@@ -1,39 +0,0 @@
-# Conway's Game Of "Life"
-
-## Summary
-
-[The Game of Life](https://en.wikipedia.org/wiki/Conway%27s_Game_of_Life), also known simply as "Life", is a cellular automaton devised by the British mathematician John Horton Conway in 1970.
-
-The "game" is a zero-player game, meaning that its evolution is determined by its initial state, requiring no further input by a human. One interacts with the Game of "Life" by creating an initial configuration and observing how it evolves, or, for advanced "players", by creating patterns with particular properties.
-
-
-## How to Run
-
-To run the model interactively you can use either the streamlit or solara version. For solara, you use
-
-```
-    $ solara run app.py
-```
-
-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.
-* ``app.py``: Defines an interactive visualization using solara.
-* ``st_app.py``: Defines an interactive visualization using Streamlit.
-
-## Optional
-
-* For the streamlit version, you need to have streamlit installed (can be done via pip install streamlit)
-
-
-## Further Reading
-[Conway's Game of Life](https://en.wikipedia.org/wiki/Conway%27s_Game_of_Life)

mesa/examples/basic/conways_game_of_life/agents.py

@@ -1,47 +0,0 @@
-from mesa import Agent
-
-
-class Cell(Agent):
-    """Represents a single ALIVE or DEAD cell in the simulation."""
-
-    DEAD = 0
-    ALIVE = 1
-
-    def __init__(self, pos, model, 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.state = init_state
-        self._next_state = None
-
-    @property
-    def is_alive(self):
-        return self.state == self.ALIVE
-
-    @property
-    def neighbors(self):
-        return self.model.grid.iter_neighbors((self.x, self.y), True)
-
-    def determine_state(self):
-        """Compute if the cell will be dead or alive at the next tick.  This is
-        based on the number of alive or dead neighbors.  The state is not
-        changed here, but is just computed and stored in self._nextState,
-        because our current state may still be necessary for our neighbors
-        to calculate their next state.
-        """
-        # Get the neighbors and apply the rules on whether to be alive or dead
-        # at the next tick.
-        live_neighbors = sum(neighbor.is_alive for neighbor in self.neighbors)
-
-        # Assume nextState is unchanged, unless changed below.
-        self._next_state = self.state
-        if self.is_alive:
-            if live_neighbors < 2 or live_neighbors > 3:
-                self._next_state = self.DEAD
-        else:
-            if live_neighbors == 3:
-                self._next_state = self.ALIVE
-
-    def assume_state(self):
-        """Set the state to the new computed state -- computed in step()."""
-        self.state = self._next_state

mesa/examples/basic/conways_game_of_life/app.py

@@ -1,51 +0,0 @@
-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

mesa/examples/basic/conways_game_of_life/model.py

@@ -1,31 +0,0 @@
-from mesa import Model
-from mesa.examples.basic.conways_game_of_life.agents import Cell
-from mesa.space import SingleGrid
-
-
-class ConwaysGameOfLife(Model):
-    """Represents the 2-dimensional array of cells in Conway's Game of Life."""
-
-    def __init__(self, width=50, height=50, seed=None):
-        """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)
-
-        # 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() < 0.1:
-                cell.state = cell.ALIVE
-            self.grid.place_agent(cell, (x, y))
-
-        self.running = True
-
-    def step(self):
-        """Perform the model step in two stages:
-        - First, all cells assume their next state (whether they will be dead or alive)
-        - Then, all cells change state to their next state.
-        """
-        self.agents.do("determine_state")
-        self.agents.do("assume_state")

mesa/examples/basic/conways_game_of_life/st_app.py

@@ -1,72 +0,0 @@
-import time
-
-import altair as alt
-import numpy as np
-import pandas as pd
-import streamlit as st
-
-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)
-height = st.slider("Select Grid Height", min_value=10, max_value=100, step=10, value=15)
-width = st.slider("Select Grid Width", min_value=10, max_value=100, step=10, value=20)
-model = ConwaysGameOfLife(height, width)
-
-col1, col2, col3 = st.columns(3)
-status_text = st.empty()
-# step_mode = st.checkbox('Run Step-by-Step')
-run = st.button("Run Simulation")
-
-
-if run:
-    tick = time.time()
-    step = 0
-    # init grid
-    df_grid = pd.DataFrame()
-    agent_counts = np.zeros((model.grid.width, model.grid.height))
-    for x in range(width):
-        for y in range(height):
-            df_grid = pd.concat(
-                [df_grid, pd.DataFrame({"x": [x], "y": [y], "state": [0]})],
-                ignore_index=True,
-            )
-
-    heatmap = (
-        alt.Chart(df_grid)
-        .mark_point(size=100)
-        .encode(x="x", y="y", color=alt.Color("state"))
-        .interactive()
-        .properties(width=800, height=600)
-    )
-
-    # init progress bar
-    my_bar = st.progress(0, text="Simulation Progress")  # progress
-    placeholder = st.empty()
-    st.subheader("Agent Grid")
-    chart = st.altair_chart(heatmap, use_container_width=True)
-    color_scale = alt.Scale(domain=[0, 1], range=["red", "yellow"])
-    for i in range(num_ticks):
-        model.step()
-        my_bar.progress((i / num_ticks), text="Simulation progress")
-        placeholder.text("Step = %d" % i)
-        for contents, (x, y) in model.grid.coord_iter():
-            # 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
-            )  # random.choice([1,2])
-
-        heatmap = (
-            alt.Chart(df_grid)
-            .mark_circle(size=100)
-            .encode(x="x", y="y", color=alt.Color("state", scale=color_scale))
-            .interactive()
-            .properties(width=800, height=600)
-        )
-        chart.altair_chart(heatmap)
-
-        time.sleep(0.1)
-
-    tock = time.time()
-    st.success(f"Simulation completed in {tock - tick:.2f} secs")

mesa/examples/basic/schelling/Readme.md

@@ -1,40 +0,0 @@
-# Schelling Segregation Model
-
-## Summary
-
-The Schelling segregation model is a classic agent-based model, demonstrating how even a mild preference for similar neighbors can lead to a much higher degree of segregation than we would intuitively expect. The model consists of agents on a square grid, where each grid cell can contain at most one agent. Agents come in two colors: red and blue. They are happy if a certain number of their eight possible neighbors are of the same color, and unhappy otherwise. Unhappy agents will pick a random empty cell to move to each step, until they are happy. The model keeps running until there are no unhappy agents.
-
-By default, the number of similar neighbors the agents need to be happy is set to 3. That means the agents would be perfectly happy with a majority of their neighbors being of a different color (e.g. a Blue agent would be happy with five Red neighbors and three Blue ones). Despite this, the model consistently leads to a high degree of segregation, with most agents ending up with no neighbors of a different color.
-
-## How to Run
-
-To run the model interactively, in this directory, run the following command
-
-```
-    $ solara run app.py
-```
-
-Then open your browser to [http://127.0.0.1:8765/](http://127.0.0.1:8765/) and click the Play button.
-
-To view and run some example model analyses, launch the IPython Notebook and open ``analysis.ipynb``. Visualizing the analysis also requires [matplotlib](http://matplotlib.org/).
-
-## How to Run without the GUI
-
-To run the model with the grid displayed as an ASCII text, run `python run_ascii.py` in this directory.
-
-## Files
-
-* ``model.py``: Contains the Schelling model class
-*  ``agents.py``: Contains the Schelling agent class
-* ``app.py``: Code for the interactive visualization.
-* ``analysis.ipynb``: Notebook demonstrating how to run experiments and parameter sweeps on the model.
-
-## Further Reading
-
-Schelling's original paper describing the model:
-
-[Schelling, Thomas C. Dynamic Models of Segregation. Journal of Mathematical Sociology. 1971, Vol. 1, pp 143-186.](https://www.stat.berkeley.edu/~aldous/157/Papers/Schelling_Seg_Models.pdf)
-
-An interactive, browser-based explanation and implementation:
-
-[Parable of the Polygons](http://ncase.me/polygons/), by Vi Hart and Nicky Case.

mesa/examples/basic/schelling/agents.py

@@ -1,26 +0,0 @@
-from mesa import Agent, Model
-
-
-class SchellingAgent(Agent):
-    """Schelling segregation agent."""
-
-    def __init__(self, model: Model, agent_type: int) -> None:
-        """Create a new Schelling agent.
-
-        Args:
-           agent_type: Indicator for the agent's type (minority=1, majority=0)
-        """
-        super().__init__(model)
-        self.type = agent_type
-
-    def step(self) -> None:
-        neighbors = self.model.grid.iter_neighbors(
-            self.pos, moore=True, radius=self.model.radius
-        )
-        similar = sum(1 for neighbor in neighbors if neighbor.type == self.type)
-
-        # If unhappy, move:
-        if similar < self.model.homophily:
-            self.model.grid.move_to_empty(self)
-        else:
-            self.model.happy += 1