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

mesa/examples/basic/conways_game_of_life/model.py

@@ -1,6 +1,6 @@
 from mesa import Model
+from mesa.discrete_space import OrthogonalMooreGrid
 from mesa.examples.basic.conways_game_of_life.agents import Cell
-from mesa.space import SingleGrid
 
 
 class ConwaysGameOfLife(Model):
@@ -10,15 +10,18 @@ class ConwaysGameOfLife(Model):
         """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)
+        self.grid = OrthogonalMooreGrid((width, height), capacity=1, 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() < initial_fraction_alive:
-                cell.state = cell.ALIVE
-            self.grid.place_agent(cell, (x, y))
+        for cell in self.grid.all_cells:
+            Cell(
+                self,
+                cell,
+                init_state=Cell.ALIVE
+                if self.random.random() < initial_fraction_alive
+                else Cell.DEAD,
+            )
 
         self.running = True
 

mesa/examples/basic/schelling/Readme.md

@@ -14,14 +14,6 @@ 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

mesa/examples/basic/schelling/agents.py

@@ -1,23 +1,28 @@
-from mesa import Agent
+from mesa.discrete_space import CellAgent
 
 
-class SchellingAgent(Agent):
+class SchellingAgent(CellAgent):
     """Schelling segregation agent."""
 
-    def __init__(self, model, agent_type: int) -> None:
+    def __init__(
+        self, model, cell, agent_type: int, homophily: float = 0.4, radius: int = 1
+    ) -> 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)
+            homophily: Minimum number of similar neighbors needed for happiness
+            radius: Search radius for checking neighbor similarity
         """
         super().__init__(model)
+        self.cell = cell
         self.type = agent_type
+        self.homophily = homophily
+        self.radius = radius
 
     def step(self) -> None:
         """Determine if agent is happy and move if necessary."""
-        neighbors = self.model.grid.get_neighbors(
-            self.pos, moore=True, radius=self.model.radius
-        )
+        neighbors = list(self.cell.get_neighborhood(radius=self.radius).agents)
 
         # Count similar neighbors
         similar_neighbors = len([n for n in neighbors if n.type == self.type])
@@ -30,7 +35,7 @@ class SchellingAgent(Agent):
             similarity_fraction = 0.0
 
         # Move if unhappy
-        if similarity_fraction < self.model.homophily:
-            self.model.grid.move_to_empty(self)
+        if similarity_fraction < self.homophily:
+            self.cell = self.model.grid.select_random_empty_cell()
         else:
             self.model.happy += 1

mesa/examples/basic/schelling/model.py

@@ -1,7 +1,7 @@
 from mesa import Model
 from mesa.datacollection import DataCollector
+from mesa.discrete_space import OrthogonalMooreGrid
 from mesa.examples.basic.schelling.agents import SchellingAgent
-from mesa.space import SingleGrid
 
 
 class Schelling(Model):
@@ -31,15 +31,11 @@ class Schelling(Model):
         super().__init__(seed=seed)
 
         # Model parameters
-        self.height = height
-        self.width = width
         self.density = density
         self.minority_pc = minority_pc
-        self.homophily = homophily
-        self.radius = radius
 
         # Initialize grid
-        self.grid = SingleGrid(width, height, torus=True)
+        self.grid = OrthogonalMooreGrid((width, height), random=self.random, capacity=1)
 
         # Track happiness
         self.happy = 0
@@ -64,11 +60,12 @@ class Schelling(Model):
         )
 
         # Create agents and place them on the grid
-        for _, pos in self.grid.coord_iter():
+        for cell in self.grid.all_cells:
             if self.random.random() < self.density:
                 agent_type = 1 if self.random.random() < minority_pc else 0
-                agent = SchellingAgent(self, agent_type)
-                self.grid.place_agent(agent, pos)
+                SchellingAgent(
+                    self, cell, agent_type, homophily=homophily, radius=radius
+                )
 
         # Collect initial state
         self.datacollector.collect(self)

mesa/examples/basic/virus_on_network/Readme.md

@@ -38,10 +38,6 @@ To run the model interactively, in this directory, run 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
-
-
 [Stonedahl, F. and Wilensky, U. (2008). NetLogo Virus on a Network model](http://ccl.northwestern.edu/netlogo/models/VirusonaNetwork).
 Center for Connected Learning and Computer-Based Modeling, Northwestern University, Evanston, IL.
 

mesa/examples/basic/virus_on_network/agents.py

@@ -1,6 +1,6 @@
 from enum import Enum
 
-from mesa import Agent
+from mesa.discrete_space import FixedAgent
 
 
 class State(Enum):
@@ -9,7 +9,7 @@ class State(Enum):
     RESISTANT = 2
 
 
-class VirusAgent(Agent):
+class VirusAgent(FixedAgent):
     """Individual Agent definition and its properties/interaction methods."""
 
     def __init__(
@@ -20,6 +20,7 @@ class VirusAgent(Agent):
         virus_check_frequency,
         recovery_chance,
         gain_resistance_chance,
+        cell,
     ):
         super().__init__(model)
 
@@ -29,19 +30,14 @@ class VirusAgent(Agent):
         self.virus_check_frequency = virus_check_frequency
         self.recovery_chance = recovery_chance
         self.gain_resistance_chance = gain_resistance_chance
+        self.cell = cell
 
     def try_to_infect_neighbors(self):
-        neighbors_nodes = self.model.grid.get_neighborhood(
-            self.pos, include_center=False
-        )
-        susceptible_neighbors = [
-            agent
-            for agent in self.model.grid.get_cell_list_contents(neighbors_nodes)
-            if agent.state is State.SUSCEPTIBLE
-        ]
-        for a in susceptible_neighbors:
-            if self.random.random() < self.virus_spread_chance:
-                a.state = State.INFECTED
+        for agent in self.cell.neighborhood.agents:
+            if (agent.state is State.SUSCEPTIBLE) and (
+                self.random.random() < self.virus_spread_chance
+            ):
+                agent.state = State.INFECTED
 
     def try_gain_resistance(self):
         if self.random.random() < self.gain_resistance_chance:
@@ -57,13 +53,13 @@ class VirusAgent(Agent):
             # Failed
             self.state = State.INFECTED
 
-    def try_check_situation(self):
-        if (self.random.random() < self.virus_check_frequency) and (
-            self.state is State.INFECTED
+    def check_situation(self):
+        if (self.state is State.INFECTED) and (
+            self.random.random() < self.virus_check_frequency
         ):
             self.try_remove_infection()
 
     def step(self):
         if self.state is State.INFECTED:
             self.try_to_infect_neighbors()
-        self.try_check_situation()
+        self.check_situation()

mesa/examples/basic/virus_on_network/model.py

@@ -4,11 +4,12 @@ import networkx as nx
 
 import mesa
 from mesa import Model
+from mesa.discrete_space import CellCollection, Network
 from mesa.examples.basic.virus_on_network.agents import State, VirusAgent
 
 
 def number_state(model, state):
-    return sum(1 for a in model.grid.get_all_cell_contents() if a.state is state)
+    return sum(1 for a in model.grid.all_cells.agents if a.state is state)
 
 
 def number_infected(model):
@@ -38,18 +39,13 @@ class VirusOnNetwork(Model):
         seed=None,
     ):
         super().__init__(seed=seed)
-        self.num_nodes = num_nodes
-        prob = avg_node_degree / self.num_nodes
-        self.G = nx.erdos_renyi_graph(n=self.num_nodes, p=prob)
-        self.grid = mesa.space.NetworkGrid(self.G)
+        prob = avg_node_degree / num_nodes
+        graph = nx.erdos_renyi_graph(n=num_nodes, p=prob)
+        self.grid = Network(graph, capacity=1, random=self.random)
 
         self.initial_outbreak_size = (
             initial_outbreak_size if initial_outbreak_size <= num_nodes else num_nodes
         )
-        self.virus_spread_chance = virus_spread_chance
-        self.virus_check_frequency = virus_check_frequency
-        self.recovery_chance = recovery_chance
-        self.gain_resistance_chance = gain_resistance_chance
 
         self.datacollector = mesa.DataCollector(
             {
@@ -60,23 +56,23 @@ class VirusOnNetwork(Model):
             }
         )
 
-        # Create agents
-        for node in self.G.nodes():
-            a = VirusAgent(
-                self,
-                State.SUSCEPTIBLE,
-                self.virus_spread_chance,
-                self.virus_check_frequency,
-                self.recovery_chance,
-                self.gain_resistance_chance,
-            )
-
-            # Add the agent to the node
-            self.grid.place_agent(a, node)
+        VirusAgent.create_agents(
+            self,
+            num_nodes,
+            State.SUSCEPTIBLE,
+            virus_spread_chance,
+            virus_check_frequency,
+            recovery_chance,
+            gain_resistance_chance,
+            list(self.grid.all_cells),
+        )
 
         # Infect some nodes
-        infected_nodes = self.random.sample(list(self.G), self.initial_outbreak_size)
-        for a in self.grid.get_cell_list_contents(infected_nodes):
+        infected_nodes = CellCollection(
+            self.random.sample(list(self.grid.all_cells), self.initial_outbreak_size),
+            random=self.random,
+        )
+        for a in infected_nodes.agents:
             a.state = State.INFECTED
 
         self.running = True

mesa/experimental/__init__.py

@@ -15,6 +15,6 @@ Notes:
     - Features graduate from experimental status once their APIs are stabilized
 """
 
-from mesa.experimental import cell_space, continuous_space, devs, mesa_signals
+from mesa.experimental import continuous_space, devs, mesa_signals, meta_agents
 
-__all__ = ["cell_space", "continuous_space", "devs", "mesa_signals"]
+__all__ = ["continuous_space", "devs", "mesa_signals", "meta_agents"]

mesa/experimental/cell_space/__init__.py

@@ -15,23 +15,25 @@ like resource growth, pollution diffusion, or infrastructure networks. The cell
 space system is experimental and under active development.
 """
 
-from mesa.experimental.cell_space.cell import Cell
-from mesa.experimental.cell_space.cell_agent import (
+import warnings
+
+from mesa.discrete_space.cell import Cell
+from mesa.discrete_space.cell_agent import (
     CellAgent,
     FixedAgent,
     Grid2DMovingAgent,
 )
-from mesa.experimental.cell_space.cell_collection import CellCollection
-from mesa.experimental.cell_space.discrete_space import DiscreteSpace
-from mesa.experimental.cell_space.grid import (
+from mesa.discrete_space.cell_collection import CellCollection
+from mesa.discrete_space.discrete_space import DiscreteSpace
+from mesa.discrete_space.grid import (
     Grid,
     HexGrid,
     OrthogonalMooreGrid,
     OrthogonalVonNeumannGrid,
 )
-from mesa.experimental.cell_space.network import Network
-from mesa.experimental.cell_space.property_layer import PropertyLayer
-from mesa.experimental.cell_space.voronoi import VoronoiGrid
+from mesa.discrete_space.network import Network
+from mesa.discrete_space.property_layer import PropertyLayer
+from mesa.discrete_space.voronoi import VoronoiGrid
 
 __all__ = [
     "Cell",
@@ -48,3 +50,11 @@ __all__ = [
     "PropertyLayer",
     "VoronoiGrid",
 ]
+
+
+warnings.warn(
+    "you are importing from mesa.experimental.cell_space, "
+    "all cell spaces have been moved to mesa.discrete_space",
+    DeprecationWarning,
+    stacklevel=2,
+)

mesa/experimental/meta_agents/__init__.py

@@ -0,0 +1,25 @@
+"""This method is for dynamically creating new agents (meta-agents).
+
+Meta-agents are defined as agents composed of existing agents.
+
+Meta-agents are created dynamically with a pointer to the model, name of the meta-agent,,
+iterable of agents to belong to the new meta-agents, any new functions for the meta-agent,
+any new attributes for the meta-agent, whether to retain sub-agent functions,
+whether to retain sub-agent attributes.
+
+Examples of meta-agents:
+- An autonomous car where the subagents are the wheels, sensors,
+battery, computer etc. and the meta-agent is the car itself.
+- A company where the subagents are employees, departments, buildings, etc.
+- A city where the subagents are people, buildings, streets, etc.
+
+Currently meta-agents are restricted to one parent agent for each subagent/
+one meta-agent per subagent.
+
+Goal is to assess usage and expand functionality.
+
+"""
+
+from .meta_agent import MetaAgent
+
+__all__ = ["MetaAgent"]