Have Agent use self.model instead of passing it around

Author: Nathan Miller

docs/tutorials/intro_tutorial.ipynb

@@ -104,8 +104,8 @@
     "\n",
     "class MoneyAgent(Agent):\n",
     "    \"\"\"An agent with fixed initial wealth.\"\"\"\n",
-    "    def __init__(self, unique_id):\n",
-    "        self.unique_id = unique_id\n",
+    "    def __init__(self, unique_id, model):\n",
+    "        super().__init__(unique_id, model)\n",
     "        self.wealth = 1\n",
     "\n",
     "class MoneyModel(Model):\n",
@@ -114,7 +114,7 @@
     "        self.num_agents = N\n",
     "        # Create agents\n",
     "        for i in range(self.num_agents):\n",
-    "            a = MoneyAgent(i)"
+    "            a = MoneyAgent(i, self)"
    ]
   },
   {
@@ -145,11 +145,11 @@
     "\n",
     "class MoneyAgent(Agent):\n",
     "    \"\"\" An agent with fixed initial wealth.\"\"\"\n",
-    "    def __init__(self, unique_id):\n",
-    "        self.unique_id = unique_id\n",
+    "    def __init__(self, unique_id, model):\n",
+    "        super().__init__(unique_id, model)\n",
     "        self.wealth = 1\n",
     "\n",
-    "    def step(self, model):\n",
+    "    def step(self):\n",
     "        # The agent's step will go here.\n",
     "        pass\n",
     "\n",
@@ -160,7 +160,7 @@
     "        self.schedule = RandomActivation(self)\n",
     "        # Create agents\n",
     "        for i in range(self.num_agents):\n",
-    "            a = MoneyAgent(i)\n",
+    "            a = MoneyAgent(i, self)\n",
     "            self.schedule.add(a)\n",
     "\n",
     "    def step(self):\n",
@@ -242,14 +242,14 @@
    "source": [
     "class MoneyAgent(Agent):\n",
     "    \"\"\" An agent with fixed initial wealth.\"\"\"\n",
-    "    def __init__(self, unique_id):\n",
-    "        self.unique_id = unique_id\n",
+    "    def __init__(self, unique_id, model):\n",
+    "        super().__init__(unique_id, model)\n",
     "        self.wealth = 1\n",
     "\n",
-    "    def step(self, model):\n",
+    "    def step(self):\n",
     "        if self.wealth == 0:\n",
     "            return\n",
-    "        other_agent = random.choice(model.schedule.agents)\n",
+    "        other_agent = random.choice(self.model.schedule.agents)\n",
     "        other_agent.wealth += 1\n",
     "        self.wealth -= 1"
    ]
@@ -449,7 +449,7 @@
     "        \n",
     "        # Create agents\n",
     "        for i in range(self.num_agents):\n",
-    "            a = MoneyAgent(i)\n",
+    "            a = MoneyAgent(i, self)\n",
     "            self.schedule.add(a)\n",
     "            \n",
     "            # Add the agent to a random grid cell\n",
@@ -483,22 +483,22 @@
     "```python\n",
     "class MoneyAgent(Agent):\n",
     "   #...\n",
-    "    def move(self, model):\n",
-    "        possible_steps = model.grid.get_neighborhood(\n",
+    "    def move(self):\n",
+    "        possible_steps = self.model.grid.get_neighborhood(\n",
     "            self.pos, \n",
     "            moore=True,\n",
     "            include_center=False)\n",
     "        new_position = random.choice(possible_steps)\n",
-    "        model.grid.move_agent(self, new_position)\n",
+    "        self.model.grid.move_agent(self, new_position)\n",
     "```\n",
     "\n",
     "Next, we need to get all the other agents present in a cell, and give one of them some money. We can get the contents of one or more cells using the grid's `get_cell_list_contents` method, or by accessing a cell directly. The method accepts a list of cell coordinate tuples, or a single tuple if we only care about one cell.\n",
     "\n",
     "```python\n",
     "class MoneyAgent(Agent):\n",
     "    #...\n",
-    "    def give_money(self, model):\n",
-    "        cellmates = model.grid.get_cell_list_contents([self.pos])\n",
+    "    def give_money(self):\n",
+    "        cellmates = self.model.grid.get_cell_list_contents([self.pos])\n",
     "        if len(cellmates) > 1:\n",
     "            other = random.choice(cellmates)\n",
     "            other.wealth += 1\n",
@@ -510,10 +510,10 @@
     "```python\n",
     "class MoneyAgent(Agent):\n",
     "    # ...\n",
-    "    def step(self, model):\n",
-    "        self.move(model)\n",
+    "    def step(self):\n",
+    "        self.move()\n",
     "        if self.wealth > 0:\n",
-    "            self.give_money(model)\n",
+    "            self.give_money()\n",
     "```\n",
     "\n",
     "Now, putting that all together should look like this:"
@@ -535,7 +535,7 @@
     "        self.schedule = RandomActivation(self)\n",
     "        # Create agents\n",
     "        for i in range(self.num_agents):\n",
-    "            a = MoneyAgent(i)\n",
+    "            a = MoneyAgent(i, self)\n",
     "            self.schedule.add(a)\n",
     "            # Add the agent to a random grid cell\n",
     "            x = random.randrange(self.grid.width)\n",
@@ -547,29 +547,29 @@
     "\n",
     "class MoneyAgent(Agent):\n",
     "    \"\"\" An agent with fixed initial wealth.\"\"\"\n",
-    "    def __init__(self, unique_id):\n",
-    "        self.unique_id = unique_id\n",
+    "    def __init__(self, unique_id, model):\n",
+    "        super().__init__(unique_id, model)\n",
     "        self.wealth = 1\n",
     "\n",
-    "    def move(self, model):\n",
-    "        possible_steps = model.grid.get_neighborhood(\n",
+    "    def move(self):\n",
+    "        possible_steps = self.model.grid.get_neighborhood(\n",
     "            self.pos, \n",
     "            moore=True, \n",
     "            include_center=False)\n",
     "        new_position = random.choice(possible_steps)\n",
-    "        model.grid.move_agent(self, new_position)\n",
+    "        self.model.grid.move_agent(self, new_position)\n",
     "\n",
-    "    def give_money(self, model):\n",
-    "        cellmates = model.grid.get_cell_list_contents([self.pos])\n",
+    "    def give_money(self):\n",
+    "        cellmates = self.model.grid.get_cell_list_contents([self.pos])\n",
     "        if len(cellmates) > 1:\n",
     "            other = random.choice(cellmates)\n",
     "            other.wealth += 1\n",
     "            self.wealth -= 1\n",
     "\n",
-    "    def step(self, model):\n",
-    "        self.move(model)\n",
+    "    def step(self):\n",
+    "        self.move()\n",
     "        if self.wealth > 0:\n",
-    "            self.give_money(model)"
+    "            self.give_money()"
    ]
   },
   {
@@ -676,29 +676,29 @@
     "\n",
     "class MoneyAgent(Agent):\n",
     "    \"\"\" An agent with fixed initial wealth.\"\"\"\n",
-    "    def __init__(self, unique_id):\n",
-    "        self.unique_id = unique_id\n",
+    "    def __init__(self, unique_id, model):\n",
+    "        super().__init__(unique_id, model)\n",
     "        self.wealth = 1\n",
     "\n",
-    "    def move(self, model):\n",
-    "        possible_steps = model.grid.get_neighborhood(\n",
+    "    def move(self):\n",
+    "        possible_steps = self.model.grid.get_neighborhood(\n",
     "            self.pos, \n",
     "            moore=True, \n",
     "            include_center=False)\n",
     "        new_position = random.choice(possible_steps)\n",
-    "        model.grid.move_agent(self, new_position)\n",
+    "        self.model.grid.move_agent(self, new_position)\n",
     "\n",
-    "    def give_money(self, model):\n",
-    "        cellmates = model.grid.get_cell_list_contents([self.pos])\n",
+    "    def give_money(self):\n",
+    "        cellmates = self.model.grid.get_cell_list_contents([self.pos])\n",
     "        if len(cellmates) > 1:\n",
     "            other = random.choice(cellmates)\n",
     "            other.wealth += 1\n",
     "            self.wealth -= 1\n",
     "\n",
-    "    def step(self, model):\n",
-    "        self.move(model)\n",
+    "    def step(self):\n",
+    "        self.move()\n",
     "        if self.wealth > 0:\n",
-    "            self.give_money(model)\n",
+    "            self.give_money()\n",
     "\n",
     "class MoneyModel(Model):\n",
     "    \"\"\"A model with some number of agents.\"\"\"\n",
@@ -709,7 +709,7 @@
     "        \n",
     "        # Create agents\n",
     "        for i in range(self.num_agents):\n",
-    "            a = MoneyAgent(i)\n",
+    "            a = MoneyAgent(i, self)\n",
     "            self.schedule.add(a)\n",
     "            # Add the agent to a random grid cell\n",
     "            x = random.randrange(self.grid.width)\n",
@@ -989,7 +989,7 @@
     "        \n",
     "        # Create agents\n",
     "        for i in range(self.num_agents):\n",
-    "            a = MoneyAgent(i)\n",
+    "            a = MoneyAgent(i, self)\n",
     "            self.schedule.add(a)\n",
     "            # Add the agent to a random grid cell\n",
     "            x = random.randrange(self.grid.width)\n",

docs/tutorials/intro_tutorial.rst

@@ -116,8 +116,8 @@ The beginning of both classes looks like this:
     
     class MoneyAgent(Agent):
         """An agent with fixed initial wealth."""
-        def __init__(self, unique_id):
-            self.unique_id = unique_id
+        def __init__(self, unique_id, model):
+            super().__init__(unique_id, model)
             self.wealth = 1
     
     class MoneyModel(Model):
@@ -126,7 +126,7 @@ The beginning of both classes looks like this:
             self.num_agents = N
             # Create agents
             for i in range(self.num_agents):
-                a = MoneyAgent(i)
+                a = MoneyAgent(i, self)
 
 Adding the scheduler
 ~~~~~~~~~~~~~~~~~~~~
@@ -164,11 +164,11 @@ this:
     
     class MoneyAgent(Agent):
         """ An agent with fixed initial wealth."""
-        def __init__(self, unique_id):
-            self.unique_id = unique_id
+        def __init__(self, unique_id, model):
+            super().__init__(unique_id, model)
             self.wealth = 1
     
-        def step(self, model):
+        def step(self):
             # The agent's step will go here.
             pass
     
@@ -179,7 +179,7 @@ this:
             self.schedule = RandomActivation(self)
             # Create agents
             for i in range(self.num_agents):
-                a = MoneyAgent(i)
+                a = MoneyAgent(i, self)
                 self.schedule.add(a)
     
         def step(self):
@@ -234,14 +234,14 @@ With that in mind, we rewrite the agent's ``step`` method, like this:
 
     class MoneyAgent(Agent):
         """ An agent with fixed initial wealth."""
-        def __init__(self, unique_id):
-            self.unique_id = unique_id
+        def __init__(self, unique_id, model):
+            super().__init__(unique_id, model)
             self.wealth = 1
     
-        def step(self, model):
+        def step(self):
             if self.wealth == 0:
                 return
-            other_agent = random.choice(model.schedule.agents)
+            other_agent = random.choice(self.model.schedule.agents)
             other_agent.wealth += 1
             self.wealth -= 1
 
@@ -404,7 +404,7 @@ coordinates to place the agent.
             
             # Create agents
             for i in range(self.num_agents):
-                a = MoneyAgent(i)
+                a = MoneyAgent(i, self)
                 self.schedule.add(a)
                 
                 # Add the agent to a random grid cell
@@ -448,13 +448,13 @@ With that in mind, the agent's ``move`` method looks like this:
 
     class MoneyAgent(Agent):
        #...
-        def move(self, model):
-            possible_steps = model.grid.get_neighborhood(
+        def move(self):
+            possible_steps = self.model.grid.get_neighborhood(
                 self.pos, 
                 moore=True,
                 include_center=False)
             new_position = random.choice(possible_steps)
-            model.grid.move_agent(self, new_position)
+            self.model.grid.move_agent(self, new_position)
 
 Next, we need to get all the other agents present in a cell, and give
 one of them some money. We can get the contents of one or more cells
@@ -466,8 +466,8 @@ single tuple if we only care about one cell.
 
     class MoneyAgent(Agent):
         #...
-        def give_money(self, model):
-            cellmates = model.grid.get_cell_list_contents([self.pos])
+        def give_money(self):
+            cellmates = self.model.grid.get_cell_list_contents([self.pos])
             if len(cellmates) > 1:
                 other = random.choice(cellmates)
                 other.wealth += 1
@@ -479,10 +479,10 @@ And with those two methods, the agent's ``step`` method becomes:
 
     class MoneyAgent(Agent):
         # ...
-        def step(self, model):
-            self.move(model)
+        def step(self):
+            self.move()
             if self.wealth > 0:
-                self.give_money(model)
+                self.give_money()
 
 Now, putting that all together should look like this:
 
@@ -496,7 +496,7 @@ Now, putting that all together should look like this:
             self.schedule = RandomActivation(self)
             # Create agents
             for i in range(self.num_agents):
-                a = MoneyAgent(i)
+                a = MoneyAgent(i, self)
                 self.schedule.add(a)
                 # Add the agent to a random grid cell
                 x = random.randrange(self.grid.width)
@@ -508,29 +508,29 @@ Now, putting that all together should look like this:
     
     class MoneyAgent(Agent):
         """ An agent with fixed initial wealth."""
-        def __init__(self, unique_id):
-            self.unique_id = unique_id
+        def __init__(self, unique_id, model):
+            super().__init__(unique_id, model)
             self.wealth = 1
     
-        def move(self, model):
-            possible_steps = model.grid.get_neighborhood(
+        def move(self):
+            possible_steps = self.model.grid.get_neighborhood(
                 self.pos, 
                 moore=True, 
                 include_center=False)
             new_position = random.choice(possible_steps)
-            model.grid.move_agent(self, new_position)
+            self.model.grid.move_agent(self, new_position)
     
-        def give_money(self, model):
-            cellmates = model.grid.get_cell_list_contents([self.pos])
+        def give_money(self):
+            cellmates = self.model.grid.get_cell_list_contents([self.pos])
             if len(cellmates) > 1:
                 other = random.choice(cellmates)
                 other.wealth += 1
                 self.wealth -= 1
     
-        def step(self, model):
-            self.move(model)
+        def step(self):
+            self.move()
             if self.wealth > 0:
-                self.give_money(model)
+                self.give_money()
 
 Let's create a model with 50 agents on a 10x10 grid, and run it for 20
 steps.
@@ -622,29 +622,29 @@ measure of wealth inequality.
     
     class MoneyAgent(Agent):
         """ An agent with fixed initial wealth."""
-        def __init__(self, unique_id):
-            self.unique_id = unique_id
+        def __init__(self, unique_id, model):
+            super().__init__(unique_id, model)
             self.wealth = 1
     
-        def move(self, model):
-            possible_steps = model.grid.get_neighborhood(
+        def move(self):
+            possible_steps = self.model.grid.get_neighborhood(
                 self.pos, 
                 moore=True, 
                 include_center=False)
             new_position = random.choice(possible_steps)
-            model.grid.move_agent(self, new_position)
+            self.model.grid.move_agent(self, new_position)
     
-        def give_money(self, model):
-            cellmates = model.grid.get_cell_list_contents([self.pos])
+        def give_money(self):
+            cellmates = self.model.grid.get_cell_list_contents([self.pos])
             if len(cellmates) > 1:
                 other = random.choice(cellmates)
                 other.wealth += 1
                 self.wealth -= 1
     
-        def step(self, model):
-            self.move(model)
+        def step(self):
+            self.move()
             if self.wealth > 0:
-                self.give_money(model)
+                self.give_money()
     
     class MoneyModel(Model):
         """A model with some number of agents."""
@@ -655,7 +655,7 @@ measure of wealth inequality.
             
             # Create agents
             for i in range(self.num_agents):
-                a = MoneyAgent(i)
+                a = MoneyAgent(i, self)
                 self.schedule.add(a)
                 # Add the agent to a random grid cell
                 x = random.randrange(self.grid.width)
@@ -832,7 +832,7 @@ indefinitely.
             
             # Create agents
             for i in range(self.num_agents):
-                a = MoneyAgent(i)
+                a = MoneyAgent(i, self)
                 self.schedule.add(a)
                 # Add the agent to a random grid cell
                 x = random.randrange(self.grid.width)

examples/Basic/basic/model.py

@@ -6,8 +6,8 @@
 
 
 class Walker(Agent):
-    def __init__(self, unique_id, pos, heading=(1, 0)):
-        self.unique_id = unique_id
+    def __init__(self, unique_id, model, pos, heading=(1, 0)):
+        super().__init__(unique_id, model)
         self.pos = pos
         self.heading = heading
         self.headings = {(1, 0), (0, 1), (-1, 0), (0, -1)}
@@ -35,7 +35,7 @@ def make_walker_agents(self):
             if self.grid.is_cell_empty(pos):
                 print("Creating agent {2} at ({0}, {1})"
                       .format(x, y, unique_id))
-                a = Walker(unique_id, pos, heading)
+                a = Walker(unique_id, self, pos, heading)
                 self.schedule.add(a)
                 self.grid.place_agent(a, pos)
                 unique_id += 1

examples/Boltzmann_Wealth_Model/MoneyModel.py

@@ -28,7 +28,7 @@ def __init__(self, N, width, height):
         )
         # Create agents
         for i in range(self.num_agents):
-            a = MoneyAgent(i)
+            a = MoneyAgent(i, self)
             self.schedule.add(a)
             # Add the agent to a random grid cell
             x = random.randrange(self.grid.width)
@@ -46,26 +46,25 @@ def run_model(self, n):
 
 class MoneyAgent(Agent):
     """ An agent with fixed initial wealth."""
-
-    def __init__(self, unique_id):
-        self.unique_id = unique_id
+    def __init__(self, unique_id, model):
+        super().__init__(unique_id, model)
         self.wealth = 1
 
-    def move(self, model):
-        possible_steps = model.grid.get_neighborhood(
+    def move(self):
+        possible_steps = self.model.grid.get_neighborhood(
             self.pos, moore=True, include_center=False
         )
         new_position = random.choice(possible_steps)
-        model.grid.move_agent(self, new_position)
+        self.model.grid.move_agent(self, new_position)
 
-    def give_money(self, model):
-        cellmates = model.grid.get_cell_list_contents([self.pos])
+    def give_money(self):
+        cellmates = self.model.grid.get_cell_list_contents([self.pos])
         if len(cellmates) > 1:
             other = random.choice(cellmates)
             other.wealth += 1
             self.wealth -= 1
 
-    def step(self, model):
-        self.move(model)
+    def step(self):
+        self.move()
         if self.wealth > 0:
-            self.give_money(model)
+            self.give_money()

examples/ColorPatches/color_patches/model.py

@@ -22,7 +22,7 @@ def __init__(self, pos, model, initial_state):
         '''
         Create a cell, in the given state, at the given row, col position.
         '''
-        Agent.__init__(self, pos, model)
+        super().__init__(pos, model)
         self._row = pos[0]
         self._col = pos[1]
         self._state = initial_state
@@ -40,14 +40,14 @@ def get_state(self):
         '''Return the current state (OPINION) of this cell.'''
         return self._state
 
-    def step(self, model):
+    def step(self):
         '''
         Determines the agent opinion for the next step by polling its neighbors
         The opinion is determined by the majority of the 8 neighbors' opinion
         A choice is made at random in case of a tie
         The next state is stored until all cells have been polled
         '''
-        neighbor_iter_ = model.grid.neighbor_iter((self._row, self._col), True)
+        neighbor_iter_ = self.model.grid.neighbor_iter((self._row, self._col), True)
         neighbors_opinion = Counter(n.get_state() for n in neighbor_iter_)
         # Following is a a tuple (attribute, occurrences)
         polled_opinions = neighbors_opinion.most_common()
@@ -58,8 +58,7 @@ def step(self, model):
 
         self._next_state = random.choice(tied_opinions)[0]
 
-    # model argument is unused
-    def advance(self, model):
+    def advance(self):
         '''
         Set the state of the agent to the next state
         '''

examples/ConwaysGameOfLife/game_of_life/cell.py

@@ -11,7 +11,7 @@ def __init__(self, pos, model, init_state=DEAD):
         '''
         Create a cell, in the given state, at the given x, y position.
         '''
-        Agent.__init__(self, pos, model)
+        super().__init__(pos, model)
         self.x, self.y = pos
         self.state = init_state
         self._nextState = None
@@ -24,7 +24,7 @@ def isAlive(self):
     def neighbors(self):
         return self.model.grid.neighbor_iter((self.x, self.y), True)
 
-    def step(self, model):
+    def step(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
@@ -46,7 +46,7 @@ def step(self, model):
             if live_neighbors == 3:
                 self._nextState = self.ALIVE
 
-    def advance(self, model):
+    def advance(self):
         '''
         Set the state to the new computed state -- computed in step().
         '''

examples/EpsteinCivilViolence/civil_violence/agent.py

@@ -30,8 +30,8 @@ class Citizen(Agent):
 
     """
 
-    def __init__(self, unique_id, pos, hardship, regime_legitimacy,
-                 risk_aversion, threshold, vision, model):
+    def __init__(self, unique_id, model, pos, hardship, regime_legitimacy,
+                 risk_aversion, threshold, vision):
         """
         Create a new Citizen.
         Args:
@@ -61,37 +61,37 @@ def __init__(self, unique_id, pos, hardship, regime_legitimacy,
         self.grievance = self.hardship * (1 - self.regime_legitimacy)
         self.arrest_probability = None
 
-    def step(self, model):
+    def step(self):
         """
         Decide whether to activate, then move if applicable.
         """
         if self.jail_sentence:
             self.jail_sentence -= 1
             return  # no other changes or movements if agent is in jail.
-        self.update_neighbors(model)
-        self.update_estimated_arrest_probability(model)
+        self.update_neighbors()
+        self.update_estimated_arrest_probability()
         net_risk = self.risk_aversion * self.arrest_probability
         if self.condition == 'Quiescent' and (
                 self.grievance - net_risk) > self.threshold:
             self.condition = 'Active'
         elif self.condition == 'Active' and (
                 self.grievance - net_risk) <= self.threshold:
             self.condition = 'Quiescent'
-        if model.movement and self.empty_neighbors:
+        if self.model.movement and self.empty_neighbors:
             new_pos = random.choice(self.empty_neighbors)
-            model.grid.move_agent(self, new_pos)
+            self.model.grid.move_agent(self, new_pos)
 
-    def update_neighbors(self, model):
+    def update_neighbors(self):
         """
         Look around and see who my neighbors are
         """
-        self.neighborhood = model.grid.get_neighborhood(self.pos,
+        self.neighborhood = self.model.grid.get_neighborhood(self.pos,
                                                         moore=False, radius=1)
-        self.neighbors = model.grid.get_cell_list_contents(self.neighborhood)
+        self.neighbors = self.model.grid.get_cell_list_contents(self.neighborhood)
         self.empty_neighbors = [c for c in self.neighborhood if
-                                model.grid.is_cell_empty(c)]
+                                self.model.grid.is_cell_empty(c)]
 
-    def update_estimated_arrest_probability(self, model):
+    def update_estimated_arrest_probability(self):
         """
         Based on the ratio of cops to actives in my neighborhood, estimate the
         p(Arrest | I go active).
@@ -105,7 +105,7 @@ def update_estimated_arrest_probability(self, model):
                     c.jail_sentence == 0):
                 actives_in_vision += 1
         self.arrest_probability = 1 - math.exp(
-            -1 * model.arrest_prob_constant * (
+            -1 * self.model.arrest_prob_constant * (
                 cops_in_vision / actives_in_vision))
 
 
@@ -121,7 +121,7 @@ class Cop(Agent):
             able to inspect
     """
 
-    def __init__(self, unique_id, pos, vision, model):
+    def __init__(self, unique_id, model, pos, vision):
         """
         Create a new Cop.
         Args:
@@ -136,12 +136,12 @@ def __init__(self, unique_id, pos, vision, model):
         self.pos = pos
         self.vision = vision
 
-    def step(self, model):
+    def step(self):
         """
         Inspect local vision and arrest a random active agent. Move if
         applicable.
         """
-        self.update_neighbors(model)
+        self.update_neighbors()
         active_neighbors = []
         for agent in self.neighbors:
             if agent.breed == 'citizen' and \
@@ -150,18 +150,18 @@ def step(self, model):
                 active_neighbors.append(agent)
         if active_neighbors:
             arrestee = random.choice(active_neighbors)
-            sentence = random.randint(0, model.max_jail_term)
+            sentence = random.randint(0, self.model.max_jail_term)
             arrestee.jail_sentence = sentence
-        if model.movement and self.empty_neighbors:
+        if self.model.movement and self.empty_neighbors:
             new_pos = random.choice(self.empty_neighbors)
-            model.grid.move_agent(self, new_pos)
+            self.model.grid.move_agent(self, new_pos)
 
-    def update_neighbors(self, model):
+    def update_neighbors(self):
         """
         Look around and see who my neighbors are.
         """
-        self.neighborhood = model.grid.get_neighborhood(self.pos,
+        self.neighborhood = self.model.grid.get_neighborhood(self.pos,
                                                         moore=False, radius=1)
-        self.neighbors = model.grid.get_cell_list_contents(self.neighborhood)
+        self.neighbors = self.model.grid.get_cell_list_contents(self.neighborhood)
         self.empty_neighbors = [c for c in self.neighborhood if
-                                model.grid.is_cell_empty(c)]
+                                self.model.grid.is_cell_empty(c)]

examples/EpsteinCivilViolence/civil_violence/model.py

@@ -77,19 +77,18 @@ def __init__(self, height, width, citizen_density, cop_density,
                 'Cop density + citizen density must be less than 1')
         for (contents, x, y) in self.grid.coord_iter():
             if random.random() < self.cop_density:
-                cop = Cop(unique_id, (x, y), vision=self.cop_vision,
-                          model=self)
+                cop = Cop(unique_id, self, (x, y), vision=self.cop_vision)
                 unique_id += 1
                 self.grid[y][x] = cop
                 self.schedule.add(cop)
             elif random.random() < (
                     self.cop_density + self.citizen_density):
-                citizen = Citizen(unique_id, (x, y),
+                citizen = Citizen(unique_id, self, (x, y),
                                   hardship=random.random(),
                                   regime_legitimacy=self.legitimacy,
                                   risk_aversion=random.random(),
                                   threshold=self.active_threshold,
-                                  vision=self.citizen_vision, model=self)
+                                  vision=self.citizen_vision)
                 unique_id += 1
                 self.grid[y][x] = citizen
                 self.schedule.add(citizen)

examples/Flockers/flockers/boid.py

@@ -17,7 +17,7 @@ class Boid(Agent):
     define their movement. Separation is their desired minimum distance from
     any other Boid.
     '''
-    def __init__(self, unique_id, pos, speed=5, heading=None,
+    def __init__(self, unique_id, model, pos, speed=5, heading=None,
                  vision=5, separation=1):
         '''
         Create a new Boid flocker agent.
@@ -30,7 +30,7 @@ def __init__(self, unique_id, pos, speed=5, heading=None,
             vision: Radius to look around for nearby Boids.
             separation: Minimum distance to maintain from other Boids.
         '''
-        self.unique_id = unique_id
+        super().__init__(unique_id, model)
         self.pos = pos
         self.speed = speed
         if heading is not None:
@@ -72,12 +72,12 @@ def match_heading(self, neighbors):
             mean_heading += np.int64(neighbor.heading)
         return mean_heading / len(neighbors)
 
-    def step(self, model):
+    def step(self):
         '''
         Get the Boid's neighbors, compute the new vector, and move accordingly.
         '''
 
-        neighbors = model.space.get_neighbors(self.pos, self.vision, False)
+        neighbors = self.model.space.get_neighbors(self.pos, self.vision, False)
         if len(neighbors) > 0:
             cohere_vector = self.cohere(neighbors)
             separate_vector = self.separate(neighbors)
@@ -88,4 +88,4 @@ def step(self, model):
             self.heading /= np.linalg.norm(self.heading)
         new_pos = np.array(self.pos) + self.heading * self.speed
         new_x, new_y = new_pos
-        model.space.move_agent(self, (new_x, new_y))
+        self.model.space.move_agent(self, (new_x, new_y))

examples/Flockers/flockers/model.py

@@ -53,8 +53,8 @@ def make_agents(self):
             pos = (x, y)
             heading = np.random.random(2) * 2 - np.array((1, 1))
             heading /= np.linalg.norm(heading)
-            boid = Boid(i, pos, self.speed, heading,
-                        self.vision, self.separation)
+            boid = Boid(i, self, pos, self.speed, heading, self.vision,
+                        self.separation)
             self.space.place_agent(boid, pos)
             self.schedule.add(boid)
 

examples/ForestFire/forest_fire/agent.py

@@ -13,22 +13,23 @@ class TreeCell(Agent):
     unique_id isn't strictly necessary here, but it's good
     practice to give one to each agent anyway.
     """
-    def __init__(self, pos):
+    def __init__(self, pos, model):
         """
         Create a new tree.
         Args:
             pos: The tree's coordinates on the grid.
+            model: standard model reference for agent.
         """
+        super().__init__(pos, model)
         self.pos = pos
-        self.unique_id = pos
         self.condition = "Fine"
 
-    def step(self, model):
+    def step(self):
         """
         If the tree is on fire, spread it to fine trees nearby.
         """
         if self.condition == "On Fire":
-            for neighbor in model.grid.neighbor_iter(self.pos):
+            for neighbor in self.model.grid.neighbor_iter(self.pos):
                 if neighbor.condition == "Fine":
                     neighbor.condition = "On Fire"
             self.condition = "Burned Out"

examples/ForestFire/forest_fire/model.py

@@ -38,7 +38,7 @@ def __init__(self, height, width, density):
         for (contents, x, y) in self.grid.coord_iter():
             if random.random() < self.density:
                 # Create a tree
-                new_tree = TreeCell((x, y))
+                new_tree = TreeCell((x, y), self)
                 # Set all trees in the first column on fire.
                 if x == 0:
                     new_tree.condition = "On Fire"

examples/PD_Grid/pd_grid.py

@@ -17,7 +17,7 @@
 
 class PD_Agent(Agent):
 
-    def __init__(self, pos, starting_move=None):
+    def __init__(self, pos, model, starting_move=None):
         '''
         Create a new Prisoner's Dilemma agent.
 
@@ -26,6 +26,7 @@ def __init__(self, pos, starting_move=None):
             starting_move: If provided, determines the agent's initial state:
                            C(ooperating) or D(efecting). Otherwise, random.
         '''
+        super().__init__(pos, model)
         self.pos = pos
         self.score = 0
         if starting_move:
@@ -34,29 +35,29 @@ def __init__(self, pos, starting_move=None):
             self.move = random.choice(["C", "D"])
         self.next_move = None
 
-    def step(self, model):
+    def step(self):
         '''
         Get the neighbors' moves, and change own move accordingly.
         '''
-        neighbors = model.grid.get_neighbors(self.pos, True,
-                                             include_center=True)
+        neighbors = self.model.grid.get_neighbors(self.pos, True,
+                                                  include_center=True)
         best_neighbor = max(neighbors, key=lambda a: a.score)
         self.next_move = best_neighbor.move
 
-        if model.schedule_type != "Simultaneous":
-            self.advance(model)
+        if self.model.schedule_type != "Simultaneous":
+            self.advance()
 
-    def advance(self, model):
+    def advance(self):
         self.move = self.next_move
-        self.score += self.increment_score(model)
+        self.score += self.increment_score()
 
-    def increment_score(self, model):
-        neighbors = model.grid.get_neighbors(self.pos, True)
-        if model.schedule_type == "Simultaneous":
+    def increment_score(self):
+        neighbors = self.model.grid.get_neighbors(self.pos, True)
+        if self.model.schedule_type == "Simultaneous":
             moves = [neighbor.next_move for neighbor in neighbors]
         else:
             moves = [neighbor.move for neighbor in neighbors]
-        return sum(model.payoff[(self.move, move)] for move in moves)
+        return sum(self.model.payoff[(self.move, move)] for move in moves)
 
 
 class PD_Model(Model):
@@ -94,7 +95,7 @@ def __init__(self, height, width, schedule_type, payoffs=None):
         # Create agents
         for x in range(width):
             for y in range(height):
-                agent = PD_Agent((x, y))
+                agent = PD_Agent((x, y), self)
                 self.grid.place_agent(agent, (x, y))
                 self.schedule.add(agent)
 

examples/Schelling/model.py

@@ -10,7 +10,7 @@ class SchellingAgent(Agent):
     '''
     Schelling segregation agent
     '''
-    def __init__(self, pos, agent_type):
+    def __init__(self, pos, model, agent_type):
         '''
          Create a new Schelling agent.
 
@@ -19,21 +19,21 @@ def __init__(self, pos, agent_type):
             x, y: Agent initial location.
             agent_type: Indicator for the agent's type (minority=1, majority=0)
         '''
-        self.unique_id = pos
+        super().__init__(pos, model)
         self.pos = pos
         self.type = agent_type
 
-    def step(self, model):
+    def step(self):
         similar = 0
-        for neighbor in model.grid.neighbor_iter(self.pos):
+        for neighbor in self.model.grid.neighbor_iter(self.pos):
             if neighbor.type == self.type:
                 similar += 1
 
         # If unhappy, move:
-        if similar < model.homophily:
-            model.grid.move_to_empty(self)
+        if similar < self.model.homophily:
+            self.model.grid.move_to_empty(self)
         else:
-            model.happy += 1
+            self.model.happy += 1
 
 
 class SchellingModel(Model):
@@ -75,7 +75,7 @@ def __init__(self, height, width, density, minority_pc, homophily):
                 else:
                     agent_type = 0
 
-                agent = SchellingAgent((x, y), agent_type)
+                agent = SchellingAgent((x, y), self, agent_type)
                 self.grid.position_agent(agent, (x, y))
                 self.schedule.add(agent)
 

examples/WolfSheep/wolf_sheep/agents.py

@@ -14,42 +14,42 @@ class Sheep(RandomWalker):
 
     energy = None
 
-    def __init__(self, grid, pos, moore, energy=None):
-        super().__init__(grid, pos, moore)
+    def __init__(self, pos, model, moore, energy=None):
+        super().__init__(pos, model, moore=moore)
         self.energy = energy
 
-    def step(self, model):
+    def step(self):
         '''
         A model step. Move, then eat grass and reproduce.
         '''
         self.random_move()
         living = True
 
-        if model.grass:
+        if self.model.grass:
             # Reduce energy
             self.energy -= 1
 
             # If there is grass available, eat it
-            this_cell = model.grid.get_cell_list_contents([self.pos])
+            this_cell = self.model.grid.get_cell_list_contents([self.pos])
             grass_patch = [obj for obj in this_cell
                            if isinstance(obj, GrassPatch)][0]
             if grass_patch.fully_grown:
-                self.energy += model.sheep_gain_from_food
+                self.energy += self.model.sheep_gain_from_food
                 grass_patch.fully_grown = False
 
             # Death
             if self.energy < 0:
-                model.grid._remove_agent(self.pos, self)
-                model.schedule.remove(self)
+                self.model.grid._remove_agent(self.pos, self)
+                self.model.schedule.remove(self)
                 living = False
 
-        if living and random.random() < model.sheep_reproduce:
+        if living and random.random() < self.model.sheep_reproduce:
             # Create a new sheep:
-            if model.grass:
+            if self.model.grass:
                 self.energy /= 2
-            lamb = Sheep(self.grid, self.pos, self.moore, self.energy)
-            model.grid.place_agent(lamb, self.pos)
-            model.schedule.add(lamb)
+            lamb = Sheep(self.pos, self.model, self.moore, self.energy)
+            self.model.grid.place_agent(lamb, self.pos)
+            self.model.schedule.add(lamb)
 
 
 class Wolf(RandomWalker):
@@ -59,60 +59,61 @@ class Wolf(RandomWalker):
 
     energy = None
 
-    def __init__(self, grid, pos, moore, energy):
-        super().__init__(grid, pos, moore)
+    def __init__(self, pos, model, moore, energy=None):
+        super().__init__(pos, model, moore=moore)
         self.energy = energy
 
-    def step(self, model):
+    def step(self):
         self.random_move()
         self.energy -= 1
 
         # If there are sheep present, eat one
         x, y = self.pos
-        this_cell = model.grid.get_cell_list_contents([self.pos])
+        this_cell = self.model.grid.get_cell_list_contents([self.pos])
         sheep = [obj for obj in this_cell if isinstance(obj, Sheep)]
         if len(sheep) > 0:
             sheep_to_eat = random.choice(sheep)
-            self.energy += model.wolf_gain_from_food
+            self.energy += self.model.wolf_gain_from_food
 
             # Kill the sheep
-            model.grid._remove_agent(self.pos, sheep_to_eat)
-            model.schedule.remove(sheep_to_eat)
+            self.model.grid._remove_agent(self.pos, sheep_to_eat)
+            self.model.schedule.remove(sheep_to_eat)
 
         # Death or reproduction
         if self.energy < 0:
-            model.grid._remove_agent(self.pos, self)
-            model.schedule.remove(self)
+            self.model.grid._remove_agent(self.pos, self)
+            self.model.schedule.remove(self)
         else:
-            if random.random() < model.wolf_reproduce:
+            if random.random() < self.model.wolf_reproduce:
                 # Create a new wolf cub
                 self.energy /= 2
-                cub = Wolf(self.grid, self.pos, self.moore, self.energy)
-                model.grid.place_agent(cub, cub.pos)
-                model.schedule.add(cub)
+                cub = Wolf(self.pos, self.model, self.moore, self.energy)
+                self.model.grid.place_agent(cub, cub.pos)
+                self.model.schedule.add(cub)
 
 
 class GrassPatch(Agent):
     '''
     A patch of grass that grows at a fixed rate and it is eaten by sheep
     '''
 
-    def __init__(self, fully_grown, countdown):
+    def __init__(self, pos, model, fully_grown, countdown):
         '''
         Creates a new patch of grass
 
         Args:
             grown: (boolean) Whether the patch of grass is fully grown or not
             countdown: Time for the patch of grass to be fully grown again
         '''
+        super().__init__(pos, model)
         self.fully_grown = fully_grown
         self.countdown = countdown
 
-    def step(self, model):
+    def step(self):
         if not self.fully_grown:
             if self.countdown <= 0:
                 # Set as fully grown
                 self.fully_grown = True
-                self.countdown = model.grass_regrowth_time
+                self.countdown = self.model.grass_regrowth_time
             else:
                 self.countdown -= 1

examples/WolfSheep/wolf_sheep/model.py

@@ -84,7 +84,7 @@ def __init__(self, height=20, width=20,
             x = random.randrange(self.width)
             y = random.randrange(self.height)
             energy = random.randrange(2 * self.sheep_gain_from_food)
-            sheep = Sheep(self.grid, (x, y), True, energy)
+            sheep = Sheep((x, y), self, True, energy)
             self.grid.place_agent(sheep, (x, y))
             self.schedule.add(sheep)
 
@@ -93,7 +93,7 @@ def __init__(self, height=20, width=20,
             x = random.randrange(self.width)
             y = random.randrange(self.height)
             energy = random.randrange(2 * self.wolf_gain_from_food)
-            wolf = Wolf(self.grid, (x, y), True, energy)
+            wolf = Wolf((x, y), self, True, energy)
             self.grid.place_agent(wolf, (x, y))
             self.schedule.add(wolf)
 
@@ -108,7 +108,7 @@ def __init__(self, height=20, width=20,
                 else:
                     countdown = random.randrange(self.grass_regrowth_time)
 
-                patch = GrassPatch(fully_grown, countdown)
+                patch = GrassPatch((x, y), self, fully_grown, countdown)
                 self.grid.place_agent(patch, (x, y))
                 self.schedule.add(patch)
 

examples/WolfSheep/wolf_sheep/random_walk.py

@@ -21,15 +21,15 @@ class RandomWalker(Agent):
     y = None
     moore = True
 
-    def __init__(self, grid, pos, moore=True):
+    def __init__(self, pos, model, moore=True):
         '''
         grid: The MultiGrid object in which the agent lives.
         x: The agent's current x coordinate
         y: The agent's current y coordinate
         moore: If True, may move in all 8 directions.
                 Otherwise, only up, down, left, right.
         '''
-        self.grid = grid
+        super().__init__(pos, model)
         self.pos = pos
         self.moore = moore
 
@@ -38,7 +38,7 @@ def random_move(self):
         Step one cell in any allowable direction.
         '''
         # Pick the next cell from the adjacent cells.
-        next_moves = self.grid.get_neighborhood(self.pos, self.moore, True)
+        next_moves = self.model.grid.get_neighborhood(self.pos, self.moore, True)
         next_move = random.choice(next_moves)
         # Now move:
-        self.grid.move_agent(self, next_move)
+        self.model.grid.move_agent(self, next_move)

examples/WolfSheep/wolf_sheep/schedule.py

@@ -12,7 +12,7 @@ class RandomActivationByBreed(RandomActivation):
     This is equivalent to the NetLogo 'ask breed...' and is generally the
     default behavior for an ABM.
 
-    Assumes that all agents have a step(model) method.
+    Assumes that all agents have a step() method.
     '''
     agents_by_breed = defaultdict(list)
 
@@ -70,7 +70,7 @@ def step_breed(self, breed):
         agents = self.agents_by_breed[breed]
         random.shuffle(agents)
         for agent in agents:
-            agent.step(self.model)
+            agent.step()
 
     def get_breed_count(self, breed_class):
         '''

examples/WolfSheep/wolf_sheep/test_random_walk.py

@@ -18,7 +18,7 @@ class WalkerAgent(RandomWalker):
     Agent which only walks around.
     '''
 
-    def step(self, model):
+    def step(self):
         self.random_move()
 
 
@@ -47,7 +47,7 @@ def __init__(self, height, width, agent_count):
         for i in range(self.agent_count):
             x = random.randrange(self.width)
             y = random.randrange(self.height)
-            a = WalkerAgent(self.grid, (x, y), True)
+            a = WalkerAgent((x, y), self, True)
             self.schedule.add(a)
             self.grid.place_agent(a, (x, y))
 

mesa/agent.py

@@ -14,6 +14,6 @@ def __init__(self, unique_id, model):
         self.unique_id = unique_id
         self.model = model
 
-    def step(self, model):
+    def step(self):
         """ A single step of the agent. """
         pass

mesa/time.py

@@ -33,8 +33,7 @@ class BaseScheduler:
     """ Simplest scheduler; activates agents one at a time, in the order
     they were added.
 
-    Assumes that each agent added has a *step* method, which accepts a model
-    object as its single argument.
+    Assumes that each agent added has a *step* method which takes no arguments.
 
     (This is explicitly meant to replicate the scheduler in MASON).
 
@@ -56,7 +55,7 @@ def add(self, agent):
 
         Args:
             agent: An Agent to be added to the schedule. NOTE: The agent must
-            have a step(model) method.
+            have a step() method.
 
         """
         self.agents.append(agent)
@@ -74,7 +73,7 @@ def remove(self, agent):
     def step(self):
         """ Execute the step of all the agents, one at a time. """
         for agent in self.agents:
-            agent.step(self.model)
+            agent.step()
         self.steps += 1
         self.time += 1
 
@@ -99,9 +98,8 @@ def step(self):
 
         """
         random.shuffle(self.agents)
-
         for agent in self.agents:
-            agent.step(self.model)
+            agent.step()
         self.steps += 1
         self.time += 1
 
@@ -110,16 +108,16 @@ class SimultaneousActivation(BaseScheduler):
     """ A scheduler to simulate the simultaneous activation of all the agents.
 
     This scheduler requires that each agent have two methods: step and advance.
-    step(model) activates the agent and stages any necessary changes, but does
-    not apply them yet. advance(model) then applies the changes.
+    step() activates the agent and stages any necessary changes, but does not
+    apply them yet. advance() then applies the changes.
 
     """
     def step(self):
         """ Step all agents, then advance them. """
         for agent in self.agents:
-            agent.step(self.model)
+            agent.step()
         for agent in self.agents:
-            agent.advance(self.model)
+            agent.advance()
         self.steps += 1
         self.time += 1
 
@@ -167,7 +165,7 @@ def step(self):
             random.shuffle(self.agents)
         for stage in self.stage_list:
             for agent in self.agents:
-                getattr(agent, stage)(self.model)  # Run stage
+                getattr(agent, stage)()  # Run stage
             if self.shuffle_between_stages:
                 random.shuffle(self.agents)
             self.time += self.stage_time

tests/test_batchrunner.py

@@ -18,7 +18,7 @@ def __init__(self, unique_id, val):
         self.unique_id = unique_id
         self.val = val
 
-    def step(self, model):
+    def step(self):
         """
         increment val by 1
         """

tests/test_datacollector.py

@@ -12,22 +12,22 @@ class MockAgent(Agent):
     '''
     Minimalistic agent for testing purposes.
     '''
-    def __init__(self, unique_id, val):
-        self.unique_id = unique_id
+    def __init__(self, unique_id, model, val=0):
+        super().__init__(unique_id, model)
         self.val = val
 
-    def step(self, model):
+    def step(self):
         '''
         Increment val by 1.
         '''
         self.val += 1
 
-    def write_final_values(self, model):
+    def write_final_values(self):
         '''
         Write the final value to the appropriate table.
         '''
         row = {"agent_id": self.unique_id, "final_value": self.val}
-        model.datacollector.add_table_row("Final_Values", row)
+        self.model.datacollector.add_table_row("Final_Values", row)
 
 
 class MockModel(Model):
@@ -40,7 +40,7 @@ class MockModel(Model):
     def __init__(self):
         self.schedule = BaseScheduler(self)
         for i in range(10):
-            a = MockAgent(i, i)
+            a = MockAgent(i, self, val=i)
             self.schedule.add(a)
         self.datacollector = DataCollector(
             {"total_agents": lambda m: m.schedule.get_agent_count()},
@@ -62,7 +62,7 @@ def setUp(self):
             self.model.step()
         # Write to table:
         for agent in self.model.schedule.agents:
-            agent.write_final_values(self.model)
+            agent.write_final_values()
 
     def test_model_vars(self):
         '''

tests/test_time.py

@@ -18,16 +18,13 @@ class MockAgent(Agent):
     Minimalistic agent for testing purposes.
     '''
 
-    def __init__(self, name):
-        self.unique_id = name
+    def stage_one(self):
+        self.model.log.append(self.unique_id + "_1")
 
-    def stage_one(self, model):
-        model.log.append(self.unique_id + "_1")
+    def stage_two(self):
+        self.model.log.append(self.unique_id + "_2")
 
-    def stage_two(self, model):
-        model.log.append(self.unique_id + "_2")
-
-    def advance(self, model):
+    def advance(self):
         pass
 
 
@@ -64,7 +61,7 @@ def __init__(self, shuffle=False, activation=STAGED):
 
         # Make agents
         for name in ["A", "B"]:
-            agent = MockAgent(name)
+            agent = MockAgent(name, self)
             self.schedule.add(agent)
 
     def step(self):