Mesa 3.1.5__py3-none-any.whl → 3.2.0__py3-none-any.whl

mesa/examples/advanced/alliance_formation/model.py

@@ -0,0 +1,184 @@
+import networkx as nx
+import numpy as np
+
+import mesa
+from mesa import Agent
+from mesa.examples.advanced.alliance_formation.agents import AllianceAgent
+from mesa.experimental.meta_agents.meta_agent import (
+    create_meta_agent,
+    find_combinations,
+)
+
+
+class MultiLevelAllianceModel(mesa.Model):
+    """
+    Model for simulating multi-level alliances among agents.
+    """
+
+    def __init__(self, n=50, mean=0.5, std_dev=0.1, seed=42):
+        """
+        Initialize the model.
+
+        Args:
+            n (int): Number of agents.
+            mean (float): Mean value for normal distribution.
+            std_dev (float): Standard deviation for normal distribution.
+            seed (int): Random seed.
+        """
+        super().__init__(seed=seed)
+        self.population = n
+        self.network = nx.Graph()  # Initialize the network
+        self.datacollector = mesa.DataCollector(model_reporters={"Network": "network"})
+
+        # Create Agents
+        power = self.rng.normal(mean, std_dev, n)
+        power = np.clip(power, 0, 1)
+        position = self.rng.normal(mean, std_dev, n)
+        position = np.clip(position, 0, 1)
+        AllianceAgent.create_agents(self, n, power, position)
+        agent_ids = [
+            (agent.unique_id, {"size": 300, "level": 0}) for agent in self.agents
+        ]
+        self.network.add_nodes_from(agent_ids)
+
+    def add_link(self, meta_agent, agents):
+        """
+        Add links between a meta agent and its constituent agents in the network.
+
+        Args:
+            meta_agent (MetaAgent): The meta agent.
+            agents (list): List of agents.
+        """
+        for agent in agents:
+            self.network.add_edge(meta_agent.unique_id, agent.unique_id)
+
+    def calculate_shapley_value(self, agents):
+        """
+        Calculate the Shapley value of the two agents.
+
+        Args:
+            agents (list): List of agents.
+
+        Returns:
+            tuple: Potential utility, new position, and level.
+        """
+        positions = agents.get("position")
+        new_position = 1 - (max(positions) - min(positions))
+        potential_utility = agents.agg("power", sum) * 1.2 * new_position
+
+        value_0 = 0.5 * agents[0].power + 0.5 * (potential_utility - agents[1].power)
+        value_1 = 0.5 * agents[1].power + 0.5 * (potential_utility - agents[0].power)
+
+        if value_0 > agents[0].power and value_1 > agents[1].power:
+            if agents[0].level > agents[1].level:
+                level = agents[0].level
+            elif agents[0].level == agents[1].level:
+                level = agents[0].level + 1
+            else:
+                level = agents[1].level
+
+            return potential_utility, new_position, level
+
+    def only_best_combination(self, combinations):
+        """
+        Filter to keep only the best combination for each agent.
+
+        Args:
+            combinations (list): List of combinations.
+
+        Returns:
+            dict: Unique combinations.
+        """
+        best = {}
+        # Determine best option for EACH agent
+        for group, value in combinations:
+            agent_ids = sorted(group.get("unique_id"))  # by default is bilateral
+            # Deal with all possibilities
+            if (
+                agent_ids[0] not in best and agent_ids[1] not in best
+            ):  # if neither in add both
+                best[agent_ids[0]] = [group, value, agent_ids]
+                best[agent_ids[1]] = [group, value, agent_ids]
+            elif (
+                agent_ids[0] in best and agent_ids[1] in best
+            ):  # if both in, see if both would be trading up
+                if (
+                    value[0] > best[agent_ids[0]][1][0]
+                    and value[0] > best[agent_ids[1]][1][0]
+                ):
+                    # Remove the old alliances
+                    del best[best[agent_ids[0]][2][1]]
+                    del best[best[agent_ids[1]][2][0]]
+                    # Add the new alliance
+                    best[agent_ids[0]] = [group, value, agent_ids]
+                    best[agent_ids[1]] = [group, value, agent_ids]
+            elif (
+                agent_ids[0] in best
+            ):  # if only agent_ids[0] in, see if it would be trading up
+                if value[0] > best[agent_ids[0]][1][0]:
+                    # Remove the old alliance for agent_ids[0]
+                    del best[best[agent_ids[0]][2][1]]
+                    # Add the new alliance
+                    best[agent_ids[0]] = [group, value, agent_ids]
+                    best[agent_ids[1]] = [group, value, agent_ids]
+            elif (
+                agent_ids[1] in best
+            ):  # if only agent_ids[1] in, see if it would be trading up
+                if value[0] > best[agent_ids[1]][1][0]:
+                    # Remove the old alliance for agent_ids[1]
+                    del best[best[agent_ids[1]][2][0]]
+                    # Add the new alliance
+                    best[agent_ids[0]] = [group, value, agent_ids]
+                    best[agent_ids[1]] = [group, value, agent_ids]
+
+        # Create a unique dictionary of the best combinations
+        unique_combinations = {}
+        for group, value, agents_nums in best.values():
+            unique_combinations[tuple(agents_nums)] = [group, value]
+
+        return unique_combinations.values()
+
+    def step(self):
+        """
+        Execute one step of the model.
+        """
+        # Get all other agents of the same type
+        agent_types = list(self.agents_by_type.keys())
+
+        for agent_type in agent_types:
+            similar_agents = self.agents_by_type[agent_type]
+
+            # Find the best combinations using find_combinations
+            if (
+                len(similar_agents) > 1
+            ):  # only form alliances if there are more than 1 agent
+                combinations = find_combinations(
+                    self,
+                    similar_agents,
+                    size=2,
+                    evaluation_func=self.calculate_shapley_value,
+                    filter_func=self.only_best_combination,
+                )
+
+                for alliance, attributes in combinations:
+                    class_name = f"MetaAgentLevel{attributes[2]}"
+                    meta = create_meta_agent(
+                        self,
+                        class_name,
+                        alliance,
+                        Agent,
+                        meta_attributes={
+                            "level": attributes[2],
+                            "power": attributes[0],
+                            "position": attributes[1],
+                        },
+                    )
+
+                    # Update the network if a new meta agent instance created
+                    if meta:
+                        self.network.add_node(
+                            meta.unique_id,
+                            size=(meta.level + 1) * 300,
+                            level=meta.level,
+                        )
+                        self.add_link(meta, meta.agents)

mesa/examples/advanced/epstein_civil_violence/agents.py

@@ -10,7 +10,7 @@ class CitizenState(Enum):
     ARRESTED = 3
 
 
-class EpsteinAgent(mesa.experimental.cell_space.CellAgent):
+class EpsteinAgent(mesa.discrete_space.CellAgent):
     def update_neighbors(self):
         """
         Look around and see who my neighbors are

mesa/examples/advanced/epstein_civil_violence/model.py

@@ -53,7 +53,7 @@ class EpsteinCivilViolence(mesa.Model):
         self.movement = movement
         self.max_iters = max_iters
 
-        self.grid = mesa.experimental.cell_space.OrthogonalVonNeumannGrid(
+        self.grid = mesa.discrete_space.OrthogonalVonNeumannGrid(
             (width, height), capacity=1, torus=True, random=self.random
         )
 

mesa/examples/advanced/pd_grid/Readme.md

@@ -17,13 +17,11 @@ The Demographic Prisoner's Dilemma demonstrates how simple rules can lead to the
 
 ## How to Run
 
-##### Web based model simulation
+To run the model interactively, in this directory, run the following command
 
-To run the model interactively, run ``solara run app.py`` in this directory.
-
-##### Jupyter Notebook
-
-Launch the ``Demographic Prisoner's Dilemma Activation Schedule.ipynb`` notebook and run the code.
+```
+    $ solara run app.py
+```
 
 ## Files
 

mesa/examples/advanced/pd_grid/agents.py

@@ -1,4 +1,4 @@
-from mesa.experimental.cell_space import CellAgent
+from mesa.discrete_space import CellAgent
 
 
 class PDAgent(CellAgent):

mesa/examples/advanced/pd_grid/model.py

@@ -1,6 +1,6 @@
 import mesa
+from mesa.discrete_space import OrthogonalMooreGrid
 from mesa.examples.advanced.pd_grid.agents import PDAgent
-from mesa.experimental.cell_space import OrthogonalMooreGrid
 
 
 class PdGrid(mesa.Model):

mesa/examples/advanced/sugarscape_g1mt/Readme.md

@@ -42,14 +42,13 @@ The model demonstrates several Mesa concepts and features:
 
 
 ## How to Run
-To run the model interactively:
+
+To run the model interactively, in this directory, run the following command
 
 ```
-  $ solara run app.py
+    $ 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
 
 * `model.py`: The Sugarscape Constant Growback with Traders model.
@@ -58,7 +57,7 @@ Then open your browser to [http://127.0.0.1:8521/](http://127.0.0.1:8521/) and p
 * `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
+## Further Reading
 
 - [Growing Artificial Societies](https://mitpress.mit.edu/9780262550253/growing-artificial-societies/)
 - [Complexity Explorer Sugarscape with Traders Tutorial](https://www.complexityexplorer.org/courses/172-agent-based-models-with-python-an-introduction-to-mesa)

mesa/examples/advanced/sugarscape_g1mt/agents.py

@@ -1,6 +1,6 @@
 import math
 
-from mesa.experimental.cell_space import CellAgent
+from mesa.discrete_space import CellAgent
 
 
 # Helper function

mesa/examples/advanced/sugarscape_g1mt/model.py

@@ -3,9 +3,9 @@ from pathlib import Path
 import numpy as np
 
 import mesa
+from mesa.discrete_space import OrthogonalVonNeumannGrid
+from mesa.discrete_space.property_layer import PropertyLayer
 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

mesa/examples/advanced/wolf_sheep/Readme.md

@@ -14,29 +14,14 @@ The model is tests and demonstrates several Mesa concepts and features:
  - Writing a model composed of multiple files.
  - Dynamically adding and removing agents from the schedule
 
-## Installation
-
-To install the dependencies use pip and the requirements.txt in this directory. e.g.
-
-```
-    # First, we clone the Mesa repo
-    $ git clone https://github.com/projectmesa/mesa.git
-    $ cd mesa
-    # Then we cd to the example directory
-    $ cd examples/wolf_sheep
-    $ pip install -r requirements.txt
-```
-
 ## How to Run
 
-To run the model interactively, run ``mesa runserver`` in this directory. e.g.
+To run the model interactively, in this directory, run the following command
 
 ```
-    $ 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
 
 * ``wolf_sheep/random_walk.py``: This defines the ``RandomWalker`` agent, which implements the behavior of moving randomly across a grid, one cell at a time. Both the Wolf and Sheep agents will inherit from it.

mesa/examples/advanced/wolf_sheep/agents.py

@@ -1,4 +1,4 @@
-from mesa.experimental.cell_space import CellAgent, FixedAgent
+from mesa.discrete_space import CellAgent, FixedAgent
 
 
 class Animal(CellAgent):

mesa/examples/advanced/wolf_sheep/app.py

@@ -2,6 +2,7 @@ from mesa.examples.advanced.wolf_sheep.agents import GrassPatch, Sheep, Wolf
 from mesa.examples.advanced.wolf_sheep.model import WolfSheep
 from mesa.experimental.devs import ABMSimulator
 from mesa.visualization import (
+    CommandConsole,
     Slider,
     SolaraViz,
     make_plot_component,
@@ -87,7 +88,7 @@ model = WolfSheep(simulator=simulator, grass=True)
 
 page = SolaraViz(
     model,
-    components=[space_component, lineplot_component],
+    components=[space_component, lineplot_component, CommandConsole],
     model_params=model_params,
     name="Wolf Sheep",
     simulator=simulator,

mesa/examples/advanced/wolf_sheep/model.py

@@ -13,8 +13,8 @@ import math
 
 from mesa import Model
 from mesa.datacollection import DataCollector
+from mesa.discrete_space import OrthogonalVonNeumannGrid
 from mesa.examples.advanced.wolf_sheep.agents import GrassPatch, Sheep, Wolf
-from mesa.experimental.cell_space import OrthogonalVonNeumannGrid
 from mesa.experimental.devs import ABMSimulator
 
 

mesa/examples/basic/boid_flockers/Readme.md

@@ -8,7 +8,12 @@ This model tests Mesa's continuous space feature, and uses numpy arrays to repre
 
 ## How to Run
 
-* To launch the visualization interactively, run ``solara run app.py`` in this directory.It will automatically open a browser page.
+To run the model interactively, in this directory, run the following command
+
+```
+    $ solara run app.py
+```
+
 
 ## Files
 

mesa/examples/basic/boid_flockers/agents.py

@@ -58,6 +58,7 @@ class Boid(ContinuousSpaceAgent):
         self.separate_factor = separate
         self.match_factor = match
         self.neighbors = []
+        self.angle = 0.0  # represents the angle at which the boid is moving
 
     def step(self):
         """Get the Boid's neighbors, compute the new vector, and move accordingly."""

mesa/examples/basic/boid_flockers/app.py

@@ -1,19 +1,34 @@
 import os
 import sys
 
+from matplotlib.markers import MarkerStyle
+
 sys.path.insert(0, os.path.abspath("../../../.."))
 
 from mesa.examples.basic.boid_flockers.model import BoidFlockers
 from mesa.visualization import Slider, SolaraViz, make_space_component
 
+# Pre-compute markers for different angles (e.g., every 10 degrees)
+MARKER_CACHE = {}
+for angle in range(0, 360, 10):
+    marker = MarkerStyle(10)
+    marker._transform = marker.get_transform().rotate_deg(angle)
+    MARKER_CACHE[angle] = marker
+
 
 def boid_draw(agent):
     neighbors = len(agent.neighbors)
 
+    # Calculate the angle
+    deg = agent.angle
+    # Round to nearest 10 degrees
+    rounded_deg = round(deg / 10) * 10 % 360
+
+    # using cached markers to speed things up
     if neighbors <= 1:
-        return {"color": "red", "size": 20}
+        return {"color": "red", "size": 20, "marker": MARKER_CACHE[rounded_deg]}
     elif neighbors >= 2:
-        return {"color": "green", "size": 20}
+        return {"color": "green", "size": 20, "marker": MARKER_CACHE[rounded_deg]}
 
 
 model_params = {

mesa/examples/basic/boid_flockers/model.py

@@ -49,6 +49,9 @@ class BoidFlockers(Model):
             seed: Random seed for reproducibility (default: None)
         """
         super().__init__(seed=seed)
+        self.agent_angles = np.zeros(
+            population_size
+        )  # holds the angle representing the direction of all agents at a given step
 
         # Set up the space
         self.space = ContinuousSpace(
@@ -79,6 +82,14 @@ class BoidFlockers(Model):
         self.average_heading = None
         self.update_average_heading()
 
+    # vectorizing the calculation of angles for all agents
+    def calculate_angles(self):
+        d1 = np.array([agent.direction[0] for agent in self.agents])
+        d2 = np.array([agent.direction[1] for agent in self.agents])
+        self.agent_angles = np.degrees(np.arctan2(d1, d2))
+        for agent, angle in zip(self.agents, self.agent_angles):
+            agent.angle = angle
+
     def update_average_heading(self):
         """Calculate the average heading (direction) of all Boids."""
         if not self.agents:
@@ -96,3 +107,4 @@ class BoidFlockers(Model):
         """
         self.agents.shuffle_do("step")
         self.update_average_heading()
+        self.calculate_angles()

mesa/examples/basic/boltzmann_wealth_model/Readme.md

@@ -2,25 +2,18 @@
 
 ## 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.
+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. Mesa's [Getting Started](https://mesa.readthedocs.io/latest/getting_started.html) section walks through the Boltzmann Wealth Model in a series of short introductory tutorials, starting with[Creating your First Model](https://mesa.readthedocs.io/latest/tutorials/0_first_model.html).
 
 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:
+To run the model interactively, in this directory, run the following command
 
 ```
     $ 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
 
@@ -46,9 +39,6 @@ Then, you can run the Streamlit app using the following command:
 
 ## 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)

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/Readme.md

@@ -9,20 +9,12 @@ The "game" is a zero-player game, meaning that its evolution is determined by it
 
 ## How to Run
 
-To run the model interactively you can use either the streamlit or solara version. For solara, you use
+To run the model interactively, in this directory, run the following command
 
 ```
     $ 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.

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